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 "onyxc_int.h" 13 #include "onyx_int.h" 14 #include "quantize.h" 15 #include "vpx_mem/vpx_mem.h" 16 #include "vpx_scale/yv12extend.h" 17 #include "vpx_scale/vpxscale.h" 18 #include "alloccommon.h" 19 #if ARCH_ARM 20 #include "vpx_ports/arm.h" 21 #endif 22 23 extern void vp8_loop_filter_frame(VP8_COMMON *cm, MACROBLOCKD *mbd, int filt_val); 24 extern void vp8_loop_filter_frame_yonly(VP8_COMMON *cm, MACROBLOCKD *mbd, int filt_val, int sharpness_lvl); 25 extern int vp8_calc_ss_err(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *dest, const vp8_variance_rtcd_vtable_t *rtcd); 26 #if HAVE_ARMV7 27 extern void vp8_yv12_copy_frame_yonly_no_extend_frame_borders_neon(YV12_BUFFER_CONFIG *src_ybc, YV12_BUFFER_CONFIG *dst_ybc); 28 #endif 29 30 #if CONFIG_RUNTIME_CPU_DETECT 31 #define IF_RTCD(x) (x) 32 #else 33 #define IF_RTCD(x) NULL 34 #endif 35 36 extern void 37 (*vp8_yv12_copy_partial_frame_ptr)(YV12_BUFFER_CONFIG *src_ybc, 38 YV12_BUFFER_CONFIG *dst_ybc, 39 int Fraction); 40 void 41 vp8_yv12_copy_partial_frame(YV12_BUFFER_CONFIG *src_ybc, YV12_BUFFER_CONFIG *dst_ybc, int Fraction) 42 { 43 unsigned char *src_y, *dst_y; 44 int yheight; 45 int ystride; 46 int border; 47 int yoffset; 48 int linestocopy; 49 50 border = src_ybc->border; 51 yheight = src_ybc->y_height; 52 ystride = src_ybc->y_stride; 53 54 linestocopy = (yheight >> (Fraction + 4)); 55 56 if (linestocopy < 1) 57 linestocopy = 1; 58 59 linestocopy <<= 4; 60 61 yoffset = ystride * ((yheight >> 5) * 16 - 8); 62 src_y = src_ybc->y_buffer + yoffset; 63 dst_y = dst_ybc->y_buffer + yoffset; 64 65 vpx_memcpy(dst_y, src_y, ystride *(linestocopy + 16)); 66 } 67 68 static int vp8_calc_partial_ssl_err(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *dest, int Fraction, const vp8_variance_rtcd_vtable_t *rtcd) 69 { 70 int i, j; 71 int Total = 0; 72 int srcoffset, dstoffset; 73 unsigned char *src = source->y_buffer; 74 unsigned char *dst = dest->y_buffer; 75 76 int linestocopy = (source->y_height >> (Fraction + 4)); 77 (void)rtcd; 78 79 if (linestocopy < 1) 80 linestocopy = 1; 81 82 linestocopy <<= 4; 83 84 85 srcoffset = source->y_stride * (dest->y_height >> 5) * 16; 86 dstoffset = dest->y_stride * (dest->y_height >> 5) * 16; 87 88 src += srcoffset; 89 dst += dstoffset; 90 91 // Loop through the Y plane raw and reconstruction data summing (square differences) 92 for (i = 0; i < linestocopy; i += 16) 93 { 94 for (j = 0; j < source->y_width; j += 16) 95 { 96 unsigned int sse; 97 Total += VARIANCE_INVOKE(rtcd, mse16x16)(src + j, source->y_stride, dst + j, dest->y_stride, &sse); 98 } 99 100 src += 16 * source->y_stride; 101 dst += 16 * dest->y_stride; 102 } 103 104 return Total; 105 } 106 107 extern void vp8_loop_filter_partial_frame 108 ( 109 VP8_COMMON *cm, 110 MACROBLOCKD *mbd, 111 int default_filt_lvl, 112 int sharpness_lvl, 113 int Fraction 114 ); 115 116 // Enforce a minimum filter level based upon baseline Q 117 static int get_min_filter_level(VP8_COMP *cpi, int base_qindex) 118 { 119 int min_filter_level; 120 121 if (cpi->source_alt_ref_active && cpi->common.refresh_golden_frame && !cpi->common.refresh_alt_ref_frame) 122 min_filter_level = 0; 123 else 124 { 125 if (base_qindex <= 6) 126 min_filter_level = 0; 127 else if (base_qindex <= 16) 128 min_filter_level = 1; 129 else 130 min_filter_level = (base_qindex / 8); 131 } 132 133 return min_filter_level; 134 } 135 136 // Enforce a maximum filter level based upon baseline Q 137 static int get_max_filter_level(VP8_COMP *cpi, int base_qindex) 138 { 139 // PGW August 2006: Highest filter values almost always a bad idea 140 141 // jbb chg: 20100118 - not so any more with this overquant stuff allow high values 142 // with lots of intra coming in. 143 int max_filter_level = MAX_LOOP_FILTER ;//* 3 / 4; 144 145 if (cpi->section_intra_rating > 8) 146 max_filter_level = MAX_LOOP_FILTER * 3 / 4; 147 148 (void) cpi; 149 (void) base_qindex; 150 151 return max_filter_level; 152 } 153 154 void vp8cx_pick_filter_level_fast(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi) 155 { 156 VP8_COMMON *cm = &cpi->common; 157 158 int best_err = 0; 159 int filt_err = 0; 160 int min_filter_level = 0; 161 int max_filter_level = MAX_LOOP_FILTER * 3 / 4; // PGW August 2006: Highest filter values almost always a bad idea 162 int filt_val; 163 int best_filt_val = cm->filter_level; 164 165 // Make a copy of the unfiltered / processed recon buffer 166 //vp8_yv12_copy_frame_ptr( cm->frame_to_show, &cpi->last_frame_uf ); 167 vp8_yv12_copy_partial_frame_ptr(cm->frame_to_show, &cpi->last_frame_uf, 3); 168 169 if (cm->frame_type == KEY_FRAME) 170 cm->sharpness_level = 0; 171 else 172 cm->sharpness_level = cpi->oxcf.Sharpness; 173 174 // Enforce a minimum filter level based upon Q 175 min_filter_level = get_min_filter_level(cpi, cm->base_qindex); 176 max_filter_level = get_max_filter_level(cpi, cm->base_qindex); 177 178 // Start the search at the previous frame filter level unless it is now out of range. 179 if (cm->filter_level < min_filter_level) 180 cm->filter_level = min_filter_level; 181 else if (cm->filter_level > max_filter_level) 182 cm->filter_level = max_filter_level; 183 184 filt_val = cm->filter_level; 185 best_filt_val = filt_val; 186 187 // Set up alternate filter values 188 189 // Get the err using the previous frame's filter value. 190 vp8_loop_filter_partial_frame(cm, &cpi->mb.e_mbd, filt_val, 0 , 3); 191 cm->last_frame_type = cm->frame_type; 192 cm->last_filter_type = cm->filter_type; 193 cm->last_sharpness_level = cm->sharpness_level; 194 195 best_err = vp8_calc_partial_ssl_err(sd, cm->frame_to_show, 3, IF_RTCD(&cpi->rtcd.variance)); 196 197 // Re-instate the unfiltered frame 198 vp8_yv12_copy_partial_frame_ptr(&cpi->last_frame_uf, cm->frame_to_show, 3); 199 200 filt_val -= (1 + ((filt_val > 10) ? 1 : 0)); 201 202 // Search lower filter levels 203 while (filt_val >= min_filter_level) 204 { 205 // Apply the loop filter 206 vp8_loop_filter_partial_frame(cm, &cpi->mb.e_mbd, filt_val, 0, 3); 207 cm->last_frame_type = cm->frame_type; 208 cm->last_filter_type = cm->filter_type; 209 cm->last_sharpness_level = cm->sharpness_level; 210 211 // Get the err for filtered frame 212 filt_err = vp8_calc_partial_ssl_err(sd, cm->frame_to_show, 3, IF_RTCD(&cpi->rtcd.variance)); 213 214 215 // Re-instate the unfiltered frame 216 vp8_yv12_copy_partial_frame_ptr(&cpi->last_frame_uf, cm->frame_to_show, 3); 217 218 219 // Update the best case record or exit loop. 220 if (filt_err < best_err) 221 { 222 best_err = filt_err; 223 best_filt_val = filt_val; 224 } 225 else 226 break; 227 228 // Adjust filter level 229 filt_val -= (1 + ((filt_val > 10) ? 1 : 0)); 230 } 231 232 // Search up (note that we have already done filt_val = cm->filter_level) 233 filt_val = cm->filter_level + (1 + ((filt_val > 10) ? 1 : 0)); 234 235 if (best_filt_val == cm->filter_level) 236 { 237 // Resist raising filter level for very small gains 238 best_err -= (best_err >> 10); 239 240 while (filt_val < max_filter_level) 241 { 242 // Apply the loop filter 243 vp8_loop_filter_partial_frame(cm, &cpi->mb.e_mbd, filt_val, 0, 3); 244 cm->last_frame_type = cm->frame_type; 245 cm->last_filter_type = cm->filter_type; 246 cm->last_sharpness_level = cm->sharpness_level; 247 248 // Get the err for filtered frame 249 filt_err = vp8_calc_partial_ssl_err(sd, cm->frame_to_show, 3, IF_RTCD(&cpi->rtcd.variance)); 250 251 // Re-instate the unfiltered frame 252 vp8_yv12_copy_partial_frame_ptr(&cpi->last_frame_uf, cm->frame_to_show, 3); 253 254 // Update the best case record or exit loop. 255 if (filt_err < best_err) 256 { 257 // Do not raise filter level if improvement is < 1 part in 4096 258 best_err = filt_err - (filt_err >> 10); 259 260 best_filt_val = filt_val; 261 } 262 else 263 break; 264 265 // Adjust filter level 266 filt_val += (1 + ((filt_val > 10) ? 1 : 0)); 267 } 268 } 269 270 cm->filter_level = best_filt_val; 271 272 if (cm->filter_level < min_filter_level) 273 cm->filter_level = min_filter_level; 274 275 if (cm->filter_level > max_filter_level) 276 cm->filter_level = max_filter_level; 277 } 278 279 // Stub function for now Alt LF not used 280 void vp8cx_set_alt_lf_level(VP8_COMP *cpi, int filt_val) 281 { 282 MACROBLOCKD *mbd = &cpi->mb.e_mbd; 283 (void) filt_val; 284 285 mbd->segment_feature_data[MB_LVL_ALT_LF][0] = cpi->segment_feature_data[MB_LVL_ALT_LF][0]; 286 mbd->segment_feature_data[MB_LVL_ALT_LF][1] = cpi->segment_feature_data[MB_LVL_ALT_LF][1]; 287 mbd->segment_feature_data[MB_LVL_ALT_LF][2] = cpi->segment_feature_data[MB_LVL_ALT_LF][2]; 288 mbd->segment_feature_data[MB_LVL_ALT_LF][3] = cpi->segment_feature_data[MB_LVL_ALT_LF][3]; 289 } 290 291 void vp8cx_pick_filter_level(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi) 292 { 293 VP8_COMMON *cm = &cpi->common; 294 295 int best_err = 0; 296 int filt_err = 0; 297 int min_filter_level; 298 int max_filter_level; 299 int prediction_difference = (int)(100 * abs((int)(cpi->last_auto_filter_prediction_error - cpi->prediction_error)) / (1 + cpi->prediction_error)); 300 301 int filter_step; 302 int filt_high = 0; 303 int filt_mid = cm->filter_level; // Start search at previous frame filter level 304 int filt_low = 0; 305 int filt_best; 306 int filt_direction = 0; 307 308 int Bias = 0; // Bias against raising loop filter and in favour of lowering it 309 310 // Make a copy of the unfiltered / processed recon buffer 311 #if HAVE_ARMV7 312 #if CONFIG_RUNTIME_CPU_DETECT 313 if (cm->rtcd.flags & HAS_NEON) 314 #endif 315 { 316 vp8_yv12_copy_frame_yonly_no_extend_frame_borders_neon(cm->frame_to_show, &cpi->last_frame_uf); 317 } 318 #if CONFIG_RUNTIME_CPU_DETECT 319 else 320 #endif 321 #endif 322 #if !HAVE_ARMV7 || CONFIG_RUNTIME_CPU_DETECT 323 { 324 vp8_yv12_copy_frame_ptr(cm->frame_to_show, &cpi->last_frame_uf); 325 } 326 #endif 327 328 if (cm->frame_type == KEY_FRAME) 329 cm->sharpness_level = 0; 330 else 331 cm->sharpness_level = cpi->oxcf.Sharpness; 332 333 // Enforce a minimum filter level based upon Q 334 min_filter_level = get_min_filter_level(cpi, cm->base_qindex); 335 max_filter_level = get_max_filter_level(cpi, cm->base_qindex); 336 337 // Start the search at the previous frame filter level unless it is now out of range. 338 filt_mid = cm->filter_level; 339 340 if (filt_mid < min_filter_level) 341 filt_mid = min_filter_level; 342 else if (filt_mid > max_filter_level) 343 filt_mid = max_filter_level; 344 345 // Define the initial step size 346 filter_step = (filt_mid < 16) ? 4 : filt_mid / 4; 347 348 // Get baseline error score 349 vp8cx_set_alt_lf_level(cpi, filt_mid); 350 vp8_loop_filter_frame_yonly(cm, &cpi->mb.e_mbd, filt_mid, 0); 351 cm->last_frame_type = cm->frame_type; 352 cm->last_filter_type = cm->filter_type; 353 cm->last_sharpness_level = cm->sharpness_level; 354 355 best_err = vp8_calc_ss_err(sd, cm->frame_to_show, IF_RTCD(&cpi->rtcd.variance)); 356 filt_best = filt_mid; 357 358 // Re-instate the unfiltered frame 359 #if HAVE_ARMV7 360 #if CONFIG_RUNTIME_CPU_DETECT 361 if (cm->rtcd.flags & HAS_NEON) 362 #endif 363 { 364 vp8_yv12_copy_frame_yonly_no_extend_frame_borders_neon(&cpi->last_frame_uf, cm->frame_to_show); 365 } 366 #if CONFIG_RUNTIME_CPU_DETECT 367 else 368 #endif 369 #endif 370 #if !HAVE_ARMV7 || CONFIG_RUNTIME_CPU_DETECT 371 { 372 vp8_yv12_copy_frame_yonly_ptr(&cpi->last_frame_uf, cm->frame_to_show); 373 } 374 #endif 375 376 while (filter_step > 0) 377 { 378 Bias = (best_err >> (15 - (filt_mid / 8))) * filter_step; //PGW change 12/12/06 for small images 379 380 // jbb chg: 20100118 - in sections with lots of new material coming in don't bias as much to a low filter value 381 if (cpi->section_intra_rating < 20) 382 Bias = Bias * cpi->section_intra_rating / 20; 383 384 filt_high = ((filt_mid + filter_step) > max_filter_level) ? max_filter_level : (filt_mid + filter_step); 385 filt_low = ((filt_mid - filter_step) < min_filter_level) ? min_filter_level : (filt_mid - filter_step); 386 387 if ((filt_direction <= 0) && (filt_low != filt_mid)) 388 { 389 // Get Low filter error score 390 vp8cx_set_alt_lf_level(cpi, filt_low); 391 vp8_loop_filter_frame_yonly(cm, &cpi->mb.e_mbd, filt_low, 0); 392 cm->last_frame_type = cm->frame_type; 393 cm->last_filter_type = cm->filter_type; 394 cm->last_sharpness_level = cm->sharpness_level; 395 396 filt_err = vp8_calc_ss_err(sd, cm->frame_to_show, IF_RTCD(&cpi->rtcd.variance)); 397 398 // Re-instate the unfiltered frame 399 #if HAVE_ARMV7 400 #if CONFIG_RUNTIME_CPU_DETECT 401 if (cm->rtcd.flags & HAS_NEON) 402 #endif 403 { 404 vp8_yv12_copy_frame_yonly_no_extend_frame_borders_neon(&cpi->last_frame_uf, cm->frame_to_show); 405 } 406 #if CONFIG_RUNTIME_CPU_DETECT 407 else 408 #endif 409 #endif 410 #if !HAVE_ARMV7 || CONFIG_RUNTIME_CPU_DETECT 411 { 412 vp8_yv12_copy_frame_yonly_ptr(&cpi->last_frame_uf, cm->frame_to_show); 413 } 414 #endif 415 416 // If value is close to the best so far then bias towards a lower loop filter value. 417 if ((filt_err - Bias) < best_err) 418 { 419 // Was it actually better than the previous best? 420 if (filt_err < best_err) 421 best_err = filt_err; 422 423 filt_best = filt_low; 424 } 425 } 426 427 // Now look at filt_high 428 if ((filt_direction >= 0) && (filt_high != filt_mid)) 429 { 430 vp8cx_set_alt_lf_level(cpi, filt_high); 431 vp8_loop_filter_frame_yonly(cm, &cpi->mb.e_mbd, filt_high, 0); 432 cm->last_frame_type = cm->frame_type; 433 cm->last_filter_type = cm->filter_type; 434 cm->last_sharpness_level = cm->sharpness_level; 435 436 filt_err = vp8_calc_ss_err(sd, cm->frame_to_show, IF_RTCD(&cpi->rtcd.variance)); 437 438 // Re-instate the unfiltered frame 439 #if HAVE_ARMV7 440 #if CONFIG_RUNTIME_CPU_DETECT 441 if (cm->rtcd.flags & HAS_NEON) 442 #endif 443 { 444 vp8_yv12_copy_frame_yonly_no_extend_frame_borders_neon(&cpi->last_frame_uf, cm->frame_to_show); 445 } 446 #if CONFIG_RUNTIME_CPU_DETECT 447 else 448 #endif 449 #endif 450 #if !HAVE_ARMV7 || CONFIG_RUNTIME_CPU_DETECT 451 { 452 vp8_yv12_copy_frame_yonly_ptr(&cpi->last_frame_uf, cm->frame_to_show); 453 } 454 #endif 455 456 // Was it better than the previous best? 457 if (filt_err < (best_err - Bias)) 458 { 459 best_err = filt_err; 460 filt_best = filt_high; 461 } 462 } 463 464 // Half the step distance if the best filter value was the same as last time 465 if (filt_best == filt_mid) 466 { 467 filter_step = filter_step / 2; 468 filt_direction = 0; 469 } 470 else 471 { 472 filt_direction = (filt_best < filt_mid) ? -1 : 1; 473 filt_mid = filt_best; 474 } 475 } 476 477 cm->filter_level = filt_best; 478 cpi->last_auto_filt_val = filt_best; 479 cpi->last_auto_filt_q = cm->base_qindex; 480 481 cpi->last_auto_filter_prediction_error = cpi->prediction_error; 482 cpi->frames_since_auto_filter = 0; 483 } 484
