generic-library/vpx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge "Adds compound wedge prediction modes" into nextgenv2

Browse Source
This commit is contained in:
Debargha Mukherjee
2016-03-10 17:44:45 +00:00
committed by Gerrit Code Review
parent ccc809f30c f34deab243
commit ce4b35d510
21 changed files with 2959 additions and 318 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
vp10/common/blockd.h
View File

@@ -45,6 +45,7 @@ typedef enum {
#endif // CONFIG_EXT_INTERP && SUPPORT_NONINTERPOLATING_FILTERS
#define MAXTXLEN 32
#define CU_SIZE 64
static INLINE int is_inter_mode(PREDICTION_MODE mode) {
#if CONFIG_EXT_INTER
@@ -55,6 +56,23 @@ static INLINE int is_inter_mode(PREDICTION_MODE mode) {
}
#if CONFIG_EXT_INTER
#define WEDGE_BITS_SML 3
#define WEDGE_BITS_MED 4
#define WEDGE_BITS_BIG 5
#define WEDGE_NONE -1
#define WEDGE_WEIGHT_BITS 6
static INLINE int get_wedge_bits(BLOCK_SIZE sb_type) {
if (sb_type < BLOCK_8X8)
return 0;
if (sb_type <= BLOCK_8X8)
return WEDGE_BITS_SML;
else if (sb_type <= BLOCK_32X32)
return WEDGE_BITS_MED;
else
return WEDGE_BITS_BIG;
}
static INLINE int is_inter_singleref_mode(PREDICTION_MODE mode) {
return mode >= NEARESTMV && mode <= NEWFROMNEARMV;
}
@@ -69,6 +87,11 @@ static INLINE int have_newmv_in_inter_mode(PREDICTION_MODE mode) {
mode == NEAREST_NEWMV || mode == NEW_NEARESTMV ||
mode == NEAR_NEWMV || mode == NEW_NEARMV);
}
#else
static INLINE int have_newmv_in_inter_mode(PREDICTION_MODE mode) {
return (mode == NEWMV);
}
#endif // CONFIG_EXT_INTER
/* For keyframes, intra block modes are predicted by the (already decoded)
@@ -172,6 +195,12 @@ typedef struct {
#if CONFIG_EXT_INTER
PREDICTION_MODE interintra_mode;
PREDICTION_MODE interintra_uv_mode;
// TODO(debargha): Consolidate these flags
int use_wedge_interintra;
int interintra_wedge_index;
int interintra_uv_wedge_index;
int use_wedge_interinter;
int interinter_wedge_index;
#endif // CONFIG_EXT_INTER
#if CONFIG_OBMC
@@ -203,12 +232,6 @@ static INLINE int has_second_ref(const MB_MODE_INFO *mbmi) {
return mbmi->ref_frame[1] > INTRA_FRAME;
}
#if CONFIG_OBMC
static INLINE int is_obmc_allowed(const MB_MODE_INFO *mbmi) {
return (mbmi->sb_type >= BLOCK_8X8);
}
#endif // CONFIG_OBMC
PREDICTION_MODE vp10_left_block_mode(const MODE_INFO *cur_mi,
const MODE_INFO *left_mi, int b);
@@ -647,6 +670,23 @@ static INLINE int is_interintra_pred(const MB_MODE_INFO *mbmi) {
}
#endif // CONFIG_EXT_INTER
#if CONFIG_OBMC
static INLINE int is_obmc_allowed(const MB_MODE_INFO *mbmi) {
return (mbmi->sb_type >= BLOCK_8X8);
}
static INLINE int is_neighbor_overlappable(const MB_MODE_INFO *mbmi) {
#if CONFIG_EXT_INTER
return (is_inter_block(mbmi) &&
!(has_second_ref(mbmi) && get_wedge_bits(mbmi->sb_type) &&
mbmi->use_wedge_interinter) &&
!(is_interintra_pred(mbmi)));
#else
return (is_inter_block(mbmi));
#endif // CONFIG_EXT_INTER
}
#endif // CONFIG_OBMC
#ifdef __cplusplus
} // extern "C"
#endif

26
vp10/common/entropymode.c
View File

@@ -10,6 +10,7 @@
#include "vpx_mem/vpx_mem.h"
#include "vp10/common/reconinter.h"
#include "vp10/common/onyxc_int.h"
#include "vp10/common/seg_common.h"
@@ -190,8 +191,8 @@ static const vpx_prob default_drl_prob[DRL_MODE_CONTEXTS] = {
#if CONFIG_EXT_INTER
static const vpx_prob default_new2mv_prob = 180;
#endif
#endif
#endif // CONFIG_EXT_INTER
#endif // CONFIG_REF_MV
static const vpx_prob default_inter_mode_probs[INTER_MODE_CONTEXTS]
[INTER_MODES - 1] = {
@@ -230,6 +231,14 @@ static const vpx_prob default_inter_compound_mode_probs
static const vpx_prob default_interintra_prob[BLOCK_SIZES] = {
192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
};
static const vpx_prob default_wedge_interintra_prob[BLOCK_SIZES] = {
192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
};
static const vpx_prob default_wedge_interinter_prob[BLOCK_SIZES] = {
192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
};
#endif // CONFIG_EXT_INTER
#if CONFIG_OBMC
@@ -1327,6 +1336,8 @@ static void init_mode_probs(FRAME_CONTEXT *fc) {
#if CONFIG_EXT_INTER
vp10_copy(fc->inter_compound_mode_probs, default_inter_compound_mode_probs);
vp10_copy(fc->interintra_prob, default_interintra_prob);
vp10_copy(fc->wedge_interintra_prob, default_wedge_interintra_prob);
vp10_copy(fc->wedge_interinter_prob, default_wedge_interinter_prob);
#endif // CONFIG_EXT_INTER
#if CONFIG_SUPERTX
vp10_copy(fc->supertx_prob, default_supertx_prob);
@@ -1435,12 +1446,21 @@ void vp10_adapt_inter_frame_probs(VP10_COMMON *cm) {
pre_fc->inter_compound_mode_probs[i],
counts->inter_compound_mode[i],
fc->inter_compound_mode_probs[i]);
for (i = 0; i < BLOCK_SIZES; ++i) {
if (is_interintra_allowed_bsize(i))
fc->interintra_prob[i] = mode_mv_merge_probs(pre_fc->interintra_prob[i],
counts->interintra[i]);
}
for (i = 0; i < BLOCK_SIZES; ++i) {
if (is_interintra_allowed_bsize(i) && get_wedge_bits(i))
fc->wedge_interintra_prob[i] = mode_mv_merge_probs(
pre_fc->wedge_interintra_prob[i], counts->wedge_interintra[i]);
}
for (i = 0; i < BLOCK_SIZES; ++i) {
if (get_wedge_bits(i))
fc->wedge_interinter_prob[i] = mode_mv_merge_probs(
pre_fc->wedge_interinter_prob[i], counts->wedge_interinter[i]);
}
#endif // CONFIG_EXT_INTER
for (i = 0; i < BLOCK_SIZE_GROUPS; i++)

6
vp10/common/entropymode.h
View File

@@ -61,13 +61,15 @@ typedef struct frame_contexts {
#if CONFIG_EXT_INTER
vpx_prob new2mv_prob;
#endif // CONFIG_EXT_INTER
#endif
#endif // CONFIG_REF_MV
vpx_prob inter_mode_probs[INTER_MODE_CONTEXTS][INTER_MODES - 1];
#if CONFIG_EXT_INTER
vpx_prob inter_compound_mode_probs[INTER_MODE_CONTEXTS]
[INTER_COMPOUND_MODES - 1];
vpx_prob interintra_prob[BLOCK_SIZES];
vpx_prob wedge_interintra_prob[BLOCK_SIZES];
vpx_prob wedge_interinter_prob[BLOCK_SIZES];
#endif // CONFIG_EXT_INTER
#if CONFIG_OBMC
vpx_prob obmc_prob[BLOCK_SIZES];
@@ -130,6 +132,8 @@ typedef struct FRAME_COUNTS {
#if CONFIG_EXT_INTER
unsigned int inter_compound_mode[INTER_MODE_CONTEXTS][INTER_COMPOUND_MODES];
unsigned int interintra[BLOCK_SIZES][2];
unsigned int wedge_interintra[BLOCK_SIZES][2];
unsigned int wedge_interinter[BLOCK_SIZES][2];
#endif // CONFIG_EXT_INTER
#if CONFIG_OBMC
unsigned int obmc[BLOCK_SIZES][2];

41
vp10/common/enums.h
View File

@@ -41,21 +41,32 @@ typedef enum BITSTREAM_PROFILE {
MAX_PROFILES
} BITSTREAM_PROFILE;
#define BLOCK_4X4 0
#define BLOCK_4X8 1
#define BLOCK_8X4 2
#define BLOCK_8X8 3
#define BLOCK_8X16 4
#define BLOCK_16X8 5
#define BLOCK_16X16 6
#define BLOCK_16X32 7
#define BLOCK_32X16 8
#define BLOCK_32X32 9
#define BLOCK_32X64 10
#define BLOCK_64X32 11
#define BLOCK_64X64 12
#define BLOCK_SIZES 13
#define BLOCK_INVALID BLOCK_SIZES
#define BLOCK_4X4 0
#define BLOCK_4X8 1
#define BLOCK_8X4 2
#define BLOCK_8X8 3
#define BLOCK_8X16 4
#define BLOCK_16X8 5
#define BLOCK_16X16 6
#define BLOCK_16X32 7
#define BLOCK_32X16 8
#define BLOCK_32X32 9
#define BLOCK_32X64 10
#define BLOCK_64X32 11
#define BLOCK_64X64 12
#if CONFIG_EXT_PARTITION
#define BLOCK_64X128 13
#define BLOCK_128X64 14
#define BLOCK_128X128 15
#define BLOCK_SIZES 16
#else
#define BLOCK_SIZES 13
#endif // CONFIG_EXT_PARTITION
#define BLOCK_INVALID (BLOCK_SIZES)
#define BLOCK_LARGEST (BLOCK_SIZES - 1)
typedef uint8_t BLOCK_SIZE;
typedef enum PARTITION_TYPE {

927
vp10/common/reconinter.c
View File

File diff suppressed because it is too large Load Diff

127
vp10/common/reconinter.h
View File

@@ -62,14 +62,14 @@ static INLINE void inter_predictor(const uint8_t *src, int src_stride,
}
#if CONFIG_VP9_HIGHBITDEPTH
static INLINE void high_inter_predictor(const uint8_t *src, int src_stride,
uint8_t *dst, int dst_stride,
const int subpel_x,
const int subpel_y,
const struct scale_factors *sf,
int w, int h, int ref,
const INTERP_FILTER interp_filter,
int xs, int ys, int bd) {
static INLINE void highbd_inter_predictor(const uint8_t *src, int src_stride,
uint8_t *dst, int dst_stride,
const int subpel_x,
const int subpel_y,
const struct scale_factors *sf,
int w, int h, int ref,
const INTERP_FILTER interp_filter,
int xs, int ys, int bd) {
InterpFilterParams interp_filter_params =
vp10_get_interp_filter_params(interp_filter);
if (interp_filter_params.taps == SUBPEL_TAPS) {
@@ -105,6 +105,61 @@ static INLINE void high_inter_predictor(const uint8_t *src, int src_stride,
}
#endif // CONFIG_VP9_HIGHBITDEPTH
void build_inter_predictors(MACROBLOCKD *xd, int plane,
#if CONFIG_OBMC
int mi_col_offset, int mi_row_offset,
#endif // CONFIG_OBMC
int block,
int bw, int bh,
int x, int y, int w, int h,
#if CONFIG_SUPERTX && CONFIG_EXT_INTER
int wedge_offset_x, int wedge_offset_y,
#endif // CONFIG_SUPERTX && CONFIG_EXT_INTER
int mi_x, int mi_y);
static INLINE void vp10_make_inter_predictor(
const uint8_t *src,
int src_stride,
uint8_t *dst,
int dst_stride,
const int subpel_x,
const int subpel_y,
const struct scale_factors *sf,
int w, int h, int ref,
const INTERP_FILTER interp_filter,
int xs, int ys,
const MACROBLOCKD *xd) {
(void) xd;
#if CONFIG_VP9_HIGHBITDEPTH
if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH)
highbd_inter_predictor(src, src_stride, dst, dst_stride,
subpel_x, subpel_y, sf, w, h, ref,
interp_filter, xs, ys, xd->bd);
else
#endif // CONFIG_VP9_HIGHBITDEPTH
inter_predictor(src, src_stride, dst, dst_stride,
subpel_x, subpel_y, sf, w, h, ref,
interp_filter, xs, ys);
}
#if CONFIG_EXT_INTER
void vp10_make_masked_inter_predictor(
const uint8_t *pre,
int pre_stride,
uint8_t *dst,
int dst_stride,
const int subpel_x,
const int subpel_y,
const struct scale_factors *sf,
int w, int h,
const INTERP_FILTER interp_filter,
int xs, int ys,
#if CONFIG_SUPERTX
int plane, int wedge_offset_x, int wedge_offset_y,
#endif // CONFIG_SUPERTX
const MACROBLOCKD *xd);
#endif // CONFIG_EXT_INTER
static INLINE int round_mv_comp_q4(int value) {
return (value < 0 ? value - 2 : value + 2) / 4;
}
@@ -114,10 +169,10 @@ static MV mi_mv_pred_q4(const MODE_INFO *mi, int idx) {
mi->bmi[1].as_mv[idx].as_mv.row +
mi->bmi[2].as_mv[idx].as_mv.row +
mi->bmi[3].as_mv[idx].as_mv.row),
round_mv_comp_q4(mi->bmi[0].as_mv[idx].as_mv.col +
mi->bmi[1].as_mv[idx].as_mv.col +
mi->bmi[2].as_mv[idx].as_mv.col +
mi->bmi[3].as_mv[idx].as_mv.col) };
round_mv_comp_q4(mi->bmi[0].as_mv[idx].as_mv.col +
mi->bmi[1].as_mv[idx].as_mv.col +
mi->bmi[2].as_mv[idx].as_mv.col +
mi->bmi[3].as_mv[idx].as_mv.col) };
return res;
}
@@ -183,15 +238,6 @@ static INLINE MV average_split_mvs(const struct macroblockd_plane *pd,
return res;
}
void build_inter_predictors(MACROBLOCKD *xd, int plane,
#if CONFIG_OBMC
int mi_col_offset, int mi_row_offset,
#endif // CONFIG_OBMC
int block,
int bw, int bh,
int x, int y, int w, int h,
int mi_x, int mi_y);
void vp10_build_inter_predictor_sub8x8(MACROBLOCKD *xd, int plane,
int i, int ir, int ic,
int mi_row, int mi_col);
@@ -209,9 +255,21 @@ void vp10_build_inter_predictors_sb(MACROBLOCKD *xd, int mi_row, int mi_col,
BLOCK_SIZE bsize);
#if CONFIG_SUPERTX
void vp10_build_inter_predictors_sb_sub8x8(MACROBLOCKD *xd,
int mi_row, int mi_col,
BLOCK_SIZE bsize, int block);
void vp10_build_inter_predictors_sb_sub8x8_extend(
MACROBLOCKD *xd,
#if CONFIG_EXT_INTER
int mi_row_ori, int mi_col_ori,
#endif // CONFIG_EXT_INTER
int mi_row, int mi_col,
BLOCK_SIZE bsize, int block);
void vp10_build_inter_predictors_sb_extend(
MACROBLOCKD *xd,
#if CONFIG_EXT_INTER
int mi_row_ori, int mi_col_ori,
#endif // CONFIG_EXT_INTER
int mi_row, int mi_col,
BLOCK_SIZE bsize);
struct macroblockd_plane;
void vp10_build_masked_inter_predictor_complex(
MACROBLOCKD *xd,
@@ -219,7 +277,6 @@ void vp10_build_masked_inter_predictor_complex(
const struct macroblockd_plane *pd, int mi_row, int mi_col,
int mi_row_ori, int mi_col_ori, BLOCK_SIZE bsize, BLOCK_SIZE top_bsize,
PARTITION_TYPE partition, int plane);
#endif // CONFIG_SUPERTX
void vp10_build_inter_predictor(const uint8_t *src, int src_stride,
@@ -376,6 +433,15 @@ void vp10_build_obmc_inter_prediction(VP10_COMMON *cm,
#endif // CONFIG_OBMC
#if CONFIG_EXT_INTER
#define MASK_MASTER_SIZE (2 * CU_SIZE)
#define MASK_MASTER_STRIDE (2 * CU_SIZE)
void vp10_init_wedge_masks();
const uint8_t *vp10_get_soft_mask(int wedge_index,
BLOCK_SIZE sb_type,
int h, int w);
void vp10_build_interintra_predictors(MACROBLOCKD *xd,
uint8_t *ypred,
uint8_t *upred,
@@ -398,6 +464,17 @@ void vp10_build_interintra_predictors_sbuv(MACROBLOCKD *xd,
uint8_t *vpred,
int ustride, int vstride,
BLOCK_SIZE bsize);
// Encoder only
void vp10_build_inter_predictors_for_planes_single_buf(
MACROBLOCKD *xd, BLOCK_SIZE bsize,
int mi_row, int mi_col, int ref,
uint8_t *ext_dst[3], int ext_dst_stride[3]);
void vp10_build_wedge_inter_predictor_from_buf(
MACROBLOCKD *xd, BLOCK_SIZE bsize,
int mi_row, int mi_col,
uint8_t *ext_dst0[3], int ext_dst_stride0[3],
uint8_t *ext_dst1[3], int ext_dst_stride1[3]);
#endif // CONFIG_EXT_INTER
#ifdef __cplusplus

7
vp10/common/thread_common.c
View File

@@ -412,6 +412,13 @@ void vp10_accumulate_frame_counts(VP10_COMMON *cm, FRAME_COUNTS *counts,
for (i = 0; i < BLOCK_SIZES; i++)
for (j = 0; j < 2; j++)
cm->counts.interintra[i][j] += counts->interintra[i][j];
for (i = 0; i < BLOCK_SIZES; i++)
for (j = 0; j < 2; j++)
cm->counts.wedge_interintra[i][j] += counts->wedge_interintra[i][j];
for (i = 0; i < BLOCK_SIZES; i++)
for (j = 0; j < 2; j++)
cm->counts.wedge_interinter[i][j] += counts->wedge_interinter[i][j];
#endif // CONFIG_EXT_INTER
for (i = 0; i < INTRA_INTER_CONTEXTS; i++)

8
vp10/common/vp10_rtcd_defs.pl
View File

@@ -12,7 +12,7 @@ struct macroblockd;
/* Encoder forward decls */
struct macroblock;
struct vp9_variance_vtable;
struct vp10_variance_vtable;
struct search_site_config;
struct mv;
union int_mv;
@@ -614,15 +614,15 @@ if (vpx_config("CONFIG_VP9_HIGHBITDEPTH") eq "yes") {
#
# Motion search
#
add_proto qw/int vp10_full_search_sad/, "const struct macroblock *x, const struct mv *ref_mv, int sad_per_bit, int distance, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv, struct mv *best_mv";
add_proto qw/int vp10_full_search_sad/, "const struct macroblock *x, const struct mv *ref_mv, int sad_per_bit, int distance, const struct vp10_variance_vtable *fn_ptr, const struct mv *center_mv, struct mv *best_mv";
specialize qw/vp10_full_search_sad sse3 sse4_1/;
$vp10_full_search_sad_sse3=vp10_full_search_sadx3;
$vp10_full_search_sad_sse4_1=vp10_full_search_sadx8;
add_proto qw/int vp10_diamond_search_sad/, "const struct macroblock *x, const struct search_site_config *cfg, struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv";
add_proto qw/int vp10_diamond_search_sad/, "const struct macroblock *x, const struct search_site_config *cfg, struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp10_variance_vtable *fn_ptr, const struct mv *center_mv";
specialize qw/vp10_diamond_search_sad/;
add_proto qw/int vp10_full_range_search/, "const struct macroblock *x, const struct search_site_config *cfg, struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv";
add_proto qw/int vp10_full_range_search/, "const struct macroblock *x, const struct search_site_config *cfg, struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp10_variance_vtable *fn_ptr, const struct mv *center_mv";
specialize qw/vp10_full_range_search/;
add_proto qw/void vp10_temporal_filter_apply/, "uint8_t *frame1, unsigned int stride, uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, unsigned int *accumulator, uint16_t *count";

376
vp10/decoder/decodeframe.c
View File

@@ -529,10 +529,10 @@ static void build_mc_border(const uint8_t *src, int src_stride,
}
#if CONFIG_VP9_HIGHBITDEPTH
static void high_build_mc_border(const uint8_t *src8, int src_stride,
uint16_t *dst, int dst_stride,
int x, int y, int b_w, int b_h,
int w, int h) {
static void build_mc_border_highbd(const uint8_t *src8, int src_stride,
uint16_t *dst, int dst_stride,
int x, int y, int b_w, int b_h,
int w, int h) {
// Get a pointer to the start of the real data for this row.
const uint16_t *src = CONVERT_TO_SHORTPTR(src8);
const uint16_t *ref_row = src - x - y * src_stride;
@@ -574,39 +574,54 @@ static void high_build_mc_border(const uint8_t *src8, int src_stride,
} while (--b_h);
}
static void extend_and_predict(const uint8_t *buf_ptr1, int pre_buf_stride,
int x0, int y0, int b_w, int b_h,
int frame_width, int frame_height,
int border_offset,
uint8_t *const dst, int dst_buf_stride,
int subpel_x, int subpel_y,
const INTERP_FILTER interp_filter,
const struct scale_factors *sf,
MACROBLOCKD *xd,
int w, int h, int ref, int xs, int ys) {
DECLARE_ALIGNED(16, uint16_t, mc_buf_high[80 * 2 * 80 * 2]);
static void extend_and_predict_highbd(const uint8_t *buf_ptr1,
int pre_buf_stride,
int x0, int y0, int b_w, int b_h,
int frame_width, int frame_height,
int border_offset,
uint8_t *const dst, int dst_buf_stride,
int subpel_x, int subpel_y,
const INTERP_FILTER interp_filter,
const struct scale_factors *sf,
#if CONFIG_EXT_INTER && CONFIG_SUPERTX
int plane,
int wedge_offset_x, int wedge_offset_y,
#endif // CONFIG_EXT_INTER && CONFIG_SUPERTX
MACROBLOCKD *xd,
int w, int h, int ref, int xs, int ys) {
DECLARE_ALIGNED(16, uint16_t,
mc_buf_high[(CU_SIZE + 16) * 2 * (CU_SIZE + 16) * 2]);
const uint8_t *buf_ptr;
if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
high_build_mc_border(buf_ptr1, pre_buf_stride, mc_buf_high, b_w,
x0, y0, b_w, b_h, frame_width, frame_height);
build_mc_border_highbd(buf_ptr1, pre_buf_stride, mc_buf_high, b_w,
x0, y0, b_w, b_h, frame_width, frame_height);
buf_ptr = CONVERT_TO_BYTEPTR(mc_buf_high) + border_offset;
} else {
build_mc_border(buf_ptr1, pre_buf_stride, (uint8_t *)mc_buf_high, b_w,
x0, y0, b_w, b_h, frame_width, frame_height);
buf_ptr = ((uint8_t *)mc_buf_high) + border_offset;
}
if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
high_inter_predictor(buf_ptr, b_w, dst, dst_buf_stride, subpel_x,
subpel_y, sf, w, h, ref, interp_filter,
xs, ys, xd->bd);
} else {
inter_predictor(buf_ptr, b_w, dst, dst_buf_stride, subpel_x,
subpel_y, sf, w, h, ref, interp_filter, xs, ys);
}
#if CONFIG_EXT_INTER
if (ref && get_wedge_bits(xd->mi[0]->mbmi.sb_type) &&
xd->mi[0]->mbmi.use_wedge_interinter)
vp10_make_masked_inter_predictor(
buf_ptr, b_w, dst, dst_buf_stride,
subpel_x, subpel_y, sf, w, h,
interp_filter, xs, ys,
#if CONFIG_SUPERTX
plane, wedge_offset_x, wedge_offset_y,
#endif // CONFIG_SUPERTX
xd);
else
#endif // CONFIG_EXT_INTER
vp10_make_inter_predictor(buf_ptr, b_w, dst, dst_buf_stride,
subpel_x, subpel_y, sf, w, h, ref,
interp_filter, xs, ys, xd);
}
#else
static void extend_and_predict(const uint8_t *buf_ptr1, int pre_buf_stride,
int x0, int y0, int b_w, int b_h,
int frame_width, int frame_height,
@@ -615,21 +630,48 @@ static void extend_and_predict(const uint8_t *buf_ptr1, int pre_buf_stride,
int subpel_x, int subpel_y,
const INTERP_FILTER interp_filter,
const struct scale_factors *sf,
#if CONFIG_EXT_INTER && CONFIG_SUPERTX
int plane,
int wedge_offset_x, int wedge_offset_y,
#endif // CONFIG_EXT_INTER && CONFIG_SUPERTX
MACROBLOCKD *xd,
int w, int h, int ref, int xs, int ys) {
DECLARE_ALIGNED(16, uint8_t, mc_buf[80 * 2 * 80 * 2]);
DECLARE_ALIGNED(16, uint8_t, mc_buf[(CU_SIZE + 16) * 2 * (CU_SIZE + 16) * 2]);
const uint8_t *buf_ptr;
build_mc_border(buf_ptr1, pre_buf_stride, mc_buf, b_w,
x0, y0, b_w, b_h, frame_width, frame_height);
buf_ptr = mc_buf + border_offset;
inter_predictor(buf_ptr, b_w, dst, dst_buf_stride, subpel_x,
subpel_y, sf, w, h, ref, interp_filter, xs, ys);
#if CONFIG_EXT_INTER
if (ref && get_wedge_bits(xd->mi[0]->mbmi.sb_type) &&
xd->mi[0]->mbmi.use_wedge_interinter)
vp10_make_masked_inter_predictor(
buf_ptr, b_w, dst, dst_buf_stride,
subpel_x, subpel_y, sf, w, h,
interp_filter, xs, ys,
#if CONFIG_SUPERTX
plane, wedge_offset_x, wedge_offset_y,
#endif // CONFIG_SUPERTX
xd);
else
#endif // CONFIG_EXT_INTER
vp10_make_inter_predictor(buf_ptr, b_w, dst, dst_buf_stride,
subpel_x, subpel_y, sf, w, h, ref,
interp_filter, xs, ys, xd);
}
#endif // CONFIG_VP9_HIGHBITDEPTH
static void dec_build_inter_predictors(VP10Decoder *const pbi, MACROBLOCKD *xd,
int plane, int bw, int bh, int x,
int y, int w, int h, int mi_x, int mi_y,
static void dec_build_inter_predictors(VP10Decoder *const pbi,
MACROBLOCKD *xd, int plane,
#if CONFIG_OBMC
int mi_col_offset, int mi_row_offset,
#endif // CONFIG_OBMC
int bw, int bh,
int x, int y, int w, int h,
#if CONFIG_EXT_INTER && CONFIG_SUPERTX
int wedge_offset_x, int wedge_offset_y,
#endif // CONFIG_EXT_INTER && CONFIG_SUPERTX
int mi_x, int mi_y,
const INTERP_FILTER interp_filter,
const struct scale_factors *sf,
struct buf_2d *pre_buf,
@@ -644,9 +686,20 @@ static void dec_build_inter_predictors(VP10Decoder *const pbi, MACROBLOCKD *xd,
int xs, ys, x0, y0, x0_16, y0_16, frame_width, frame_height,
buf_stride, subpel_x, subpel_y;
uint8_t *ref_frame, *buf_ptr;
#if CONFIG_EXT_INTER
#if CONFIG_OBMC
const MODE_INFO *mi = xd->mi[mi_col_offset + xd->mi_stride * mi_row_offset];
#else
const MODE_INFO *mi = xd->mi[0];
#endif // CONFIG_OBMC
#endif // CONFIG_EXT_INTER
#if CONFIG_EXT_INTERP
const int i_filter = IsInterpolatingFilter(interp_filter);
#endif // CONFIG_EXT_INTERP
#if CONFIG_OBMC
(void) mi_col_offset;
(void) mi_row_offset;
#endif // CONFIG_OBMC
// Get reference frame pointer, width and height.
if (plane == 0) {
@@ -766,15 +819,27 @@ static void dec_build_inter_predictors(VP10Decoder *const pbi, MACROBLOCKD *xd,
const int border_offset = y_pad * (filter_size / 2 - 1) * b_w +
x_pad * (filter_size / 2 - 1);
#if CONFIG_VP9_HIGHBITDEPTH
extend_and_predict_highbd(buf_ptr1, buf_stride, x0, y0, b_w, b_h,
frame_width, frame_height, border_offset,
dst, dst_buf->stride,
subpel_x, subpel_y,
interp_filter, sf,
#if CONFIG_EXT_INTER && CONFIG_SUPERTX
plane, wedge_offset_x, wedge_offset_y,
#endif // CONFIG_EXT_INTER && CONFIG_SUPERTX
xd, w, h, ref, xs, ys);
#else
extend_and_predict(buf_ptr1, buf_stride, x0, y0, b_w, b_h,
frame_width, frame_height, border_offset,
dst, dst_buf->stride,
subpel_x, subpel_y,
interp_filter, sf,
#if CONFIG_VP9_HIGHBITDEPTH
xd,
#endif
w, h, ref, xs, ys);
#if CONFIG_EXT_INTER && CONFIG_SUPERTX
plane, wedge_offset_x, wedge_offset_y,
#endif // CONFIG_EXT_INTER && CONFIG_SUPERTX
xd, w, h, ref, xs, ys);
#endif // CONFIG_VP9_HIGHBITDEPTH
return;
}
} else {
@@ -786,29 +851,44 @@ static void dec_build_inter_predictors(VP10Decoder *const pbi, MACROBLOCKD *xd,
VPXMAX(0, (y1 + 7)) << (plane == 0 ? 0 : 1));
}
}
#if CONFIG_VP9_HIGHBITDEPTH
if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
high_inter_predictor(buf_ptr, buf_stride, dst, dst_buf->stride, subpel_x,
subpel_y, sf, w, h, ref, interp_filter,
xs, ys, xd->bd);
#if CONFIG_EXT_INTER
if (ref && get_wedge_bits(mi->mbmi.sb_type) &&
mi->mbmi.use_wedge_interinter) {
vp10_make_masked_inter_predictor(
buf_ptr, buf_stride, dst, dst_buf->stride,
subpel_x, subpel_y, sf, w, h,
interp_filter, xs, ys,
#if CONFIG_SUPERTX
plane, wedge_offset_x, wedge_offset_y,
#endif // CONFIG_SUPERTX
xd);
} else {
inter_predictor(buf_ptr, buf_stride, dst, dst_buf->stride, subpel_x,
subpel_y, sf, w, h, ref, interp_filter, xs, ys);
vp10_make_inter_predictor(buf_ptr, buf_stride, dst, dst_buf->stride,
subpel_x, subpel_y, sf, w, h, ref,
interp_filter, xs, ys, xd);
}
#else
inter_predictor(buf_ptr, buf_stride, dst, dst_buf->stride, subpel_x,
subpel_y, sf, w, h, ref, interp_filter, xs, ys);
#endif // CONFIG_VP9_HIGHBITDEPTH
vp10_make_inter_predictor(buf_ptr, buf_stride, dst, dst_buf->stride,
subpel_x, subpel_y, sf, w, h, ref,
interp_filter, xs, ys, xd);
#endif // CONFIG_EXT_INTER
}
#endif // (CONFIG_SUPERTX || CONFIG_OBMC)
#if CONFIG_SUPERTX
static void dec_build_inter_predictors_sb(VP10Decoder *const pbi,
MACROBLOCKD *xd,
int mi_row, int mi_col) {
static void dec_build_inter_predictors_sb_extend(
VP10Decoder *const pbi, MACROBLOCKD *xd,
#if CONFIG_EXT_INTER
int mi_row_ori, int mi_col_ori,
#endif // CONFIG_EXT_INTER
int mi_row, int mi_col) {
int plane;
const int mi_x = mi_col * MI_SIZE;
const int mi_y = mi_row * MI_SIZE;
#if CONFIG_EXT_INTER
const int wedge_offset_x = (mi_col_ori - mi_col) * MI_SIZE;
const int wedge_offset_y = (mi_row_ori - mi_row) * MI_SIZE;
#endif // CONFIG_EXT_INTER
const MODE_INFO *mi = xd->mi[0];
const INTERP_FILTER interp_filter = mi->mbmi.interp_filter;
const BLOCK_SIZE sb_type = mi->mbmi.sb_type;
@@ -816,6 +896,7 @@ static void dec_build_inter_predictors_sb(VP10Decoder *const pbi,
for (plane = 0; plane < MAX_MB_PLANE; ++plane) {
struct macroblockd_plane *const pd = &xd->plane[plane];
struct buf_2d *const dst_buf = &pd->dst;
const int num_4x4_w = pd->n4_w;
const int num_4x4_h = pd->n4_h;
@@ -844,24 +925,44 @@ static void dec_build_inter_predictors_sb(VP10Decoder *const pbi,
for (y = 0; y < num_4x4_h; ++y) {
for (x = 0; x < num_4x4_w; ++x) {
const MV mv = average_split_mvs(pd, mi, ref, y * 2 + x);
dec_build_inter_predictors(pbi, xd, plane, n4w_x4, n4h_x4,
4 * x, 4 * y, pw, ph, mi_x, mi_y,
interp_filter, sf, pre_buf, dst_buf,
&mv, ref_frame_buf, is_scaled, ref);
dec_build_inter_predictors(
pbi, xd, plane,
#if CONFIG_OBMC
0, 0,
#endif // CONFIG_OBMC
n4w_x4, n4h_x4,
4 * x, 4 * y, pw, ph,
#if CONFIG_EXT_INTER
wedge_offset_x >> (pd->subsampling_x),
wedge_offset_y >> (pd->subsampling_y),
#endif // CONFIG_EXT_INTER
mi_x, mi_y,
interp_filter, sf, pre_buf, dst_buf,
&mv, ref_frame_buf, is_scaled, ref);
}
}
} else {
const MV mv = mi->mbmi.mv[ref].as_mv;
dec_build_inter_predictors(pbi, xd, plane, n4w_x4, n4h_x4,
0, 0, n4w_x4, n4h_x4, mi_x, mi_y,
interp_filter, sf, pre_buf, dst_buf,
&mv, ref_frame_buf,
is_scaled, ref);
dec_build_inter_predictors(
pbi, xd, plane,
#if CONFIG_OBMC
0, 0,
#endif // CONFIG_OBMC
n4w_x4, n4h_x4,
0, 0, n4w_x4, n4h_x4,
#if CONFIG_EXT_INTER
wedge_offset_x >> (pd->subsampling_x),
wedge_offset_y >> (pd->subsampling_y),
#endif // CONFIG_EXT_INTER
mi_x, mi_y,
interp_filter, sf, pre_buf, dst_buf,
&mv, ref_frame_buf,
is_scaled, ref);
}
}
}
#if CONFIG_EXT_INTER
if (is_interintra_pred(&xd->mi[0]->mbmi))
if (is_interintra_pred(&mi->mbmi))
vp10_build_interintra_predictors(xd,
xd->plane[0].dst.buf,
xd->plane[1].dst.buf,
@@ -873,15 +974,23 @@ static void dec_build_inter_predictors_sb(VP10Decoder *const pbi,
#endif // CONFIG_EXT_INTER
}
static void dec_build_inter_predictors_sb_sub8x8(VP10Decoder *const pbi,
MACROBLOCKD *xd,
int mi_row, int mi_col,
int block) {
static void dec_build_inter_predictors_sb_sub8x8_extend(
VP10Decoder *const pbi,
MACROBLOCKD *xd,
#if CONFIG_EXT_INTER
int mi_row_ori, int mi_col_ori,
#endif // CONFIG_EXT_INTER
int mi_row, int mi_col,
int block) {
// Prediction function used in supertx:
// Use the mv at current block (which is less than 8x8)
int plane;
const int mi_x = mi_col * MI_SIZE;
const int mi_y = mi_row * MI_SIZE;
#if CONFIG_EXT_INTER
const int wedge_offset_x = (mi_col_ori - mi_col) * MI_SIZE;
const int wedge_offset_y = (mi_row_ori - mi_row) * MI_SIZE;
#endif // CONFIG_EXT_INTER
const MODE_INFO *mi = xd->mi[0];
const INTERP_FILTER interp_filter = mi->mbmi.interp_filter;
const int is_compound = has_second_ref(&mi->mbmi);
@@ -908,14 +1017,23 @@ static void dec_build_inter_predictors_sb_sub8x8(VP10Decoder *const pbi,
RefCntBuffer *const ref_frame_buf = &pool->frame_bufs[idx];
const int is_scaled = vp10_is_scaled(sf);
const MV mv = average_split_mvs(pd, mi, ref, block);
dec_build_inter_predictors(pbi, xd, plane, n4w_x4, n4h_x4,
0, 0, n4w_x4, n4h_x4, mi_x, mi_y,
dec_build_inter_predictors(pbi, xd, plane,
#if CONFIG_OBMC
0, 0,
#endif // CONFIG_OBMC
n4w_x4, n4h_x4,
0, 0, n4w_x4, n4h_x4,
#if CONFIG_EXT_INTER
wedge_offset_x >> (pd->subsampling_x),
wedge_offset_y >> (pd->subsampling_y),
#endif // CONFIG_EXT_INTER
mi_x, mi_y,
interp_filter, sf, pre_buf, dst_buf,
&mv, ref_frame_buf, is_scaled, ref);
}
}
#if CONFIG_EXT_INTER
if (is_interintra_pred(&xd->mi[0]->mbmi))
if (is_interintra_pred(&mi->mbmi))
vp10_build_interintra_predictors(xd,
xd->plane[0].dst.buf,
xd->plane[1].dst.buf,
@@ -923,7 +1041,7 @@ static void dec_build_inter_predictors_sb_sub8x8(VP10Decoder *const pbi,
xd->plane[0].dst.stride,
xd->plane[1].dst.stride,
xd->plane[2].dst.stride,
xd->mi[0]->mbmi.sb_type);
mi->mbmi.sb_type);
#endif // CONFIG_EXT_INTER
}
#endif // CONFIG_SUPERTX
@@ -953,7 +1071,7 @@ static void dec_build_prediction_by_above_preds(VP10Decoder *const pbi,
mi_step = VPXMIN(xd->n8_w, num_8x8_blocks_wide_lookup[sb_type]);
if (!is_inter_block(mbmi))
if (!is_neighbor_overlappable(mbmi))
continue;
for (j = 0; j < MAX_MB_PLANE; ++j) {
@@ -1010,15 +1128,27 @@ static void dec_build_prediction_by_above_preds(VP10Decoder *const pbi,
&& y == 0 && !pd->subsampling_y)
continue;
dec_build_inter_predictors(pbi, xd, j, bw, bh,
4 * x, 0, pw, bh, mi_x, mi_y,
dec_build_inter_predictors(pbi, xd, j,
mi_col_offset, mi_row_offset,
bw, bh,
4 * x, 0, pw, bh,
#if CONFIG_EXT_INTER && CONFIG_SUPERTX
0, 0,
#endif // CONFIG_EXT_INTER && CONFIG_SUPERTX
mi_x, mi_y,
interp_filter, sf, pre_buf, dst_buf,
&mv, ref_frame_buf, is_scaled, ref);
}
} else {
const MV mv = mi->mbmi.mv[ref].as_mv;
dec_build_inter_predictors(pbi, xd, j, bw, bh,
0, 0, bw, bh, mi_x, mi_y, interp_filter,
dec_build_inter_predictors(pbi, xd, j,
mi_col_offset, mi_row_offset,
bw, bh,
0, 0, bw, bh,
#if CONFIG_EXT_INTER && CONFIG_SUPERTX
0, 0,
#endif // CONFIG_EXT_INTER && CONFIG_SUPERTX
mi_x, mi_y, interp_filter,
sf, pre_buf, dst_buf, &mv, ref_frame_buf,
is_scaled, ref);
}
@@ -1054,7 +1184,7 @@ static void dec_build_prediction_by_left_preds(VP10Decoder *const pbi,
mi_step = VPXMIN(xd->n8_h, num_8x8_blocks_high_lookup[sb_type]);
if (!is_inter_block(mbmi))
if (!is_neighbor_overlappable(mbmi))
continue;
for (j = 0; j < MAX_MB_PLANE; ++j) {
@@ -1112,15 +1242,31 @@ static void dec_build_prediction_by_left_preds(VP10Decoder *const pbi,
&& x == 0 && !pd->subsampling_x)
continue;
dec_build_inter_predictors(pbi, xd, j, bw, bh,
0, 4 * y, bw, ph, mi_x, mi_y,
dec_build_inter_predictors(pbi, xd, j,
#if CONFIG_OBMC
mi_col_offset, mi_row_offset,
#endif // CONFIG_OBMC
bw, bh,
0, 4 * y, bw, ph,
#if CONFIG_EXT_INTER && CONFIG_SUPERTX
0, 0,
#endif // CONFIG_EXT_INTER && CONFIG_SUPERTX
mi_x, mi_y,
interp_filter, sf, pre_buf, dst_buf,
&mv, ref_frame_buf, is_scaled, ref);
}
} else {
const MV mv = mi->mbmi.mv[ref].as_mv;
dec_build_inter_predictors(pbi, xd, j, bw, bh,
0, 0, bw, bh, mi_x, mi_y, interp_filter,
dec_build_inter_predictors(pbi, xd, j,
#if CONFIG_OBMC
mi_col_offset, mi_row_offset,
#endif // CONFIG_OBMC
bw, bh,
0, 0, bw, bh,
#if CONFIG_EXT_INTER && CONFIG_SUPERTX
0, 0,
#endif // CONFIG_EXT_INTER && CONFIG_SUPERTX
mi_x, mi_y, interp_filter,
sf, pre_buf, dst_buf, &mv, ref_frame_buf,
is_scaled, ref);
}
@@ -1263,8 +1409,7 @@ static void set_offsets_topblock(VP10_COMMON *const cm, MACROBLOCKD *const xd,
static void set_param_topblock(VP10_COMMON *const cm, MACROBLOCKD *const xd,
BLOCK_SIZE bsize, int mi_row, int mi_col,
int txfm,
int skip) {
int txfm, int skip) {
const int bw = num_8x8_blocks_wide_lookup[bsize];
const int bh = num_8x8_blocks_high_lookup[bsize];
const int x_mis = VPXMIN(bw, cm->mi_cols - mi_col);
@@ -1356,10 +1501,19 @@ static void dec_predict_b_extend(
(c >> xd->plane[2].subsampling_x);
if (!b_sub8x8)
dec_build_inter_predictors_sb(pbi, xd, mi_row_pred, mi_col_pred);
dec_build_inter_predictors_sb_extend(
pbi, xd,
#if CONFIG_EXT_INTER
mi_row_ori, mi_col_ori,
#endif // CONFIG_EXT_INTER
mi_row_pred, mi_col_pred);
else
dec_build_inter_predictors_sb_sub8x8(pbi, xd, mi_row_pred, mi_col_pred,
block);
dec_build_inter_predictors_sb_sub8x8_extend(
pbi, xd,
#if CONFIG_EXT_INTER
mi_row_ori, mi_col_ori,
#endif // CONFIG_EXT_INTER
mi_row_pred, mi_col_pred, block);
}
static void dec_extend_dir(VP10Decoder *const pbi, MACROBLOCKD *const xd,
@@ -1861,38 +2015,43 @@ static void decode_block(VP10Decoder *const pbi, MACROBLOCKD *const xd,
#if CONFIG_OBMC
if (mbmi->obmc) {
#if CONFIG_VP9_HIGHBITDEPTH
DECLARE_ALIGNED(16, uint8_t, tmp_buf1[2 * MAX_MB_PLANE * 64 * 64]);
DECLARE_ALIGNED(16, uint8_t, tmp_buf2[2 * MAX_MB_PLANE * 64 * 64]);
DECLARE_ALIGNED(16, uint8_t,
tmp_buf1[2 * MAX_MB_PLANE * CU_SIZE * CU_SIZE]);
DECLARE_ALIGNED(16, uint8_t,
tmp_buf2[2 * MAX_MB_PLANE * CU_SIZE * CU_SIZE]);
#else
DECLARE_ALIGNED(16, uint8_t, tmp_buf1[MAX_MB_PLANE * 64 * 64]);
DECLARE_ALIGNED(16, uint8_t, tmp_buf2[MAX_MB_PLANE * 64 * 64]);
DECLARE_ALIGNED(16, uint8_t,
tmp_buf1[MAX_MB_PLANE * CU_SIZE * CU_SIZE]);
DECLARE_ALIGNED(16, uint8_t,
tmp_buf2[MAX_MB_PLANE * CU_SIZE * CU_SIZE]);
#endif // CONFIG_VP9_HIGHBITDEPTH
uint8_t *dst_buf1[MAX_MB_PLANE], *dst_buf2[MAX_MB_PLANE];
int dst_stride1[MAX_MB_PLANE] = {64, 64, 64};
int dst_stride2[MAX_MB_PLANE] = {64, 64, 64};
int dst_stride1[MAX_MB_PLANE] = {CU_SIZE, CU_SIZE, CU_SIZE};
int dst_stride2[MAX_MB_PLANE] = {CU_SIZE, CU_SIZE, CU_SIZE};
assert(mbmi->sb_type >= BLOCK_8X8);
#if CONFIG_VP9_HIGHBITDEPTH
if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
int len = sizeof(uint16_t);
dst_buf1[0] = CONVERT_TO_BYTEPTR(tmp_buf1);
dst_buf1[1] = CONVERT_TO_BYTEPTR(tmp_buf1 + 4096 * len);
dst_buf1[2] = CONVERT_TO_BYTEPTR(tmp_buf1 + 8192 * len);
dst_buf1[1] = CONVERT_TO_BYTEPTR(tmp_buf1 + CU_SIZE * CU_SIZE * len);
dst_buf1[2] = CONVERT_TO_BYTEPTR(tmp_buf1 +
CU_SIZE * CU_SIZE * 2 * len);
dst_buf2[0] = CONVERT_TO_BYTEPTR(tmp_buf2);
dst_buf2[1] = CONVERT_TO_BYTEPTR(tmp_buf2 + 4096 * len);
dst_buf2[2] = CONVERT_TO_BYTEPTR(tmp_buf2 + 8192 * len);
dst_buf2[1] = CONVERT_TO_BYTEPTR(tmp_buf2 + CU_SIZE * CU_SIZE * len);
dst_buf2[2] = CONVERT_TO_BYTEPTR(tmp_buf2 +
CU_SIZE * CU_SIZE * 2 * len);
} else {
#endif // CONFIG_VP9_HIGHBITDEPTH
dst_buf1[0] = tmp_buf1;
dst_buf1[1] = tmp_buf1 + 4096;
dst_buf1[2] = tmp_buf1 + 8192;
dst_buf2[0] = tmp_buf2;
dst_buf2[1] = tmp_buf2 + 4096;
dst_buf2[2] = tmp_buf2 + 8192;
dst_buf1[0] = tmp_buf1;
dst_buf1[1] = tmp_buf1 + CU_SIZE * CU_SIZE;
dst_buf1[2] = tmp_buf1 + CU_SIZE * CU_SIZE * 2;
dst_buf2[0] = tmp_buf2;
dst_buf2[1] = tmp_buf2 + CU_SIZE * CU_SIZE;
dst_buf2[2] = tmp_buf2 + CU_SIZE * CU_SIZE * 2;
#if CONFIG_VP9_HIGHBITDEPTH
}
#endif // CONFIG_VP9_HIGHBITDEPTH
dec_build_prediction_by_above_preds(pbi, xd, mi_row, mi_col,
dst_buf1, dst_stride1);
dec_build_prediction_by_left_preds(pbi, xd, mi_row, mi_col,
@@ -3585,13 +3744,24 @@ static int read_compressed_header(VP10Decoder *pbi, const uint8_t *data,
#if CONFIG_EXT_INTER
read_inter_compound_mode_probs(fc, &r);
if (cm->reference_mode != COMPOUND_REFERENCE) {
for (i = 0; i < BLOCK_SIZES; i++) {
if (is_interintra_allowed_bsize(i)) {
vp10_diff_update_prob(&r, &fc->interintra_prob[i]);
}
}
for (i = 0; i < BLOCK_SIZES; i++) {
if (is_interintra_allowed_bsize(i) && get_wedge_bits(i)) {
vp10_diff_update_prob(&r, &fc->wedge_interintra_prob[i]);
}
}
}
if (cm->reference_mode != SINGLE_REFERENCE) {
for (i = 0; i < BLOCK_SIZES; i++) {
if (get_wedge_bits(i)) {
vp10_diff_update_prob(&r, &fc->wedge_interinter_prob[i]);
}
}
}
#endif // CONFIG_EXT_INTER
@@ -3660,6 +3830,10 @@ static void debug_check_frame_counts(const VP10_COMMON *const cm) {
sizeof(cm->counts.inter_compound_mode)));
assert(!memcmp(cm->counts.interintra, zero_counts.interintra,
sizeof(cm->counts.interintra)));
assert(!memcmp(cm->counts.wedge_interintra, zero_counts.wedge_interintra,
sizeof(cm->counts.wedge_interintra)));
assert(!memcmp(cm->counts.wedge_interinter, zero_counts.wedge_interinter,
sizeof(cm->counts.wedge_interinter)));
#endif // CONFIG_EXT_INTER
#if CONFIG_OBMC
assert(!memcmp(cm->counts.obmc, zero_counts.obmc,

37
vp10/decoder/decodemv.c
View File

@@ -1180,10 +1180,11 @@ static void read_inter_block_mode_info(VP10Decoder *const pbi,
}
#if CONFIG_OBMC
mbmi->obmc = 0;
#if CONFIG_SUPERTX
if (!supertx_enabled)
#endif // CONFIG_SUPERTX
mbmi->obmc = read_is_obmc_block(cm, xd, r);
mbmi->obmc = read_is_obmc_block(cm, xd, r);
#endif // CONFIG_OBMC
#if CONFIG_REF_MV
@@ -1427,7 +1428,12 @@ static void read_inter_block_mode_info(VP10Decoder *const pbi,
}
#if CONFIG_EXT_INTER
mbmi->use_wedge_interintra = 0;
mbmi->use_wedge_interinter = 0;
if (cm->reference_mode != COMPOUND_REFERENCE &&
#if CONFIG_OBMC
!(is_obmc_allowed(mbmi) && mbmi->obmc) &&
#endif // CONFIG_OBMC
#if CONFIG_SUPERTX
!supertx_enabled &&
#endif
@@ -1439,19 +1445,42 @@ static void read_inter_block_mode_info(VP10Decoder *const pbi,
if (interintra) {
const PREDICTION_MODE interintra_mode =
read_intra_mode_y(cm, xd, r, size_group_lookup[bsize]);
mbmi->ref_frame[1] = INTRA_FRAME;
mbmi->interintra_mode = interintra_mode;
mbmi->interintra_uv_mode = interintra_mode;
#if CONFIG_EXT_INTRA
// TODO(debargha|geza.lore):
// Should we use ext_intra modes for interintra?
mbmi->ext_intra_mode_info.use_ext_intra_mode[0] = 0;
mbmi->ext_intra_mode_info.use_ext_intra_mode[1] = 0;
mbmi->angle_delta[0] = 0;
mbmi->angle_delta[1] = 0;
mbmi->intra_filter = INTRA_FILTER_LINEAR;
#endif // CONFIG_EXT_INTRA
if (get_wedge_bits(bsize)) {
mbmi->use_wedge_interintra =
vpx_read(r, cm->fc->wedge_interintra_prob[bsize]);
if (xd->counts)
xd->counts->wedge_interintra[bsize][mbmi->use_wedge_interintra]++;
if (mbmi->use_wedge_interintra) {
mbmi->interintra_wedge_index =
mbmi->interintra_uv_wedge_index =
vpx_read_literal(r, get_wedge_bits(bsize));
}
}
}
}
if (cm->reference_mode != SINGLE_REFERENCE &&
is_inter_compound_mode(mbmi->mode) &&
#if CONFIG_OBMC
!(is_obmc_allowed(mbmi) && mbmi->obmc) &&
#endif // CONFIG_OBMC
get_wedge_bits(bsize)) {
mbmi->use_wedge_interinter =
vpx_read(r, cm->fc->wedge_interinter_prob[bsize]);
if (xd->counts)
xd->counts->wedge_interinter[bsize][mbmi->use_wedge_interinter]++;
if (mbmi->use_wedge_interinter) {
mbmi->interinter_wedge_index =
vpx_read_literal(r, get_wedge_bits(bsize));
}
}
#endif // CONFIG_EXT_INTER

4
vp10/decoder/decoder.c
View File

@@ -30,6 +30,7 @@
#include "vp10/common/postproc.h"
#endif
#include "vp10/common/quant_common.h"
#include "vp10/common/reconinter.h"
#include "vp10/common/reconintra.h"
#include "vp10/decoder/decodeframe.h"
@@ -44,6 +45,9 @@ static void initialize_dec(void) {
vpx_dsp_rtcd();
vpx_scale_rtcd();
vp10_init_intra_predictors();
#if CONFIG_EXT_INTER
vp10_init_wedge_masks();
#endif // CONFIG_EXT_INTER
init_done = 1;
}
}

45
vp10/encoder/bitstream.c
View File

@@ -1002,12 +1002,13 @@ static void pack_inter_mode_mvs(VP10_COMP *cpi, const MODE_INFO *mi,
} else {
int16_t mode_ctx = mbmi_ext->mode_context[mbmi->ref_frame[0]];
write_ref_frames(cm, xd, w);
#if CONFIG_OBMC
#if CONFIG_SUPERTX
if (!supertx_enabled)
#endif // CONFIG_SUPERTX
if (is_obmc_allowed(mbmi))
vpx_write(w, mbmi->obmc, cm->fc->obmc_prob[bsize]);
if (is_obmc_allowed(mbmi))
vpx_write(w, mbmi->obmc, cm->fc->obmc_prob[bsize]);
#endif // CONFIG_OBMC
#if CONFIG_REF_MV
@@ -1057,8 +1058,8 @@ static void pack_inter_mode_mvs(VP10_COMP *cpi, const MODE_INFO *mi,
#if CONFIG_EXT_INTER
if (!is_compound)
#endif // CONFIG_EXT_INTER
mode_ctx = vp10_mode_context_analyzer(mbmi_ext->mode_context,
mbmi->ref_frame, bsize, j);
mode_ctx = vp10_mode_context_analyzer(mbmi_ext->mode_context,
mbmi->ref_frame, bsize, j);
#endif
#if CONFIG_EXT_INTER
if (is_inter_compound_mode(b_mode))
@@ -1167,6 +1168,9 @@ static void pack_inter_mode_mvs(VP10_COMP *cpi, const MODE_INFO *mi,
#if CONFIG_EXT_INTER
if (cpi->common.reference_mode != COMPOUND_REFERENCE &&
#if CONFIG_OBMC
!(is_obmc_allowed(mbmi) && mbmi->obmc) &&
#endif // CONFIG_OBMC
#if CONFIG_SUPERTX
!supertx_enabled &&
#endif // CONFIG_SUPERTX
@@ -1177,8 +1181,28 @@ static void pack_inter_mode_mvs(VP10_COMP *cpi, const MODE_INFO *mi,
write_intra_mode(w, mbmi->interintra_mode,
cm->fc->y_mode_prob[size_group_lookup[bsize]]);
assert(mbmi->interintra_mode == mbmi->interintra_uv_mode);
if (get_wedge_bits(bsize)) {
vpx_write(w, mbmi->use_wedge_interintra,
cm->fc->wedge_interintra_prob[bsize]);
if (mbmi->use_wedge_interintra) {
vpx_write_literal(w, mbmi->interintra_wedge_index,
get_wedge_bits(bsize));
}
}
}
}
if (cpi->common.reference_mode != SINGLE_REFERENCE &&
is_inter_compound_mode(mbmi->mode) &&
#if CONFIG_OBMC
!(is_obmc_allowed(mbmi) && mbmi->obmc) &&
#endif // CONFIG_OBMC
get_wedge_bits(bsize)) {
vpx_write(w, mbmi->use_wedge_interinter,
cm->fc->wedge_interinter_prob[bsize]);
if (mbmi->use_wedge_interinter)
vpx_write_literal(w, mbmi->interinter_wedge_index,
get_wedge_bits(bsize));
}
#endif // CONFIG_EXT_INTER
#if CONFIG_EXT_INTERP
@@ -2453,6 +2477,19 @@ static size_t write_compressed_header(VP10_COMP *cpi, uint8_t *data) {
cm->counts.interintra[i]);
}
}
for (i = 0; i < BLOCK_SIZES; i++) {
if (is_interintra_allowed_bsize(i) && get_wedge_bits(i))
vp10_cond_prob_diff_update(&header_bc,
&fc->wedge_interintra_prob[i],
cm->counts.wedge_interintra[i]);
}
}
if (cm->reference_mode != SINGLE_REFERENCE) {
for (i = 0; i < BLOCK_SIZES; i++)
if (get_wedge_bits(i))
vp10_cond_prob_diff_update(&header_bc,
&fc->wedge_interinter_prob[i],
cm->counts.wedge_interinter[i]);
}
#endif // CONFIG_EXT_INTER

88
vp10/encoder/encodeframe.c
View File

@@ -61,6 +61,9 @@ static int check_intra_sb(VP10_COMP *cpi, const TileInfo *const tile,
int mi_row, int mi_col, BLOCK_SIZE bsize,
PC_TREE *pc_tree);
static void predict_superblock(VP10_COMP *cpi, ThreadData *td,
#if CONFIG_EXT_INTER
int mi_row_ori, int mi_col_ori,
#endif // CONFIG_EXT_INTER
int mi_row_pred, int mi_col_pred,
BLOCK_SIZE bsize_pred, int b_sub8x8, int block);
static int check_supertx_sb(BLOCK_SIZE bsize, TX_SIZE supertx_size,
@@ -1290,6 +1293,10 @@ static void update_state_supertx(VP10_COMP *cpi, ThreadData *td,
mbmi->inter_tx_size[(idy << 3) + idx] = mbmi->tx_size;
}
#endif // CONFIG_VAR_TX
#if CONFIG_OBMC
// Turn OBMC off for supertx
mbmi->obmc = 0;
#endif // CONFIG_OBMC
if (!output_enabled)
return;
@@ -1801,29 +1808,43 @@ static void update_stats(VP10_COMMON *cm, ThreadData *td
[ref0 != GOLDEN_FRAME]++;
#endif // CONFIG_EXT_REFS
}
#if CONFIG_OBMC
#if CONFIG_SUPERTX
if (!supertx_enabled)
#endif // CONFIG_SUPERTX
if (is_obmc_allowed(mbmi))
counts->obmc[mbmi->sb_type][mbmi->obmc]++;
if (is_obmc_allowed(mbmi))
counts->obmc[mbmi->sb_type][mbmi->obmc]++;
#endif // CONFIG_OBMC
}
}
#if CONFIG_EXT_INTER
if (cm->reference_mode != COMPOUND_REFERENCE &&
#if CONFIG_SUPERTX
!supertx_enabled &&
#if CONFIG_OBMC
!(is_obmc_allowed(mbmi) && mbmi->obmc) &&
#endif
is_interintra_allowed(mbmi)) {
#if CONFIG_SUPERTX
!supertx_enabled &&
#endif
is_interintra_allowed(mbmi)) {
if (mbmi->ref_frame[1] == INTRA_FRAME) {
counts->y_mode[size_group_lookup[bsize]][mbmi->interintra_mode]++;
counts->interintra[bsize][1]++;
if (get_wedge_bits(bsize))
counts->wedge_interintra[bsize][mbmi->use_wedge_interintra]++;
} else {
counts->interintra[bsize][0]++;
}
}
if (cm->reference_mode != SINGLE_REFERENCE &&
is_inter_compound_mode(mbmi->mode) &&
#if CONFIG_OBMC
!(is_obmc_allowed(mbmi) && mbmi->obmc) &&
#endif // CONFIG_OBMC
get_wedge_bits(bsize)) {
counts->wedge_interinter[bsize][mbmi->use_wedge_interinter]++;
}
#endif // CONFIG_EXT_INTER
if (inter_block &&
@@ -4457,15 +4478,19 @@ static void encode_superblock(VP10_COMP *cpi, ThreadData *td,
#if CONFIG_OBMC
if (mbmi->obmc) {
#if CONFIG_VP9_HIGHBITDEPTH
DECLARE_ALIGNED(16, uint8_t, tmp_buf1[2 * MAX_MB_PLANE * 64 * 64]);
DECLARE_ALIGNED(16, uint8_t, tmp_buf2[2 * MAX_MB_PLANE * 64 * 64]);
DECLARE_ALIGNED(16, uint8_t,
tmp_buf1[2 * MAX_MB_PLANE * CU_SIZE * CU_SIZE]);
DECLARE_ALIGNED(16, uint8_t,
tmp_buf2[2 * MAX_MB_PLANE * CU_SIZE * CU_SIZE]);
#else
DECLARE_ALIGNED(16, uint8_t, tmp_buf1[MAX_MB_PLANE * 64 * 64]);
DECLARE_ALIGNED(16, uint8_t, tmp_buf2[MAX_MB_PLANE * 64 * 64]);
DECLARE_ALIGNED(16, uint8_t,
tmp_buf1[MAX_MB_PLANE * CU_SIZE * CU_SIZE]);
DECLARE_ALIGNED(16, uint8_t,
tmp_buf2[MAX_MB_PLANE * CU_SIZE * CU_SIZE]);
#endif // CONFIG_VP9_HIGHBITDEPTH
uint8_t *dst_buf1[MAX_MB_PLANE], *dst_buf2[MAX_MB_PLANE];
int dst_stride1[MAX_MB_PLANE] = {64, 64, 64};
int dst_stride2[MAX_MB_PLANE] = {64, 64, 64};
int dst_stride1[MAX_MB_PLANE] = {CU_SIZE, CU_SIZE, CU_SIZE};
int dst_stride2[MAX_MB_PLANE] = {CU_SIZE, CU_SIZE, CU_SIZE};
assert(mbmi->sb_type >= BLOCK_8X8);
@@ -4473,23 +4498,24 @@ static void encode_superblock(VP10_COMP *cpi, ThreadData *td,
if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
int len = sizeof(uint16_t);
dst_buf1[0] = CONVERT_TO_BYTEPTR(tmp_buf1);
dst_buf1[1] = CONVERT_TO_BYTEPTR(tmp_buf1 + 4096 * len);
dst_buf1[2] = CONVERT_TO_BYTEPTR(tmp_buf1 + 8192 * len);
dst_buf1[1] = CONVERT_TO_BYTEPTR(tmp_buf1 + CU_SIZE * CU_SIZE * len);
dst_buf1[2] = CONVERT_TO_BYTEPTR(
tmp_buf1 + CU_SIZE * CU_SIZE * 2 * len);
dst_buf2[0] = CONVERT_TO_BYTEPTR(tmp_buf2);
dst_buf2[1] = CONVERT_TO_BYTEPTR(tmp_buf2 + 4096 * len);
dst_buf2[2] = CONVERT_TO_BYTEPTR(tmp_buf2 + 8192 * len);
dst_buf2[1] = CONVERT_TO_BYTEPTR(tmp_buf2 + CU_SIZE * CU_SIZE * len);
dst_buf2[2] = CONVERT_TO_BYTEPTR(
tmp_buf2 + CU_SIZE * CU_SIZE * 2 * len);
} else {
#endif // CONFIG_VP9_HIGHBITDEPTH
dst_buf1[0] = tmp_buf1;
dst_buf1[1] = tmp_buf1 + 4096;
dst_buf1[2] = tmp_buf1 + 8192;
dst_buf1[1] = tmp_buf1 + CU_SIZE * CU_SIZE;
dst_buf1[2] = tmp_buf1 + CU_SIZE * CU_SIZE * 2;
dst_buf2[0] = tmp_buf2;
dst_buf2[1] = tmp_buf2 + 4096;
dst_buf2[2] = tmp_buf2 + 8192;
dst_buf2[1] = tmp_buf2 + CU_SIZE * CU_SIZE;
dst_buf2[2] = tmp_buf2 + CU_SIZE * CU_SIZE * 2;
#if CONFIG_VP9_HIGHBITDEPTH
}
#endif // CONFIG_VP9_HIGHBITDEPTH
vp10_build_prediction_by_above_preds(cpi, xd, mi_row, mi_col, dst_buf1,
dst_stride1);
vp10_build_prediction_by_left_preds(cpi, xd, mi_row, mi_col, dst_buf2,
@@ -4500,7 +4526,6 @@ static void encode_superblock(VP10_COMP *cpi, ThreadData *td,
dst_buf1, dst_stride1,
dst_buf2, dst_stride2);
}
#endif // CONFIG_OBMC
vp10_encode_sb(x, VPXMAX(bsize, BLOCK_8X8));
@@ -4694,6 +4719,9 @@ static int check_supertx_sb(BLOCK_SIZE bsize, TX_SIZE supertx_size,
}
static void predict_superblock(VP10_COMP *cpi, ThreadData *td,
#if CONFIG_EXT_INTER
int mi_row_ori, int mi_col_ori,
#endif // CONFIG_EXT_INTER
int mi_row_pred, int mi_col_pred,
BLOCK_SIZE bsize_pred, int b_sub8x8, int block) {
// Used in supertx
@@ -4718,10 +4746,19 @@ static void predict_superblock(VP10_COMP *cpi, ThreadData *td,
}
if (!b_sub8x8)
vp10_build_inter_predictors_sb(xd, mi_row_pred, mi_col_pred, bsize_pred);
vp10_build_inter_predictors_sb_extend(
xd,
#if CONFIG_EXT_INTER
mi_row_ori, mi_col_ori,
#endif // CONFIG_EXT_INTER
mi_row_pred, mi_col_pred, bsize_pred);
else
vp10_build_inter_predictors_sb_sub8x8(xd, mi_row_pred, mi_col_pred,
bsize_pred, block);
vp10_build_inter_predictors_sb_sub8x8_extend(
xd,
#if CONFIG_EXT_INTER
mi_row_ori, mi_col_ori,
#endif // CONFIG_EXT_INTER
mi_row_pred, mi_col_pred, bsize_pred, block);
}
static void predict_b_extend(VP10_COMP *cpi, ThreadData *td,
@@ -4772,6 +4809,9 @@ static void predict_b_extend(VP10_COMP *cpi, ThreadData *td,
(c >> xd->plane[2].subsampling_x);
predict_superblock(cpi, td,
#if CONFIG_EXT_INTER
mi_row_ori, mi_col_ori,
#endif // CONFIG_EXT_INTER
mi_row_pred, mi_col_pred, bsize_pred,
b_sub8x8, block);

431
vp10/encoder/encoder.c
View File

@@ -349,6 +349,9 @@ void vp10_initialize_enc(void) {
vp10_entropy_mv_init();
vp10_temporal_filter_init();
vp10_encode_token_init();
#if CONFIG_EXT_INTER
vp10_init_wedge_masks();
#endif
init_done = 1;
}
}
@@ -1038,6 +1041,19 @@ static void fnname##_bits12(const uint8_t *src_ptr, \
sad_array[i] >>= 4; \
}
#if CONFIG_EXT_PARTITION
MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad128x128)
MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad128x128_avg)
MAKE_BFP_SAD3_WRAPPER(vpx_highbd_sad128x128x3)
MAKE_BFP_SAD8_WRAPPER(vpx_highbd_sad128x128x8)
MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad128x128x4d)
MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad128x64)
MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad128x64_avg)
MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad128x64x4d)
MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad64x128)
MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad64x128_avg)
MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad64x128x4d)
#endif // CONFIG_EXT_PARTITION
MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad32x16)
MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad32x16_avg)
MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad32x16x4d)
@@ -1094,6 +1110,61 @@ MAKE_BFP_SAD3_WRAPPER(vpx_highbd_sad4x4x3)
MAKE_BFP_SAD8_WRAPPER(vpx_highbd_sad4x4x8)
MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad4x4x4d)
#if CONFIG_EXT_INTER
#define HIGHBD_MBFP(BT, MSDF, MVF, MSVF) \
cpi->fn_ptr[BT].msdf = MSDF; \
cpi->fn_ptr[BT].mvf = MVF; \
cpi->fn_ptr[BT].msvf = MSVF;
#define MAKE_MBFP_SAD_WRAPPER(fnname) \
static unsigned int fnname##_bits8(const uint8_t *src_ptr, \
int source_stride, \
const uint8_t *ref_ptr, \
int ref_stride, \
const uint8_t *m, \
int m_stride) { \
return fnname(src_ptr, source_stride, ref_ptr, ref_stride, \
m, m_stride); \
} \
static unsigned int fnname##_bits10(const uint8_t *src_ptr, \
int source_stride, \
const uint8_t *ref_ptr, \
int ref_stride, \
const uint8_t *m, \
int m_stride) { \
return fnname(src_ptr, source_stride, ref_ptr, ref_stride, \
m, m_stride) >> 2; \
} \
static unsigned int fnname##_bits12(const uint8_t *src_ptr, \
int source_stride, \
const uint8_t *ref_ptr, \
int ref_stride, \
const uint8_t *m, \
int m_stride) { \
return fnname(src_ptr, source_stride, ref_ptr, ref_stride, \
m, m_stride) >> 4; \
}
#if CONFIG_EXT_PARTITION
MAKE_MBFP_SAD_WRAPPER(vpx_highbd_masked_sad128x128)
MAKE_MBFP_SAD_WRAPPER(vpx_highbd_masked_sad128x64)
MAKE_MBFP_SAD_WRAPPER(vpx_highbd_masked_sad64x128)
#endif // CONFIG_EXT_PARTITION
MAKE_MBFP_SAD_WRAPPER(vpx_highbd_masked_sad64x64)
MAKE_MBFP_SAD_WRAPPER(vpx_highbd_masked_sad64x32)
MAKE_MBFP_SAD_WRAPPER(vpx_highbd_masked_sad32x64)
MAKE_MBFP_SAD_WRAPPER(vpx_highbd_masked_sad32x32)
MAKE_MBFP_SAD_WRAPPER(vpx_highbd_masked_sad32x16)
MAKE_MBFP_SAD_WRAPPER(vpx_highbd_masked_sad16x32)
MAKE_MBFP_SAD_WRAPPER(vpx_highbd_masked_sad16x16)
MAKE_MBFP_SAD_WRAPPER(vpx_highbd_masked_sad16x8)
MAKE_MBFP_SAD_WRAPPER(vpx_highbd_masked_sad8x16)
MAKE_MBFP_SAD_WRAPPER(vpx_highbd_masked_sad8x8)
MAKE_MBFP_SAD_WRAPPER(vpx_highbd_masked_sad8x4)
MAKE_MBFP_SAD_WRAPPER(vpx_highbd_masked_sad4x8)
MAKE_MBFP_SAD_WRAPPER(vpx_highbd_masked_sad4x4)
#endif // CONFIG_EXT_INTER
static void highbd_set_var_fns(VP10_COMP *const cpi) {
VP10_COMMON *const cm = &cpi->common;
if (cm->use_highbitdepth) {
@@ -1228,6 +1299,107 @@ static void highbd_set_var_fns(VP10_COMP *const cpi) {
vpx_highbd_sad4x4x3_bits8,
vpx_highbd_sad4x4x8_bits8,
vpx_highbd_sad4x4x4d_bits8)
#if CONFIG_EXT_PARTITION
HIGHBD_BFP(BLOCK_128X128,
vpx_highbd_sad128x128_bits8,
vpx_highbd_sad128x128_avg_bits8,
vpx_highbd_8_variance128x128,
vpx_highbd_8_sub_pixel_variance128x128,
vpx_highbd_8_sub_pixel_avg_variance128x128,
vpx_highbd_sad128x128x3_bits8,
vpx_highbd_sad128x128x8_bits8,
vpx_highbd_sad128x128x4d_bits8)
HIGHBD_BFP(BLOCK_128X64,
vpx_highbd_sad128x64_bits8,
vpx_highbd_sad128x64_avg_bits8,
vpx_highbd_8_variance128x64,
vpx_highbd_8_sub_pixel_variance128x64,
vpx_highbd_8_sub_pixel_avg_variance128x64,
NULL,
NULL,
vpx_highbd_sad128x64x4d_bits8)
HIGHBD_BFP(BLOCK_64X128,
vpx_highbd_sad64x128_bits8,
vpx_highbd_sad64x128_avg_bits8,
vpx_highbd_8_variance64x128,
vpx_highbd_8_sub_pixel_variance64x128,
vpx_highbd_8_sub_pixel_avg_variance64x128,
NULL,
NULL,
vpx_highbd_sad64x128x4d_bits8)
#endif // CONFIG_EXT_PARTITION
#if CONFIG_EXT_INTER
#if CONFIG_EXT_PARTITION
HIGHBD_MBFP(BLOCK_128X128,
vpx_highbd_masked_sad128x128_bits8,
vpx_highbd_masked_variance128x128,
vpx_highbd_masked_sub_pixel_variance128x128)
HIGHBD_MBFP(BLOCK_128X64,
vpx_highbd_masked_sad128x64_bits8,
vpx_highbd_masked_variance128x64,
vpx_highbd_masked_sub_pixel_variance128x64)
HIGHBD_MBFP(BLOCK_64X128,
vpx_highbd_masked_sad64x128_bits8,
vpx_highbd_masked_variance64x128,
vpx_highbd_masked_sub_pixel_variance64x128)
#endif // CONFIG_EXT_PARTITION
HIGHBD_MBFP(BLOCK_64X64,
vpx_highbd_masked_sad64x64_bits8,
vpx_highbd_masked_variance64x64,
vpx_highbd_masked_sub_pixel_variance64x64)
HIGHBD_MBFP(BLOCK_64X32,
vpx_highbd_masked_sad64x32_bits8,
vpx_highbd_masked_variance64x32,
vpx_highbd_masked_sub_pixel_variance64x32)
HIGHBD_MBFP(BLOCK_32X64,
vpx_highbd_masked_sad32x64_bits8,
vpx_highbd_masked_variance32x64,
vpx_highbd_masked_sub_pixel_variance32x64)
HIGHBD_MBFP(BLOCK_32X32,
vpx_highbd_masked_sad32x32_bits8,
vpx_highbd_masked_variance32x32,
vpx_highbd_masked_sub_pixel_variance32x32)
HIGHBD_MBFP(BLOCK_32X16,
vpx_highbd_masked_sad32x16_bits8,
vpx_highbd_masked_variance32x16,
vpx_highbd_masked_sub_pixel_variance32x16)
HIGHBD_MBFP(BLOCK_16X32,
vpx_highbd_masked_sad16x32_bits8,
vpx_highbd_masked_variance16x32,
vpx_highbd_masked_sub_pixel_variance16x32)
HIGHBD_MBFP(BLOCK_16X16,
vpx_highbd_masked_sad16x16_bits8,
vpx_highbd_masked_variance16x16,
vpx_highbd_masked_sub_pixel_variance16x16)
HIGHBD_MBFP(BLOCK_8X16,
vpx_highbd_masked_sad8x16_bits8,
vpx_highbd_masked_variance8x16,
vpx_highbd_masked_sub_pixel_variance8x16)
HIGHBD_MBFP(BLOCK_16X8,
vpx_highbd_masked_sad16x8_bits8,
vpx_highbd_masked_variance16x8,
vpx_highbd_masked_sub_pixel_variance16x8)
HIGHBD_MBFP(BLOCK_8X8,
vpx_highbd_masked_sad8x8_bits8,
vpx_highbd_masked_variance8x8,
vpx_highbd_masked_sub_pixel_variance8x8)
HIGHBD_MBFP(BLOCK_4X8,
vpx_highbd_masked_sad4x8_bits8,
vpx_highbd_masked_variance4x8,
vpx_highbd_masked_sub_pixel_variance4x8)
HIGHBD_MBFP(BLOCK_8X4,
vpx_highbd_masked_sad8x4_bits8,
vpx_highbd_masked_variance8x4,
vpx_highbd_masked_sub_pixel_variance8x4)
HIGHBD_MBFP(BLOCK_4X4,
vpx_highbd_masked_sad4x4_bits8,
vpx_highbd_masked_variance4x4,
vpx_highbd_masked_sub_pixel_variance4x4)
#endif // CONFIG_EXT_INTER
break;
case VPX_BITS_10:
@@ -1360,6 +1532,107 @@ static void highbd_set_var_fns(VP10_COMP *const cpi) {
vpx_highbd_sad4x4x3_bits10,
vpx_highbd_sad4x4x8_bits10,
vpx_highbd_sad4x4x4d_bits10)
#if CONFIG_EXT_PARTITION
HIGHBD_BFP(BLOCK_128X128,
vpx_highbd_sad128x128_bits10,
vpx_highbd_sad128x128_avg_bits10,
vpx_highbd_10_variance128x128,
vpx_highbd_10_sub_pixel_variance128x128,
vpx_highbd_10_sub_pixel_avg_variance128x128,
vpx_highbd_sad128x128x3_bits10,
vpx_highbd_sad128x128x8_bits10,
vpx_highbd_sad128x128x4d_bits10)
HIGHBD_BFP(BLOCK_128X64,
vpx_highbd_sad128x64_bits10,
vpx_highbd_sad128x64_avg_bits10,
vpx_highbd_10_variance128x64,
vpx_highbd_10_sub_pixel_variance128x64,
vpx_highbd_10_sub_pixel_avg_variance128x64,
NULL,
NULL,
vpx_highbd_sad128x64x4d_bits10)
HIGHBD_BFP(BLOCK_64X128,
vpx_highbd_sad64x128_bits10,
vpx_highbd_sad64x128_avg_bits10,
vpx_highbd_10_variance64x128,
vpx_highbd_10_sub_pixel_variance64x128,
vpx_highbd_10_sub_pixel_avg_variance64x128,
NULL,
NULL,
vpx_highbd_sad64x128x4d_bits10)
#endif // CONFIG_EXT_PARTITION
#if CONFIG_EXT_INTER
#if CONFIG_EXT_PARTITION
HIGHBD_MBFP(BLOCK_128X128,
vpx_highbd_masked_sad128x128_bits10,
vpx_highbd_10_masked_variance128x128,
vpx_highbd_10_masked_sub_pixel_variance128x128)
HIGHBD_MBFP(BLOCK_128X64,
vpx_highbd_masked_sad128x64_bits10,
vpx_highbd_10_masked_variance128x64,
vpx_highbd_10_masked_sub_pixel_variance128x64)
HIGHBD_MBFP(BLOCK_64X128,
vpx_highbd_masked_sad64x128_bits10,
vpx_highbd_10_masked_variance64x128,
vpx_highbd_10_masked_sub_pixel_variance64x128)
#endif // CONFIG_EXT_PARTITION
HIGHBD_MBFP(BLOCK_64X64,
vpx_highbd_masked_sad64x64_bits10,
vpx_highbd_10_masked_variance64x64,
vpx_highbd_10_masked_sub_pixel_variance64x64)
HIGHBD_MBFP(BLOCK_64X32,
vpx_highbd_masked_sad64x32_bits10,
vpx_highbd_10_masked_variance64x32,
vpx_highbd_10_masked_sub_pixel_variance64x32)
HIGHBD_MBFP(BLOCK_32X64,
vpx_highbd_masked_sad32x64_bits10,
vpx_highbd_10_masked_variance32x64,
vpx_highbd_10_masked_sub_pixel_variance32x64)
HIGHBD_MBFP(BLOCK_32X32,
vpx_highbd_masked_sad32x32_bits10,
vpx_highbd_10_masked_variance32x32,
vpx_highbd_10_masked_sub_pixel_variance32x32)
HIGHBD_MBFP(BLOCK_32X16,
vpx_highbd_masked_sad32x16_bits10,
vpx_highbd_10_masked_variance32x16,
vpx_highbd_10_masked_sub_pixel_variance32x16)
HIGHBD_MBFP(BLOCK_16X32,
vpx_highbd_masked_sad16x32_bits10,
vpx_highbd_10_masked_variance16x32,
vpx_highbd_10_masked_sub_pixel_variance16x32)
HIGHBD_MBFP(BLOCK_16X16,
vpx_highbd_masked_sad16x16_bits10,
vpx_highbd_10_masked_variance16x16,
vpx_highbd_10_masked_sub_pixel_variance16x16)
HIGHBD_MBFP(BLOCK_8X16,
vpx_highbd_masked_sad8x16_bits10,
vpx_highbd_10_masked_variance8x16,
vpx_highbd_10_masked_sub_pixel_variance8x16)
HIGHBD_MBFP(BLOCK_16X8,
vpx_highbd_masked_sad16x8_bits10,
vpx_highbd_10_masked_variance16x8,
vpx_highbd_10_masked_sub_pixel_variance16x8)
HIGHBD_MBFP(BLOCK_8X8,
vpx_highbd_masked_sad8x8_bits10,
vpx_highbd_10_masked_variance8x8,
vpx_highbd_10_masked_sub_pixel_variance8x8)
HIGHBD_MBFP(BLOCK_4X8,
vpx_highbd_masked_sad4x8_bits10,
vpx_highbd_10_masked_variance4x8,
vpx_highbd_10_masked_sub_pixel_variance4x8)
HIGHBD_MBFP(BLOCK_8X4,
vpx_highbd_masked_sad8x4_bits10,
vpx_highbd_10_masked_variance8x4,
vpx_highbd_10_masked_sub_pixel_variance8x4)
HIGHBD_MBFP(BLOCK_4X4,
vpx_highbd_masked_sad4x4_bits10,
vpx_highbd_10_masked_variance4x4,
vpx_highbd_10_masked_sub_pixel_variance4x4)
#endif // CONFIG_EXT_INTER
break;
case VPX_BITS_12:
@@ -1492,6 +1765,107 @@ static void highbd_set_var_fns(VP10_COMP *const cpi) {
vpx_highbd_sad4x4x3_bits12,
vpx_highbd_sad4x4x8_bits12,
vpx_highbd_sad4x4x4d_bits12)
#if CONFIG_EXT_PARTITION
HIGHBD_BFP(BLOCK_128X128,
vpx_highbd_sad128x128_bits12,
vpx_highbd_sad128x128_avg_bits12,
vpx_highbd_12_variance128x128,
vpx_highbd_12_sub_pixel_variance128x128,
vpx_highbd_12_sub_pixel_avg_variance128x128,
vpx_highbd_sad128x128x3_bits12,
vpx_highbd_sad128x128x8_bits12,
vpx_highbd_sad128x128x4d_bits12)
HIGHBD_BFP(BLOCK_128X64,
vpx_highbd_sad128x64_bits12,
vpx_highbd_sad128x64_avg_bits12,
vpx_highbd_12_variance128x64,
vpx_highbd_12_sub_pixel_variance128x64,
vpx_highbd_12_sub_pixel_avg_variance128x64,
NULL,
NULL,
vpx_highbd_sad128x64x4d_bits12)
HIGHBD_BFP(BLOCK_64X128,
vpx_highbd_sad64x128_bits12,
vpx_highbd_sad64x128_avg_bits12,
vpx_highbd_12_variance64x128,
vpx_highbd_12_sub_pixel_variance64x128,
vpx_highbd_12_sub_pixel_avg_variance64x128,
NULL,
NULL,
vpx_highbd_sad64x128x4d_bits12)
#endif // CONFIG_EXT_PARTITION
#if CONFIG_EXT_INTER
#if CONFIG_EXT_PARTITION
HIGHBD_MBFP(BLOCK_128X128,
vpx_highbd_masked_sad128x128_bits12,
vpx_highbd_12_masked_variance128x128,
vpx_highbd_12_masked_sub_pixel_variance128x128)
HIGHBD_MBFP(BLOCK_128X64,
vpx_highbd_masked_sad128x64_bits12,
vpx_highbd_12_masked_variance128x64,
vpx_highbd_12_masked_sub_pixel_variance128x64)
HIGHBD_MBFP(BLOCK_64X128,
vpx_highbd_masked_sad64x128_bits12,
vpx_highbd_12_masked_variance64x128,
vpx_highbd_12_masked_sub_pixel_variance64x128)
#endif // CONFIG_EXT_PARTITION
HIGHBD_MBFP(BLOCK_64X64,
vpx_highbd_masked_sad64x64_bits12,
vpx_highbd_12_masked_variance64x64,
vpx_highbd_12_masked_sub_pixel_variance64x64)
HIGHBD_MBFP(BLOCK_64X32,
vpx_highbd_masked_sad64x32_bits12,
vpx_highbd_12_masked_variance64x32,
vpx_highbd_12_masked_sub_pixel_variance64x32)
HIGHBD_MBFP(BLOCK_32X64,
vpx_highbd_masked_sad32x64_bits12,
vpx_highbd_12_masked_variance32x64,
vpx_highbd_12_masked_sub_pixel_variance32x64)
HIGHBD_MBFP(BLOCK_32X32,
vpx_highbd_masked_sad32x32_bits12,
vpx_highbd_12_masked_variance32x32,
vpx_highbd_12_masked_sub_pixel_variance32x32)
HIGHBD_MBFP(BLOCK_32X16,
vpx_highbd_masked_sad32x16_bits12,
vpx_highbd_12_masked_variance32x16,
vpx_highbd_12_masked_sub_pixel_variance32x16)
HIGHBD_MBFP(BLOCK_16X32,
vpx_highbd_masked_sad16x32_bits12,
vpx_highbd_12_masked_variance16x32,
vpx_highbd_12_masked_sub_pixel_variance16x32)
HIGHBD_MBFP(BLOCK_16X16,
vpx_highbd_masked_sad16x16_bits12,
vpx_highbd_12_masked_variance16x16,
vpx_highbd_12_masked_sub_pixel_variance16x16)
HIGHBD_MBFP(BLOCK_8X16,
vpx_highbd_masked_sad8x16_bits12,
vpx_highbd_12_masked_variance8x16,
vpx_highbd_12_masked_sub_pixel_variance8x16)
HIGHBD_MBFP(BLOCK_16X8,
vpx_highbd_masked_sad16x8_bits12,
vpx_highbd_12_masked_variance16x8,
vpx_highbd_12_masked_sub_pixel_variance16x8)
HIGHBD_MBFP(BLOCK_8X8,
vpx_highbd_masked_sad8x8_bits12,
vpx_highbd_12_masked_variance8x8,
vpx_highbd_12_masked_sub_pixel_variance8x8)
HIGHBD_MBFP(BLOCK_4X8,
vpx_highbd_masked_sad4x8_bits12,
vpx_highbd_12_masked_variance4x8,
vpx_highbd_12_masked_sub_pixel_variance4x8)
HIGHBD_MBFP(BLOCK_8X4,
vpx_highbd_masked_sad8x4_bits12,
vpx_highbd_12_masked_variance8x4,
vpx_highbd_12_masked_sub_pixel_variance8x4)
HIGHBD_MBFP(BLOCK_4X4,
vpx_highbd_masked_sad4x4_bits12,
vpx_highbd_12_masked_variance4x4,
vpx_highbd_12_masked_sub_pixel_variance4x4)
#endif // CONFIG_EXT_INTER
break;
default:
@@ -1912,6 +2286,21 @@ VP10_COMP *vp10_create_compressor(VP10EncoderConfig *oxcf,
cpi->fn_ptr[BT].sdx8f = SDX8F; \
cpi->fn_ptr[BT].sdx4df = SDX4DF;
#if CONFIG_EXT_PARTITION
BFP(BLOCK_128X128, vpx_sad128x128, vpx_sad128x128_avg,
vpx_variance128x128, vpx_sub_pixel_variance128x128,
vpx_sub_pixel_avg_variance128x128, vpx_sad128x128x3, vpx_sad128x128x8,
vpx_sad128x128x4d)
BFP(BLOCK_128X64, vpx_sad128x64, vpx_sad128x64_avg,
vpx_variance128x64, vpx_sub_pixel_variance128x64,
vpx_sub_pixel_avg_variance128x64, NULL, NULL, vpx_sad128x64x4d)
BFP(BLOCK_64X128, vpx_sad64x128, vpx_sad64x128_avg,
vpx_variance64x128, vpx_sub_pixel_variance64x128,
vpx_sub_pixel_avg_variance64x128, NULL, NULL, vpx_sad64x128x4d)
#endif // CONFIG_EXT_PARTITION
BFP(BLOCK_32X16, vpx_sad32x16, vpx_sad32x16_avg,
vpx_variance32x16, vpx_sub_pixel_variance32x16,
vpx_sub_pixel_avg_variance32x16, NULL, NULL, vpx_sad32x16x4d)
@@ -1971,6 +2360,48 @@ VP10_COMP *vp10_create_compressor(VP10EncoderConfig *oxcf,
vpx_sub_pixel_avg_variance4x4,
vpx_sad4x4x3, vpx_sad4x4x8, vpx_sad4x4x4d)
#if CONFIG_EXT_INTER
#define MBFP(BT, MSDF, MVF, MSVF) \
cpi->fn_ptr[BT].msdf = MSDF; \
cpi->fn_ptr[BT].mvf = MVF; \
cpi->fn_ptr[BT].msvf = MSVF;
#if CONFIG_EXT_PARTITION
MBFP(BLOCK_128X128, vpx_masked_sad128x128, vpx_masked_variance128x128,
vpx_masked_sub_pixel_variance128x128)
MBFP(BLOCK_128X64, vpx_masked_sad128x64, vpx_masked_variance128x64,
vpx_masked_sub_pixel_variance128x64)
MBFP(BLOCK_64X128, vpx_masked_sad64x128, vpx_masked_variance64x128,
vpx_masked_sub_pixel_variance64x128)
#endif // CONFIG_EXT_PARTITION
MBFP(BLOCK_64X64, vpx_masked_sad64x64, vpx_masked_variance64x64,
vpx_masked_sub_pixel_variance64x64)
MBFP(BLOCK_64X32, vpx_masked_sad64x32, vpx_masked_variance64x32,
vpx_masked_sub_pixel_variance64x32)
MBFP(BLOCK_32X64, vpx_masked_sad32x64, vpx_masked_variance32x64,
vpx_masked_sub_pixel_variance32x64)
MBFP(BLOCK_32X32, vpx_masked_sad32x32, vpx_masked_variance32x32,
vpx_masked_sub_pixel_variance32x32)
MBFP(BLOCK_32X16, vpx_masked_sad32x16, vpx_masked_variance32x16,
vpx_masked_sub_pixel_variance32x16)
MBFP(BLOCK_16X32, vpx_masked_sad16x32, vpx_masked_variance16x32,
vpx_masked_sub_pixel_variance16x32)
MBFP(BLOCK_16X16, vpx_masked_sad16x16, vpx_masked_variance16x16,
vpx_masked_sub_pixel_variance16x16)
MBFP(BLOCK_16X8, vpx_masked_sad16x8, vpx_masked_variance16x8,
vpx_masked_sub_pixel_variance16x8)
MBFP(BLOCK_8X16, vpx_masked_sad8x16, vpx_masked_variance8x16,
vpx_masked_sub_pixel_variance8x16)
MBFP(BLOCK_8X8, vpx_masked_sad8x8, vpx_masked_variance8x8,
vpx_masked_sub_pixel_variance8x8)
MBFP(BLOCK_4X8, vpx_masked_sad4x8, vpx_masked_variance4x8,
vpx_masked_sub_pixel_variance4x8)
MBFP(BLOCK_8X4, vpx_masked_sad8x4, vpx_masked_variance8x4,
vpx_masked_sub_pixel_variance8x4)
MBFP(BLOCK_4X4, vpx_masked_sad4x4, vpx_masked_variance4x4,
vpx_masked_sub_pixel_variance4x4)
#endif // CONFIG_EXT_INTER
#if CONFIG_VP9_HIGHBITDEPTH
highbd_set_var_fns(cpi);
#endif

2
vp10/encoder/encoder.h
View File

@@ -422,7 +422,7 @@ typedef struct VP10_COMP {
fractional_mv_step_fp *find_fractional_mv_step;
vp10_full_search_fn_t full_search_sad;
vp10_diamond_search_fn_t diamond_search_sad;
vp9_variance_fn_ptr_t fn_ptr[BLOCK_SIZES];
vp10_variance_fn_ptr_t fn_ptr[BLOCK_SIZES];
uint64_t time_receive_data;
uint64_t time_compress_data;
uint64_t time_pick_lpf;

2
vp10/encoder/firstpass.c
View File

@@ -388,7 +388,7 @@ static void first_pass_motion_search(VP10_COMP *cpi, MACROBLOCK *x,
MV ref_mv_full = {ref_mv->row >> 3, ref_mv->col >> 3};
int num00, tmp_err, n;
const BLOCK_SIZE bsize = xd->mi[0]->mbmi.sb_type;
vp9_variance_fn_ptr_t v_fn_ptr = cpi->fn_ptr[bsize];
vp10_variance_fn_ptr_t v_fn_ptr = cpi->fn_ptr[bsize];
const int new_mv_mode_penalty = NEW_MV_MODE_PENALTY;
int step_param = 3;

2
vp10/encoder/mbgraph.c
View File

@@ -31,7 +31,7 @@ static unsigned int do_16x16_motion_iteration(VP10_COMP *cpi,
MACROBLOCK *const x = &cpi->td.mb;
MACROBLOCKD *const xd = &x->e_mbd;
const MV_SPEED_FEATURES *const mv_sf = &cpi->sf.mv;
const vp9_variance_fn_ptr_t v_fn_ptr = cpi->fn_ptr[BLOCK_16X16];
const vp10_variance_fn_ptr_t v_fn_ptr = cpi->fn_ptr[BLOCK_16X16];
const int tmp_col_min = x->mv_col_min;
const int tmp_col_max = x->mv_col_max;

413
vp10/encoder/mcomp.c
View File

@@ -354,7 +354,7 @@ static unsigned int setup_center_error(const MACROBLOCKD *xd,
const MV *bestmv,
const MV *ref_mv,
int error_per_bit,
const vp9_variance_fn_ptr_t *vfp,
const vp10_variance_fn_ptr_t *vfp,
const uint8_t *const src,
const int src_stride,
const uint8_t *const y,
@@ -430,7 +430,7 @@ int vp10_find_best_sub_pixel_tree_pruned_evenmore(
MV *bestmv, const MV *ref_mv,
int allow_hp,
int error_per_bit,
const vp9_variance_fn_ptr_t *vfp,
const vp10_variance_fn_ptr_t *vfp,
int forced_stop,
int iters_per_step,
int *cost_list,
@@ -516,7 +516,7 @@ int vp10_find_best_sub_pixel_tree_pruned_more(const MACROBLOCK *x,
MV *bestmv, const MV *ref_mv,
int allow_hp,
int error_per_bit,
const vp9_variance_fn_ptr_t *vfp,
const vp10_variance_fn_ptr_t *vfp,
int forced_stop,
int iters_per_step,
int *cost_list,
@@ -599,7 +599,7 @@ int vp10_find_best_sub_pixel_tree_pruned(const MACROBLOCK *x,
MV *bestmv, const MV *ref_mv,
int allow_hp,
int error_per_bit,
const vp9_variance_fn_ptr_t *vfp,
const vp10_variance_fn_ptr_t *vfp,
int forced_stop,
int iters_per_step,
int *cost_list,
@@ -748,7 +748,7 @@ static void highbd_upsampled_pred(uint16_t *comp_pred,
#endif
static int upsampled_pref_error(const MACROBLOCKD *xd,
const vp9_variance_fn_ptr_t *vfp,
const vp10_variance_fn_ptr_t *vfp,
const uint8_t *const src, const int src_stride,
const uint8_t *const y, int y_stride,
const uint8_t *second_pred,
@@ -786,7 +786,7 @@ return besterr;
static unsigned int upsampled_setup_center_error(
const MACROBLOCKD *xd, const MV *bestmv, const MV *ref_mv,
int error_per_bit, const vp9_variance_fn_ptr_t *vfp,
int error_per_bit, const vp10_variance_fn_ptr_t *vfp,
const uint8_t *const src, const int src_stride,
const uint8_t *const y, int y_stride, const uint8_t *second_pred,
int w, int h, int offset, int *mvjcost, int *mvcost[2],
@@ -804,7 +804,7 @@ int vp10_find_best_sub_pixel_tree(const MACROBLOCK *x,
MV *bestmv, const MV *ref_mv,
int allow_hp,
int error_per_bit,
const vp9_variance_fn_ptr_t *vfp,
const vp10_variance_fn_ptr_t *vfp,
int forced_stop,
int iters_per_step,
int *cost_list,
@@ -1037,7 +1037,7 @@ static INLINE int is_mv_in(const MACROBLOCK *x, const MV *mv) {
static INLINE void calc_int_cost_list(const MACROBLOCK *x,
const MV *ref_mv,
int sadpb,
const vp9_variance_fn_ptr_t *fn_ptr,
const vp10_variance_fn_ptr_t *fn_ptr,
const MV *best_mv,
int *cost_list) {
static const MV neighbors[4] = {{0, -1}, {1, 0}, {0, 1}, {-1, 0}};
@@ -1095,7 +1095,7 @@ static int vp10_pattern_search(const MACROBLOCK *x,
int sad_per_bit,
int do_init_search,
int *cost_list,
const vp9_variance_fn_ptr_t *vfp,
const vp10_variance_fn_ptr_t *vfp,
int use_mvcost,
const MV *center_mv,
MV *best_mv,
@@ -1270,7 +1270,7 @@ static int vp10_pattern_search_sad(const MACROBLOCK *x,
int sad_per_bit,
int do_init_search,
int *cost_list,
const vp9_variance_fn_ptr_t *vfp,
const vp10_variance_fn_ptr_t *vfp,
int use_mvcost,
const MV *center_mv,
MV *best_mv,
@@ -1552,7 +1552,7 @@ static int vp10_pattern_search_sad(const MACROBLOCK *x,
int vp10_get_mvpred_var(const MACROBLOCK *x,
const MV *best_mv, const MV *center_mv,
const vp9_variance_fn_ptr_t *vfp,
const vp10_variance_fn_ptr_t *vfp,
int use_mvcost) {
const MACROBLOCKD *const xd = &x->e_mbd;
const struct buf_2d *const what = &x->plane[0].src;
@@ -1569,7 +1569,7 @@ int vp10_get_mvpred_var(const MACROBLOCK *x,
int vp10_get_mvpred_av_var(const MACROBLOCK *x,
const MV *best_mv, const MV *center_mv,
const uint8_t *second_pred,
const vp9_variance_fn_ptr_t *vfp,
const vp10_variance_fn_ptr_t *vfp,
int use_mvcost) {
const MACROBLOCKD *const xd = &x->e_mbd;
const struct buf_2d *const what = &x->plane[0].src;
@@ -1589,7 +1589,7 @@ int vp10_hex_search(const MACROBLOCK *x,
int sad_per_bit,
int do_init_search,
int *cost_list,
const vp9_variance_fn_ptr_t *vfp,
const vp10_variance_fn_ptr_t *vfp,
int use_mvcost,
const MV *center_mv, MV *best_mv) {
// First scale has 8-closest points, the rest have 6 points in hex shape
@@ -1624,7 +1624,7 @@ int vp10_bigdia_search(const MACROBLOCK *x,
int sad_per_bit,
int do_init_search,
int *cost_list,
const vp9_variance_fn_ptr_t *vfp,
const vp10_variance_fn_ptr_t *vfp,
int use_mvcost,
const MV *center_mv,
MV *best_mv) {
@@ -1666,7 +1666,7 @@ int vp10_square_search(const MACROBLOCK *x,
int sad_per_bit,
int do_init_search,
int *cost_list,
const vp9_variance_fn_ptr_t *vfp,
const vp10_variance_fn_ptr_t *vfp,
int use_mvcost,
const MV *center_mv,
MV *best_mv) {
@@ -1708,7 +1708,7 @@ int vp10_fast_hex_search(const MACROBLOCK *x,
int sad_per_bit,
int do_init_search, // must be zero for fast_hex
int *cost_list,
const vp9_variance_fn_ptr_t *vfp,
const vp10_variance_fn_ptr_t *vfp,
int use_mvcost,
const MV *center_mv,
MV *best_mv) {
@@ -1723,7 +1723,7 @@ int vp10_fast_dia_search(const MACROBLOCK *x,
int sad_per_bit,
int do_init_search,
int *cost_list,
const vp9_variance_fn_ptr_t *vfp,
const vp10_variance_fn_ptr_t *vfp,
int use_mvcost,
const MV *center_mv,
MV *best_mv) {
@@ -1739,7 +1739,7 @@ int vp10_fast_dia_search(const MACROBLOCK *x,
static int exhuastive_mesh_search(const MACROBLOCK *x,
MV *ref_mv, MV *best_mv,
int range, int step, int sad_per_bit,
const vp9_variance_fn_ptr_t *fn_ptr,
const vp10_variance_fn_ptr_t *fn_ptr,
const MV *center_mv) {
const MACROBLOCKD *const xd = &x->e_mbd;
const struct buf_2d *const what = &x->plane[0].src;
@@ -1822,11 +1822,11 @@ static int exhuastive_mesh_search(const MACROBLOCK *x,
}
int vp10_diamond_search_sad_c(const MACROBLOCK *x,
const search_site_config *cfg,
MV *ref_mv, MV *best_mv, int search_param,
int sad_per_bit, int *num00,
const vp9_variance_fn_ptr_t *fn_ptr,
const MV *center_mv) {
const search_site_config *cfg,
MV *ref_mv, MV *best_mv, int search_param,
int sad_per_bit, int *num00,
const vp10_variance_fn_ptr_t *fn_ptr,
const MV *center_mv) {
int i, j, step;
const MACROBLOCKD *const xd = &x->e_mbd;
@@ -2179,7 +2179,7 @@ int vp10_full_pixel_diamond(const VP10_COMP *cpi, MACROBLOCK *x,
MV *mvp_full, int step_param,
int sadpb, int further_steps, int do_refine,
int *cost_list,
const vp9_variance_fn_ptr_t *fn_ptr,
const vp10_variance_fn_ptr_t *fn_ptr,
const MV *ref_mv, MV *dst_mv) {
MV temp_mv;
int thissme, n, num00 = 0;
@@ -2246,7 +2246,7 @@ int vp10_full_pixel_diamond(const VP10_COMP *cpi, MACROBLOCK *x,
// according to the encode speed profile.
static int full_pixel_exhaustive(VP10_COMP *cpi, MACROBLOCK *x,
MV *centre_mv_full, int sadpb, int *cost_list,
const vp9_variance_fn_ptr_t *fn_ptr,
const vp10_variance_fn_ptr_t *fn_ptr,
const MV *ref_mv, MV *dst_mv) {
const SPEED_FEATURES *const sf = &cpi->sf;
MV temp_mv = {centre_mv_full->row, centre_mv_full->col};
@@ -2305,7 +2305,7 @@ static int full_pixel_exhaustive(VP10_COMP *cpi, MACROBLOCK *x,
int vp10_full_search_sad_c(const MACROBLOCK *x, const MV *ref_mv,
int sad_per_bit, int distance,
const vp9_variance_fn_ptr_t *fn_ptr,
const vp10_variance_fn_ptr_t *fn_ptr,
const MV *center_mv, MV *best_mv) {
int r, c;
const MACROBLOCKD *const xd = &x->e_mbd;
@@ -2338,7 +2338,7 @@ int vp10_full_search_sad_c(const MACROBLOCK *x, const MV *ref_mv,
int vp10_full_search_sadx3(const MACROBLOCK *x, const MV *ref_mv,
int sad_per_bit, int distance,
const vp9_variance_fn_ptr_t *fn_ptr,
const vp10_variance_fn_ptr_t *fn_ptr,
const MV *center_mv, MV *best_mv) {
int r;
const MACROBLOCKD *const xd = &x->e_mbd;
@@ -2403,7 +2403,7 @@ int vp10_full_search_sadx3(const MACROBLOCK *x, const MV *ref_mv,
int vp10_full_search_sadx8(const MACROBLOCK *x, const MV *ref_mv,
int sad_per_bit, int distance,
const vp9_variance_fn_ptr_t *fn_ptr,
const vp10_variance_fn_ptr_t *fn_ptr,
const MV *center_mv, MV *best_mv) {
int r;
const MACROBLOCKD *const xd = &x->e_mbd;
@@ -2493,7 +2493,7 @@ int vp10_full_search_sadx8(const MACROBLOCK *x, const MV *ref_mv,
int vp10_refining_search_sad(const MACROBLOCK *x,
MV *ref_mv, int error_per_bit,
int search_range,
const vp9_variance_fn_ptr_t *fn_ptr,
const vp10_variance_fn_ptr_t *fn_ptr,
const MV *center_mv) {
const MACROBLOCKD *const xd = &x->e_mbd;
const MV neighbors[4] = {{ -1, 0}, {0, -1}, {0, 1}, {1, 0}};
@@ -2572,7 +2572,7 @@ int vp10_refining_search_sad(const MACROBLOCK *x,
int vp10_refining_search_8p_c(const MACROBLOCK *x,
MV *ref_mv, int error_per_bit,
int search_range,
const vp9_variance_fn_ptr_t *fn_ptr,
const vp10_variance_fn_ptr_t *fn_ptr,
const MV *center_mv,
const uint8_t *second_pred) {
const MV neighbors[8] = {{-1, 0}, {0, -1}, {0, 1}, {1, 0},
@@ -2636,7 +2636,7 @@ int vp10_full_pixel_search(VP10_COMP *cpi, MACROBLOCK *x,
int var_max, int rd) {
const SPEED_FEATURES *const sf = &cpi->sf;
const SEARCH_METHODS method = sf->mv.search_method;
vp9_variance_fn_ptr_t *fn_ptr = &cpi->fn_ptr[bsize];
vp10_variance_fn_ptr_t *fn_ptr = &cpi->fn_ptr[bsize];
int var = 0;
if (cost_list) {
cost_list[0] = INT_MAX;
@@ -2707,3 +2707,354 @@ int vp10_full_pixel_search(VP10_COMP *cpi, MACROBLOCK *x,
return var;
}
#if CONFIG_EXT_INTER
/* returns subpixel variance error function */
#define DIST(r, c) \
vfp->msvf(pre(y, y_stride, r, c), y_stride, sp(c), sp(r), z, \
src_stride, mask, mask_stride, &sse)
/* checks if (r, c) has better score than previous best */
#define MVC(r, c) \
(mvcost ? \
((mvjcost[((r) != rr) * 2 + ((c) != rc)] + \
mvcost[0][((r) - rr)] + mvcost[1][((c) - rc)]) * \
error_per_bit + 4096) >> 13 : 0)
#define CHECK_BETTER(v, r, c) \
if (c >= minc && c <= maxc && r >= minr && r <= maxr) { \
thismse = (DIST(r, c)); \
if ((v = MVC(r, c) + thismse) < besterr) { \
besterr = v; \
br = r; \
bc = c; \
*distortion = thismse; \
*sse1 = sse; \
} \
} else { \
v = INT_MAX; \
}
int vp10_find_best_masked_sub_pixel_tree(const MACROBLOCK *x,
const uint8_t *mask, int mask_stride,
MV *bestmv, const MV *ref_mv,
int allow_hp,
int error_per_bit,
const vp10_variance_fn_ptr_t *vfp,
int forced_stop,
int iters_per_step,
int *mvjcost, int *mvcost[2],
int *distortion,
unsigned int *sse1, int is_second) {
const uint8_t *const z = x->plane[0].src.buf;
const int src_stride = x->plane[0].src.stride;
const MACROBLOCKD *xd = &x->e_mbd;
unsigned int besterr = INT_MAX;
unsigned int sse;
unsigned int whichdir;
int thismse;
unsigned int halfiters = iters_per_step;
unsigned int quarteriters = iters_per_step;
unsigned int eighthiters = iters_per_step;
const int y_stride = xd->plane[0].pre[is_second].stride;
const int offset = bestmv->row * y_stride + bestmv->col;
const uint8_t *const y = xd->plane[0].pre[is_second].buf;
int rr = ref_mv->row;
int rc = ref_mv->col;
int br = bestmv->row * 8;
int bc = bestmv->col * 8;
int hstep = 4;
const int minc = VPXMAX(x->mv_col_min * 8, ref_mv->col - MV_MAX);
const int maxc = VPXMIN(x->mv_col_max * 8, ref_mv->col + MV_MAX);
const int minr = VPXMAX(x->mv_row_min * 8, ref_mv->row - MV_MAX);
const int maxr = VPXMIN(x->mv_row_max * 8, ref_mv->row + MV_MAX);
int tr = br;
int tc = bc;
// central mv
bestmv->row *= 8;
bestmv->col *= 8;
// calculate central point error
besterr = vfp->mvf(y + offset, y_stride, z, src_stride, mask, mask_stride,
sse1);
*distortion = besterr;
besterr += mv_err_cost(bestmv, ref_mv, mvjcost, mvcost, error_per_bit);
// 1/2 pel
FIRST_LEVEL_CHECKS;
if (halfiters > 1) {
SECOND_LEVEL_CHECKS;
}
tr = br;
tc = bc;
// Note forced_stop: 0 - full, 1 - qtr only, 2 - half only
if (forced_stop != 2) {
hstep >>= 1;
FIRST_LEVEL_CHECKS;
if (quarteriters > 1) {
SECOND_LEVEL_CHECKS;
}
tr = br;
tc = bc;
}
if (allow_hp && vp10_use_mv_hp(ref_mv) && forced_stop == 0) {
hstep >>= 1;
FIRST_LEVEL_CHECKS;
if (eighthiters > 1) {
SECOND_LEVEL_CHECKS;
}
tr = br;
tc = bc;
}
// These lines insure static analysis doesn't warn that
// tr and tc aren't used after the above point.
(void) tr;
(void) tc;
bestmv->row = br;
bestmv->col = bc;
if ((abs(bestmv->col - ref_mv->col) > (MAX_FULL_PEL_VAL << 3)) ||
(abs(bestmv->row - ref_mv->row) > (MAX_FULL_PEL_VAL << 3)))
return INT_MAX;
return besterr;
}
#undef DIST
#undef MVC
#undef CHECK_BETTER
static int get_masked_mvpred_var(const MACROBLOCK *x,
const uint8_t *mask, int mask_stride,
const MV *best_mv, const MV *center_mv,
const vp10_variance_fn_ptr_t *vfp,
int use_mvcost, int is_second) {
const MACROBLOCKD *const xd = &x->e_mbd;
const struct buf_2d *const what = &x->plane[0].src;
const struct buf_2d *const in_what = &xd->plane[0].pre[is_second];
const MV mv = {best_mv->row * 8, best_mv->col * 8};
unsigned int unused;
return vfp->mvf(what->buf, what->stride,
get_buf_from_mv(in_what, best_mv), in_what->stride,
mask, mask_stride, &unused) +
(use_mvcost ? mv_err_cost(&mv, center_mv, x->nmvjointcost,
x->mvcost, x->errorperbit) : 0);
}
int masked_refining_search_sad(const MACROBLOCK *x,
const uint8_t *mask, int mask_stride,
MV *ref_mv, int error_per_bit,
int search_range,
const vp10_variance_fn_ptr_t *fn_ptr,
const MV *center_mv, int is_second) {
const MV neighbors[4] = {{ -1, 0}, {0, -1}, {0, 1}, {1, 0}};
const MACROBLOCKD *const xd = &x->e_mbd;
const struct buf_2d *const what = &x->plane[0].src;
const struct buf_2d *const in_what = &xd->plane[0].pre[is_second];
const MV fcenter_mv = {center_mv->row >> 3, center_mv->col >> 3};
unsigned int best_sad = fn_ptr->msdf(what->buf, what->stride,
get_buf_from_mv(in_what, ref_mv),
in_what->stride, mask, mask_stride) +
mvsad_err_cost(x, ref_mv, &fcenter_mv, error_per_bit);
int i, j;
for (i = 0; i < search_range; i++) {
int best_site = -1;
for (j = 0; j < 4; j++) {
const MV mv = {ref_mv->row + neighbors[j].row,
ref_mv->col + neighbors[j].col};
if (is_mv_in(x, &mv)) {
unsigned int sad = fn_ptr->msdf(what->buf, what->stride,
get_buf_from_mv(in_what, &mv), in_what->stride, mask, mask_stride);
if (sad < best_sad) {
sad += mvsad_err_cost(x, &mv, &fcenter_mv, error_per_bit);
if (sad < best_sad) {
best_sad = sad;
best_site = j;
}
}
}
}
if (best_site == -1) {
break;
} else {
ref_mv->row += neighbors[best_site].row;
ref_mv->col += neighbors[best_site].col;
}
}
return best_sad;
}
int masked_diamond_search_sad(const MACROBLOCK *x,
const search_site_config *cfg,
const uint8_t *mask, int mask_stride,
MV *ref_mv, MV *best_mv,
int search_param,
int sad_per_bit, int *num00,
const vp10_variance_fn_ptr_t *fn_ptr,
const MV *center_mv, int is_second) {
const MACROBLOCKD *const xd = &x->e_mbd;
const struct buf_2d *const what = &x->plane[0].src;
const struct buf_2d *const in_what = &xd->plane[0].pre[is_second];
// search_param determines the length of the initial step and hence the number
// of iterations
// 0 = initial step (MAX_FIRST_STEP) pel : 1 = (MAX_FIRST_STEP/2) pel, 2 =
// (MAX_FIRST_STEP/4) pel... etc.
const search_site *const ss = &cfg->ss[search_param * cfg->searches_per_step];
const int tot_steps = (cfg->ss_count / cfg->searches_per_step) - search_param;
const MV fcenter_mv = {center_mv->row >> 3, center_mv->col >> 3};
const uint8_t *best_address, *in_what_ref;
int best_sad = INT_MAX;
int best_site = 0;
int last_site = 0;
int i, j, step;
clamp_mv(ref_mv, x->mv_col_min, x->mv_col_max, x->mv_row_min, x->mv_row_max);
in_what_ref = get_buf_from_mv(in_what, ref_mv);
best_address = in_what_ref;
*num00 = 0;
*best_mv = *ref_mv;
// Check the starting position
best_sad = fn_ptr->msdf(what->buf, what->stride,
best_address, in_what->stride,
mask, mask_stride) +
mvsad_err_cost(x, best_mv, &fcenter_mv, sad_per_bit);
i = 1;
for (step = 0; step < tot_steps; step++) {
for (j = 0; j < cfg->searches_per_step; j++) {
const MV mv = {best_mv->row + ss[i].mv.row,
best_mv->col + ss[i].mv.col};
if (is_mv_in(x, &mv)) {
int sad = fn_ptr->msdf(what->buf, what->stride,
best_address + ss[i].offset, in_what->stride,
mask, mask_stride);
if (sad < best_sad) {
sad += mvsad_err_cost(x, &mv, &fcenter_mv, sad_per_bit);
if (sad < best_sad) {
best_sad = sad;
best_site = i;
}
}
}
i++;
}
if (best_site != last_site) {
best_mv->row += ss[best_site].mv.row;
best_mv->col += ss[best_site].mv.col;
best_address += ss[best_site].offset;
last_site = best_site;
#if defined(NEW_DIAMOND_SEARCH)
while (1) {
const MV this_mv = {best_mv->row + ss[best_site].mv.row,
best_mv->col + ss[best_site].mv.col};
if (is_mv_in(x, &this_mv)) {
int sad = fn_ptr->msdf(what->buf, what->stride,
best_address + ss[best_site].offset,
in_what->stride, mask, mask_stride);
if (sad < best_sad) {
sad += mvsad_err_cost(x, &this_mv, &fcenter_mv, sad_per_bit);
if (sad < best_sad) {
best_sad = sad;
best_mv->row += ss[best_site].mv.row;
best_mv->col += ss[best_site].mv.col;
best_address += ss[best_site].offset;
continue;
}
}
}
break;
}
#endif
} else if (best_address == in_what_ref) {
(*num00)++;
}
}
return best_sad;
}
int vp10_masked_full_pixel_diamond(const VP10_COMP *cpi, MACROBLOCK *x,
const uint8_t *mask, int mask_stride,
MV *mvp_full, int step_param,
int sadpb, int further_steps, int do_refine,
const vp10_variance_fn_ptr_t *fn_ptr,
const MV *ref_mv, MV *dst_mv,
int is_second) {
MV temp_mv;
int thissme, n, num00 = 0;
int bestsme = masked_diamond_search_sad(x, &cpi->ss_cfg,
mask, mask_stride,
mvp_full, &temp_mv,
step_param, sadpb, &n,
fn_ptr, ref_mv, is_second);
if (bestsme < INT_MAX)
bestsme = get_masked_mvpred_var(x, mask, mask_stride, &temp_mv, ref_mv,
fn_ptr, 1, is_second);
*dst_mv = temp_mv;
// If there won't be more n-step search, check to see if refining search is
// needed.
if (n > further_steps)
do_refine = 0;
while (n < further_steps) {
++n;
if (num00) {
num00--;
} else {
thissme = masked_diamond_search_sad(x, &cpi->ss_cfg,
mask, mask_stride,
mvp_full, &temp_mv,
step_param + n, sadpb, &num00,
fn_ptr, ref_mv, is_second);
if (thissme < INT_MAX)
thissme = get_masked_mvpred_var(x, mask, mask_stride,
&temp_mv, ref_mv, fn_ptr, 1,
is_second);
// check to see if refining search is needed.
if (num00 > further_steps - n)
do_refine = 0;
if (thissme < bestsme) {
bestsme = thissme;
*dst_mv = temp_mv;
}
}
}
// final 1-away diamond refining search
if (do_refine) {
const int search_range = 8;
MV best_mv = *dst_mv;
thissme = masked_refining_search_sad(x, mask, mask_stride,
&best_mv, sadpb, search_range,
fn_ptr, ref_mv, is_second);
if (thissme < INT_MAX)
thissme = get_masked_mvpred_var(x, mask, mask_stride,
&best_mv, ref_mv, fn_ptr, 1,
is_second);
if (thissme < bestsme) {
bestsme = thissme;
*dst_mv = best_mv;
}
}
return bestsme;
}
#endif // CONFIG_EXT_INTER

40
vp10/encoder/mcomp.h
View File

@@ -53,12 +53,12 @@ int vp10_mv_bit_cost(const MV *mv, const MV *ref,
// Utility to compute variance + MV rate cost for a given MV
int vp10_get_mvpred_var(const MACROBLOCK *x,
const MV *best_mv, const MV *center_mv,
const vp9_variance_fn_ptr_t *vfp,
const vp10_variance_fn_ptr_t *vfp,
int use_mvcost);
int vp10_get_mvpred_av_var(const MACROBLOCK *x,
const MV *best_mv, const MV *center_mv,
const uint8_t *second_pred,
const vp9_variance_fn_ptr_t *vfp,
const vp10_variance_fn_ptr_t *vfp,
int use_mvcost);
struct VP10_COMP;
@@ -69,7 +69,7 @@ int vp10_init_search_range(int size);
int vp10_refining_search_sad(const struct macroblock *x,
struct mv *ref_mv,
int sad_per_bit, int distance,
const struct vp9_variance_vtable *fn_ptr,
const vp10_variance_fn_ptr_t *fn_ptr,
const struct mv *center_mv);
// Runs sequence of diamond searches in smaller steps for RD.
@@ -77,7 +77,7 @@ int vp10_full_pixel_diamond(const struct VP10_COMP *cpi, MACROBLOCK *x,
MV *mvp_full, int step_param,
int sadpb, int further_steps, int do_refine,
int *cost_list,
const vp9_variance_fn_ptr_t *fn_ptr,
const vp10_variance_fn_ptr_t *fn_ptr,
const MV *ref_mv, MV *dst_mv);
// Perform integral projection based motion estimation.
@@ -93,7 +93,7 @@ typedef int (integer_mv_pattern_search_fn) (
int error_per_bit,
int do_init_search,
int *cost_list,
const vp9_variance_fn_ptr_t *vf,
const vp10_variance_fn_ptr_t *vf,
int use_mvcost,
const MV *center_mv,
MV *best_mv);
@@ -109,7 +109,7 @@ typedef int (fractional_mv_step_fp) (
MV *bestmv, const MV *ref_mv,
int allow_hp,
int error_per_bit,
const vp9_variance_fn_ptr_t *vfp,
const vp10_variance_fn_ptr_t *vfp,
int forced_stop, // 0 - full, 1 - qtr only, 2 - half only
int iters_per_step,
int *cost_list,
@@ -130,13 +130,13 @@ extern fractional_mv_step_fp vp10_find_best_sub_pixel_tree_pruned_evenmore;
typedef int (*vp10_full_search_fn_t)(const MACROBLOCK *x,
const MV *ref_mv, int sad_per_bit,
int distance,
const vp9_variance_fn_ptr_t *fn_ptr,
const vp10_variance_fn_ptr_t *fn_ptr,
const MV *center_mv, MV *best_mv);
typedef int (*vp10_refining_search_fn_t)(const MACROBLOCK *x,
MV *ref_mv, int sad_per_bit,
int distance,
const vp9_variance_fn_ptr_t *fn_ptr,
const vp10_variance_fn_ptr_t *fn_ptr,
const MV *center_mv);
typedef int (*vp10_diamond_search_fn_t)(const MACROBLOCK *x,
@@ -144,13 +144,13 @@ typedef int (*vp10_diamond_search_fn_t)(const MACROBLOCK *x,
MV *ref_mv, MV *best_mv,
int search_param, int sad_per_bit,
int *num00,
const vp9_variance_fn_ptr_t *fn_ptr,
const vp10_variance_fn_ptr_t *fn_ptr,
const MV *center_mv);
int vp10_refining_search_8p_c(const MACROBLOCK *x,
MV *ref_mv, int error_per_bit,
int search_range,
const vp9_variance_fn_ptr_t *fn_ptr,
const vp10_variance_fn_ptr_t *fn_ptr,
const MV *center_mv, const uint8_t *second_pred);
struct VP10_COMP;
@@ -162,6 +162,26 @@ int vp10_full_pixel_search(struct VP10_COMP *cpi, MACROBLOCK *x,
const MV *ref_mv, MV *tmp_mv,
int var_max, int rd);
#if CONFIG_EXT_INTER
int vp10_find_best_masked_sub_pixel_tree(const MACROBLOCK *x,
const uint8_t *mask, int mask_stride,
MV *bestmv, const MV *ref_mv,
int allow_hp,
int error_per_bit,
const vp10_variance_fn_ptr_t *vfp,
int forced_stop,
int iters_per_step,
int *mvjcost, int *mvcost[2],
int *distortion,
unsigned int *sse1, int is_second);
int vp10_masked_full_pixel_diamond(const struct VP10_COMP *cpi, MACROBLOCK *x,
const uint8_t *mask, int mask_stride,
MV *mvp_full, int step_param,
int sadpb, int further_steps, int do_refine,
const vp10_variance_fn_ptr_t *fn_ptr,
const MV *ref_mv, MV *dst_mv,
int is_second);
#endif // CONFIG_EXT_INTER
#ifdef __cplusplus
} // extern "C"
#endif

596
vp10/encoder/rdopt.c
View File

@@ -44,10 +44,6 @@
#include "vp10/encoder/rdopt.h"
#include "vp10/encoder/aq_variance.h"
// TODO(geza.lore) Update this when the extended coding unit size experiment
// have been ported.
#define CU_SIZE 64
#if CONFIG_EXT_REFS
#define LAST_FRAME_MODE_MASK ((1 << GOLDEN_FRAME) | (1 << ALTREF_FRAME) | \
@@ -4305,8 +4301,8 @@ static void joint_motion_search(VP10_COMP *cpi, MACROBLOCK *x,
if (bsize >= BLOCK_8X8)
#endif // CONFIG_EXT_INTER
*rate_mv += vp10_mv_bit_cost(&frame_mv[refs[ref]].as_mv,
&x->mbmi_ext->ref_mvs[refs[ref]][0].as_mv,
x->nmvjointcost, x->mvcost, MV_COST_WEIGHT);
&x->mbmi_ext->ref_mvs[refs[ref]][0].as_mv,
x->nmvjointcost, x->mvcost, MV_COST_WEIGHT);
#if CONFIG_EXT_INTER
else
*rate_mv += vp10_mv_bit_cost(&frame_mv[refs[ref]].as_mv,
@@ -5107,6 +5103,7 @@ static void single_motion_search(VP10_COMP *cpi, MACROBLOCK *x,
#else
int ref = mbmi->ref_frame[0];
MV ref_mv = x->mbmi_ext->ref_mvs[ref][0].as_mv;
int ref_idx = 0;
#endif // CONFIG_EXT_INTER
int tmp_col_min = x->mv_col_min;
@@ -5133,9 +5130,9 @@ static void single_motion_search(VP10_COMP *cpi, MACROBLOCK *x,
// match the resolution of the current frame, allowing the existing
// motion search code to be used without additional modifications.
for (i = 0; i < MAX_MB_PLANE; i++)
backup_yv12[i] = xd->plane[i].pre[0];
backup_yv12[i] = xd->plane[i].pre[ref_idx];
vp10_setup_pre_planes(xd, 0, scaled_ref_frame, mi_row, mi_col, NULL);
vp10_setup_pre_planes(xd, ref_idx, scaled_ref_frame, mi_row, mi_col, NULL);
}
vp10_set_mv_search_range(x, &ref_mv);
@@ -5179,7 +5176,7 @@ static void single_motion_search(VP10_COMP *cpi, MACROBLOCK *x,
if (scaled_ref_frame) {
int i;
for (i = 0; i < MAX_MB_PLANE; ++i)
xd->plane[i].pre[0] = backup_yv12[i];
xd->plane[i].pre[ref_idx] = backup_yv12[i];
}
return;
}
@@ -5193,8 +5190,8 @@ static void single_motion_search(VP10_COMP *cpi, MACROBLOCK *x,
mvp_full.row >>= 3;
bestsme = vp10_full_pixel_search(cpi, x, bsize, &mvp_full, step_param, sadpb,
cond_cost_list(cpi, cost_list),
&ref_mv, &tmp_mv->as_mv, INT_MAX, 1);
cond_cost_list(cpi, cost_list),
&ref_mv, &tmp_mv->as_mv, INT_MAX, 1);
x->mv_col_min = tmp_col_min;
x->mv_col_max = tmp_col_max;
@@ -5208,11 +5205,11 @@ static void single_motion_search(VP10_COMP *cpi, MACROBLOCK *x,
const int ph = 4 * num_4x4_blocks_high_lookup[bsize];
// Use up-sampled reference frames.
struct macroblockd_plane *const pd = &xd->plane[0];
struct buf_2d backup_pred = pd->pre[0];
struct buf_2d backup_pred = pd->pre[ref_idx];
const YV12_BUFFER_CONFIG *upsampled_ref = get_upsampled_ref(cpi, ref);
// Set pred for Y plane
setup_pred_plane(&pd->pre[0], upsampled_ref->y_buffer,
setup_pred_plane(&pd->pre[ref_idx], upsampled_ref->y_buffer,
upsampled_ref->y_stride, (mi_row << 3), (mi_col << 3),
NULL, pd->subsampling_x, pd->subsampling_y);
@@ -5228,7 +5225,7 @@ static void single_motion_search(VP10_COMP *cpi, MACROBLOCK *x,
pw, ph, 1);
// Restore the reference frames.
pd->pre[0] = backup_pred;
pd->pre[ref_idx] = backup_pred;
#else
cpi->find_fractional_mv_step(x, &tmp_mv->as_mv, &ref_mv,
cm->allow_high_precision_mv,
@@ -5250,7 +5247,7 @@ static void single_motion_search(VP10_COMP *cpi, MACROBLOCK *x,
if (scaled_ref_frame) {
int i;
for (i = 0; i < MAX_MB_PLANE; i++)
xd->plane[i].pre[0] = backup_yv12[i];
xd->plane[i].pre[ref_idx] = backup_yv12[i];
}
}
@@ -5264,6 +5261,176 @@ static INLINE void restore_dst_buf(MACROBLOCKD *xd,
}
}
#if CONFIG_EXT_INTER
static void do_masked_motion_search(VP10_COMP *cpi, MACROBLOCK *x,
const uint8_t *mask, int mask_stride,
BLOCK_SIZE bsize,
int mi_row, int mi_col,
int_mv *tmp_mv, int *rate_mv,
int ref_idx,
int mv_idx) {
MACROBLOCKD *xd = &x->e_mbd;
const VP10_COMMON *cm = &cpi->common;
MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
struct buf_2d backup_yv12[MAX_MB_PLANE] = {{0, 0}};
int bestsme = INT_MAX;
int step_param;
int sadpb = x->sadperbit16;
MV mvp_full;
int ref = mbmi->ref_frame[ref_idx];
MV ref_mv = x->mbmi_ext->ref_mvs[ref][mv_idx].as_mv;
int tmp_col_min = x->mv_col_min;
int tmp_col_max = x->mv_col_max;
int tmp_row_min = x->mv_row_min;
int tmp_row_max = x->mv_row_max;
const YV12_BUFFER_CONFIG *scaled_ref_frame =
vp10_get_scaled_ref_frame(cpi, ref);
MV pred_mv[3];
pred_mv[0] = x->mbmi_ext->ref_mvs[ref][0].as_mv;
pred_mv[1] = x->mbmi_ext->ref_mvs[ref][1].as_mv;
pred_mv[2] = x->pred_mv[ref];
#if CONFIG_REF_MV
vp10_set_mvcost(x, ref);
#endif
if (scaled_ref_frame) {
int i;
// Swap out the reference frame for a version that's been scaled to
// match the resolution of the current frame, allowing the existing
// motion search code to be used without additional modifications.
for (i = 0; i < MAX_MB_PLANE; i++)
backup_yv12[i] = xd->plane[i].pre[ref_idx];
vp10_setup_pre_planes(xd, ref_idx, scaled_ref_frame, mi_row, mi_col, NULL);
}
vp10_set_mv_search_range(x, &ref_mv);
// Work out the size of the first step in the mv step search.
// 0 here is maximum length first step. 1 is MAX >> 1 etc.
if (cpi->sf.mv.auto_mv_step_size && cm->show_frame) {
// Take wtd average of the step_params based on the last frame's
// max mv magnitude and that based on the best ref mvs of the current
// block for the given reference.
step_param = (vp10_init_search_range(x->max_mv_context[ref]) +
cpi->mv_step_param) / 2;
} else {
step_param = cpi->mv_step_param;
}
// TODO(debargha): is show_frame needed here?
if (cpi->sf.adaptive_motion_search && bsize < BLOCK_LARGEST &&
cm->show_frame) {
int boffset = 2 * (b_width_log2_lookup[BLOCK_LARGEST] -
VPXMIN(b_height_log2_lookup[bsize], b_width_log2_lookup[bsize]));
step_param = VPXMAX(step_param, boffset);
}
if (cpi->sf.adaptive_motion_search) {
int bwl = b_width_log2_lookup[bsize];
int bhl = b_height_log2_lookup[bsize];
int tlevel = x->pred_mv_sad[ref] >> (bwl + bhl + 4);
if (tlevel < 5)
step_param += 2;
// prev_mv_sad is not setup for dynamically scaled frames.
if (cpi->oxcf.resize_mode != RESIZE_DYNAMIC) {
int i;
for (i = LAST_FRAME; i <= ALTREF_FRAME && cm->show_frame; ++i) {
if ((x->pred_mv_sad[ref] >> 3) > x->pred_mv_sad[i]) {
x->pred_mv[ref].row = 0;
x->pred_mv[ref].col = 0;
tmp_mv->as_int = INVALID_MV;
if (scaled_ref_frame) {
int i;
for (i = 0; i < MAX_MB_PLANE; ++i)
xd->plane[i].pre[ref_idx] = backup_yv12[i];
}
return;
}
}
}
}
mvp_full = pred_mv[x->mv_best_ref_index[ref]];
mvp_full.col >>= 3;
mvp_full.row >>= 3;
bestsme = vp10_masked_full_pixel_diamond(cpi, x, mask, mask_stride,
&mvp_full, step_param, sadpb,
MAX_MVSEARCH_STEPS - 1 - step_param,
1, &cpi->fn_ptr[bsize],
&ref_mv, &tmp_mv->as_mv, ref_idx);
x->mv_col_min = tmp_col_min;
x->mv_col_max = tmp_col_max;
x->mv_row_min = tmp_row_min;
x->mv_row_max = tmp_row_max;
if (bestsme < INT_MAX) {
int dis; /* TODO: use dis in distortion calculation later. */
vp10_find_best_masked_sub_pixel_tree(x, mask, mask_stride,
&tmp_mv->as_mv, &ref_mv,
cm->allow_high_precision_mv,
x->errorperbit,
&cpi->fn_ptr[bsize],
cpi->sf.mv.subpel_force_stop,
cpi->sf.mv.subpel_iters_per_step,
x->nmvjointcost, x->mvcost,
&dis, &x->pred_sse[ref], ref_idx);
}
*rate_mv = vp10_mv_bit_cost(&tmp_mv->as_mv, &ref_mv,
x->nmvjointcost, x->mvcost, MV_COST_WEIGHT);
if (cpi->sf.adaptive_motion_search && cm->show_frame)
x->pred_mv[ref] = tmp_mv->as_mv;
if (scaled_ref_frame) {
int i;
for (i = 0; i < MAX_MB_PLANE; i++)
xd->plane[i].pre[ref_idx] = backup_yv12[i];
}
}
static void do_masked_motion_search_indexed(VP10_COMP *cpi, MACROBLOCK *x,
int wedge_index,
BLOCK_SIZE bsize,
int mi_row, int mi_col,
int_mv *tmp_mv, int *rate_mv,
int mv_idx[2],
int which) {
// NOTE: which values: 0 - 0 only, 1 - 1 only, 2 - both
MACROBLOCKD *xd = &x->e_mbd;
MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
BLOCK_SIZE sb_type = mbmi->sb_type;
int w = (4 << b_width_log2_lookup[sb_type]);
int h = (4 << b_height_log2_lookup[sb_type]);
const uint8_t *mask;
const int mask_stride = MASK_MASTER_STRIDE;
mask = vp10_get_soft_mask(wedge_index, sb_type, h, w);
if (which == 0 || which == 2)
do_masked_motion_search(cpi, x, mask, mask_stride, bsize,
mi_row, mi_col, &tmp_mv[0], &rate_mv[0],
0, mv_idx[0]);
if (which == 1 || which == 2) {
// get the negative mask
mask = vp10_get_soft_mask(wedge_index ^ 1, sb_type, h, w);
do_masked_motion_search(cpi, x, mask, mask_stride, bsize,
mi_row, mi_col, &tmp_mv[1], &rate_mv[1],
1, mv_idx[1]);
}
}
#endif // CONFIG_EXT_INTER
// In some situations we want to discount tha pparent cost of a new motion
// vector. Where there is a subtle motion field and especially where there is
// low spatial complexity then it can be hard to cover the cost of a new motion
@@ -5296,6 +5463,7 @@ static INLINE void clamp_mv2(MV *mv, const MACROBLOCKD *xd) {
xd->mb_to_top_edge - LEFT_TOP_MARGIN,
xd->mb_to_bottom_edge + RIGHT_BOTTOM_MARGIN);
}
static INTERP_FILTER predict_interp_filter(const VP10_COMP *cpi,
const MACROBLOCK *x,
const BLOCK_SIZE bsize,
@@ -5424,6 +5592,7 @@ static int64_t handle_inter_mode(VP10_COMP *cpi, MACROBLOCK *x,
int_mv single_newmvs[2][MAX_REF_FRAMES],
int single_newmvs_rate[2][MAX_REF_FRAMES],
int *compmode_interintra_cost,
int *compmode_wedge_cost,
#else
int_mv single_newmv[MAX_REF_FRAMES],
#endif // CONFIG_EXT_INTER
@@ -5444,41 +5613,47 @@ static int64_t handle_inter_mode(VP10_COMP *cpi, MACROBLOCK *x,
int refs[2] = { mbmi->ref_frame[0],
(mbmi->ref_frame[1] < 0 ? 0 : mbmi->ref_frame[1]) };
int_mv cur_mv[2];
int rate_mv = 0;
#if CONFIG_EXT_INTER
int mv_idx = (this_mode == NEWFROMNEARMV) ? 1 : 0;
int_mv single_newmv[MAX_REF_FRAMES];
const int * const intra_mode_cost =
cpi->mbmode_cost[size_group_lookup[bsize]];
const int is_comp_interintra_pred = (mbmi->ref_frame[1] == INTRA_FRAME);
const int tmp_buf_sz = CU_SIZE * CU_SIZE;
#if CONFIG_REF_MV
uint8_t ref_frame_type = vp10_ref_frame_type(mbmi->ref_frame);
#endif
#endif // CONFIG_EXT_INTER
#if CONFIG_VP9_HIGHBITDEPTH
DECLARE_ALIGNED(16, uint16_t, tmp_buf16[MAX_MB_PLANE * 64 * 64]);
DECLARE_ALIGNED(16, uint16_t, tmp_buf16[MAX_MB_PLANE * CU_SIZE * CU_SIZE]);
uint8_t *tmp_buf;
#else
DECLARE_ALIGNED(16, uint8_t, tmp_buf[MAX_MB_PLANE * 64 * 64]);
DECLARE_ALIGNED(16, uint8_t, tmp_buf[MAX_MB_PLANE * CU_SIZE * CU_SIZE]);
#endif // CONFIG_VP9_HIGHBITDEPTH
#if CONFIG_EXT_INTER
const int tmp_buf_sz = CU_SIZE * CU_SIZE;
#endif // CONFIG_EXT_INTER
#if CONFIG_OBMC
int allow_obmc = is_obmc_allowed(mbmi);
int allow_obmc =
#if CONFIG_EXT_INTER
!is_comp_interintra_pred &&
#endif // CONFIG_EXT_INTER
is_obmc_allowed(mbmi);
int best_obmc_flag = 0;
#if CONFIG_VP9_HIGHBITDEPTH
DECLARE_ALIGNED(16, uint16_t, tmp_buf1_16[MAX_MB_PLANE * 64 * 64]);
DECLARE_ALIGNED(16, uint16_t, tmp_buf2_16[MAX_MB_PLANE * 64 * 64]);
DECLARE_ALIGNED(16, uint16_t, tmp_buf1_16[MAX_MB_PLANE * CU_SIZE * CU_SIZE]);
DECLARE_ALIGNED(16, uint16_t, tmp_buf2_16[MAX_MB_PLANE * CU_SIZE * CU_SIZE]);
uint8_t *tmp_buf1, *tmp_buf2;
uint8_t *obmc_tmp_buf1[3];
uint8_t *obmc_tmp_buf2[3];
#else
DECLARE_ALIGNED(16, uint8_t, tmp_buf1[MAX_MB_PLANE * 64 * 64]);
DECLARE_ALIGNED(16, uint8_t, tmp_buf2[MAX_MB_PLANE * 64 * 64]);
uint8_t *obmc_tmp_buf1[3] = {tmp_buf1, tmp_buf1 + 4096, tmp_buf1 + 8192};
uint8_t *obmc_tmp_buf2[3] = {tmp_buf2, tmp_buf2 + 4096, tmp_buf2 + 8192};
DECLARE_ALIGNED(16, uint8_t, tmp_buf1[MAX_MB_PLANE * CU_SIZE * CU_SIZE]);
DECLARE_ALIGNED(16, uint8_t, tmp_buf2[MAX_MB_PLANE * CU_SIZE * CU_SIZE]);
uint8_t *obmc_tmp_buf1[3] = {tmp_buf1, tmp_buf1 + CU_SIZE * CU_SIZE,
tmp_buf1 + CU_SIZE * CU_SIZE * 2};
uint8_t *obmc_tmp_buf2[3] = {tmp_buf2, tmp_buf2 + CU_SIZE * CU_SIZE,
tmp_buf2 + CU_SIZE * CU_SIZE * 2};
#endif // CONFIG_VP9_HIGHBITDEPTH
int obmc_tmp_stride[3] = {64, 64, 64};
int obmc_tmp_stride[3] = {CU_SIZE, CU_SIZE, CU_SIZE};
uint8_t skip_txfm_bestfilter[2][MAX_MB_PLANE << 2] = {{0}, {0}};
int64_t bsse_bestfilter[2][MAX_MB_PLANE << 2] = {{0}, {0}};
@@ -5497,6 +5672,7 @@ static int64_t handle_inter_mode(VP10_COMP *cpi, MACROBLOCK *x,
unsigned int best_pred_var = UINT_MAX;
MB_MODE_INFO best_mbmi;
#endif // CONFIG_OBMC
int pred_exists = 0;
int intpel_mv;
int64_t rd, tmp_rd, best_rd = INT64_MAX;
@@ -5515,6 +5691,9 @@ static int64_t handle_inter_mode(VP10_COMP *cpi, MACROBLOCK *x,
#if CONFIG_EXT_INTER
*compmode_interintra_cost = 0;
mbmi->use_wedge_interintra = 0;
*compmode_wedge_cost = 0;
mbmi->use_wedge_interinter = 0;
// is_comp_interintra_pred implies !is_comp_pred
assert(!is_comp_interintra_pred || (!is_comp_pred));
@@ -5565,12 +5744,7 @@ static int64_t handle_inter_mode(VP10_COMP *cpi, MACROBLOCK *x,
return INT64_MAX;
}
#if CONFIG_EXT_INTER
if (have_newmv_in_inter_mode(this_mode)) {
#else
if (this_mode == NEWMV) {
#endif // CONFIG_EXT_INTER
int rate_mv;
if (is_comp_pred) {
#if CONFIG_EXT_INTER
for (i = 0; i < 2; ++i) {
@@ -5757,7 +5931,7 @@ static int64_t handle_inter_mode(VP10_COMP *cpi, MACROBLOCK *x,
}
}
#endif // CONFIG_EXT_INTER
#endif
#endif // CONFIG_REF_MV
// do first prediction into the destination buffer. Do the next
// prediction into a temporary buffer. Then keep track of which one
@@ -5795,10 +5969,11 @@ static int64_t handle_inter_mode(VP10_COMP *cpi, MACROBLOCK *x,
if (RDCOST(x->rdmult, x->rddiv, *rate2, 0) > ref_best_rd &&
#if CONFIG_EXT_INTER
mbmi->mode != NEARESTMV && mbmi->mode != NEAREST_NEARESTMV)
mbmi->mode != NEARESTMV && mbmi->mode != NEAREST_NEARESTMV
#else
mbmi->mode != NEARESTMV)
mbmi->mode != NEARESTMV
#endif // CONFIG_EXT_INTER
)
return INT64_MAX;
pred_exists = 0;
@@ -5991,6 +6166,8 @@ static int64_t handle_inter_mode(VP10_COMP *cpi, MACROBLOCK *x,
skip_sse_sb = tmp_skip_sse;
memcpy(skip_txfm, x->skip_txfm, sizeof(skip_txfm));
memcpy(bsse, x->bsse, sizeof(bsse));
} else {
pred_exists = 0;
}
}
restore_dst_buf(xd, orig_dst, orig_dst_stride);
@@ -6002,12 +6179,169 @@ static int64_t handle_inter_mode(VP10_COMP *cpi, MACROBLOCK *x,
rs = cm->interp_filter == SWITCHABLE ? vp10_get_switchable_rate(cpi, xd) : 0;
#if CONFIG_EXT_INTER
if (is_comp_pred && get_wedge_bits(bsize)) {
int wedge_index, best_wedge_index = WEDGE_NONE, rs;
int rate_sum;
int64_t dist_sum;
int64_t best_rd_nowedge = INT64_MAX;
int64_t best_rd_wedge = INT64_MAX;
int wedge_types;
int tmp_skip_txfm_sb;
int64_t tmp_skip_sse_sb;
rs = vp10_cost_bit(cm->fc->wedge_interinter_prob[bsize], 0);
vp10_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
model_rd_for_sb(cpi, bsize, x, xd, &rate_sum, &dist_sum,
&tmp_skip_txfm_sb, &tmp_skip_sse_sb);
rd = RDCOST(x->rdmult, x->rddiv, rs + rate_mv + rate_sum, dist_sum);
best_rd_nowedge = rd;
mbmi->use_wedge_interinter = 1;
rs = get_wedge_bits(bsize) * 256 +
vp10_cost_bit(cm->fc->wedge_interinter_prob[bsize], 1);
wedge_types = (1 << get_wedge_bits(bsize));
if (have_newmv_in_inter_mode(this_mode)) {
int_mv tmp_mv[2];
int rate_mvs[2], tmp_rate_mv = 0;
uint8_t pred0[2 * CU_SIZE * CU_SIZE * 3];
uint8_t pred1[2 * CU_SIZE * CU_SIZE * 3];
uint8_t *preds0[3] = {pred0,
pred0 + 2 * CU_SIZE * CU_SIZE,
pred0 + 4 * CU_SIZE * CU_SIZE};
uint8_t *preds1[3] = {pred1,
pred1 + 2 * CU_SIZE * CU_SIZE,
pred1 + 4 * CU_SIZE * CU_SIZE};
int strides[3] = {CU_SIZE, CU_SIZE, CU_SIZE};
vp10_build_inter_predictors_for_planes_single_buf(
xd, bsize, mi_row, mi_col, 0, preds0, strides);
vp10_build_inter_predictors_for_planes_single_buf(
xd, bsize, mi_row, mi_col, 1, preds1, strides);
for (wedge_index = 0; wedge_index < wedge_types; ++wedge_index) {
mbmi->interinter_wedge_index = wedge_index;
vp10_build_wedge_inter_predictor_from_buf(xd, bsize, mi_row, mi_col,
preds0, strides,
preds1, strides);
model_rd_for_sb(cpi, bsize, x, xd, &rate_sum, &dist_sum,
&tmp_skip_txfm_sb, &tmp_skip_sse_sb);
rd = RDCOST(x->rdmult, x->rddiv, rs + rate_mv + rate_sum, dist_sum);
if (rd < best_rd_wedge) {
best_wedge_index = wedge_index;
best_rd_wedge = rd;
}
}
mbmi->interinter_wedge_index = best_wedge_index;
if (this_mode == NEW_NEWMV) {
int mv_idxs[2] = {0, 0};
do_masked_motion_search_indexed(cpi, x, mbmi->interinter_wedge_index,
bsize, mi_row, mi_col, tmp_mv, rate_mvs,
mv_idxs, 2);
tmp_rate_mv = rate_mvs[0] + rate_mvs[1];
mbmi->mv[0].as_int = tmp_mv[0].as_int;
mbmi->mv[1].as_int = tmp_mv[1].as_int;
} else if (this_mode == NEW_NEARESTMV || this_mode == NEW_NEARMV) {
int mv_idxs[2] = {0, 0};
do_masked_motion_search_indexed(cpi, x, mbmi->interinter_wedge_index,
bsize, mi_row, mi_col, tmp_mv, rate_mvs,
mv_idxs, 0);
tmp_rate_mv = rate_mvs[0];
mbmi->mv[0].as_int = tmp_mv[0].as_int;
} else if (this_mode == NEAREST_NEWMV || this_mode == NEAR_NEWMV) {
int mv_idxs[2] = {0, 0};
do_masked_motion_search_indexed(cpi, x, mbmi->interinter_wedge_index,
bsize, mi_row, mi_col, tmp_mv, rate_mvs,
mv_idxs, 1);
tmp_rate_mv = rate_mvs[1];
mbmi->mv[1].as_int = tmp_mv[1].as_int;
}
vp10_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
model_rd_for_sb(cpi, bsize, x, xd, &rate_sum, &dist_sum,
&tmp_skip_txfm_sb, &tmp_skip_sse_sb);
rd = RDCOST(x->rdmult, x->rddiv, rs + tmp_rate_mv + rate_sum, dist_sum);
if (rd < best_rd_wedge) {
best_rd_wedge = rd;
} else {
mbmi->mv[0].as_int = cur_mv[0].as_int;
mbmi->mv[1].as_int = cur_mv[1].as_int;
tmp_rate_mv = rate_mv;
}
if (best_rd_wedge < best_rd_nowedge) {
mbmi->use_wedge_interinter = 1;
mbmi->interinter_wedge_index = best_wedge_index;
xd->mi[0]->bmi[0].as_mv[0].as_int = mbmi->mv[0].as_int;
xd->mi[0]->bmi[0].as_mv[1].as_int = mbmi->mv[1].as_int;
*rate2 += tmp_rate_mv - rate_mv;
rate_mv = tmp_rate_mv;
} else {
mbmi->use_wedge_interinter = 0;
mbmi->mv[0].as_int = cur_mv[0].as_int;
mbmi->mv[1].as_int = cur_mv[1].as_int;
}
} else {
uint8_t pred0[2 * CU_SIZE * CU_SIZE * 3];
uint8_t pred1[2 * CU_SIZE * CU_SIZE * 3];
uint8_t *preds0[3] = {pred0,
pred0 + 2 * CU_SIZE * CU_SIZE,
pred0 + 4 * CU_SIZE * CU_SIZE};
uint8_t *preds1[3] = {pred1,
pred1 + 2 * CU_SIZE * CU_SIZE,
pred1 + 4 * CU_SIZE * CU_SIZE};
int strides[3] = {CU_SIZE, CU_SIZE, CU_SIZE};
vp10_build_inter_predictors_for_planes_single_buf(
xd, bsize, mi_row, mi_col, 0, preds0, strides);
vp10_build_inter_predictors_for_planes_single_buf(
xd, bsize, mi_row, mi_col, 1, preds1, strides);
for (wedge_index = 0; wedge_index < wedge_types; ++wedge_index) {
mbmi->interinter_wedge_index = wedge_index;
// vp10_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
vp10_build_wedge_inter_predictor_from_buf(xd, bsize, mi_row, mi_col,
preds0, strides,
preds1, strides);
model_rd_for_sb(cpi, bsize, x, xd, &rate_sum, &dist_sum,
&tmp_skip_txfm_sb, &tmp_skip_sse_sb);
rd = RDCOST(x->rdmult, x->rddiv, rs + rate_mv + rate_sum, dist_sum);
if (rd < best_rd_wedge) {
best_wedge_index = wedge_index;
best_rd_wedge = rd;
}
}
if (best_rd_wedge < best_rd_nowedge) {
mbmi->use_wedge_interinter = 1;
mbmi->interinter_wedge_index = best_wedge_index;
} else {
mbmi->use_wedge_interinter = 0;
}
}
#if CONFIG_OBMC
if (mbmi->use_wedge_interinter)
allow_obmc = 0;
#endif // CONFIG_OBMC
if (ref_best_rd < INT64_MAX &&
VPXMIN(best_rd_wedge, best_rd_nowedge) / 2 > ref_best_rd)
return INT64_MAX;
pred_exists = 0;
tmp_rd = VPXMIN(best_rd_wedge, best_rd_nowedge);
if (mbmi->use_wedge_interinter)
*compmode_wedge_cost = get_wedge_bits(bsize) * 256 +
vp10_cost_bit(cm->fc->wedge_interinter_prob[bsize], 1);
else
*compmode_wedge_cost =
vp10_cost_bit(cm->fc->wedge_interinter_prob[bsize], 0);
}
if (is_comp_interintra_pred) {
PREDICTION_MODE interintra_mode, best_interintra_mode = DC_PRED;
int64_t best_interintra_rd = INT64_MAX;
int rmode, rate_sum;
int64_t dist_sum;
int j;
int wedge_bits, wedge_types, wedge_index, best_wedge_index = -1;
int64_t best_interintra_rd_nowedge = INT64_MAX;
int64_t best_interintra_rd_wedge = INT64_MAX;
int rwedge;
int bw = 4 << b_width_log2_lookup[mbmi->sb_type],
bh = 4 << b_height_log2_lookup[mbmi->sb_type];
int_mv tmp_mv;
int tmp_rate_mv = 0;
mbmi->ref_frame[1] = NONE;
for (j = 0; j < MAX_MB_PLANE; j++) {
xd->plane[j].dst.buf = tmp_buf + j * tmp_buf_sz;
@@ -6023,16 +6357,16 @@ static int64_t handle_inter_mode(VP10_COMP *cpi, MACROBLOCK *x,
mbmi->interintra_uv_mode = interintra_mode;
rmode = intra_mode_cost[mbmi->interintra_mode];
vp10_build_interintra_predictors(xd,
tmp_buf,
tmp_buf + tmp_buf_sz,
tmp_buf + 2 * tmp_buf_sz,
CU_SIZE,
CU_SIZE,
CU_SIZE,
bsize);
tmp_buf,
tmp_buf + tmp_buf_sz,
tmp_buf + 2 * tmp_buf_sz,
CU_SIZE,
CU_SIZE,
CU_SIZE,
bsize);
model_rd_for_sb(cpi, bsize, x, xd, &rate_sum, &dist_sum,
&skip_txfm_sb, &skip_sse_sb);
rd = RDCOST(x->rdmult, x->rddiv, rmode + rate_sum, dist_sum);
rd = RDCOST(x->rdmult, x->rddiv, rate_mv + rmode + rate_sum, dist_sum);
if (rd < best_interintra_rd) {
best_interintra_rd = rd;
best_interintra_mode = interintra_mode;
@@ -6044,17 +6378,112 @@ static int64_t handle_inter_mode(VP10_COMP *cpi, MACROBLOCK *x,
best_interintra_rd / 2 > ref_best_rd) {
return INT64_MAX;
}
wedge_bits = get_wedge_bits(bsize);
rmode = intra_mode_cost[mbmi->interintra_mode];
if (wedge_bits) {
vp10_build_interintra_predictors(xd,
tmp_buf,
tmp_buf + tmp_buf_sz,
tmp_buf + 2 * tmp_buf_sz,
CU_SIZE,
CU_SIZE,
CU_SIZE,
bsize);
model_rd_for_sb(cpi, bsize, x, xd, &rate_sum, &dist_sum,
&skip_txfm_sb, &skip_sse_sb);
rwedge = vp10_cost_bit(cm->fc->wedge_interintra_prob[bsize], 0);
rd = RDCOST(x->rdmult, x->rddiv,
rmode + rate_mv + rwedge + rate_sum, dist_sum);
best_interintra_rd_nowedge = rd;
mbmi->use_wedge_interintra = 1;
rwedge = wedge_bits * 256 +
vp10_cost_bit(cm->fc->wedge_interintra_prob[bsize], 1);
wedge_types = (1 << wedge_bits);
for (wedge_index = 0; wedge_index < wedge_types; ++wedge_index) {
mbmi->interintra_wedge_index = wedge_index;
mbmi->interintra_uv_wedge_index = wedge_index;
vp10_build_interintra_predictors(xd,
tmp_buf,
tmp_buf + tmp_buf_sz,
tmp_buf + 2 * tmp_buf_sz,
CU_SIZE,
CU_SIZE,
CU_SIZE,
bsize);
model_rd_for_sb(cpi, bsize, x, xd, &rate_sum, &dist_sum,
&skip_txfm_sb, &skip_sse_sb);
rd = RDCOST(x->rdmult, x->rddiv,
rmode + rate_mv + rwedge + rate_sum, dist_sum);
if (rd < best_interintra_rd_wedge) {
best_interintra_rd_wedge = rd;
best_wedge_index = wedge_index;
}
}
// Refine motion vector.
if (have_newmv_in_inter_mode(this_mode)) {
// get negative of mask
const uint8_t* mask = vp10_get_soft_mask(
best_wedge_index ^ 1, bsize, bh, bw);
mbmi->interintra_wedge_index = best_wedge_index;
mbmi->interintra_uv_wedge_index = best_wedge_index;
do_masked_motion_search(cpi, x, mask, MASK_MASTER_STRIDE, bsize,
mi_row, mi_col, &tmp_mv, &tmp_rate_mv,
0, mv_idx);
mbmi->mv[0].as_int = tmp_mv.as_int;
vp10_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
model_rd_for_sb(cpi, bsize, x, xd, &rate_sum, &dist_sum,
&skip_txfm_sb, &skip_sse_sb);
rd = RDCOST(x->rdmult, x->rddiv,
rmode + tmp_rate_mv + rwedge + rate_sum, dist_sum);
if (rd < best_interintra_rd_wedge) {
best_interintra_rd_wedge = rd;
} else {
tmp_mv.as_int = cur_mv[0].as_int;
tmp_rate_mv = rate_mv;
}
} else {
tmp_mv.as_int = cur_mv[0].as_int;
tmp_rate_mv = rate_mv;
}
if (best_interintra_rd_wedge < best_interintra_rd_nowedge) {
mbmi->use_wedge_interintra = 1;
mbmi->interintra_wedge_index = best_wedge_index;
mbmi->interintra_uv_wedge_index = best_wedge_index;
best_interintra_rd = best_interintra_rd_wedge;
mbmi->mv[0].as_int = tmp_mv.as_int;
*rate2 += tmp_rate_mv - rate_mv;
rate_mv = tmp_rate_mv;
} else {
mbmi->use_wedge_interintra = 0;
best_interintra_rd = best_interintra_rd_nowedge;
mbmi->mv[0].as_int = cur_mv[0].as_int;
}
}
pred_exists = 0;
tmp_rd = best_interintra_rd;
*compmode_interintra_cost =
vp10_cost_bit(cm->fc->interintra_prob[bsize], 1);
vp10_cost_bit(cm->fc->interintra_prob[bsize], 1);
*compmode_interintra_cost += intra_mode_cost[mbmi->interintra_mode];
if (get_wedge_bits(bsize)) {
*compmode_interintra_cost += vp10_cost_bit(
cm->fc->wedge_interintra_prob[bsize], mbmi->use_wedge_interintra);
if (mbmi->use_wedge_interintra) {
*compmode_interintra_cost += get_wedge_bits(bsize) * 256;
}
}
} else if (is_interintra_allowed(mbmi)) {
*compmode_interintra_cost =
vp10_cost_bit(cm->fc->interintra_prob[bsize], 0);
}
#if CONFIG_EXT_INTERP
if (!vp10_is_interp_needed(xd) && cm->interp_filter == SWITCHABLE) {
mbmi->interp_filter = EIGHTTAP_REGULAR;
pred_exists = 0;
}
#endif // CONFIG_EXT_INTERP
#endif // CONFIG_EXT_INTER
#if CONFIG_OBMC
@@ -6800,17 +7229,15 @@ void vp10_rd_pick_inter_mode_sb(VP10_COMP *cpi,
int_mv *const candidates = x->mbmi_ext->ref_mvs[ref_frame];
x->mbmi_ext->mode_context[ref_frame] = 0;
vp10_find_mv_refs(cm, xd, mi, ref_frame,
#if CONFIG_REF_MV
&mbmi_ext->ref_mv_count[ref_frame],
mbmi_ext->ref_mv_stack[ref_frame],
#if CONFIG_EXT_INTER
mbmi_ext->compound_mode_context,
#endif // CONFIG_EXT_INTER
#endif
candidates, mi_row, mi_col,
NULL, NULL, mbmi_ext->mode_context);
}
#endif
#endif // CONFIG_REF_MV
#if CONFIG_OBMC
vp10_build_prediction_by_above_preds(cpi, xd, mi_row, mi_col, dst_buf1,
@@ -6936,6 +7363,7 @@ void vp10_rd_pick_inter_mode_sb(VP10_COMP *cpi,
int compmode_cost = 0;
#if CONFIG_EXT_INTER
int compmode_interintra_cost = 0;
int compmode_wedge_cost = 0;
#endif // CONFIG_EXT_INTER
int rate2 = 0, rate_y = 0, rate_uv = 0;
int64_t distortion2 = 0, distortion_y = 0, distortion_uv = 0;
@@ -7326,6 +7754,7 @@ void vp10_rd_pick_inter_mode_sb(VP10_COMP *cpi,
single_newmvs,
single_newmvs_rate,
&compmode_interintra_cost,
&compmode_wedge_cost,
#else
single_newmv,
#endif // CONFIG_EXT_INTER
@@ -7392,6 +7821,7 @@ void vp10_rd_pick_inter_mode_sb(VP10_COMP *cpi,
int dummy_single_newmvs_rate[2][MAX_REF_FRAMES] =
{ { 0 }, { 0 } };
int dummy_compmode_interintra_cost = 0;
int dummy_compmode_wedge_cost = 0;
#else
int_mv dummy_single_newmv[MAX_REF_FRAMES] = { { 0 } };
#endif
@@ -7411,6 +7841,7 @@ void vp10_rd_pick_inter_mode_sb(VP10_COMP *cpi,
dummy_single_newmvs,
dummy_single_newmvs_rate,
&dummy_compmode_interintra_cost,
&dummy_compmode_wedge_cost,
#else
dummy_single_newmv,
#endif
@@ -7487,6 +7918,8 @@ void vp10_rd_pick_inter_mode_sb(VP10_COMP *cpi,
#if CONFIG_EXT_INTER
rate2 += compmode_interintra_cost;
if (cm->reference_mode != SINGLE_REFERENCE && comp_pred)
rate2 += compmode_wedge_cost;
#endif // CONFIG_EXT_INTER
// Estimate the reference frame signaling cost and add it
@@ -8103,6 +8536,10 @@ void vp10_rd_pick_inter_mode_sub8x8(struct VP10_COMP *cpi,
#if CONFIG_OBMC
mbmi->obmc = 0;
#endif // CONFIG_OBMC
#if CONFIG_EXT_INTER
mbmi->use_wedge_interinter = 0;
mbmi->use_wedge_interintra = 0;
#endif // CONFIG_EXT_INTER
for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; ++i)
filter_cache[i] = INT64_MAX;
@@ -8850,7 +9287,7 @@ void vp10_build_prediction_by_above_preds(VP10_COMP *cpi,
mi_step = VPXMIN(xd->n8_w,
num_8x8_blocks_wide_lookup[above_mbmi->sb_type]);
if (!is_inter_block(above_mbmi))
if (!is_neighbor_overlappable(above_mbmi))
continue;
for (j = 0; j < MAX_MB_PLANE; ++j) {
@@ -8860,14 +9297,27 @@ void vp10_build_prediction_by_above_preds(VP10_COMP *cpi,
0, i, NULL,
pd->subsampling_x, pd->subsampling_y);
}
/*
set_ref_ptrs(cm, xd, above_mbmi->ref_frame[0], above_mbmi->ref_frame[1]);
for (ref = 0; ref < 1 + has_second_ref(above_mbmi); ++ref) {
YV12_BUFFER_CONFIG *cfg = get_ref_frame_buffer(cpi,
above_mbmi->ref_frame[ref]);
YV12_BUFFER_CONFIG *cfg = get_ref_frame_buffer(
cpi, above_mbmi->ref_frame[ref]);
assert(cfg != NULL);
vp10_setup_pre_planes(xd, ref, cfg, mi_row, mi_col + i,
&xd->block_refs[ref]->sf);
}
*/
for (ref = 0; ref < 1 + has_second_ref(above_mbmi); ++ref) {
MV_REFERENCE_FRAME frame = above_mbmi->ref_frame[ref];
RefBuffer *ref_buf = &cm->frame_refs[frame - LAST_FRAME];
xd->block_refs[ref] = ref_buf;
if ((!vp10_is_valid_scale(&ref_buf->sf)))
vpx_internal_error(xd->error_info, VPX_CODEC_UNSUP_BITSTREAM,
"Reference frame has invalid dimensions");
vp10_setup_pre_planes(xd, ref, ref_buf->buf, mi_row, mi_col + i,
&ref_buf->sf);
}
xd->mb_to_left_edge = -(((mi_col + i) * MI_SIZE) * 8);
mi_x = (mi_col + i) << MI_SIZE_LOG2;
@@ -8896,11 +9346,19 @@ void vp10_build_prediction_by_above_preds(VP10_COMP *cpi,
build_inter_predictors(xd, j, mi_col_offset, mi_row_offset,
y * 2 + x, bw, bh,
4 * x, 0, pw, bh, mi_x, mi_y);
4 * x, 0, pw, bh,
#if CONFIG_SUPERTX && CONFIG_EXT_INTER
0, 0,
#endif // CONFIG_SUPERTX && CONFIG_EXT_INTER
mi_x, mi_y);
}
} else {
build_inter_predictors(xd, j, mi_col_offset, mi_row_offset, 0,
bw, bh, 0, 0, bw, bh, mi_x, mi_y);
build_inter_predictors(xd, j, mi_col_offset, mi_row_offset,
0, bw, bh, 0, 0, bw, bh,
#if CONFIG_SUPERTX && CONFIG_EXT_INTER
0, 0,
#endif // CONFIG_SUPERTX && CONFIG_EXT_INTER
mi_x, mi_y);
}
}
}
@@ -8928,11 +9386,12 @@ void vp10_build_prediction_by_left_preds(VP10_COMP *cpi,
MODE_INFO *left_mi = xd->mi[mi_col_offset +
mi_row_offset * xd->mi_stride];
MB_MODE_INFO *left_mbmi = &left_mi->mbmi;
const int is_compound = has_second_ref(left_mbmi);
mi_step = VPXMIN(xd->n8_h,
num_8x8_blocks_high_lookup[left_mbmi->sb_type]);
if (!is_inter_block(left_mbmi))
if (!is_neighbor_overlappable(left_mbmi))
continue;
for (j = 0; j < MAX_MB_PLANE; ++j) {
@@ -8942,6 +9401,7 @@ void vp10_build_prediction_by_left_preds(VP10_COMP *cpi,
i, 0, NULL,
pd->subsampling_x, pd->subsampling_y);
}
/*
set_ref_ptrs(cm, xd, left_mbmi->ref_frame[0], left_mbmi->ref_frame[1]);
for (ref = 0; ref < 1 + has_second_ref(left_mbmi); ++ref) {
YV12_BUFFER_CONFIG *cfg = get_ref_frame_buffer(cpi,
@@ -8950,6 +9410,18 @@ void vp10_build_prediction_by_left_preds(VP10_COMP *cpi,
vp10_setup_pre_planes(xd, ref, cfg, mi_row + i, mi_col,
&xd->block_refs[ref]->sf);
}
*/
for (ref = 0; ref < 1 + is_compound; ++ref) {
MV_REFERENCE_FRAME frame = left_mbmi->ref_frame[ref];
RefBuffer *ref_buf = &cm->frame_refs[frame - LAST_FRAME];
xd->block_refs[ref] = ref_buf;
if ((!vp10_is_valid_scale(&ref_buf->sf)))
vpx_internal_error(xd->error_info, VPX_CODEC_UNSUP_BITSTREAM,
"Reference frame has invalid dimensions");
vp10_setup_pre_planes(xd, ref, ref_buf->buf, mi_row + i, mi_col,
&ref_buf->sf);
}
xd->mb_to_top_edge = -(((mi_row + i) * MI_SIZE) * 8);
mi_x = mi_col << MI_SIZE_LOG2;
@@ -8978,11 +9450,19 @@ void vp10_build_prediction_by_left_preds(VP10_COMP *cpi,
build_inter_predictors(xd, j, mi_col_offset, mi_row_offset,
y * 2 + x, bw, bh,
0, 4 * y, bw, ph, mi_x, mi_y);
0, 4 * y, bw, ph,
#if CONFIG_SUPERTX && CONFIG_EXT_INTER
0, 0,
#endif // CONFIG_SUPERTX && CONFIG_EXT_INTER
mi_x, mi_y);
}
} else {
build_inter_predictors(xd, j, mi_col_offset, mi_row_offset, 0,
bw, bh, 0, 0, bw, bh, mi_x, mi_y);
bw, bh, 0, 0, bw, bh,
#if CONFIG_SUPERTX && CONFIG_EXT_INTER
0, 0,
#endif // CONFIG_SUPERTX && CONFIG_EXT_INTER
mi_x, mi_y);
}
}
}

47
vpx_dsp/variance.h
View File

@@ -74,7 +74,32 @@ typedef struct variance_vtable {
} vp8_variance_fn_ptr_t;
#endif // CONFIG_VP8
#if CONFIG_VP9 || CONFIG_VP10
#if CONFIG_VP10 && CONFIG_EXT_INTER
typedef unsigned int(*vpx_masked_sad_fn_t)(const uint8_t *src_ptr,
int source_stride,
const uint8_t *ref_ptr,
int ref_stride,
const uint8_t *msk_ptr,
int msk_stride);
typedef unsigned int (*vpx_masked_variance_fn_t)(const uint8_t *src_ptr,
int source_stride,
const uint8_t *ref_ptr,
int ref_stride,
const uint8_t *msk_ptr,
int msk_stride,
unsigned int *sse);
typedef unsigned int (*vpx_masked_subpixvariance_fn_t)(const uint8_t *src_ptr,
int source_stride,
int xoffset,
int yoffset,
const uint8_t *ref_ptr,
int Refstride,
const uint8_t *msk_ptr,
int msk_stride,
unsigned int *sse);
#endif // CONFIG_VP10 && CONFIG_EXT_INTER
#if CONFIG_VP9
typedef struct vp9_variance_vtable {
vpx_sad_fn_t sdf;
vpx_sad_avg_fn_t sdaf;
@@ -85,7 +110,25 @@ typedef struct vp9_variance_vtable {
vpx_sad_multi_fn_t sdx8f;
vpx_sad_multi_d_fn_t sdx4df;
} vp9_variance_fn_ptr_t;
#endif // CONFIG_VP9 || CONFIG_VP10
#endif // CONFIG_VP9
#if CONFIG_VP10
typedef struct vp10_variance_vtable {
vpx_sad_fn_t sdf;
vpx_sad_avg_fn_t sdaf;
vpx_variance_fn_t vf;
vpx_subpixvariance_fn_t svf;
vpx_subp_avg_variance_fn_t svaf;
vpx_sad_multi_fn_t sdx3f;
vpx_sad_multi_fn_t sdx8f;
vpx_sad_multi_d_fn_t sdx4df;
#if CONFIG_EXT_INTER
vpx_masked_sad_fn_t msdf;
vpx_masked_variance_fn_t mvf;
vpx_masked_subpixvariance_fn_t msvf;
#endif // CONFIG_EXT_INTER
} vp10_variance_fn_ptr_t;
#endif // CONFIG_VP10
#ifdef __cplusplus
} // extern "C"