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 "variance.h" 13 #include "filter.h" 14 15 16 unsigned int vp8_get_mb_ss_c 17 ( 18 const short *src_ptr 19 ) 20 { 21 unsigned int i = 0, sum = 0; 22 23 do 24 { 25 sum += (src_ptr[i] * src_ptr[i]); 26 i++; 27 } 28 while (i < 256); 29 30 return sum; 31 } 32 33 34 static void variance( 35 const unsigned char *src_ptr, 36 int source_stride, 37 const unsigned char *ref_ptr, 38 int recon_stride, 39 int w, 40 int h, 41 unsigned int *sse, 42 int *sum) 43 { 44 int i, j; 45 int diff; 46 47 *sum = 0; 48 *sse = 0; 49 50 for (i = 0; i < h; i++) 51 { 52 for (j = 0; j < w; j++) 53 { 54 diff = src_ptr[j] - ref_ptr[j]; 55 *sum += diff; 56 *sse += diff * diff; 57 } 58 59 src_ptr += source_stride; 60 ref_ptr += recon_stride; 61 } 62 } 63 64 65 unsigned int vp8_variance16x16_c( 66 const unsigned char *src_ptr, 67 int source_stride, 68 const unsigned char *ref_ptr, 69 int recon_stride, 70 unsigned int *sse) 71 { 72 unsigned int var; 73 int avg; 74 75 76 variance(src_ptr, source_stride, ref_ptr, recon_stride, 16, 16, &var, &avg); 77 *sse = var; 78 return (var - (((unsigned int)avg * avg) >> 8)); 79 } 80 81 unsigned int vp8_variance8x16_c( 82 const unsigned char *src_ptr, 83 int source_stride, 84 const unsigned char *ref_ptr, 85 int recon_stride, 86 unsigned int *sse) 87 { 88 unsigned int var; 89 int avg; 90 91 92 variance(src_ptr, source_stride, ref_ptr, recon_stride, 8, 16, &var, &avg); 93 *sse = var; 94 return (var - (((unsigned int)avg * avg) >> 7)); 95 } 96 97 unsigned int vp8_variance16x8_c( 98 const unsigned char *src_ptr, 99 int source_stride, 100 const unsigned char *ref_ptr, 101 int recon_stride, 102 unsigned int *sse) 103 { 104 unsigned int var; 105 int avg; 106 107 108 variance(src_ptr, source_stride, ref_ptr, recon_stride, 16, 8, &var, &avg); 109 *sse = var; 110 return (var - (((unsigned int)avg * avg) >> 7)); 111 } 112 113 114 unsigned int vp8_variance8x8_c( 115 const unsigned char *src_ptr, 116 int source_stride, 117 const unsigned char *ref_ptr, 118 int recon_stride, 119 unsigned int *sse) 120 { 121 unsigned int var; 122 int avg; 123 124 125 variance(src_ptr, source_stride, ref_ptr, recon_stride, 8, 8, &var, &avg); 126 *sse = var; 127 return (var - (((unsigned int)avg * avg) >> 6)); 128 } 129 130 unsigned int vp8_variance4x4_c( 131 const unsigned char *src_ptr, 132 int source_stride, 133 const unsigned char *ref_ptr, 134 int recon_stride, 135 unsigned int *sse) 136 { 137 unsigned int var; 138 int avg; 139 140 141 variance(src_ptr, source_stride, ref_ptr, recon_stride, 4, 4, &var, &avg); 142 *sse = var; 143 return (var - (((unsigned int)avg * avg) >> 4)); 144 } 145 146 147 unsigned int vp8_mse16x16_c( 148 const unsigned char *src_ptr, 149 int source_stride, 150 const unsigned char *ref_ptr, 151 int recon_stride, 152 unsigned int *sse) 153 { 154 unsigned int var; 155 int avg; 156 157 variance(src_ptr, source_stride, ref_ptr, recon_stride, 16, 16, &var, &avg); 158 *sse = var; 159 return var; 160 } 161 162 163 /**************************************************************************** 164 * 165 * ROUTINE : filter_block2d_bil_first_pass 166 * 167 * INPUTS : UINT8 *src_ptr : Pointer to source block. 168 * UINT32 src_pixels_per_line : Stride of input block. 169 * UINT32 pixel_step : Offset between filter input samples (see notes). 170 * UINT32 output_height : Input block height. 171 * UINT32 output_width : Input block width. 172 * INT32 *vp8_filter : Array of 2 bi-linear filter taps. 173 * 174 * OUTPUTS : INT32 *output_ptr : Pointer to filtered block. 175 * 176 * RETURNS : void 177 * 178 * FUNCTION : Applies a 1-D 2-tap bi-linear filter to the source block in 179 * either horizontal or vertical direction to produce the 180 * filtered output block. Used to implement first-pass 181 * of 2-D separable filter. 182 * 183 * SPECIAL NOTES : Produces INT32 output to retain precision for next pass. 184 * Two filter taps should sum to VP8_FILTER_WEIGHT. 185 * pixel_step defines whether the filter is applied 186 * horizontally (pixel_step=1) or vertically (pixel_step=stride). 187 * It defines the offset required to move from one input 188 * to the next. 189 * 190 ****************************************************************************/ 191 static void var_filter_block2d_bil_first_pass 192 ( 193 const unsigned char *src_ptr, 194 unsigned short *output_ptr, 195 unsigned int src_pixels_per_line, 196 int pixel_step, 197 unsigned int output_height, 198 unsigned int output_width, 199 const short *vp8_filter 200 ) 201 { 202 unsigned int i, j; 203 204 for (i = 0; i < output_height; i++) 205 { 206 for (j = 0; j < output_width; j++) 207 { 208 /* Apply bilinear filter */ 209 output_ptr[j] = (((int)src_ptr[0] * vp8_filter[0]) + 210 ((int)src_ptr[pixel_step] * vp8_filter[1]) + 211 (VP8_FILTER_WEIGHT / 2)) >> VP8_FILTER_SHIFT; 212 src_ptr++; 213 } 214 215 /* Next row... */ 216 src_ptr += src_pixels_per_line - output_width; 217 output_ptr += output_width; 218 } 219 } 220 221 /**************************************************************************** 222 * 223 * ROUTINE : filter_block2d_bil_second_pass 224 * 225 * INPUTS : INT32 *src_ptr : Pointer to source block. 226 * UINT32 src_pixels_per_line : Stride of input block. 227 * UINT32 pixel_step : Offset between filter input samples (see notes). 228 * UINT32 output_height : Input block height. 229 * UINT32 output_width : Input block width. 230 * INT32 *vp8_filter : Array of 2 bi-linear filter taps. 231 * 232 * OUTPUTS : UINT16 *output_ptr : Pointer to filtered block. 233 * 234 * RETURNS : void 235 * 236 * FUNCTION : Applies a 1-D 2-tap bi-linear filter to the source block in 237 * either horizontal or vertical direction to produce the 238 * filtered output block. Used to implement second-pass 239 * of 2-D separable filter. 240 * 241 * SPECIAL NOTES : Requires 32-bit input as produced by filter_block2d_bil_first_pass. 242 * Two filter taps should sum to VP8_FILTER_WEIGHT. 243 * pixel_step defines whether the filter is applied 244 * horizontally (pixel_step=1) or vertically (pixel_step=stride). 245 * It defines the offset required to move from one input 246 * to the next. 247 * 248 ****************************************************************************/ 249 static void var_filter_block2d_bil_second_pass 250 ( 251 const unsigned short *src_ptr, 252 unsigned char *output_ptr, 253 unsigned int src_pixels_per_line, 254 unsigned int pixel_step, 255 unsigned int output_height, 256 unsigned int output_width, 257 const short *vp8_filter 258 ) 259 { 260 unsigned int i, j; 261 int Temp; 262 263 for (i = 0; i < output_height; i++) 264 { 265 for (j = 0; j < output_width; j++) 266 { 267 /* Apply filter */ 268 Temp = ((int)src_ptr[0] * vp8_filter[0]) + 269 ((int)src_ptr[pixel_step] * vp8_filter[1]) + 270 (VP8_FILTER_WEIGHT / 2); 271 output_ptr[j] = (unsigned int)(Temp >> VP8_FILTER_SHIFT); 272 src_ptr++; 273 } 274 275 /* Next row... */ 276 src_ptr += src_pixels_per_line - output_width; 277 output_ptr += output_width; 278 } 279 } 280 281 282 unsigned int vp8_sub_pixel_variance4x4_c 283 ( 284 const unsigned char *src_ptr, 285 int src_pixels_per_line, 286 int xoffset, 287 int yoffset, 288 const unsigned char *dst_ptr, 289 int dst_pixels_per_line, 290 unsigned int *sse 291 ) 292 { 293 unsigned char temp2[20*16]; 294 const short *HFilter, *VFilter; 295 unsigned short FData3[5*4]; /* Temp data bufffer used in filtering */ 296 297 HFilter = vp8_bilinear_filters[xoffset]; 298 VFilter = vp8_bilinear_filters[yoffset]; 299 300 /* First filter 1d Horizontal */ 301 var_filter_block2d_bil_first_pass(src_ptr, FData3, src_pixels_per_line, 1, 5, 4, HFilter); 302 303 /* Now filter Verticaly */ 304 var_filter_block2d_bil_second_pass(FData3, temp2, 4, 4, 4, 4, VFilter); 305 306 return vp8_variance4x4_c(temp2, 4, dst_ptr, dst_pixels_per_line, sse); 307 } 308 309 310 unsigned int vp8_sub_pixel_variance8x8_c 311 ( 312 const unsigned char *src_ptr, 313 int src_pixels_per_line, 314 int xoffset, 315 int yoffset, 316 const unsigned char *dst_ptr, 317 int dst_pixels_per_line, 318 unsigned int *sse 319 ) 320 { 321 unsigned short FData3[9*8]; /* Temp data bufffer used in filtering */ 322 unsigned char temp2[20*16]; 323 const short *HFilter, *VFilter; 324 325 HFilter = vp8_bilinear_filters[xoffset]; 326 VFilter = vp8_bilinear_filters[yoffset]; 327 328 var_filter_block2d_bil_first_pass(src_ptr, FData3, src_pixels_per_line, 1, 9, 8, HFilter); 329 var_filter_block2d_bil_second_pass(FData3, temp2, 8, 8, 8, 8, VFilter); 330 331 return vp8_variance8x8_c(temp2, 8, dst_ptr, dst_pixels_per_line, sse); 332 } 333 334 unsigned int vp8_sub_pixel_variance16x16_c 335 ( 336 const unsigned char *src_ptr, 337 int src_pixels_per_line, 338 int xoffset, 339 int yoffset, 340 const unsigned char *dst_ptr, 341 int dst_pixels_per_line, 342 unsigned int *sse 343 ) 344 { 345 unsigned short FData3[17*16]; /* Temp data bufffer used in filtering */ 346 unsigned char temp2[20*16]; 347 const short *HFilter, *VFilter; 348 349 HFilter = vp8_bilinear_filters[xoffset]; 350 VFilter = vp8_bilinear_filters[yoffset]; 351 352 var_filter_block2d_bil_first_pass(src_ptr, FData3, src_pixels_per_line, 1, 17, 16, HFilter); 353 var_filter_block2d_bil_second_pass(FData3, temp2, 16, 16, 16, 16, VFilter); 354 355 return vp8_variance16x16_c(temp2, 16, dst_ptr, dst_pixels_per_line, sse); 356 } 357 358 359 unsigned int vp8_variance_halfpixvar16x16_h_c( 360 const unsigned char *src_ptr, 361 int source_stride, 362 const unsigned char *ref_ptr, 363 int recon_stride, 364 unsigned int *sse) 365 { 366 return vp8_sub_pixel_variance16x16_c(src_ptr, source_stride, 4, 0, 367 ref_ptr, recon_stride, sse); 368 } 369 370 371 unsigned int vp8_variance_halfpixvar16x16_v_c( 372 const unsigned char *src_ptr, 373 int source_stride, 374 const unsigned char *ref_ptr, 375 int recon_stride, 376 unsigned int *sse) 377 { 378 return vp8_sub_pixel_variance16x16_c(src_ptr, source_stride, 0, 4, 379 ref_ptr, recon_stride, sse); 380 } 381 382 383 unsigned int vp8_variance_halfpixvar16x16_hv_c( 384 const unsigned char *src_ptr, 385 int source_stride, 386 const unsigned char *ref_ptr, 387 int recon_stride, 388 unsigned int *sse) 389 { 390 return vp8_sub_pixel_variance16x16_c(src_ptr, source_stride, 4, 4, 391 ref_ptr, recon_stride, sse); 392 } 393 394 395 unsigned int vp8_sub_pixel_mse16x16_c 396 ( 397 const unsigned char *src_ptr, 398 int src_pixels_per_line, 399 int xoffset, 400 int yoffset, 401 const unsigned char *dst_ptr, 402 int dst_pixels_per_line, 403 unsigned int *sse 404 ) 405 { 406 vp8_sub_pixel_variance16x16_c(src_ptr, src_pixels_per_line, xoffset, yoffset, dst_ptr, dst_pixels_per_line, sse); 407 return *sse; 408 } 409 410 unsigned int vp8_sub_pixel_variance16x8_c 411 ( 412 const unsigned char *src_ptr, 413 int src_pixels_per_line, 414 int xoffset, 415 int yoffset, 416 const unsigned char *dst_ptr, 417 int dst_pixels_per_line, 418 unsigned int *sse 419 ) 420 { 421 unsigned short FData3[16*9]; /* Temp data bufffer used in filtering */ 422 unsigned char temp2[20*16]; 423 const short *HFilter, *VFilter; 424 425 HFilter = vp8_bilinear_filters[xoffset]; 426 VFilter = vp8_bilinear_filters[yoffset]; 427 428 var_filter_block2d_bil_first_pass(src_ptr, FData3, src_pixels_per_line, 1, 9, 16, HFilter); 429 var_filter_block2d_bil_second_pass(FData3, temp2, 16, 16, 8, 16, VFilter); 430 431 return vp8_variance16x8_c(temp2, 16, dst_ptr, dst_pixels_per_line, sse); 432 } 433 434 unsigned int vp8_sub_pixel_variance8x16_c 435 ( 436 const unsigned char *src_ptr, 437 int src_pixels_per_line, 438 int xoffset, 439 int yoffset, 440 const unsigned char *dst_ptr, 441 int dst_pixels_per_line, 442 unsigned int *sse 443 ) 444 { 445 unsigned short FData3[9*16]; /* Temp data bufffer used in filtering */ 446 unsigned char temp2[20*16]; 447 const short *HFilter, *VFilter; 448 449 450 HFilter = vp8_bilinear_filters[xoffset]; 451 VFilter = vp8_bilinear_filters[yoffset]; 452 453 454 var_filter_block2d_bil_first_pass(src_ptr, FData3, src_pixels_per_line, 1, 17, 8, HFilter); 455 var_filter_block2d_bil_second_pass(FData3, temp2, 8, 8, 16, 8, VFilter); 456 457 return vp8_variance8x16_c(temp2, 8, dst_ptr, dst_pixels_per_line, sse); 458 } 459
