vpx_scale/generic/gen_scalers.c

   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 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     unsigned char *des = dest;
  48     const unsigned char *src = source;
  49
  50     (void) dest_width;
  51
  52     for (i = 0; i < source_width - 4; i += 4)
  53     {
  54         a = src[0];
  55         b = src[1];
  56         des [0] = (unsigned char) a;
  57         des [1] = (unsigned char)((a * 51 + 205 * b + 128) >> 8);
  58         c = src[2] * 154;
  59         a = src[3];
  60         des [2] = (unsigned char)((b * 102 + c + 128) >> 8);
  61         des [3] = (unsigned char)((c + 102 * a + 128) >> 8);
  62         b = src[4];
  63         des [4] = (unsigned char)((a * 205 + 51 * b + 128) >> 8);
  64
  65         src += 4;
  66         des += 5;
  67     }
  68
  69     a = src[0];
  70     b = src[1];
  71     des [0] = (unsigned char)(a);
  72     des [1] = (unsigned char)((a * 51 + 205 * b + 128) >> 8);
  73     c = src[2] * 154;
  74     a = src[3];
  75     des [2] = (unsigned char)((b * 102 + c + 128) >> 8);
  76     des [3] = (unsigned char)((c + 102 * a + 128) >> 8);
  77     des [4] = (unsigned char)(a);
  78
  79 }
  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 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     unsigned char *des = dest;
 105
 106     for (i = 0; i < dest_width; i++)
 107     {
 108         a = des [0];
 109         b = des [dest_pitch];
 110
 111         des[dest_pitch] = (unsigned char)((a * 51 + 205 * b + 128) >> 8);
 112
 113         c = des[dest_pitch*2] * 154;
 114         d = des[dest_pitch*3];
 115
 116         des [dest_pitch*2] = (unsigned char)((b * 102 + c + 128) >> 8);
 117         des [dest_pitch*3] = (unsigned char)((c + 102 * d + 128) >> 8);
 118
 119         /* First line in next band */
 120         a = des [dest_pitch * 5];
 121         des [dest_pitch * 4] = (unsigned char)((d * 205 + 51 * a + 128) >> 8);
 122
 123         des ++;
 124     }
 125 }
 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 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     unsigned char *des = dest;
 152
 153     for (i = 0; i < dest_width; ++i)
 154     {
 155         a = des[0];
 156         b = des[dest_pitch];
 157
 158         des[dest_pitch] = (unsigned char)((a * 51 + 205 * b + 128) >> 8);
 159
 160         c = des[dest_pitch*2] * 154;
 161         d = des[dest_pitch*3];
 162
 163         des [dest_pitch*2] = (unsigned char)((b * 102 + c + 128) >> 8);
 164         des [dest_pitch*3] = (unsigned char)((c + 102 * d + 128) >> 8);
 165
 166         /* No other line for interplation of this line, so .. */
 167         des[dest_pitch*4] = (unsigned char) d;
 168
 169         des++;
 170     }
 171 }
 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 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     unsigned char *des = dest;
 204     const unsigned char *src = source;
 205
 206     (void) dest_width;
 207
 208     for (i = 0; i < source_width - 2; i += 2)
 209     {
 210         a = src[0];
 211         b = src[1];
 212         c = src[2];
 213
 214         des [0] = (unsigned char)(a);
 215         des [1] = (unsigned char)((a * 85 + 171 * b + 128) >> 8);
 216         des [2] = (unsigned char)((b * 171 + 85 * c + 128) >> 8);
 217
 218         src += 2;
 219         des += 3;
 220     }
 221
 222     a = src[0];
 223     b = src[1];
 224     des [0] = (unsigned char)(a);
 225     des [1] = (unsigned char)((a * 85 + 171 * b + 128) >> 8);
 226     des [2] = (unsigned char)(b);
 227 }
 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 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     unsigned char *des = dest;
 254
 255     for (i = 0; i < dest_width; i++)
 256     {
 257         a = des [0];
 258         b = des [dest_pitch];
 259         c = des[dest_pitch*3];
 260         des [dest_pitch  ] = (unsigned char)((a * 85 + 171 * b + 128) >> 8);
 261         des [dest_pitch*2] = (unsigned char)((b * 171 + 85 * c + 128) >> 8);
 262
 263         des++;
 264     }
 265 }
 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 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     unsigned char *des = dest;
 292
 293     for (i = 0; i < dest_width; ++i)
 294     {
 295         a = des [0];
 296         b = des [dest_pitch];
 297
 298         des [dest_pitch  ] = (unsigned char)((a * 85 + 171 * b + 128) >> 8);
 299         des [dest_pitch*2] = (unsigned char)(b);
 300         des++;
 301     }
 302 }
 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 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     unsigned char *des = dest;
 335     const unsigned char *src = source;
 336
 337     (void) dest_width;
 338
 339     for (i = 0; i < source_width - 3; i += 3)
 340     {
 341         a = src[0];
 342         b = src[1];
 343         des [0] = (unsigned char)(a);
 344         des [1] = (unsigned char)((a * 102 + 154 * b + 128) >> 8);
 345
 346         c = src[2] ;
 347         des [2] = (unsigned char)((b * 205 + c * 51 + 128) >> 8);
 348         des [3] = (unsigned char)((b * 51 + c * 205 + 128) >> 8);
 349
 350         a = src[3];
 351         des [4] = (unsigned char)((c * 154 + a * 102 + 128) >> 8);
 352
 353         src += 3;
 354         des += 5;
 355     }
 356
 357     a = src[0];
 358     b = src[1];
 359     des [0] = (unsigned char)(a);
 360
 361     des [1] = (unsigned char)((a * 102 + 154 * b + 128) >> 8);
 362     c = src[2] ;
 363     des [2] = (unsigned char)((b * 205 + c * 51 + 128) >> 8);
 364     des [3] = (unsigned char)((b * 51 + c * 205 + 128) >> 8);
 365
 366     des [4] = (unsigned char)(c);
 367 }
 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 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     unsigned char *des = dest;
 393
 394     for (i = 0; i < dest_width; i++)
 395     {
 396         a = des [0];
 397         b = des [dest_pitch];
 398         des [dest_pitch] = (unsigned char)((a * 102 + 154 * b + 128) >> 8);
 399
 400         c = des[dest_pitch*2];
 401         des [dest_pitch*2] = (unsigned char)((b * 205 + c * 51 + 128) >> 8);
 402         des [dest_pitch*3] = (unsigned char)((b * 51 + c * 205 + 128) >> 8);
 403
 404         /* First line in next band... */
 405         a = des [dest_pitch * 5];
 406         des [dest_pitch * 4] = (unsigned char)((c * 154 + a * 102 + 128) >> 8);
 407
 408         des++;
 409     }
 410 }
 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 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     unsigned char *des = dest;
 437
 438     for (i = 0; i < dest_width; ++i)
 439     {
 440         a = des [0];
 441         b = des [dest_pitch];
 442
 443         des [ dest_pitch ] = (unsigned char)((a * 102 + 154 * b + 128) >> 8);
 444
 445         c = des[dest_pitch*2];
 446         des [dest_pitch*2] = (unsigned char)((b * 205 + c * 51 + 128) >> 8);
 447         des [dest_pitch*3] = (unsigned char)((b * 51 + c * 205 + 128) >> 8);
 448
 449         /* No other line for interplation of this line, so .. */
 450         des [ dest_pitch * 4 ] = (unsigned char)(c) ;
 451
 452         des++;
 453     }
 454 }
 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 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     unsigned char *des = dest;
 487     const unsigned char *src = source;
 488
 489     (void) dest_width;
 490
 491     for (i = 0; i < source_width - 3; i += 3)
 492     {
 493         a = src[0];
 494         b = src[1];
 495         des [0] = (unsigned char)(a);
 496         des [1] = (unsigned char)((a * 64 + b * 192 + 128) >> 8);
 497
 498         c = src[2];
 499         des [2] = (unsigned char)((b + c + 1) >> 1);
 500
 501         a = src[3];
 502         des [3] = (unsigned char)((c * 192 + a * 64 + 128) >> 8);
 503
 504         src += 3;
 505         des += 4;
 506     }
 507
 508     a = src[0];
 509     b = src[1];
 510     des [0] = (unsigned char)(a);
 511     des [1] = (unsigned char)((a * 64 + b * 192 + 128) >> 8);
 512
 513     c = src[2] ;
 514     des [2] = (unsigned char)((b + c + 1) >> 1);
 515     des [3] = (unsigned char)(c);
 516 }
 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 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     unsigned char *des = dest;
 542
 543     for (i = 0; i < dest_width; i++)
 544     {
 545         a = des [0];
 546         b = des [dest_pitch];
 547         des [dest_pitch]   = (unsigned char)((a * 64 + b * 192 + 128) >> 8);
 548
 549         c = des[dest_pitch*2];
 550         des [dest_pitch*2] = (unsigned char)((b + c + 1) >> 1);
 551
 552         /* First line in next band... */
 553         a = des [dest_pitch*4];
 554         des [dest_pitch*3] = (unsigned char)((c * 192 + a * 64 + 128) >> 8);
 555
 556         des++;
 557     }
 558 }
 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 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     unsigned char *des = dest;
 585
 586     for (i = 0; i < dest_width; ++i)
 587     {
 588         a = des [0];
 589         b = des [dest_pitch];
 590
 591         des [dest_pitch]   = (unsigned char)((a * 64 + b * 192 + 128) >> 8);
 592
 593         c = des[dest_pitch*2];
 594         des [dest_pitch*2] = (unsigned char)((b + c + 1) >> 1);
 595
 596         /* No other line for interplation of this line, so .. */
 597         des [dest_pitch*3] = (unsigned char)(c);
 598
 599         des++;
 600     }
 601 }
 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 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     unsigned char *des = dest;
 633     const unsigned char *src = source;
 634
 635     (void) dest_width;
 636
 637     for (i = 0; i < source_width - 1; i += 1)
 638     {
 639         a = src[0];
 640         b = src[1];
 641         des [0] = (unsigned char)(a);
 642         des [1] = (unsigned char)((a + b + 1) >> 1);
 643         src += 1;
 644         des += 2;
 645     }
 646
 647     a = src[0];
 648     des [0] = (unsigned char)(a);
 649     des [1] = (unsigned char)(a);
 650 }
 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 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     unsigned char *des = dest;
 676
 677     for (i = 0; i < dest_width; i++)
 678     {
 679         a = des [0];
 680         b = des [dest_pitch * 2];
 681
 682         des[dest_pitch] = (unsigned char)((a + b + 1) >> 1);
 683
 684         des++;
 685     }
 686 }
 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 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     unsigned char *des = dest;
 712
 713     for (i = 0; i < dest_width; ++i)
 714     {
 715         des[dest_pitch] = des[0];
 716         des++;
 717     }
 718 }
 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 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     unsigned char *des = dest;
 754     const unsigned char *src = source;
 755
 756     (void) dest_width;
 757
 758     for (i = 0; i < source_width; i += 5)
 759     {
 760         a = src[0];
 761         b = src[1];
 762         c = src[2];
 763         d = src[3];
 764         e = src[4];
 765
 766         des[0] = (unsigned char) a;
 767         des[1] = (unsigned char)((b * 192 + c * 64 + 128) >> 8);
 768         des[2] = (unsigned char)((c * 128 + d * 128 + 128) >> 8);
 769         des[3] = (unsigned char)((d * 64 + e * 192 + 128) >> 8);
 770
 771         src += 5;
 772         des += 4;
 773     }
 774 }
 775
 776
 777
 778
 779 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     unsigned char *des = dest;
 784     unsigned char *src = source;
 785
 786     for (i = 0; i < dest_width; i++)
 787     {
 788
 789         a = src[0 * src_pitch];
 790         b = src[1 * src_pitch];
 791         c = src[2 * src_pitch];
 792         d = src[3 * src_pitch];
 793         e = src[4 * src_pitch];
 794
 795         des[0 * dest_pitch] = (unsigned char) a;
 796         des[1 * dest_pitch] = (unsigned char)((b * 192 + c * 64 + 128) >> 8);
 797         des[2 * dest_pitch] = (unsigned char)((c * 128 + d * 128 + 128) >> 8);
 798         des[3 * dest_pitch] = (unsigned char)((d * 64 + e * 192 + 128) >> 8);
 799
 800         src ++;
 801         des ++;
 802
 803     }
 804 }
 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 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     unsigned char *des = dest;
 838     const unsigned char *src = source;
 839
 840     (void) dest_width;
 841
 842     for (i = 0; i < source_width; i += 5)
 843     {
 844         a = src[0];
 845         b = src[1];
 846         c = src[2];
 847         d = src[3];
 848         e = src[4];
 849
 850         des[0] = (unsigned char) a;
 851         des[1] = (unsigned char)((b * 85  + c * 171 + 128) >> 8);
 852         des[2] = (unsigned char)((d * 171 + e * 85 + 128) >> 8);
 853
 854         src += 5;
 855         des += 3;
 856     }
 857
 858 }
 859
 860 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     unsigned char *des = dest;
 865     unsigned char *src = source;
 866
 867     for (i = 0; i < dest_width; i++)
 868     {
 869
 870         a = src[0 * src_pitch];
 871         b = src[1 * src_pitch];
 872         c = src[2 * src_pitch];
 873         d = src[3 * src_pitch];
 874         e = src[4 * src_pitch];
 875
 876         des[0 * dest_pitch] = (unsigned char) a;
 877         des[1 * dest_pitch] = (unsigned char)((b * 85 + c * 171 + 128) >> 8);
 878         des[2 * dest_pitch] = (unsigned char)((d * 171 + e * 85 + 128) >> 8);
 879
 880         src ++;
 881         des ++;
 882
 883     }
 884 }
 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 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     unsigned char *des = dest;
 916     const unsigned char *src = source;
 917
 918     (void) dest_width;
 919
 920     for (i = 0; i < source_width; i += 2)
 921     {
 922         a = src[0];
 923         des [0] = (unsigned char)(a);
 924         src += 2;
 925         des += 1;
 926     }
 927
 928
 929
 930 }
 931 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     vpx_memcpy(dest, source, dest_width);
 936 }
 937
 938 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     int width = dest_width;
 943
 944     (void) dest_pitch;
 945
 946     for (i = 0; i < width; i++)
 947     {
 948         temp = 8;
 949         temp += source[i-(int)src_pitch] * 3;
 950         temp += source[i] * 10;
 951         temp += source[i+src_pitch] * 3;
 952         temp >>= 4 ;
 953         dest[i] = (unsigned char)(temp);
 954     }
 955
 956 }