vp8/common/filter_c.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 <stdlib.h>
  13
  14 #define BLOCK_HEIGHT_WIDTH 4
  15 #define VP8_FILTER_WEIGHT 128
  16 #define VP8_FILTER_SHIFT  7
  17
  18
  19 static const int bilinear_filters[8][2] =
  20 {
  21     { 128,   0 },
  22     { 112,  16 },
  23     {  96,  32 },
  24     {  80,  48 },
  25     {  64,  64 },
  26     {  48,  80 },
  27     {  32,  96 },
  28     {  16, 112 }
  29 };
  30
  31
  32 static const short sub_pel_filters[8][6] =
  33 {
  34
  35     { 0,  0,  128,    0,   0,  0 },         /* note that 1/8 pel positions are just as per alpha -0.5 bicubic */
  36     { 0, -6,  123,   12,  -1,  0 },
  37     { 2, -11, 108,   36,  -8,  1 },         /* New 1/4 pel 6 tap filter */
  38     { 0, -9,   93,   50,  -6,  0 },
  39     { 3, -16,  77,   77, -16,  3 },         /* New 1/2 pel 6 tap filter */
  40     { 0, -6,   50,   93,  -9,  0 },
  41     { 1, -8,   36,  108, -11,  2 },         /* New 1/4 pel 6 tap filter */
  42     { 0, -1,   12,  123,  -6,  0 },
  43
  44
  45
  46 };
  47
  48 void vp8_filter_block2d_first_pass
  49 (
  50     unsigned char *src_ptr,
  51     int *output_ptr,
  52     unsigned int src_pixels_per_line,
  53     unsigned int pixel_step,
  54     unsigned int output_height,
  55     unsigned int output_width,
  56     const short *vp8_filter
  57 )
  58 {
  59     unsigned int i, j;
  60     int  Temp;
  61
  62     for (i = 0; i < output_height; i++)
  63     {
  64         for (j = 0; j < output_width; j++)
  65         {
  66             Temp = ((int)src_ptr[-2 * (int)pixel_step] * vp8_filter[0]) +
  67                    ((int)src_ptr[-1 * (int)pixel_step] * vp8_filter[1]) +
  68                    ((int)src_ptr[0]                 * vp8_filter[2]) +
  69                    ((int)src_ptr[pixel_step]         * vp8_filter[3]) +
  70                    ((int)src_ptr[2*pixel_step]       * vp8_filter[4]) +
  71                    ((int)src_ptr[3*pixel_step]       * vp8_filter[5]) +
  72                    (VP8_FILTER_WEIGHT >> 1);      /* Rounding */
  73
  74             /* Normalize back to 0-255 */
  75             Temp = Temp >> VP8_FILTER_SHIFT;
  76
  77             if (Temp < 0)
  78                 Temp = 0;
  79             else if (Temp > 255)
  80                 Temp = 255;
  81
  82             output_ptr[j] = Temp;
  83             src_ptr++;
  84         }
  85
  86         /* Next row... */
  87         src_ptr    += src_pixels_per_line - output_width;
  88         output_ptr += output_width;
  89     }
  90 }
  91
  92 void vp8_filter_block2d_second_pass
  93 (
  94     int *src_ptr,
  95     unsigned char *output_ptr,
  96     int output_pitch,
  97     unsigned int src_pixels_per_line,
  98     unsigned int pixel_step,
  99     unsigned int output_height,
 100     unsigned int output_width,
 101     const short *vp8_filter
 102 )
 103 {
 104     unsigned int i, j;
 105     int  Temp;
 106
 107     for (i = 0; i < output_height; i++)
 108     {
 109         for (j = 0; j < output_width; j++)
 110         {
 111             /* Apply filter */
 112             Temp = ((int)src_ptr[-2 * (int)pixel_step] * vp8_filter[0]) +
 113                    ((int)src_ptr[-1 * (int)pixel_step] * vp8_filter[1]) +
 114                    ((int)src_ptr[0]                 * vp8_filter[2]) +
 115                    ((int)src_ptr[pixel_step]         * vp8_filter[3]) +
 116                    ((int)src_ptr[2*pixel_step]       * vp8_filter[4]) +
 117                    ((int)src_ptr[3*pixel_step]       * vp8_filter[5]) +
 118                    (VP8_FILTER_WEIGHT >> 1);   /* Rounding */
 119
 120             /* Normalize back to 0-255 */
 121             Temp = Temp >> VP8_FILTER_SHIFT;
 122
 123             if (Temp < 0)
 124                 Temp = 0;
 125             else if (Temp > 255)
 126                 Temp = 255;
 127
 128             output_ptr[j] = (unsigned char)Temp;
 129             src_ptr++;
 130         }
 131
 132         /* Start next row */
 133         src_ptr    += src_pixels_per_line - output_width;
 134         output_ptr += output_pitch;
 135     }
 136 }
 137
 138
 139 void vp8_filter_block2d
 140 (
 141     unsigned char  *src_ptr,
 142     unsigned char  *output_ptr,
 143     unsigned int src_pixels_per_line,
 144     int output_pitch,
 145     const short  *HFilter,
 146     const short  *VFilter
 147 )
 148 {
 149     int FData[9*4]; /* Temp data bufffer used in filtering */
 150
 151     /* First filter 1-D horizontally... */
 152     vp8_filter_block2d_first_pass(src_ptr - (2 * src_pixels_per_line), FData, src_pixels_per_line, 1, 9, 4, HFilter);
 153
 154     /* then filter verticaly... */
 155     vp8_filter_block2d_second_pass(FData + 8, output_ptr, output_pitch, 4, 4, 4, 4, VFilter);
 156 }
 157
 158
 159 void vp8_block_variation_c
 160 (
 161     unsigned char  *src_ptr,
 162     int   src_pixels_per_line,
 163     int *HVar,
 164     int *VVar
 165 )
 166 {
 167     int i, j;
 168     unsigned char *Ptr = src_ptr;
 169
 170     for (i = 0; i < 4; i++)
 171     {
 172         for (j = 0; j < 4; j++)
 173         {
 174             *HVar += abs((int)Ptr[j] - (int)Ptr[j+1]);
 175             *VVar += abs((int)Ptr[j] - (int)Ptr[j+src_pixels_per_line]);
 176         }
 177
 178         Ptr += src_pixels_per_line;
 179     }
 180 }
 181
 182
 183
 184
 185 void vp8_sixtap_predict_c
 186 (
 187     unsigned char  *src_ptr,
 188     int   src_pixels_per_line,
 189     int  xoffset,
 190     int  yoffset,
 191     unsigned char *dst_ptr,
 192     int dst_pitch
 193 )
 194 {
 195     const short  *HFilter;
 196     const short  *VFilter;
 197
 198     HFilter = sub_pel_filters[xoffset];   /* 6 tap */
 199     VFilter = sub_pel_filters[yoffset];   /* 6 tap */
 200
 201     vp8_filter_block2d(src_ptr, dst_ptr, src_pixels_per_line, dst_pitch, HFilter, VFilter);
 202 }
 203 void vp8_sixtap_predict8x8_c
 204 (
 205     unsigned char  *src_ptr,
 206     int  src_pixels_per_line,
 207     int  xoffset,
 208     int  yoffset,
 209     unsigned char *dst_ptr,
 210     int  dst_pitch
 211 )
 212 {
 213     const short  *HFilter;
 214     const short  *VFilter;
 215     int FData[13*16];   /* Temp data bufffer used in filtering */
 216
 217     HFilter = sub_pel_filters[xoffset];   /* 6 tap */
 218     VFilter = sub_pel_filters[yoffset];   /* 6 tap */
 219
 220     /* First filter 1-D horizontally... */
 221     vp8_filter_block2d_first_pass(src_ptr - (2 * src_pixels_per_line), FData, src_pixels_per_line, 1, 13, 8, HFilter);
 222
 223
 224     /* then filter verticaly... */
 225     vp8_filter_block2d_second_pass(FData + 16, dst_ptr, dst_pitch, 8, 8, 8, 8, VFilter);
 226
 227 }
 228
 229 void vp8_sixtap_predict8x4_c
 230 (
 231     unsigned char  *src_ptr,
 232     int  src_pixels_per_line,
 233     int  xoffset,
 234     int  yoffset,
 235     unsigned char *dst_ptr,
 236     int  dst_pitch
 237 )
 238 {
 239     const short  *HFilter;
 240     const short  *VFilter;
 241     int FData[13*16];   /* Temp data bufffer used in filtering */
 242
 243     HFilter = sub_pel_filters[xoffset];   /* 6 tap */
 244     VFilter = sub_pel_filters[yoffset];   /* 6 tap */
 245
 246     /* First filter 1-D horizontally... */
 247     vp8_filter_block2d_first_pass(src_ptr - (2 * src_pixels_per_line), FData, src_pixels_per_line, 1, 9, 8, HFilter);
 248
 249
 250     /* then filter verticaly... */
 251     vp8_filter_block2d_second_pass(FData + 16, dst_ptr, dst_pitch, 8, 8, 4, 8, VFilter);
 252
 253 }
 254
 255 void vp8_sixtap_predict16x16_c
 256 (
 257     unsigned char  *src_ptr,
 258     int  src_pixels_per_line,
 259     int  xoffset,
 260     int  yoffset,
 261     unsigned char *dst_ptr,
 262     int  dst_pitch
 263 )
 264 {
 265     const short  *HFilter;
 266     const short  *VFilter;
 267     int FData[21*24];   /* Temp data bufffer used in filtering */
 268
 269
 270     HFilter = sub_pel_filters[xoffset];   /* 6 tap */
 271     VFilter = sub_pel_filters[yoffset];   /* 6 tap */
 272
 273     /* First filter 1-D horizontally... */
 274     vp8_filter_block2d_first_pass(src_ptr - (2 * src_pixels_per_line), FData, src_pixels_per_line, 1, 21, 16, HFilter);
 275
 276     /* then filter verticaly... */
 277     vp8_filter_block2d_second_pass(FData + 32, dst_ptr, dst_pitch, 16, 16, 16, 16, VFilter);
 278
 279 }
 280
 281
 282 /****************************************************************************
 283  *
 284  *  ROUTINE       : filter_block2d_bil_first_pass
 285  *
 286  *  INPUTS        : UINT8  *src_ptr          : Pointer to source block.
 287  *                  UINT32 src_pixels_per_line : Stride of input block.
 288  *                  UINT32 pixel_step        : Offset between filter input samples (see notes).
 289  *                  UINT32 output_height     : Input block height.
 290  *                  UINT32 output_width      : Input block width.
 291  *                  INT32  *vp8_filter          : Array of 2 bi-linear filter taps.
 292  *
 293  *  OUTPUTS       : INT32 *output_ptr        : Pointer to filtered block.
 294  *
 295  *  RETURNS       : void
 296  *
 297  *  FUNCTION      : Applies a 1-D 2-tap bi-linear filter to the source block in
 298  *                  either horizontal or vertical direction to produce the
 299  *                  filtered output block. Used to implement first-pass
 300  *                  of 2-D separable filter.
 301  *
 302  *  SPECIAL NOTES : Produces INT32 output to retain precision for next pass.
 303  *                  Two filter taps should sum to VP8_FILTER_WEIGHT.
 304  *                  pixel_step defines whether the filter is applied
 305  *                  horizontally (pixel_step=1) or vertically (pixel_step=stride).
 306  *                  It defines the offset required to move from one input
 307  *                  to the next.
 308  *
 309  ****************************************************************************/
 310 void vp8_filter_block2d_bil_first_pass
 311 (
 312     unsigned char *src_ptr,
 313     unsigned short *output_ptr,
 314     unsigned int src_pixels_per_line,
 315     int pixel_step,
 316     unsigned int output_height,
 317     unsigned int output_width,
 318     const int *vp8_filter
 319 )
 320 {
 321     unsigned int i, j;
 322
 323     for (i = 0; i < output_height; i++)
 324     {
 325         for (j = 0; j < output_width; j++)
 326         {
 327             /* Apply bilinear filter */
 328             output_ptr[j] = (((int)src_ptr[0]          * vp8_filter[0]) +
 329                              ((int)src_ptr[pixel_step] * vp8_filter[1]) +
 330                              (VP8_FILTER_WEIGHT / 2)) >> VP8_FILTER_SHIFT;
 331             src_ptr++;
 332         }
 333
 334         /* Next row... */
 335         src_ptr    += src_pixels_per_line - output_width;
 336         output_ptr += output_width;
 337     }
 338 }
 339
 340 /****************************************************************************
 341  *
 342  *  ROUTINE       : filter_block2d_bil_second_pass
 343  *
 344  *  INPUTS        : INT32  *src_ptr          : Pointer to source block.
 345  *                  UINT32 src_pixels_per_line : Stride of input block.
 346  *                  UINT32 pixel_step        : Offset between filter input samples (see notes).
 347  *                  UINT32 output_height     : Input block height.
 348  *                  UINT32 output_width      : Input block width.
 349  *                  INT32  *vp8_filter          : Array of 2 bi-linear filter taps.
 350  *
 351  *  OUTPUTS       : UINT16 *output_ptr       : Pointer to filtered block.
 352  *
 353  *  RETURNS       : void
 354  *
 355  *  FUNCTION      : Applies a 1-D 2-tap bi-linear filter to the source block in
 356  *                  either horizontal or vertical direction to produce the
 357  *                  filtered output block. Used to implement second-pass
 358  *                  of 2-D separable filter.
 359  *
 360  *  SPECIAL NOTES : Requires 32-bit input as produced by filter_block2d_bil_first_pass.
 361  *                  Two filter taps should sum to VP8_FILTER_WEIGHT.
 362  *                  pixel_step defines whether the filter is applied
 363  *                  horizontally (pixel_step=1) or vertically (pixel_step=stride).
 364  *                  It defines the offset required to move from one input
 365  *                  to the next.
 366  *
 367  ****************************************************************************/
 368 void vp8_filter_block2d_bil_second_pass
 369 (
 370     unsigned short *src_ptr,
 371     unsigned char  *output_ptr,
 372     int output_pitch,
 373     unsigned int  src_pixels_per_line,
 374     unsigned int  pixel_step,
 375     unsigned int  output_height,
 376     unsigned int  output_width,
 377     const int *vp8_filter
 378 )
 379 {
 380     unsigned int  i, j;
 381     int  Temp;
 382
 383     for (i = 0; i < output_height; i++)
 384     {
 385         for (j = 0; j < output_width; j++)
 386         {
 387             /* Apply filter */
 388             Temp = ((int)src_ptr[0]         * vp8_filter[0]) +
 389                    ((int)src_ptr[pixel_step] * vp8_filter[1]) +
 390                    (VP8_FILTER_WEIGHT / 2);
 391             output_ptr[j] = (unsigned int)(Temp >> VP8_FILTER_SHIFT);
 392             src_ptr++;
 393         }
 394
 395         /* Next row... */
 396         src_ptr    += src_pixels_per_line - output_width;
 397         output_ptr += output_pitch;
 398     }
 399 }
 400
 401
 402 /****************************************************************************
 403  *
 404  *  ROUTINE       : filter_block2d_bil
 405  *
 406  *  INPUTS        : UINT8  *src_ptr          : Pointer to source block.
 407  *                  UINT32 src_pixels_per_line : Stride of input block.
 408  *                  INT32  *HFilter         : Array of 2 horizontal filter taps.
 409  *                  INT32  *VFilter         : Array of 2 vertical filter taps.
 410  *
 411  *  OUTPUTS       : UINT16 *output_ptr       : Pointer to filtered block.
 412  *
 413  *  RETURNS       : void
 414  *
 415  *  FUNCTION      : 2-D filters an input block by applying a 2-tap
 416  *                  bi-linear filter horizontally followed by a 2-tap
 417  *                  bi-linear filter vertically on the result.
 418  *
 419  *  SPECIAL NOTES : The largest block size can be handled here is 16x16
 420  *
 421  ****************************************************************************/
 422 void vp8_filter_block2d_bil
 423 (
 424     unsigned char *src_ptr,
 425     unsigned char *output_ptr,
 426     unsigned int   src_pixels_per_line,
 427     unsigned int   dst_pitch,
 428     const int      *HFilter,
 429     const int      *VFilter,
 430     int            Width,
 431     int            Height
 432 )
 433 {
 434
 435     unsigned short FData[17*16];    /* Temp data bufffer used in filtering */
 436
 437     /* First filter 1-D horizontally... */
 438     vp8_filter_block2d_bil_first_pass(src_ptr, FData, src_pixels_per_line, 1, Height + 1, Width, HFilter);
 439
 440     /* then 1-D vertically... */
 441     vp8_filter_block2d_bil_second_pass(FData, output_ptr, dst_pitch, Width, Width, Height, Width, VFilter);
 442 }
 443
 444
 445 void vp8_bilinear_predict4x4_c
 446 (
 447     unsigned char  *src_ptr,
 448     int   src_pixels_per_line,
 449     int  xoffset,
 450     int  yoffset,
 451     unsigned char *dst_ptr,
 452     int dst_pitch
 453 )
 454 {
 455     const int  *HFilter;
 456     const int  *VFilter;
 457
 458     HFilter = bilinear_filters[xoffset];
 459     VFilter = bilinear_filters[yoffset];
 460 #if 0
 461     {
 462         int i;
 463         unsigned char temp1[16];
 464         unsigned char temp2[16];
 465
 466         bilinear_predict4x4_mmx(src_ptr, src_pixels_per_line, xoffset, yoffset, temp1, 4);
 467         vp8_filter_block2d_bil(src_ptr, temp2, src_pixels_per_line, 4, HFilter, VFilter, 4, 4);
 468
 469         for (i = 0; i < 16; i++)
 470         {
 471             if (temp1[i] != temp2[i])
 472             {
 473                 bilinear_predict4x4_mmx(src_ptr, src_pixels_per_line, xoffset, yoffset, temp1, 4);
 474                 vp8_filter_block2d_bil(src_ptr, temp2, src_pixels_per_line, 4, HFilter, VFilter, 4, 4);
 475             }
 476         }
 477     }
 478 #endif
 479     vp8_filter_block2d_bil(src_ptr, dst_ptr, src_pixels_per_line, dst_pitch, HFilter, VFilter, 4, 4);
 480
 481 }
 482
 483 void vp8_bilinear_predict8x8_c
 484 (
 485     unsigned char  *src_ptr,
 486     int  src_pixels_per_line,
 487     int  xoffset,
 488     int  yoffset,
 489     unsigned char *dst_ptr,
 490     int  dst_pitch
 491 )
 492 {
 493     const int  *HFilter;
 494     const int  *VFilter;
 495
 496     HFilter = bilinear_filters[xoffset];
 497     VFilter = bilinear_filters[yoffset];
 498
 499     vp8_filter_block2d_bil(src_ptr, dst_ptr, src_pixels_per_line, dst_pitch, HFilter, VFilter, 8, 8);
 500
 501 }
 502
 503 void vp8_bilinear_predict8x4_c
 504 (
 505     unsigned char  *src_ptr,
 506     int  src_pixels_per_line,
 507     int  xoffset,
 508     int  yoffset,
 509     unsigned char *dst_ptr,
 510     int  dst_pitch
 511 )
 512 {
 513     const int  *HFilter;
 514     const int  *VFilter;
 515
 516     HFilter = bilinear_filters[xoffset];
 517     VFilter = bilinear_filters[yoffset];
 518
 519     vp8_filter_block2d_bil(src_ptr, dst_ptr, src_pixels_per_line, dst_pitch, HFilter, VFilter, 8, 4);
 520
 521 }
 522
 523 void vp8_bilinear_predict16x16_c
 524 (
 525     unsigned char  *src_ptr,
 526     int  src_pixels_per_line,
 527     int  xoffset,
 528     int  yoffset,
 529     unsigned char *dst_ptr,
 530     int  dst_pitch
 531 )
 532 {
 533     const int  *HFilter;
 534     const int  *VFilter;
 535
 536     HFilter = bilinear_filters[xoffset];
 537     VFilter = bilinear_filters[yoffset];
 538
 539     vp8_filter_block2d_bil(src_ptr, dst_ptr, src_pixels_per_line, dst_pitch, HFilter, VFilter, 16, 16);
 540 }