diff options
author | Ronald S. Bultje <rbultje@google.com> | 2013-06-06 13:44:34 -0700 |
---|---|---|
committer | Ronald S. Bultje <rbultje@google.com> | 2013-06-06 17:28:09 -0700 |
commit | 6ef805eb9d084eec2ca52ff5740cbd30972fbf78 (patch) | |
tree | d56e75726f4c33853b541a03132954f4e31ece5e /vp9/encoder | |
parent | 9062b92b0fb9e49fbe22ad844abdfaf9f86530dd (diff) | |
download | libvpx-6ef805eb9d084eec2ca52ff5740cbd30972fbf78.tar libvpx-6ef805eb9d084eec2ca52ff5740cbd30972fbf78.tar.gz libvpx-6ef805eb9d084eec2ca52ff5740cbd30972fbf78.tar.bz2 libvpx-6ef805eb9d084eec2ca52ff5740cbd30972fbf78.zip |
Change ref frame coding.
Code intra/inter, then comp/single, then the ref frame selection.
Use contextualization for all steps. Don't code two past frames
in comp pred mode.
Change-Id: I4639a78cd5cccb283023265dbcc07898c3e7cf95
Diffstat (limited to 'vp9/encoder')
-rw-r--r-- | vp9/encoder/vp9_bitstream.c | 236 | ||||
-rw-r--r-- | vp9/encoder/vp9_encodeframe.c | 136 | ||||
-rw-r--r-- | vp9/encoder/vp9_encodeintra.c | 2 | ||||
-rw-r--r-- | vp9/encoder/vp9_encodemb.c | 6 | ||||
-rw-r--r-- | vp9/encoder/vp9_encodemv.c | 4 | ||||
-rw-r--r-- | vp9/encoder/vp9_firstpass.c | 5 | ||||
-rw-r--r-- | vp9/encoder/vp9_onyx_if.c | 52 | ||||
-rw-r--r-- | vp9/encoder/vp9_onyx_int.h | 27 | ||||
-rw-r--r-- | vp9/encoder/vp9_ratectrl.c | 16 | ||||
-rw-r--r-- | vp9/encoder/vp9_rdopt.c | 425 | ||||
-rw-r--r-- | vp9/encoder/vp9_tokenize.c | 2 |
11 files changed, 345 insertions, 566 deletions
diff --git a/vp9/encoder/vp9_bitstream.c b/vp9/encoder/vp9_bitstream.c index 62b8547f1..844a1c1bd 100644 --- a/vp9/encoder/vp9_bitstream.c +++ b/vp9/encoder/vp9_bitstream.c @@ -343,41 +343,6 @@ void vp9_update_skip_probs(VP9_COMP *cpi) { cpi->skip_true_count[k]); } -// This function updates the reference frame prediction stats -static void update_refpred_stats(VP9_COMP *cpi) { - VP9_COMMON *const cm = &cpi->common; - int i; - vp9_prob new_pred_probs[PREDICTION_PROBS]; - int old_cost, new_cost; - - // Set the prediction probability structures to defaults - if (cm->frame_type != KEY_FRAME) { - // From the prediction counts set the probabilities for each context - for (i = 0; i < PREDICTION_PROBS; i++) { - const int c0 = cpi->ref_pred_count[i][0]; - const int c1 = cpi->ref_pred_count[i][1]; - - new_pred_probs[i] = get_binary_prob(c0, c1); - - // Decide whether or not to update the reference frame probs. - // Returned costs are in 1/256 bit units. - old_cost = c0 * vp9_cost_zero(cm->ref_pred_probs[i]) + - c1 * vp9_cost_one(cm->ref_pred_probs[i]); - - new_cost = c0 * vp9_cost_zero(new_pred_probs[i]) + - c1 * vp9_cost_one(new_pred_probs[i]); - - // Cost saving must be >= 8 bits (2048 in these units) - if ((old_cost - new_cost) >= 2048) { - cpi->ref_pred_probs_update[i] = 1; - cm->ref_pred_probs[i] = new_pred_probs[i]; - } else { - cpi->ref_pred_probs_update[i] = 0; - } - } - } -} - static void write_intra_mode(vp9_writer *bc, int m, const vp9_prob *p) { write_token(bc, vp9_intra_mode_tree, p, vp9_intra_mode_encodings + m); } @@ -510,16 +475,15 @@ static void write_mb_segid(vp9_writer *bc, } // This function encodes the reference frame -static void encode_ref_frame(vp9_writer *const bc, - VP9_COMMON *const cm, - MACROBLOCKD *xd, - int segment_id, - MV_REFERENCE_FRAME rf) { - int seg_ref_active; +static void encode_ref_frame(VP9_COMP *cpi, vp9_writer *bc) { + VP9_COMMON *const pc = &cpi->common; + MACROBLOCK *const x = &cpi->mb; + MACROBLOCKD *const xd = &x->e_mbd; + MB_MODE_INFO *mi = &xd->mode_info_context->mbmi; + const int segment_id = mi->segment_id; + int seg_ref_active = vp9_segfeature_active(xd, segment_id, + SEG_LVL_REF_FRAME); int seg_ref_count = 0; - seg_ref_active = vp9_segfeature_active(xd, - segment_id, - SEG_LVL_REF_FRAME); if (seg_ref_active) { seg_ref_count = vp9_check_segref(xd, segment_id, INTRA_FRAME) + @@ -531,84 +495,35 @@ static void encode_ref_frame(vp9_writer *const bc, // If segment level coding of this signal is disabled... // or the segment allows multiple reference frame options if (!seg_ref_active || (seg_ref_count > 1)) { - // Values used in prediction model coding - unsigned char prediction_flag; - vp9_prob pred_prob; - MV_REFERENCE_FRAME pred_rf; - - // Get the context probability the prediction flag - pred_prob = vp9_get_pred_prob(cm, xd, PRED_REF); - - // Get the predicted value. - pred_rf = vp9_get_pred_ref(cm, xd); - - // Did the chosen reference frame match its predicted value. - prediction_flag = - (xd->mode_info_context->mbmi.ref_frame == pred_rf); - - vp9_set_pred_flag(xd, PRED_REF, prediction_flag); - vp9_write(bc, prediction_flag, pred_prob); - - // If not predicted correctly then code value explicitly - if (!prediction_flag) { - vp9_prob mod_refprobs[PREDICTION_PROBS]; - - vpx_memcpy(mod_refprobs, - cm->mod_refprobs[pred_rf], sizeof(mod_refprobs)); - - // If segment coding enabled blank out options that cant occur by - // setting the branch probability to 0. - if (seg_ref_active) { - mod_refprobs[INTRA_FRAME] *= - vp9_check_segref(xd, segment_id, INTRA_FRAME); - mod_refprobs[LAST_FRAME] *= - vp9_check_segref(xd, segment_id, LAST_FRAME); - mod_refprobs[GOLDEN_FRAME] *= - (vp9_check_segref(xd, segment_id, GOLDEN_FRAME) * - vp9_check_segref(xd, segment_id, ALTREF_FRAME)); - } - - if (mod_refprobs[0]) { - vp9_write(bc, (rf != INTRA_FRAME), mod_refprobs[0]); - } - - // Inter coded - if (rf != INTRA_FRAME) { - if (mod_refprobs[1]) { - vp9_write(bc, (rf != LAST_FRAME), mod_refprobs[1]); - } + // does the feature use compound prediction or not + // (if not specified at the frame/segment level) + if (pc->comp_pred_mode == HYBRID_PREDICTION) { + vp9_write(bc, mi->ref_frame[1] > INTRA_FRAME, + vp9_get_pred_prob(pc, xd, PRED_COMP_INTER_INTER)); + } else { + assert((mi->ref_frame[1] <= INTRA_FRAME) == + (pc->comp_pred_mode == SINGLE_PREDICTION_ONLY)); + } - if (rf != LAST_FRAME) { - if (mod_refprobs[2]) { - vp9_write(bc, (rf != GOLDEN_FRAME), mod_refprobs[2]); - } - } - } + if (mi->ref_frame[1] > INTRA_FRAME) { + vp9_write(bc, mi->ref_frame[0] == GOLDEN_FRAME, + vp9_get_pred_prob(pc, xd, PRED_COMP_REF_P)); + } else { + vp9_write(bc, mi->ref_frame[0] != LAST_FRAME, + vp9_get_pred_prob(pc, xd, PRED_SINGLE_REF_P1)); + if (mi->ref_frame[0] != LAST_FRAME) + vp9_write(bc, mi->ref_frame[0] != GOLDEN_FRAME, + vp9_get_pred_prob(pc, xd, PRED_SINGLE_REF_P2)); } + } else { + assert(mi->ref_frame[1] <= INTRA_FRAME); + assert(vp9_check_segref(xd, segment_id, mi->ref_frame[0])); } // if using the prediction mdoel we have nothing further to do because // the reference frame is fully coded by the segment } -// Update the probabilities used to encode reference frame data -static void update_ref_probs(VP9_COMP *const cpi) { - VP9_COMMON *const cm = &cpi->common; - - const int *const rfct = cpi->count_mb_ref_frame_usage; - const int rf_intra = rfct[INTRA_FRAME]; - const int rf_inter = rfct[LAST_FRAME] + - rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME]; - - cm->prob_intra_coded = get_binary_prob(rf_intra, rf_inter); - cm->prob_last_coded = get_prob(rfct[LAST_FRAME], rf_inter); - cm->prob_gf_coded = get_binary_prob(rfct[GOLDEN_FRAME], rfct[ALTREF_FRAME]); - - // Compute a modified set of probabilities to use when prediction of the - // reference frame fails - vp9_compute_mod_refprobs(cm); -} - static void pack_inter_mode_mvs(VP9_COMP *cpi, MODE_INFO *m, vp9_writer *bc, int mi_row, int mi_col) { VP9_COMMON *const pc = &cpi->common; @@ -616,7 +531,7 @@ static void pack_inter_mode_mvs(VP9_COMP *cpi, MODE_INFO *m, MACROBLOCK *const x = &cpi->mb; MACROBLOCKD *const xd = &x->e_mbd; MB_MODE_INFO *const mi = &m->mbmi; - const MV_REFERENCE_FRAME rf = mi->ref_frame; + const MV_REFERENCE_FRAME rf = mi->ref_frame[0]; const MB_PREDICTION_MODE mode = mi->mode; const int segment_id = mi->segment_id; int skip_coeff; @@ -654,8 +569,7 @@ static void pack_inter_mode_mvs(VP9_COMP *cpi, MODE_INFO *m, vp9_get_pred_prob(pc, xd, PRED_MBSKIP)); } - // Encode the reference frame. - encode_ref_frame(bc, pc, xd, segment_id, rf); + vp9_write(bc, rf != INTRA_FRAME, vp9_get_pred_prob(pc, xd, PRED_INTRA_INTER)); if (mi->sb_type >= BLOCK_SIZE_SB8X8 && pc->txfm_mode == TX_MODE_SELECT && !(rf != INTRA_FRAME && @@ -695,6 +609,8 @@ static void pack_inter_mode_mvs(VP9_COMP *cpi, MODE_INFO *m, } else { vp9_prob mv_ref_p[VP9_INTER_MODES - 1]; + encode_ref_frame(cpi, bc); + vp9_mv_ref_probs(&cpi->common, mv_ref_p, mi->mb_mode_context[rf]); #ifdef ENTROPY_STATS @@ -719,13 +635,6 @@ static void pack_inter_mode_mvs(VP9_COMP *cpi, MODE_INFO *m, assert(mi->interp_filter == cpi->common.mcomp_filter_type); } - // does the feature use compound prediction or not - // (if not specified at the frame/segment level) - if (cpi->common.comp_pred_mode == HYBRID_PREDICTION) { - vp9_write(bc, mi->second_ref_frame > INTRA_FRAME, - vp9_get_pred_prob(pc, xd, PRED_COMP)); - } - if (xd->mode_info_context->mbmi.sb_type < BLOCK_SIZE_SB8X8) { int j; MB_PREDICTION_MODE blockmode; @@ -747,7 +656,7 @@ static void pack_inter_mode_mvs(VP9_COMP *cpi, MODE_INFO *m, vp9_encode_mv(bc, &blockmv.as_mv, &mi->best_mv.as_mv, nmvc, xd->allow_high_precision_mv); - if (mi->second_ref_frame > 0) + if (mi->ref_frame[1] > INTRA_FRAME) vp9_encode_mv(bc, &cpi->mb.partition_info->bmi[j].second_mv.as_mv, &mi->best_second_mv.as_mv, @@ -767,7 +676,7 @@ static void pack_inter_mode_mvs(VP9_COMP *cpi, MODE_INFO *m, &mi->mv[0].as_mv, &mi->best_mv.as_mv, nmvc, xd->allow_high_precision_mv); - if (mi->second_ref_frame > 0) + if (mi->ref_frame[1] > INTRA_FRAME) vp9_encode_mv(bc, &mi->mv[1].as_mv, &mi->best_second_mv.as_mv, nmvc, xd->allow_high_precision_mv); @@ -1175,25 +1084,6 @@ static void update_coef_probs(VP9_COMP* const cpi, vp9_writer* const bc) { update_coef_probs_common(bc, cpi, TX_32X32); } -static void segment_reference_frames(VP9_COMP *cpi) { - VP9_COMMON *oci = &cpi->common; - MODE_INFO *mi = oci->mi; - int ref[MAX_MB_SEGMENTS] = {0}; - int i, j; - int mb_index = 0; - MACROBLOCKD *const xd = &cpi->mb.e_mbd; - - for (i = 0; i < oci->mb_rows; i++) { - for (j = 0; j < oci->mb_cols; j++, mb_index++) - ref[mi[mb_index].mbmi.segment_id] |= (1 << mi[mb_index].mbmi.ref_frame); - mb_index++; - } - for (i = 0; i < MAX_MB_SEGMENTS; i++) { - vp9_enable_segfeature(xd, i, SEG_LVL_REF_FRAME); - vp9_set_segdata(xd, i, SEG_LVL_REF_FRAME, ref[i]); - } -} - static void encode_loopfilter(VP9_COMMON *pc, MACROBLOCKD *xd, struct vp9_write_bit_buffer *wb) { int i; @@ -1303,7 +1193,6 @@ static void encode_segmentation(VP9_COMP *cpi, // Segmentation data vp9_wb_write_bit(wb, xd->update_mb_segmentation_data); - // segment_reference_frames(cpi); if (xd->update_mb_segmentation_data) { vp9_wb_write_bit(wb, xd->mb_segment_abs_delta); @@ -1502,16 +1391,6 @@ void write_uncompressed_header(VP9_COMP *cpi, for (i = 0; i < ALLOWED_REFS_PER_FRAME; ++i) vp9_wb_write_bit(wb, cm->ref_frame_sign_bias[LAST_FRAME + i]); - // Encode the common prediction model status flag probability updates for - // the reference frame - update_refpred_stats(cpi); - for (i = 0; i < PREDICTION_PROBS; i++) { - const int update = cpi->ref_pred_probs_update[i]; - vp9_wb_write_bit(wb, update); - if (update) - vp9_wb_write_literal(wb, cm->ref_pred_probs[i], 8); - } - // Signal whether to allow high MV precision vp9_wb_write_bit(wb, xd->allow_high_precision_mv); @@ -1576,6 +1455,11 @@ void vp9_pack_bitstream(VP9_COMP *cpi, uint8_t *dest, unsigned long *size) { pc->fc.pre_nmvc = pc->fc.nmvc; vp9_copy(pc->fc.pre_switchable_interp_prob, pc->fc.switchable_interp_prob); vp9_copy(pc->fc.pre_inter_mode_probs, pc->fc.inter_mode_probs); + vp9_copy(pc->fc.pre_intra_inter_prob, pc->fc.intra_inter_prob); + vp9_copy(pc->fc.pre_comp_inter_prob, pc->fc.comp_inter_prob); + vp9_copy(pc->fc.pre_comp_ref_prob, pc->fc.comp_ref_prob); + vp9_copy(pc->fc.pre_single_ref_prob, pc->fc.single_ref_prob); + cpi->common.fc.pre_nmvc = cpi->common.fc.nmvc; update_coef_probs(cpi, &header_bc); @@ -1588,7 +1472,6 @@ void vp9_pack_bitstream(VP9_COMP *cpi, uint8_t *dest, unsigned long *size) { vp9_write_prob(&header_bc, pc->mbskip_pred_probs[i]); if (pc->frame_type != KEY_FRAME) { - #ifdef ENTROPY_STATS active_section = 1; #endif @@ -1599,14 +1482,11 @@ void vp9_pack_bitstream(VP9_COMP *cpi, uint8_t *dest, unsigned long *size) { if (pc->mcomp_filter_type == SWITCHABLE) update_switchable_interp_probs(pc, &header_bc); - // Update the probabilities used to encode reference frame data - update_ref_probs(cpi); - - vp9_write_prob(&header_bc, pc->prob_intra_coded); - vp9_write_prob(&header_bc, pc->prob_last_coded); - vp9_write_prob(&header_bc, pc->prob_gf_coded); + for (i = 0; i < INTRA_INTER_CONTEXTS; i++) + vp9_cond_prob_diff_update(&header_bc, &pc->fc.intra_inter_prob[i], + VP9_DEF_UPDATE_PROB, cpi->intra_inter_count[i]); - { + if (pc->allow_comp_inter_inter) { const int comp_pred_mode = cpi->common.comp_pred_mode; const int use_compound_pred = (comp_pred_mode != SINGLE_PREDICTION_ONLY); const int use_hybrid_pred = (comp_pred_mode == HYBRID_PREDICTION); @@ -1615,14 +1495,32 @@ void vp9_pack_bitstream(VP9_COMP *cpi, uint8_t *dest, unsigned long *size) { if (use_compound_pred) { vp9_write_bit(&header_bc, use_hybrid_pred); if (use_hybrid_pred) { - for (i = 0; i < COMP_PRED_CONTEXTS; i++) { - pc->prob_comppred[i] = get_binary_prob(cpi->single_pred_count[i], - cpi->comp_pred_count[i]); - vp9_write_prob(&header_bc, pc->prob_comppred[i]); - } + for (i = 0; i < COMP_INTER_CONTEXTS; i++) + vp9_cond_prob_diff_update(&header_bc, &pc->fc.comp_inter_prob[i], + VP9_DEF_UPDATE_PROB, + cpi->comp_inter_count[i]); } } } + + if (pc->comp_pred_mode != COMP_PREDICTION_ONLY) { + for (i = 0; i < REF_CONTEXTS; i++) { + vp9_cond_prob_diff_update(&header_bc, &pc->fc.single_ref_prob[i][0], + VP9_DEF_UPDATE_PROB, + cpi->single_ref_count[i][0]); + vp9_cond_prob_diff_update(&header_bc, &pc->fc.single_ref_prob[i][1], + VP9_DEF_UPDATE_PROB, + cpi->single_ref_count[i][1]); + } + } + + if (pc->comp_pred_mode != SINGLE_PREDICTION_ONLY) { + for (i = 0; i < REF_CONTEXTS; i++) + vp9_cond_prob_diff_update(&header_bc, &pc->fc.comp_ref_prob[i], + VP9_DEF_UPDATE_PROB, + cpi->comp_ref_count[i]); + } + update_mbintra_mode_probs(cpi, &header_bc); for (i = 0; i < NUM_PARTITION_CONTEXTS; ++i) { diff --git a/vp9/encoder/vp9_encodeframe.c b/vp9/encoder/vp9_encodeframe.c index 084e7b346..26ec57ec2 100644 --- a/vp9/encoder/vp9_encodeframe.c +++ b/vp9/encoder/vp9_encodeframe.c @@ -330,7 +330,6 @@ static void update_state(VP9_COMP *cpi, BLOCK_SIZE_TYPE bsize, int output_enabled) { int i, x_idx, y; - VP9_COMMON *const cm = &cpi->common; MACROBLOCK *const x = &cpi->mb; MACROBLOCKD *const xd = &x->e_mbd; MODE_INFO *mi = &ctx->mic; @@ -345,7 +344,8 @@ static void update_state(VP9_COMP *cpi, #if CONFIG_DEBUG assert(mb_mode < MB_MODE_COUNT); assert(mb_mode_index < MAX_MODES); - assert(mi->mbmi.ref_frame < MAX_REF_FRAMES); + assert(mi->mbmi.ref_frame[0] < MAX_REF_FRAMES); + assert(mi->mbmi.ref_frame[1] < MAX_REF_FRAMES); #endif assert(mi->mbmi.sb_type == bsize); @@ -366,7 +366,7 @@ static void update_state(VP9_COMP *cpi, ctx->txfm_rd_diff[ALLOW_32X32] = ctx->txfm_rd_diff[ALLOW_16X16]; } - if (mbmi->ref_frame != INTRA_FRAME && mbmi->sb_type < BLOCK_SIZE_SB8X8) { + if (mbmi->ref_frame[0] != INTRA_FRAME && mbmi->sb_type < BLOCK_SIZE_SB8X8) { *x->partition_info = ctx->partition_info; mbmi->mv[0].as_int = x->partition_info->bmi[3].mv.as_int; mbmi->mv[1].as_int = x->partition_info->bmi[3].second_mv.as_int; @@ -376,29 +376,9 @@ static void update_state(VP9_COMP *cpi, if (!output_enabled) return; - { - int segment_id = mbmi->segment_id, ref_pred_flag; - if (!vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP)) { - for (i = 0; i < NB_TXFM_MODES; i++) { - cpi->rd_tx_select_diff[i] += ctx->txfm_rd_diff[i]; - } - } - - // Did the chosen reference frame match its predicted value. - ref_pred_flag = ((xd->mode_info_context->mbmi.ref_frame == - vp9_get_pred_ref(cm, xd))); - vp9_set_pred_flag(xd, PRED_REF, ref_pred_flag); - if (!xd->segmentation_enabled || - !vp9_segfeature_active(xd, segment_id, SEG_LVL_REF_FRAME) || - vp9_check_segref(xd, segment_id, INTRA_FRAME) + - vp9_check_segref(xd, segment_id, LAST_FRAME) + - vp9_check_segref(xd, segment_id, GOLDEN_FRAME) + - vp9_check_segref(xd, segment_id, ALTREF_FRAME) > 1) { - // Get the prediction context and status - int pred_context = vp9_get_pred_context(cm, xd, PRED_REF); - - // Count prediction success - cpi->ref_pred_count[pred_context][ref_pred_flag]++; + if (!vp9_segfeature_active(xd, mbmi->segment_id, SEG_LVL_SKIP)) { + for (i = 0; i < NB_TXFM_MODES; i++) { + cpi->rd_tx_select_diff[i] += ctx->txfm_rd_diff[i]; } } @@ -448,15 +428,16 @@ static void update_state(VP9_COMP *cpi, */ // Note how often each mode chosen as best cpi->mode_chosen_counts[mb_mode_index]++; - if (mbmi->ref_frame != INTRA_FRAME && + if (mbmi->ref_frame[0] != INTRA_FRAME && (mbmi->sb_type < BLOCK_SIZE_SB8X8 || mbmi->mode == NEWMV)) { int_mv best_mv, best_second_mv; - MV_REFERENCE_FRAME rf = mbmi->ref_frame; + const MV_REFERENCE_FRAME rf1 = mbmi->ref_frame[0]; + const MV_REFERENCE_FRAME rf2 = mbmi->ref_frame[1]; best_mv.as_int = ctx->best_ref_mv.as_int; best_second_mv.as_int = ctx->second_best_ref_mv.as_int; if (mbmi->mode == NEWMV) { - best_mv.as_int = mbmi->ref_mvs[rf][0].as_int; - best_second_mv.as_int = mbmi->ref_mvs[mbmi->second_ref_frame][0].as_int; + best_mv.as_int = mbmi->ref_mvs[rf1][0].as_int; + best_second_mv.as_int = mbmi->ref_mvs[rf2][0].as_int; } mbmi->best_mv.as_int = best_mv.as_int; mbmi->best_second_mv.as_int = best_second_mv.as_int; @@ -654,14 +635,8 @@ static void update_stats(VP9_COMP *cpi, int mi_row, int mi_col) { if (cm->frame_type != KEY_FRAME) { int segment_id, seg_ref_active; - if (mbmi->ref_frame) { - int pred_context = vp9_get_pred_context(cm, xd, PRED_COMP); - - if (mbmi->second_ref_frame <= INTRA_FRAME) - cpi->single_pred_count[pred_context]++; - else - cpi->comp_pred_count[pred_context]++; - } + cpi->intra_inter_count[vp9_get_pred_context(cm, xd, PRED_INTRA_INTER)] + [mbmi->ref_frame[0] > INTRA_FRAME]++; // If we have just a single reference frame coded for a segment then // exclude from the reference frame counts used to work out @@ -671,15 +646,31 @@ static void update_stats(VP9_COMP *cpi, int mi_row, int mi_col) { segment_id = mbmi->segment_id; seg_ref_active = vp9_segfeature_active(xd, segment_id, SEG_LVL_REF_FRAME); - if (!seg_ref_active || - ((vp9_check_segref(xd, segment_id, INTRA_FRAME) + - vp9_check_segref(xd, segment_id, LAST_FRAME) + - vp9_check_segref(xd, segment_id, GOLDEN_FRAME) + - vp9_check_segref(xd, segment_id, ALTREF_FRAME)) > 1)) { - cpi->count_mb_ref_frame_usage[mbmi->ref_frame]++; + if (mbmi->ref_frame[0] > INTRA_FRAME && + (!seg_ref_active || + ((vp9_check_segref(xd, segment_id, INTRA_FRAME) + + vp9_check_segref(xd, segment_id, LAST_FRAME) + + vp9_check_segref(xd, segment_id, GOLDEN_FRAME) + + vp9_check_segref(xd, segment_id, ALTREF_FRAME)) > 1))) { + if (cm->comp_pred_mode == HYBRID_PREDICTION) + cpi->comp_inter_count[vp9_get_pred_context(cm, xd, + PRED_COMP_INTER_INTER)] + [mbmi->ref_frame[1] > INTRA_FRAME]++; + + if (mbmi->ref_frame[1] > INTRA_FRAME) { + cpi->comp_ref_count[vp9_get_pred_context(cm, xd, PRED_COMP_REF_P)] + [mbmi->ref_frame[0] == GOLDEN_FRAME]++; + } else { + cpi->single_ref_count[vp9_get_pred_context(cm, xd, PRED_SINGLE_REF_P1)] + [0][mbmi->ref_frame[0] != LAST_FRAME]++; + if (mbmi->ref_frame[0] != LAST_FRAME) + cpi->single_ref_count[vp9_get_pred_context(cm, xd, + PRED_SINGLE_REF_P2)] + [1][mbmi->ref_frame[0] != GOLDEN_FRAME]++; + } } // Count of last ref frame 0,0 usage - if ((mbmi->mode == ZEROMV) && (mbmi->ref_frame == LAST_FRAME)) + if ((mbmi->mode == ZEROMV) && (mbmi->ref_frame[0] == LAST_FRAME)) cpi->inter_zz_count++; } } @@ -1445,7 +1436,6 @@ static void init_encode_frame_mb_context(VP9_COMP *cpi) { x->act_zbin_adj = 0; cpi->seg0_idx = 0; - vpx_memset(cpi->ref_pred_count, 0, sizeof(cpi->ref_pred_count)); xd->mode_info_stride = cm->mode_info_stride; xd->frame_type = cm->frame_type; @@ -1472,11 +1462,14 @@ static void init_encode_frame_mb_context(VP9_COMP *cpi) { xd->mode_info_context->mbmi.mode = DC_PRED; xd->mode_info_context->mbmi.uv_mode = DC_PRED; - vp9_zero(cpi->count_mb_ref_frame_usage) vp9_zero(cpi->y_mode_count) vp9_zero(cpi->y_uv_mode_count) vp9_zero(cpi->common.fc.inter_mode_counts) vp9_zero(cpi->partition_count); + vp9_zero(cpi->intra_inter_count); + vp9_zero(cpi->comp_inter_count); + vp9_zero(cpi->single_ref_count); + vp9_zero(cpi->comp_ref_count); // Note: this memset assumes above_context[0], [1] and [2] // are allocated as part of the same buffer. @@ -1516,11 +1509,6 @@ static void encode_frame_internal(VP9_COMP *cpi) { // cpi->common.current_video_frame, cpi->common.show_frame, // cm->frame_type); - // Compute a modified set of reference frame probabilities to use when - // prediction fails. These are based on the current general estimates for - // this frame which may be updated with each iteration of the recode loop. - vp9_compute_mod_refprobs(cm); - // debug output #if DBG_PRNT_SEGMAP { @@ -1572,8 +1560,6 @@ static void encode_frame_internal(VP9_COMP *cpi) { init_encode_frame_mb_context(cpi); vpx_memset(cpi->rd_comp_pred_diff, 0, sizeof(cpi->rd_comp_pred_diff)); - vpx_memset(cpi->single_pred_count, 0, sizeof(cpi->single_pred_count)); - vpx_memset(cpi->comp_pred_count, 0, sizeof(cpi->comp_pred_count)); vpx_memset(cpi->txfm_count_32x32p, 0, sizeof(cpi->txfm_count_32x32p)); vpx_memset(cpi->txfm_count_16x16p, 0, sizeof(cpi->txfm_count_16x16p)); vpx_memset(cpi->txfm_count_8x8p, 0, sizeof(cpi->txfm_count_8x8p)); @@ -1764,6 +1750,20 @@ static void reset_skip_txfm_size(VP9_COMP *cpi, TX_SIZE txfm_max) { } void vp9_encode_frame(VP9_COMP *cpi) { + VP9_COMMON *const cm = &cpi->common; + + if (cm->ref_frame_sign_bias[LAST_FRAME] == + cm->ref_frame_sign_bias[GOLDEN_FRAME] && + cm->ref_frame_sign_bias[LAST_FRAME] == + cm->ref_frame_sign_bias[ALTREF_FRAME]) { + cm->allow_comp_inter_inter = 0; + } else { + cm->allow_comp_inter_inter = 1; + cm->comp_fixed_ref = ALTREF_FRAME; + cm->comp_var_ref[0] = LAST_FRAME; + cm->comp_var_ref[1] = GOLDEN_FRAME; + } + if (cpi->sf.RD) { int i, frame_type, pred_type; TXFM_MODE txfm_type; @@ -1787,7 +1787,7 @@ void vp9_encode_frame(VP9_COMP *cpi) { frame_type = 2; /* prediction (compound, single or hybrid) mode selection */ - if (frame_type == 3) + if (frame_type == 3 || !cm->allow_comp_inter_inter) pred_type = SINGLE_PREDICTION_ONLY; else if (cpi->rd_prediction_type_threshes[frame_type][1] > cpi->rd_prediction_type_threshes[frame_type][0] && @@ -1870,15 +1870,17 @@ void vp9_encode_frame(VP9_COMP *cpi) { int single_count_zero = 0; int comp_count_zero = 0; - for (i = 0; i < COMP_PRED_CONTEXTS; i++) { - single_count_zero += cpi->single_pred_count[i]; - comp_count_zero += cpi->comp_pred_count[i]; + for (i = 0; i < COMP_INTER_CONTEXTS; i++) { + single_count_zero += cpi->comp_inter_count[i][0]; + comp_count_zero += cpi->comp_inter_count[i][1]; } if (comp_count_zero == 0) { cpi->common.comp_pred_mode = SINGLE_PREDICTION_ONLY; + vp9_zero(cpi->comp_inter_count); } else if (single_count_zero == 0) { cpi->common.comp_pred_mode = COMP_PREDICTION_ONLY; + vp9_zero(cpi->comp_inter_count); } } @@ -1997,9 +1999,9 @@ static void encode_superblock(VP9_COMP *cpi, TOKENEXTRA **t, // Increase zbin size to suppress noise cpi->zbin_mode_boost = 0; if (cpi->zbin_mode_boost_enabled) { - if (mbmi->ref_frame != INTRA_FRAME) { + if (mbmi->ref_frame[0] != INTRA_FRAME) { if (mbmi->mode == ZEROMV) { - if (mbmi->ref_frame != LAST_FRAME) + if (mbmi->ref_frame[0] != LAST_FRAME) cpi->zbin_mode_boost = GF_ZEROMV_ZBIN_BOOST; else cpi->zbin_mode_boost = LF_ZEROMV_ZBIN_BOOST; @@ -2016,7 +2018,7 @@ static void encode_superblock(VP9_COMP *cpi, TOKENEXTRA **t, vp9_update_zbin_extra(cpi, x); } - if (mbmi->ref_frame == INTRA_FRAME) { + if (mbmi->ref_frame[0] == INTRA_FRAME) { vp9_encode_intra_block_y(cm, x, (bsize < BLOCK_SIZE_SB8X8) ? BLOCK_SIZE_SB8X8 : bsize); vp9_encode_intra_block_uv(cm, x, (bsize < BLOCK_SIZE_SB8X8) ? @@ -2024,11 +2026,11 @@ static void encode_superblock(VP9_COMP *cpi, TOKENEXTRA **t, if (output_enabled) sum_intra_stats(cpi, x); } else { - int idx = cm->ref_frame_map[get_ref_frame_idx(cpi, mbmi->ref_frame)]; + int idx = cm->ref_frame_map[get_ref_frame_idx(cpi, mbmi->ref_frame[0])]; YV12_BUFFER_CONFIG *ref_fb = &cm->yv12_fb[idx]; YV12_BUFFER_CONFIG *second_ref_fb = NULL; - if (mbmi->second_ref_frame > 0) { - idx = cm->ref_frame_map[get_ref_frame_idx(cpi, mbmi->second_ref_frame)]; + if (mbmi->ref_frame[1] > 0) { + idx = cm->ref_frame_map[get_ref_frame_idx(cpi, mbmi->ref_frame[1])]; second_ref_fb = &cm->yv12_fb[idx]; } @@ -2042,7 +2044,7 @@ static void encode_superblock(VP9_COMP *cpi, TOKENEXTRA **t, : bsize); } - if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME) { + if (xd->mode_info_context->mbmi.ref_frame[0] == INTRA_FRAME) { vp9_tokenize_sb(cpi, xd, t, !output_enabled, (bsize < BLOCK_SIZE_SB8X8) ? BLOCK_SIZE_SB8X8 : bsize); } else if (!x->skip) { @@ -2072,7 +2074,7 @@ static void encode_superblock(VP9_COMP *cpi, TOKENEXTRA **t, if (output_enabled) { if (cm->txfm_mode == TX_MODE_SELECT && mbmi->sb_type >= BLOCK_SIZE_SB8X8 && - !(mbmi->ref_frame != INTRA_FRAME && (mbmi->mb_skip_coeff || + !(mbmi->ref_frame[0] != INTRA_FRAME && (mbmi->mb_skip_coeff || vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP)))) { if (bsize >= BLOCK_SIZE_SB32X32) { cpi->txfm_count_32x32p[mbmi->txfm_size]++; @@ -2085,7 +2087,7 @@ static void encode_superblock(VP9_COMP *cpi, TOKENEXTRA **t, int x, y; TX_SIZE sz = (cm->txfm_mode == TX_MODE_SELECT) ? TX_32X32 : cm->txfm_mode; // The new intra coding scheme requires no change of transform size - if (mi->mbmi.ref_frame != INTRA_FRAME) { + if (mi->mbmi.ref_frame[0] != INTRA_FRAME) { if (sz == TX_32X32 && bsize < BLOCK_SIZE_SB32X32) sz = TX_16X16; if (sz == TX_16X16 && bsize < BLOCK_SIZE_MB16X16) diff --git a/vp9/encoder/vp9_encodeintra.c b/vp9/encoder/vp9_encodeintra.c index 57041a90b..c78882ab3 100644 --- a/vp9/encoder/vp9_encodeintra.c +++ b/vp9/encoder/vp9_encodeintra.c @@ -20,7 +20,7 @@ int vp9_encode_intra(VP9_COMP *cpi, MACROBLOCK *x, int use_16x16_pred) { MB_MODE_INFO * mbmi = &x->e_mbd.mode_info_context->mbmi; (void) cpi; mbmi->mode = DC_PRED; - mbmi->ref_frame = INTRA_FRAME; + mbmi->ref_frame[0] = INTRA_FRAME; if (use_16x16_pred) { mbmi->txfm_size = TX_16X16; vp9_encode_intra_block_y(&cpi->common, x, BLOCK_SIZE_MB16X16); diff --git a/vp9/encoder/vp9_encodemb.c b/vp9/encoder/vp9_encodemb.c index b65b2619b..aa9cf8d13 100644 --- a/vp9/encoder/vp9_encodemb.c +++ b/vp9/encoder/vp9_encodemb.c @@ -118,7 +118,7 @@ static void optimize_b(VP9_COMMON *const cm, MACROBLOCK *mb, int plane, int block, BLOCK_SIZE_TYPE bsize, ENTROPY_CONTEXT *a, ENTROPY_CONTEXT *l, TX_SIZE tx_size) { - const int ref = mb->e_mbd.mode_info_context->mbmi.ref_frame != INTRA_FRAME; + const int ref = mb->e_mbd.mode_info_context->mbmi.ref_frame[0] != INTRA_FRAME; MACROBLOCKD *const xd = &mb->e_mbd; vp9_token_state tokens[1025][2]; unsigned best_index[1025][2]; @@ -179,7 +179,7 @@ static void optimize_b(VP9_COMMON *const cm, MACROBLOCK *mb, /* Now set up a Viterbi trellis to evaluate alternative roundings. */ rdmult = mb->rdmult * err_mult; - if (mb->e_mbd.mode_info_context->mbmi.ref_frame == INTRA_FRAME) + if (mb->e_mbd.mode_info_context->mbmi.ref_frame[0] == INTRA_FRAME) rdmult = (rdmult * 9) >> 4; rddiv = mb->rddiv; memset(best_index, 0, sizeof(best_index)); @@ -622,7 +622,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE_TYPE bsize, mode = plane == 0? mbmi->mode: mbmi->uv_mode; if (plane == 0 && mbmi->sb_type < BLOCK_SIZE_SB8X8 && - mbmi->ref_frame == INTRA_FRAME) + mbmi->ref_frame[0] == INTRA_FRAME) b_mode = xd->mode_info_context->bmi[ib].as_mode.first; else b_mode = mode; diff --git a/vp9/encoder/vp9_encodemv.c b/vp9/encoder/vp9_encodemv.c index 2b6dfba64..a582d183d 100644 --- a/vp9/encoder/vp9_encodemv.c +++ b/vp9/encoder/vp9_encodemv.c @@ -584,7 +584,7 @@ void vp9_update_nmv_count(VP9_COMP *cpi, MACROBLOCK *x, mv.col = (pi->bmi[i].mv.as_mv.col - best_ref_mv->as_mv.col); vp9_increment_nmv(&mv, &best_ref_mv->as_mv, &cpi->NMVcount, x->e_mbd.allow_high_precision_mv); - if (x->e_mbd.mode_info_context->mbmi.second_ref_frame > 0) { + if (x->e_mbd.mode_info_context->mbmi.ref_frame[1] > INTRA_FRAME) { mv.row = pi->bmi[i].second_mv.as_mv.row - second_best_ref_mv->as_mv.row; mv.col = pi->bmi[i].second_mv.as_mv.col - @@ -600,7 +600,7 @@ void vp9_update_nmv_count(VP9_COMP *cpi, MACROBLOCK *x, mv.col = (mbmi->mv[0].as_mv.col - best_ref_mv->as_mv.col); vp9_increment_nmv(&mv, &best_ref_mv->as_mv, &cpi->NMVcount, x->e_mbd.allow_high_precision_mv); - if (mbmi->second_ref_frame > 0) { + if (mbmi->ref_frame[1] > INTRA_FRAME) { mv.row = (mbmi->mv[1].as_mv.row - second_best_ref_mv->as_mv.row); mv.col = (mbmi->mv[1].as_mv.col - second_best_ref_mv->as_mv.col); vp9_increment_nmv(&mv, &second_best_ref_mv->as_mv, &cpi->NMVcount, diff --git a/vp9/encoder/vp9_firstpass.c b/vp9/encoder/vp9_firstpass.c index b07e37d7a..001129d02 100644 --- a/vp9/encoder/vp9_firstpass.c +++ b/vp9/encoder/vp9_firstpass.c @@ -523,7 +523,7 @@ void vp9_first_pass(VP9_COMP *cpi) { xd->left_available = (mb_col != 0); xd->mode_info_context->mbmi.sb_type = BLOCK_SIZE_MB16X16; - xd->mode_info_context->mbmi.ref_frame = INTRA_FRAME; + xd->mode_info_context->mbmi.ref_frame[0] = INTRA_FRAME; // do intra 16x16 prediction this_error = vp9_encode_intra(cpi, x, use_dc_pred); @@ -620,7 +620,8 @@ void vp9_first_pass(VP9_COMP *cpi) { this_error = motion_error; vp9_set_mbmode_and_mvs(x, NEWMV, &mv); xd->mode_info_context->mbmi.txfm_size = TX_4X4; - xd->mode_info_context->mbmi.ref_frame = LAST_FRAME; + xd->mode_info_context->mbmi.ref_frame[0] = LAST_FRAME; + xd->mode_info_context->mbmi.ref_frame[1] = NONE; vp9_build_inter_predictors_sby(xd, mb_row << 1, mb_col << 1, BLOCK_SIZE_MB16X16); diff --git a/vp9/encoder/vp9_onyx_if.c b/vp9/encoder/vp9_onyx_if.c index a0e7b37da..4ca5ef3ec 100644 --- a/vp9/encoder/vp9_onyx_if.c +++ b/vp9/encoder/vp9_onyx_if.c @@ -623,25 +623,20 @@ static void set_rd_speed_thresholds(VP9_COMP *cpi, int mode, int speed) { sf->thresh_mult[THR_SPLITG ] += speed_multiplier * 2500; sf->thresh_mult[THR_SPLITA ] += speed_multiplier * 2500; - sf->thresh_mult[THR_COMP_ZEROLG ] += speed_multiplier * 1500; sf->thresh_mult[THR_COMP_ZEROLA ] += speed_multiplier * 1500; sf->thresh_mult[THR_COMP_ZEROGA ] += speed_multiplier * 1500; - sf->thresh_mult[THR_COMP_NEARESTLG] += speed_multiplier * 1500; sf->thresh_mult[THR_COMP_NEARESTLA] += speed_multiplier * 1500; sf->thresh_mult[THR_COMP_NEARESTGA] += speed_multiplier * 1500; - sf->thresh_mult[THR_COMP_NEARLG ] += speed_multiplier * 1500; sf->thresh_mult[THR_COMP_NEARLA ] += speed_multiplier * 1500; sf->thresh_mult[THR_COMP_NEARGA ] += speed_multiplier * 1500; - sf->thresh_mult[THR_COMP_NEWLG ] += speed_multiplier * 2000; sf->thresh_mult[THR_COMP_NEWLA ] += speed_multiplier * 2000; sf->thresh_mult[THR_COMP_NEWGA ] += speed_multiplier * 2000; sf->thresh_mult[THR_COMP_SPLITLA ] += speed_multiplier * 4500; sf->thresh_mult[THR_COMP_SPLITGA ] += speed_multiplier * 4500; - sf->thresh_mult[THR_COMP_SPLITLG ] += speed_multiplier * 4500; if (speed > 4) { for (i = 0; i < MAX_MODES; ++i) @@ -685,14 +680,6 @@ static void set_rd_speed_thresholds(VP9_COMP *cpi, int mode, int speed) { sf->thresh_mult[THR_SPLITA ] = INT_MAX; } - if ((cpi->ref_frame_flags & (VP9_LAST_FLAG | VP9_GOLD_FLAG)) != - (VP9_LAST_FLAG | VP9_GOLD_FLAG)) { - sf->thresh_mult[THR_COMP_ZEROLG ] = INT_MAX; - sf->thresh_mult[THR_COMP_NEARESTLG] = INT_MAX; - sf->thresh_mult[THR_COMP_NEARLG ] = INT_MAX; - sf->thresh_mult[THR_COMP_NEWLG ] = INT_MAX; - sf->thresh_mult[THR_COMP_SPLITLG ] = INT_MAX; - } if ((cpi->ref_frame_flags & (VP9_LAST_FLAG | VP9_ALT_FLAG)) != (VP9_LAST_FLAG | VP9_ALT_FLAG)) { sf->thresh_mult[THR_COMP_ZEROLA ] = INT_MAX; @@ -1311,21 +1298,9 @@ VP9_PTR vp9_create_compressor(VP9_CONFIG *oxcf) { cpi->frames_till_gf_update_due = 0; cpi->gf_overspend_bits = 0; cpi->non_gf_bitrate_adjustment = 0; - cm->prob_last_coded = 128; - cm->prob_gf_coded = 128; - cm->prob_intra_coded = 63; - for (i = 0; i < COMP_PRED_CONTEXTS; i++) - cm->prob_comppred[i] = 128; for (i = 0; i < TX_SIZE_MAX_SB - 1; i++) cm->prob_tx[i] = 128; - // Prime the recent reference frame usage counters. - // Hereafter they will be maintained as a sort of moving average - cpi->recent_ref_frame_usage[INTRA_FRAME] = 1; - cpi->recent_ref_frame_usage[LAST_FRAME] = 1; - cpi->recent_ref_frame_usage[GOLDEN_FRAME] = 1; - cpi->recent_ref_frame_usage[ALTREF_FRAME] = 1; - // Set reference frame sign bias for ALTREF frame to 1 (for now) cpi->common.ref_frame_sign_bias[ALTREF_FRAME] = 1; @@ -2083,22 +2058,6 @@ static void update_golden_frame_stats(VP9_COMP *cpi) { cpi->refresh_golden_frame = 0; cpi->common.frames_since_golden = 0; - // if ( cm->frame_type == KEY_FRAME ) - // { - cpi->recent_ref_frame_usage[INTRA_FRAME] = 1; - cpi->recent_ref_frame_usage[LAST_FRAME] = 1; - cpi->recent_ref_frame_usage[GOLDEN_FRAME] = 1; - cpi->recent_ref_frame_usage[ALTREF_FRAME] = 1; - // } - // else - // { - // // Carry a portion of count over to beginning of next gf sequence - // cpi->recent_ref_frame_usage[INTRA_FRAME] >>= 5; - // cpi->recent_ref_frame_usage[LAST_FRAME] >>= 5; - // cpi->recent_ref_frame_usage[GOLDEN_FRAME] >>= 5; - // cpi->recent_ref_frame_usage[ALTREF_FRAME] >>= 5; - // } - // ******** Fixed Q test code only ************ // If we are going to use the ALT reference for the next group of frames set a flag to say so. if (cpi->oxcf.fixed_q >= 0 && @@ -2123,13 +2082,6 @@ static void update_golden_frame_stats(VP9_COMP *cpi) { cpi->common.frames_till_alt_ref_frame--; cpi->common.frames_since_golden++; - - if (cpi->common.frames_since_golden > 1) { - cpi->recent_ref_frame_usage[INTRA_FRAME] += cpi->count_mb_ref_frame_usage[INTRA_FRAME]; - cpi->recent_ref_frame_usage[LAST_FRAME] += cpi->count_mb_ref_frame_usage[LAST_FRAME]; - cpi->recent_ref_frame_usage[GOLDEN_FRAME] += cpi->count_mb_ref_frame_usage[GOLDEN_FRAME]; - cpi->recent_ref_frame_usage[ALTREF_FRAME] += cpi->count_mb_ref_frame_usage[ALTREF_FRAME]; - } } } @@ -3113,6 +3065,10 @@ static void encode_frame_to_data_rate(VP9_COMP *cpi, vp9_copy(cpi->common.fc.y_mode_counts, cpi->y_mode_count); vp9_copy(cpi->common.fc.uv_mode_counts, cpi->y_uv_mode_count); vp9_copy(cpi->common.fc.partition_counts, cpi->partition_count); + vp9_copy(cm->fc.intra_inter_count, cpi->intra_inter_count); + vp9_copy(cm->fc.comp_inter_count, cpi->comp_inter_count); + vp9_copy(cm->fc.single_ref_count, cpi->single_ref_count); + vp9_copy(cm->fc.comp_ref_count, cpi->comp_ref_count); cpi->common.fc.NMVcount = cpi->NMVcount; if (!cpi->common.error_resilient_mode && !cpi->common.frame_parallel_decoding_mode) { diff --git a/vp9/encoder/vp9_onyx_int.h b/vp9/encoder/vp9_onyx_int.h index 1f102e869..79a57eeb6 100644 --- a/vp9/encoder/vp9_onyx_int.h +++ b/vp9/encoder/vp9_onyx_int.h @@ -47,7 +47,7 @@ #define KEY_FRAME_CONTEXT 5 -#define MAX_MODES 41 +#define MAX_MODES 36 #define MIN_THRESHMULT 32 #define MAX_THRESHMULT 512 @@ -65,9 +65,10 @@ typedef struct { int nmvcosts_hp[2][MV_VALS]; vp9_prob segment_pred_probs[PREDICTION_PROBS]; - unsigned char ref_pred_probs_update[PREDICTION_PROBS]; - vp9_prob ref_pred_probs[PREDICTION_PROBS]; - vp9_prob prob_comppred[COMP_PRED_CONTEXTS]; + vp9_prob intra_inter_prob[INTRA_INTER_CONTEXTS]; + vp9_prob comp_inter_prob[COMP_INTER_CONTEXTS]; + vp9_prob single_ref_prob[REF_CONTEXTS][2]; + vp9_prob comp_ref_prob[REF_CONTEXTS]; unsigned char *last_frame_seg_map_copy; @@ -174,10 +175,6 @@ typedef enum { THR_B_PRED, - THR_COMP_ZEROLG, - THR_COMP_NEARESTLG, - THR_COMP_NEARLG, - THR_COMP_ZEROLA, THR_COMP_NEARESTLA, THR_COMP_NEARLA, @@ -186,11 +183,9 @@ typedef enum { THR_COMP_NEARESTGA, THR_COMP_NEARGA, - THR_COMP_NEWLG, THR_COMP_NEWLA, THR_COMP_NEWGA, - THR_COMP_SPLITLG, THR_COMP_SPLITLA, THR_COMP_SPLITGA, } THR_MODES; @@ -325,8 +320,11 @@ typedef struct VP9_COMP { int64_t rd_comp_pred_diff[NB_PREDICTION_TYPES]; int rd_prediction_type_threshes[4][NB_PREDICTION_TYPES]; - int comp_pred_count[COMP_PRED_CONTEXTS]; - int single_pred_count[COMP_PRED_CONTEXTS]; + unsigned int intra_inter_count[INTRA_INTER_CONTEXTS][2]; + unsigned int comp_inter_count[COMP_INTER_CONTEXTS][2]; + unsigned int single_ref_count[REF_CONTEXTS][2][2]; + unsigned int comp_ref_count[REF_CONTEXTS][2]; + // FIXME contextualize int txfm_count_32x32p[TX_SIZE_MAX_SB]; int txfm_count_16x16p[TX_SIZE_MAX_SB - 1]; @@ -433,7 +431,6 @@ typedef struct VP9_COMP { int mbgraph_n_frames; // number of frames filled in the above int static_mb_pct; // % forced skip mbs by segmentation int seg0_progress, seg0_idx, seg0_cnt; - int ref_pred_count[3][2]; int decimation_factor; int decimation_count; @@ -454,12 +451,8 @@ typedef struct VP9_COMP { vp9_prob last_skip_false_probs[3][MBSKIP_CONTEXTS]; int last_skip_probs_q[3]; - int recent_ref_frame_usage[MAX_REF_FRAMES]; - int count_mb_ref_frame_usage[MAX_REF_FRAMES]; int ref_frame_flags; - unsigned char ref_pred_probs_update[PREDICTION_PROBS]; - SPEED_FEATURES sf; int error_bins[1024]; diff --git a/vp9/encoder/vp9_ratectrl.c b/vp9/encoder/vp9_ratectrl.c index 82f0306c9..9515ea4a5 100644 --- a/vp9/encoder/vp9_ratectrl.c +++ b/vp9/encoder/vp9_ratectrl.c @@ -129,9 +129,11 @@ void vp9_save_coding_context(VP9_COMP *cpi) { vp9_copy(cc->partition_prob, cm->fc.partition_prob); vp9_copy(cc->segment_pred_probs, cm->segment_pred_probs); - vp9_copy(cc->ref_pred_probs_update, cpi->ref_pred_probs_update); - vp9_copy(cc->ref_pred_probs, cm->ref_pred_probs); - vp9_copy(cc->prob_comppred, cm->prob_comppred); + + vp9_copy(cc->intra_inter_prob, cm->fc.intra_inter_prob); + vp9_copy(cc->comp_inter_prob, cm->fc.comp_inter_prob); + vp9_copy(cc->single_ref_prob, cm->fc.single_ref_prob); + vp9_copy(cc->comp_ref_prob, cm->fc.comp_ref_prob); vpx_memcpy(cpi->coding_context.last_frame_seg_map_copy, cm->last_frame_seg_map, (cm->mi_rows * cm->mi_cols)); @@ -163,9 +165,11 @@ void vp9_restore_coding_context(VP9_COMP *cpi) { vp9_copy(cm->fc.partition_prob, cc->partition_prob); vp9_copy(cm->segment_pred_probs, cc->segment_pred_probs); - vp9_copy(cpi->ref_pred_probs_update, cc->ref_pred_probs_update); - vp9_copy(cm->ref_pred_probs, cc->ref_pred_probs); - vp9_copy(cm->prob_comppred, cc->prob_comppred); + + vp9_copy(cm->fc.intra_inter_prob, cc->intra_inter_prob); + vp9_copy(cm->fc.comp_inter_prob, cc->comp_inter_prob); + vp9_copy(cm->fc.single_ref_prob, cc->single_ref_prob); + vp9_copy(cm->fc.comp_ref_prob, cc->comp_ref_prob); vpx_memcpy(cm->last_frame_seg_map, cpi->coding_context.last_frame_seg_map_copy, diff --git a/vp9/encoder/vp9_rdopt.c b/vp9/encoder/vp9_rdopt.c index f785c32ca..8eedfc13a 100644 --- a/vp9/encoder/vp9_rdopt.c +++ b/vp9/encoder/vp9_rdopt.c @@ -90,24 +90,18 @@ const MODE_DEFINITION vp9_mode_order[MAX_MODES] = { {I4X4_PRED, INTRA_FRAME, NONE}, /* compound prediction modes */ - {ZEROMV, LAST_FRAME, GOLDEN_FRAME}, - {NEARESTMV, LAST_FRAME, GOLDEN_FRAME}, - {NEARMV, LAST_FRAME, GOLDEN_FRAME}, - - {ZEROMV, ALTREF_FRAME, LAST_FRAME}, - {NEARESTMV, ALTREF_FRAME, LAST_FRAME}, - {NEARMV, ALTREF_FRAME, LAST_FRAME}, + {ZEROMV, LAST_FRAME, ALTREF_FRAME}, + {NEARESTMV, LAST_FRAME, ALTREF_FRAME}, + {NEARMV, LAST_FRAME, ALTREF_FRAME}, {ZEROMV, GOLDEN_FRAME, ALTREF_FRAME}, {NEARESTMV, GOLDEN_FRAME, ALTREF_FRAME}, {NEARMV, GOLDEN_FRAME, ALTREF_FRAME}, - {NEWMV, LAST_FRAME, GOLDEN_FRAME}, - {NEWMV, ALTREF_FRAME, LAST_FRAME }, + {NEWMV, LAST_FRAME, ALTREF_FRAME}, {NEWMV, GOLDEN_FRAME, ALTREF_FRAME}, - {SPLITMV, LAST_FRAME, GOLDEN_FRAME}, - {SPLITMV, ALTREF_FRAME, LAST_FRAME }, + {SPLITMV, LAST_FRAME, ALTREF_FRAME}, {SPLITMV, GOLDEN_FRAME, ALTREF_FRAME}, }; @@ -306,7 +300,7 @@ static INLINE int cost_coeffs(VP9_COMMON *const cm, MACROBLOCK *mb, const int eob = xd->plane[plane].eobs[block]; const int16_t *qcoeff_ptr = BLOCK_OFFSET(xd->plane[plane].qcoeff, block, 16); - const int ref = mbmi->ref_frame != INTRA_FRAME; + const int ref = mbmi->ref_frame[0] != INTRA_FRAME; unsigned int (*token_costs)[PREV_COEF_CONTEXTS][MAX_ENTROPY_TOKENS] = mb->token_costs[tx_size][type][ref]; ENTROPY_CONTEXT above_ec, left_ec; @@ -595,7 +589,7 @@ static void super_block_yrd_for_txfm(VP9_COMMON *const cm, MACROBLOCK *x, MACROBLOCKD *const xd = &x->e_mbd; xd->mode_info_context->mbmi.txfm_size = tx_size; - if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME) + if (xd->mode_info_context->mbmi.ref_frame[0] == INTRA_FRAME) vp9_encode_intra_block_y(cm, x, bsize); else vp9_xform_quant_sby(cm, x, bsize); @@ -614,7 +608,7 @@ static void super_block_yrd(VP9_COMP *cpi, MACROBLOCKD *xd = &x->e_mbd; MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi; - if (mbmi->ref_frame > INTRA_FRAME) + if (mbmi->ref_frame[0] > INTRA_FRAME) vp9_subtract_sby(x, bs); if (cpi->speed > 4) { @@ -918,7 +912,7 @@ static void super_block_uvrd_for_txfm(VP9_COMMON *const cm, MACROBLOCK *x, int *skippable, BLOCK_SIZE_TYPE bsize, TX_SIZE uv_tx_size) { MACROBLOCKD *const xd = &x->e_mbd; - if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME) + if (xd->mode_info_context->mbmi.ref_frame[0] == INTRA_FRAME) vp9_encode_intra_block_uv(cm, x, bsize); else vp9_xform_quant_sbuv(cm, x, bsize); @@ -934,7 +928,7 @@ static void super_block_uvrd(VP9_COMMON *const cm, MACROBLOCK *x, MACROBLOCKD *const xd = &x->e_mbd; MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi; - if (mbmi->ref_frame > INTRA_FRAME) + if (mbmi->ref_frame[0] > INTRA_FRAME) vp9_subtract_sbuv(x, bsize); if (mbmi->txfm_size >= TX_32X32 && bsize >= BLOCK_SIZE_SB64X64) { @@ -1034,31 +1028,31 @@ static int labels2mode(MACROBLOCK *x, int i, // is when we are on a new label (jbb May 08, 2007) switch (m = this_mode) { case NEWMV: - this_mv->as_int = seg_mvs[mbmi->ref_frame].as_int; + this_mv->as_int = seg_mvs[mbmi->ref_frame[0]].as_int; thismvcost = vp9_mv_bit_cost(this_mv, best_ref_mv, mvjcost, mvcost, 102, xd->allow_high_precision_mv); - if (mbmi->second_ref_frame > 0) { - this_second_mv->as_int = seg_mvs[mbmi->second_ref_frame].as_int; + if (mbmi->ref_frame[1] > 0) { + this_second_mv->as_int = seg_mvs[mbmi->ref_frame[1]].as_int; thismvcost += vp9_mv_bit_cost(this_second_mv, second_best_ref_mv, mvjcost, mvcost, 102, xd->allow_high_precision_mv); } break; case NEARESTMV: - this_mv->as_int = frame_mv[NEARESTMV][mbmi->ref_frame].as_int; - if (mbmi->second_ref_frame > 0) + this_mv->as_int = frame_mv[NEARESTMV][mbmi->ref_frame[0]].as_int; + if (mbmi->ref_frame[1] > 0) this_second_mv->as_int = - frame_mv[NEARESTMV][mbmi->second_ref_frame].as_int; + frame_mv[NEARESTMV][mbmi->ref_frame[1]].as_int; break; case NEARMV: - this_mv->as_int = frame_mv[NEARMV][mbmi->ref_frame].as_int; - if (mbmi->second_ref_frame > 0) + this_mv->as_int = frame_mv[NEARMV][mbmi->ref_frame[0]].as_int; + if (mbmi->ref_frame[1] > 0) this_second_mv->as_int = - frame_mv[NEARMV][mbmi->second_ref_frame].as_int; + frame_mv[NEARMV][mbmi->ref_frame[1]].as_int; break; case ZEROMV: this_mv->as_int = 0; - if (mbmi->second_ref_frame > 0) + if (mbmi->ref_frame[1] > 0) this_second_mv->as_int = 0; break; default: @@ -1066,15 +1060,15 @@ static int labels2mode(MACROBLOCK *x, int i, } cost = vp9_cost_mv_ref(cpi, this_mode, - mbmi->mb_mode_context[mbmi->ref_frame]); + mbmi->mb_mode_context[mbmi->ref_frame[0]]); mic->bmi[i].as_mv[0].as_int = this_mv->as_int; - if (mbmi->second_ref_frame > 0) + if (mbmi->ref_frame[1] > 0) mic->bmi[i].as_mv[1].as_int = this_second_mv->as_int; x->partition_info->bmi[i].mode = m; x->partition_info->bmi[i].mv.as_int = this_mv->as_int; - if (mbmi->second_ref_frame > 0) + if (mbmi->ref_frame[1] > 0) x->partition_info->bmi[i].second_mv.as_int = this_second_mv->as_int; for (idy = 0; idy < bh; ++idy) { for (idx = 0; idx < bw; ++idx) { @@ -1136,7 +1130,7 @@ static int64_t encode_inter_mb_segment(VP9_COMMON *const cm, // TODO(debargha): Make this work properly with the // implicit-compoundinter-weight experiment when implicit // weighting for splitmv modes is turned on. - if (xd->mode_info_context->mbmi.second_ref_frame > 0) { + if (xd->mode_info_context->mbmi.ref_frame[1] > 0) { uint8_t* const second_pre = raster_block_offset_uint8(xd, BLOCK_SIZE_SB8X8, 0, i, xd->plane[0].pre[1].buf, @@ -1254,7 +1248,7 @@ static INLINE void mi_buf_shift(MACROBLOCK *x, int i) { raster_block_offset_uint8(&x->e_mbd, BLOCK_SIZE_SB8X8, 0, i, x->e_mbd.plane[0].pre[0].buf, x->e_mbd.plane[0].pre[0].stride); - if (mbmi->second_ref_frame) + if (mbmi->ref_frame[1]) x->e_mbd.plane[0].pre[1].buf = raster_block_offset_uint8(&x->e_mbd, BLOCK_SIZE_SB8X8, 0, i, x->e_mbd.plane[0].pre[1].buf, @@ -1266,7 +1260,7 @@ static INLINE void mi_buf_restore(MACROBLOCK *x, struct buf_2d orig_src, MB_MODE_INFO *mbmi = &x->e_mbd.mode_info_context->mbmi; x->plane[0].src = orig_src; x->e_mbd.plane[0].pre[0] = orig_pre[0]; - if (mbmi->second_ref_frame) + if (mbmi->ref_frame[1]) x->e_mbd.plane[0].pre[1] = orig_pre[1]; } @@ -1326,16 +1320,16 @@ static void rd_check_segment_txsize(VP9_COMP *cpi, MACROBLOCK *x, int bestlabelyrate = 0; i = idy * 2 + idx; - frame_mv[ZEROMV][mbmi->ref_frame].as_int = 0; - frame_mv[ZEROMV][mbmi->second_ref_frame].as_int = 0; + frame_mv[ZEROMV][mbmi->ref_frame[0]].as_int = 0; + frame_mv[ZEROMV][mbmi->ref_frame[1]].as_int = 0; vp9_append_sub8x8_mvs_for_idx(&cpi->common, &x->e_mbd, - &frame_mv[NEARESTMV][mbmi->ref_frame], - &frame_mv[NEARMV][mbmi->ref_frame], + &frame_mv[NEARESTMV][mbmi->ref_frame[0]], + &frame_mv[NEARMV][mbmi->ref_frame[0]], i, 0); - if (mbmi->second_ref_frame > 0) + if (mbmi->ref_frame[1] > 0) vp9_append_sub8x8_mvs_for_idx(&cpi->common, &x->e_mbd, - &frame_mv[NEARESTMV][mbmi->second_ref_frame], - &frame_mv[NEARMV][mbmi->second_ref_frame], + &frame_mv[NEARESTMV][mbmi->ref_frame[1]], + &frame_mv[NEARMV][mbmi->ref_frame[1]], i, 1); // search for the best motion vector on this segment @@ -1353,7 +1347,7 @@ static void rd_check_segment_txsize(VP9_COMP *cpi, MACROBLOCK *x, vpx_memcpy(t_left_s, t_left, sizeof(t_left_s)); // motion search for newmv (single predictor case only) - if (mbmi->second_ref_frame <= 0 && this_mode == NEWMV) { + if (mbmi->ref_frame[1] <= 0 && this_mode == NEWMV) { int step_param = 0; int further_steps; int thissme, bestsme = INT_MAX; @@ -1420,14 +1414,14 @@ static void rd_check_segment_txsize(VP9_COMP *cpi, MACROBLOCK *x, &distortion, &sse); // safe motion search result for use in compound prediction - seg_mvs[i][mbmi->ref_frame].as_int = mode_mv[NEWMV].as_int; + seg_mvs[i][mbmi->ref_frame[0]].as_int = mode_mv[NEWMV].as_int; } // restore src pointers mi_buf_restore(x, orig_src, orig_pre); - } else if (mbmi->second_ref_frame > 0 && this_mode == NEWMV) { - if (seg_mvs[i][mbmi->second_ref_frame].as_int == INVALID_MV || - seg_mvs[i][mbmi->ref_frame ].as_int == INVALID_MV) + } else if (mbmi->ref_frame[1] > 0 && this_mode == NEWMV) { + if (seg_mvs[i][mbmi->ref_frame[1]].as_int == INVALID_MV || + seg_mvs[i][mbmi->ref_frame[0]].as_int == INVALID_MV) continue; // adjust src pointers @@ -1436,10 +1430,10 @@ static void rd_check_segment_txsize(VP9_COMP *cpi, MACROBLOCK *x, iterative_motion_search(cpi, x, bsize, frame_mv[this_mode], scaled_ref_frame, mi_row, mi_col, seg_mvs[i]); - seg_mvs[i][mbmi->ref_frame].as_int = - frame_mv[this_mode][mbmi->ref_frame].as_int; - seg_mvs[i][mbmi->second_ref_frame].as_int = - frame_mv[this_mode][mbmi->second_ref_frame].as_int; + seg_mvs[i][mbmi->ref_frame[0]].as_int = + frame_mv[this_mode][mbmi->ref_frame[0]].as_int; + seg_mvs[i][mbmi->ref_frame[1]].as_int = + frame_mv[this_mode][mbmi->ref_frame[1]].as_int; } // restore src pointers mi_buf_restore(x, orig_src, orig_pre); @@ -1457,7 +1451,7 @@ static void rd_check_segment_txsize(VP9_COMP *cpi, MACROBLOCK *x, ((mode_mv[this_mode].as_mv.col >> 3) > x->mv_col_max)) { continue; } - if (mbmi->second_ref_frame > 0 && + if (mbmi->ref_frame[1] > 0 && mv_check_bounds(x, &second_mode_mv[this_mode])) continue; @@ -1513,7 +1507,7 @@ static void rd_check_segment_txsize(VP9_COMP *cpi, MACROBLOCK *x, // store everything needed to come back to this!! for (i = 0; i < 4; i++) { bsi->mvs[i].as_mv = x->partition_info->bmi[i].mv.as_mv; - if (mbmi->second_ref_frame > 0) + if (mbmi->ref_frame[1] > 0) bsi->second_mvs[i].as_mv = x->partition_info->bmi[i].second_mv.as_mv; bsi->modes[i] = x->partition_info->bmi[i].mode; bsi->eobs[i] = best_eobs[i]; @@ -1551,7 +1545,7 @@ static int rd_pick_best_mbsegmentation(VP9_COMP *cpi, MACROBLOCK *x, /* set it to the best */ for (i = 0; i < 4; i++) { x->e_mbd.mode_info_context->bmi[i].as_mv[0].as_int = bsi.mvs[i].as_int; - if (mbmi->second_ref_frame > 0) + if (mbmi->ref_frame[1] > 0) x->e_mbd.mode_info_context->bmi[i].as_mv[1].as_int = bsi.second_mvs[i].as_int; x->e_mbd.plane[0].eobs[i] = bsi.eobs[i]; @@ -1563,14 +1557,14 @@ static int rd_pick_best_mbsegmentation(VP9_COMP *cpi, MACROBLOCK *x, for (i = 0; i < x->partition_info->count; i++) { x->partition_info->bmi[i].mode = bsi.modes[i]; x->partition_info->bmi[i].mv.as_mv = bsi.mvs[i].as_mv; - if (mbmi->second_ref_frame > 0) + if (mbmi->ref_frame[1] > 0) x->partition_info->bmi[i].second_mv.as_mv = bsi.second_mvs[i].as_mv; } /* * used to set mbmi->mv.as_int */ x->partition_info->bmi[3].mv.as_int = bsi.mvs[3].as_int; - if (mbmi->second_ref_frame > 0) + if (mbmi->ref_frame[1] > 0) x->partition_info->bmi[3].second_mv.as_int = bsi.second_mvs[3].as_int; *returntotrate = bsi.r; @@ -1627,77 +1621,15 @@ static void mv_pred(VP9_COMP *cpi, MACROBLOCK *x, x->mv_best_ref_index[ref_frame] = best_index; } -extern void vp9_calc_ref_probs(int *count, vp9_prob *probs); -static void estimate_curframe_refprobs(VP9_COMP *cpi, - vp9_prob mod_refprobs[3], - int pred_ref) { - int norm_cnt[MAX_REF_FRAMES]; - const int *const rfct = cpi->count_mb_ref_frame_usage; - int intra_count = rfct[INTRA_FRAME]; - int last_count = rfct[LAST_FRAME]; - int gf_count = rfct[GOLDEN_FRAME]; - int arf_count = rfct[ALTREF_FRAME]; - - // Work out modified reference frame probabilities to use where prediction - // of the reference frame fails - if (pred_ref == INTRA_FRAME) { - norm_cnt[0] = 0; - norm_cnt[1] = last_count; - norm_cnt[2] = gf_count; - norm_cnt[3] = arf_count; - vp9_calc_ref_probs(norm_cnt, mod_refprobs); - mod_refprobs[0] = 0; // This branch implicit - } else if (pred_ref == LAST_FRAME) { - norm_cnt[0] = intra_count; - norm_cnt[1] = 0; - norm_cnt[2] = gf_count; - norm_cnt[3] = arf_count; - vp9_calc_ref_probs(norm_cnt, mod_refprobs); - mod_refprobs[1] = 0; // This branch implicit - } else if (pred_ref == GOLDEN_FRAME) { - norm_cnt[0] = intra_count; - norm_cnt[1] = last_count; - norm_cnt[2] = 0; - norm_cnt[3] = arf_count; - vp9_calc_ref_probs(norm_cnt, mod_refprobs); - mod_refprobs[2] = 0; // This branch implicit - } else { - norm_cnt[0] = intra_count; - norm_cnt[1] = last_count; - norm_cnt[2] = gf_count; - norm_cnt[3] = 0; - vp9_calc_ref_probs(norm_cnt, mod_refprobs); - mod_refprobs[2] = 0; // This branch implicit - } -} - -static INLINE unsigned weighted_cost(vp9_prob *tab0, vp9_prob *tab1, - int idx, int val, int weight) { - unsigned cost0 = tab0[idx] ? vp9_cost_bit(tab0[idx], val) : 0; - unsigned cost1 = tab1[idx] ? vp9_cost_bit(tab1[idx], val) : 0; - // weight is 16-bit fixed point, so this basically calculates: - // 0.5 + weight * cost1 + (1.0 - weight) * cost0 - return (0x8000 + weight * cost1 + (0x10000 - weight) * cost0) >> 16; -} - static void estimate_ref_frame_costs(VP9_COMP *cpi, int segment_id, - unsigned int *ref_costs) { - VP9_COMMON *cm = &cpi->common; - MACROBLOCKD *xd = &cpi->mb.e_mbd; - vp9_prob *mod_refprobs; - - unsigned int cost; - int pred_ref; - int pred_flag; - int pred_ctx; - int i; - - vp9_prob pred_prob, new_pred_prob; - int seg_ref_active; + unsigned int *ref_costs_single, + unsigned int *ref_costs_comp, + vp9_prob *comp_mode_p) { + VP9_COMMON *const cm = &cpi->common; + MACROBLOCKD *const xd = &cpi->mb.e_mbd; + int seg_ref_active = vp9_segfeature_active(xd, segment_id, + SEG_LVL_REF_FRAME); int seg_ref_count = 0; - seg_ref_active = vp9_segfeature_active(xd, - segment_id, - SEG_LVL_REF_FRAME); if (seg_ref_active) { seg_ref_count = vp9_check_segref(xd, segment_id, INTRA_FRAME) + @@ -1706,56 +1638,56 @@ static void estimate_ref_frame_costs(VP9_COMP *cpi, int segment_id, vp9_check_segref(xd, segment_id, ALTREF_FRAME); } - // Get the predicted reference for this mb - pred_ref = vp9_get_pred_ref(cm, xd); - - // Get the context probability for the prediction flag (based on last frame) - pred_prob = vp9_get_pred_prob(cm, xd, PRED_REF); - - // Predict probability for current frame based on stats so far - pred_ctx = vp9_get_pred_context(cm, xd, PRED_REF); - new_pred_prob = get_binary_prob(cpi->ref_pred_count[pred_ctx][0], - cpi->ref_pred_count[pred_ctx][1]); - - // Get the set of probabilities to use if prediction fails - mod_refprobs = cm->mod_refprobs[pred_ref]; + if (seg_ref_active && seg_ref_count == 1) { + vpx_memset(ref_costs_single, 0, MAX_REF_FRAMES * sizeof(*ref_costs_single)); + vpx_memset(ref_costs_comp, 0, MAX_REF_FRAMES * sizeof(*ref_costs_comp)); + *comp_mode_p = 128; + } else { + vp9_prob intra_inter_p = vp9_get_pred_prob(cm, xd, PRED_INTRA_INTER); + vp9_prob comp_inter_p = 128; - // For each possible selected reference frame work out a cost. - for (i = 0; i < MAX_REF_FRAMES; i++) { - if (seg_ref_active && seg_ref_count == 1) { - cost = 0; + if (cm->comp_pred_mode == HYBRID_PREDICTION) { + comp_inter_p = vp9_get_pred_prob(cm, xd, PRED_COMP_INTER_INTER); + *comp_mode_p = comp_inter_p; } else { - pred_flag = (i == pred_ref); + *comp_mode_p = 128; + } - // Get the prediction for the current mb - cost = weighted_cost(&pred_prob, &new_pred_prob, 0, - pred_flag, cpi->seg0_progress); - if (cost > 1024) cost = 768; // i.e. account for 4 bits max. + ref_costs_single[INTRA_FRAME] = vp9_cost_bit(intra_inter_p, 0); - // for incorrectly predicted cases - if (!pred_flag) { - vp9_prob curframe_mod_refprobs[3]; + if (cm->comp_pred_mode != COMP_PREDICTION_ONLY) { + vp9_prob ref_single_p1 = vp9_get_pred_prob(cm, xd, PRED_SINGLE_REF_P1); + vp9_prob ref_single_p2 = vp9_get_pred_prob(cm, xd, PRED_SINGLE_REF_P2); + unsigned int base_cost = vp9_cost_bit(intra_inter_p, 1); - if (cpi->seg0_progress) { - estimate_curframe_refprobs(cpi, curframe_mod_refprobs, pred_ref); - } else { - vpx_memset(curframe_mod_refprobs, 0, sizeof(curframe_mod_refprobs)); - } + if (cm->comp_pred_mode == HYBRID_PREDICTION) + base_cost += vp9_cost_bit(comp_inter_p, 0); - cost += weighted_cost(mod_refprobs, curframe_mod_refprobs, 0, - (i != INTRA_FRAME), cpi->seg0_progress); - if (i != INTRA_FRAME) { - cost += weighted_cost(mod_refprobs, curframe_mod_refprobs, 1, - (i != LAST_FRAME), cpi->seg0_progress); - if (i != LAST_FRAME) { - cost += weighted_cost(mod_refprobs, curframe_mod_refprobs, 2, - (i != GOLDEN_FRAME), cpi->seg0_progress); - } - } - } + ref_costs_single[LAST_FRAME] = ref_costs_single[GOLDEN_FRAME] = + ref_costs_single[ALTREF_FRAME] = base_cost; + ref_costs_single[LAST_FRAME] += vp9_cost_bit(ref_single_p1, 0); + ref_costs_single[GOLDEN_FRAME] += vp9_cost_bit(ref_single_p1, 1); + ref_costs_single[ALTREF_FRAME] += vp9_cost_bit(ref_single_p1, 1); + ref_costs_single[GOLDEN_FRAME] += vp9_cost_bit(ref_single_p2, 0); + ref_costs_single[ALTREF_FRAME] += vp9_cost_bit(ref_single_p2, 1); + } else { + ref_costs_single[LAST_FRAME] = 512; + ref_costs_single[GOLDEN_FRAME] = 512; + ref_costs_single[ALTREF_FRAME] = 512; } + if (cm->comp_pred_mode != SINGLE_PREDICTION_ONLY) { + vp9_prob ref_comp_p = vp9_get_pred_prob(cm, xd, PRED_COMP_REF_P); + unsigned int base_cost = vp9_cost_bit(intra_inter_p, 1); - ref_costs[i] = cost; + if (cm->comp_pred_mode == HYBRID_PREDICTION) + base_cost += vp9_cost_bit(comp_inter_p, 1); + + ref_costs_comp[LAST_FRAME] = base_cost + vp9_cost_bit(ref_comp_p, 0); + ref_costs_comp[GOLDEN_FRAME] = base_cost + vp9_cost_bit(ref_comp_p, 1); + } else { + ref_costs_comp[LAST_FRAME] = 512; + ref_costs_comp[GOLDEN_FRAME] = 512; + } } } @@ -1959,8 +1891,8 @@ static void iterative_motion_search(VP9_COMP *cpi, MACROBLOCK *x, int pw = 4 << b_width_log2(bsize), ph = 4 << b_height_log2(bsize); MACROBLOCKD *xd = &x->e_mbd; MB_MODE_INFO *mbmi = &xd->mode_info_context->mbmi; - int refs[2] = { mbmi->ref_frame, - (mbmi->second_ref_frame < 0 ? 0 : mbmi->second_ref_frame) }; + int refs[2] = { mbmi->ref_frame[0], + (mbmi->ref_frame[1] < 0 ? 0 : mbmi->ref_frame[1]) }; int_mv ref_mv[2]; const enum BlockSize block_size = get_plane_block_size(bsize, &xd->plane[0]); int ite; @@ -2102,7 +2034,6 @@ static int64_t handle_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, BLOCK_SIZE_TYPE bsize, int64_t txfm_cache[], int *rate2, int *distortion, int *skippable, - int *compmode_cost, int *rate_y, int *distortion_y, int *rate_uv, int *distortion_uv, int *mode_excluded, int *disable_skip, @@ -2119,12 +2050,12 @@ static int64_t handle_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, const enum BlockSize uv_block_size = get_plane_block_size(bsize, &xd->plane[1]); MB_MODE_INFO *mbmi = &xd->mode_info_context->mbmi; - const int is_comp_pred = (mbmi->second_ref_frame > 0); + const int is_comp_pred = (mbmi->ref_frame[1] > 0); const int num_refs = is_comp_pred ? 2 : 1; const int this_mode = mbmi->mode; int i; - int refs[2] = { mbmi->ref_frame, - (mbmi->second_ref_frame < 0 ? 0 : mbmi->second_ref_frame) }; + int refs[2] = { mbmi->ref_frame[0], + (mbmi->ref_frame[1] < 0 ? 0 : mbmi->ref_frame[1]) }; int_mv cur_mv[2]; int_mv ref_mv[2]; int64_t this_rd = 0; @@ -2263,10 +2194,8 @@ static int64_t handle_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, * are only three options: Last/Golden, ARF/Last or Golden/ARF, or in other * words if you present them in that order, the second one is always known * if the first is known */ - *compmode_cost = vp9_cost_bit(vp9_get_pred_prob(cm, xd, PRED_COMP), - is_comp_pred); *rate2 += vp9_cost_mv_ref(cpi, this_mode, - mbmi->mb_mode_context[mbmi->ref_frame]); + mbmi->mb_mode_context[mbmi->ref_frame[0]]); pred_exists = 0; interpolating_intpel_seen = 0; @@ -2460,7 +2389,7 @@ void vp9_rd_pick_intra_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, vpx_memset(&txfm_cache,0,sizeof(txfm_cache)); ctx->skip = 0; xd->mode_info_context->mbmi.mode = DC_PRED; - xd->mode_info_context->mbmi.ref_frame = INTRA_FRAME; + xd->mode_info_context->mbmi.ref_frame[0] = INTRA_FRAME; err = rd_pick_intra_sby_mode(cpi, x, &rate_y, &rate_y_tokenonly, &dist_y, &y_skip, bsize, txfm_cache); mode = xd->mode_info_context->mbmi.mode; @@ -2513,7 +2442,7 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, const enum BlockSize block_size = get_plane_block_size(bsize, &xd->plane[0]); MB_PREDICTION_MODE this_mode; MB_PREDICTION_MODE best_mode = DC_PRED; - MV_REFERENCE_FRAME ref_frame, second_ref = INTRA_FRAME; + MV_REFERENCE_FRAME ref_frame; unsigned char segment_id = xd->mode_info_context->mbmi.segment_id; int comp_pred, i; int_mv frame_mv[MB_MODE_COUNT][MAX_REF_FRAMES]; @@ -2533,7 +2462,8 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, MB_MODE_INFO best_mbmode; int j; int mode_index, best_mode_index = 0; - unsigned int ref_costs[MAX_REF_FRAMES]; + unsigned int ref_costs_single[MAX_REF_FRAMES], ref_costs_comp[MAX_REF_FRAMES]; + vp9_prob comp_mode_p; int64_t best_overall_rd = INT64_MAX; INTERPOLATIONFILTERTYPE best_filter = SWITCHABLE; INTERPOLATIONFILTERTYPE tmp_best_filter = SWITCHABLE; @@ -2566,7 +2496,8 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, ctx->modes_with_high_error = 0; xd->mode_info_context->mbmi.segment_id = segment_id; - estimate_ref_frame_costs(cpi, segment_id, ref_costs); + estimate_ref_frame_costs(cpi, segment_id, ref_costs_single, ref_costs_comp, + &comp_mode_p); vpx_memset(&best_mbmode, 0, sizeof(best_mbmode)); vpx_memset(&single_newmv, 0, sizeof(single_newmv)); @@ -2619,7 +2550,7 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, if (cpi->speed == 0 || (cpi->speed > 0 && (ref_frame_mask & (1 << INTRA_FRAME)))) { mbmi->mode = DC_PRED; - mbmi->ref_frame = INTRA_FRAME; + mbmi->ref_frame[0] = INTRA_FRAME; for (i = 0; i <= (bsize < BLOCK_SIZE_MB16X16 ? TX_4X4 : (bsize < BLOCK_SIZE_SB32X32 ? TX_8X8 : (bsize < BLOCK_SIZE_SB64X64 ? TX_16X16 : TX_32X32))); @@ -2637,7 +2568,6 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, int mode_excluded = 0; int64_t this_rd = INT64_MAX; int disable_skip = 0; - int other_cost = 0; int compmode_cost = 0; int rate2 = 0, rate_y = 0, rate_uv = 0; int distortion2 = 0, distortion_y = 0, distortion_uv = 0; @@ -2672,39 +2602,39 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, } } - mbmi->ref_frame = ref_frame; - mbmi->second_ref_frame = vp9_mode_order[mode_index].second_ref_frame; + mbmi->ref_frame[0] = ref_frame; + mbmi->ref_frame[1] = vp9_mode_order[mode_index].second_ref_frame; if (!(ref_frame == INTRA_FRAME || (cpi->ref_frame_flags & flag_list[ref_frame]))) { continue; } - if (!(mbmi->second_ref_frame == NONE - || (cpi->ref_frame_flags & flag_list[mbmi->second_ref_frame]))) { + if (!(mbmi->ref_frame[1] == NONE + || (cpi->ref_frame_flags & flag_list[mbmi->ref_frame[1]]))) { continue; } // TODO(jingning, jkoleszar): scaling reference frame not supported for // SPLITMV. - if (mbmi->ref_frame > 0 && - (scale_factor[mbmi->ref_frame].x_num != - scale_factor[mbmi->ref_frame].x_den || - scale_factor[mbmi->ref_frame].y_num != - scale_factor[mbmi->ref_frame].y_den) && + if (mbmi->ref_frame[0] > 0 && + (scale_factor[mbmi->ref_frame[0]].x_num != + scale_factor[mbmi->ref_frame[0]].x_den || + scale_factor[mbmi->ref_frame[0]].y_num != + scale_factor[mbmi->ref_frame[0]].y_den) && this_mode == SPLITMV) continue; - if (mbmi->second_ref_frame > 0 && - (scale_factor[mbmi->second_ref_frame].x_num != - scale_factor[mbmi->second_ref_frame].x_den || - scale_factor[mbmi->second_ref_frame].y_num != - scale_factor[mbmi->second_ref_frame].y_den) && + if (mbmi->ref_frame[1] > 0 && + (scale_factor[mbmi->ref_frame[1]].x_num != + scale_factor[mbmi->ref_frame[1]].x_den || + scale_factor[mbmi->ref_frame[1]].y_num != + scale_factor[mbmi->ref_frame[1]].y_den) && this_mode == SPLITMV) continue; - set_scale_factors(xd, mbmi->ref_frame, mbmi->second_ref_frame, + set_scale_factors(xd, mbmi->ref_frame[0], mbmi->ref_frame[1], scale_factor); - comp_pred = mbmi->second_ref_frame > INTRA_FRAME; + comp_pred = mbmi->ref_frame[1] > INTRA_FRAME; mbmi->mode = this_mode; mbmi->uv_mode = DC_PRED; @@ -2721,24 +2651,18 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, continue; if (comp_pred) { - if (ref_frame == ALTREF_FRAME) { - second_ref = LAST_FRAME; - } else { - second_ref = ref_frame + 1; - } - if (!(cpi->ref_frame_flags & flag_list[second_ref])) + if (!(cpi->ref_frame_flags & flag_list[mbmi->ref_frame[1]])) continue; - mbmi->second_ref_frame = second_ref; - set_scale_factors(xd, mbmi->ref_frame, mbmi->second_ref_frame, + set_scale_factors(xd, mbmi->ref_frame[0], mbmi->ref_frame[1], scale_factor); mode_excluded = mode_excluded ? mode_excluded : cm->comp_pred_mode == SINGLE_PREDICTION_ONLY; } else { - // mbmi->second_ref_frame = vp9_mode_order[mode_index].second_ref_frame; + // mbmi->ref_frame[1] = vp9_mode_order[mode_index].ref_frame[1]; if (ref_frame != INTRA_FRAME) { - if (mbmi->second_ref_frame != INTRA_FRAME) + if (mbmi->ref_frame[1] != INTRA_FRAME) mode_excluded = mode_excluded ? mode_excluded : cm->comp_pred_mode == COMP_PREDICTION_ONLY; @@ -2749,7 +2673,7 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, for (i = 0; i < MAX_MB_PLANE; i++) { xd->plane[i].pre[0] = yv12_mb[ref_frame][i]; if (comp_pred) - xd->plane[i].pre[1] = yv12_mb[second_ref][i]; + xd->plane[i].pre[1] = yv12_mb[mbmi->ref_frame[1]][i]; } // If the segment reference frame feature is enabled.... @@ -2826,7 +2750,7 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, rate2 += intra_cost_penalty; distortion2 = distortion_y + distortion_uv; } else if (this_mode == SPLITMV) { - const int is_comp_pred = mbmi->second_ref_frame > 0; + const int is_comp_pred = mbmi->ref_frame[1] > 0; int rate, distortion; int64_t this_rd_thresh; int64_t tmp_rd, tmp_best_rd = INT64_MAX, tmp_best_rdu = INT64_MAX; @@ -2834,17 +2758,17 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, int tmp_best_distortion = INT_MAX, tmp_best_skippable = 0; int switchable_filter_index; int_mv *second_ref = is_comp_pred ? - &mbmi->ref_mvs[mbmi->second_ref_frame][0] : NULL; + &mbmi->ref_mvs[mbmi->ref_frame[1]][0] : NULL; union b_mode_info tmp_best_bmodes[16]; MB_MODE_INFO tmp_best_mbmode; PARTITION_INFO tmp_best_partition; int pred_exists = 0; int uv_skippable; - this_rd_thresh = (mbmi->ref_frame == LAST_FRAME) ? + this_rd_thresh = (mbmi->ref_frame[0] == LAST_FRAME) ? cpi->rd_threshes[bsize][THR_NEWMV] : cpi->rd_threshes[bsize][THR_NEWA]; - this_rd_thresh = (mbmi->ref_frame == GOLDEN_FRAME) ? + this_rd_thresh = (mbmi->ref_frame[0] == GOLDEN_FRAME) ? cpi->rd_threshes[bsize][THR_NEWG] : this_rd_thresh; xd->mode_info_context->mbmi.txfm_size = TX_4X4; @@ -2857,12 +2781,12 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, vp9_setup_interp_filters(xd, mbmi->interp_filter, &cpi->common); tmp_rd = rd_pick_best_mbsegmentation(cpi, x, - &mbmi->ref_mvs[mbmi->ref_frame][0], - second_ref, INT64_MAX, - &rate, &rate_y, &distortion, - &skippable, - (int)this_rd_thresh, seg_mvs, - mi_row, mi_col); + &mbmi->ref_mvs[mbmi->ref_frame[0]][0], + second_ref, INT64_MAX, + &rate, &rate_y, &distortion, + &skippable, + (int)this_rd_thresh, seg_mvs, + mi_row, mi_col); if (cpi->common.mcomp_filter_type == SWITCHABLE) { const int rs = get_switchable_rate(cm, x); tmp_rd += RDCOST(x->rdmult, x->rddiv, rs, 0); @@ -2895,12 +2819,12 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, // Handles the special case when a filter that is not in the // switchable list (bilinear, 6-tap) is indicated at the frame level tmp_rd = rd_pick_best_mbsegmentation(cpi, x, - &mbmi->ref_mvs[mbmi->ref_frame][0], - second_ref, INT64_MAX, - &rate, &rate_y, &distortion, - &skippable, - (int)this_rd_thresh, seg_mvs, - mi_row, mi_col); + &mbmi->ref_mvs[mbmi->ref_frame[0]][0], + second_ref, INT64_MAX, + &rate, &rate_y, &distortion, + &skippable, + (int)this_rd_thresh, seg_mvs, + mi_row, mi_col); } else { if (cpi->common.mcomp_filter_type == SWITCHABLE) { int rs = get_switchable_rate(cm, x); @@ -2945,24 +2869,24 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, mode_excluded = cpi->common.comp_pred_mode == COMP_PREDICTION_ONLY; } - compmode_cost = - vp9_cost_bit(vp9_get_pred_prob(cm, xd, PRED_COMP), is_comp_pred); + compmode_cost = vp9_cost_bit(comp_mode_p, is_comp_pred); } else { YV12_BUFFER_CONFIG *scaled_ref_frame[2] = {NULL, NULL}; - int fb = get_ref_frame_idx(cpi, mbmi->ref_frame); + int fb = get_ref_frame_idx(cpi, mbmi->ref_frame[0]); if (cpi->scaled_ref_idx[fb] != cm->ref_frame_map[fb]) scaled_ref_frame[0] = &cm->yv12_fb[cpi->scaled_ref_idx[fb]]; if (comp_pred) { - fb = get_ref_frame_idx(cpi, mbmi->second_ref_frame); + fb = get_ref_frame_idx(cpi, mbmi->ref_frame[1]); if (cpi->scaled_ref_idx[fb] != cm->ref_frame_map[fb]) scaled_ref_frame[1] = &cm->yv12_fb[cpi->scaled_ref_idx[fb]]; } + compmode_cost = vp9_cost_bit(comp_mode_p, + mbmi->ref_frame[1] > INTRA_FRAME); this_rd = handle_inter_mode(cpi, x, bsize, txfm_cache, &rate2, &distortion2, &skippable, - &compmode_cost, &rate_y, &distortion_y, &rate_uv, &distortion_uv, &mode_excluded, &disable_skip, @@ -2979,7 +2903,11 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, // Estimate the reference frame signaling cost and add it // to the rolling cost variable. - rate2 += ref_costs[xd->mode_info_context->mbmi.ref_frame]; + if (mbmi->ref_frame[1] > INTRA_FRAME) { + rate2 += ref_costs_comp[mbmi->ref_frame[0]]; + } else { + rate2 += ref_costs_single[mbmi->ref_frame[0]]; + } if (!disable_skip) { // Test for the condition where skip block will be activated @@ -3007,7 +2935,6 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, if (skip_prob) { prob_skip_cost = vp9_cost_bit(skip_prob, 1); rate2 += prob_skip_cost; - other_cost += prob_skip_cost; } } } else if (mb_skip_allowed) { @@ -3015,7 +2942,6 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, int prob_skip_cost = vp9_cost_bit(vp9_get_pred_prob(cm, xd, PRED_MBSKIP), 0); rate2 += prob_skip_cost; - other_cost += prob_skip_cost; } // Calculate the final RD estimate for this mode. @@ -3024,14 +2950,14 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, #if 0 // Keep record of best intra distortion - if ((xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME) && + if ((xd->mode_info_context->mbmi.ref_frame[0] == INTRA_FRAME) && (this_rd < best_intra_rd)) { best_intra_rd = this_rd; *returnintra = distortion2; } #endif - if (!disable_skip && mbmi->ref_frame == INTRA_FRAME) + if (!disable_skip && mbmi->ref_frame[0] == INTRA_FRAME) for (i = 0; i < NB_PREDICTION_TYPES; ++i) best_pred_rd[i] = MIN(best_pred_rd[i], this_rd); @@ -3047,9 +2973,9 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, || distortion2 < mode_distortions[this_mode]) { mode_distortions[this_mode] = distortion2; } - if (frame_distortions[mbmi->ref_frame] == -1 - || distortion2 < frame_distortions[mbmi->ref_frame]) { - frame_distortions[mbmi->ref_frame] = distortion2; + if (frame_distortions[mbmi->ref_frame[0]] == -1 + || distortion2 < frame_distortions[mbmi->ref_frame[0]]) { + frame_distortions[mbmi->ref_frame[0]] = distortion2; } } @@ -3064,7 +2990,6 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, mbmi->mv[0].as_int = 0; } - other_cost += ref_costs[xd->mode_info_context->mbmi.ref_frame]; *returnrate = rate2; *returndistortion = distortion2; best_rd = this_rd; @@ -3101,7 +3026,7 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, } /* keep record of best compound/single-only prediction */ - if (!disable_skip && mbmi->ref_frame != INTRA_FRAME) { + if (!disable_skip && mbmi->ref_frame[0] != INTRA_FRAME) { int single_rd, hybrid_rd, single_rate, hybrid_rate; if (cpi->common.comp_pred_mode == HYBRID_PREDICTION) { @@ -3115,10 +3040,10 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, single_rd = RDCOST(x->rdmult, x->rddiv, single_rate, distortion2); hybrid_rd = RDCOST(x->rdmult, x->rddiv, hybrid_rate, distortion2); - if (mbmi->second_ref_frame <= INTRA_FRAME && + if (mbmi->ref_frame[1] <= INTRA_FRAME && single_rd < best_pred_rd[SINGLE_PREDICTION_ONLY]) { best_pred_rd[SINGLE_PREDICTION_ONLY] = single_rd; - } else if (mbmi->second_ref_frame > INTRA_FRAME && + } else if (mbmi->ref_frame[1] > INTRA_FRAME && single_rd < best_pred_rd[COMP_PREDICTION_ONLY]) { best_pred_rd[COMP_PREDICTION_ONLY] = single_rd; } @@ -3179,7 +3104,7 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, assert((cm->mcomp_filter_type == SWITCHABLE) || (cm->mcomp_filter_type == best_mbmode.interp_filter) || - (best_mbmode.ref_frame == INTRA_FRAME)); + (best_mbmode.ref_frame[0] == INTRA_FRAME)); // Accumulate filter usage stats // TODO(agrange): Use RD criteria to select interpolation filter mode. @@ -3227,11 +3152,11 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, if (!vp9_segfeature_active(xd, segment_id, SEG_LVL_REF_FRAME) && cpi->is_src_frame_alt_ref && (cpi->oxcf.arnr_max_frames == 0) && - (best_mbmode.mode != ZEROMV || best_mbmode.ref_frame != ALTREF_FRAME) + (best_mbmode.mode != ZEROMV || best_mbmode.ref_frame[0] != ALTREF_FRAME) && bsize >= BLOCK_SIZE_SB8X8) { mbmi->mode = ZEROMV; - mbmi->ref_frame = ALTREF_FRAME; - mbmi->second_ref_frame = NONE; + mbmi->ref_frame[0] = ALTREF_FRAME; + mbmi->ref_frame[1] = NONE; mbmi->mv[0].as_int = 0; mbmi->uv_mode = DC_PRED; mbmi->mb_skip_coeff = 1; @@ -3251,19 +3176,19 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, // macroblock modes *mbmi = best_mbmode; - if (best_mbmode.ref_frame == INTRA_FRAME && + if (best_mbmode.ref_frame[0] == INTRA_FRAME && best_mbmode.sb_type < BLOCK_SIZE_SB8X8) { for (i = 0; i < 4; i++) xd->mode_info_context->bmi[i].as_mode = best_bmodes[i].as_mode; } - if (best_mbmode.ref_frame != INTRA_FRAME && + if (best_mbmode.ref_frame[0] != INTRA_FRAME && best_mbmode.sb_type < BLOCK_SIZE_SB8X8) { for (i = 0; i < 4; i++) xd->mode_info_context->bmi[i].as_mv[0].as_int = best_bmodes[i].as_mv[0].as_int; - if (mbmi->second_ref_frame > 0) + if (mbmi->ref_frame[1] > 0) for (i = 0; i < 4; i++) xd->mode_info_context->bmi[i].as_mv[1].as_int = best_bmodes[i].as_mv[1].as_int; @@ -3293,13 +3218,13 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, } end: - set_scale_factors(xd, mbmi->ref_frame, mbmi->second_ref_frame, + set_scale_factors(xd, mbmi->ref_frame[0], mbmi->ref_frame[1], scale_factor); store_coding_context(x, ctx, best_mode_index, &best_partition, - &mbmi->ref_mvs[mbmi->ref_frame][0], - &mbmi->ref_mvs[mbmi->second_ref_frame < 0 ? 0 : - mbmi->second_ref_frame][0], + &mbmi->ref_mvs[mbmi->ref_frame[0]][0], + &mbmi->ref_mvs[mbmi->ref_frame[1] < 0 ? 0 : + mbmi->ref_frame[1]][0], best_pred_diff, best_txfm_diff); return best_rd; diff --git a/vp9/encoder/vp9_tokenize.c b/vp9/encoder/vp9_tokenize.c index b307c54b0..cb05219dd 100644 --- a/vp9/encoder/vp9_tokenize.c +++ b/vp9/encoder/vp9_tokenize.c @@ -130,7 +130,7 @@ static void tokenize_b(int plane, int block, BLOCK_SIZE_TYPE bsize, const int *scan, *nb; vp9_coeff_count *counts; vp9_coeff_probs_model *coef_probs; - const int ref = mbmi->ref_frame != INTRA_FRAME; + const int ref = mbmi->ref_frame[0] != INTRA_FRAME; ENTROPY_CONTEXT above_ec, left_ec; uint8_t token_cache[1024]; TX_TYPE tx_type = DCT_DCT; |