/* *  Copyright (c) 2010 The WebM project authors. All Rights Reserved. * *  Use of this source code is governed by a BSD-style license *  that can be found in the LICENSE file in the root of the source *  tree. An additional intellectual property rights grant can be found *  in the file PATENTS.  All contributing project authors may *  be found in the AUTHORS file in the root of the source tree. */ #include "vpx_config.h"#include "vp8_rtcd.h"#include "loopfilter.h"#include "onyxc_int.h"#include "vpx_mem/vpx_mem.h" static void lf_init_lut(loop_filter_info_n *lfi) {  int filt_lvl;   for (filt_lvl = 0; filt_lvl <= MAX_LOOP_FILTER; ++filt_lvl) {    if (filt_lvl >= 40) {      lfi->hev_thr_lut[KEY_FRAME][filt_lvl] = 2;      lfi->hev_thr_lut[INTER_FRAME][filt_lvl] = 3;    } else if (filt_lvl >= 20) {      lfi->hev_thr_lut[KEY_FRAME][filt_lvl] = 1;      lfi->hev_thr_lut[INTER_FRAME][filt_lvl] = 2;    } else if (filt_lvl >= 15) {      lfi->hev_thr_lut[KEY_FRAME][filt_lvl] = 1;      lfi->hev_thr_lut[INTER_FRAME][filt_lvl] = 1;    } else {      lfi->hev_thr_lut[KEY_FRAME][filt_lvl] = 0;      lfi->hev_thr_lut[INTER_FRAME][filt_lvl] = 0;    }  }   lfi->mode_lf_lut[DC_PRED] = 1;  lfi->mode_lf_lut[V_PRED] = 1;  lfi->mode_lf_lut[H_PRED] = 1;  lfi->mode_lf_lut[TM_PRED] = 1;  lfi->mode_lf_lut[B_PRED] = 0;   lfi->mode_lf_lut[ZEROMV] = 1;  lfi->mode_lf_lut[NEARESTMV] = 2;  lfi->mode_lf_lut[NEARMV] = 2;  lfi->mode_lf_lut[NEWMV] = 2;  lfi->mode_lf_lut[SPLITMV] = 3;} void vp8_loop_filter_update_sharpness(loop_filter_info_n *lfi,                                      int sharpness_lvl) {  int i;   /* For each possible value for the loop filter fill out limits */  for (i = 0; i <= MAX_LOOP_FILTER; ++i) {    int filt_lvl = i;    int block_inside_limit = 0;     /* Set loop filter paramaeters that control sharpness. */    block_inside_limit = filt_lvl >> (sharpness_lvl > 0);    block_inside_limit = block_inside_limit >> (sharpness_lvl > 4);     if (sharpness_lvl > 0) {      if (block_inside_limit > (9 - sharpness_lvl)) {        block_inside_limit = (9 - sharpness_lvl);      }    }     if (block_inside_limit < 1) block_inside_limit = 1;     memset(lfi->lim[i], block_inside_limit, SIMD_WIDTH);    memset(lfi->blim[i], (2 * filt_lvl + block_inside_limit), SIMD_WIDTH);    memset(lfi->mblim[i], (2 * (filt_lvl + 2) + block_inside_limit),           SIMD_WIDTH);  }} void vp8_loop_filter_init(VP8_COMMON *cm) {  loop_filter_info_n *lfi = &cm->lf_info;  int i;   /* init limits for given sharpness*/  vp8_loop_filter_update_sharpness(lfi, cm->sharpness_level);  cm->last_sharpness_level = cm->sharpness_level;   /* init LUT for lvl  and hev thr picking */  lf_init_lut(lfi);   /* init hev threshold const vectors */  for (i = 0; i < 4; ++i) {    memset(lfi->hev_thr[i], i, SIMD_WIDTH);  }} void vp8_loop_filter_frame_init(VP8_COMMON *cm, MACROBLOCKD *mbd,                                int default_filt_lvl) {  int seg,  /* segment number */      ref,  /* index in ref_lf_deltas */      mode; /* index in mode_lf_deltas */   loop_filter_info_n *lfi = &cm->lf_info;   /* update limits if sharpness has changed */  if (cm->last_sharpness_level != cm->sharpness_level) {    vp8_loop_filter_update_sharpness(lfi, cm->sharpness_level);    cm->last_sharpness_level = cm->sharpness_level;  }   for (seg = 0; seg < MAX_MB_SEGMENTS; ++seg) {    int lvl_seg = default_filt_lvl;    int lvl_ref, lvl_mode;     /* Note the baseline filter values for each segment */    if (mbd->segmentation_enabled) {      if (mbd->mb_segement_abs_delta == SEGMENT_ABSDATA) {        lvl_seg = mbd->segment_feature_data[MB_LVL_ALT_LF][seg];      } else { /* Delta Value */        lvl_seg += mbd->segment_feature_data[MB_LVL_ALT_LF][seg];      }      lvl_seg = (lvl_seg > 0) ? ((lvl_seg > 63) ? 63 : lvl_seg) : 0;    }     if (!mbd->mode_ref_lf_delta_enabled) {      /* we could get rid of this if we assume that deltas are set to       * zero when not in use; encoder always uses deltas       */      memset(lfi->lvl[seg][0], lvl_seg, 4 * 4);      continue;    }     /* INTRA_FRAME */    ref = INTRA_FRAME;     /* Apply delta for reference frame */    lvl_ref = lvl_seg + mbd->ref_lf_deltas[ref];     /* Apply delta for Intra modes */    mode = 0; /* B_PRED */    /* Only the split mode BPRED has a further special case */    lvl_mode = lvl_ref + mbd->mode_lf_deltas[mode];    /* clamp */    lvl_mode = (lvl_mode > 0) ? (lvl_mode > 63 ? 63 : lvl_mode) : 0;     lfi->lvl[seg][ref][mode] = lvl_mode;     mode = 1; /* all the rest of Intra modes */    /* clamp */    lvl_mode = (lvl_ref > 0) ? (lvl_ref > 63 ? 63 : lvl_ref) : 0;    lfi->lvl[seg][ref][mode] = lvl_mode;     /* LAST, GOLDEN, ALT */    for (ref = 1; ref < MAX_REF_FRAMES; ++ref) {      /* Apply delta for reference frame */      lvl_ref = lvl_seg + mbd->ref_lf_deltas[ref];       /* Apply delta for Inter modes */      for (mode = 1; mode < 4; ++mode) {        lvl_mode = lvl_ref + mbd->mode_lf_deltas[mode];        /* clamp */        lvl_mode = (lvl_mode > 0) ? (lvl_mode > 63 ? 63 : lvl_mode) : 0;         lfi->lvl[seg][ref][mode] = lvl_mode;      }    }  }} void vp8_loop_filter_row_normal(VP8_COMMON *cm, MODE_INFO *mode_info_context,                                int mb_row, int post_ystride, int post_uvstride,                                unsigned char *y_ptr, unsigned char *u_ptr,                                unsigned char *v_ptr) {  int mb_col;  int filter_level;  loop_filter_info_n *lfi_n = &cm->lf_info;  loop_filter_info lfi;  FRAME_TYPE frame_type = cm->frame_type;   for (mb_col = 0; mb_col < cm->mb_cols; ++mb_col) {    int skip_lf = (mode_info_context->mbmi.mode != B_PRED &&                   mode_info_context->mbmi.mode != SPLITMV &&                   mode_info_context->mbmi.mb_skip_coeff);     const int mode_index = lfi_n->mode_lf_lut[mode_info_context->mbmi.mode];    const int seg = mode_info_context->mbmi.segment_id;    const int ref_frame = mode_info_context->mbmi.ref_frame;     filter_level = lfi_n->lvl[seg][ref_frame][mode_index];     if (filter_level) {      const int hev_index = lfi_n->hev_thr_lut[frame_type][filter_level];      lfi.mblim = lfi_n->mblim[filter_level];      lfi.blim = lfi_n->blim[filter_level];      lfi.lim = lfi_n->lim[filter_level];      lfi.hev_thr = lfi_n->hev_thr[hev_index];       if (mb_col > 0)        vp8_loop_filter_mbv(y_ptr, u_ptr, v_ptr, post_ystride, post_uvstride,                            &lfi);       if (!skip_lf)        vp8_loop_filter_bv(y_ptr, u_ptr, v_ptr, post_ystride, post_uvstride,                           &lfi);       /* don't apply across umv border */      if (mb_row > 0)        vp8_loop_filter_mbh(y_ptr, u_ptr, v_ptr, post_ystride, post_uvstride,                            &lfi);       if (!skip_lf)        vp8_loop_filter_bh(y_ptr, u_ptr, v_ptr, post_ystride, post_uvstride,                           &lfi);    }     y_ptr += 16;    u_ptr += 8;    v_ptr += 8;     mode_info_context++; /* step to next MB */  }} void vp8_loop_filter_row_simple(VP8_COMMON *cm, MODE_INFO *mode_info_context,                                int mb_row, int post_ystride,                                unsigned char *y_ptr) {  int mb_col;  int filter_level;  loop_filter_info_n *lfi_n = &cm->lf_info;   for (mb_col = 0; mb_col < cm->mb_cols; ++mb_col) {    int skip_lf = (mode_info_context->mbmi.mode != B_PRED &&                   mode_info_context->mbmi.mode != SPLITMV &&                   mode_info_context->mbmi.mb_skip_coeff);     const int mode_index = lfi_n->mode_lf_lut[mode_info_context->mbmi.mode];    const int seg = mode_info_context->mbmi.segment_id;    const int ref_frame = mode_info_context->mbmi.ref_frame;     filter_level = lfi_n->lvl[seg][ref_frame][mode_index];     if (filter_level) {      if (mb_col > 0)        vp8_loop_filter_simple_mbv(y_ptr, post_ystride,                                   lfi_n->mblim[filter_level]);       if (!skip_lf)        vp8_loop_filter_simple_bv(y_ptr, post_ystride,                                  lfi_n->blim[filter_level]);       /* don't apply across umv border */      if (mb_row > 0)        vp8_loop_filter_simple_mbh(y_ptr, post_ystride,                                   lfi_n->mblim[filter_level]);       if (!skip_lf)        vp8_loop_filter_simple_bh(y_ptr, post_ystride,                                  lfi_n->blim[filter_level]);    }     y_ptr += 16;     mode_info_context++; /* step to next MB */  }}void vp8_loop_filter_frame(VP8_COMMON *cm, MACROBLOCKD *mbd, int frame_type) {  YV12_BUFFER_CONFIG *post = cm->frame_to_show;  loop_filter_info_n *lfi_n = &cm->lf_info;  loop_filter_info lfi;   int mb_row;  int mb_col;  int mb_rows = cm->mb_rows;  int mb_cols = cm->mb_cols;   int filter_level;   unsigned char *y_ptr, *u_ptr, *v_ptr;   /* Point at base of Mb MODE_INFO list */  const MODE_INFO *mode_info_context = cm->mi;  int post_y_stride = post->y_stride;  int post_uv_stride = post->uv_stride;   /* Initialize the loop filter for this frame. */  vp8_loop_filter_frame_init(cm, mbd, cm->filter_level);   /* Set up the buffer pointers */  y_ptr = post->y_buffer;  u_ptr = post->u_buffer;  v_ptr = post->v_buffer;   /* vp8_filter each macro block */  if (cm->filter_type == NORMAL_LOOPFILTER) {    for (mb_row = 0; mb_row < mb_rows; ++mb_row) {      for (mb_col = 0; mb_col < mb_cols; ++mb_col) {        int skip_lf = (mode_info_context->mbmi.mode != B_PRED &&                       mode_info_context->mbmi.mode != SPLITMV &&                       mode_info_context->mbmi.mb_skip_coeff);         const int mode_index = lfi_n->mode_lf_lut[mode_info_context->mbmi.mode];        const int seg = mode_info_context->mbmi.segment_id;        const int ref_frame = mode_info_context->mbmi.ref_frame;         filter_level = lfi_n->lvl[seg][ref_frame][mode_index];         if (filter_level) {          const int hev_index = lfi_n->hev_thr_lut[frame_type][filter_level];          lfi.mblim = lfi_n->mblim[filter_level];          lfi.blim = lfi_n->blim[filter_level];          lfi.lim = lfi_n->lim[filter_level];          lfi.hev_thr = lfi_n->hev_thr[hev_index];           if (mb_col > 0)            vp8_loop_filter_mbv(y_ptr, u_ptr, v_ptr, post_y_stride,                                post_uv_stride, &lfi);           if (!skip_lf)            vp8_loop_filter_bv(y_ptr, u_ptr, v_ptr, post_y_stride,                               post_uv_stride, &lfi);           /* don't apply across umv border */          if (mb_row > 0)            vp8_loop_filter_mbh(y_ptr, u_ptr, v_ptr, post_y_stride,                                post_uv_stride, &lfi);           if (!skip_lf)            vp8_loop_filter_bh(y_ptr, u_ptr, v_ptr, post_y_stride,                               post_uv_stride, &lfi);        }         y_ptr += 16;        u_ptr += 8;        v_ptr += 8;         mode_info_context++; /* step to next MB */      }      y_ptr += post_y_stride * 16 - post->y_width;      u_ptr += post_uv_stride * 8 - post->uv_width;      v_ptr += post_uv_stride * 8 - post->uv_width;       mode_info_context++; /* Skip border mb */    }  } else { /* SIMPLE_LOOPFILTER */    for (mb_row = 0; mb_row < mb_rows; ++mb_row) {      for (mb_col = 0; mb_col < mb_cols; ++mb_col) {        int skip_lf = (mode_info_context->mbmi.mode != B_PRED &&                       mode_info_context->mbmi.mode != SPLITMV &&                       mode_info_context->mbmi.mb_skip_coeff);         const int mode_index = lfi_n->mode_lf_lut[mode_info_context->mbmi.mode];        const int seg = mode_info_context->mbmi.segment_id;        const int ref_frame = mode_info_context->mbmi.ref_frame;         filter_level = lfi_n->lvl[seg][ref_frame][mode_index];        if (filter_level) {          const unsigned char *mblim = lfi_n->mblim[filter_level];          const unsigned char *blim = lfi_n->blim[filter_level];           if (mb_col > 0)            vp8_loop_filter_simple_mbv(y_ptr, post_y_stride, mblim);           if (!skip_lf) vp8_loop_filter_simple_bv(y_ptr, post_y_stride, blim);           /* don't apply across umv border */          if (mb_row > 0)            vp8_loop_filter_simple_mbh(y_ptr, post_y_stride, mblim);           if (!skip_lf) vp8_loop_filter_simple_bh(y_ptr, post_y_stride, blim);        }         y_ptr += 16;        u_ptr += 8;        v_ptr += 8;         mode_info_context++; /* step to next MB */      }      y_ptr += post_y_stride * 16 - post->y_width;      u_ptr += post_uv_stride * 8 - post->uv_width;      v_ptr += post_uv_stride * 8 - post->uv_width;       mode_info_context++; /* Skip border mb */    }  }} void vp8_loop_filter_frame_yonly(VP8_COMMON *cm, MACROBLOCKD *mbd,                                 int default_filt_lvl) {  YV12_BUFFER_CONFIG *post = cm->frame_to_show;   unsigned char *y_ptr;  int mb_row;  int mb_col;   loop_filter_info_n *lfi_n = &cm->lf_info;  loop_filter_info lfi;   int filter_level;  FRAME_TYPE frame_type = cm->frame_type;   /* Point at base of Mb MODE_INFO list */  const MODE_INFO *mode_info_context = cm->mi; #if 0    if(default_filt_lvl == 0) /* no filter applied */        return;#endif   /* Initialize the loop filter for this frame. */  vp8_loop_filter_frame_init(cm, mbd, default_filt_lvl);   /* Set up the buffer pointers */  y_ptr = post->y_buffer;   /* vp8_filter each macro block */  for (mb_row = 0; mb_row < cm->mb_rows; ++mb_row) {    for (mb_col = 0; mb_col < cm->mb_cols; ++mb_col) {      int skip_lf = (mode_info_context->mbmi.mode != B_PRED &&                     mode_info_context->mbmi.mode != SPLITMV &&                     mode_info_context->mbmi.mb_skip_coeff);       const int mode_index = lfi_n->mode_lf_lut[mode_info_context->mbmi.mode];      const int seg = mode_info_context->mbmi.segment_id;      const int ref_frame = mode_info_context->mbmi.ref_frame;       filter_level = lfi_n->lvl[seg][ref_frame][mode_index];       if (filter_level) {        if (cm->filter_type == NORMAL_LOOPFILTER) {          const int hev_index = lfi_n->hev_thr_lut[frame_type][filter_level];          lfi.mblim = lfi_n->mblim[filter_level];          lfi.blim = lfi_n->blim[filter_level];          lfi.lim = lfi_n->lim[filter_level];          lfi.hev_thr = lfi_n->hev_thr[hev_index];           if (mb_col > 0)            vp8_loop_filter_mbv(y_ptr, 0, 0, post->y_stride, 0, &lfi);           if (!skip_lf)            vp8_loop_filter_bv(y_ptr, 0, 0, post->y_stride, 0, &lfi);           /* don't apply across umv border */          if (mb_row > 0)            vp8_loop_filter_mbh(y_ptr, 0, 0, post->y_stride, 0, &lfi);           if (!skip_lf)            vp8_loop_filter_bh(y_ptr, 0, 0, post->y_stride, 0, &lfi);        } else {          if (mb_col > 0)            vp8_loop_filter_simple_mbv(y_ptr, post->y_stride,                                       lfi_n->mblim[filter_level]);           if (!skip_lf)            vp8_loop_filter_simple_bv(y_ptr, post->y_stride,                                      lfi_n->blim[filter_level]);           /* don't apply across umv border */          if (mb_row > 0)            vp8_loop_filter_simple_mbh(y_ptr, post->y_stride,                                       lfi_n->mblim[filter_level]);           if (!skip_lf)            vp8_loop_filter_simple_bh(y_ptr, post->y_stride,                                      lfi_n->blim[filter_level]);        }      }       y_ptr += 16;      mode_info_context++; /* step to next MB */    }     y_ptr += post->y_stride * 16 - post->y_width;    mode_info_context++; /* Skip border mb */  }} void vp8_loop_filter_partial_frame(VP8_COMMON *cm, MACROBLOCKD *mbd,                                   int default_filt_lvl) {  YV12_BUFFER_CONFIG *post = cm->frame_to_show;   unsigned char *y_ptr;  int mb_row;  int mb_col;  int mb_cols = post->y_width >> 4;  int mb_rows = post->y_height >> 4;   int linestocopy;   loop_filter_info_n *lfi_n = &cm->lf_info;  loop_filter_info lfi;   int filter_level;  FRAME_TYPE frame_type = cm->frame_type;   const MODE_INFO *mode_info_context; #if 0    if(default_filt_lvl == 0) /* no filter applied */        return;#endif   /* Initialize the loop filter for this frame. */  vp8_loop_filter_frame_init(cm, mbd, default_filt_lvl);

Lines 1–500 of 566. Load more