Index: source/libvpx/vp9/encoder/vp9_pickmode.c |
diff --git a/source/libvpx/vp9/encoder/vp9_pickmode.c b/source/libvpx/vp9/encoder/vp9_pickmode.c |
index 6dfb9eedde14e15b3bff64b5a32625fdfcb67156..9fb7cfba7bfc9e67024650502cb6a8164023f8b7 100644 |
--- a/source/libvpx/vp9/encoder/vp9_pickmode.c |
+++ b/source/libvpx/vp9/encoder/vp9_pickmode.c |
@@ -20,9 +20,11 @@ |
#include "vp9/common/vp9_blockd.h" |
#include "vp9/common/vp9_common.h" |
#include "vp9/common/vp9_mvref_common.h" |
+#include "vp9/common/vp9_pred_common.h" |
#include "vp9/common/vp9_reconinter.h" |
#include "vp9/common/vp9_reconintra.h" |
+#include "vp9/encoder/vp9_cost.h" |
#include "vp9/encoder/vp9_encoder.h" |
#include "vp9/encoder/vp9_pickmode.h" |
#include "vp9/encoder/vp9_ratectrl.h" |
@@ -49,7 +51,7 @@ static int mv_refs_rt(const VP9_COMMON *cm, const MACROBLOCKD *xd, |
int const_motion = 0; |
// Blank the reference vector list |
- vpx_memset(mv_ref_list, 0, sizeof(*mv_ref_list) * MAX_MV_REF_CANDIDATES); |
+ memset(mv_ref_list, 0, sizeof(*mv_ref_list) * MAX_MV_REF_CANDIDATES); |
// The nearest 2 blocks are treated differently |
// if the size < 8x8 we get the mv from the bmi substructure, |
@@ -58,7 +60,7 @@ static int mv_refs_rt(const VP9_COMMON *cm, const MACROBLOCKD *xd, |
const POSITION *const mv_ref = &mv_ref_search[i]; |
if (is_inside(tile, mi_col, mi_row, cm->mi_rows, mv_ref)) { |
const MODE_INFO *const candidate_mi = xd->mi[mv_ref->col + mv_ref->row * |
- xd->mi_stride].src_mi; |
+ xd->mi_stride]; |
const MB_MODE_INFO *const candidate = &candidate_mi->mbmi; |
// Keep counts for entropy encoding. |
context_counter += mode_2_counter[candidate->mode]; |
@@ -79,7 +81,7 @@ static int mv_refs_rt(const VP9_COMMON *cm, const MACROBLOCKD *xd, |
const POSITION *const mv_ref = &mv_ref_search[i]; |
if (is_inside(tile, mi_col, mi_row, cm->mi_rows, mv_ref)) { |
const MB_MODE_INFO *const candidate = &xd->mi[mv_ref->col + mv_ref->row * |
- xd->mi_stride].src_mi->mbmi; |
+ xd->mi_stride]->mbmi; |
different_ref_found = 1; |
if (candidate->ref_frame[0] == ref_frame) |
@@ -95,7 +97,7 @@ static int mv_refs_rt(const VP9_COMMON *cm, const MACROBLOCKD *xd, |
const POSITION *mv_ref = &mv_ref_search[i]; |
if (is_inside(tile, mi_col, mi_row, cm->mi_rows, mv_ref)) { |
const MB_MODE_INFO *const candidate = &xd->mi[mv_ref->col + mv_ref->row |
- * xd->mi_stride].src_mi->mbmi; |
+ * xd->mi_stride]->mbmi; |
// If the candidate is INTRA we don't want to consider its mv. |
IF_DIFF_REF_FRAME_ADD_MV(candidate, ref_frame, ref_sign_bias, |
@@ -120,7 +122,7 @@ static int combined_motion_search(VP9_COMP *cpi, MACROBLOCK *x, |
int_mv *tmp_mv, int *rate_mv, |
int64_t best_rd_sofar) { |
MACROBLOCKD *xd = &x->e_mbd; |
- MB_MODE_INFO *mbmi = &xd->mi[0].src_mi->mbmi; |
+ MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi; |
struct buf_2d backup_yv12[MAX_MB_PLANE] = {{0, 0}}; |
const int step_param = cpi->sf.mv.fullpel_search_step_param; |
const int sadpb = x->sadperbit16; |
@@ -188,6 +190,8 @@ static int combined_motion_search(VP9_COMP *cpi, MACROBLOCK *x, |
cond_cost_list(cpi, cost_list), |
x->nmvjointcost, x->mvcost, |
&dis, &x->pred_sse[ref], NULL, 0, 0); |
+ *rate_mv = vp9_mv_bit_cost(&tmp_mv->as_mv, &ref_mv, |
+ x->nmvjointcost, x->mvcost, MV_COST_WEIGHT); |
} |
if (scaled_ref_frame) { |
@@ -198,6 +202,250 @@ static int combined_motion_search(VP9_COMP *cpi, MACROBLOCK *x, |
return rv; |
} |
+static void block_variance(const uint8_t *src, int src_stride, |
+ const uint8_t *ref, int ref_stride, |
+ int w, int h, unsigned int *sse, int *sum, |
+ int block_size, unsigned int *sse8x8, |
+ int *sum8x8, unsigned int *var8x8) { |
+ int i, j, k = 0; |
+ |
+ *sse = 0; |
+ *sum = 0; |
+ |
+ for (i = 0; i < h; i += block_size) { |
+ for (j = 0; j < w; j += block_size) { |
+ vp9_get8x8var(src + src_stride * i + j, src_stride, |
+ ref + ref_stride * i + j, ref_stride, |
+ &sse8x8[k], &sum8x8[k]); |
+ *sse += sse8x8[k]; |
+ *sum += sum8x8[k]; |
+ var8x8[k] = sse8x8[k] - (((unsigned int)sum8x8[k] * sum8x8[k]) >> 6); |
+ k++; |
+ } |
+ } |
+} |
+ |
+static void calculate_variance(int bw, int bh, TX_SIZE tx_size, |
+ unsigned int *sse_i, int *sum_i, |
+ unsigned int *var_o, unsigned int *sse_o, |
+ int *sum_o) { |
+ const BLOCK_SIZE unit_size = txsize_to_bsize[tx_size]; |
+ const int nw = 1 << (bw - b_width_log2_lookup[unit_size]); |
+ const int nh = 1 << (bh - b_height_log2_lookup[unit_size]); |
+ int i, j, k = 0; |
+ |
+ for (i = 0; i < nh; i += 2) { |
+ for (j = 0; j < nw; j += 2) { |
+ sse_o[k] = sse_i[i * nw + j] + sse_i[i * nw + j + 1] + |
+ sse_i[(i + 1) * nw + j] + sse_i[(i + 1) * nw + j + 1]; |
+ sum_o[k] = sum_i[i * nw + j] + sum_i[i * nw + j + 1] + |
+ sum_i[(i + 1) * nw + j] + sum_i[(i + 1) * nw + j + 1]; |
+ var_o[k] = sse_o[k] - (((unsigned int)sum_o[k] * sum_o[k]) >> |
+ (b_width_log2_lookup[unit_size] + |
+ b_height_log2_lookup[unit_size] + 6)); |
+ k++; |
+ } |
+ } |
+} |
+ |
+static void model_rd_for_sb_y_large(VP9_COMP *cpi, BLOCK_SIZE bsize, |
+ MACROBLOCK *x, MACROBLOCKD *xd, |
+ int *out_rate_sum, int64_t *out_dist_sum, |
+ unsigned int *var_y, unsigned int *sse_y, |
+ int mi_row, int mi_col, int *early_term) { |
+ // Note our transform coeffs are 8 times an orthogonal transform. |
+ // Hence quantizer step is also 8 times. To get effective quantizer |
+ // we need to divide by 8 before sending to modeling function. |
+ unsigned int sse; |
+ int rate; |
+ int64_t dist; |
+ struct macroblock_plane *const p = &x->plane[0]; |
+ struct macroblockd_plane *const pd = &xd->plane[0]; |
+ const uint32_t dc_quant = pd->dequant[0]; |
+ const uint32_t ac_quant = pd->dequant[1]; |
+ const int64_t dc_thr = dc_quant * dc_quant >> 6; |
+ const int64_t ac_thr = ac_quant * ac_quant >> 6; |
+ unsigned int var; |
+ int sum; |
+ int skip_dc = 0; |
+ |
+ const int bw = b_width_log2_lookup[bsize]; |
+ const int bh = b_height_log2_lookup[bsize]; |
+ const int num8x8 = 1 << (bw + bh - 2); |
+ unsigned int sse8x8[64] = {0}; |
+ int sum8x8[64] = {0}; |
+ unsigned int var8x8[64] = {0}; |
+ TX_SIZE tx_size; |
+ int i, k; |
+ |
+ // Calculate variance for whole partition, and also save 8x8 blocks' variance |
+ // to be used in following transform skipping test. |
+ block_variance(p->src.buf, p->src.stride, pd->dst.buf, pd->dst.stride, |
+ 4 << bw, 4 << bh, &sse, &sum, 8, sse8x8, sum8x8, var8x8); |
+ var = sse - (((int64_t)sum * sum) >> (bw + bh + 4)); |
+ |
+ *var_y = var; |
+ *sse_y = sse; |
+ |
+ if (cpi->common.tx_mode == TX_MODE_SELECT) { |
+ if (sse > (var << 2)) |
+ tx_size = MIN(max_txsize_lookup[bsize], |
+ tx_mode_to_biggest_tx_size[cpi->common.tx_mode]); |
+ else |
+ tx_size = TX_8X8; |
+ |
+ if (cpi->sf.partition_search_type == VAR_BASED_PARTITION) { |
+ if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ && |
+ cyclic_refresh_segment_id_boosted(xd->mi[0]->mbmi.segment_id)) |
+ tx_size = TX_8X8; |
+ else if (tx_size > TX_16X16) |
+ tx_size = TX_16X16; |
+ } |
+ } else { |
+ tx_size = MIN(max_txsize_lookup[bsize], |
+ tx_mode_to_biggest_tx_size[cpi->common.tx_mode]); |
+ } |
+ |
+ assert(tx_size >= TX_8X8); |
+ xd->mi[0]->mbmi.tx_size = tx_size; |
+ |
+ // Evaluate if the partition block is a skippable block in Y plane. |
+ { |
+ unsigned int sse16x16[16] = {0}; |
+ int sum16x16[16] = {0}; |
+ unsigned int var16x16[16] = {0}; |
+ const int num16x16 = num8x8 >> 2; |
+ |
+ unsigned int sse32x32[4] = {0}; |
+ int sum32x32[4] = {0}; |
+ unsigned int var32x32[4] = {0}; |
+ const int num32x32 = num8x8 >> 4; |
+ |
+ int ac_test = 1; |
+ int dc_test = 1; |
+ const int num = (tx_size == TX_8X8) ? num8x8 : |
+ ((tx_size == TX_16X16) ? num16x16 : num32x32); |
+ const unsigned int *sse_tx = (tx_size == TX_8X8) ? sse8x8 : |
+ ((tx_size == TX_16X16) ? sse16x16 : sse32x32); |
+ const unsigned int *var_tx = (tx_size == TX_8X8) ? var8x8 : |
+ ((tx_size == TX_16X16) ? var16x16 : var32x32); |
+ |
+ // Calculate variance if tx_size > TX_8X8 |
+ if (tx_size >= TX_16X16) |
+ calculate_variance(bw, bh, TX_8X8, sse8x8, sum8x8, var16x16, sse16x16, |
+ sum16x16); |
+ if (tx_size == TX_32X32) |
+ calculate_variance(bw, bh, TX_16X16, sse16x16, sum16x16, var32x32, |
+ sse32x32, sum32x32); |
+ |
+ // Skipping test |
+ x->skip_txfm[0] = 0; |
+ for (k = 0; k < num; k++) |
+ // Check if all ac coefficients can be quantized to zero. |
+ if (!(var_tx[k] < ac_thr || var == 0)) { |
+ ac_test = 0; |
+ break; |
+ } |
+ |
+ for (k = 0; k < num; k++) |
+ // Check if dc coefficient can be quantized to zero. |
+ if (!(sse_tx[k] - var_tx[k] < dc_thr || sse == var)) { |
+ dc_test = 0; |
+ break; |
+ } |
+ |
+ if (ac_test) { |
+ x->skip_txfm[0] = 2; |
+ |
+ if (dc_test) |
+ x->skip_txfm[0] = 1; |
+ } else if (dc_test) { |
+ skip_dc = 1; |
+ } |
+ } |
+ |
+ if (x->skip_txfm[0] == 1) { |
+ int skip_uv[2] = {0}; |
+ unsigned int var_uv[2]; |
+ unsigned int sse_uv[2]; |
+ |
+ *out_rate_sum = 0; |
+ *out_dist_sum = sse << 4; |
+ |
+ // Transform skipping test in UV planes. |
+ for (i = 1; i <= 2; i++) { |
+ struct macroblock_plane *const p = &x->plane[i]; |
+ struct macroblockd_plane *const pd = &xd->plane[i]; |
+ const TX_SIZE uv_tx_size = get_uv_tx_size(&xd->mi[0]->mbmi, pd); |
+ const BLOCK_SIZE unit_size = txsize_to_bsize[uv_tx_size]; |
+ const BLOCK_SIZE uv_bsize = get_plane_block_size(bsize, pd); |
+ const int uv_bw = b_width_log2_lookup[uv_bsize]; |
+ const int uv_bh = b_height_log2_lookup[uv_bsize]; |
+ const int sf = (uv_bw - b_width_log2_lookup[unit_size]) + |
+ (uv_bh - b_height_log2_lookup[unit_size]); |
+ const uint32_t uv_dc_thr = pd->dequant[0] * pd->dequant[0] >> (6 - sf); |
+ const uint32_t uv_ac_thr = pd->dequant[1] * pd->dequant[1] >> (6 - sf); |
+ int j = i - 1; |
+ |
+ vp9_build_inter_predictors_sbp(xd, mi_row, mi_col, bsize, i); |
+ var_uv[j] = cpi->fn_ptr[uv_bsize].vf(p->src.buf, p->src.stride, |
+ pd->dst.buf, pd->dst.stride, &sse_uv[j]); |
+ |
+ if ((var_uv[j] < uv_ac_thr || var_uv[j] == 0) && |
+ (sse_uv[j] - var_uv[j] < uv_dc_thr || sse_uv[j] == var_uv[j])) |
+ skip_uv[j] = 1; |
+ else |
+ break; |
+ } |
+ |
+ // If the transform in YUV planes are skippable, the mode search checks |
+ // fewer inter modes and doesn't check intra modes. |
+ if (skip_uv[0] & skip_uv[1]) { |
+ *early_term = 1; |
+ } |
+ |
+ return; |
+ } |
+ |
+ if (!skip_dc) { |
+#if CONFIG_VP9_HIGHBITDEPTH |
+ if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) { |
+ vp9_model_rd_from_var_lapndz(sse - var, num_pels_log2_lookup[bsize], |
+ dc_quant >> (xd->bd - 5), &rate, &dist); |
+ } else { |
+ vp9_model_rd_from_var_lapndz(sse - var, num_pels_log2_lookup[bsize], |
+ dc_quant >> 3, &rate, &dist); |
+ } |
+#else |
+ vp9_model_rd_from_var_lapndz(sse - var, num_pels_log2_lookup[bsize], |
+ dc_quant >> 3, &rate, &dist); |
+#endif // CONFIG_VP9_HIGHBITDEPTH |
+ } |
+ |
+ if (!skip_dc) { |
+ *out_rate_sum = rate >> 1; |
+ *out_dist_sum = dist << 3; |
+ } else { |
+ *out_rate_sum = 0; |
+ *out_dist_sum = (sse - var) << 4; |
+ } |
+ |
+#if CONFIG_VP9_HIGHBITDEPTH |
+ if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) { |
+ vp9_model_rd_from_var_lapndz(var, num_pels_log2_lookup[bsize], |
+ ac_quant >> (xd->bd - 5), &rate, &dist); |
+ } else { |
+ vp9_model_rd_from_var_lapndz(var, num_pels_log2_lookup[bsize], |
+ ac_quant >> 3, &rate, &dist); |
+ } |
+#else |
+ vp9_model_rd_from_var_lapndz(var, num_pels_log2_lookup[bsize], |
+ ac_quant >> 3, &rate, &dist); |
+#endif // CONFIG_VP9_HIGHBITDEPTH |
+ |
+ *out_rate_sum += rate; |
+ *out_dist_sum += dist << 4; |
+} |
static void model_rd_for_sb_y(VP9_COMP *cpi, BLOCK_SIZE bsize, |
MACROBLOCK *x, MACROBLOCKD *xd, |
@@ -224,21 +472,21 @@ static void model_rd_for_sb_y(VP9_COMP *cpi, BLOCK_SIZE bsize, |
if (cpi->common.tx_mode == TX_MODE_SELECT) { |
if (sse > (var << 2)) |
- xd->mi[0].src_mi->mbmi.tx_size = |
+ xd->mi[0]->mbmi.tx_size = |
MIN(max_txsize_lookup[bsize], |
tx_mode_to_biggest_tx_size[cpi->common.tx_mode]); |
else |
- xd->mi[0].src_mi->mbmi.tx_size = TX_8X8; |
+ xd->mi[0]->mbmi.tx_size = TX_8X8; |
if (cpi->sf.partition_search_type == VAR_BASED_PARTITION) { |
if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ && |
- cyclic_refresh_segment_id_boosted(xd->mi[0].src_mi->mbmi.segment_id)) |
- xd->mi[0].src_mi->mbmi.tx_size = TX_8X8; |
- else if (xd->mi[0].src_mi->mbmi.tx_size > TX_16X16) |
- xd->mi[0].src_mi->mbmi.tx_size = TX_16X16; |
+ cyclic_refresh_segment_id_boosted(xd->mi[0]->mbmi.segment_id)) |
+ xd->mi[0]->mbmi.tx_size = TX_8X8; |
+ else if (xd->mi[0]->mbmi.tx_size > TX_16X16) |
+ xd->mi[0]->mbmi.tx_size = TX_16X16; |
} |
} else { |
- xd->mi[0].src_mi->mbmi.tx_size = |
+ xd->mi[0]->mbmi.tx_size = |
MIN(max_txsize_lookup[bsize], |
tx_mode_to_biggest_tx_size[cpi->common.tx_mode]); |
} |
@@ -246,7 +494,7 @@ static void model_rd_for_sb_y(VP9_COMP *cpi, BLOCK_SIZE bsize, |
// Evaluate if the partition block is a skippable block in Y plane. |
{ |
const BLOCK_SIZE unit_size = |
- txsize_to_bsize[xd->mi[0].src_mi->mbmi.tx_size]; |
+ txsize_to_bsize[xd->mi[0]->mbmi.tx_size]; |
const unsigned int num_blk_log2 = |
(b_width_log2_lookup[bsize] - b_width_log2_lookup[unit_size]) + |
(b_height_log2_lookup[bsize] - b_height_log2_lookup[unit_size]); |
@@ -312,6 +560,132 @@ static void model_rd_for_sb_y(VP9_COMP *cpi, BLOCK_SIZE bsize, |
*out_dist_sum += dist << 4; |
} |
+#if CONFIG_VP9_HIGHBITDEPTH |
+static void block_yrd(VP9_COMP *cpi, MACROBLOCK *x, int *rate, int64_t *dist, |
+ int *skippable, int64_t *sse, int plane, |
+ BLOCK_SIZE bsize, TX_SIZE tx_size) { |
+ MACROBLOCKD *xd = &x->e_mbd; |
+ unsigned int var_y, sse_y; |
+ (void)plane; |
+ (void)tx_size; |
+ model_rd_for_sb_y(cpi, bsize, x, xd, rate, dist, &var_y, &sse_y); |
+ *sse = INT_MAX; |
+ *skippable = 0; |
+ return; |
+} |
+#else |
+static void block_yrd(VP9_COMP *cpi, MACROBLOCK *x, int *rate, int64_t *dist, |
+ int *skippable, int64_t *sse, int plane, |
+ BLOCK_SIZE bsize, TX_SIZE tx_size) { |
+ MACROBLOCKD *xd = &x->e_mbd; |
+ const struct macroblockd_plane *pd = &xd->plane[plane]; |
+ const struct macroblock_plane *const p = &x->plane[plane]; |
+ const int num_4x4_w = num_4x4_blocks_wide_lookup[bsize]; |
+ const int num_4x4_h = num_4x4_blocks_high_lookup[bsize]; |
+ const int step = 1 << (tx_size << 1); |
+ const int block_step = (1 << tx_size); |
+ int block = 0, r, c; |
+ int shift = tx_size == TX_32X32 ? 0 : 2; |
+ const int max_blocks_wide = num_4x4_w + (xd->mb_to_right_edge >= 0 ? 0 : |
+ xd->mb_to_right_edge >> (5 + pd->subsampling_x)); |
+ const int max_blocks_high = num_4x4_h + (xd->mb_to_bottom_edge >= 0 ? 0 : |
+ xd->mb_to_bottom_edge >> (5 + pd->subsampling_y)); |
+ int eob_cost = 0; |
+ |
+ (void)cpi; |
+ vp9_subtract_plane(x, bsize, plane); |
+ *skippable = 1; |
+ // Keep track of the row and column of the blocks we use so that we know |
+ // if we are in the unrestricted motion border. |
+ for (r = 0; r < max_blocks_high; r += block_step) { |
+ for (c = 0; c < num_4x4_w; c += block_step) { |
+ if (c < max_blocks_wide) { |
+ const scan_order *const scan_order = &vp9_default_scan_orders[tx_size]; |
+ tran_low_t *const coeff = BLOCK_OFFSET(p->coeff, block); |
+ tran_low_t *const qcoeff = BLOCK_OFFSET(p->qcoeff, block); |
+ tran_low_t *const dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block); |
+ uint16_t *const eob = &p->eobs[block]; |
+ const int diff_stride = 4 * num_4x4_blocks_wide_lookup[bsize]; |
+ const int16_t *src_diff; |
+ src_diff = &p->src_diff[(r * diff_stride + c) << 2]; |
+ |
+ switch (tx_size) { |
+ case TX_32X32: |
+ vp9_fdct32x32_rd(src_diff, coeff, diff_stride); |
+ vp9_quantize_fp_32x32(coeff, 1024, x->skip_block, p->zbin, |
+ p->round_fp, p->quant_fp, p->quant_shift, |
+ qcoeff, dqcoeff, pd->dequant, eob, |
+ scan_order->scan, scan_order->iscan); |
+ break; |
+ case TX_16X16: |
+ vp9_hadamard_16x16(src_diff, diff_stride, (int16_t *)coeff); |
+ vp9_quantize_fp(coeff, 256, x->skip_block, p->zbin, p->round_fp, |
+ p->quant_fp, p->quant_shift, qcoeff, dqcoeff, |
+ pd->dequant, eob, |
+ scan_order->scan, scan_order->iscan); |
+ break; |
+ case TX_8X8: |
+ vp9_hadamard_8x8(src_diff, diff_stride, (int16_t *)coeff); |
+ vp9_quantize_fp(coeff, 64, x->skip_block, p->zbin, p->round_fp, |
+ p->quant_fp, p->quant_shift, qcoeff, dqcoeff, |
+ pd->dequant, eob, |
+ scan_order->scan, scan_order->iscan); |
+ break; |
+ case TX_4X4: |
+ x->fwd_txm4x4(src_diff, coeff, diff_stride); |
+ vp9_quantize_fp(coeff, 16, x->skip_block, p->zbin, p->round_fp, |
+ p->quant_fp, p->quant_shift, qcoeff, dqcoeff, |
+ pd->dequant, eob, |
+ scan_order->scan, scan_order->iscan); |
+ break; |
+ default: |
+ assert(0); |
+ break; |
+ } |
+ *skippable &= (*eob == 0); |
+ eob_cost += 1; |
+ } |
+ block += step; |
+ } |
+ } |
+ |
+ if (*skippable && *sse < INT64_MAX) { |
+ *rate = 0; |
+ *dist = (*sse << 6) >> shift; |
+ *sse = *dist; |
+ return; |
+ } |
+ |
+ block = 0; |
+ *rate = 0; |
+ *dist = 0; |
+ *sse = (*sse << 6) >> shift; |
+ for (r = 0; r < max_blocks_high; r += block_step) { |
+ for (c = 0; c < num_4x4_w; c += block_step) { |
+ if (c < max_blocks_wide) { |
+ tran_low_t *const coeff = BLOCK_OFFSET(p->coeff, block); |
+ tran_low_t *const qcoeff = BLOCK_OFFSET(p->qcoeff, block); |
+ tran_low_t *const dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block); |
+ uint16_t *const eob = &p->eobs[block]; |
+ |
+ if (*eob == 1) |
+ *rate += (int)abs(qcoeff[0]); |
+ else if (*eob > 1) |
+ *rate += (int)vp9_satd((const int16_t *)qcoeff, step << 4); |
+ |
+ *dist += vp9_block_error_fp(coeff, dqcoeff, step << 4) >> shift; |
+ } |
+ block += step; |
+ } |
+ } |
+ |
+ if (*skippable == 0) { |
+ *rate <<= 10; |
+ *rate += (eob_cost << 8); |
+ } |
+} |
+#endif |
+ |
static void model_rd_for_sb_uv(VP9_COMP *cpi, BLOCK_SIZE bsize, |
MACROBLOCK *x, MACROBLOCKD *xd, |
int *out_rate_sum, int64_t *out_dist_sum, |
@@ -402,7 +776,7 @@ static void encode_breakout_test(VP9_COMP *cpi, MACROBLOCK *x, |
struct buf_2d yv12_mb[][MAX_MB_PLANE], |
int *rate, int64_t *dist) { |
MACROBLOCKD *xd = &x->e_mbd; |
- MB_MODE_INFO *mbmi = &xd->mi[0].src_mi->mbmi; |
+ MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi; |
const BLOCK_SIZE uv_size = get_plane_block_size(bsize, &xd->plane[1]); |
unsigned int var = var_y, sse = sse_y; |
@@ -518,7 +892,9 @@ static void estimate_block_intra(int plane, int block, BLOCK_SIZE plane_bsize, |
int i, j; |
int rate; |
int64_t dist; |
- unsigned int var_y, sse_y; |
+ int64_t this_sse = INT64_MAX; |
+ int is_skippable; |
+ |
txfrm_block_to_raster_xy(plane_bsize, tx_size, block, &i, &j); |
assert(plane == 0); |
(void) plane; |
@@ -533,8 +909,13 @@ static void estimate_block_intra(int plane, int block, BLOCK_SIZE plane_bsize, |
x->skip_encode ? src_stride : dst_stride, |
pd->dst.buf, dst_stride, |
i, j, 0); |
- // This procedure assumes zero offset from p->src.buf and pd->dst.buf. |
- model_rd_for_sb_y(cpi, bsize_tx, x, xd, &rate, &dist, &var_y, &sse_y); |
+ |
+ // TODO(jingning): This needs further refactoring. |
+ block_yrd(cpi, x, &rate, &dist, &is_skippable, &this_sse, 0, |
+ bsize_tx, MIN(tx_size, TX_16X16)); |
+ x->skip_txfm[0] = is_skippable; |
+ rate += vp9_cost_bit(vp9_get_skip_prob(&cpi->common, xd), is_skippable); |
+ |
p->src.buf = src_buf_base; |
pd->dst.buf = dst_buf_base; |
args->rate += rate; |
@@ -542,7 +923,7 @@ static void estimate_block_intra(int plane, int block, BLOCK_SIZE plane_bsize, |
} |
static const THR_MODES mode_idx[MAX_REF_FRAMES - 1][4] = { |
- {THR_DC, THR_H_PRED, THR_V_PRED, THR_TM}, |
+ {THR_DC, THR_V_PRED, THR_H_PRED, THR_TM}, |
{THR_NEARESTMV, THR_NEARMV, THR_ZEROMV, THR_NEWMV}, |
{THR_NEARESTG, THR_NEARG, THR_ZEROG, THR_NEWG}, |
}; |
@@ -551,20 +932,54 @@ static const PREDICTION_MODE intra_mode_list[] = { |
DC_PRED, V_PRED, H_PRED, TM_PRED |
}; |
+static int mode_offset(const PREDICTION_MODE mode) { |
+ if (mode >= NEARESTMV) { |
+ return INTER_OFFSET(mode); |
+ } else { |
+ switch (mode) { |
+ case DC_PRED: |
+ return 0; |
+ case V_PRED: |
+ return 1; |
+ case H_PRED: |
+ return 2; |
+ case TM_PRED: |
+ return 3; |
+ default: |
+ return -1; |
+ } |
+ } |
+} |
+ |
+static INLINE void update_thresh_freq_fact(VP9_COMP *cpi, |
+ TileDataEnc *tile_data, |
+ BLOCK_SIZE bsize, |
+ MV_REFERENCE_FRAME ref_frame, |
+ THR_MODES best_mode_idx, |
+ PREDICTION_MODE mode) { |
+ THR_MODES thr_mode_idx = mode_idx[ref_frame][mode_offset(mode)]; |
+ int *freq_fact = &tile_data->thresh_freq_fact[bsize][thr_mode_idx]; |
+ if (thr_mode_idx == best_mode_idx) |
+ *freq_fact -= (*freq_fact >> 4); |
+ else |
+ *freq_fact = MIN(*freq_fact + RD_THRESH_INC, |
+ cpi->sf.adaptive_rd_thresh * RD_THRESH_MAX_FACT); |
+} |
+ |
void vp9_pick_intra_mode(VP9_COMP *cpi, MACROBLOCK *x, RD_COST *rd_cost, |
BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx) { |
MACROBLOCKD *const xd = &x->e_mbd; |
- MB_MODE_INFO *const mbmi = &xd->mi[0].src_mi->mbmi; |
+ MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi; |
RD_COST this_rdc, best_rdc; |
PREDICTION_MODE this_mode; |
struct estimate_block_intra_args args = { cpi, x, DC_PRED, 0, 0 }; |
const TX_SIZE intra_tx_size = |
MIN(max_txsize_lookup[bsize], |
tx_mode_to_biggest_tx_size[cpi->common.tx_mode]); |
- MODE_INFO *const mic = xd->mi[0].src_mi; |
+ MODE_INFO *const mic = xd->mi[0]; |
int *bmode_costs; |
- const MODE_INFO *above_mi = xd->mi[-xd->mi_stride].src_mi; |
- const MODE_INFO *left_mi = xd->left_available ? xd->mi[-1].src_mi : NULL; |
+ const MODE_INFO *above_mi = xd->mi[-xd->mi_stride]; |
+ const MODE_INFO *left_mi = xd->left_available ? xd->mi[-1] : NULL; |
const PREDICTION_MODE A = vp9_above_block_mode(mic, above_mi, 0); |
const PREDICTION_MODE L = vp9_left_block_mode(mic, left_mi, 0); |
bmode_costs = cpi->y_mode_costs[A][L]; |
@@ -576,7 +991,7 @@ void vp9_pick_intra_mode(VP9_COMP *cpi, MACROBLOCK *x, RD_COST *rd_cost, |
mbmi->ref_frame[0] = INTRA_FRAME; |
mbmi->mv[0].as_int = INVALID_MV; |
mbmi->uv_mode = DC_PRED; |
- vpx_memset(x->skip_txfm, 0, sizeof(x->skip_txfm)); |
+ memset(x->skip_txfm, 0, sizeof(x->skip_txfm)); |
// Change the limit of this loop to add other intra prediction |
// mode tests. |
@@ -602,9 +1017,23 @@ void vp9_pick_intra_mode(VP9_COMP *cpi, MACROBLOCK *x, RD_COST *rd_cost, |
*rd_cost = best_rdc; |
} |
-static const int ref_frame_cost[MAX_REF_FRAMES] = { |
- 1235, 229, 530, 615, |
-}; |
+static void init_ref_frame_cost(VP9_COMMON *const cm, |
+ MACROBLOCKD *const xd, |
+ int ref_frame_cost[MAX_REF_FRAMES]) { |
+ vp9_prob intra_inter_p = vp9_get_intra_inter_prob(cm, xd); |
+ vp9_prob ref_single_p1 = vp9_get_pred_prob_single_ref_p1(cm, xd); |
+ vp9_prob ref_single_p2 = vp9_get_pred_prob_single_ref_p2(cm, xd); |
+ |
+ ref_frame_cost[INTRA_FRAME] = vp9_cost_bit(intra_inter_p, 0); |
+ ref_frame_cost[LAST_FRAME] = ref_frame_cost[GOLDEN_FRAME] = |
+ ref_frame_cost[ALTREF_FRAME] = vp9_cost_bit(intra_inter_p, 1); |
+ |
+ ref_frame_cost[LAST_FRAME] += vp9_cost_bit(ref_single_p1, 0); |
+ ref_frame_cost[GOLDEN_FRAME] += vp9_cost_bit(ref_single_p1, 1); |
+ ref_frame_cost[ALTREF_FRAME] += vp9_cost_bit(ref_single_p1, 1); |
+ ref_frame_cost[GOLDEN_FRAME] += vp9_cost_bit(ref_single_p2, 0); |
+ ref_frame_cost[ALTREF_FRAME] += vp9_cost_bit(ref_single_p2, 1); |
+} |
typedef struct { |
MV_REFERENCE_FRAME ref_frame; |
@@ -632,7 +1061,7 @@ void vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, |
VP9_COMMON *const cm = &cpi->common; |
TileInfo *const tile_info = &tile_data->tile_info; |
MACROBLOCKD *const xd = &x->e_mbd; |
- MB_MODE_INFO *const mbmi = &xd->mi[0].src_mi->mbmi; |
+ MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi; |
struct macroblockd_plane *const pd = &xd->plane[0]; |
PREDICTION_MODE best_mode = ZEROMV; |
MV_REFERENCE_FRAME ref_frame, best_ref_frame = LAST_FRAME; |
@@ -651,7 +1080,7 @@ void vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, |
// Reduce the intra cost penalty for small blocks (<=16x16). |
const int reduction_fac = |
(cpi->sf.partition_search_type == VAR_BASED_PARTITION && |
- bsize <= BLOCK_16X16) ? 2 : 0; |
+ bsize <= BLOCK_16X16) ? ((bsize <= BLOCK_8X8) ? 4 : 2) : 0; |
const int intra_cost_penalty = vp9_get_intra_cost_penalty( |
cm->base_qindex, cm->y_dc_delta_q, cm->bit_depth) >> reduction_fac; |
const int64_t inter_mode_thresh = RDCOST(x->rdmult, x->rddiv, |
@@ -670,9 +1099,9 @@ void vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, |
// process. |
// tmp[3] points to dst buffer, and the other 3 point to allocated buffers. |
PRED_BUFFER tmp[4]; |
- DECLARE_ALIGNED_ARRAY(16, uint8_t, pred_buf, 3 * 64 * 64); |
+ DECLARE_ALIGNED(16, uint8_t, pred_buf[3 * 64 * 64]); |
#if CONFIG_VP9_HIGHBITDEPTH |
- DECLARE_ALIGNED_ARRAY(16, uint16_t, pred_buf_16, 3 * 64 * 64); |
+ DECLARE_ALIGNED(16, uint16_t, pred_buf_16[3 * 64 * 64]); |
#endif |
struct buf_2d orig_dst = pd->dst; |
PRED_BUFFER *best_pred = NULL; |
@@ -682,6 +1111,10 @@ void vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, |
int ref_frame_skip_mask = 0; |
int idx; |
int best_pred_sad = INT_MAX; |
+ int best_early_term = 0; |
+ int ref_frame_cost[MAX_REF_FRAMES]; |
+ |
+ init_ref_frame_cost(cm, xd, ref_frame_cost); |
if (reuse_inter_pred) { |
int i; |
@@ -706,9 +1139,9 @@ void vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, |
x->skip = 0; |
if (xd->up_available) |
- filter_ref = xd->mi[-xd->mi_stride].src_mi->mbmi.interp_filter; |
+ filter_ref = xd->mi[-xd->mi_stride]->mbmi.interp_filter; |
else if (xd->left_available) |
- filter_ref = xd->mi[-1].src_mi->mbmi.interp_filter; |
+ filter_ref = xd->mi[-1]->mbmi.interp_filter; |
else |
filter_ref = cm->interp_filter; |
@@ -726,7 +1159,6 @@ void vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, |
#endif |
if (cpi->rc.frames_since_golden == 0) { |
- cpi->ref_frame_flags &= (~VP9_GOLD_FLAG); |
usable_ref_frame = LAST_FRAME; |
} else { |
usable_ref_frame = GOLDEN_FRAME; |
@@ -747,11 +1179,11 @@ void vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, |
sf, sf); |
if (cm->use_prev_frame_mvs) |
- vp9_find_mv_refs(cm, xd, tile_info, xd->mi[0].src_mi, ref_frame, |
+ vp9_find_mv_refs(cm, xd, tile_info, xd->mi[0], ref_frame, |
candidates, mi_row, mi_col, NULL, NULL); |
else |
const_motion[ref_frame] = mv_refs_rt(cm, xd, tile_info, |
- xd->mi[0].src_mi, |
+ xd->mi[0], |
ref_frame, candidates, |
mi_row, mi_col); |
@@ -773,6 +1205,10 @@ void vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, |
int mode_index; |
int i; |
PREDICTION_MODE this_mode = ref_mode_set[idx].pred_mode; |
+ int64_t this_sse; |
+ int is_skippable; |
+ int this_early_term = 0; |
+ |
if (!(cpi->sf.inter_mode_mask[bsize] & (1 << this_mode))) |
continue; |
@@ -850,6 +1286,7 @@ void vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, |
best_pred_sad = cpi->fn_ptr[bsize].sdf(x->plane[0].src.buf, |
x->plane[0].src.stride, |
pre_buf, pre_stride); |
+ x->pred_mv_sad[LAST_FRAME] = best_pred_sad; |
} |
if (this_mode != NEARESTMV && |
@@ -885,7 +1322,7 @@ void vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, |
INTERP_FILTER best_filter = SWITCHABLE, filter; |
PRED_BUFFER *current_pred = this_mode_pred; |
- for (filter = EIGHTTAP; filter <= EIGHTTAP_SHARP; ++filter) { |
+ for (filter = EIGHTTAP; filter <= EIGHTTAP_SMOOTH; ++filter) { |
int64_t cost; |
mbmi->interp_filter = filter; |
vp9_build_inter_predictors_sby(xd, mi_row, mi_col, bsize); |
@@ -924,17 +1361,55 @@ void vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, |
var_y = pf_var[best_filter]; |
sse_y = pf_sse[best_filter]; |
x->skip_txfm[0] = skip_txfm; |
+ if (reuse_inter_pred) { |
+ pd->dst.buf = this_mode_pred->data; |
+ pd->dst.stride = this_mode_pred->stride; |
+ } |
} else { |
mbmi->interp_filter = (filter_ref == SWITCHABLE) ? EIGHTTAP : filter_ref; |
vp9_build_inter_predictors_sby(xd, mi_row, mi_col, bsize); |
- model_rd_for_sb_y(cpi, bsize, x, xd, &this_rdc.rate, &this_rdc.dist, |
- &var_y, &sse_y); |
- this_rdc.rate += |
- cm->interp_filter == SWITCHABLE ? |
- vp9_get_switchable_rate(cpi, xd) : 0; |
+ |
+ // For large partition blocks, extra testing is done. |
+ if (bsize > BLOCK_32X32 && |
+ !cyclic_refresh_segment_id_boosted(xd->mi[0]->mbmi.segment_id) && |
+ cm->base_qindex) { |
+ model_rd_for_sb_y_large(cpi, bsize, x, xd, &this_rdc.rate, |
+ &this_rdc.dist, &var_y, &sse_y, mi_row, mi_col, |
+ &this_early_term); |
+ } else { |
+ model_rd_for_sb_y(cpi, bsize, x, xd, &this_rdc.rate, &this_rdc.dist, |
+ &var_y, &sse_y); |
+ } |
+ } |
+ |
+ if (!this_early_term) { |
+ this_sse = (int64_t)sse_y; |
+ block_yrd(cpi, x, &this_rdc.rate, &this_rdc.dist, &is_skippable, |
+ &this_sse, 0, bsize, MIN(mbmi->tx_size, TX_16X16)); |
+ x->skip_txfm[0] = is_skippable; |
+ if (is_skippable) { |
+ this_rdc.rate = vp9_cost_bit(vp9_get_skip_prob(cm, xd), 1); |
+ } else { |
+ if (RDCOST(x->rdmult, x->rddiv, this_rdc.rate, this_rdc.dist) < |
+ RDCOST(x->rdmult, x->rddiv, 0, this_sse)) { |
+ this_rdc.rate += vp9_cost_bit(vp9_get_skip_prob(cm, xd), 0); |
+ } else { |
+ this_rdc.rate = vp9_cost_bit(vp9_get_skip_prob(cm, xd), 1); |
+ this_rdc.dist = this_sse; |
+ x->skip_txfm[0] = 1; |
+ } |
+ } |
+ |
+ if (cm->interp_filter == SWITCHABLE) { |
+ if ((mbmi->mv[0].as_mv.row | mbmi->mv[0].as_mv.col) & 0x07) |
+ this_rdc.rate += vp9_get_switchable_rate(cpi, xd); |
+ } |
+ } else { |
+ this_rdc.rate += cm->interp_filter == SWITCHABLE ? |
+ vp9_get_switchable_rate(cpi, xd) : 0; |
+ this_rdc.rate += vp9_cost_bit(vp9_get_skip_prob(cm, xd), 1); |
} |
- // chroma component rate-distortion cost modeling |
if (x->color_sensitivity[0] || x->color_sensitivity[1]) { |
int uv_rate = 0; |
int64_t uv_dist = 0; |
@@ -942,7 +1417,8 @@ void vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, |
vp9_build_inter_predictors_sbp(xd, mi_row, mi_col, bsize, 1); |
if (x->color_sensitivity[1]) |
vp9_build_inter_predictors_sbp(xd, mi_row, mi_col, bsize, 2); |
- model_rd_for_sb_uv(cpi, bsize, x, xd, &uv_rate, &uv_dist, &var_y, &sse_y); |
+ model_rd_for_sb_uv(cpi, bsize, x, xd, &uv_rate, &uv_dist, |
+ &var_y, &sse_y); |
this_rdc.rate += uv_rate; |
this_rdc.dist += uv_dist; |
} |
@@ -981,6 +1457,7 @@ void vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, |
best_tx_size = mbmi->tx_size; |
best_ref_frame = ref_frame; |
best_mode_skip_txfm = x->skip_txfm[0]; |
+ best_early_term = this_early_term; |
if (reuse_inter_pred) { |
free_pred_buffer(best_pred); |
@@ -993,6 +1470,13 @@ void vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, |
if (x->skip) |
break; |
+ |
+ // If early termination flag is 1 and at least 2 modes are checked, |
+ // the mode search is terminated. |
+ if (best_early_term && idx > 0) { |
+ x->skip = 1; |
+ break; |
+ } |
} |
mbmi->mode = best_mode; |
@@ -1000,7 +1484,7 @@ void vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, |
mbmi->tx_size = best_tx_size; |
mbmi->ref_frame[0] = best_ref_frame; |
mbmi->mv[0].as_int = frame_mv[best_mode][best_ref_frame].as_int; |
- xd->mi[0].src_mi->bmi[0].as_mv[0].as_int = mbmi->mv[0].as_int; |
+ xd->mi[0]->bmi[0].as_mv[0].as_int = mbmi->mv[0].as_int; |
x->skip_txfm[0] = best_mode_skip_txfm; |
// Perform intra prediction search, if the best SAD is above a certain |
@@ -1039,8 +1523,18 @@ void vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, |
for (i = 0; i < 4; ++i) { |
const PREDICTION_MODE this_mode = intra_mode_list[i]; |
- if (!((1 << this_mode) & cpi->sf.intra_y_mode_mask[intra_tx_size])) |
+ THR_MODES mode_index = mode_idx[INTRA_FRAME][mode_offset(this_mode)]; |
+ int mode_rd_thresh = rd_threshes[mode_index]; |
+ |
+ if (!((1 << this_mode) & cpi->sf.intra_y_mode_bsize_mask[bsize])) |
+ continue; |
+ |
+ if (rd_less_than_thresh(best_rdc.rdcost, mode_rd_thresh, |
+ rd_thresh_freq_fact[mode_index])) |
continue; |
+ |
+ mbmi->mode = this_mode; |
+ mbmi->ref_frame[0] = INTRA_FRAME; |
args.mode = this_mode; |
args.rate = 0; |
args.dist = 0; |
@@ -1057,17 +1551,17 @@ void vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, |
if (this_rdc.rdcost < best_rdc.rdcost) { |
best_rdc = this_rdc; |
- mbmi->mode = this_mode; |
+ best_mode = this_mode; |
best_intra_tx_size = mbmi->tx_size; |
- mbmi->ref_frame[0] = INTRA_FRAME; |
+ best_ref_frame = INTRA_FRAME; |
mbmi->uv_mode = this_mode; |
mbmi->mv[0].as_int = INVALID_MV; |
+ best_mode_skip_txfm = x->skip_txfm[0]; |
} |
} |
// Reset mb_mode_info to the best inter mode. |
- if (mbmi->ref_frame[0] != INTRA_FRAME) { |
- x->skip_txfm[0] = best_mode_skip_txfm; |
+ if (best_ref_frame != INTRA_FRAME) { |
mbmi->tx_size = best_tx_size; |
} else { |
mbmi->tx_size = best_intra_tx_size; |
@@ -1075,6 +1569,9 @@ void vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, |
} |
pd->dst = orig_dst; |
+ mbmi->mode = best_mode; |
+ mbmi->ref_frame[0] = best_ref_frame; |
+ x->skip_txfm[0] = best_mode_skip_txfm; |
if (reuse_inter_pred && best_pred != NULL) { |
if (best_pred->data != orig_dst.buf && is_inter_mode(mbmi->mode)) { |
@@ -1096,20 +1593,28 @@ void vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, |
} |
if (cpi->sf.adaptive_rd_thresh) { |
- THR_MODES best_mode_idx = is_inter_block(mbmi) ? |
- mode_idx[best_ref_frame][INTER_OFFSET(mbmi->mode)] : |
- mode_idx[INTRA_FRAME][mbmi->mode]; |
+ THR_MODES best_mode_idx = mode_idx[best_ref_frame][mode_offset(mbmi->mode)]; |
PREDICTION_MODE this_mode; |
- for (ref_frame = LAST_FRAME; ref_frame <= GOLDEN_FRAME; ++ref_frame) { |
- if (best_ref_frame != ref_frame) continue; |
- for (this_mode = NEARESTMV; this_mode <= NEWMV; ++this_mode) { |
- THR_MODES thr_mode_idx = mode_idx[ref_frame][INTER_OFFSET(this_mode)]; |
- int *freq_fact = &tile_data->thresh_freq_fact[bsize][thr_mode_idx]; |
- if (thr_mode_idx == best_mode_idx) |
- *freq_fact -= (*freq_fact >> 4); |
- else |
- *freq_fact = MIN(*freq_fact + RD_THRESH_INC, |
- cpi->sf.adaptive_rd_thresh * RD_THRESH_MAX_FACT); |
+ |
+ if (best_ref_frame == INTRA_FRAME) { |
+ // Only consider the modes that are included in the intra_mode_list. |
+ int intra_modes = sizeof(intra_mode_list)/sizeof(PREDICTION_MODE); |
+ int i; |
+ |
+ // TODO(yunqingwang): Check intra mode mask and only update freq_fact |
+ // for those valid modes. |
+ for (i = 0; i < intra_modes; i++) { |
+ PREDICTION_MODE this_mode = intra_mode_list[i]; |
+ update_thresh_freq_fact(cpi, tile_data, bsize, INTRA_FRAME, |
+ best_mode_idx, this_mode); |
+ } |
+ } else { |
+ for (ref_frame = LAST_FRAME; ref_frame <= GOLDEN_FRAME; ++ref_frame) { |
+ if (best_ref_frame != ref_frame) continue; |
+ for (this_mode = NEARESTMV; this_mode <= NEWMV; ++this_mode) { |
+ update_thresh_freq_fact(cpi, tile_data, bsize, ref_frame, |
+ best_mode_idx, this_mode); |
+ } |
} |
} |
} |
@@ -1125,7 +1630,7 @@ void vp9_pick_inter_mode_sub8x8(VP9_COMP *cpi, MACROBLOCK *x, |
TileInfo *const tile_info = &tile_data->tile_info; |
SPEED_FEATURES *const sf = &cpi->sf; |
MACROBLOCKD *const xd = &x->e_mbd; |
- MB_MODE_INFO *const mbmi = &xd->mi[0].src_mi->mbmi; |
+ MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi; |
const struct segmentation *const seg = &cm->seg; |
MV_REFERENCE_FRAME ref_frame, second_ref_frame = NONE; |
MV_REFERENCE_FRAME best_ref_frame = NONE; |
@@ -1154,7 +1659,7 @@ void vp9_pick_inter_mode_sub8x8(VP9_COMP *cpi, MACROBLOCK *x, |
&cm->frame_refs[ref_frame - 1].sf; |
vp9_setup_pred_block(xd, yv12_mb[ref_frame], yv12, mi_row, mi_col, |
sf, sf); |
- vp9_find_mv_refs(cm, xd, tile_info, xd->mi[0].src_mi, ref_frame, |
+ vp9_find_mv_refs(cm, xd, tile_info, xd->mi[0], ref_frame, |
candidates, mi_row, mi_col, NULL, NULL); |
vp9_find_best_ref_mvs(xd, cm->allow_high_precision_mv, candidates, |
@@ -1214,7 +1719,7 @@ void vp9_pick_inter_mode_sub8x8(VP9_COMP *cpi, MACROBLOCK *x, |
const struct buf_2d orig_src = p->src; |
const struct buf_2d orig_dst = pd->dst; |
struct buf_2d orig_pre[2]; |
- vpx_memcpy(orig_pre, xd->plane[0].pre, sizeof(orig_pre)); |
+ memcpy(orig_pre, xd->plane[0].pre, sizeof(orig_pre)); |
// set buffer pointers for sub8x8 motion search. |
p->src.buf = |
@@ -1233,7 +1738,7 @@ void vp9_pick_inter_mode_sub8x8(VP9_COMP *cpi, MACROBLOCK *x, |
for (this_mode = NEARESTMV; this_mode <= NEWMV; ++this_mode) { |
int b_rate = 0; |
- xd->mi[0].bmi[i].as_mv[0].as_int = b_mv[this_mode].as_int; |
+ xd->mi[0]->bmi[i].as_mv[0].as_int = b_mv[this_mode].as_int; |
if (this_mode == NEWMV) { |
const int step_param = cpi->sf.mv.fullpel_search_step_param; |
@@ -1250,8 +1755,8 @@ void vp9_pick_inter_mode_sub8x8(VP9_COMP *cpi, MACROBLOCK *x, |
mvp_full.row = b_mv[NEARESTMV].as_mv.row >> 3; |
mvp_full.col = b_mv[NEARESTMV].as_mv.col >> 3; |
} else { |
- mvp_full.row = xd->mi[0].bmi[0].as_mv[0].as_mv.row >> 3; |
- mvp_full.col = xd->mi[0].bmi[0].as_mv[0].as_mv.col >> 3; |
+ mvp_full.row = xd->mi[0]->bmi[0].as_mv[0].as_mv.row >> 3; |
+ mvp_full.col = xd->mi[0]->bmi[0].as_mv[0].as_mv.col >> 3; |
} |
vp9_set_mv_search_range(x, &mbmi->ref_mvs[0]->as_mv); |
@@ -1293,7 +1798,7 @@ void vp9_pick_inter_mode_sub8x8(VP9_COMP *cpi, MACROBLOCK *x, |
&dummy_dist, |
&x->pred_sse[ref_frame], NULL, 0, 0); |
- xd->mi[0].bmi[i].as_mv[0].as_mv = tmp_mv; |
+ xd->mi[0]->bmi[i].as_mv[0].as_mv = tmp_mv; |
} else { |
b_rate += cpi->inter_mode_cost[mbmi->mode_context[ref_frame]] |
[INTER_OFFSET(this_mode)]; |
@@ -1303,7 +1808,7 @@ void vp9_pick_inter_mode_sub8x8(VP9_COMP *cpi, MACROBLOCK *x, |
if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) { |
vp9_highbd_build_inter_predictor(pd->pre[0].buf, pd->pre[0].stride, |
pd->dst.buf, pd->dst.stride, |
- &xd->mi[0].bmi[i].as_mv[0].as_mv, |
+ &xd->mi[0]->bmi[i].as_mv[0].as_mv, |
&xd->block_refs[0]->sf, |
4 * num_4x4_blocks_wide, |
4 * num_4x4_blocks_high, 0, |
@@ -1315,7 +1820,7 @@ void vp9_pick_inter_mode_sub8x8(VP9_COMP *cpi, MACROBLOCK *x, |
#endif |
vp9_build_inter_predictor(pd->pre[0].buf, pd->pre[0].stride, |
pd->dst.buf, pd->dst.stride, |
- &xd->mi[0].bmi[i].as_mv[0].as_mv, |
+ &xd->mi[0]->bmi[i].as_mv[0].as_mv, |
&xd->block_refs[0]->sf, |
4 * num_4x4_blocks_wide, |
4 * num_4x4_blocks_high, 0, |
@@ -1337,7 +1842,7 @@ void vp9_pick_inter_mode_sub8x8(VP9_COMP *cpi, MACROBLOCK *x, |
if (this_rdc.rdcost < b_best_rd) { |
b_best_rd = this_rdc.rdcost; |
bsi[ref_frame][i].as_mode = this_mode; |
- bsi[ref_frame][i].as_mv[0].as_mv = xd->mi[0].bmi[i].as_mv[0].as_mv; |
+ bsi[ref_frame][i].as_mv[0].as_mv = xd->mi[0]->bmi[i].as_mv[0].as_mv; |
} |
} // mode search |
@@ -1347,11 +1852,11 @@ void vp9_pick_inter_mode_sub8x8(VP9_COMP *cpi, MACROBLOCK *x, |
pd->dst = orig_dst; |
this_rd += b_best_rd; |
- xd->mi[0].bmi[i] = bsi[ref_frame][i]; |
+ xd->mi[0]->bmi[i] = bsi[ref_frame][i]; |
if (num_4x4_blocks_wide > 1) |
- xd->mi[0].bmi[i + 1] = xd->mi[0].bmi[i]; |
+ xd->mi[0]->bmi[i + 1] = xd->mi[0]->bmi[i]; |
if (num_4x4_blocks_high > 1) |
- xd->mi[0].bmi[i + 2] = xd->mi[0].bmi[i]; |
+ xd->mi[0]->bmi[i + 2] = xd->mi[0]->bmi[i]; |
} |
} // loop through sub8x8 blocks |
@@ -1366,15 +1871,15 @@ void vp9_pick_inter_mode_sub8x8(VP9_COMP *cpi, MACROBLOCK *x, |
for (idy = 0; idy < 2; idy += num_4x4_blocks_high) { |
for (idx = 0; idx < 2; idx += num_4x4_blocks_wide) { |
const int block = idy * 2 + idx; |
- xd->mi[0].bmi[block] = bsi[best_ref_frame][block]; |
+ xd->mi[0]->bmi[block] = bsi[best_ref_frame][block]; |
if (num_4x4_blocks_wide > 1) |
- xd->mi[0].bmi[block + 1] = bsi[best_ref_frame][block]; |
+ xd->mi[0]->bmi[block + 1] = bsi[best_ref_frame][block]; |
if (num_4x4_blocks_high > 1) |
- xd->mi[0].bmi[block + 2] = bsi[best_ref_frame][block]; |
+ xd->mi[0]->bmi[block + 2] = bsi[best_ref_frame][block]; |
} |
} |
- mbmi->mode = xd->mi[0].bmi[3].as_mode; |
- ctx->mic = *(xd->mi[0].src_mi); |
+ mbmi->mode = xd->mi[0]->bmi[3].as_mode; |
+ ctx->mic = *(xd->mi[0]); |
ctx->skip_txfm[0] = 0; |
ctx->skip = 0; |
// Dummy assignment for speed -5. No effect in speed -6. |