LCOV - code coverage report
Current view: directory - media/libvpx/vpx_scale/generic - gen_scalers.c (source / functions) Found Hit Coverage
Test: app.info Lines: 296 0 0.0 %
Date: 2012-06-02 Functions: 22 0 0.0 %

       1                 : /*
       2                 :  *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
       3                 :  *
       4                 :  *  Use of this source code is governed by a BSD-style license
       5                 :  *  that can be found in the LICENSE file in the root of the source
       6                 :  *  tree. An additional intellectual property rights grant can be found
       7                 :  *  in the file PATENTS.  All contributing project authors may
       8                 :  *  be found in the AUTHORS file in the root of the source tree.
       9                 :  */
      10                 : 
      11                 : 
      12                 : #include "vpx_scale/vpxscale.h"
      13                 : #include "vpx_mem/vpx_mem.h"
      14                 : /****************************************************************************
      15                 : *  Imports
      16                 : ****************************************************************************/
      17                 : 
      18                 : /****************************************************************************
      19                 :  *
      20                 :  *  ROUTINE       : vp8cx_horizontal_line_4_5_scale_c
      21                 :  *
      22                 :  *  INPUTS        : const unsigned char *source : Pointer to source data.
      23                 :  *                  unsigned int source_width    : Stride of source.
      24                 :  *                  unsigned char *dest         : Pointer to destination data.
      25                 :  *                  unsigned int dest_width      : Stride of destination (NOT USED).
      26                 :  *
      27                 :  *  OUTPUTS       : None.
      28                 :  *
      29                 :  *  RETURNS       : void
      30                 :  *
      31                 :  *  FUNCTION      : Copies horizontal line of pixels from source to
      32                 :  *                  destination scaling up by 4 to 5.
      33                 :  *
      34                 :  *  SPECIAL NOTES : None.
      35                 :  *
      36                 :  ****************************************************************************/
      37               0 : void vp8cx_horizontal_line_4_5_scale_c
      38                 : (
      39                 :     const unsigned char *source,
      40                 :     unsigned int source_width,
      41                 :     unsigned char *dest,
      42                 :     unsigned int dest_width
      43                 : )
      44                 : {
      45                 :     unsigned i;
      46                 :     unsigned int a, b, c;
      47               0 :     unsigned char *des = dest;
      48               0 :     const unsigned char *src = source;
      49                 : 
      50                 :     (void) dest_width;
      51                 : 
      52               0 :     for (i = 0; i < source_width - 4; i += 4)
      53                 :     {
      54               0 :         a = src[0];
      55               0 :         b = src[1];
      56               0 :         des [0] = (unsigned char) a;
      57               0 :         des [1] = (unsigned char)((a * 51 + 205 * b + 128) >> 8);
      58               0 :         c = src[2] * 154;
      59               0 :         a = src[3];
      60               0 :         des [2] = (unsigned char)((b * 102 + c + 128) >> 8);
      61               0 :         des [3] = (unsigned char)((c + 102 * a + 128) >> 8);
      62               0 :         b = src[4];
      63               0 :         des [4] = (unsigned char)((a * 205 + 51 * b + 128) >> 8);
      64                 : 
      65               0 :         src += 4;
      66               0 :         des += 5;
      67                 :     }
      68                 : 
      69               0 :     a = src[0];
      70               0 :     b = src[1];
      71               0 :     des [0] = (unsigned char)(a);
      72               0 :     des [1] = (unsigned char)((a * 51 + 205 * b + 128) >> 8);
      73               0 :     c = src[2] * 154;
      74               0 :     a = src[3];
      75               0 :     des [2] = (unsigned char)((b * 102 + c + 128) >> 8);
      76               0 :     des [3] = (unsigned char)((c + 102 * a + 128) >> 8);
      77               0 :     des [4] = (unsigned char)(a);
      78                 : 
      79               0 : }
      80                 : 
      81                 : /****************************************************************************
      82                 :  *
      83                 :  *  ROUTINE       : vp8cx_vertical_band_4_5_scale_c
      84                 :  *
      85                 :  *  INPUTS        : unsigned char *dest    : Pointer to destination data.
      86                 :  *                  unsigned int dest_pitch : Stride of destination data.
      87                 :  *                  unsigned int dest_width : Width of destination data.
      88                 :  *
      89                 :  *  OUTPUTS       : None.
      90                 :  *
      91                 :  *  RETURNS       : void
      92                 :  *
      93                 :  *  FUNCTION      : Scales vertical band of pixels by scale 4 to 5. The
      94                 :  *                  height of the band scaled is 4-pixels.
      95                 :  *
      96                 :  *  SPECIAL NOTES : The routine uses the first line of the band below
      97                 :  *                  the current band.
      98                 :  *
      99                 :  ****************************************************************************/
     100               0 : void vp8cx_vertical_band_4_5_scale_c(unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width)
     101                 : {
     102                 :     unsigned int i;
     103                 :     unsigned int a, b, c, d;
     104               0 :     unsigned char *des = dest;
     105                 : 
     106               0 :     for (i = 0; i < dest_width; i++)
     107                 :     {
     108               0 :         a = des [0];
     109               0 :         b = des [dest_pitch];
     110                 : 
     111               0 :         des[dest_pitch] = (unsigned char)((a * 51 + 205 * b + 128) >> 8);
     112                 : 
     113               0 :         c = des[dest_pitch*2] * 154;
     114               0 :         d = des[dest_pitch*3];
     115                 : 
     116               0 :         des [dest_pitch*2] = (unsigned char)((b * 102 + c + 128) >> 8);
     117               0 :         des [dest_pitch*3] = (unsigned char)((c + 102 * d + 128) >> 8);
     118                 : 
     119                 :         /* First line in next band */
     120               0 :         a = des [dest_pitch * 5];
     121               0 :         des [dest_pitch * 4] = (unsigned char)((d * 205 + 51 * a + 128) >> 8);
     122                 : 
     123               0 :         des ++;
     124                 :     }
     125               0 : }
     126                 : 
     127                 : /****************************************************************************
     128                 :  *
     129                 :  *  ROUTINE       : vp8cx_last_vertical_band_4_5_scale_c
     130                 :  *
     131                 :  *  INPUTS        : unsigned char *dest    : Pointer to destination data.
     132                 :  *                  unsigned int dest_pitch : Stride of destination data.
     133                 :  *                  unsigned int dest_width : Width of destination data.
     134                 :  *
     135                 :  *  OUTPUTS       : None.
     136                 :  *
     137                 :  *  RETURNS       : void
     138                 :  *
     139                 :  *  FUNCTION      : Scales last vertical band of pixels by scale 4 to 5. The
     140                 :  *                  height of the band scaled is 4-pixels.
     141                 :  *
     142                 :  *  SPECIAL NOTES : The routine does not have available the first line of
     143                 :  *                  the band below the current band, since this is the
     144                 :  *                  last band.
     145                 :  *
     146                 :  ****************************************************************************/
     147               0 : void vp8cx_last_vertical_band_4_5_scale_c(unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width)
     148                 : {
     149                 :     unsigned int i;
     150                 :     unsigned int a, b, c, d;
     151               0 :     unsigned char *des = dest;
     152                 : 
     153               0 :     for (i = 0; i < dest_width; ++i)
     154                 :     {
     155               0 :         a = des[0];
     156               0 :         b = des[dest_pitch];
     157                 : 
     158               0 :         des[dest_pitch] = (unsigned char)((a * 51 + 205 * b + 128) >> 8);
     159                 : 
     160               0 :         c = des[dest_pitch*2] * 154;
     161               0 :         d = des[dest_pitch*3];
     162                 : 
     163               0 :         des [dest_pitch*2] = (unsigned char)((b * 102 + c + 128) >> 8);
     164               0 :         des [dest_pitch*3] = (unsigned char)((c + 102 * d + 128) >> 8);
     165                 : 
     166                 :         /* No other line for interplation of this line, so .. */
     167               0 :         des[dest_pitch*4] = (unsigned char) d;
     168                 : 
     169               0 :         des++;
     170                 :     }
     171               0 : }
     172                 : 
     173                 : /****************************************************************************
     174                 :  *
     175                 :  *  ROUTINE       : vp8cx_horizontal_line_2_3_scale_c
     176                 :  *
     177                 :  *  INPUTS        : const unsigned char *source : Pointer to source data.
     178                 :  *                  unsigned int source_width    : Stride of source.
     179                 :  *                  unsigned char *dest         : Pointer to destination data.
     180                 :  *                  unsigned int dest_width      : Stride of destination (NOT USED).
     181                 :  *
     182                 :  *  OUTPUTS       : None.
     183                 :  *
     184                 :  *  RETURNS       : void
     185                 :  *
     186                 :  *  FUNCTION      : Copies horizontal line of pixels from source to
     187                 :  *                  destination scaling up by 2 to 3.
     188                 :  *
     189                 :  *  SPECIAL NOTES : None.
     190                 :  *
     191                 :  *
     192                 :  ****************************************************************************/
     193               0 : void vp8cx_horizontal_line_2_3_scale_c
     194                 : (
     195                 :     const unsigned char *source,
     196                 :     unsigned int source_width,
     197                 :     unsigned char *dest,
     198                 :     unsigned int dest_width
     199                 : )
     200                 : {
     201                 :     unsigned int i;
     202                 :     unsigned int a, b, c;
     203               0 :     unsigned char *des = dest;
     204               0 :     const unsigned char *src = source;
     205                 : 
     206                 :     (void) dest_width;
     207                 : 
     208               0 :     for (i = 0; i < source_width - 2; i += 2)
     209                 :     {
     210               0 :         a = src[0];
     211               0 :         b = src[1];
     212               0 :         c = src[2];
     213                 : 
     214               0 :         des [0] = (unsigned char)(a);
     215               0 :         des [1] = (unsigned char)((a * 85 + 171 * b + 128) >> 8);
     216               0 :         des [2] = (unsigned char)((b * 171 + 85 * c + 128) >> 8);
     217                 : 
     218               0 :         src += 2;
     219               0 :         des += 3;
     220                 :     }
     221                 : 
     222               0 :     a = src[0];
     223               0 :     b = src[1];
     224               0 :     des [0] = (unsigned char)(a);
     225               0 :     des [1] = (unsigned char)((a * 85 + 171 * b + 128) >> 8);
     226               0 :     des [2] = (unsigned char)(b);
     227               0 : }
     228                 : 
     229                 : 
     230                 : /****************************************************************************
     231                 :  *
     232                 :  *  ROUTINE       : vp8cx_vertical_band_2_3_scale_c
     233                 :  *
     234                 :  *  INPUTS        : unsigned char *dest    : Pointer to destination data.
     235                 :  *                  unsigned int dest_pitch : Stride of destination data.
     236                 :  *                  unsigned int dest_width : Width of destination data.
     237                 :  *
     238                 :  *  OUTPUTS       : None.
     239                 :  *
     240                 :  *  RETURNS       : void
     241                 :  *
     242                 :  *  FUNCTION      : Scales vertical band of pixels by scale 2 to 3. The
     243                 :  *                  height of the band scaled is 2-pixels.
     244                 :  *
     245                 :  *  SPECIAL NOTES : The routine uses the first line of the band below
     246                 :  *                  the current band.
     247                 :  *
     248                 :  ****************************************************************************/
     249               0 : void vp8cx_vertical_band_2_3_scale_c(unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width)
     250                 : {
     251                 :     unsigned int i;
     252                 :     unsigned int a, b, c;
     253               0 :     unsigned char *des = dest;
     254                 : 
     255               0 :     for (i = 0; i < dest_width; i++)
     256                 :     {
     257               0 :         a = des [0];
     258               0 :         b = des [dest_pitch];
     259               0 :         c = des[dest_pitch*3];
     260               0 :         des [dest_pitch  ] = (unsigned char)((a * 85 + 171 * b + 128) >> 8);
     261               0 :         des [dest_pitch*2] = (unsigned char)((b * 171 + 85 * c + 128) >> 8);
     262                 : 
     263               0 :         des++;
     264                 :     }
     265               0 : }
     266                 : 
     267                 : /****************************************************************************
     268                 :  *
     269                 :  *  ROUTINE       : vp8cx_last_vertical_band_2_3_scale_c
     270                 :  *
     271                 :  *  INPUTS        : unsigned char *dest    : Pointer to destination data.
     272                 :  *                  unsigned int dest_pitch : Stride of destination data.
     273                 :  *                  unsigned int dest_width : Width of destination data.
     274                 :  *
     275                 :  *  OUTPUTS       : None.
     276                 :  *
     277                 :  *  RETURNS       : void
     278                 :  *
     279                 :  *  FUNCTION      : Scales last vertical band of pixels by scale 2 to 3. The
     280                 :  *                  height of the band scaled is 2-pixels.
     281                 :  *
     282                 :  *  SPECIAL NOTES : The routine does not have available the first line of
     283                 :  *                  the band below the current band, since this is the
     284                 :  *                  last band.
     285                 :  *
     286                 :  ****************************************************************************/
     287               0 : void vp8cx_last_vertical_band_2_3_scale_c(unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width)
     288                 : {
     289                 :     unsigned int i;
     290                 :     unsigned int a, b;
     291               0 :     unsigned char *des = dest;
     292                 : 
     293               0 :     for (i = 0; i < dest_width; ++i)
     294                 :     {
     295               0 :         a = des [0];
     296               0 :         b = des [dest_pitch];
     297                 : 
     298               0 :         des [dest_pitch  ] = (unsigned char)((a * 85 + 171 * b + 128) >> 8);
     299               0 :         des [dest_pitch*2] = (unsigned char)(b);
     300               0 :         des++;
     301                 :     }
     302               0 : }
     303                 : 
     304                 : /****************************************************************************
     305                 :  *
     306                 :  *  ROUTINE       : vp8cx_horizontal_line_3_5_scale_c
     307                 :  *
     308                 :  *  INPUTS        : const unsigned char *source : Pointer to source data.
     309                 :  *                  unsigned int source_width    : Stride of source.
     310                 :  *                  unsigned char *dest         : Pointer to destination data.
     311                 :  *                  unsigned int dest_width      : Stride of destination (NOT USED).
     312                 :  *
     313                 :  *  OUTPUTS       : None.
     314                 :  *
     315                 :  *  RETURNS       : void
     316                 :  *
     317                 :  *  FUNCTION      : Copies horizontal line of pixels from source to
     318                 :  *                  destination scaling up by 3 to 5.
     319                 :  *
     320                 :  *  SPECIAL NOTES : None.
     321                 :  *
     322                 :  *
     323                 :  ****************************************************************************/
     324               0 : void vp8cx_horizontal_line_3_5_scale_c
     325                 : (
     326                 :     const unsigned char *source,
     327                 :     unsigned int source_width,
     328                 :     unsigned char *dest,
     329                 :     unsigned int dest_width
     330                 : )
     331                 : {
     332                 :     unsigned int i;
     333                 :     unsigned int a, b, c;
     334               0 :     unsigned char *des = dest;
     335               0 :     const unsigned char *src = source;
     336                 : 
     337                 :     (void) dest_width;
     338                 : 
     339               0 :     for (i = 0; i < source_width - 3; i += 3)
     340                 :     {
     341               0 :         a = src[0];
     342               0 :         b = src[1];
     343               0 :         des [0] = (unsigned char)(a);
     344               0 :         des [1] = (unsigned char)((a * 102 + 154 * b + 128) >> 8);
     345                 : 
     346               0 :         c = src[2] ;
     347               0 :         des [2] = (unsigned char)((b * 205 + c * 51 + 128) >> 8);
     348               0 :         des [3] = (unsigned char)((b * 51 + c * 205 + 128) >> 8);
     349                 : 
     350               0 :         a = src[3];
     351               0 :         des [4] = (unsigned char)((c * 154 + a * 102 + 128) >> 8);
     352                 : 
     353               0 :         src += 3;
     354               0 :         des += 5;
     355                 :     }
     356                 : 
     357               0 :     a = src[0];
     358               0 :     b = src[1];
     359               0 :     des [0] = (unsigned char)(a);
     360                 : 
     361               0 :     des [1] = (unsigned char)((a * 102 + 154 * b + 128) >> 8);
     362               0 :     c = src[2] ;
     363               0 :     des [2] = (unsigned char)((b * 205 + c * 51 + 128) >> 8);
     364               0 :     des [3] = (unsigned char)((b * 51 + c * 205 + 128) >> 8);
     365                 : 
     366               0 :     des [4] = (unsigned char)(c);
     367               0 : }
     368                 : 
     369                 : /****************************************************************************
     370                 :  *
     371                 :  *  ROUTINE       : vp8cx_vertical_band_3_5_scale_c
     372                 :  *
     373                 :  *  INPUTS        : unsigned char *dest    : Pointer to destination data.
     374                 :  *                  unsigned int dest_pitch : Stride of destination data.
     375                 :  *                  unsigned int dest_width : Width of destination data.
     376                 :  *
     377                 :  *  OUTPUTS       : None.
     378                 :  *
     379                 :  *  RETURNS       : void
     380                 :  *
     381                 :  *  FUNCTION      : Scales vertical band of pixels by scale 3 to 5. The
     382                 :  *                  height of the band scaled is 3-pixels.
     383                 :  *
     384                 :  *  SPECIAL NOTES : The routine uses the first line of the band below
     385                 :  *                  the current band.
     386                 :  *
     387                 :  ****************************************************************************/
     388               0 : void vp8cx_vertical_band_3_5_scale_c(unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width)
     389                 : {
     390                 :     unsigned int i;
     391                 :     unsigned int a, b, c;
     392               0 :     unsigned char *des = dest;
     393                 : 
     394               0 :     for (i = 0; i < dest_width; i++)
     395                 :     {
     396               0 :         a = des [0];
     397               0 :         b = des [dest_pitch];
     398               0 :         des [dest_pitch] = (unsigned char)((a * 102 + 154 * b + 128) >> 8);
     399                 : 
     400               0 :         c = des[dest_pitch*2];
     401               0 :         des [dest_pitch*2] = (unsigned char)((b * 205 + c * 51 + 128) >> 8);
     402               0 :         des [dest_pitch*3] = (unsigned char)((b * 51 + c * 205 + 128) >> 8);
     403                 : 
     404                 :         /* First line in next band... */
     405               0 :         a = des [dest_pitch * 5];
     406               0 :         des [dest_pitch * 4] = (unsigned char)((c * 154 + a * 102 + 128) >> 8);
     407                 : 
     408               0 :         des++;
     409                 :     }
     410               0 : }
     411                 : 
     412                 : /****************************************************************************
     413                 :  *
     414                 :  *  ROUTINE       : vp8cx_last_vertical_band_3_5_scale_c
     415                 :  *
     416                 :  *  INPUTS        : unsigned char *dest    : Pointer to destination data.
     417                 :  *                  unsigned int dest_pitch : Stride of destination data.
     418                 :  *                  unsigned int dest_width : Width of destination data.
     419                 :  *
     420                 :  *  OUTPUTS       : None.
     421                 :  *
     422                 :  *  RETURNS       : void
     423                 :  *
     424                 :  *  FUNCTION      : Scales last vertical band of pixels by scale 3 to 5. The
     425                 :  *                  height of the band scaled is 3-pixels.
     426                 :  *
     427                 :  *  SPECIAL NOTES : The routine does not have available the first line of
     428                 :  *                  the band below the current band, since this is the
     429                 :  *                  last band.
     430                 :  *
     431                 :  ****************************************************************************/
     432               0 : void vp8cx_last_vertical_band_3_5_scale_c(unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width)
     433                 : {
     434                 :     unsigned int i;
     435                 :     unsigned int a, b, c;
     436               0 :     unsigned char *des = dest;
     437                 : 
     438               0 :     for (i = 0; i < dest_width; ++i)
     439                 :     {
     440               0 :         a = des [0];
     441               0 :         b = des [dest_pitch];
     442                 : 
     443               0 :         des [ dest_pitch ] = (unsigned char)((a * 102 + 154 * b + 128) >> 8);
     444                 : 
     445               0 :         c = des[dest_pitch*2];
     446               0 :         des [dest_pitch*2] = (unsigned char)((b * 205 + c * 51 + 128) >> 8);
     447               0 :         des [dest_pitch*3] = (unsigned char)((b * 51 + c * 205 + 128) >> 8);
     448                 : 
     449                 :         /* No other line for interplation of this line, so .. */
     450               0 :         des [ dest_pitch * 4 ] = (unsigned char)(c) ;
     451                 : 
     452               0 :         des++;
     453                 :     }
     454               0 : }
     455                 : 
     456                 : /****************************************************************************
     457                 :  *
     458                 :  *  ROUTINE       : vp8cx_horizontal_line_3_4_scale_c
     459                 :  *
     460                 :  *  INPUTS        : const unsigned char *source : Pointer to source data.
     461                 :  *                  unsigned int source_width    : Stride of source.
     462                 :  *                  unsigned char *dest         : Pointer to destination data.
     463                 :  *                  unsigned int dest_width      : Stride of destination (NOT USED).
     464                 :  *
     465                 :  *  OUTPUTS       : None.
     466                 :  *
     467                 :  *  RETURNS       : void
     468                 :  *
     469                 :  *  FUNCTION      : Copies horizontal line of pixels from source to
     470                 :  *                  destination scaling up by 3 to 4.
     471                 :  *
     472                 :  *  SPECIAL NOTES : None.
     473                 :  *
     474                 :  *
     475                 :  ****************************************************************************/
     476               0 : void vp8cx_horizontal_line_3_4_scale_c
     477                 : (
     478                 :     const unsigned char *source,
     479                 :     unsigned int source_width,
     480                 :     unsigned char *dest,
     481                 :     unsigned int dest_width
     482                 : )
     483                 : {
     484                 :     unsigned int i;
     485                 :     unsigned int a, b, c;
     486               0 :     unsigned char *des = dest;
     487               0 :     const unsigned char *src = source;
     488                 : 
     489                 :     (void) dest_width;
     490                 : 
     491               0 :     for (i = 0; i < source_width - 3; i += 3)
     492                 :     {
     493               0 :         a = src[0];
     494               0 :         b = src[1];
     495               0 :         des [0] = (unsigned char)(a);
     496               0 :         des [1] = (unsigned char)((a * 64 + b * 192 + 128) >> 8);
     497                 : 
     498               0 :         c = src[2];
     499               0 :         des [2] = (unsigned char)((b + c + 1) >> 1);
     500                 : 
     501               0 :         a = src[3];
     502               0 :         des [3] = (unsigned char)((c * 192 + a * 64 + 128) >> 8);
     503                 : 
     504               0 :         src += 3;
     505               0 :         des += 4;
     506                 :     }
     507                 : 
     508               0 :     a = src[0];
     509               0 :     b = src[1];
     510               0 :     des [0] = (unsigned char)(a);
     511               0 :     des [1] = (unsigned char)((a * 64 + b * 192 + 128) >> 8);
     512                 : 
     513               0 :     c = src[2] ;
     514               0 :     des [2] = (unsigned char)((b + c + 1) >> 1);
     515               0 :     des [3] = (unsigned char)(c);
     516               0 : }
     517                 : 
     518                 : /****************************************************************************
     519                 :  *
     520                 :  *  ROUTINE       : vp8cx_vertical_band_3_4_scale_c
     521                 :  *
     522                 :  *  INPUTS        : unsigned char *dest    : Pointer to destination data.
     523                 :  *                  unsigned int dest_pitch : Stride of destination data.
     524                 :  *                  unsigned int dest_width : Width of destination data.
     525                 :  *
     526                 :  *  OUTPUTS       : None.
     527                 :  *
     528                 :  *  RETURNS       : void
     529                 :  *
     530                 :  *  FUNCTION      : Scales vertical band of pixels by scale 3 to 4. The
     531                 :  *                  height of the band scaled is 3-pixels.
     532                 :  *
     533                 :  *  SPECIAL NOTES : The routine uses the first line of the band below
     534                 :  *                  the current band.
     535                 :  *
     536                 :  ****************************************************************************/
     537               0 : void vp8cx_vertical_band_3_4_scale_c(unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width)
     538                 : {
     539                 :     unsigned int i;
     540                 :     unsigned int a, b, c;
     541               0 :     unsigned char *des = dest;
     542                 : 
     543               0 :     for (i = 0; i < dest_width; i++)
     544                 :     {
     545               0 :         a = des [0];
     546               0 :         b = des [dest_pitch];
     547               0 :         des [dest_pitch]   = (unsigned char)((a * 64 + b * 192 + 128) >> 8);
     548                 : 
     549               0 :         c = des[dest_pitch*2];
     550               0 :         des [dest_pitch*2] = (unsigned char)((b + c + 1) >> 1);
     551                 : 
     552                 :         /* First line in next band... */
     553               0 :         a = des [dest_pitch*4];
     554               0 :         des [dest_pitch*3] = (unsigned char)((c * 192 + a * 64 + 128) >> 8);
     555                 : 
     556               0 :         des++;
     557                 :     }
     558               0 : }
     559                 : 
     560                 : /****************************************************************************
     561                 :  *
     562                 :  *  ROUTINE       : vp8cx_last_vertical_band_3_4_scale_c
     563                 :  *
     564                 :  *  INPUTS        : unsigned char *dest    : Pointer to destination data.
     565                 :  *                  unsigned int dest_pitch : Stride of destination data.
     566                 :  *                  unsigned int dest_width : Width of destination data.
     567                 :  *
     568                 :  *  OUTPUTS       : None.
     569                 :  *
     570                 :  *  RETURNS       : void
     571                 :  *
     572                 :  *  FUNCTION      : Scales last vertical band of pixels by scale 3 to 4. The
     573                 :  *                  height of the band scaled is 3-pixels.
     574                 :  *
     575                 :  *  SPECIAL NOTES : The routine does not have available the first line of
     576                 :  *                  the band below the current band, since this is the
     577                 :  *                  last band.
     578                 :  *
     579                 :  ****************************************************************************/
     580               0 : void vp8cx_last_vertical_band_3_4_scale_c(unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width)
     581                 : {
     582                 :     unsigned int i;
     583                 :     unsigned int a, b, c;
     584               0 :     unsigned char *des = dest;
     585                 : 
     586               0 :     for (i = 0; i < dest_width; ++i)
     587                 :     {
     588               0 :         a = des [0];
     589               0 :         b = des [dest_pitch];
     590                 : 
     591               0 :         des [dest_pitch]   = (unsigned char)((a * 64 + b * 192 + 128) >> 8);
     592                 : 
     593               0 :         c = des[dest_pitch*2];
     594               0 :         des [dest_pitch*2] = (unsigned char)((b + c + 1) >> 1);
     595                 : 
     596                 :         /* No other line for interplation of this line, so .. */
     597               0 :         des [dest_pitch*3] = (unsigned char)(c);
     598                 : 
     599               0 :         des++;
     600                 :     }
     601               0 : }
     602                 : 
     603                 : /****************************************************************************
     604                 :  *
     605                 :  *  ROUTINE       : vp8cx_horizontal_line_1_2_scale_c
     606                 :  *
     607                 :  *  INPUTS        : const unsigned char *source : Pointer to source data.
     608                 :  *                  unsigned int source_width    : Stride of source.
     609                 :  *                  unsigned char *dest         : Pointer to destination data.
     610                 :  *                  unsigned int dest_width      : Stride of destination (NOT USED).
     611                 :  *
     612                 :  *  OUTPUTS       : None.
     613                 :  *
     614                 :  *  RETURNS       : void
     615                 :  *
     616                 :  *  FUNCTION      : Copies horizontal line of pixels from source to
     617                 :  *                  destination scaling up by 1 to 2.
     618                 :  *
     619                 :  *  SPECIAL NOTES : None.
     620                 :  *
     621                 :  ****************************************************************************/
     622               0 : void vp8cx_horizontal_line_1_2_scale_c
     623                 : (
     624                 :     const unsigned char *source,
     625                 :     unsigned int source_width,
     626                 :     unsigned char *dest,
     627                 :     unsigned int dest_width
     628                 : )
     629                 : {
     630                 :     unsigned int i;
     631                 :     unsigned int a, b;
     632               0 :     unsigned char *des = dest;
     633               0 :     const unsigned char *src = source;
     634                 : 
     635                 :     (void) dest_width;
     636                 : 
     637               0 :     for (i = 0; i < source_width - 1; i += 1)
     638                 :     {
     639               0 :         a = src[0];
     640               0 :         b = src[1];
     641               0 :         des [0] = (unsigned char)(a);
     642               0 :         des [1] = (unsigned char)((a + b + 1) >> 1);
     643               0 :         src += 1;
     644               0 :         des += 2;
     645                 :     }
     646                 : 
     647               0 :     a = src[0];
     648               0 :     des [0] = (unsigned char)(a);
     649               0 :     des [1] = (unsigned char)(a);
     650               0 : }
     651                 : 
     652                 : /****************************************************************************
     653                 :  *
     654                 :  *  ROUTINE       : vp8cx_vertical_band_1_2_scale_c
     655                 :  *
     656                 :  *  INPUTS        : unsigned char *dest    : Pointer to destination data.
     657                 :  *                  unsigned int dest_pitch : Stride of destination data.
     658                 :  *                  unsigned int dest_width : Width of destination data.
     659                 :  *
     660                 :  *  OUTPUTS       : None.
     661                 :  *
     662                 :  *  RETURNS       : void
     663                 :  *
     664                 :  *  FUNCTION      : Scales vertical band of pixels by scale 1 to 2. The
     665                 :  *                  height of the band scaled is 1-pixel.
     666                 :  *
     667                 :  *  SPECIAL NOTES : The routine uses the first line of the band below
     668                 :  *                  the current band.
     669                 :  *
     670                 :  ****************************************************************************/
     671               0 : void vp8cx_vertical_band_1_2_scale_c(unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width)
     672                 : {
     673                 :     unsigned int i;
     674                 :     unsigned int a, b;
     675               0 :     unsigned char *des = dest;
     676                 : 
     677               0 :     for (i = 0; i < dest_width; i++)
     678                 :     {
     679               0 :         a = des [0];
     680               0 :         b = des [dest_pitch * 2];
     681                 : 
     682               0 :         des[dest_pitch] = (unsigned char)((a + b + 1) >> 1);
     683                 : 
     684               0 :         des++;
     685                 :     }
     686               0 : }
     687                 : 
     688                 : /****************************************************************************
     689                 :  *
     690                 :  *  ROUTINE       : vp8cx_last_vertical_band_1_2_scale_c
     691                 :  *
     692                 :  *  INPUTS        : unsigned char *dest    : Pointer to destination data.
     693                 :  *                  unsigned int dest_pitch : Stride of destination data.
     694                 :  *                  unsigned int dest_width : Width of destination data.
     695                 :  *
     696                 :  *  OUTPUTS       : None.
     697                 :  *
     698                 :  *  RETURNS       : void
     699                 :  *
     700                 :  *  FUNCTION      : Scales last vertical band of pixels by scale 1 to 2. The
     701                 :  *                  height of the band scaled is 1-pixel.
     702                 :  *
     703                 :  *  SPECIAL NOTES : The routine does not have available the first line of
     704                 :  *                  the band below the current band, since this is the
     705                 :  *                  last band.
     706                 :  *
     707                 :  ****************************************************************************/
     708               0 : void vp8cx_last_vertical_band_1_2_scale_c(unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width)
     709                 : {
     710                 :     unsigned int i;
     711               0 :     unsigned char *des = dest;
     712                 : 
     713               0 :     for (i = 0; i < dest_width; ++i)
     714                 :     {
     715               0 :         des[dest_pitch] = des[0];
     716               0 :         des++;
     717                 :     }
     718               0 : }
     719                 : 
     720                 : 
     721                 : 
     722                 : 
     723                 : 
     724                 : /****************************************************************************
     725                 :  *
     726                 :  *  ROUTINE       : vp8cx_horizontal_line_4_5_scale_c
     727                 :  *
     728                 :  *  INPUTS        : const unsigned char *source : Pointer to source data.
     729                 :  *                  unsigned int source_width    : Stride of source.
     730                 :  *                  unsigned char *dest         : Pointer to destination data.
     731                 :  *                  unsigned int dest_width      : Stride of destination (NOT USED).
     732                 :  *
     733                 :  *  OUTPUTS       : None.
     734                 :  *
     735                 :  *  RETURNS       : void
     736                 :  *
     737                 :  *  FUNCTION      : Copies horizontal line of pixels from source to
     738                 :  *                  destination scaling up by 4 to 5.
     739                 :  *
     740                 :  *  SPECIAL NOTES : None.
     741                 :  *
     742                 :  ****************************************************************************/
     743               0 : void vp8cx_horizontal_line_5_4_scale_c
     744                 : (
     745                 :     const unsigned char *source,
     746                 :     unsigned int source_width,
     747                 :     unsigned char *dest,
     748                 :     unsigned int dest_width
     749                 : )
     750                 : {
     751                 :     unsigned i;
     752                 :     unsigned int a, b, c, d, e;
     753               0 :     unsigned char *des = dest;
     754               0 :     const unsigned char *src = source;
     755                 : 
     756                 :     (void) dest_width;
     757                 : 
     758               0 :     for (i = 0; i < source_width; i += 5)
     759                 :     {
     760               0 :         a = src[0];
     761               0 :         b = src[1];
     762               0 :         c = src[2];
     763               0 :         d = src[3];
     764               0 :         e = src[4];
     765                 : 
     766               0 :         des[0] = (unsigned char) a;
     767               0 :         des[1] = (unsigned char)((b * 192 + c * 64 + 128) >> 8);
     768               0 :         des[2] = (unsigned char)((c * 128 + d * 128 + 128) >> 8);
     769               0 :         des[3] = (unsigned char)((d * 64 + e * 192 + 128) >> 8);
     770                 : 
     771               0 :         src += 5;
     772               0 :         des += 4;
     773                 :     }
     774               0 : }
     775                 : 
     776                 : 
     777                 : 
     778                 : 
     779               0 : void vp8cx_vertical_band_5_4_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width)
     780                 : {
     781                 :     unsigned int i;
     782                 :     unsigned int a, b, c, d, e;
     783               0 :     unsigned char *des = dest;
     784               0 :     unsigned char *src = source;
     785                 : 
     786               0 :     for (i = 0; i < dest_width; i++)
     787                 :     {
     788                 : 
     789               0 :         a = src[0 * src_pitch];
     790               0 :         b = src[1 * src_pitch];
     791               0 :         c = src[2 * src_pitch];
     792               0 :         d = src[3 * src_pitch];
     793               0 :         e = src[4 * src_pitch];
     794                 : 
     795               0 :         des[0 * dest_pitch] = (unsigned char) a;
     796               0 :         des[1 * dest_pitch] = (unsigned char)((b * 192 + c * 64 + 128) >> 8);
     797               0 :         des[2 * dest_pitch] = (unsigned char)((c * 128 + d * 128 + 128) >> 8);
     798               0 :         des[3 * dest_pitch] = (unsigned char)((d * 64 + e * 192 + 128) >> 8);
     799                 : 
     800               0 :         src ++;
     801               0 :         des ++;
     802                 : 
     803                 :     }
     804               0 : }
     805                 : 
     806                 : 
     807                 : /*7***************************************************************************
     808                 :  *
     809                 :  *  ROUTINE       : vp8cx_horizontal_line_3_5_scale_c
     810                 :  *
     811                 :  *  INPUTS        : const unsigned char *source : Pointer to source data.
     812                 :  *                  unsigned int source_width    : Stride of source.
     813                 :  *                  unsigned char *dest         : Pointer to destination data.
     814                 :  *                  unsigned int dest_width      : Stride of destination (NOT USED).
     815                 :  *
     816                 :  *  OUTPUTS       : None.
     817                 :  *
     818                 :  *  RETURNS       : void
     819                 :  *
     820                 :  *  FUNCTION      : Copies horizontal line of pixels from source to
     821                 :  *                  destination scaling up by 3 to 5.
     822                 :  *
     823                 :  *  SPECIAL NOTES : None.
     824                 :  *
     825                 :  *
     826                 :  ****************************************************************************/
     827               0 : void vp8cx_horizontal_line_5_3_scale_c
     828                 : (
     829                 :     const unsigned char *source,
     830                 :     unsigned int source_width,
     831                 :     unsigned char *dest,
     832                 :     unsigned int dest_width
     833                 : )
     834                 : {
     835                 :     unsigned int i;
     836                 :     unsigned int a, b, c, d , e;
     837               0 :     unsigned char *des = dest;
     838               0 :     const unsigned char *src = source;
     839                 : 
     840                 :     (void) dest_width;
     841                 : 
     842               0 :     for (i = 0; i < source_width; i += 5)
     843                 :     {
     844               0 :         a = src[0];
     845               0 :         b = src[1];
     846               0 :         c = src[2];
     847               0 :         d = src[3];
     848               0 :         e = src[4];
     849                 : 
     850               0 :         des[0] = (unsigned char) a;
     851               0 :         des[1] = (unsigned char)((b * 85  + c * 171 + 128) >> 8);
     852               0 :         des[2] = (unsigned char)((d * 171 + e * 85 + 128) >> 8);
     853                 : 
     854               0 :         src += 5;
     855               0 :         des += 3;
     856                 :     }
     857                 : 
     858               0 : }
     859                 : 
     860               0 : void vp8cx_vertical_band_5_3_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width)
     861                 : {
     862                 :     unsigned int i;
     863                 :     unsigned int a, b, c, d, e;
     864               0 :     unsigned char *des = dest;
     865               0 :     unsigned char *src = source;
     866                 : 
     867               0 :     for (i = 0; i < dest_width; i++)
     868                 :     {
     869                 : 
     870               0 :         a = src[0 * src_pitch];
     871               0 :         b = src[1 * src_pitch];
     872               0 :         c = src[2 * src_pitch];
     873               0 :         d = src[3 * src_pitch];
     874               0 :         e = src[4 * src_pitch];
     875                 : 
     876               0 :         des[0 * dest_pitch] = (unsigned char) a;
     877               0 :         des[1 * dest_pitch] = (unsigned char)((b * 85 + c * 171 + 128) >> 8);
     878               0 :         des[2 * dest_pitch] = (unsigned char)((d * 171 + e * 85 + 128) >> 8);
     879                 : 
     880               0 :         src ++;
     881               0 :         des ++;
     882                 : 
     883                 :     }
     884               0 : }
     885                 : 
     886                 : /****************************************************************************
     887                 :  *
     888                 :  *  ROUTINE       : vp8cx_horizontal_line_1_2_scale_c
     889                 :  *
     890                 :  *  INPUTS        : const unsigned char *source : Pointer to source data.
     891                 :  *                  unsigned int source_width    : Stride of source.
     892                 :  *                  unsigned char *dest         : Pointer to destination data.
     893                 :  *                  unsigned int dest_width      : Stride of destination (NOT USED).
     894                 :  *
     895                 :  *  OUTPUTS       : None.
     896                 :  *
     897                 :  *  RETURNS       : void
     898                 :  *
     899                 :  *  FUNCTION      : Copies horizontal line of pixels from source to
     900                 :  *                  destination scaling up by 1 to 2.
     901                 :  *
     902                 :  *  SPECIAL NOTES : None.
     903                 :  *
     904                 :  ****************************************************************************/
     905               0 : void vp8cx_horizontal_line_2_1_scale_c
     906                 : (
     907                 :     const unsigned char *source,
     908                 :     unsigned int source_width,
     909                 :     unsigned char *dest,
     910                 :     unsigned int dest_width
     911                 : )
     912                 : {
     913                 :     unsigned int i;
     914                 :     unsigned int a;
     915               0 :     unsigned char *des = dest;
     916               0 :     const unsigned char *src = source;
     917                 : 
     918                 :     (void) dest_width;
     919                 : 
     920               0 :     for (i = 0; i < source_width; i += 2)
     921                 :     {
     922               0 :         a = src[0];
     923               0 :         des [0] = (unsigned char)(a);
     924               0 :         src += 2;
     925               0 :         des += 1;
     926                 :     }
     927                 : 
     928                 : 
     929                 : 
     930               0 : }
     931               0 : void vp8cx_vertical_band_2_1_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width)
     932                 : {
     933                 :     (void) dest_pitch;
     934                 :     (void) src_pitch;
     935               0 :     vpx_memcpy(dest, source, dest_width);
     936               0 : }
     937                 : 
     938               0 : void vp8cx_vertical_band_2_1_scale_i_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width)
     939                 : {
     940                 :     int i;
     941                 :     int temp;
     942               0 :     int width = dest_width;
     943                 : 
     944                 :     (void) dest_pitch;
     945                 : 
     946               0 :     for (i = 0; i < width; i++)
     947                 :     {
     948               0 :         temp = 8;
     949               0 :         temp += source[i-(int)src_pitch] * 3;
     950               0 :         temp += source[i] * 10;
     951               0 :         temp += source[i+src_pitch] * 3;
     952               0 :         temp >>= 4 ;
     953               0 :         dest[i] = (unsigned char)(temp);
     954                 :     }
     955                 : 
     956               0 : }

Generated by: LCOV version 1.7