mozilla
/
aom
зеркало из
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Merge the new loopfilter experiment 

Change-Id: I524ba98841f2e1850e3276ac365c501cea31546d
This commit is contained in:
John Koleszar 2013-06-07 00:54:28 -07:00 коммит произвёл Gerrit Code Review
Родитель c37a1e5ef2
Коммит 44db42c114
4 изменённых файлов: 0 добавлений и 557 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

1
configure поставляемый
Просмотреть файл

@ -243,7 +243,6 @@ EXPERIMENT_LIST="
non420
alpha
balanced_coeftree
new_loopfilter
"
CONFIG_LIST="
external_build

393
vp9/common/vp9_loopfilter.c
Просмотреть файл

@ -152,398 +152,6 @@ void vp9_loop_filter_frame_init(VP9_COMMON *cm,
}
}
#if !CONFIG_NEW_LOOPFILTER
// Determine if we should skip inner-MB loop filtering within a MB
// The current condition is that the loop filtering is skipped only
// the MB uses a prediction size of 16x16 and either 16x16 transform
// is used or there is no residue at all.
static int mb_lf_skip(const MB_MODE_INFO *const mbmi) {
const int skip_coef = mbmi->mb_skip_coeff;
const int tx_size = mbmi->txfm_size;
return mbmi->sb_type >= BLOCK_SIZE_MB16X16 &&
(tx_size >= TX_16X16 || skip_coef);
}
// Determine if we should skip MB loop filtering on a MB edge within
// a superblock, the current condition is that MB loop filtering is
// skipped only when both MBs do not use inner MB loop filtering, and
// same motion vector with same reference frame
static int sb_mb_lf_skip(const MODE_INFO *const mip0,
const MODE_INFO *const mip1) {
const MB_MODE_INFO *mbmi0 = &mip0->mbmi;
const MB_MODE_INFO *mbmi1 = &mip1->mbmi;
return mb_lf_skip(mbmi0) && mb_lf_skip(mbmi1) &&
mbmi0->ref_frame[0] != INTRA_FRAME &&
mbmi1->ref_frame[0] != INTRA_FRAME;
}
static void lpf_mb(VP9_COMMON *cm, const MODE_INFO *mi,
int do_left_mb_v, int do_above_mb_h,
int do_left_mbuv_v, int do_above_mbuv_h,
int mb_row, int mb_col,
uint8_t *y_ptr, uint8_t *u_ptr, uint8_t *v_ptr,
int y_stride, int uv_stride) {
loop_filter_info_n *lfi_n = &cm->lf_info;
struct loop_filter_info lfi;
int mode = mi->mbmi.mode;
int mode_index = lfi_n->mode_lf_lut[mode];
int seg = mi->mbmi.segment_id;
MV_REFERENCE_FRAME ref_frame = mi->mbmi.ref_frame[0];
int filter_level = lfi_n->lvl[seg][ref_frame][mode_index];
if (filter_level) {
const int skip_lf = mb_lf_skip(&mi->mbmi);
const int tx_size = mi->mbmi.txfm_size;
const int hev_index = filter_level >> 4;
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 (do_above_mb_h) {
if (tx_size >= TX_16X16)
vp9_lpf_mbh_w(y_ptr,
do_above_mbuv_h ? u_ptr : NULL,
do_above_mbuv_h ? v_ptr : NULL,
y_stride, uv_stride, &lfi);
else
vp9_loop_filter_mbh(y_ptr, u_ptr, v_ptr, y_stride, uv_stride, &lfi);
}
if (!skip_lf && mb_row * 2 + 1 < cm->mi_rows) {
if (tx_size >= TX_8X8) {
if (tx_size == TX_8X8 &&
mi->mbmi.sb_type < BLOCK_SIZE_MB16X16)
vp9_loop_filter_bh8x8(y_ptr, u_ptr, v_ptr,
y_stride, uv_stride, &lfi);
else
vp9_loop_filter_bh8x8(y_ptr, NULL, NULL,
y_stride, uv_stride, &lfi);
} else {
vp9_loop_filter_bh(y_ptr, u_ptr, v_ptr,
y_stride, uv_stride, &lfi);
}
}
if (do_left_mb_v) {
if (tx_size >= TX_16X16)
vp9_lpf_mbv_w(y_ptr,
do_left_mbuv_v ? u_ptr : NULL,
do_left_mbuv_v ? v_ptr : NULL,
y_stride, uv_stride, &lfi);
else
vp9_loop_filter_mbv(y_ptr, u_ptr, v_ptr, y_stride, uv_stride, &lfi);
}
if (!skip_lf && mb_col * 2 + 1 < cm->mi_cols) {
if (tx_size >= TX_8X8) {
if (tx_size == TX_8X8 &&
mi->mbmi.sb_type < BLOCK_SIZE_MB16X16)
vp9_loop_filter_bv8x8(y_ptr, u_ptr, v_ptr,
y_stride, uv_stride, &lfi);
else
vp9_loop_filter_bv8x8(y_ptr, NULL, NULL,
y_stride, uv_stride, &lfi);
} else {
vp9_loop_filter_bv(y_ptr, u_ptr, v_ptr,
y_stride, uv_stride, &lfi);
}
}
}
}
static void lpf_sb32(VP9_COMMON *cm, const MODE_INFO *mode_info_context,
int mb_row, int mb_col,
uint8_t *y_ptr, uint8_t *u_ptr, uint8_t *v_ptr,
int y_stride, int uv_stride,
int y_only) {
BLOCK_SIZE_TYPE sb_type = mode_info_context->mbmi.sb_type;
const int wbl = b_width_log2(sb_type), hbl = b_height_log2(sb_type);
TX_SIZE tx_size = mode_info_context->mbmi.txfm_size;
int do_left_v, do_above_h;
int do_left_v_mbuv, do_above_h_mbuv;
int mis = cm->mode_info_stride;
const MODE_INFO *mi;
// process 1st MB top-left
mi = mode_info_context;
do_left_v = (mb_col > 0);
do_above_h = (mb_row > 0);
do_left_v_mbuv = !(sb_type >= BLOCK_SIZE_SB64X64 &&
tx_size >= TX_32X32 && (mb_col & 2));
do_above_h_mbuv = !(sb_type >= BLOCK_SIZE_SB64X64 &&
tx_size >= TX_32X32 && (mb_row & 2));
lpf_mb(cm, mi, do_left_v, do_above_h,
do_left_v_mbuv, do_above_h_mbuv,
mb_row, mb_col,
y_ptr,
y_only? 0 : u_ptr,
y_only? 0 : v_ptr,
y_stride, uv_stride);
// process 2nd MB top-right
mi = mode_info_context + 2;
do_left_v = !(wbl >= 3 /* 32x16 or >=32x32 */ && (tx_size >= TX_32X32 ||
sb_mb_lf_skip(mode_info_context, mi)));
do_above_h = (mb_row > 0);
do_left_v_mbuv = !(wbl >= 3 /* 32x16 or >=32x32 */ && (tx_size >= TX_16X16 ||
sb_mb_lf_skip(mode_info_context, mi)));
do_above_h_mbuv = !(sb_type >= BLOCK_SIZE_SB64X64 &&
tx_size >= TX_32X32 && (mb_row & 2));
lpf_mb(cm, mi, do_left_v, do_above_h,
do_left_v_mbuv, do_above_h_mbuv,
mb_row, mb_col + 1,
y_ptr + 16,
y_only ? 0 : (u_ptr + 8),
y_only ? 0 : (v_ptr + 8),
y_stride, uv_stride);
// process 3rd MB bottom-left
mi = mode_info_context + (mis << 1);
do_left_v = (mb_col > 0);
do_above_h = !(hbl >= 3 /* 16x32 or >=32x32 */ && (tx_size >= TX_32X32 ||
sb_mb_lf_skip(mode_info_context, mi)));
do_left_v_mbuv = !(sb_type >= BLOCK_SIZE_SB64X64 &&
tx_size >= TX_32X32 && (mb_col & 2));
do_above_h_mbuv = !(hbl >= 3 /* 16x32 or >=32x32 */ && (tx_size >= TX_16X16 ||
sb_mb_lf_skip(mode_info_context, mi)));
lpf_mb(cm, mi, do_left_v, do_above_h,
do_left_v_mbuv, do_above_h_mbuv,
mb_row + 1, mb_col,
y_ptr + 16 * y_stride,
y_only ? 0 : (u_ptr + 8 * uv_stride),
y_only ? 0 : (v_ptr + 8 * uv_stride),
y_stride, uv_stride);
// process 4th MB bottom right
mi = mode_info_context + ((mis + 1) << 1);
do_left_v = !(wbl >= 3 /* 32x16 or >=32x32 */ && (tx_size >= TX_32X32 ||
sb_mb_lf_skip(mi - 2, mi)));
do_above_h = !(hbl >= 3 /* 16x32 or >=32x32 */ && (tx_size >= TX_32X32 ||
sb_mb_lf_skip(mode_info_context + 2, mi)));
do_left_v_mbuv = (wbl >= 3 /* 32x16 or >=32x32 */ && (tx_size >= TX_16X16 ||
sb_mb_lf_skip(mi - 2, mi)));
do_above_h_mbuv = !(hbl >= 3 /* 16x32 or >=32x32 */ && (tx_size >= TX_16X16 ||
sb_mb_lf_skip(mode_info_context + 2, mi)));
lpf_mb(cm, mi, do_left_v, do_above_h,
do_left_v_mbuv, do_above_h_mbuv,
mb_row + 1, mb_col + 1,
y_ptr + 16 * y_stride + 16,
y_only ? 0 : (u_ptr + 8 * uv_stride + 8),
y_only ? 0 : (v_ptr + 8 * uv_stride + 8),
y_stride, uv_stride);
}
static void lpf_sb64(VP9_COMMON *cm, const MODE_INFO *mode_info_context,
int mb_row, int mb_col,
uint8_t *y_ptr, uint8_t *u_ptr, uint8_t *v_ptr,
int y_stride, int uv_stride,
int y_only) {
lpf_sb32(cm, mode_info_context, mb_row, mb_col,
y_ptr, u_ptr, v_ptr,
y_stride, uv_stride, y_only);
lpf_sb32(cm, mode_info_context + 4, mb_row, mb_col + 2,
y_ptr + 32, u_ptr + 16, v_ptr + 16,
y_stride, uv_stride, y_only);
lpf_sb32(cm, mode_info_context + cm->mode_info_stride * 4,
mb_row + 2, mb_col,
y_ptr + 32 * y_stride,
u_ptr + 16 * uv_stride,
v_ptr + 16 * uv_stride,
y_stride, uv_stride, y_only);
lpf_sb32(cm, mode_info_context + cm->mode_info_stride * 4 + 4,
mb_row + 2, mb_col + 2,
y_ptr + 32 * y_stride + 32,
u_ptr + 16 * uv_stride + 16,
v_ptr + 16 * uv_stride + 16,
y_stride, uv_stride, y_only);
}
void vp9_loop_filter_frame(VP9_COMMON *cm,
MACROBLOCKD *xd,
int frame_filter_level,
int y_only) {
YV12_BUFFER_CONFIG *post = cm->frame_to_show;
int mb_row, mb_col;
const int sb64_rows = cm->mb_rows / 4;
const int sb64_cols = cm->mb_cols / 4;
const int extra_sb32_row = (cm->mb_rows & 2) != 0;
const int extra_sb32_col = (cm->mb_cols & 2) != 0;
const int extra_mb_col = cm->mb_cols & 1;
const int extra_mb_row = cm->mb_rows & 1;
// Set up the buffer pointers
uint8_t *y_ptr = post->y_buffer;
uint8_t *u_ptr = y_only ? 0 : post->u_buffer;
uint8_t *v_ptr = y_only ? 0 : post->v_buffer;
// Point at base of Mb MODE_INFO list
const MODE_INFO *mode_info_context = cm->mi;
const MODE_INFO *mi;
const int mis = cm->mode_info_stride;
const int y_stride = post->y_stride;
const int uv_stride = post->uv_stride;
// These two flags signal if MB left edge and above edge
// should be filtered using MB edge filter. Currently, MB
// edge filtering is not applied on MB edge internal to a
// 32x32 superblock if:
// 1) SB32 is using 32x32 prediction and 32x32 transform
// 2) SB32 is using 32x32 prediction and 16x16 transform
// but all coefficients are zero.
// MB edges are on 32x32 superblock boundary are always
// filtered except on image frame boundary.
int do_left_v, do_above_h;
// These two flags signal if MB UV left edge and above edge
// should be filtered using MB edge filter. Currently, MB
// edge filtering is not applied for MB edges internal to
// a 32x32 superblock if:
// 1) SB32 is using 32x32 prediction and 32x32 transform
// 2) SB32 is using 32x32 prediction and 16x16 transform
// but all coefficients are zero.
// 3) SB32 UV edges internal to a SB64 and 32x32 transform
// is used, i.e. UV is doing 32x32 transform hence no
// transform boundary exists inside the SB64 for UV
int do_left_v_mbuv, do_above_h_mbuv;
// Initialize the loop filter for this frame.
vp9_loop_filter_frame_init(cm, xd, frame_filter_level);
// vp9_filter each 64x64 SB
// For each SB64: the 4 SB32 are filtered in raster scan order
// For each SB32: the 4 MBs are filtered in raster scan order
// For each MB: the left and above MB edges as well as the
// internal block edges are processed together
for (mb_row = 0; mb_row < sb64_rows * 4; mb_row += 4) {
for (mb_col = 0; mb_col < sb64_cols * 4; mb_col += 4) {
lpf_sb64(cm, mode_info_context, mb_row, mb_col,
y_ptr, u_ptr, v_ptr,
y_stride, uv_stride, y_only);
y_ptr += 64;
u_ptr = y_only? 0 : u_ptr + 32;
v_ptr = y_only? 0 : v_ptr + 32;
mode_info_context += 8; // step to next SB64
}
if (extra_sb32_col) {
// process 2 SB32s in the extra SB32 col
lpf_sb32(cm, mode_info_context, mb_row, mb_col,
y_ptr, u_ptr, v_ptr,
y_stride, uv_stride, y_only);
lpf_sb32(cm, mode_info_context + mis * 4,
mb_row + 2, mb_col,
y_ptr + 32 * y_stride,
u_ptr + 16 * uv_stride,
v_ptr + 16 * uv_stride,
y_stride, uv_stride, y_only);
y_ptr += 32;
u_ptr = y_only? 0 : u_ptr + 16;
v_ptr = y_only? 0 : v_ptr + 16;
mode_info_context += 4; // step to next SB32
mb_col += 2;
}
if (extra_mb_col) {
// process 4 MB in the extra MB col
int k;
for (k = 0; k < 4; ++k) {
mi = mode_info_context + (mis << 1) * k;
do_left_v = (mb_col > 0);
do_above_h = k == 0 ? mb_row > 0 : 1;
do_left_v_mbuv = 1;
do_above_h_mbuv = 1;
lpf_mb(cm, mi, do_left_v, do_above_h,
do_left_v_mbuv, do_above_h_mbuv,
mb_row + k, mb_col,
y_ptr + (k * 16) * y_stride,
y_only ? 0 : (u_ptr + (k * 8) * uv_stride),
y_only ? 0 : (v_ptr + (k * 8) * uv_stride),
y_stride, uv_stride);
}
y_ptr += 16;
u_ptr = y_only? 0 : u_ptr + 8;
v_ptr = y_only? 0 : v_ptr + 8;
mode_info_context += 2; // step to next MB
}
// move pointers to the begining of next sb64 row
y_ptr += y_stride * 64 - cm->mb_cols * 16;
if (!y_only) {
u_ptr += uv_stride * 32 - cm->mb_cols * 8;
v_ptr += uv_stride * 32 - cm->mb_cols * 8;
}
/* skip to next SB64 row */
mode_info_context += mis * 8 - cm->mb_cols * 2;
}
if (extra_sb32_row) {
const int sb32_cols = sb64_cols * 2 + extra_sb32_col;
for (mb_col = 0; mb_col < sb32_cols * 2; mb_col += 2) {
lpf_sb32(cm, mode_info_context, mb_row, mb_col,
y_ptr, u_ptr, v_ptr,
y_stride, uv_stride, y_only);
y_ptr += 32;
u_ptr = y_only? 0 : u_ptr + 16;
v_ptr = y_only? 0 : v_ptr + 16;
mode_info_context += 4; // step to next SB32
}
if (extra_mb_col) {
// process 1st MB
mi = mode_info_context;
do_left_v = (mb_col > 0);
do_above_h = (mb_row > 0);
do_left_v_mbuv = 1;
do_above_h_mbuv = 1;
lpf_mb(cm, mi, do_left_v, do_above_h,
do_left_v_mbuv, do_above_h_mbuv,
mb_row, mb_col,
y_ptr,
y_only? NULL : u_ptr,
y_only? NULL : v_ptr,
y_stride, uv_stride);
// process 2nd MB
mi = mode_info_context + (mis << 1);
do_left_v = (mb_col > 0);
do_above_h = 1;
do_left_v_mbuv = 1;
do_above_h_mbuv = 1;
lpf_mb(cm, mi, do_left_v, do_above_h,
do_left_v_mbuv, do_above_h_mbuv,
mb_row + 1, mb_col,
y_ptr + 16 * y_stride,
y_only ? NULL : (u_ptr + 8 * uv_stride),
y_only ? NULL : (v_ptr + 8 * uv_stride),
y_stride, uv_stride);
y_ptr += 16;
u_ptr = y_only? 0 : u_ptr + 8;
v_ptr = y_only? 0 : v_ptr + 8;
mode_info_context += 2; /* step to next MB */
}
// move pointers to the beginning of next sb64 row
y_ptr += y_stride * 32 - cm->mb_cols * 16;
u_ptr += y_only? 0 : uv_stride * 16 - cm->mb_cols * 8;
v_ptr += y_only? 0 : uv_stride * 16 - cm->mb_cols * 8;
// skip to next MB row if exist
mode_info_context += mis * 4 - cm->mb_cols * 2;
mb_row += 2;
}
if (extra_mb_row) {
for (mb_col = 0; mb_col < cm->mb_cols; mb_col++) {
const MODE_INFO *mi = mode_info_context;
do_left_v = (mb_col > 0);
do_above_h = (mb_row > 0);
do_left_v_mbuv = 1;
do_above_h_mbuv = 1;
lpf_mb(cm, mi, do_left_v, do_above_h,
do_left_v_mbuv, do_above_h_mbuv,
mb_row, mb_col,
y_ptr,
y_only? 0 : u_ptr,
y_only? 0 : v_ptr,
y_stride, uv_stride);
y_ptr += 16;
u_ptr = y_only? 0 : u_ptr + 8;
v_ptr = y_only? 0 : v_ptr + 8;
mode_info_context += 2; // step to next MB
}
}
}
#else
static int build_lfi(const VP9_COMMON *cm, const MB_MODE_INFO *mbmi,
struct loop_filter_info *lfi) {
const loop_filter_info_n *lfi_n = &cm->lf_info;
@ -780,4 +388,3 @@ void vp9_loop_filter_frame(VP9_COMMON *cm,
}
}
}
#endif

137
vp9/common/vp9_loopfilter_filters.c
Просмотреть файл

@ -206,111 +206,6 @@ void vp9_mbloop_filter_vertical_edge_c(uint8_t *s, int pitch,
}
}
#if !CONFIG_NEW_LOOPFILTER
/* Vertical MB Filtering */
void vp9_loop_filter_mbv_c(uint8_t *y_ptr, uint8_t *u_ptr,
uint8_t *v_ptr, int y_stride, int uv_stride,
struct loop_filter_info *lfi) {
vp9_mbloop_filter_vertical_edge_c(y_ptr, y_stride,
lfi->mblim, lfi->lim, lfi->hev_thr, 2);
if (u_ptr)
vp9_mbloop_filter_vertical_edge_c(u_ptr, uv_stride,
lfi->mblim, lfi->lim, lfi->hev_thr, 1);
if (v_ptr)
vp9_mbloop_filter_vertical_edge_c(v_ptr, uv_stride,
lfi->mblim, lfi->lim, lfi->hev_thr, 1);
}
/* Vertical B Filtering */
void vp9_loop_filter_bv_c(uint8_t*y_ptr, uint8_t *u_ptr,
uint8_t *v_ptr, int y_stride, int uv_stride,
struct loop_filter_info *lfi) {
vp9_loop_filter_vertical_edge_c(y_ptr + 4, y_stride,
lfi->blim, lfi->lim, lfi->hev_thr, 2);
vp9_loop_filter_vertical_edge_c(y_ptr + 8, y_stride,
lfi->blim, lfi->lim, lfi->hev_thr, 2);
vp9_loop_filter_vertical_edge_c(y_ptr + 12, y_stride,
lfi->blim, lfi->lim, lfi->hev_thr, 2);
if (u_ptr)
vp9_loop_filter_vertical_edge_c(u_ptr + 4, uv_stride,
lfi->blim, lfi->lim, lfi->hev_thr, 1);
if (v_ptr)
vp9_loop_filter_vertical_edge_c(v_ptr + 4, uv_stride,
lfi->blim, lfi->lim, lfi->hev_thr, 1);
}
// Horizontal MB filtering
void vp9_loop_filter_mbh_c(uint8_t *y, uint8_t *u, uint8_t *v,
int y_stride, int uv_stride,
struct loop_filter_info *lfi) {
vp9_mbloop_filter_horizontal_edge_c(y, y_stride,
lfi->mblim, lfi->lim, lfi->hev_thr, 2);
if (u)
vp9_mbloop_filter_horizontal_edge_c(u, uv_stride,
lfi->mblim, lfi->lim, lfi->hev_thr, 1);
if (v)
vp9_mbloop_filter_horizontal_edge_c(v, uv_stride,
lfi->mblim, lfi->lim, lfi->hev_thr, 1);
}
// Horizontal B Filtering
void vp9_loop_filter_bh_c(uint8_t *y, uint8_t *u, uint8_t *v,
int y_stride, int uv_stride,
struct loop_filter_info *lfi) {
vp9_loop_filter_horizontal_edge_c(y + 4 * y_stride, y_stride,
lfi->blim, lfi->lim, lfi->hev_thr, 2);
vp9_loop_filter_horizontal_edge_c(y + 8 * y_stride, y_stride,
lfi->blim, lfi->lim, lfi->hev_thr, 2);
vp9_loop_filter_horizontal_edge_c(y + 12 * y_stride, y_stride,
lfi->blim, lfi->lim, lfi->hev_thr, 2);
if (u)
vp9_loop_filter_horizontal_edge_c(u + 4 * uv_stride, uv_stride,
lfi->blim, lfi->lim, lfi->hev_thr, 1);
if (v)
vp9_loop_filter_horizontal_edge_c(v + 4 * uv_stride, uv_stride,
lfi->blim, lfi->lim, lfi->hev_thr, 1);
}
void vp9_loop_filter_bh8x8_c(uint8_t *y, uint8_t *u, uint8_t *v,
int y_stride, int uv_stride,
struct loop_filter_info *lfi) {
vp9_mbloop_filter_horizontal_edge_c(y + 8 * y_stride, y_stride,
lfi->blim, lfi->lim, lfi->hev_thr, 2);
if (u)
vp9_loop_filter_horizontal_edge_c(u + 4 * uv_stride, uv_stride,
lfi->blim, lfi->lim, lfi->hev_thr, 1);
if (v)
vp9_loop_filter_horizontal_edge_c(v + 4 * uv_stride, uv_stride,
lfi->blim, lfi->lim, lfi->hev_thr, 1);
}
void vp9_loop_filter_bv8x8_c(uint8_t *y, uint8_t *u, uint8_t *v,
int y_stride, int uv_stride,
struct loop_filter_info *lfi) {
vp9_mbloop_filter_vertical_edge_c(y + 8, y_stride,
lfi->blim, lfi->lim, lfi->hev_thr, 2);
if (u)
vp9_loop_filter_vertical_edge_c(u + 4, uv_stride,
lfi->blim, lfi->lim, lfi->hev_thr, 1);
if (v)
vp9_loop_filter_vertical_edge_c(v + 4, uv_stride,
lfi->blim, lfi->lim, lfi->hev_thr, 1);
}
#endif
static INLINE void wide_mbfilter(int8_t mask, uint8_t hev,
uint8_t flat, uint8_t flat2,
uint8_t *op7, uint8_t *op6, uint8_t *op5,
@ -413,35 +308,3 @@ void vp9_mb_lpf_vertical_edge_w(uint8_t *s, int p,
s += p;
}
}
#if !CONFIG_NEW_LOOPFILTER
void vp9_lpf_mbv_w_c(uint8_t *y, uint8_t *u, uint8_t *v,
int y_stride, int uv_stride,
struct loop_filter_info *lfi) {
vp9_mb_lpf_vertical_edge_w(y, y_stride,
lfi->mblim, lfi->lim, lfi->hev_thr, 2);
if (u)
vp9_mbloop_filter_vertical_edge_c(u, uv_stride,
lfi->mblim, lfi->lim, lfi->hev_thr, 1);
if (v)
vp9_mbloop_filter_vertical_edge_c(v, uv_stride,
lfi->mblim, lfi->lim, lfi->hev_thr, 1);
}
void vp9_lpf_mbh_w_c(uint8_t *y, uint8_t *u, uint8_t *v,
int y_stride, int uv_stride,
struct loop_filter_info *lfi) {
vp9_mb_lpf_horizontal_edge_w(y, y_stride,
lfi->mblim, lfi->lim, lfi->hev_thr, 2);
if (u)
vp9_mbloop_filter_horizontal_edge_c(u, uv_stride,
lfi->mblim, lfi->lim, lfi->hev_thr, 1);
if (v)
vp9_mbloop_filter_horizontal_edge_c(v, uv_stride,
lfi->mblim, lfi->lim, lfi->hev_thr, 1);
}
#endif

26
vp9/common/vp9_rtcd_defs.sh
Просмотреть файл

@ -86,7 +86,6 @@ fi
#
# Loopfilter
#
if [ "$CONFIG_NEW_LOOPFILTER" = "yes" ]; then
prototype void vp9_mb_lpf_vertical_edge_w "uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int count"
specialize vp9_mb_lpf_vertical_edge_w
@ -104,31 +103,6 @@ specialize vp9_mbloop_filter_horizontal_edge
prototype void vp9_loop_filter_horizontal_edge "uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int count"
specialize vp9_loop_filter_horizontal_edge
else
prototype void vp9_loop_filter_mbv "uint8_t *y, uint8_t *u, uint8_t *v, int ystride, int uv_stride, struct loop_filter_info *lfi"
specialize vp9_loop_filter_mbv sse2
prototype void vp9_loop_filter_bv "uint8_t *y, uint8_t *u, uint8_t *v, int ystride, int uv_stride, struct loop_filter_info *lfi"
specialize vp9_loop_filter_bv sse2
prototype void vp9_loop_filter_bv8x8 "uint8_t *y, uint8_t *u, uint8_t *v, int ystride, int uv_stride, struct loop_filter_info *lfi"
specialize vp9_loop_filter_bv8x8 sse2
prototype void vp9_loop_filter_mbh "uint8_t *y, uint8_t *u, uint8_t *v, int ystride, int uv_stride, struct loop_filter_info *lfi"
specialize vp9_loop_filter_mbh sse2
prototype void vp9_loop_filter_bh "uint8_t *y, uint8_t *u, uint8_t *v, int ystride, int uv_stride, struct loop_filter_info *lfi"
specialize vp9_loop_filter_bh sse2
prototype void vp9_loop_filter_bh8x8 "uint8_t *y, uint8_t *u, uint8_t *v, int ystride, int uv_stride, struct loop_filter_info *lfi"
specialize vp9_loop_filter_bh8x8 sse2
prototype void vp9_lpf_mbh_w "unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr, int y_stride, int uv_stride, struct loop_filter_info *lfi"
specialize vp9_lpf_mbh_w sse2
prototype void vp9_lpf_mbv_w "unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr, int y_stride, int uv_stride, struct loop_filter_info *lfi"
specialize vp9_lpf_mbv_w sse2
fi
#
# post proc