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_ports/config.h" 13 #include "loopfilter.h" 14 #include "onyxc_int.h" 15 16 typedef unsigned char uc; 17 18 19 prototype_loopfilter(vp8_loop_filter_horizontal_edge_c); 20 prototype_loopfilter(vp8_loop_filter_vertical_edge_c); 21 prototype_loopfilter(vp8_mbloop_filter_horizontal_edge_c); 22 prototype_loopfilter(vp8_mbloop_filter_vertical_edge_c); 23 prototype_loopfilter(vp8_loop_filter_simple_horizontal_edge_c); 24 prototype_loopfilter(vp8_loop_filter_simple_vertical_edge_c); 25 26 /* Horizontal MB filtering */ 27 void vp8_loop_filter_mbh_c(unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr, 28 int y_stride, int uv_stride, loop_filter_info *lfi, int simpler_lpf) 29 { 30 (void) simpler_lpf; 31 vp8_mbloop_filter_horizontal_edge_c(y_ptr, y_stride, lfi->mbflim, lfi->lim, lfi->mbthr, 2); 32 33 if (u_ptr) 34 vp8_mbloop_filter_horizontal_edge_c(u_ptr, uv_stride, lfi->uvmbflim, lfi->uvlim, lfi->uvmbthr, 1); 35 36 if (v_ptr) 37 vp8_mbloop_filter_horizontal_edge_c(v_ptr, uv_stride, lfi->uvmbflim, lfi->uvlim, lfi->uvmbthr, 1); 38 } 39 40 void vp8_loop_filter_mbhs_c(unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr, 41 int y_stride, int uv_stride, loop_filter_info *lfi, int simpler_lpf) 42 { 43 (void) u_ptr; 44 (void) v_ptr; 45 (void) uv_stride; 46 (void) simpler_lpf; 47 vp8_loop_filter_simple_horizontal_edge_c(y_ptr, y_stride, lfi->mbflim, lfi->lim, lfi->mbthr, 2); 48 } 49 50 /* Vertical MB Filtering */ 51 void vp8_loop_filter_mbv_c(unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr, 52 int y_stride, int uv_stride, loop_filter_info *lfi, int simpler_lpf) 53 { 54 (void) simpler_lpf; 55 vp8_mbloop_filter_vertical_edge_c(y_ptr, y_stride, lfi->mbflim, lfi->lim, lfi->mbthr, 2); 56 57 if (u_ptr) 58 vp8_mbloop_filter_vertical_edge_c(u_ptr, uv_stride, lfi->uvmbflim, lfi->uvlim, lfi->uvmbthr, 1); 59 60 if (v_ptr) 61 vp8_mbloop_filter_vertical_edge_c(v_ptr, uv_stride, lfi->uvmbflim, lfi->uvlim, lfi->uvmbthr, 1); 62 } 63 64 void vp8_loop_filter_mbvs_c(unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr, 65 int y_stride, int uv_stride, loop_filter_info *lfi, int simpler_lpf) 66 { 67 (void) u_ptr; 68 (void) v_ptr; 69 (void) uv_stride; 70 (void) simpler_lpf; 71 vp8_loop_filter_simple_vertical_edge_c(y_ptr, y_stride, lfi->mbflim, lfi->lim, lfi->mbthr, 2); 72 } 73 74 /* Horizontal B Filtering */ 75 void vp8_loop_filter_bh_c(unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr, 76 int y_stride, int uv_stride, loop_filter_info *lfi, int simpler_lpf) 77 { 78 (void) simpler_lpf; 79 vp8_loop_filter_horizontal_edge_c(y_ptr + 4 * y_stride, y_stride, lfi->flim, lfi->lim, lfi->thr, 2); 80 vp8_loop_filter_horizontal_edge_c(y_ptr + 8 * y_stride, y_stride, lfi->flim, lfi->lim, lfi->thr, 2); 81 vp8_loop_filter_horizontal_edge_c(y_ptr + 12 * y_stride, y_stride, lfi->flim, lfi->lim, lfi->thr, 2); 82 83 if (u_ptr) 84 vp8_loop_filter_horizontal_edge_c(u_ptr + 4 * uv_stride, uv_stride, lfi->uvflim, lfi->uvlim, lfi->uvthr, 1); 85 86 if (v_ptr) 87 vp8_loop_filter_horizontal_edge_c(v_ptr + 4 * uv_stride, uv_stride, lfi->uvflim, lfi->uvlim, lfi->uvthr, 1); 88 } 89 90 void vp8_loop_filter_bhs_c(unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr, 91 int y_stride, int uv_stride, loop_filter_info *lfi, int simpler_lpf) 92 { 93 (void) u_ptr; 94 (void) v_ptr; 95 (void) uv_stride; 96 (void) simpler_lpf; 97 vp8_loop_filter_simple_horizontal_edge_c(y_ptr + 4 * y_stride, y_stride, lfi->flim, lfi->lim, lfi->thr, 2); 98 vp8_loop_filter_simple_horizontal_edge_c(y_ptr + 8 * y_stride, y_stride, lfi->flim, lfi->lim, lfi->thr, 2); 99 vp8_loop_filter_simple_horizontal_edge_c(y_ptr + 12 * y_stride, y_stride, lfi->flim, lfi->lim, lfi->thr, 2); 100 } 101 102 /* Vertical B Filtering */ 103 void vp8_loop_filter_bv_c(unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr, 104 int y_stride, int uv_stride, loop_filter_info *lfi, int simpler_lpf) 105 { 106 (void) simpler_lpf; 107 vp8_loop_filter_vertical_edge_c(y_ptr + 4, y_stride, lfi->flim, lfi->lim, lfi->thr, 2); 108 vp8_loop_filter_vertical_edge_c(y_ptr + 8, y_stride, lfi->flim, lfi->lim, lfi->thr, 2); 109 vp8_loop_filter_vertical_edge_c(y_ptr + 12, y_stride, lfi->flim, lfi->lim, lfi->thr, 2); 110 111 if (u_ptr) 112 vp8_loop_filter_vertical_edge_c(u_ptr + 4, uv_stride, lfi->uvflim, lfi->uvlim, lfi->uvthr, 1); 113 114 if (v_ptr) 115 vp8_loop_filter_vertical_edge_c(v_ptr + 4, uv_stride, lfi->uvflim, lfi->uvlim, lfi->uvthr, 1); 116 } 117 118 void vp8_loop_filter_bvs_c(unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr, 119 int y_stride, int uv_stride, loop_filter_info *lfi, int simpler_lpf) 120 { 121 (void) u_ptr; 122 (void) v_ptr; 123 (void) uv_stride; 124 (void) simpler_lpf; 125 vp8_loop_filter_simple_vertical_edge_c(y_ptr + 4, y_stride, lfi->flim, lfi->lim, lfi->thr, 2); 126 vp8_loop_filter_simple_vertical_edge_c(y_ptr + 8, y_stride, lfi->flim, lfi->lim, lfi->thr, 2); 127 vp8_loop_filter_simple_vertical_edge_c(y_ptr + 12, y_stride, lfi->flim, lfi->lim, lfi->thr, 2); 128 } 129 130 void vp8_init_loop_filter(VP8_COMMON *cm) 131 { 132 loop_filter_info *lfi = cm->lf_info; 133 LOOPFILTERTYPE lft = cm->filter_type; 134 int sharpness_lvl = cm->sharpness_level; 135 int frame_type = cm->frame_type; 136 int i, j; 137 138 int block_inside_limit = 0; 139 int HEVThresh; 140 const int yhedge_boost = 2; 141 const int uvhedge_boost = 2; 142 143 /* For each possible value for the loop filter fill out a "loop_filter_info" entry. */ 144 for (i = 0; i <= MAX_LOOP_FILTER; i++) 145 { 146 int filt_lvl = i; 147 148 if (frame_type == KEY_FRAME) 149 { 150 if (filt_lvl >= 40) 151 HEVThresh = 2; 152 else if (filt_lvl >= 15) 153 HEVThresh = 1; 154 else 155 HEVThresh = 0; 156 } 157 else 158 { 159 if (filt_lvl >= 40) 160 HEVThresh = 3; 161 else if (filt_lvl >= 20) 162 HEVThresh = 2; 163 else if (filt_lvl >= 15) 164 HEVThresh = 1; 165 else 166 HEVThresh = 0; 167 } 168 169 /* Set loop filter paramaeters that control sharpness. */ 170 block_inside_limit = filt_lvl >> (sharpness_lvl > 0); 171 block_inside_limit = block_inside_limit >> (sharpness_lvl > 4); 172 173 if (sharpness_lvl > 0) 174 { 175 if (block_inside_limit > (9 - sharpness_lvl)) 176 block_inside_limit = (9 - sharpness_lvl); 177 } 178 179 if (block_inside_limit < 1) 180 block_inside_limit = 1; 181 182 for (j = 0; j < 16; j++) 183 { 184 lfi[i].lim[j] = block_inside_limit; 185 lfi[i].mbflim[j] = filt_lvl + yhedge_boost; 186 lfi[i].mbthr[j] = HEVThresh; 187 lfi[i].flim[j] = filt_lvl; 188 lfi[i].thr[j] = HEVThresh; 189 lfi[i].uvlim[j] = block_inside_limit; 190 lfi[i].uvmbflim[j] = filt_lvl + uvhedge_boost; 191 lfi[i].uvmbthr[j] = HEVThresh; 192 lfi[i].uvflim[j] = filt_lvl; 193 lfi[i].uvthr[j] = HEVThresh; 194 } 195 196 } 197 198 /* Set up the function pointers depending on the type of loop filtering selected */ 199 if (lft == NORMAL_LOOPFILTER) 200 { 201 cm->lf_mbv = LF_INVOKE(&cm->rtcd.loopfilter, normal_mb_v); 202 cm->lf_bv = LF_INVOKE(&cm->rtcd.loopfilter, normal_b_v); 203 cm->lf_mbh = LF_INVOKE(&cm->rtcd.loopfilter, normal_mb_h); 204 cm->lf_bh = LF_INVOKE(&cm->rtcd.loopfilter, normal_b_h); 205 } 206 else 207 { 208 cm->lf_mbv = LF_INVOKE(&cm->rtcd.loopfilter, simple_mb_v); 209 cm->lf_bv = LF_INVOKE(&cm->rtcd.loopfilter, simple_b_v); 210 cm->lf_mbh = LF_INVOKE(&cm->rtcd.loopfilter, simple_mb_h); 211 cm->lf_bh = LF_INVOKE(&cm->rtcd.loopfilter, simple_b_h); 212 } 213 } 214 215 /* Put vp8_init_loop_filter() in vp8dx_create_decompressor(). Only call vp8_frame_init_loop_filter() while decoding 216 * each frame. Check last_frame_type to skip the function most of times. 217 */ 218 void vp8_frame_init_loop_filter(loop_filter_info *lfi, int frame_type) 219 { 220 int HEVThresh; 221 int i, j; 222 223 /* For each possible value for the loop filter fill out a "loop_filter_info" entry. */ 224 for (i = 0; i <= MAX_LOOP_FILTER; i++) 225 { 226 int filt_lvl = i; 227 228 if (frame_type == KEY_FRAME) 229 { 230 if (filt_lvl >= 40) 231 HEVThresh = 2; 232 else if (filt_lvl >= 15) 233 HEVThresh = 1; 234 else 235 HEVThresh = 0; 236 } 237 else 238 { 239 if (filt_lvl >= 40) 240 HEVThresh = 3; 241 else if (filt_lvl >= 20) 242 HEVThresh = 2; 243 else if (filt_lvl >= 15) 244 HEVThresh = 1; 245 else 246 HEVThresh = 0; 247 } 248 249 for (j = 0; j < 16; j++) 250 { 251 /*lfi[i].lim[j] = block_inside_limit; 252 lfi[i].mbflim[j] = filt_lvl+yhedge_boost;*/ 253 lfi[i].mbthr[j] = HEVThresh; 254 /*lfi[i].flim[j] = filt_lvl;*/ 255 lfi[i].thr[j] = HEVThresh; 256 /*lfi[i].uvlim[j] = block_inside_limit; 257 lfi[i].uvmbflim[j] = filt_lvl+uvhedge_boost;*/ 258 lfi[i].uvmbthr[j] = HEVThresh; 259 /*lfi[i].uvflim[j] = filt_lvl;*/ 260 lfi[i].uvthr[j] = HEVThresh; 261 } 262 } 263 } 264 265 266 void vp8_adjust_mb_lf_value(MACROBLOCKD *mbd, int *filter_level) 267 { 268 MB_MODE_INFO *mbmi = &mbd->mode_info_context->mbmi; 269 270 if (mbd->mode_ref_lf_delta_enabled) 271 { 272 /* Apply delta for reference frame */ 273 *filter_level += mbd->ref_lf_deltas[mbmi->ref_frame]; 274 275 /* Apply delta for mode */ 276 if (mbmi->ref_frame == INTRA_FRAME) 277 { 278 /* Only the split mode BPRED has a further special case */ 279 if (mbmi->mode == B_PRED) 280 *filter_level += mbd->mode_lf_deltas[0]; 281 } 282 else 283 { 284 /* Zero motion mode */ 285 if (mbmi->mode == ZEROMV) 286 *filter_level += mbd->mode_lf_deltas[1]; 287 288 /* Split MB motion mode */ 289 else if (mbmi->mode == SPLITMV) 290 *filter_level += mbd->mode_lf_deltas[3]; 291 292 /* All other inter motion modes (Nearest, Near, New) */ 293 else 294 *filter_level += mbd->mode_lf_deltas[2]; 295 } 296 297 /* Range check */ 298 if (*filter_level > MAX_LOOP_FILTER) 299 *filter_level = MAX_LOOP_FILTER; 300 else if (*filter_level < 0) 301 *filter_level = 0; 302 } 303 } 304 305 306 void vp8_loop_filter_frame 307 ( 308 VP8_COMMON *cm, 309 MACROBLOCKD *mbd, 310 int default_filt_lvl 311 ) 312 { 313 YV12_BUFFER_CONFIG *post = cm->frame_to_show; 314 loop_filter_info *lfi = cm->lf_info; 315 FRAME_TYPE frame_type = cm->frame_type; 316 317 int mb_row; 318 int mb_col; 319 320 321 int baseline_filter_level[MAX_MB_SEGMENTS]; 322 int filter_level; 323 int alt_flt_enabled = mbd->segmentation_enabled; 324 325 int i; 326 unsigned char *y_ptr, *u_ptr, *v_ptr; 327 328 mbd->mode_info_context = cm->mi; /* Point at base of Mb MODE_INFO list */ 329 330 /* Note the baseline filter values for each segment */ 331 if (alt_flt_enabled) 332 { 333 for (i = 0; i < MAX_MB_SEGMENTS; i++) 334 { 335 /* Abs value */ 336 if (mbd->mb_segement_abs_delta == SEGMENT_ABSDATA) 337 baseline_filter_level[i] = mbd->segment_feature_data[MB_LVL_ALT_LF][i]; 338 /* Delta Value */ 339 else 340 { 341 baseline_filter_level[i] = default_filt_lvl + mbd->segment_feature_data[MB_LVL_ALT_LF][i]; 342 baseline_filter_level[i] = (baseline_filter_level[i] >= 0) ? ((baseline_filter_level[i] <= MAX_LOOP_FILTER) ? baseline_filter_level[i] : MAX_LOOP_FILTER) : 0; /* Clamp to valid range */ 343 } 344 } 345 } 346 else 347 { 348 for (i = 0; i < MAX_MB_SEGMENTS; i++) 349 baseline_filter_level[i] = default_filt_lvl; 350 } 351 352 /* Initialize the loop filter for this frame. */ 353 if ((cm->last_filter_type != cm->filter_type) || (cm->last_sharpness_level != cm->sharpness_level)) 354 vp8_init_loop_filter(cm); 355 else if (frame_type != cm->last_frame_type) 356 vp8_frame_init_loop_filter(lfi, frame_type); 357 358 /* Set up the buffer pointers */ 359 y_ptr = post->y_buffer; 360 u_ptr = post->u_buffer; 361 v_ptr = post->v_buffer; 362 363 /* vp8_filter each macro block */ 364 for (mb_row = 0; mb_row < cm->mb_rows; mb_row++) 365 { 366 for (mb_col = 0; mb_col < cm->mb_cols; mb_col++) 367 { 368 int Segment = (alt_flt_enabled) ? mbd->mode_info_context->mbmi.segment_id : 0; 369 370 filter_level = baseline_filter_level[Segment]; 371 372 /* Distance of Mb to the various image edges. 373 * These specified to 8th pel as they are always compared to values that are in 1/8th pel units 374 * Apply any context driven MB level adjustment 375 */ 376 vp8_adjust_mb_lf_value(mbd, &filter_level); 377 378 if (filter_level) 379 { 380 if (mb_col > 0) 381 cm->lf_mbv(y_ptr, u_ptr, v_ptr, post->y_stride, post->uv_stride, &lfi[filter_level], cm->simpler_lpf); 382 383 if (mbd->mode_info_context->mbmi.dc_diff > 0) 384 cm->lf_bv(y_ptr, u_ptr, v_ptr, post->y_stride, post->uv_stride, &lfi[filter_level], cm->simpler_lpf); 385 386 /* don't apply across umv border */ 387 if (mb_row > 0) 388 cm->lf_mbh(y_ptr, u_ptr, v_ptr, post->y_stride, post->uv_stride, &lfi[filter_level], cm->simpler_lpf); 389 390 if (mbd->mode_info_context->mbmi.dc_diff > 0) 391 cm->lf_bh(y_ptr, u_ptr, v_ptr, post->y_stride, post->uv_stride, &lfi[filter_level], cm->simpler_lpf); 392 } 393 394 y_ptr += 16; 395 u_ptr += 8; 396 v_ptr += 8; 397 398 mbd->mode_info_context++; /* step to next MB */ 399 } 400 401 y_ptr += post->y_stride * 16 - post->y_width; 402 u_ptr += post->uv_stride * 8 - post->uv_width; 403 v_ptr += post->uv_stride * 8 - post->uv_width; 404 405 mbd->mode_info_context++; /* Skip border mb */ 406 } 407 } 408 409 410 void vp8_loop_filter_frame_yonly 411 ( 412 VP8_COMMON *cm, 413 MACROBLOCKD *mbd, 414 int default_filt_lvl, 415 int sharpness_lvl 416 ) 417 { 418 YV12_BUFFER_CONFIG *post = cm->frame_to_show; 419 420 int i; 421 unsigned char *y_ptr; 422 int mb_row; 423 int mb_col; 424 425 loop_filter_info *lfi = cm->lf_info; 426 int baseline_filter_level[MAX_MB_SEGMENTS]; 427 int filter_level; 428 int alt_flt_enabled = mbd->segmentation_enabled; 429 FRAME_TYPE frame_type = cm->frame_type; 430 431 (void) sharpness_lvl; 432 433 /*MODE_INFO * this_mb_mode_info = cm->mi;*/ /* Point at base of Mb MODE_INFO list */ 434 mbd->mode_info_context = cm->mi; /* Point at base of Mb MODE_INFO list */ 435 436 /* Note the baseline filter values for each segment */ 437 if (alt_flt_enabled) 438 { 439 for (i = 0; i < MAX_MB_SEGMENTS; i++) 440 { 441 /* Abs value */ 442 if (mbd->mb_segement_abs_delta == SEGMENT_ABSDATA) 443 baseline_filter_level[i] = mbd->segment_feature_data[MB_LVL_ALT_LF][i]; 444 /* Delta Value */ 445 else 446 { 447 baseline_filter_level[i] = default_filt_lvl + mbd->segment_feature_data[MB_LVL_ALT_LF][i]; 448 baseline_filter_level[i] = (baseline_filter_level[i] >= 0) ? ((baseline_filter_level[i] <= MAX_LOOP_FILTER) ? baseline_filter_level[i] : MAX_LOOP_FILTER) : 0; /* Clamp to valid range */ 449 } 450 } 451 } 452 else 453 { 454 for (i = 0; i < MAX_MB_SEGMENTS; i++) 455 baseline_filter_level[i] = default_filt_lvl; 456 } 457 458 /* Initialize the loop filter for this frame. */ 459 if ((cm->last_filter_type != cm->filter_type) || (cm->last_sharpness_level != cm->sharpness_level)) 460 vp8_init_loop_filter(cm); 461 else if (frame_type != cm->last_frame_type) 462 vp8_frame_init_loop_filter(lfi, frame_type); 463 464 /* Set up the buffer pointers */ 465 y_ptr = post->y_buffer; 466 467 /* vp8_filter each macro block */ 468 for (mb_row = 0; mb_row < cm->mb_rows; mb_row++) 469 { 470 for (mb_col = 0; mb_col < cm->mb_cols; mb_col++) 471 { 472 int Segment = (alt_flt_enabled) ? mbd->mode_info_context->mbmi.segment_id : 0; 473 filter_level = baseline_filter_level[Segment]; 474 475 /* Apply any context driven MB level adjustment */ 476 vp8_adjust_mb_lf_value(mbd, &filter_level); 477 478 if (filter_level) 479 { 480 if (mb_col > 0) 481 cm->lf_mbv(y_ptr, 0, 0, post->y_stride, 0, &lfi[filter_level], 0); 482 483 if (mbd->mode_info_context->mbmi.dc_diff > 0) 484 cm->lf_bv(y_ptr, 0, 0, post->y_stride, 0, &lfi[filter_level], 0); 485 486 /* don't apply across umv border */ 487 if (mb_row > 0) 488 cm->lf_mbh(y_ptr, 0, 0, post->y_stride, 0, &lfi[filter_level], 0); 489 490 if (mbd->mode_info_context->mbmi.dc_diff > 0) 491 cm->lf_bh(y_ptr, 0, 0, post->y_stride, 0, &lfi[filter_level], 0); 492 } 493 494 y_ptr += 16; 495 mbd->mode_info_context ++; /* step to next MB */ 496 497 } 498 499 y_ptr += post->y_stride * 16 - post->y_width; 500 mbd->mode_info_context ++; /* Skip border mb */ 501 } 502 503 } 504 505 506 void vp8_loop_filter_partial_frame 507 ( 508 VP8_COMMON *cm, 509 MACROBLOCKD *mbd, 510 int default_filt_lvl, 511 int sharpness_lvl, 512 int Fraction 513 ) 514 { 515 YV12_BUFFER_CONFIG *post = cm->frame_to_show; 516 517 int i; 518 unsigned char *y_ptr; 519 int mb_row; 520 int mb_col; 521 /*int mb_rows = post->y_height >> 4;*/ 522 int mb_cols = post->y_width >> 4; 523 524 int linestocopy; 525 526 loop_filter_info *lfi = cm->lf_info; 527 int baseline_filter_level[MAX_MB_SEGMENTS]; 528 int filter_level; 529 int alt_flt_enabled = mbd->segmentation_enabled; 530 FRAME_TYPE frame_type = cm->frame_type; 531 532 (void) sharpness_lvl; 533 534 /*MODE_INFO * this_mb_mode_info = cm->mi + (post->y_height>>5) * (mb_cols + 1);*/ /* Point at base of Mb MODE_INFO list */ 535 mbd->mode_info_context = cm->mi + (post->y_height >> 5) * (mb_cols + 1); /* Point at base of Mb MODE_INFO list */ 536 537 linestocopy = (post->y_height >> (4 + Fraction)); 538 539 if (linestocopy < 1) 540 linestocopy = 1; 541 542 linestocopy <<= 4; 543 544 /* Note the baseline filter values for each segment */ 545 if (alt_flt_enabled) 546 { 547 for (i = 0; i < MAX_MB_SEGMENTS; i++) 548 { 549 /* Abs value */ 550 if (mbd->mb_segement_abs_delta == SEGMENT_ABSDATA) 551 baseline_filter_level[i] = mbd->segment_feature_data[MB_LVL_ALT_LF][i]; 552 /* Delta Value */ 553 else 554 { 555 baseline_filter_level[i] = default_filt_lvl + mbd->segment_feature_data[MB_LVL_ALT_LF][i]; 556 baseline_filter_level[i] = (baseline_filter_level[i] >= 0) ? ((baseline_filter_level[i] <= MAX_LOOP_FILTER) ? baseline_filter_level[i] : MAX_LOOP_FILTER) : 0; /* Clamp to valid range */ 557 } 558 } 559 } 560 else 561 { 562 for (i = 0; i < MAX_MB_SEGMENTS; i++) 563 baseline_filter_level[i] = default_filt_lvl; 564 } 565 566 /* Initialize the loop filter for this frame. */ 567 if ((cm->last_filter_type != cm->filter_type) || (cm->last_sharpness_level != cm->sharpness_level)) 568 vp8_init_loop_filter(cm); 569 else if (frame_type != cm->last_frame_type) 570 vp8_frame_init_loop_filter(lfi, frame_type); 571 572 /* Set up the buffer pointers */ 573 y_ptr = post->y_buffer + (post->y_height >> 5) * 16 * post->y_stride; 574 575 /* vp8_filter each macro block */ 576 for (mb_row = 0; mb_row<(linestocopy >> 4); mb_row++) 577 { 578 for (mb_col = 0; mb_col < mb_cols; mb_col++) 579 { 580 int Segment = (alt_flt_enabled) ? mbd->mode_info_context->mbmi.segment_id : 0; 581 filter_level = baseline_filter_level[Segment]; 582 583 if (filter_level) 584 { 585 if (mb_col > 0) 586 cm->lf_mbv(y_ptr, 0, 0, post->y_stride, 0, &lfi[filter_level], 0); 587 588 if (mbd->mode_info_context->mbmi.dc_diff > 0) 589 cm->lf_bv(y_ptr, 0, 0, post->y_stride, 0, &lfi[filter_level], 0); 590 591 cm->lf_mbh(y_ptr, 0, 0, post->y_stride, 0, &lfi[filter_level], 0); 592 593 if (mbd->mode_info_context->mbmi.dc_diff > 0) 594 cm->lf_bh(y_ptr, 0, 0, post->y_stride, 0, &lfi[filter_level], 0); 595 } 596 597 y_ptr += 16; 598 mbd->mode_info_context += 1; /* step to next MB */ 599 } 600 601 y_ptr += post->y_stride * 16 - post->y_width; 602 mbd->mode_info_context += 1; /* Skip border mb */ 603 } 604 } 605
