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

Refactor inter recon functions to support scaling 

Ensure that all inter prediction goes through a common code path
that takes scaling into account. Removes a bunch of duplicate
1st/2nd predictor code. Also introduces a 16x8 mode for 8x8
MVs, similar to the 8x4 trick we were doing before. This has an
unexpected effect with EIGHTTAP_SMOOTH, so it's disabled in that
case for now.

Change-Id: Ia053e823a8bc616a988a0af30452e1e75a739cba
This commit is contained in:
John Koleszar 2013-02-08 17:49:44 -08:00
Родитель 9770d564f4
Коммит 6a4f708c25
13 изменённых файлов: 384 добавлений и 484 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

3
test/convolve_test.cc
Просмотреть файл

@ -506,10 +506,12 @@ INSTANTIATE_TEST_CASE_P(C, ConvolveTest, ::testing::Values(
make_tuple(4, 4, &convolve8_2d_only_c),
make_tuple(8, 4, &convolve8_2d_only_c),
make_tuple(8, 8, &convolve8_2d_only_c),
make_tuple(16, 8, &convolve8_2d_only_c),
make_tuple(16, 16, &convolve8_2d_only_c),
make_tuple(4, 4, &convolve8_c),
make_tuple(8, 4, &convolve8_c),
make_tuple(8, 8, &convolve8_c),
make_tuple(16, 8, &convolve8_c),
make_tuple(16, 16, &convolve8_c)));
}
@ -523,5 +525,6 @@ INSTANTIATE_TEST_CASE_P(SSSE3, ConvolveTest, ::testing::Values(
make_tuple(4, 4, &convolve8_ssse3),
make_tuple(8, 4, &convolve8_ssse3),
make_tuple(8, 8, &convolve8_ssse3),
make_tuple(16, 8, &convolve8_ssse3),
make_tuple(16, 16, &convolve8_ssse3)));
#endif

11
vp9/common/vp9_blockd.h
Просмотреть файл

@ -288,6 +288,15 @@ typedef struct superblockd {
DECLARE_ALIGNED(16, int16_t, dqcoeff[32*32+16*16*2]);
} SUPERBLOCKD;
struct scale_factors {
int x_num;
int x_den;
int x_offset_q4;
int y_num;
int y_den;
int y_offset_q4;
};
typedef struct macroblockd {
DECLARE_ALIGNED(16, int16_t, diff[384]); /* from idct diff */
DECLARE_ALIGNED(16, uint8_t, predictor[384]);
@ -303,6 +312,8 @@ typedef struct macroblockd {
YV12_BUFFER_CONFIG pre; /* Filtered copy of previous frame reconstruction */
YV12_BUFFER_CONFIG second_pre;
YV12_BUFFER_CONFIG dst;
struct scale_factors scale_factor[2];
struct scale_factors scale_factor_uv[2];
MODE_INFO *prev_mode_info_context;
MODE_INFO *mode_info_context;

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

@ -318,25 +318,17 @@ void vp9_convolve_copy(const uint8_t *src, int src_stride,
const int16_t *filter_x, int filter_x_stride,
const int16_t *filter_y, int filter_y_stride,
int w, int h) {
if (h == 16) {
if (w == 16 && h == 16) {
vp9_copy_mem16x16(src, src_stride, dst, dst_stride);
} else if (h == 8) {
} else if (w == 8 && h == 8) {
vp9_copy_mem8x8(src, src_stride, dst, dst_stride);
} else if (w == 8) {
} else if (w == 8 && h == 4) {
vp9_copy_mem8x4(src, src_stride, dst, dst_stride);
} else {
// 4x4
int r;
for (r = 0; r < 4; ++r) {
#if !(CONFIG_FAST_UNALIGNED)
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[2];
dst[3] = src[3];
#else
*(uint32_t *)dst = *(const uint32_t *)src;
#endif
for (r = h; r > 0; --r) {
memcpy(dst, src, w);
src += src_stride;
dst += dst_stride;
}

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

@ -71,6 +71,17 @@ static void setup_macroblock(MACROBLOCKD *xd, BLOCKSET bs) {
setup_block(&blockd[block + 4], stride, v, v2, stride,
((block - 16) >> 1) * 4 * stride + (block & 1) * 4, bs);
}
// TODO(jkoleszar): this will move once we're actually scaling.
xd->scale_factor[0].x_num = 1;
xd->scale_factor[0].x_den = 1;
xd->scale_factor[0].y_num = 1;
xd->scale_factor[0].y_den = 1;
xd->scale_factor[0].x_offset_q4 = 0;
xd->scale_factor[0].y_offset_q4 = 0;
xd->scale_factor[1]= xd->scale_factor[0];
xd->scale_factor_uv[0] = xd->scale_factor[0];
xd->scale_factor_uv[1] = xd->scale_factor[1];
}
void vp9_setup_block_dptrs(MACROBLOCKD *xd) {

10
vp9/common/vp9_mv.h
Просмотреть файл

@ -23,4 +23,14 @@ typedef union int_mv {
MV as_mv;
} int_mv; /* facilitates faster equality tests and copies */
struct mv32 {
int32_t row;
int32_t col;
};
typedef union int_mv32 {
uint64_t as_int;
struct mv32 as_mv;
} int_mv32; /* facilitates faster equality tests and copies */
#endif // VP9_COMMON_VP9_MV_H_

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

@ -146,109 +146,118 @@ void vp9_copy_mem8x4_c(const uint8_t *src,
}
}
void vp9_build_inter_predictors_b(BLOCKD *d, int pitch,
struct subpix_fn_table *subpix) {
uint8_t *ptr_base;
uint8_t *ptr;
uint8_t *pred_ptr = d->predictor;
int_mv mv;
static int32_t scale_motion_vector_component(int mv,
int num,
int den,
int offset_q4) {
// returns the scaled and offset value of the mv component.
// input and output mv have the same units -- this would work with either q3
// or q4 motion vectors. Offset is given as a q4 fractional number.
const int32_t mv_q4 = mv * 16;
ptr_base = *(d->base_pre);
mv.as_int = d->bmi.as_mv[0].as_int;
ptr = ptr_base + d->pre + (mv.as_mv.row >> 3) * d->pre_stride +
(mv.as_mv.col >> 3);
/* TODO(jkoleszar): make fixed point, or as a second multiply? */
return (mv_q4 * num / den + offset_q4 + 8) >> 4;
}
subpix->predict[!!(mv.as_mv.col & 7)][!!(mv.as_mv.row & 7)][0](
ptr, d->pre_stride, pred_ptr, pitch,
static int_mv32 scale_motion_vector(const int_mv *src_mv,
const struct scale_factors *scale) {
// returns mv * scale + offset
int_mv32 result;
result.as_mv.row = scale_motion_vector_component(src_mv->as_mv.row,
scale->y_num, scale->y_den,
scale->y_offset_q4);
result.as_mv.col = scale_motion_vector_component(src_mv->as_mv.col,
scale->x_num, scale->x_den,
scale->x_offset_q4);
return result;
}
void vp9_build_inter_predictor(const uint8_t *src, int src_stride,
uint8_t *dst, int dst_stride,
const int_mv *mv_q3,
const struct scale_factors *scale,
int w, int h, int do_avg,
const struct subpix_fn_table *subpix) {
int_mv32 mv;
mv = scale_motion_vector(mv_q3, scale);
src = src + (mv.as_mv.row >> 3) * src_stride + (mv.as_mv.col >> 3);
subpix->predict[!!(mv.as_mv.col & 7)][!!(mv.as_mv.row & 7)][do_avg](
src, src_stride, dst, dst_stride,
subpix->filter_x[(mv.as_mv.col & 7) << 1], subpix->x_step_q4,
subpix->filter_y[(mv.as_mv.row & 7) << 1], subpix->y_step_q4,
4, 4);
w, h);
}
/*
* Similar to vp9_build_inter_predictors_b(), but instead of storing the
* results in d->predictor, we average the contents of d->predictor (which
* come from an earlier call to vp9_build_inter_predictors_b()) with the
* predictor of the second reference frame / motion vector.
/* Like vp9_build_inter_predictor, but takes the full-pel part of the
* mv separately, and the fractional part as a q4.
*/
void vp9_build_2nd_inter_predictors_b(BLOCKD *d, int pitch,
struct subpix_fn_table *subpix) {
uint8_t *ptr_base;
uint8_t *ptr;
uint8_t *pred_ptr = d->predictor;
int_mv mv;
void vp9_build_inter_predictor_q4(const uint8_t *src, int src_stride,
uint8_t *dst, int dst_stride,
const int_mv *fullpel_mv_q3,
const int_mv *frac_mv_q4,
const struct scale_factors *scale,
int w, int h, int do_avg,
const struct subpix_fn_table *subpix) {
const int mv_row_q4 = ((fullpel_mv_q3->as_mv.row >> 3) << 4)
+ (frac_mv_q4->as_mv.row & 0xf);
const int mv_col_q4 = ((fullpel_mv_q3->as_mv.col >> 3) << 4)
+ (frac_mv_q4->as_mv.col & 0xf);
const int scaled_mv_row_q4 =
scale_motion_vector_component(mv_row_q4, scale->y_num, scale->y_den,
scale->y_offset_q4);
const int scaled_mv_col_q4 =
scale_motion_vector_component(mv_col_q4, scale->x_num, scale->x_den,
scale->x_offset_q4);
const int subpel_x = scaled_mv_col_q4 & 15;
const int subpel_y = scaled_mv_row_q4 & 15;
ptr_base = *(d->base_second_pre);
mv.as_int = d->bmi.as_mv[1].as_int;
ptr = ptr_base + d->pre + (mv.as_mv.row >> 3) * d->pre_stride +
(mv.as_mv.col >> 3);
subpix->predict[!!(mv.as_mv.col & 7)][!!(mv.as_mv.row & 7)][1](
ptr, d->pre_stride, pred_ptr, pitch,
subpix->filter_x[(mv.as_mv.col & 7) << 1], subpix->x_step_q4,
subpix->filter_y[(mv.as_mv.row & 7) << 1], subpix->y_step_q4,
4, 4);
src = src + (scaled_mv_row_q4 >> 4) * src_stride + (scaled_mv_col_q4 >> 4);
subpix->predict[!!subpel_x][!!subpel_y][do_avg](
src, src_stride, dst, dst_stride,
subpix->filter_x[subpel_x], subpix->x_step_q4,
subpix->filter_y[subpel_y], subpix->y_step_q4,
w, h);
}
void vp9_build_inter_predictors4b(MACROBLOCKD *xd, BLOCKD *d, int pitch) {
uint8_t *ptr_base;
uint8_t *ptr;
uint8_t *pred_ptr = d->predictor;
int_mv mv;
static void build_2x1_inter_predictor(const BLOCKD *d0, const BLOCKD *d1,
const struct scale_factors *scale,
int block_size, int stride, int which_mv,
const struct subpix_fn_table *subpix) {
assert(d1->predictor - d0->predictor == block_size);
assert(d1->pre == d0->pre + block_size);
ptr_base = *(d->base_pre);
mv.as_int = d->bmi.as_mv[0].as_int;
ptr = ptr_base + d->pre + (mv.as_mv.row >> 3) * d->pre_stride +
(mv.as_mv.col >> 3);
if (d0->bmi.as_mv[which_mv].as_int == d1->bmi.as_mv[which_mv].as_int) {
uint8_t **base_pre = which_mv ? d0->base_second_pre : d0->base_pre;
xd->subpix.predict[!!(mv.as_mv.col & 7)][!!(mv.as_mv.row & 7)][0](
ptr, d->pre_stride, pred_ptr, pitch,
xd->subpix.filter_x[(mv.as_mv.col & 7) << 1], xd->subpix.x_step_q4,
xd->subpix.filter_y[(mv.as_mv.row & 7) << 1], xd->subpix.y_step_q4,
8, 8);
}
vp9_build_inter_predictor(*base_pre + d0->pre,
d0->pre_stride,
d0->predictor, stride,
&d0->bmi.as_mv[which_mv],
&scale[which_mv],
2 * block_size, block_size, which_mv,
subpix);
/*
* Similar to build_inter_predictors_4b(), but instead of storing the
* results in d->predictor, we average the contents of d->predictor (which
* come from an earlier call to build_inter_predictors_4b()) with the
* predictor of the second reference frame / motion vector.
*/
void vp9_build_2nd_inter_predictors4b(MACROBLOCKD *xd,
BLOCKD *d, int pitch) {
uint8_t *ptr_base;
uint8_t *ptr;
uint8_t *pred_ptr = d->predictor;
int_mv mv;
} else {
uint8_t **base_pre0 = which_mv ? d0->base_second_pre : d0->base_pre;
uint8_t **base_pre1 = which_mv ? d1->base_second_pre : d1->base_pre;
ptr_base = *(d->base_second_pre);
mv.as_int = d->bmi.as_mv[1].as_int;
ptr = ptr_base + d->pre + (mv.as_mv.row >> 3) * d->pre_stride +
(mv.as_mv.col >> 3);
xd->subpix.predict[!!(mv.as_mv.col & 7)][!!(mv.as_mv.row & 7)][1](
ptr, d->pre_stride, pred_ptr, pitch,
xd->subpix.filter_x[(mv.as_mv.col & 7) << 1], xd->subpix.x_step_q4,
xd->subpix.filter_y[(mv.as_mv.row & 7) << 1], xd->subpix.y_step_q4,
8, 8);
}
static void build_inter_predictors2b(MACROBLOCKD *xd, BLOCKD *d, int pitch) {
uint8_t *ptr_base;
uint8_t *ptr;
uint8_t *pred_ptr = d->predictor;
int_mv mv;
ptr_base = *(d->base_pre);
mv.as_int = d->bmi.as_mv[0].as_int;
ptr = ptr_base + d->pre + (mv.as_mv.row >> 3) * d->pre_stride +
(mv.as_mv.col >> 3);
xd->subpix.predict[!!(mv.as_mv.col & 7)][!!(mv.as_mv.row & 7)][0](
ptr, d->pre_stride, pred_ptr, pitch,
xd->subpix.filter_x[(mv.as_mv.col & 7) << 1], xd->subpix.x_step_q4,
xd->subpix.filter_y[(mv.as_mv.row & 7) << 1], xd->subpix.y_step_q4,
8, 4);
vp9_build_inter_predictor(*base_pre0 + d0->pre,
d0->pre_stride,
d0->predictor, stride,
&d0->bmi.as_mv[which_mv],
&scale[which_mv],
block_size, block_size, which_mv,
subpix);
vp9_build_inter_predictor(*base_pre1 + d1->pre,
d1->pre_stride,
d1->predictor, stride,
&d1->bmi.as_mv[which_mv],
&scale[which_mv],
block_size, block_size, which_mv,
subpix);
}
}
/*encoder only*/
@ -329,19 +338,14 @@ void vp9_build_inter4x4_predictors_mbuv(MACROBLOCKD *xd) {
}
for (i = 16; i < 24; i += 2) {
const int use_second_ref = xd->mode_info_context->mbmi.second_ref_frame > 0;
int which_mv;
BLOCKD *d0 = &blockd[i];
BLOCKD *d1 = &blockd[i + 1];
if (d0->bmi.as_mv[0].as_int == d1->bmi.as_mv[0].as_int)
build_inter_predictors2b(xd, d0, 8);
else {
vp9_build_inter_predictors_b(d0, 8, &xd->subpix);
vp9_build_inter_predictors_b(d1, 8, &xd->subpix);
}
if (xd->mode_info_context->mbmi.second_ref_frame > 0) {
vp9_build_2nd_inter_predictors_b(d0, 8, &xd->subpix);
vp9_build_2nd_inter_predictors_b(d1, 8, &xd->subpix);
for (which_mv = 0; which_mv < 1 + use_second_ref; ++which_mv) {
build_2x1_inter_predictor(d0, d1, xd->scale_factor_uv, 4, 8, which_mv,
&xd->subpix);
}
}
}
@ -383,91 +387,87 @@ static void clamp_uvmv_to_umv_border(MV *mv, const MACROBLOCKD *xd) {
}
/*encoder only*/
void vp9_build_1st_inter16x16_predictors_mby(MACROBLOCKD *xd,
uint8_t *dst_y,
int dst_ystride,
int clamp_mvs) {
uint8_t *ptr_base = xd->pre.y_buffer;
uint8_t *ptr;
int pre_stride = xd->block[0].pre_stride;
int_mv ymv;
void vp9_build_inter16x16_predictors_mby(MACROBLOCKD *xd,
uint8_t *dst_y,
int dst_ystride) {
const int use_second_ref = xd->mode_info_context->mbmi.second_ref_frame > 0;
int which_mv;
ymv.as_int = xd->mode_info_context->mbmi.mv[0].as_int;
for (which_mv = 0; which_mv < 1 + use_second_ref; ++which_mv) {
const int clamp_mvs =
which_mv ? xd->mode_info_context->mbmi.need_to_clamp_secondmv
: xd->mode_info_context->mbmi.need_to_clamp_mvs;
uint8_t *base_pre;
int_mv ymv;
if (clamp_mvs)
clamp_mv_to_umv_border(&ymv.as_mv, xd);
ymv.as_int = xd->mode_info_context->mbmi.mv[which_mv].as_int;
base_pre = which_mv ? xd->second_pre.y_buffer
: xd->pre.y_buffer;
if (clamp_mvs)
clamp_mv_to_umv_border(&ymv.as_mv, xd);
ptr = ptr_base + (ymv.as_mv.row >> 3) * pre_stride + (ymv.as_mv.col >> 3);
xd->subpix.predict[!!(ymv.as_mv.col & 7)][!!(ymv.as_mv.row & 7)][0](
ptr, pre_stride, dst_y, dst_ystride,
xd->subpix.filter_x[(ymv.as_mv.col & 7) << 1], xd->subpix.x_step_q4,
xd->subpix.filter_y[(ymv.as_mv.row & 7) << 1], xd->subpix.y_step_q4,
16, 16);
vp9_build_inter_predictor(base_pre, xd->block[0].pre_stride,
dst_y, dst_ystride,
&ymv, &xd->scale_factor[which_mv],
16, 16, which_mv, &xd->subpix);
}
}
void vp9_build_1st_inter16x16_predictors_mbuv(MACROBLOCKD *xd,
uint8_t *dst_u,
uint8_t *dst_v,
int dst_uvstride) {
int offset;
uint8_t *uptr, *vptr;
int pre_stride = xd->block[0].pre_stride;
int_mv _o16x16mv;
int_mv _16x16mv;
void vp9_build_inter16x16_predictors_mbuv(MACROBLOCKD *xd,
uint8_t *dst_u,
uint8_t *dst_v,
int dst_uvstride) {
const int use_second_ref = xd->mode_info_context->mbmi.second_ref_frame > 0;
int which_mv;
_16x16mv.as_int = xd->mode_info_context->mbmi.mv[0].as_int;
for (which_mv = 0; which_mv < 1 + use_second_ref; ++which_mv) {
const int clamp_mvs =
which_mv ? xd->mode_info_context->mbmi.need_to_clamp_secondmv
: xd->mode_info_context->mbmi.need_to_clamp_mvs;
uint8_t *uptr, *vptr;
int pre_stride = xd->block[0].pre_stride;
int_mv _o16x16mv;
int_mv _16x16mv;
if (xd->mode_info_context->mbmi.need_to_clamp_mvs)
clamp_mv_to_umv_border(&_16x16mv.as_mv, xd);
_16x16mv.as_int = xd->mode_info_context->mbmi.mv[which_mv].as_int;
_o16x16mv = _16x16mv;
/* calc uv motion vectors */
if (_16x16mv.as_mv.row < 0)
_16x16mv.as_mv.row -= 1;
else
_16x16mv.as_mv.row += 1;
if (clamp_mvs)
clamp_mv_to_umv_border(&_16x16mv.as_mv, xd);
if (_16x16mv.as_mv.col < 0)
_16x16mv.as_mv.col -= 1;
else
_16x16mv.as_mv.col += 1;
_o16x16mv = _16x16mv;
/* calc uv motion vectors */
if (_16x16mv.as_mv.row < 0)
_16x16mv.as_mv.row -= 1;
else
_16x16mv.as_mv.row += 1;
_16x16mv.as_mv.row /= 2;
_16x16mv.as_mv.col /= 2;
if (_16x16mv.as_mv.col < 0)
_16x16mv.as_mv.col -= 1;
else
_16x16mv.as_mv.col += 1;
_16x16mv.as_mv.row &= xd->fullpixel_mask;
_16x16mv.as_mv.col &= xd->fullpixel_mask;
_16x16mv.as_mv.row /= 2;
_16x16mv.as_mv.col /= 2;
pre_stride >>= 1;
offset = (_16x16mv.as_mv.row >> 3) * pre_stride + (_16x16mv.as_mv.col >> 3);
uptr = xd->pre.u_buffer + offset;
vptr = xd->pre.v_buffer + offset;
_16x16mv.as_mv.row &= xd->fullpixel_mask;
_16x16mv.as_mv.col &= xd->fullpixel_mask;
xd->subpix.predict[!!(_o16x16mv.as_mv.col & 15)]
[!!(_o16x16mv.as_mv.row & 15)][0](
uptr, pre_stride, dst_u, dst_uvstride,
xd->subpix.filter_x[_o16x16mv.as_mv.col & 15], xd->subpix.x_step_q4,
xd->subpix.filter_y[_o16x16mv.as_mv.row & 15], xd->subpix.y_step_q4,
8, 8);
pre_stride >>= 1;
uptr = (which_mv ? xd->second_pre.u_buffer : xd->pre.u_buffer);
vptr = (which_mv ? xd->second_pre.v_buffer : xd->pre.v_buffer);
xd->subpix.predict[!!(_o16x16mv.as_mv.col & 15)]
[!!(_o16x16mv.as_mv.row & 15)][0](
vptr, pre_stride, dst_v, dst_uvstride,
xd->subpix.filter_x[_o16x16mv.as_mv.col & 15], xd->subpix.x_step_q4,
xd->subpix.filter_y[_o16x16mv.as_mv.row & 15], xd->subpix.y_step_q4,
8, 8);
}
vp9_build_inter_predictor_q4(uptr, pre_stride,
dst_u, dst_uvstride,
&_16x16mv, &_o16x16mv,
&xd->scale_factor_uv[which_mv],
8, 8, which_mv, &xd->subpix);
void vp9_build_1st_inter16x16_predictors_mb(MACROBLOCKD *xd,
uint8_t *dst_y,
uint8_t *dst_u,
uint8_t *dst_v,
int dst_ystride, int dst_uvstride) {
vp9_build_1st_inter16x16_predictors_mby(xd, dst_y, dst_ystride,
xd->mode_info_context->mbmi.need_to_clamp_mvs);
vp9_build_1st_inter16x16_predictors_mbuv(xd, dst_u, dst_v, dst_uvstride);
vp9_build_inter_predictor_q4(vptr, pre_stride,
dst_v, dst_uvstride,
&_16x16mv, &_o16x16mv,
&xd->scale_factor_uv[which_mv],
8, 8, which_mv, &xd->subpix);
}
}
void vp9_build_inter32x32_predictors_sb(MACROBLOCKD *x,
@ -498,22 +498,17 @@ void vp9_build_inter32x32_predictors_sb(MACROBLOCKD *x,
x->pre.u_buffer = u1 + y_idx * 8 * x->pre.uv_stride + x_idx * 8;
x->pre.v_buffer = v1 + y_idx * 8 * x->pre.uv_stride + x_idx * 8;
vp9_build_1st_inter16x16_predictors_mb(x,
dst_y + y_idx * 16 * dst_ystride + x_idx * 16,
dst_u + y_idx * 8 * dst_uvstride + x_idx * 8,
dst_v + y_idx * 8 * dst_uvstride + x_idx * 8,
dst_ystride, dst_uvstride);
if (x->mode_info_context->mbmi.second_ref_frame > 0) {
x->second_pre.y_buffer = y2 + y_idx * 16 * x->pre.y_stride + x_idx * 16;
x->second_pre.u_buffer = u2 + y_idx * 8 * x->pre.uv_stride + x_idx * 8;
x->second_pre.v_buffer = v2 + y_idx * 8 * x->pre.uv_stride + x_idx * 8;
}
vp9_build_2nd_inter16x16_predictors_mb(x,
vp9_build_inter16x16_predictors_mb(x,
dst_y + y_idx * 16 * dst_ystride + x_idx * 16,
dst_u + y_idx * 8 * dst_uvstride + x_idx * 8,
dst_v + y_idx * 8 * dst_uvstride + x_idx * 8,
dst_ystride, dst_uvstride);
}
}
x->mb_to_top_edge = edge[0];
@ -603,144 +598,54 @@ void vp9_build_inter64x64_predictors_sb(MACROBLOCKD *x,
#endif
}
/*
* The following functions should be called after an initial
* call to vp9_build_1st_inter16x16_predictors_mb() or _mby()/_mbuv().
* It will run a second filter on a (different) ref
* frame and average the result with the output of the
* first filter. The second reference frame is stored
* in x->second_pre (the reference frame index is in
* x->mode_info_context->mbmi.second_ref_frame). The second
* motion vector is x->mode_info_context->mbmi.second_mv.
*
* This allows blending prediction from two reference frames
* which sometimes leads to better prediction than from a
* single reference framer.
*/
void vp9_build_2nd_inter16x16_predictors_mby(MACROBLOCKD *xd,
uint8_t *dst_y,
int dst_ystride) {
uint8_t *ptr;
int_mv _16x16mv;
int mv_row;
int mv_col;
uint8_t *ptr_base = xd->second_pre.y_buffer;
int pre_stride = xd->block[0].pre_stride;
_16x16mv.as_int = xd->mode_info_context->mbmi.mv[1].as_int;
if (xd->mode_info_context->mbmi.need_to_clamp_secondmv)
clamp_mv_to_umv_border(&_16x16mv.as_mv, xd);
mv_row = _16x16mv.as_mv.row;
mv_col = _16x16mv.as_mv.col;
ptr = ptr_base + (mv_row >> 3) * pre_stride + (mv_col >> 3);
xd->subpix.predict[!!(mv_col & 7)][!!(mv_row & 7)][1](
ptr, pre_stride, dst_y, dst_ystride,
xd->subpix.filter_x[(mv_col & 7) << 1], xd->subpix.x_step_q4,
xd->subpix.filter_y[(mv_row & 7) << 1], xd->subpix.y_step_q4,
16, 16);
}
void vp9_build_2nd_inter16x16_predictors_mbuv(MACROBLOCKD *xd,
uint8_t *dst_u,
uint8_t *dst_v,
int dst_uvstride) {
int offset;
uint8_t *uptr, *vptr;
int_mv _16x16mv;
int mv_row;
int mv_col;
int omv_row, omv_col;
int pre_stride = xd->block[0].pre_stride;
_16x16mv.as_int = xd->mode_info_context->mbmi.mv[1].as_int;
if (xd->mode_info_context->mbmi.need_to_clamp_secondmv)
clamp_mv_to_umv_border(&_16x16mv.as_mv, xd);
mv_row = _16x16mv.as_mv.row;
mv_col = _16x16mv.as_mv.col;
/* calc uv motion vectors */
omv_row = mv_row;
omv_col = mv_col;
mv_row = (mv_row + (mv_row > 0)) >> 1;
mv_col = (mv_col + (mv_col > 0)) >> 1;
mv_row &= xd->fullpixel_mask;
mv_col &= xd->fullpixel_mask;
pre_stride >>= 1;
offset = (mv_row >> 3) * pre_stride + (mv_col >> 3);
uptr = xd->second_pre.u_buffer + offset;
vptr = xd->second_pre.v_buffer + offset;
xd->subpix.predict[!!(omv_col & 15)][!!(omv_row & 15)][1](
uptr, pre_stride, dst_u, dst_uvstride,
xd->subpix.filter_x[omv_col & 15], xd->subpix.x_step_q4,
xd->subpix.filter_y[omv_row & 15], xd->subpix.y_step_q4,
8, 8);
xd->subpix.predict[!!(omv_col & 15)][!!(omv_row & 15)][1](
vptr, pre_stride, dst_v, dst_uvstride,
xd->subpix.filter_x[omv_col & 15], xd->subpix.x_step_q4,
xd->subpix.filter_y[omv_row & 15], xd->subpix.y_step_q4,
8, 8);
}
void vp9_build_2nd_inter16x16_predictors_mb(MACROBLOCKD *xd,
uint8_t *dst_y,
uint8_t *dst_u,
uint8_t *dst_v,
int dst_ystride,
int dst_uvstride) {
vp9_build_2nd_inter16x16_predictors_mby(xd, dst_y, dst_ystride);
vp9_build_2nd_inter16x16_predictors_mbuv(xd, dst_u, dst_v, dst_uvstride);
}
static void build_inter4x4_predictors_mb(MACROBLOCKD *xd) {
int i;
MB_MODE_INFO * mbmi = &xd->mode_info_context->mbmi;
BLOCKD *blockd = xd->block;
int which_mv = 0;
const int use_second_ref = mbmi->second_ref_frame > 0;
if (xd->mode_info_context->mbmi.partitioning != PARTITIONING_4X4) {
blockd[ 0].bmi = xd->mode_info_context->bmi[ 0];
blockd[ 2].bmi = xd->mode_info_context->bmi[ 2];
blockd[ 8].bmi = xd->mode_info_context->bmi[ 8];
blockd[10].bmi = xd->mode_info_context->bmi[10];
for (i = 0; i < 16; i += 8) {
BLOCKD *d0 = &blockd[i];
BLOCKD *d1 = &blockd[i + 2];
if (mbmi->need_to_clamp_mvs) {
clamp_mv_to_umv_border(&blockd[ 0].bmi.as_mv[0].as_mv, xd);
clamp_mv_to_umv_border(&blockd[ 2].bmi.as_mv[0].as_mv, xd);
clamp_mv_to_umv_border(&blockd[ 8].bmi.as_mv[0].as_mv, xd);
clamp_mv_to_umv_border(&blockd[10].bmi.as_mv[0].as_mv, xd);
if (mbmi->second_ref_frame > 0) {
clamp_mv_to_umv_border(&blockd[ 0].bmi.as_mv[1].as_mv, xd);
clamp_mv_to_umv_border(&blockd[ 2].bmi.as_mv[1].as_mv, xd);
clamp_mv_to_umv_border(&blockd[ 8].bmi.as_mv[1].as_mv, xd);
clamp_mv_to_umv_border(&blockd[10].bmi.as_mv[1].as_mv, xd);
blockd[i + 0].bmi = xd->mode_info_context->bmi[i + 0];
blockd[i + 2].bmi = xd->mode_info_context->bmi[i + 2];
for (which_mv = 0; which_mv < 1 + use_second_ref; ++which_mv) {
if (mbmi->need_to_clamp_mvs) {
clamp_mv_to_umv_border(&blockd[i + 0].bmi.as_mv[which_mv].as_mv, xd);
clamp_mv_to_umv_border(&blockd[i + 2].bmi.as_mv[which_mv].as_mv, xd);
}
/* TODO(jkoleszar): Enabling this for EIGHTTAP_SMOOTH changes the
* result slightly, for reasons that are not immediately obvious to me.
* It probably makes sense to enable this for all filter types to be
* consistent with the way we do 8x4 below. Leaving disabled for now.
*/
if (mbmi->interp_filter != EIGHTTAP_SMOOTH) {
build_2x1_inter_predictor(d0, d1, xd->scale_factor, 8, 16,
which_mv, &xd->subpix);
} else {
uint8_t **base_pre0 = which_mv ? d0->base_second_pre : d0->base_pre;
uint8_t **base_pre1 = which_mv ? d1->base_second_pre : d1->base_pre;
vp9_build_inter_predictor(*base_pre0 + d0->pre,
d0->pre_stride,
d0->predictor, 16,
&d0->bmi.as_mv[which_mv],
&xd->scale_factor[which_mv],
8, 8, which_mv, &xd->subpix);
vp9_build_inter_predictor(*base_pre1 + d1->pre,
d1->pre_stride,
d1->predictor, 16,
&d1->bmi.as_mv[which_mv],
&xd->scale_factor[which_mv],
8, 8, which_mv, &xd->subpix);
}
}
}
vp9_build_inter_predictors4b(xd, &blockd[ 0], 16);
vp9_build_inter_predictors4b(xd, &blockd[ 2], 16);
vp9_build_inter_predictors4b(xd, &blockd[ 8], 16);
vp9_build_inter_predictors4b(xd, &blockd[10], 16);
if (mbmi->second_ref_frame > 0) {
vp9_build_2nd_inter_predictors4b(xd, &blockd[ 0], 16);
vp9_build_2nd_inter_predictors4b(xd, &blockd[ 2], 16);
vp9_build_2nd_inter_predictors4b(xd, &blockd[ 8], 16);
vp9_build_2nd_inter_predictors4b(xd, &blockd[10], 16);
}
} else {
for (i = 0; i < 16; i += 2) {
BLOCKD *d0 = &blockd[i];
@ -749,25 +654,9 @@ static void build_inter4x4_predictors_mb(MACROBLOCKD *xd) {
blockd[i + 0].bmi = xd->mode_info_context->bmi[i + 0];
blockd[i + 1].bmi = xd->mode_info_context->bmi[i + 1];
if (mbmi->need_to_clamp_mvs) {
clamp_mv_to_umv_border(&blockd[i + 0].bmi.as_mv[0].as_mv, xd);
clamp_mv_to_umv_border(&blockd[i + 1].bmi.as_mv[0].as_mv, xd);
if (mbmi->second_ref_frame > 0) {
clamp_mv_to_umv_border(&blockd[i + 0].bmi.as_mv[1].as_mv, xd);
clamp_mv_to_umv_border(&blockd[i + 1].bmi.as_mv[1].as_mv, xd);
}
}
if (d0->bmi.as_mv[0].as_int == d1->bmi.as_mv[0].as_int)
build_inter_predictors2b(xd, d0, 16);
else {
vp9_build_inter_predictors_b(d0, 16, &xd->subpix);
vp9_build_inter_predictors_b(d1, 16, &xd->subpix);
}
if (mbmi->second_ref_frame > 0) {
vp9_build_2nd_inter_predictors_b(d0, 16, &xd->subpix);
vp9_build_2nd_inter_predictors_b(d1, 16, &xd->subpix);
for (which_mv = 0; which_mv < 1 + use_second_ref; ++which_mv) {
build_2x1_inter_predictor(d0, d1, xd->scale_factor, 4, 16,
which_mv, &xd->subpix);
}
}
}
@ -776,16 +665,9 @@ static void build_inter4x4_predictors_mb(MACROBLOCKD *xd) {
BLOCKD *d0 = &blockd[i];
BLOCKD *d1 = &blockd[i + 1];
if (d0->bmi.as_mv[0].as_int == d1->bmi.as_mv[0].as_int)
build_inter_predictors2b(xd, d0, 8);
else {
vp9_build_inter_predictors_b(d0, 8, &xd->subpix);
vp9_build_inter_predictors_b(d1, 8, &xd->subpix);
}
if (mbmi->second_ref_frame > 0) {
vp9_build_2nd_inter_predictors_b(d0, 8, &xd->subpix);
vp9_build_2nd_inter_predictors_b(d1, 8, &xd->subpix);
for (which_mv = 0; which_mv < 1 + use_second_ref; ++which_mv) {
build_2x1_inter_predictor(d0, d1, xd->scale_factor_uv, 4, 8,
which_mv, &xd->subpix);
}
}
}
@ -882,22 +764,25 @@ void build_4x4uvmvs(MACROBLOCKD *xd) {
}
}
void vp9_build_inter16x16_predictors_mb(MACROBLOCKD *xd,
uint8_t *dst_y,
uint8_t *dst_u,
uint8_t *dst_v,
int dst_ystride,
int dst_uvstride) {
vp9_build_inter16x16_predictors_mby(xd, dst_y, dst_ystride);
vp9_build_inter16x16_predictors_mbuv(xd, dst_u, dst_v, dst_uvstride);
}
void vp9_build_inter_predictors_mb(MACROBLOCKD *xd) {
if (xd->mode_info_context->mbmi.mode != SPLITMV) {
vp9_build_1st_inter16x16_predictors_mb(xd, xd->predictor,
&xd->predictor[256],
&xd->predictor[320], 16, 8);
vp9_build_inter16x16_predictors_mb(xd, xd->predictor,
&xd->predictor[256],
&xd->predictor[320], 16, 8);
if (xd->mode_info_context->mbmi.second_ref_frame > 0) {
/* 256 = offset of U plane in Y+U+V buffer;
* 320 = offset of V plane in Y+U+V buffer.
* (256=16x16, 320=16x16+8x8). */
vp9_build_2nd_inter16x16_predictors_mb(xd, xd->predictor,
&xd->predictor[256],
&xd->predictor[320], 16, 8);
}
#if CONFIG_COMP_INTERINTRA_PRED
else if (xd->mode_info_context->mbmi.second_ref_frame == INTRA_FRAME) {
if (xd->mode_info_context->mbmi.second_ref_frame == INTRA_FRAME) {
vp9_build_interintra_16x16_predictors_mb(xd, xd->predictor,
&xd->predictor[256],
&xd->predictor[320], 16, 8);

69
vp9/common/vp9_reconinter.h
Просмотреть файл

@ -16,38 +16,21 @@
struct subpix_fn_table;
extern void vp9_build_1st_inter16x16_predictors_mby(MACROBLOCKD *xd,
uint8_t *dst_y,
int dst_ystride,
int clamp_mvs);
extern void vp9_build_inter16x16_predictors_mby(MACROBLOCKD *xd,
uint8_t *dst_y,
int dst_ystride);
extern void vp9_build_1st_inter16x16_predictors_mbuv(MACROBLOCKD *xd,
uint8_t *dst_u,
uint8_t *dst_v,
int dst_uvstride);
extern void vp9_build_inter16x16_predictors_mbuv(MACROBLOCKD *xd,
uint8_t *dst_u,
uint8_t *dst_v,
int dst_uvstride);
extern void vp9_build_1st_inter16x16_predictors_mb(MACROBLOCKD *xd,
uint8_t *dst_y,
uint8_t *dst_u,
uint8_t *dst_v,
int dst_ystride,
int dst_uvstride);
extern void vp9_build_2nd_inter16x16_predictors_mby(MACROBLOCKD *xd,
uint8_t *dst_y,
int dst_ystride);
extern void vp9_build_2nd_inter16x16_predictors_mbuv(MACROBLOCKD *xd,
uint8_t *dst_u,
uint8_t *dst_v,
int dst_uvstride);
extern void vp9_build_2nd_inter16x16_predictors_mb(MACROBLOCKD *xd,
uint8_t *dst_y,
uint8_t *dst_u,
uint8_t *dst_v,
int dst_ystride,
int dst_uvstride);
extern void vp9_build_inter16x16_predictors_mb(MACROBLOCKD *xd,
uint8_t *dst_y,
uint8_t *dst_u,
uint8_t *dst_v,
int dst_ystride,
int dst_uvstride);
extern void vp9_build_inter32x32_predictors_sb(MACROBLOCKD *x,
uint8_t *dst_y,
@ -65,22 +48,24 @@ extern void vp9_build_inter64x64_predictors_sb(MACROBLOCKD *x,
extern void vp9_build_inter_predictors_mb(MACROBLOCKD *xd);
extern void vp9_build_inter_predictors_b(BLOCKD *d, int pitch,
struct subpix_fn_table *sppf);
extern void vp9_build_2nd_inter_predictors_b(BLOCKD *d, int pitch,
struct subpix_fn_table *sppf);
extern void vp9_build_inter_predictors4b(MACROBLOCKD *xd, BLOCKD *d,
int pitch);
extern void vp9_build_2nd_inter_predictors4b(MACROBLOCKD *xd,
BLOCKD *d, int pitch);
extern void vp9_build_inter4x4_predictors_mbuv(MACROBLOCKD *xd);
extern void vp9_setup_interp_filters(MACROBLOCKD *xd,
INTERPOLATIONFILTERTYPE filter,
VP9_COMMON *cm);
void vp9_build_inter_predictor(const uint8_t *src, int src_stride,
uint8_t *dst, int dst_stride,
const int_mv *mv_q3,
const struct scale_factors *scale,
int w, int h, int do_avg,
const struct subpix_fn_table *subpix);
void vp9_build_inter_predictor_q4(const uint8_t *src, int src_stride,
uint8_t *dst, int dst_stride,
const int_mv *fullpel_mv_q3,
const int_mv *frac_mv_q4,
const struct scale_factors *scale,
int w, int h, int do_avg,
const struct subpix_fn_table *subpix);
#endif // VP9_COMMON_VP9_RECONINTER_H_

23
vp9/decoder/vp9_decodframe.c
Просмотреть файл

@ -177,23 +177,14 @@ static void skip_recon_mb(VP9D_COMP *pbi, MACROBLOCKD *xd) {
xd->dst.y_stride,
xd->dst.uv_stride);
} else {
vp9_build_1st_inter16x16_predictors_mb(xd,
xd->dst.y_buffer,
xd->dst.u_buffer,
xd->dst.v_buffer,
xd->dst.y_stride,
xd->dst.uv_stride);
if (xd->mode_info_context->mbmi.second_ref_frame > 0) {
vp9_build_2nd_inter16x16_predictors_mb(xd,
xd->dst.y_buffer,
xd->dst.u_buffer,
xd->dst.v_buffer,
xd->dst.y_stride,
xd->dst.uv_stride);
}
vp9_build_inter16x16_predictors_mb(xd,
xd->dst.y_buffer,
xd->dst.u_buffer,
xd->dst.v_buffer,
xd->dst.y_stride,
xd->dst.uv_stride);
#if CONFIG_COMP_INTERINTRA_PRED
else if (xd->mode_info_context->mbmi.second_ref_frame == INTRA_FRAME) {
if (xd->mode_info_context->mbmi.second_ref_frame == INTRA_FRAME) {
vp9_build_interintra_16x16_predictors_mb(xd,
xd->dst.y_buffer,
xd->dst.u_buffer,

22
vp9/encoder/vp9_encodeframe.c
Просмотреть файл

@ -2125,22 +2125,14 @@ static void encode_macroblock(VP9_COMP *cpi, TOKENEXTRA **t,
mbmi->mb_skip_coeff = 0;
} else {
vp9_build_1st_inter16x16_predictors_mb(xd,
xd->dst.y_buffer,
xd->dst.u_buffer,
xd->dst.v_buffer,
xd->dst.y_stride,
xd->dst.uv_stride);
if (xd->mode_info_context->mbmi.second_ref_frame > 0) {
vp9_build_2nd_inter16x16_predictors_mb(xd,
xd->dst.y_buffer,
xd->dst.u_buffer,
xd->dst.v_buffer,
xd->dst.y_stride,
xd->dst.uv_stride);
}
vp9_build_inter16x16_predictors_mb(xd,
xd->dst.y_buffer,
xd->dst.u_buffer,
xd->dst.v_buffer,
xd->dst.y_stride,
xd->dst.uv_stride);
#if CONFIG_COMP_INTERINTRA_PRED
else if (xd->mode_info_context->mbmi.second_ref_frame == INTRA_FRAME) {
if (xd->mode_info_context->mbmi.second_ref_frame == INTRA_FRAME) {
vp9_build_interintra_16x16_predictors_mb(xd,
xd->dst.y_buffer,
xd->dst.u_buffer,

2
vp9/encoder/vp9_encodemb.c
Просмотреть файл

@ -713,7 +713,7 @@ void vp9_encode_inter16x16y(MACROBLOCK *x) {
MACROBLOCKD *xd = &x->e_mbd;
BLOCK *b = &x->block[0];
vp9_build_1st_inter16x16_predictors_mby(xd, xd->predictor, 16, 0);
vp9_build_inter16x16_predictors_mby(xd, xd->predictor, 16);
vp9_subtract_mby(x->src_diff, *(b->base_src), xd->predictor, b->src_stride);

5
vp9/encoder/vp9_mbgraph.c
Просмотреть файл

@ -72,7 +72,7 @@ static unsigned int do_16x16_motion_iteration(VP9_COMP *cpi,
}
vp9_set_mbmode_and_mvs(x, NEWMV, dst_mv);
vp9_build_1st_inter16x16_predictors_mby(xd, xd->predictor, 16, 0);
vp9_build_inter16x16_predictors_mby(xd, xd->predictor, 16);
best_err = vp9_sad16x16(xd->dst.y_buffer, xd->dst.y_stride,
xd->predictor, 16, INT_MAX);
@ -292,6 +292,9 @@ static void update_mbgraph_frame_stats
int_mv arf_top_mv, gld_top_mv;
MODE_INFO mi_local;
// Make sure the mi context starts in a consistent state.
memset(&mi_local, 0, sizeof(mi_local));
// Set up limit values for motion vectors to prevent them extending outside the UMV borders
arf_top_mv.as_int = 0;
gld_top_mv.as_int = 0;

65
vp9/encoder/vp9_rdopt.c
Просмотреть файл

@ -2115,9 +2115,22 @@ static int64_t encode_inter_mb_segment(MACROBLOCK *x,
BLOCK *be = &x->block[i];
int thisdistortion;
vp9_build_inter_predictors_b(bd, 16, &xd->subpix);
if (xd->mode_info_context->mbmi.second_ref_frame > 0)
vp9_build_2nd_inter_predictors_b(bd, 16, &xd->subpix);
vp9_build_inter_predictor(*(bd->base_pre) + bd->pre,
bd->pre_stride,
bd->predictor, 16,
&bd->bmi.as_mv[0],
&xd->scale_factor[0],
4, 4, 0 /* no avg */, &xd->subpix);
if (xd->mode_info_context->mbmi.second_ref_frame > 0) {
vp9_build_inter_predictor(*(bd->base_second_pre) + bd->pre,
bd->pre_stride,
bd->predictor, 16,
&bd->bmi.as_mv[1],
&xd->scale_factor[1],
4, 4, 1 /* avg */, &xd->subpix);
}
vp9_subtract_b(be, bd, 16);
x->fwd_txm4x4(be->src_diff, be->coeff, 32);
x->quantize_b_4x4(be, bd);
@ -2159,14 +2172,25 @@ static int64_t encode_inter_mb_segment_8x8(MACROBLOCK *x,
int ib = vp9_i8x8_block[i];
if (labels[ib] == which_label) {
const int use_second_ref =
xd->mode_info_context->mbmi.second_ref_frame > 0;
int which_mv;
int idx = (ib & 8) + ((ib & 2) << 1);
BLOCKD *bd = &xd->block[ib], *bd2 = &xd->block[idx];
BLOCK *be = &x->block[ib], *be2 = &x->block[idx];
int thisdistortion;
vp9_build_inter_predictors4b(xd, bd, 16);
if (xd->mode_info_context->mbmi.second_ref_frame > 0)
vp9_build_2nd_inter_predictors4b(xd, bd, 16);
for (which_mv = 0; which_mv < 1 + use_second_ref; ++which_mv) {
uint8_t **base_pre = which_mv ? bd->base_second_pre : bd->base_pre;
vp9_build_inter_predictor(*base_pre + bd->pre,
bd->pre_stride,
bd->predictor, 16,
&bd->bmi.as_mv[which_mv],
&xd->scale_factor[which_mv],
8, 8, which_mv, &xd->subpix);
}
vp9_subtract_4b_c(be, bd, 16);
if (xd->mode_info_context->mbmi.txfm_size == TX_4X4) {
@ -3482,19 +3506,19 @@ static int64_t handle_inter_mode(VP9_COMP *cpi, MACROBLOCK *x,
unsigned int sse, var;
int tmp_rate_y, tmp_rate_u, tmp_rate_v;
int tmp_dist_y, tmp_dist_u, tmp_dist_v;
vp9_build_1st_inter16x16_predictors_mby(xd, xd->predictor, 16, 0);
if (is_comp_pred)
vp9_build_2nd_inter16x16_predictors_mby(xd, xd->predictor, 16);
// TODO(jkoleszar): these 2 y/uv should be replaced with one call to
// vp9_build_interintra_16x16_predictors_mb().
vp9_build_inter16x16_predictors_mby(xd, xd->predictor, 16);
#if CONFIG_COMP_INTERINTRA_PRED
if (is_comp_interintra_pred) {
vp9_build_interintra_16x16_predictors_mby(xd, xd->predictor, 16);
}
#endif
vp9_build_1st_inter16x16_predictors_mbuv(xd, xd->predictor + 256,
xd->predictor + 320, 8);
if (is_comp_pred)
vp9_build_2nd_inter16x16_predictors_mbuv(xd, xd->predictor + 256,
xd->predictor + 320, 8);
vp9_build_inter16x16_predictors_mbuv(xd, xd->predictor + 256,
xd->predictor + 320, 8);
#if CONFIG_COMP_INTERINTRA_PRED
if (is_comp_interintra_pred) {
vp9_build_interintra_16x16_predictors_mbuv(xd, xd->predictor + 256,
@ -3598,19 +3622,16 @@ static int64_t handle_inter_mode(VP9_COMP *cpi, MACROBLOCK *x,
xd->dst.y_stride,
xd->dst.uv_stride);
} else {
vp9_build_1st_inter16x16_predictors_mby(xd, xd->predictor, 16, 0);
if (is_comp_pred)
vp9_build_2nd_inter16x16_predictors_mby(xd, xd->predictor, 16);
// TODO(jkoleszar): These y/uv fns can be replaced with their mb
// equivalent
vp9_build_inter16x16_predictors_mby(xd, xd->predictor, 16);
#if CONFIG_COMP_INTERINTRA_PRED
if (is_comp_interintra_pred) {
vp9_build_interintra_16x16_predictors_mby(xd, xd->predictor, 16);
}
#endif
vp9_build_1st_inter16x16_predictors_mbuv(xd, &xd->predictor[256],
&xd->predictor[320], 8);
if (is_comp_pred)
vp9_build_2nd_inter16x16_predictors_mbuv(xd, &xd->predictor[256],
&xd->predictor[320], 8);
vp9_build_inter16x16_predictors_mbuv(xd, &xd->predictor[256],
&xd->predictor[320], 8);
#if CONFIG_COMP_INTERINTRA_PRED
if (is_comp_interintra_pred) {
vp9_build_interintra_16x16_predictors_mbuv(xd, &xd->predictor[256],

52
vp9/encoder/vp9_temporal_filter.c
Просмотреть файл

@ -12,6 +12,7 @@
#include <limits.h>
#include "vp9/common/vp9_onyxc_int.h"
#include "vp9/common/vp9_reconinter.h"
#include "vp9/encoder/vp9_onyx_int.h"
#include "vp9/common/vp9_systemdependent.h"
#include "vp9/encoder/vp9_quantize.h"
@ -42,40 +43,35 @@ static void temporal_filter_predictors_mb_c(MACROBLOCKD *xd,
int mv_row,
int mv_col,
uint8_t *pred) {
int offset;
uint8_t *yptr, *uptr, *vptr;
int omv_row, omv_col;
const int which_mv = 0;
int_mv subpel_mv;
int_mv fullpel_mv;
// Y
yptr = y_mb_ptr + (mv_row >> 3) * stride + (mv_col >> 3);
subpel_mv.as_mv.row = mv_row;
subpel_mv.as_mv.col = mv_col;
// TODO(jkoleszar): Make this rounding consistent with the rest of the code
fullpel_mv.as_mv.row = (mv_row >> 1) & ~7;
fullpel_mv.as_mv.col = (mv_col >> 1) & ~7;
xd->subpix.predict[!!(mv_col & 7)][!!(mv_row & 7)][0](
yptr, stride, &pred[0], 16,
xd->subpix.filter_x[(mv_col & 7) << 1], xd->subpix.x_step_q4,
xd->subpix.filter_y[(mv_row & 7) << 1], xd->subpix.y_step_q4,
16, 16);
vp9_build_inter_predictor(y_mb_ptr, stride,
&pred[0], 16,
&subpel_mv,
&xd->scale_factor[which_mv],
16, 16, which_mv, &xd->subpix);
// U & V
omv_row = mv_row;
omv_col = mv_col;
mv_row >>= 1;
mv_col >>= 1;
stride = (stride + 1) >> 1;
offset = (mv_row >> 3) * stride + (mv_col >> 3);
uptr = u_mb_ptr + offset;
vptr = v_mb_ptr + offset;
xd->subpix.predict[!!(omv_col & 15)][!!(omv_row & 15)][0](
uptr, stride, &pred[256], 8,
xd->subpix.filter_x[(omv_col & 15)], xd->subpix.x_step_q4,
xd->subpix.filter_y[(omv_row & 15)], xd->subpix.y_step_q4,
8, 8);
vp9_build_inter_predictor_q4(u_mb_ptr, stride,
&pred[256], 8,
&fullpel_mv, &subpel_mv,
&xd->scale_factor_uv[which_mv],
8, 8, which_mv, &xd->subpix);
xd->subpix.predict[!!(omv_col & 15)][!!(omv_row & 15)][0](
vptr, stride, &pred[320], 8,
xd->subpix.filter_x[(omv_col & 15)], xd->subpix.x_step_q4,
xd->subpix.filter_y[(omv_row & 15)], xd->subpix.y_step_q4,
8, 8);
vp9_build_inter_predictor_q4(v_mb_ptr, stride,
&pred[320], 8,
&fullpel_mv, &subpel_mv,
&xd->scale_factor_uv[which_mv],
8, 8, which_mv, &xd->subpix);
}
void vp9_temporal_filter_apply_c(uint8_t *frame1,