From a3392d57180756bcc01b1c52b40afc1767bf1e52 Mon Sep 17 00:00:00 2001 From: Paul Wilkins Date: Tue, 27 Mar 2012 13:01:34 +0100 Subject: [PATCH] T8x8 zbin and rate control changes. Some adjustments to zbin for t8x8. Changes to rules for sizing forced key frames. Some extra stats output in tmp.stt. Approximate gain on YT-hd set 0.5% There are still issues in sizing key frames and gf/arf frames when the image is largely static. These in part relate to problems with cost estimates in the recode loop. Change-Id: I6f0159dc8a8faeab4115a19c668d442491619a68 --- vp8/encoder/block.h | 4 +- vp8/encoder/onyx_if.c | 34 ++++++++---- vp8/encoder/onyx_int.h | 9 ++-- vp8/encoder/quantize.c | 120 ++++++++++++++++++++++++++--------------- vp8/encoder/rdopt.c | 15 +++--- 5 files changed, 118 insertions(+), 64 deletions(-) diff --git a/vp8/encoder/block.h b/vp8/encoder/block.h index bc40af5ee..83dddf9fa 100644 --- a/vp8/encoder/block.h +++ b/vp8/encoder/block.h @@ -33,10 +33,12 @@ typedef struct // 16 Y blocks, 4 U blocks, 4 V blocks each with 16 entries short *quant; - short *quant_fast; + short *quant_fast; // fast quant deprecated for now unsigned char *quant_shift; short *zbin; + short *zbin_8x8; short *zrun_zbin_boost; + short *zrun_zbin_boost_8x8; short *round; // Zbin Over Quant value diff --git a/vp8/encoder/onyx_if.c b/vp8/encoder/onyx_if.c index fb13c867b..117d3bdc4 100644 --- a/vp8/encoder/onyx_if.c +++ b/vp8/encoder/onyx_if.c @@ -2890,6 +2890,8 @@ static void encode_frame_to_data_rate int overshoot_seen = FALSE; int undershoot_seen = FALSE; + int loop_size_estimate = 0; + // Clear down mmx registers to allow floating point in what follows vp8_clear_system_state(); @@ -3320,9 +3322,12 @@ static void encode_frame_to_data_rate // Prevent possible divide by zero error below for perfect KF kf_err += (!kf_err); - // The key frame is not good enough - if ( (kf_err > high_err_target) && - (cpi->projected_frame_size <= frame_over_shoot_limit) ) + // The key frame is not good enough or we can afford + // to make it better without undue risk of popping. + if ( ( (kf_err > high_err_target) && + (cpi->projected_frame_size <= frame_over_shoot_limit) ) || + ( (kf_err > low_err_target) && + (cpi->projected_frame_size <= frame_under_shoot_limit) ) ) { // Lower q_high q_high = (Q > q_low) ? (Q - 1) : q_low; @@ -3612,6 +3617,9 @@ static void encode_frame_to_data_rate * needed in motion search besides loopfilter */ cm->last_frame_type = cm->frame_type; + // Keep a copy of the size estimate used in the loop + loop_size_estimate = cpi->projected_frame_size; + // Update rate control heuristics cpi->total_byte_count += (*size); cpi->projected_frame_size = (*size) << 3; @@ -3747,16 +3755,21 @@ static void encode_frame_to_data_rate #if 0 && CONFIG_INTERNAL_STATS { FILE *f = fopen("tmp.stt", "a"); + int recon_err; vp8_clear_system_state(); //__asm emms; + recon_err = vp8_calc_ss_err(cpi->Source, + &cm->yv12_fb[cm->new_fb_idx], + IF_RTCD(&cpi->rtcd.variance)); + if (cpi->twopass.total_left_stats->coded_error != 0.0) - fprintf(f, "%10d %10d %10d %10d %10d %10d %10d" + fprintf(f, "%10d %10d %10d %10d %10d %10d %10d %10d" "%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f" "%6d %5d %5d %5d %8d %8.2f %10d %10.3f" - "%10.3f %8d\n", + "%10.3f %8d %10d\n", cpi->common.current_video_frame, cpi->this_frame_target, - cpi->projected_frame_size, + cpi->projected_frame_size, loop_size_estimate, (cpi->projected_frame_size - cpi->this_frame_target), (int)cpi->total_target_vs_actual, (cpi->oxcf.starting_buffer_level-cpi->bits_off_target), @@ -3777,14 +3790,15 @@ static void encode_frame_to_data_rate cpi->twopass.total_left_stats->coded_error, (double)cpi->twopass.bits_left / cpi->twopass.total_left_stats->coded_error, - cpi->tot_recode_hits); + cpi->tot_recode_hits, recon_err); else - fprintf(f, "%10d %10d %10d %10d %10d %10d %10d" + fprintf(f, "%10d %10d %10d %10d %10d %10d %10d %10d" "%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f" "%6d %5d %5d %5d %8d %8.2f %10d %10.3f" - "%8d\n", + "%8d %10d\n", cpi->common.current_video_frame, cpi->this_frame_target, cpi->projected_frame_size, + loop_size_estimate, (cpi->projected_frame_size - cpi->this_frame_target), (int)cpi->total_target_vs_actual, (cpi->oxcf.starting_buffer_level-cpi->bits_off_target), @@ -3803,7 +3817,7 @@ static void encode_frame_to_data_rate cpi->twopass.est_max_qcorrection_factor, (int)cpi->twopass.bits_left, cpi->twopass.total_left_stats->coded_error, - cpi->tot_recode_hits); + cpi->tot_recode_hits, recon_err); fclose(f); diff --git a/vp8/encoder/onyx_int.h b/vp8/encoder/onyx_int.h index 807f0a5bc..e2788c0ef 100644 --- a/vp8/encoder/onyx_int.h +++ b/vp8/encoder/onyx_int.h @@ -301,10 +301,13 @@ typedef struct VP8_COMP DECLARE_ALIGNED(16, short, zrun_zbin_boost_y1[QINDEX_RANGE][16]); DECLARE_ALIGNED(16, short, zrun_zbin_boost_y2[QINDEX_RANGE][16]); DECLARE_ALIGNED(16, short, zrun_zbin_boost_uv[QINDEX_RANGE][16]); - DECLARE_ALIGNED(16, short, Y1quant_fast[QINDEX_RANGE][16]); - DECLARE_ALIGNED(16, short, Y2quant_fast[QINDEX_RANGE][16]); - DECLARE_ALIGNED(16, short, UVquant_fast[QINDEX_RANGE][16]); + DECLARE_ALIGNED(64, short, Y1zbin_8x8[QINDEX_RANGE][64]); + DECLARE_ALIGNED(64, short, Y2zbin_8x8[QINDEX_RANGE][64]); + DECLARE_ALIGNED(64, short, UVzbin_8x8[QINDEX_RANGE][64]); + DECLARE_ALIGNED(64, short, zrun_zbin_boost_y1_8x8[QINDEX_RANGE][64]); + DECLARE_ALIGNED(64, short, zrun_zbin_boost_y2_8x8[QINDEX_RANGE][64]); + DECLARE_ALIGNED(64, short, zrun_zbin_boost_uv_8x8[QINDEX_RANGE][64]); MACROBLOCK mb; VP8_COMMON common; diff --git a/vp8/encoder/quantize.c b/vp8/encoder/quantize.c index 91b48eae7..37e5b6d37 100644 --- a/vp8/encoder/quantize.c +++ b/vp8/encoder/quantize.c @@ -49,8 +49,8 @@ void vp8_regular_quantize_b(BLOCK *b, BLOCKD *d) z = coeff_ptr[rc]; zbin = zbin_ptr[rc] + *zbin_boost_ptr + zbin_oq_value; - zbin_boost_ptr ++; + sz = (z >> 31); // sign of z x = (z ^ sz) - sz; // x = abs(z) @@ -117,6 +117,7 @@ void vp8_regular_quantize_b_2x2(BLOCK *b, BLOCKD *d) int zbin; int x, y, z, sz; short *zbin_boost_ptr = b->zrun_zbin_boost; + int zbin_zrun_index = 0; short *coeff_ptr = b->coeff; short *zbin_ptr = b->zbin; short *round_ptr = b->round; @@ -137,29 +138,26 @@ void vp8_regular_quantize_b_2x2(BLOCK *b, BLOCKD *d) rc = vp8_default_zig_zag1d[i]; z = coeff_ptr[rc]; - //zbin = (zbin_ptr[rc] + *zbin_boost_ptr + zbin_oq_value)/q2nd; + zbin_boost_ptr = &b->zrun_zbin_boost[zbin_zrun_index]; + zbin_zrun_index += 4; zbin = (zbin_ptr[rc] + *zbin_boost_ptr + zbin_oq_value); - zbin_boost_ptr ++; - sz = (z >> 31); // sign of z - x = (z ^ sz) - sz; // x = abs(z) + sz = (z >> 31); // sign of z + x = (z ^ sz) - sz; // x = abs(z) if (x >= zbin) { - //x += (round_ptr[rc]/q2nd); x += (round_ptr[rc]); y = ((int)((int)(x * quant_ptr[rc]) >> 16) + x) >> quant_shift_ptr[rc]; // quantize (x) x = (y ^ sz) - sz; // get the sign back - qcoeff_ptr[rc] = x; // write to destination - //dqcoeff_ptr[rc] = x * dequant_ptr[rc]/q2nd; // dequantized value - dqcoeff_ptr[rc] = x * dequant_ptr[rc]; // dequantized value - + qcoeff_ptr[rc] = x; // write to destination + dqcoeff_ptr[rc] = x * dequant_ptr[rc]; // dequantized value if (y) { - eob = i; // last nonzero coeffs - zbin_boost_ptr = &b->zrun_zbin_boost[0]; // reset zero runlength + eob = i; // last nonzero coeffs + zbin_zrun_index = 0; } } } @@ -172,9 +170,9 @@ void vp8_regular_quantize_b_8x8(BLOCK *b, BLOCKD *d) int i, rc, eob; int zbin; int x, y, z, sz; - short *zbin_boost_ptr = b->zrun_zbin_boost; + short *zbin_boost_ptr = b->zrun_zbin_boost_8x8; short *coeff_ptr = b->coeff; - short *zbin_ptr = b->zbin; + short *zbin_ptr = b->zbin_8x8; short *round_ptr = b->round; short *quant_ptr = b->quant; unsigned char *quant_shift_ptr = b->quant_shift; @@ -182,7 +180,6 @@ void vp8_regular_quantize_b_8x8(BLOCK *b, BLOCKD *d) short *dqcoeff_ptr = d->dqcoeff; short *dequant_ptr = d->dequant; short zbin_oq_value = b->zbin_extra; - //double q1st = 2; vpx_memset(qcoeff_ptr, 0, 64*sizeof(short)); vpx_memset(dqcoeff_ptr, 0, 64*sizeof(short)); @@ -191,36 +188,28 @@ void vp8_regular_quantize_b_8x8(BLOCK *b, BLOCKD *d) for (i = 0; i < b->eob_max_offset_8x8; i++) { - rc = vp8_default_zig_zag1d_8x8[i]; z = coeff_ptr[rc]; - //zbin = (zbin_ptr[rc!=0] + *zbin_boost_ptr + zbin_oq_value)/q1st; zbin = (zbin_ptr[rc!=0] + *zbin_boost_ptr + zbin_oq_value); - //TODO: 8x8 zbin boost needs be done properly - if(zbin_boost_ptr < &b->zrun_zbin_boost[15]) - zbin_boost_ptr ++; + zbin_boost_ptr ++; - sz = (z >> 31); // sign of z - x = (z ^ sz) - sz; // x = abs(z) + sz = (z >> 31); // sign of z + x = (z ^ sz) - sz; // x = abs(z) if (x >= zbin) { - //x += (round_ptr[rc!=0]/q1st); - //y = ((int)(((int)(x * quant_ptr[rc!=0] * q1st) >> 16) + x)) - // >> quant_shift_ptr[rc!=0]; // quantize (x) x += (round_ptr[rc!=0]); y = ((int)(((int)(x * quant_ptr[rc!=0]) >> 16) + x)) - >> quant_shift_ptr[rc!=0]; // quantize (x) + >> quant_shift_ptr[rc!=0]; // quantize (x) x = (y ^ sz) - sz; // get the sign back - qcoeff_ptr[rc] = x; // write to destination - //dqcoeff_ptr[rc] = x * dequant_ptr[rc!=0] / q1st; // dequantized value - dqcoeff_ptr[rc] = x * dequant_ptr[rc!=0]; // dequantized value + qcoeff_ptr[rc] = x; // write to destination + dqcoeff_ptr[rc] = x * dequant_ptr[rc!=0]; // dequantized value if (y) { - eob = i; // last nonzero coeffs - zbin_boost_ptr = &b->zrun_zbin_boost[0]; // reset zero runlength + eob = i; // last nonzero coeffs + zbin_boost_ptr = b->zrun_zbin_boost_8x8; } } } @@ -307,6 +296,16 @@ void vp8cx_init_quantizer(VP8_COMP *cpi) int Q; int zbin_boost[16] = { 0, 0, 8, 10, 12, 14, 16, 20, 24, 28, 32, 36, 40, 44, 44, 44}; + + int zbin_boost_8x8[64] = { 0, 0, 8, 10, 12, 14, 16, 20, + 24, 28, 32, 36, 40, 44, 48, 52, + 56, 60, 64, 68, 72, 76, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80 }; + int qrounding_factor = 48; for (Q = 0; Q < QINDEX_RANGE; Q++) @@ -315,63 +314,92 @@ void vp8cx_init_quantizer(VP8_COMP *cpi) // dc values quant_val = vp8_dc_quant(Q, cpi->common.y1dc_delta_q); - cpi->Y1quant_fast[Q][0] = (1 << 16) / quant_val; invert_quant(cpi->Y1quant[Q] + 0, cpi->Y1quant_shift[Q] + 0, quant_val); cpi->Y1zbin[Q][0] = ((qzbin_factor * quant_val) + 64) >> 7; + cpi->Y1zbin_8x8[Q][0] = ((qzbin_factor * quant_val) + 64) >> 7; cpi->Y1round[Q][0] = (qrounding_factor * quant_val) >> 7; cpi->common.Y1dequant[Q][0] = quant_val; cpi->zrun_zbin_boost_y1[Q][0] = (quant_val * zbin_boost[0]) >> 7; + cpi->zrun_zbin_boost_y1_8x8[Q][0] = + ((quant_val * zbin_boost_8x8[0]) + 64) >> 7; quant_val = vp8_dc2quant(Q, cpi->common.y2dc_delta_q); - cpi->Y2quant_fast[Q][0] = (1 << 16) / quant_val; invert_quant(cpi->Y2quant[Q] + 0, cpi->Y2quant_shift[Q] + 0, quant_val); cpi->Y2zbin[Q][0] = ((qzbin_factor * quant_val) + 64) >> 7; + cpi->Y2zbin_8x8[Q][0] = ((qzbin_factor * quant_val) + 64) >> 7; cpi->Y2round[Q][0] = (qrounding_factor * quant_val) >> 7; cpi->common.Y2dequant[Q][0] = quant_val; cpi->zrun_zbin_boost_y2[Q][0] = (quant_val * zbin_boost[0]) >> 7; + cpi->zrun_zbin_boost_y2_8x8[Q][0] = + ((quant_val * zbin_boost_8x8[0]) + 64) >> 7; quant_val = vp8_dc_uv_quant(Q, cpi->common.uvdc_delta_q); - cpi->UVquant_fast[Q][0] = (1 << 16) / quant_val; invert_quant(cpi->UVquant[Q] + 0, cpi->UVquant_shift[Q] + 0, quant_val); cpi->UVzbin[Q][0] = ((qzbin_factor * quant_val) + 64) >> 7;; + cpi->UVzbin_8x8[Q][0] = ((qzbin_factor * quant_val) + 64) >> 7;; cpi->UVround[Q][0] = (qrounding_factor * quant_val) >> 7; cpi->common.UVdequant[Q][0] = quant_val; cpi->zrun_zbin_boost_uv[Q][0] = (quant_val * zbin_boost[0]) >> 7; + cpi->zrun_zbin_boost_uv_8x8[Q][0] = + ((quant_val * zbin_boost_8x8[0]) + 64) >> 7; - // all the ac values = ; + // all the 4x4 ac values = ; for (i = 1; i < 16; i++) { int rc = vp8_default_zig_zag1d[i]; quant_val = vp8_ac_yquant(Q); - cpi->Y1quant_fast[Q][rc] = (1 << 16) / quant_val; invert_quant(cpi->Y1quant[Q] + rc, cpi->Y1quant_shift[Q] + rc, quant_val); cpi->Y1zbin[Q][rc] = ((qzbin_factor * quant_val) + 64) >> 7; cpi->Y1round[Q][rc] = (qrounding_factor * quant_val) >> 7; cpi->common.Y1dequant[Q][rc] = quant_val; - cpi->zrun_zbin_boost_y1[Q][i] = (quant_val * zbin_boost[i]) >> 7; + cpi->zrun_zbin_boost_y1[Q][i] = + ((quant_val * zbin_boost[i]) + 64) >> 7; quant_val = vp8_ac2quant(Q, cpi->common.y2ac_delta_q); - cpi->Y2quant_fast[Q][rc] = (1 << 16) / quant_val; invert_quant(cpi->Y2quant[Q] + rc, cpi->Y2quant_shift[Q] + rc, quant_val); cpi->Y2zbin[Q][rc] = ((qzbin_factor * quant_val) + 64) >> 7; cpi->Y2round[Q][rc] = (qrounding_factor * quant_val) >> 7; cpi->common.Y2dequant[Q][rc] = quant_val; - cpi->zrun_zbin_boost_y2[Q][i] = (quant_val * zbin_boost[i]) >> 7; + cpi->zrun_zbin_boost_y2[Q][i] = + ((quant_val * zbin_boost[i]) + 64) >> 7; quant_val = vp8_ac_uv_quant(Q, cpi->common.uvac_delta_q); - cpi->UVquant_fast[Q][rc] = (1 << 16) / quant_val; invert_quant(cpi->UVquant[Q] + rc, cpi->UVquant_shift[Q] + rc, quant_val); cpi->UVzbin[Q][rc] = ((qzbin_factor * quant_val) + 64) >> 7; cpi->UVround[Q][rc] = (qrounding_factor * quant_val) >> 7; cpi->common.UVdequant[Q][rc] = quant_val; - cpi->zrun_zbin_boost_uv[Q][i] = (quant_val * zbin_boost[i]) >> 7; + cpi->zrun_zbin_boost_uv[Q][i] = + ((quant_val * zbin_boost[i]) + 64) >> 7; + } + + // 8x8 structures... only zbin seperated out for now + // This needs cleaning up for 8x8 especially if we are to add + // support for non flat Q matices + for (i = 1; i < 64; i++) + { + int rc = vp8_default_zig_zag1d_8x8[i]; + + quant_val = vp8_ac_yquant(Q); + cpi->Y1zbin_8x8[Q][rc] = ((qzbin_factor * quant_val) + 64) >> 7; + cpi->zrun_zbin_boost_y1_8x8[Q][i] = + ((quant_val * zbin_boost_8x8[i]) + 64) >> 7; + + quant_val = vp8_ac2quant(Q, cpi->common.y2ac_delta_q); + cpi->Y2zbin_8x8[Q][rc] = ((qzbin_factor * quant_val) + 64) >> 7; + cpi->zrun_zbin_boost_y2_8x8[Q][i] = + ((quant_val * zbin_boost_8x8[i]) + 64) >> 7; + + quant_val = vp8_ac_uv_quant(Q, cpi->common.uvac_delta_q); + cpi->UVzbin_8x8[Q][rc] = ((qzbin_factor * quant_val) + 64) >> 7; + cpi->zrun_zbin_boost_uv_8x8[Q][i] = + ((quant_val * zbin_boost_8x8[i]) + 64) >> 7; } } } @@ -413,12 +441,13 @@ void vp8cx_mb_init_quantizer(VP8_COMP *cpi, MACROBLOCK *x) for (i = 0; i < 16; i++) { x->block[i].quant = cpi->Y1quant[QIndex]; - x->block[i].quant_fast = cpi->Y1quant_fast[QIndex]; x->block[i].quant_shift = cpi->Y1quant_shift[QIndex]; x->block[i].zbin = cpi->Y1zbin[QIndex]; + x->block[i].zbin_8x8 = cpi->Y1zbin_8x8[QIndex]; x->block[i].round = cpi->Y1round[QIndex]; x->e_mbd.block[i].dequant = cpi->common.Y1dequant[QIndex]; x->block[i].zrun_zbin_boost = cpi->zrun_zbin_boost_y1[QIndex]; + x->block[i].zrun_zbin_boost_8x8 = cpi->zrun_zbin_boost_y1_8x8[QIndex]; x->block[i].zbin_extra = (short)zbin_extra; // Segment max eob offset feature. @@ -445,12 +474,14 @@ void vp8cx_mb_init_quantizer(VP8_COMP *cpi, MACROBLOCK *x) for (i = 16; i < 24; i++) { x->block[i].quant = cpi->UVquant[QIndex]; - x->block[i].quant_fast = cpi->UVquant_fast[QIndex]; x->block[i].quant_shift = cpi->UVquant_shift[QIndex]; x->block[i].zbin = cpi->UVzbin[QIndex]; + x->block[i].zbin_8x8 = cpi->UVzbin_8x8[QIndex]; x->block[i].round = cpi->UVround[QIndex]; x->e_mbd.block[i].dequant = cpi->common.UVdequant[QIndex]; x->block[i].zrun_zbin_boost = cpi->zrun_zbin_boost_uv[QIndex]; + x->block[i].zrun_zbin_boost_8x8 = cpi->zrun_zbin_boost_uv_8x8[QIndex]; + x->block[i].zbin_extra = (short)zbin_extra; // Segment max eob offset feature. @@ -474,13 +505,14 @@ void vp8cx_mb_init_quantizer(VP8_COMP *cpi, MACROBLOCK *x) cpi->zbin_mode_boost + x->act_zbin_adj ) ) >> 7; - x->block[24].quant_fast = cpi->Y2quant_fast[QIndex]; x->block[24].quant = cpi->Y2quant[QIndex]; x->block[24].quant_shift = cpi->Y2quant_shift[QIndex]; x->block[24].zbin = cpi->Y2zbin[QIndex]; + x->block[24].zbin_8x8 = cpi->Y2zbin_8x8[QIndex]; x->block[24].round = cpi->Y2round[QIndex]; x->e_mbd.block[24].dequant = cpi->common.Y2dequant[QIndex]; x->block[24].zrun_zbin_boost = cpi->zrun_zbin_boost_y2[QIndex]; + x->block[24].zrun_zbin_boost_8x8 = cpi->zrun_zbin_boost_y2_8x8[QIndex]; x->block[24].zbin_extra = (short)zbin_extra; // TBD perhaps not use for Y2 diff --git a/vp8/encoder/rdopt.c b/vp8/encoder/rdopt.c index c46be62e5..2582c6410 100644 --- a/vp8/encoder/rdopt.c +++ b/vp8/encoder/rdopt.c @@ -1510,10 +1510,12 @@ static void rd_pick_intra_mbuv_mode_8x8(VP8_COMP *cpi, x->e_mbd.mode_info_context->mbmi.uv_mode = mode_selected; } -int vp8_cost_mv_ref(VP8_COMMON *pc, +int vp8_cost_mv_ref(VP8_COMP *cpi, MB_PREDICTION_MODE m, const int near_mv_ref_ct[4]) { + VP8_COMMON *pc = &cpi->common; + vp8_prob p [VP8_MVREFS-1]; assert(NEARESTMV <= m && m <= SPLITMV); vp8_mv_ref_probs(pc, p, near_mv_ref_ct); @@ -1737,7 +1739,7 @@ static void rd_check_segment(VP8_COMP *cpi, MACROBLOCK *x, // Segmentation method overheads rate = vp8_cost_token(vp8_mbsplit_tree, vp8_mbsplit_probs, vp8_mbsplit_encodings + segmentation); - rate += vp8_cost_mv_ref(&cpi->common, SPLITMV, bsi->mdcounts); + rate += vp8_cost_mv_ref(cpi, SPLITMV, bsi->mdcounts); this_segment_rd += RDCOST(x->rdmult, x->rddiv, rate, 0); br += rate; @@ -3093,10 +3095,10 @@ void vp8_rd_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int } } } - //intermodecost[mode_index] = vp8_cost_mv_ref(this_mode, mdcounts); // Experimental debug code + //intermodecost[mode_index] = vp8_cost_mv_ref(cpi, this_mode, mdcounts); // Experimental debug code // Add in the Mv/mode cost - rate2 += vp8_cost_mv_ref(&cpi->common, this_mode, mdcounts); + rate2 += vp8_cost_mv_ref(cpi, this_mode, mdcounts); // Y cost and distortion if(cpi->common.txfm_mode == ALLOW_8X8) @@ -3181,7 +3183,7 @@ void vp8_rd_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int } /* Add in the Mv/mode cost */ - rate2 += vp8_cost_mv_ref(&cpi->common,this_mode, mdcounts); + rate2 += vp8_cost_mv_ref(cpi, this_mode, mdcounts); vp8_clamp_mv2(&x->e_mbd.mode_info_context->mbmi.mv, xd); vp8_clamp_mv2(&x->e_mbd.mode_info_context->mbmi.second_mv, xd); @@ -3368,7 +3370,8 @@ void vp8_rd_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int x->e_mbd.mode_info_context->mbmi.mv.as_int = 0; } - other_cost += ref_costs[x->e_mbd.mode_info_context->mbmi.ref_frame]; + other_cost += + ref_costs[x->e_mbd.mode_info_context->mbmi.ref_frame]; /* Calculate the final y RD estimate for this mode */ best_yrd = RDCOST(x->rdmult, x->rddiv, (rate2-rate_uv-other_cost), -- 2.40.0