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_config.h" 13#include "vp8_rtcd.h" 14#include "loopfilter.h" 15#include "onyxc_int.h" 16#include "vpx_mem/vpx_mem.h" 17 18 19static void lf_init_lut(loop_filter_info_n *lfi) 20{ 21 int filt_lvl; 22 23 for (filt_lvl = 0; filt_lvl <= MAX_LOOP_FILTER; filt_lvl++) 24 { 25 if (filt_lvl >= 40) 26 { 27 lfi->hev_thr_lut[KEY_FRAME][filt_lvl] = 2; 28 lfi->hev_thr_lut[INTER_FRAME][filt_lvl] = 3; 29 } 30 else if (filt_lvl >= 20) 31 { 32 lfi->hev_thr_lut[KEY_FRAME][filt_lvl] = 1; 33 lfi->hev_thr_lut[INTER_FRAME][filt_lvl] = 2; 34 } 35 else if (filt_lvl >= 15) 36 { 37 lfi->hev_thr_lut[KEY_FRAME][filt_lvl] = 1; 38 lfi->hev_thr_lut[INTER_FRAME][filt_lvl] = 1; 39 } 40 else 41 { 42 lfi->hev_thr_lut[KEY_FRAME][filt_lvl] = 0; 43 lfi->hev_thr_lut[INTER_FRAME][filt_lvl] = 0; 44 } 45 } 46 47 lfi->mode_lf_lut[DC_PRED] = 1; 48 lfi->mode_lf_lut[V_PRED] = 1; 49 lfi->mode_lf_lut[H_PRED] = 1; 50 lfi->mode_lf_lut[TM_PRED] = 1; 51 lfi->mode_lf_lut[B_PRED] = 0; 52 53 lfi->mode_lf_lut[ZEROMV] = 1; 54 lfi->mode_lf_lut[NEARESTMV] = 2; 55 lfi->mode_lf_lut[NEARMV] = 2; 56 lfi->mode_lf_lut[NEWMV] = 2; 57 lfi->mode_lf_lut[SPLITMV] = 3; 58 59} 60 61void vp8_loop_filter_update_sharpness(loop_filter_info_n *lfi, 62 int sharpness_lvl) 63{ 64 int i; 65 66 /* For each possible value for the loop filter fill out limits */ 67 for (i = 0; i <= MAX_LOOP_FILTER; i++) 68 { 69 int filt_lvl = i; 70 int block_inside_limit = 0; 71 72 /* Set loop filter paramaeters that control sharpness. */ 73 block_inside_limit = filt_lvl >> (sharpness_lvl > 0); 74 block_inside_limit = block_inside_limit >> (sharpness_lvl > 4); 75 76 if (sharpness_lvl > 0) 77 { 78 if (block_inside_limit > (9 - sharpness_lvl)) 79 block_inside_limit = (9 - sharpness_lvl); 80 } 81 82 if (block_inside_limit < 1) 83 block_inside_limit = 1; 84 85 vpx_memset(lfi->lim[i], block_inside_limit, SIMD_WIDTH); 86 vpx_memset(lfi->blim[i], (2 * filt_lvl + block_inside_limit), 87 SIMD_WIDTH); 88 vpx_memset(lfi->mblim[i], (2 * (filt_lvl + 2) + block_inside_limit), 89 SIMD_WIDTH); 90 } 91} 92 93void vp8_loop_filter_init(VP8_COMMON *cm) 94{ 95 loop_filter_info_n *lfi = &cm->lf_info; 96 int i; 97 98 /* init limits for given sharpness*/ 99 vp8_loop_filter_update_sharpness(lfi, cm->sharpness_level); 100 cm->last_sharpness_level = cm->sharpness_level; 101 102 /* init LUT for lvl and hev thr picking */ 103 lf_init_lut(lfi); 104 105 /* init hev threshold const vectors */ 106 for(i = 0; i < 4 ; i++) 107 { 108 vpx_memset(lfi->hev_thr[i], i, SIMD_WIDTH); 109 } 110} 111 112void vp8_loop_filter_frame_init(VP8_COMMON *cm, 113 MACROBLOCKD *mbd, 114 int default_filt_lvl) 115{ 116 int seg, /* segment number */ 117 ref, /* index in ref_lf_deltas */ 118 mode; /* index in mode_lf_deltas */ 119 120 loop_filter_info_n *lfi = &cm->lf_info; 121 122 /* update limits if sharpness has changed */ 123 if(cm->last_sharpness_level != cm->sharpness_level) 124 { 125 vp8_loop_filter_update_sharpness(lfi, cm->sharpness_level); 126 cm->last_sharpness_level = cm->sharpness_level; 127 } 128 129 for(seg = 0; seg < MAX_MB_SEGMENTS; seg++) 130 { 131 int lvl_seg = default_filt_lvl; 132 int lvl_ref, lvl_mode; 133 134 /* Note the baseline filter values for each segment */ 135 if (mbd->segmentation_enabled) 136 { 137 /* Abs value */ 138 if (mbd->mb_segement_abs_delta == SEGMENT_ABSDATA) 139 { 140 lvl_seg = mbd->segment_feature_data[MB_LVL_ALT_LF][seg]; 141 } 142 else /* Delta Value */ 143 { 144 lvl_seg += mbd->segment_feature_data[MB_LVL_ALT_LF][seg]; 145 lvl_seg = (lvl_seg > 0) ? ((lvl_seg > 63) ? 63: lvl_seg) : 0; 146 } 147 } 148 149 if (!mbd->mode_ref_lf_delta_enabled) 150 { 151 /* we could get rid of this if we assume that deltas are set to 152 * zero when not in use; encoder always uses deltas 153 */ 154 vpx_memset(lfi->lvl[seg][0], lvl_seg, 4 * 4 ); 155 continue; 156 } 157 158 /* INTRA_FRAME */ 159 ref = INTRA_FRAME; 160 161 /* Apply delta for reference frame */ 162 lvl_ref = lvl_seg + mbd->ref_lf_deltas[ref]; 163 164 /* Apply delta for Intra modes */ 165 mode = 0; /* B_PRED */ 166 /* Only the split mode BPRED has a further special case */ 167 lvl_mode = lvl_ref + mbd->mode_lf_deltas[mode]; 168 /* clamp */ 169 lvl_mode = (lvl_mode > 0) ? (lvl_mode > 63 ? 63 : lvl_mode) : 0; 170 171 lfi->lvl[seg][ref][mode] = lvl_mode; 172 173 mode = 1; /* all the rest of Intra modes */ 174 /* clamp */ 175 lvl_mode = (lvl_ref > 0) ? (lvl_ref > 63 ? 63 : lvl_ref) : 0; 176 lfi->lvl[seg][ref][mode] = lvl_mode; 177 178 /* LAST, GOLDEN, ALT */ 179 for(ref = 1; ref < MAX_REF_FRAMES; ref++) 180 { 181 /* Apply delta for reference frame */ 182 lvl_ref = lvl_seg + mbd->ref_lf_deltas[ref]; 183 184 /* Apply delta for Inter modes */ 185 for (mode = 1; mode < 4; mode++) 186 { 187 lvl_mode = lvl_ref + mbd->mode_lf_deltas[mode]; 188 /* clamp */ 189 lvl_mode = (lvl_mode > 0) ? (lvl_mode > 63 ? 63 : lvl_mode) : 0; 190 191 lfi->lvl[seg][ref][mode] = lvl_mode; 192 } 193 } 194 } 195} 196 197 198void vp8_loop_filter_row_normal(VP8_COMMON *cm, MODE_INFO *mode_info_context, 199 int mb_row, int post_ystride, int post_uvstride, 200 unsigned char *y_ptr, unsigned char *u_ptr, 201 unsigned char *v_ptr) 202{ 203 int mb_col; 204 int filter_level; 205 loop_filter_info_n *lfi_n = &cm->lf_info; 206 loop_filter_info lfi; 207 FRAME_TYPE frame_type = cm->frame_type; 208 209 for (mb_col = 0; mb_col < cm->mb_cols; mb_col++) 210 { 211 int skip_lf = (mode_info_context->mbmi.mode != B_PRED && 212 mode_info_context->mbmi.mode != SPLITMV && 213 mode_info_context->mbmi.mb_skip_coeff); 214 215 const int mode_index = lfi_n->mode_lf_lut[mode_info_context->mbmi.mode]; 216 const int seg = mode_info_context->mbmi.segment_id; 217 const int ref_frame = mode_info_context->mbmi.ref_frame; 218 219 filter_level = lfi_n->lvl[seg][ref_frame][mode_index]; 220 221 if (filter_level) 222 { 223 const int hev_index = lfi_n->hev_thr_lut[frame_type][filter_level]; 224 lfi.mblim = lfi_n->mblim[filter_level]; 225 lfi.blim = lfi_n->blim[filter_level]; 226 lfi.lim = lfi_n->lim[filter_level]; 227 lfi.hev_thr = lfi_n->hev_thr[hev_index]; 228 229 if (mb_col > 0) 230 vp8_loop_filter_mbv 231 (y_ptr, u_ptr, v_ptr, post_ystride, post_uvstride, &lfi); 232 233 if (!skip_lf) 234 vp8_loop_filter_bv 235 (y_ptr, u_ptr, v_ptr, post_ystride, post_uvstride, &lfi); 236 237 /* don't apply across umv border */ 238 if (mb_row > 0) 239 vp8_loop_filter_mbh 240 (y_ptr, u_ptr, v_ptr, post_ystride, post_uvstride, &lfi); 241 242 if (!skip_lf) 243 vp8_loop_filter_bh 244 (y_ptr, u_ptr, v_ptr, post_ystride, post_uvstride, &lfi); 245 } 246 247 y_ptr += 16; 248 u_ptr += 8; 249 v_ptr += 8; 250 251 mode_info_context++; /* step to next MB */ 252 } 253 254} 255 256void vp8_loop_filter_row_simple(VP8_COMMON *cm, MODE_INFO *mode_info_context, 257 int mb_row, int post_ystride, int post_uvstride, 258 unsigned char *y_ptr, unsigned char *u_ptr, 259 unsigned char *v_ptr) 260{ 261 int mb_col; 262 int filter_level; 263 loop_filter_info_n *lfi_n = &cm->lf_info; 264 265 for (mb_col = 0; mb_col < cm->mb_cols; mb_col++) 266 { 267 int skip_lf = (mode_info_context->mbmi.mode != B_PRED && 268 mode_info_context->mbmi.mode != SPLITMV && 269 mode_info_context->mbmi.mb_skip_coeff); 270 271 const int mode_index = lfi_n->mode_lf_lut[mode_info_context->mbmi.mode]; 272 const int seg = mode_info_context->mbmi.segment_id; 273 const int ref_frame = mode_info_context->mbmi.ref_frame; 274 275 filter_level = lfi_n->lvl[seg][ref_frame][mode_index]; 276 277 if (filter_level) 278 { 279 if (mb_col > 0) 280 vp8_loop_filter_simple_mbv 281 (y_ptr, post_ystride, lfi_n->mblim[filter_level]); 282 283 if (!skip_lf) 284 vp8_loop_filter_simple_bv 285 (y_ptr, post_ystride, lfi_n->blim[filter_level]); 286 287 /* don't apply across umv border */ 288 if (mb_row > 0) 289 vp8_loop_filter_simple_mbh 290 (y_ptr, post_ystride, lfi_n->mblim[filter_level]); 291 292 if (!skip_lf) 293 vp8_loop_filter_simple_bh 294 (y_ptr, post_ystride, lfi_n->blim[filter_level]); 295 } 296 297 y_ptr += 16; 298 u_ptr += 8; 299 v_ptr += 8; 300 301 mode_info_context++; /* step to next MB */ 302 } 303 304} 305void vp8_loop_filter_frame(VP8_COMMON *cm, 306 MACROBLOCKD *mbd, 307 int frame_type) 308{ 309 YV12_BUFFER_CONFIG *post = cm->frame_to_show; 310 loop_filter_info_n *lfi_n = &cm->lf_info; 311 loop_filter_info lfi; 312 313 int mb_row; 314 int mb_col; 315 int mb_rows = cm->mb_rows; 316 int mb_cols = cm->mb_cols; 317 318 int filter_level; 319 320 unsigned char *y_ptr, *u_ptr, *v_ptr; 321 322 /* Point at base of Mb MODE_INFO list */ 323 const MODE_INFO *mode_info_context = cm->mi; 324 int post_y_stride = post->y_stride; 325 int post_uv_stride = post->uv_stride; 326 327 /* Initialize the loop filter for this frame. */ 328 vp8_loop_filter_frame_init(cm, mbd, cm->filter_level); 329 330 /* Set up the buffer pointers */ 331 y_ptr = post->y_buffer; 332 u_ptr = post->u_buffer; 333 v_ptr = post->v_buffer; 334 335 /* vp8_filter each macro block */ 336 if (cm->filter_type == NORMAL_LOOPFILTER) 337 { 338 for (mb_row = 0; mb_row < mb_rows; mb_row++) 339 { 340 for (mb_col = 0; mb_col < mb_cols; mb_col++) 341 { 342 int skip_lf = (mode_info_context->mbmi.mode != B_PRED && 343 mode_info_context->mbmi.mode != SPLITMV && 344 mode_info_context->mbmi.mb_skip_coeff); 345 346 const int mode_index = lfi_n->mode_lf_lut[mode_info_context->mbmi.mode]; 347 const int seg = mode_info_context->mbmi.segment_id; 348 const int ref_frame = mode_info_context->mbmi.ref_frame; 349 350 filter_level = lfi_n->lvl[seg][ref_frame][mode_index]; 351 352 if (filter_level) 353 { 354 const int hev_index = lfi_n->hev_thr_lut[frame_type][filter_level]; 355 lfi.mblim = lfi_n->mblim[filter_level]; 356 lfi.blim = lfi_n->blim[filter_level]; 357 lfi.lim = lfi_n->lim[filter_level]; 358 lfi.hev_thr = lfi_n->hev_thr[hev_index]; 359 360 if (mb_col > 0) 361 vp8_loop_filter_mbv 362 (y_ptr, u_ptr, v_ptr, post_y_stride, post_uv_stride, &lfi); 363 364 if (!skip_lf) 365 vp8_loop_filter_bv 366 (y_ptr, u_ptr, v_ptr, post_y_stride, post_uv_stride, &lfi); 367 368 /* don't apply across umv border */ 369 if (mb_row > 0) 370 vp8_loop_filter_mbh 371 (y_ptr, u_ptr, v_ptr, post_y_stride, post_uv_stride, &lfi); 372 373 if (!skip_lf) 374 vp8_loop_filter_bh 375 (y_ptr, u_ptr, v_ptr, post_y_stride, post_uv_stride, &lfi); 376 } 377 378 y_ptr += 16; 379 u_ptr += 8; 380 v_ptr += 8; 381 382 mode_info_context++; /* step to next MB */ 383 } 384 y_ptr += post_y_stride * 16 - post->y_width; 385 u_ptr += post_uv_stride * 8 - post->uv_width; 386 v_ptr += post_uv_stride * 8 - post->uv_width; 387 388 mode_info_context++; /* Skip border mb */ 389 390 } 391 } 392 else /* SIMPLE_LOOPFILTER */ 393 { 394 for (mb_row = 0; mb_row < mb_rows; mb_row++) 395 { 396 for (mb_col = 0; mb_col < mb_cols; mb_col++) 397 { 398 int skip_lf = (mode_info_context->mbmi.mode != B_PRED && 399 mode_info_context->mbmi.mode != SPLITMV && 400 mode_info_context->mbmi.mb_skip_coeff); 401 402 const int mode_index = lfi_n->mode_lf_lut[mode_info_context->mbmi.mode]; 403 const int seg = mode_info_context->mbmi.segment_id; 404 const int ref_frame = mode_info_context->mbmi.ref_frame; 405 406 filter_level = lfi_n->lvl[seg][ref_frame][mode_index]; 407 if (filter_level) 408 { 409 const unsigned char * mblim = lfi_n->mblim[filter_level]; 410 const unsigned char * blim = lfi_n->blim[filter_level]; 411 412 if (mb_col > 0) 413 vp8_loop_filter_simple_mbv 414 (y_ptr, post_y_stride, mblim); 415 416 if (!skip_lf) 417 vp8_loop_filter_simple_bv 418 (y_ptr, post_y_stride, blim); 419 420 /* don't apply across umv border */ 421 if (mb_row > 0) 422 vp8_loop_filter_simple_mbh 423 (y_ptr, post_y_stride, mblim); 424 425 if (!skip_lf) 426 vp8_loop_filter_simple_bh 427 (y_ptr, post_y_stride, blim); 428 } 429 430 y_ptr += 16; 431 u_ptr += 8; 432 v_ptr += 8; 433 434 mode_info_context++; /* step to next MB */ 435 } 436 y_ptr += post_y_stride * 16 - post->y_width; 437 u_ptr += post_uv_stride * 8 - post->uv_width; 438 v_ptr += post_uv_stride * 8 - post->uv_width; 439 440 mode_info_context++; /* Skip border mb */ 441 442 } 443 } 444} 445 446void vp8_loop_filter_frame_yonly 447( 448 VP8_COMMON *cm, 449 MACROBLOCKD *mbd, 450 int default_filt_lvl 451) 452{ 453 YV12_BUFFER_CONFIG *post = cm->frame_to_show; 454 455 unsigned char *y_ptr; 456 int mb_row; 457 int mb_col; 458 459 loop_filter_info_n *lfi_n = &cm->lf_info; 460 loop_filter_info lfi; 461 462 int filter_level; 463 FRAME_TYPE frame_type = cm->frame_type; 464 465 /* Point at base of Mb MODE_INFO list */ 466 const MODE_INFO *mode_info_context = cm->mi; 467 468#if 0 469 if(default_filt_lvl == 0) /* no filter applied */ 470 return; 471#endif 472 473 /* Initialize the loop filter for this frame. */ 474 vp8_loop_filter_frame_init( cm, mbd, default_filt_lvl); 475 476 /* Set up the buffer pointers */ 477 y_ptr = post->y_buffer; 478 479 /* vp8_filter each macro block */ 480 for (mb_row = 0; mb_row < cm->mb_rows; mb_row++) 481 { 482 for (mb_col = 0; mb_col < cm->mb_cols; mb_col++) 483 { 484 int skip_lf = (mode_info_context->mbmi.mode != B_PRED && 485 mode_info_context->mbmi.mode != SPLITMV && 486 mode_info_context->mbmi.mb_skip_coeff); 487 488 const int mode_index = lfi_n->mode_lf_lut[mode_info_context->mbmi.mode]; 489 const int seg = mode_info_context->mbmi.segment_id; 490 const int ref_frame = mode_info_context->mbmi.ref_frame; 491 492 filter_level = lfi_n->lvl[seg][ref_frame][mode_index]; 493 494 if (filter_level) 495 { 496 if (cm->filter_type == NORMAL_LOOPFILTER) 497 { 498 const int hev_index = lfi_n->hev_thr_lut[frame_type][filter_level]; 499 lfi.mblim = lfi_n->mblim[filter_level]; 500 lfi.blim = lfi_n->blim[filter_level]; 501 lfi.lim = lfi_n->lim[filter_level]; 502 lfi.hev_thr = lfi_n->hev_thr[hev_index]; 503 504 if (mb_col > 0) 505 vp8_loop_filter_mbv 506 (y_ptr, 0, 0, post->y_stride, 0, &lfi); 507 508 if (!skip_lf) 509 vp8_loop_filter_bv 510 (y_ptr, 0, 0, post->y_stride, 0, &lfi); 511 512 /* don't apply across umv border */ 513 if (mb_row > 0) 514 vp8_loop_filter_mbh 515 (y_ptr, 0, 0, post->y_stride, 0, &lfi); 516 517 if (!skip_lf) 518 vp8_loop_filter_bh 519 (y_ptr, 0, 0, post->y_stride, 0, &lfi); 520 } 521 else 522 { 523 if (mb_col > 0) 524 vp8_loop_filter_simple_mbv 525 (y_ptr, post->y_stride, lfi_n->mblim[filter_level]); 526 527 if (!skip_lf) 528 vp8_loop_filter_simple_bv 529 (y_ptr, post->y_stride, lfi_n->blim[filter_level]); 530 531 /* don't apply across umv border */ 532 if (mb_row > 0) 533 vp8_loop_filter_simple_mbh 534 (y_ptr, post->y_stride, lfi_n->mblim[filter_level]); 535 536 if (!skip_lf) 537 vp8_loop_filter_simple_bh 538 (y_ptr, post->y_stride, lfi_n->blim[filter_level]); 539 } 540 } 541 542 y_ptr += 16; 543 mode_info_context ++; /* step to next MB */ 544 545 } 546 547 y_ptr += post->y_stride * 16 - post->y_width; 548 mode_info_context ++; /* Skip border mb */ 549 } 550 551} 552 553void vp8_loop_filter_partial_frame 554( 555 VP8_COMMON *cm, 556 MACROBLOCKD *mbd, 557 int default_filt_lvl 558) 559{ 560 YV12_BUFFER_CONFIG *post = cm->frame_to_show; 561 562 unsigned char *y_ptr; 563 int mb_row; 564 int mb_col; 565 int mb_cols = post->y_width >> 4; 566 int mb_rows = post->y_height >> 4; 567 568 int linestocopy; 569 570 loop_filter_info_n *lfi_n = &cm->lf_info; 571 loop_filter_info lfi; 572 573 int filter_level; 574 FRAME_TYPE frame_type = cm->frame_type; 575 576 const MODE_INFO *mode_info_context; 577 578#if 0 579 if(default_filt_lvl == 0) /* no filter applied */ 580 return; 581#endif 582 583 /* Initialize the loop filter for this frame. */ 584 vp8_loop_filter_frame_init( cm, mbd, default_filt_lvl); 585 586 /* number of MB rows to use in partial filtering */ 587 linestocopy = mb_rows / PARTIAL_FRAME_FRACTION; 588 linestocopy = linestocopy ? linestocopy << 4 : 16; /* 16 lines per MB */ 589 590 /* Set up the buffer pointers; partial image starts at ~middle of frame */ 591 y_ptr = post->y_buffer + ((post->y_height >> 5) * 16) * post->y_stride; 592 mode_info_context = cm->mi + (post->y_height >> 5) * (mb_cols + 1); 593 594 /* vp8_filter each macro block */ 595 for (mb_row = 0; mb_row<(linestocopy >> 4); mb_row++) 596 { 597 for (mb_col = 0; mb_col < mb_cols; mb_col++) 598 { 599 int skip_lf = (mode_info_context->mbmi.mode != B_PRED && 600 mode_info_context->mbmi.mode != SPLITMV && 601 mode_info_context->mbmi.mb_skip_coeff); 602 603 const int mode_index = 604 lfi_n->mode_lf_lut[mode_info_context->mbmi.mode]; 605 const int seg = mode_info_context->mbmi.segment_id; 606 const int ref_frame = mode_info_context->mbmi.ref_frame; 607 608 filter_level = lfi_n->lvl[seg][ref_frame][mode_index]; 609 610 if (filter_level) 611 { 612 if (cm->filter_type == NORMAL_LOOPFILTER) 613 { 614 const int hev_index = lfi_n->hev_thr_lut[frame_type][filter_level]; 615 lfi.mblim = lfi_n->mblim[filter_level]; 616 lfi.blim = lfi_n->blim[filter_level]; 617 lfi.lim = lfi_n->lim[filter_level]; 618 lfi.hev_thr = lfi_n->hev_thr[hev_index]; 619 620 if (mb_col > 0) 621 vp8_loop_filter_mbv 622 (y_ptr, 0, 0, post->y_stride, 0, &lfi); 623 624 if (!skip_lf) 625 vp8_loop_filter_bv 626 (y_ptr, 0, 0, post->y_stride, 0, &lfi); 627 628 vp8_loop_filter_mbh 629 (y_ptr, 0, 0, post->y_stride, 0, &lfi); 630 631 if (!skip_lf) 632 vp8_loop_filter_bh 633 (y_ptr, 0, 0, post->y_stride, 0, &lfi); 634 } 635 else 636 { 637 if (mb_col > 0) 638 vp8_loop_filter_simple_mbv 639 (y_ptr, post->y_stride, lfi_n->mblim[filter_level]); 640 641 if (!skip_lf) 642 vp8_loop_filter_simple_bv 643 (y_ptr, post->y_stride, lfi_n->blim[filter_level]); 644 645 vp8_loop_filter_simple_mbh 646 (y_ptr, post->y_stride, lfi_n->mblim[filter_level]); 647 648 if (!skip_lf) 649 vp8_loop_filter_simple_bh 650 (y_ptr, post->y_stride, lfi_n->blim[filter_level]); 651 } 652 } 653 654 y_ptr += 16; 655 mode_info_context += 1; /* step to next MB */ 656 } 657 658 y_ptr += post->y_stride * 16 - post->y_width; 659 mode_info_context += 1; /* Skip border mb */ 660 } 661} 662