799 lines
28 KiB
C
799 lines
28 KiB
C
/*
|
|
* 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 "loopfilter.h"
|
|
#include "onyxc_int.h"
|
|
#include "vpx_mem/vpx_mem.h"
|
|
|
|
#include "vp8/common/seg_common.h"
|
|
|
|
typedef unsigned char uc;
|
|
|
|
prototype_loopfilter(vp8_loop_filter_horizontal_edge_c);
|
|
prototype_loopfilter(vp8_loop_filter_vertical_edge_c);
|
|
|
|
|
|
prototype_loopfilter(vp8_mbloop_filter_horizontal_edge_c);
|
|
prototype_loopfilter(vp8_mbloop_filter_vertical_edge_c);
|
|
|
|
prototype_simple_loopfilter(vp8_loop_filter_simple_horizontal_edge_c);
|
|
prototype_simple_loopfilter(vp8_loop_filter_simple_vertical_edge_c);
|
|
|
|
/* Horizontal MB filtering */
|
|
void vp8_loop_filter_mbh_c(unsigned char *y_ptr, unsigned char *u_ptr,
|
|
unsigned char *v_ptr, int y_stride, int uv_stride,
|
|
loop_filter_info *lfi)
|
|
{
|
|
vp8_mbloop_filter_horizontal_edge_c(y_ptr, y_stride, lfi->mblim, lfi->lim, lfi->hev_thr, 2);
|
|
|
|
if (u_ptr)
|
|
vp8_mbloop_filter_horizontal_edge_c(u_ptr, uv_stride, lfi->mblim, lfi->lim, lfi->hev_thr, 1);
|
|
|
|
if (v_ptr)
|
|
vp8_mbloop_filter_horizontal_edge_c(v_ptr, uv_stride, lfi->mblim, lfi->lim, lfi->hev_thr, 1);
|
|
}
|
|
|
|
/* Vertical MB Filtering */
|
|
void vp8_loop_filter_mbv_c(unsigned char *y_ptr, unsigned char *u_ptr,
|
|
unsigned char *v_ptr, int y_stride, int uv_stride,
|
|
loop_filter_info *lfi)
|
|
{
|
|
vp8_mbloop_filter_vertical_edge_c(y_ptr, y_stride, lfi->mblim, lfi->lim, lfi->hev_thr, 2);
|
|
|
|
if (u_ptr)
|
|
vp8_mbloop_filter_vertical_edge_c(u_ptr, uv_stride, lfi->mblim, lfi->lim, lfi->hev_thr, 1);
|
|
|
|
if (v_ptr)
|
|
vp8_mbloop_filter_vertical_edge_c(v_ptr, uv_stride, lfi->mblim, lfi->lim, lfi->hev_thr, 1);
|
|
}
|
|
|
|
/* Horizontal B Filtering */
|
|
void vp8_loop_filter_bh_c(unsigned char *y_ptr, unsigned char *u_ptr,
|
|
unsigned char *v_ptr, int y_stride, int uv_stride,
|
|
loop_filter_info *lfi)
|
|
{
|
|
vp8_loop_filter_horizontal_edge_c(y_ptr + 4 * y_stride, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2);
|
|
vp8_loop_filter_horizontal_edge_c(y_ptr + 8 * y_stride, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2);
|
|
vp8_loop_filter_horizontal_edge_c(y_ptr + 12 * y_stride, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2);
|
|
|
|
if (u_ptr)
|
|
vp8_loop_filter_horizontal_edge_c(u_ptr + 4 * uv_stride, uv_stride, lfi->blim, lfi->lim, lfi->hev_thr, 1);
|
|
|
|
if (v_ptr)
|
|
vp8_loop_filter_horizontal_edge_c(v_ptr + 4 * uv_stride, uv_stride, lfi->blim, lfi->lim, lfi->hev_thr, 1);
|
|
}
|
|
|
|
void vp8_loop_filter_bh8x8_c(unsigned char *y_ptr, unsigned char *u_ptr,
|
|
unsigned char *v_ptr, int y_stride, int uv_stride,
|
|
loop_filter_info *lfi)
|
|
{
|
|
vp8_mbloop_filter_horizontal_edge_c(
|
|
y_ptr + 8 * y_stride, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2);
|
|
}
|
|
|
|
void vp8_loop_filter_bhs_c(unsigned char *y_ptr, int y_stride,
|
|
const unsigned char *blimit)
|
|
{
|
|
vp8_loop_filter_simple_horizontal_edge_c(y_ptr + 4 * y_stride, y_stride, blimit);
|
|
vp8_loop_filter_simple_horizontal_edge_c(y_ptr + 8 * y_stride, y_stride, blimit);
|
|
vp8_loop_filter_simple_horizontal_edge_c(y_ptr + 12 * y_stride, y_stride, blimit);
|
|
}
|
|
|
|
/* Vertical B Filtering */
|
|
void vp8_loop_filter_bv_c(unsigned char *y_ptr, unsigned char *u_ptr,
|
|
unsigned char *v_ptr, int y_stride, int uv_stride,
|
|
loop_filter_info *lfi)
|
|
{
|
|
vp8_loop_filter_vertical_edge_c(y_ptr + 4, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2);
|
|
vp8_loop_filter_vertical_edge_c(y_ptr + 8, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2);
|
|
vp8_loop_filter_vertical_edge_c(y_ptr + 12, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2);
|
|
|
|
if (u_ptr)
|
|
vp8_loop_filter_vertical_edge_c(u_ptr + 4, uv_stride, lfi->blim, lfi->lim, lfi->hev_thr, 1);
|
|
|
|
if (v_ptr)
|
|
vp8_loop_filter_vertical_edge_c(v_ptr + 4, uv_stride, lfi->blim, lfi->lim, lfi->hev_thr, 1);
|
|
}
|
|
|
|
void vp8_loop_filter_bv8x8_c(unsigned char *y_ptr, unsigned char *u_ptr,
|
|
unsigned char *v_ptr, int y_stride, int uv_stride,
|
|
loop_filter_info *lfi)
|
|
{
|
|
vp8_mbloop_filter_vertical_edge_c(
|
|
y_ptr + 8, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2);
|
|
}
|
|
|
|
void vp8_loop_filter_bvs_c(unsigned char *y_ptr, int y_stride,
|
|
const unsigned char *blimit)
|
|
{
|
|
vp8_loop_filter_simple_vertical_edge_c(y_ptr + 4, y_stride, blimit);
|
|
vp8_loop_filter_simple_vertical_edge_c(y_ptr + 8, y_stride, blimit);
|
|
vp8_loop_filter_simple_vertical_edge_c(y_ptr + 12, y_stride, blimit);
|
|
}
|
|
|
|
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[I8X8_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;
|
|
|
|
vpx_memset(lfi->lim[i], block_inside_limit, SIMD_WIDTH);
|
|
vpx_memset(lfi->blim[i], (2 * filt_lvl + block_inside_limit),
|
|
SIMD_WIDTH);
|
|
vpx_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++)
|
|
{
|
|
vpx_memset(lfi->hev_thr[i], i, SIMD_WIDTH);
|
|
}
|
|
}
|
|
|
|
void vp8_loop_filter_frame_init(VP8_COMMON *cm,
|
|
MACROBLOCKD *xd,
|
|
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;
|
|
|
|
|
|
// Set the baseline filter values for each segment
|
|
if ( segfeature_active( xd, seg, SEG_LVL_ALT_LF ) )
|
|
{
|
|
/* Abs value */
|
|
if (xd->mb_segment_abs_delta == SEGMENT_ABSDATA)
|
|
{
|
|
lvl_seg = get_segdata( xd, seg, SEG_LVL_ALT_LF );
|
|
}
|
|
else /* Delta Value */
|
|
{
|
|
lvl_seg += get_segdata( xd, seg, SEG_LVL_ALT_LF );;
|
|
lvl_seg = (lvl_seg > 0) ? ((lvl_seg > 63) ? 63: lvl_seg) : 0;
|
|
}
|
|
}
|
|
|
|
if (!xd->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
|
|
*/
|
|
vpx_memset(lfi->lvl[seg][0], lvl_seg, 4 * 4 );
|
|
continue;
|
|
}
|
|
|
|
lvl_ref = lvl_seg;
|
|
|
|
/* INTRA_FRAME */
|
|
ref = INTRA_FRAME;
|
|
|
|
/* Apply delta for reference frame */
|
|
lvl_ref += xd->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 + xd->mode_lf_deltas[mode];
|
|
lvl_mode = (lvl_mode > 0) ? (lvl_mode > 63 ? 63 : lvl_mode) : 0; /* clamp */
|
|
|
|
lfi->lvl[seg][ref][mode] = lvl_mode;
|
|
|
|
mode = 1; /* all the rest of Intra modes */
|
|
lvl_mode = (lvl_ref > 0) ? (lvl_ref > 63 ? 63 : lvl_ref) : 0; /* clamp */
|
|
lfi->lvl[seg][ref][mode] = lvl_mode;
|
|
|
|
/* LAST, GOLDEN, ALT */
|
|
for(ref = 1; ref < MAX_REF_FRAMES; ref++)
|
|
{
|
|
int lvl_ref = lvl_seg;
|
|
|
|
/* Apply delta for reference frame */
|
|
lvl_ref += xd->ref_lf_deltas[ref];
|
|
|
|
/* Apply delta for Inter modes */
|
|
for (mode = 1; mode < 4; mode++)
|
|
{
|
|
lvl_mode = lvl_ref + xd->mode_lf_deltas[mode];
|
|
lvl_mode = (lvl_mode > 0) ? (lvl_mode > 63 ? 63 : lvl_mode) : 0; /* clamp */
|
|
|
|
lfi->lvl[seg][ref][mode] = lvl_mode;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void vp8_loop_filter_frame
|
|
(
|
|
VP8_COMMON *cm,
|
|
MACROBLOCKD *xd
|
|
)
|
|
{
|
|
YV12_BUFFER_CONFIG *post = cm->frame_to_show;
|
|
loop_filter_info_n *lfi_n = &cm->lf_info;
|
|
loop_filter_info lfi;
|
|
|
|
FRAME_TYPE frame_type = cm->frame_type;
|
|
|
|
int mb_row;
|
|
int mb_col;
|
|
|
|
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;
|
|
|
|
/* Initialize the loop filter for this frame. */
|
|
vp8_loop_filter_frame_init(cm, xd, 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 */
|
|
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 != I8X8_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;
|
|
int tx_type = mode_info_context->mbmi.txfm_size;
|
|
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_c
|
|
(y_ptr, u_ptr, v_ptr, post->y_stride, post->uv_stride, &lfi);
|
|
|
|
if (!skip_lf)
|
|
{
|
|
if(tx_type == TX_8X8)
|
|
vp8_loop_filter_bv8x8_c
|
|
(y_ptr, u_ptr, v_ptr, post->y_stride, post->uv_stride, &lfi);
|
|
else
|
|
LF_INVOKE(&cm->rtcd.loopfilter, normal_b_v)
|
|
(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_c
|
|
(y_ptr, u_ptr, v_ptr, post->y_stride, post->uv_stride, &lfi);
|
|
|
|
if (!skip_lf)
|
|
{
|
|
if(tx_type == TX_8X8)
|
|
vp8_loop_filter_bh8x8_c
|
|
(y_ptr, u_ptr, v_ptr, post->y_stride, post->uv_stride, &lfi);
|
|
else
|
|
LF_INVOKE(&cm->rtcd.loopfilter, normal_b_h)
|
|
(y_ptr, u_ptr, v_ptr, post->y_stride, post->uv_stride, &lfi);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (mb_col > 0)
|
|
LF_INVOKE(&cm->rtcd.loopfilter, simple_mb_v)
|
|
(y_ptr, post->y_stride, lfi_n->mblim[filter_level]);
|
|
|
|
if (!skip_lf)
|
|
LF_INVOKE(&cm->rtcd.loopfilter, simple_b_v)
|
|
(y_ptr, post->y_stride, lfi_n->blim[filter_level]);
|
|
|
|
/* don't apply across umv border */
|
|
if (mb_row > 0)
|
|
LF_INVOKE(&cm->rtcd.loopfilter, simple_mb_h)
|
|
(y_ptr, post->y_stride, lfi_n->mblim[filter_level]);
|
|
|
|
if (!skip_lf)
|
|
LF_INVOKE(&cm->rtcd.loopfilter, simple_b_h)
|
|
(y_ptr, post->y_stride, lfi_n->blim[filter_level]);
|
|
}
|
|
}
|
|
|
|
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 *xd,
|
|
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, xd, 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 != I8X8_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;
|
|
int tx_type = mode_info_context->mbmi.txfm_size;
|
|
|
|
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_c
|
|
(y_ptr, 0, 0, post->y_stride, 0, &lfi);
|
|
|
|
if (!skip_lf)
|
|
{
|
|
if(tx_type == TX_8X8)
|
|
vp8_loop_filter_bv8x8_c
|
|
(y_ptr, 0, 0, post->y_stride, 0, &lfi);
|
|
else
|
|
LF_INVOKE(&cm->rtcd.loopfilter, normal_b_v)
|
|
(y_ptr, 0, 0, post->y_stride, 0, &lfi);
|
|
}
|
|
|
|
/* don't apply across umv border */
|
|
if (mb_row > 0)
|
|
vp8_loop_filter_mbh_c
|
|
(y_ptr, 0, 0, post->y_stride, 0, &lfi);
|
|
|
|
if (!skip_lf)
|
|
{
|
|
if(tx_type == TX_8X8)
|
|
vp8_loop_filter_bh8x8_c
|
|
(y_ptr, 0, 0, post->y_stride, 0, &lfi);
|
|
else
|
|
LF_INVOKE(&cm->rtcd.loopfilter, normal_b_h)
|
|
(y_ptr, 0, 0, post->y_stride, 0, &lfi);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (mb_col > 0)
|
|
LF_INVOKE(&cm->rtcd.loopfilter, simple_mb_v)
|
|
(y_ptr, post->y_stride, lfi_n->mblim[filter_level]);
|
|
|
|
if (!skip_lf)
|
|
LF_INVOKE(&cm->rtcd.loopfilter, simple_b_v)
|
|
(y_ptr, post->y_stride, lfi_n->blim[filter_level]);
|
|
|
|
/* don't apply across umv border */
|
|
if (mb_row > 0)
|
|
LF_INVOKE(&cm->rtcd.loopfilter, simple_mb_h)
|
|
(y_ptr, post->y_stride, lfi_n->mblim[filter_level]);
|
|
|
|
if (!skip_lf)
|
|
LF_INVOKE(&cm->rtcd.loopfilter, simple_b_h)
|
|
(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 */
|
|
}
|
|
|
|
}
|
|
#if CONFIG_FEATUREUPDATES
|
|
// TODO: Multiple copies of loop filtering code should be pruned and
|
|
// cut down. This just adds yet another so that I can do an if
|
|
// on segment.
|
|
void vp8_loop_filter_frame_segment(VP8_COMMON *cm, MACROBLOCKD *xd,
|
|
int default_filt_lvl, int segment)
|
|
{
|
|
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, xd, 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 != I8X8_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];
|
|
|
|
// check if this mb has filtering applied
|
|
// and then whether it is the right segment or
|
|
// if not whether the passed in segment is 0 and this
|
|
// segment has no alt lf
|
|
|
|
// TODO: Make this work for when segment 0 has the alt lv enabled
|
|
if (filter_level
|
|
&& (seg == segment
|
|
|| (!segfeature_active(xd, seg, SEG_LVL_ALT_LF)
|
|
&& segment == 0)))
|
|
{
|
|
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_c(y_ptr, 0, 0, post->y_stride, 0,
|
|
&lfi);
|
|
|
|
if (!skip_lf)
|
|
LF_INVOKE(&cm->rtcd.loopfilter, normal_b_v)(
|
|
y_ptr, 0, 0, post->y_stride, 0, &lfi);
|
|
|
|
/* don't apply across umv border */
|
|
if (mb_row > 0)
|
|
vp8_loop_filter_mbh_c(y_ptr, 0, 0, post->y_stride, 0,
|
|
&lfi);
|
|
|
|
if (!skip_lf)
|
|
LF_INVOKE(&cm->rtcd.loopfilter, normal_b_h)(
|
|
y_ptr, 0, 0, post->y_stride, 0, &lfi);
|
|
}
|
|
else
|
|
{
|
|
if (mb_col > 0)
|
|
LF_INVOKE(&cm->rtcd.loopfilter, simple_mb_v)(
|
|
y_ptr, post->y_stride,
|
|
lfi_n->mblim[filter_level]);
|
|
|
|
if (!skip_lf)
|
|
LF_INVOKE(&cm->rtcd.loopfilter, simple_b_v)(
|
|
y_ptr, post->y_stride,
|
|
lfi_n->blim[filter_level]);
|
|
|
|
/* don't apply across umv border */
|
|
if (mb_row > 0)
|
|
LF_INVOKE(&cm->rtcd.loopfilter, simple_mb_h)(
|
|
y_ptr, post->y_stride,
|
|
lfi_n->mblim[filter_level]);
|
|
|
|
if (!skip_lf)
|
|
LF_INVOKE(&cm->rtcd.loopfilter, simple_b_h)(
|
|
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 */
|
|
}
|
|
|
|
}
|
|
#endif
|
|
|
|
void vp8_loop_filter_partial_frame
|
|
(
|
|
VP8_COMMON *cm,
|
|
MACROBLOCKD *xd,
|
|
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 linestocopy, i;
|
|
|
|
loop_filter_info_n *lfi_n = &cm->lf_info;
|
|
loop_filter_info lfi;
|
|
|
|
int filter_level;
|
|
int alt_flt_enabled = xd->segmentation_enabled;
|
|
FRAME_TYPE frame_type = cm->frame_type;
|
|
|
|
const MODE_INFO *mode_info_context;
|
|
|
|
int lvl_seg[MAX_MB_SEGMENTS];
|
|
|
|
mode_info_context = cm->mi + (post->y_height >> 5) * (mb_cols + 1);
|
|
|
|
/* 3 is a magic number. 4 is probably magic too */
|
|
linestocopy = (post->y_height >> (4 + 3));
|
|
|
|
if (linestocopy < 1)
|
|
linestocopy = 1;
|
|
|
|
linestocopy <<= 4;
|
|
|
|
/* Note the baseline filter values for each segment */
|
|
/* See vp8_loop_filter_frame_init. Rather than call that for each change
|
|
* to default_filt_lvl, copy the relevant calculation here.
|
|
*/
|
|
if (alt_flt_enabled)
|
|
{
|
|
for (i = 0; i < MAX_MB_SEGMENTS; i++)
|
|
{ /* Abs value */
|
|
if (xd->mb_segment_abs_delta == SEGMENT_ABSDATA)
|
|
{
|
|
lvl_seg[i] = get_segdata( xd, i, SEG_LVL_ALT_LF );
|
|
}
|
|
/* Delta Value */
|
|
else
|
|
{
|
|
lvl_seg[i] = default_filt_lvl +
|
|
get_segdata( xd, i, SEG_LVL_ALT_LF );
|
|
lvl_seg[i] = (lvl_seg[i] > 0) ?
|
|
((lvl_seg[i] > 63) ? 63: lvl_seg[i]) : 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Set up the buffer pointers */
|
|
y_ptr = post->y_buffer + (post->y_height >> 5) * 16 * post->y_stride;
|
|
|
|
/* vp8_filter each macro block */
|
|
for (mb_row = 0; mb_row<(linestocopy >> 4); 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 != I8X8_PRED &&
|
|
mode_info_context->mbmi.mode != SPLITMV &&
|
|
mode_info_context->mbmi.mb_skip_coeff);
|
|
|
|
if (alt_flt_enabled)
|
|
filter_level = lvl_seg[mode_info_context->mbmi.segment_id];
|
|
else
|
|
filter_level = default_filt_lvl;
|
|
|
|
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)
|
|
LF_INVOKE(&cm->rtcd.loopfilter, normal_mb_v)
|
|
(y_ptr, 0, 0, post->y_stride, 0, &lfi);
|
|
|
|
if (!skip_lf)
|
|
LF_INVOKE(&cm->rtcd.loopfilter, normal_b_v)
|
|
(y_ptr, 0, 0, post->y_stride, 0, &lfi);
|
|
|
|
LF_INVOKE(&cm->rtcd.loopfilter, normal_mb_h)
|
|
(y_ptr, 0, 0, post->y_stride, 0, &lfi);
|
|
|
|
if (!skip_lf)
|
|
LF_INVOKE(&cm->rtcd.loopfilter, normal_b_h)
|
|
(y_ptr, 0, 0, post->y_stride, 0, &lfi);
|
|
}
|
|
else
|
|
{
|
|
if (mb_col > 0)
|
|
LF_INVOKE(&cm->rtcd.loopfilter, simple_mb_v)
|
|
(y_ptr, post->y_stride, lfi_n->mblim[filter_level]);
|
|
|
|
if (!skip_lf)
|
|
LF_INVOKE(&cm->rtcd.loopfilter, simple_b_v)
|
|
(y_ptr, post->y_stride, lfi_n->blim[filter_level]);
|
|
|
|
LF_INVOKE(&cm->rtcd.loopfilter, simple_mb_h)
|
|
(y_ptr, post->y_stride, lfi_n->mblim[filter_level]);
|
|
|
|
if (!skip_lf)
|
|
LF_INVOKE(&cm->rtcd.loopfilter, simple_b_h)
|
|
(y_ptr, post->y_stride, lfi_n->blim[filter_level]);
|
|
}
|
|
}
|
|
|
|
y_ptr += 16;
|
|
mode_info_context += 1; /* step to next MB */
|
|
}
|
|
|
|
y_ptr += post->y_stride * 16 - post->y_width;
|
|
mode_info_context += 1; /* Skip border mb */
|
|
}
|
|
}
|