From f3dff402556cb1b1dd3c7dbc1877104a792f329c Mon Sep 17 00:00:00 2001 From: Deb Mukherjee Date: Wed, 20 Jun 2012 05:07:24 -0700 Subject: [PATCH] Continued adaptive entropy coding Incorporates mv_ref, mbsplit and second_mv into the adaptive entropy framework. The mv_ref framework has been modified from before. Adds some clean-ups and fixes. Results with the adaptive entropy experiment are currently up by +1.93% on derf; +2.33% std-hd and +1.87% yt-hd. Fixed a nasty intermittent bug. Change-Id: I4b1ac9f9483b48432597595195bfec05f31d1e39 --- vp8/common/entropy.h | 5 ++ vp8/common/entropymode.c | 123 +++++++++++++++++++++++++++++++++++----------- vp8/common/entropymode.h | 5 +- vp8/common/findnearmv.c | 8 +-- vp8/common/onyxc_int.h | 22 ++++++--- vp8/decoder/decodemv.c | 40 +++++++++++++-- vp8/decoder/decodframe.c | 37 ++++++++------ vp8/encoder/bitstream.c | 54 ++++++++++++++------ vp8/encoder/block.h | 1 + vp8/encoder/encodeframe.c | 8 ++- vp8/encoder/modecosts.c | 11 ++++- vp8/encoder/onyx_if.c | 5 +- vp8/encoder/onyx_int.h | 7 ++- vp8/encoder/ratectrl.c | 44 ++++++++++------- vp8/encoder/rdopt.c | 49 ++++++++++++++++-- vp8/encoder/rdopt.h | 5 +- 16 files changed, 320 insertions(+), 104 deletions(-) diff --git a/vp8/common/entropy.h b/vp8/common/entropy.h index 78f8d5d..0433974 100644 --- a/vp8/common/entropy.h +++ b/vp8/common/entropy.h @@ -16,6 +16,11 @@ #include "blockd.h" #include "common.h" #include "coefupdateprobs.h" + + +#define SUBMVREF_COUNT 5 +#define VP8_NUMMBSPLITS 4 + /* Coefficient token alphabet */ #define ZERO_TOKEN 0 /* 0 Extra Bits 0+0 */ diff --git a/vp8/common/entropymode.c b/vp8/common/entropymode.c index 4367746..26179be 100644 --- a/vp8/common/entropymode.c +++ b/vp8/common/entropymode.c @@ -142,7 +142,7 @@ int vp8_mv_cont(const int_mv *l, const int_mv *a) return SUBMVREF_NORMAL; } -static const vp8_prob sub_mv_ref_prob [VP8_SUBMVREFS-1] = { 180, 162, 25}; +const vp8_prob vp8_sub_mv_ref_prob [VP8_SUBMVREFS-1] = { 180, 162, 25}; const vp8_prob vp8_sub_mv_ref_prob2 [SUBMVREF_COUNT][VP8_SUBMVREFS-1] = { @@ -372,7 +372,8 @@ void vp8_init_mbmode_probs(VP8_COMMON *x) x->fc.i8x8_mode_prob, bct, i8x8_mode_cts, 256, 1); - vpx_memcpy(x->fc.sub_mv_ref_prob, sub_mv_ref_prob, sizeof(sub_mv_ref_prob)); + vpx_memcpy(x->fc.sub_mv_ref_prob, vp8_sub_mv_ref_prob2, sizeof(vp8_sub_mv_ref_prob2)); + vpx_memcpy(x->fc.mbsplit_prob, vp8_mbsplit_probs, sizeof(vp8_mbsplit_probs)); } @@ -435,15 +436,15 @@ void vp8_entropy_mode_init() void vp8_init_mode_contexts(VP8_COMMON *pc) { - vpx_memset(pc->mv_ref_ct, 0, sizeof(pc->mv_ref_ct)); - vpx_memset(pc->mv_ref_ct_a, 0, sizeof(pc->mv_ref_ct_a)); + vpx_memset(pc->fc.mv_ref_ct, 0, sizeof(pc->fc.mv_ref_ct)); + vpx_memset(pc->fc.mv_ref_ct_a, 0, sizeof(pc->fc.mv_ref_ct_a)); - vpx_memcpy( pc->mode_context, + vpx_memcpy( pc->fc.mode_context, default_vp8_mode_contexts, - sizeof (pc->mode_context)); - vpx_memcpy( pc->mode_context_a, + sizeof (pc->fc.mode_context)); + vpx_memcpy( pc->fc.mode_context_a, default_vp8_mode_contexts, - sizeof (pc->mode_context_a)); + sizeof (pc->fc.mode_context_a)); } @@ -454,9 +455,9 @@ void vp8_accum_mv_refs(VP8_COMMON *pc, int (*mv_ref_ct)[4][2]; if(pc->refresh_alt_ref_frame) - mv_ref_ct = pc->mv_ref_ct_a; + mv_ref_ct = pc->fc.mv_ref_ct_a; else - mv_ref_ct = pc->mv_ref_ct; + mv_ref_ct = pc->fc.mv_ref_ct; if (m == ZEROMV) { @@ -492,6 +493,8 @@ void vp8_accum_mv_refs(VP8_COMMON *pc, } } +#define MVREF_COUNT_SAT 20 +#define MVREF_MAX_UPDATE_FACTOR 128 void vp8_update_mode_context(VP8_COMMON *pc) { int i, j; @@ -500,13 +503,13 @@ void vp8_update_mode_context(VP8_COMMON *pc) if(pc->refresh_alt_ref_frame) { - mv_ref_ct = pc->mv_ref_ct_a; - mode_context = pc->mode_context_a; + mv_ref_ct = pc->fc.mv_ref_ct_a; + mode_context = pc->fc.mode_context_a; } else { - mv_ref_ct = pc->mv_ref_ct; - mode_context = pc->mode_context; + mv_ref_ct = pc->fc.mv_ref_ct; + mode_context = pc->fc.mode_context; } for (j = 0; j < 6; j++) @@ -515,6 +518,18 @@ void vp8_update_mode_context(VP8_COMMON *pc) { int this_prob; int count = mv_ref_ct[j][i][0] + mv_ref_ct[j][i][1]; +#if CONFIG_ADAPTIVE_ENTROPY + int factor; + { + this_prob = count > 0 ? 256 * mv_ref_ct[j][i][0] / count : 128; + count = count > MVREF_COUNT_SAT ? MVREF_COUNT_SAT : count; + factor = (MVREF_MAX_UPDATE_FACTOR * count / MVREF_COUNT_SAT); + this_prob = (pc->fc.vp8_mode_contexts[j][i] * (256 - factor) + + this_prob * factor + 128) >> 8; + this_prob = this_prob? (this_prob<255?this_prob:255):1; + mode_context[j][i] = this_prob; + } +#else /* preventing rare occurances from skewing the probs */ if (count>=4) { @@ -522,9 +537,11 @@ void vp8_update_mode_context(VP8_COMMON *pc) this_prob = this_prob? (this_prob<255?this_prob:255):1; mode_context[j][i] = this_prob; } +#endif } } } + #include "vp8/common/modecont.h" void print_mode_contexts(VP8_COMMON *pc) { @@ -534,7 +551,7 @@ void print_mode_contexts(VP8_COMMON *pc) { for (i = 0; i < 4; i++) { - printf( "%4d ", pc->mode_context[j][i]); + printf( "%4d ", pc->fc.mode_context[j][i]); } printf("\n"); } @@ -543,7 +560,7 @@ void print_mode_contexts(VP8_COMMON *pc) { for (i = 0; i < 4; i++) { - printf( "%4d ", pc->mode_context_a[j][i]); + printf( "%4d ", pc->fc.mode_context_a[j][i]); } printf("\n"); } @@ -557,8 +574,8 @@ void print_mv_ref_cts(VP8_COMMON *pc) for (i = 0; i < 4; i++) { printf("(%4d:%4d) ", - pc->mv_ref_ct[j][i][0], - pc->mv_ref_ct[j][i][1]); + pc->fc.mv_ref_ct[j][i][0], + pc->fc.mv_ref_ct[j][i][1]); } printf("\n"); } @@ -567,17 +584,17 @@ void print_mv_ref_cts(VP8_COMMON *pc) #if CONFIG_ADAPTIVE_ENTROPY //#define MODE_COUNT_TESTING #define MODE_COUNT_SAT 16 -#define MODE_MAX_UPDATE_FACTOR 96 +#define MODE_MAX_UPDATE_FACTOR 128 void vp8_adapt_mode_probs(VP8_COMMON *cm) { int i, t, count, factor; unsigned int branch_ct[32][2]; - int update_factor = MODE_MAX_UPDATE_FACTOR; /* denominator 256 */ - int count_sat = MODE_COUNT_SAT; vp8_prob ymode_probs[VP8_YMODES-1]; vp8_prob uvmode_probs[VP8_UV_MODES-1]; vp8_prob bmode_probs[VP8_BINTRAMODES-1]; vp8_prob i8x8_mode_probs[VP8_I8X8_MODES-1]; + vp8_prob sub_mv_ref_probs[VP8_SUBMVREFS-1]; + vp8_prob mbsplit_probs[VP8_NUMMBSPLITS-1]; #ifdef MODE_COUNT_TESTING printf("static const unsigned int\nymode_counts" "[VP8_YMODES] = {\n"); @@ -600,6 +617,19 @@ void vp8_adapt_mode_probs(VP8_COMMON *cm) "[VP8_I8X8_MODES] = {\n"); for (t = 0; tfc.i8x8_mode_counts[t]); printf("};\n"); + printf("static const unsigned int\nsub_mv_ref_counts" + "[SUBMVREF_COUNT] [VP8_SUBMVREFS] = {\n"); + for (i = 0; i < SUBMVREF_COUNT; ++i) + { + printf(" {"); + for (t = 0; t < VP8_SUBMVREFS; ++t) printf("%d, ", cm->fc.sub_mv_ref_counts[i][t]); + printf("},\n"); + } + printf("};\n"); + printf("static const unsigned int\nmbsplit_counts" + "[VP8_NUMMBSPLITS] = {\n"); + for (t = 0; tfc.mbsplit_counts[t]); + printf("};\n"); #endif vp8_tree_probs_from_distribution( VP8_YMODES, vp8_ymode_encodings, vp8_ymode_tree, @@ -609,8 +639,8 @@ void vp8_adapt_mode_probs(VP8_COMMON *cm) { int prob; count = branch_ct[t][0] + branch_ct[t][1]; - count = count > count_sat ? count_sat : count; - factor = (update_factor * count / count_sat); + count = count > MODE_COUNT_SAT ? MODE_COUNT_SAT : count; + factor = (MODE_MAX_UPDATE_FACTOR * count / MODE_COUNT_SAT); prob = ((int)cm->fc.pre_ymode_prob[t] * (256-factor) + (int)ymode_probs[t] * factor + 128) >> 8; if (prob <= 0) cm->fc.ymode_prob[t] = 1; @@ -627,8 +657,8 @@ void vp8_adapt_mode_probs(VP8_COMMON *cm) { int prob; count = branch_ct[t][0] + branch_ct[t][1]; - count = count > count_sat ? count_sat : count; - factor = (update_factor * count / count_sat); + count = count > MODE_COUNT_SAT ? MODE_COUNT_SAT : count; + factor = (MODE_MAX_UPDATE_FACTOR * count / MODE_COUNT_SAT); prob = ((int)cm->fc.pre_uv_mode_prob[i][t] * (256-factor) + (int)uvmode_probs[t] * factor + 128) >> 8; if (prob <= 0) cm->fc.uv_mode_prob[i][t] = 1; @@ -644,8 +674,8 @@ void vp8_adapt_mode_probs(VP8_COMMON *cm) { int prob; count = branch_ct[t][0] + branch_ct[t][1]; - count = count > count_sat ? count_sat : count; - factor = (update_factor * count / count_sat); + count = count > MODE_COUNT_SAT ? MODE_COUNT_SAT : count; + factor = (MODE_MAX_UPDATE_FACTOR * count / MODE_COUNT_SAT); prob = ((int)cm->fc.pre_bmode_prob[t] * (256-factor) + (int)bmode_probs[t] * factor + 128) >> 8; if (prob <= 0) cm->fc.bmode_prob[t] = 1; @@ -660,13 +690,48 @@ void vp8_adapt_mode_probs(VP8_COMMON *cm) { int prob; count = branch_ct[t][0] + branch_ct[t][1]; - count = count > count_sat ? count_sat : count; - factor = (update_factor * count / count_sat); + count = count > MODE_COUNT_SAT ? MODE_COUNT_SAT : count; + factor = (MODE_MAX_UPDATE_FACTOR * count / MODE_COUNT_SAT); prob = ((int)cm->fc.pre_i8x8_mode_prob[t] * (256-factor) + (int)i8x8_mode_probs[t] * factor + 128) >> 8; if (prob <= 0) cm->fc.i8x8_mode_prob[t] = 1; else if (prob > 255) cm->fc.i8x8_mode_prob[t] = 255; else cm->fc.i8x8_mode_prob[t] = prob; } + for (i = 0; i < SUBMVREF_COUNT; ++i) + { + vp8_tree_probs_from_distribution( + VP8_SUBMVREFS, vp8_sub_mv_ref_encoding_array, vp8_sub_mv_ref_tree, + sub_mv_ref_probs, branch_ct, cm->fc.sub_mv_ref_counts[i], + 256, 1); + for (t = 0; t < VP8_SUBMVREFS-1; ++t) + { + int prob; + count = branch_ct[t][0] + branch_ct[t][1]; + count = count > MODE_COUNT_SAT ? MODE_COUNT_SAT : count; + factor = (MODE_MAX_UPDATE_FACTOR * count / MODE_COUNT_SAT); + prob = ((int)cm->fc.pre_sub_mv_ref_prob[i][t] * (256-factor) + + (int)sub_mv_ref_probs[t] * factor + 128) >> 8; + if (prob <= 0) cm->fc.sub_mv_ref_prob[i][t] = 1; + else if (prob > 255) cm->fc.sub_mv_ref_prob[i][t] = 255; + else cm->fc.sub_mv_ref_prob[i][t] = prob; + } + } + vp8_tree_probs_from_distribution( + VP8_NUMMBSPLITS, vp8_mbsplit_encodings, vp8_mbsplit_tree, + mbsplit_probs, branch_ct, cm->fc.mbsplit_counts, + 256, 1); + for (t = 0; t < VP8_NUMMBSPLITS-1; ++t) + { + int prob; + count = branch_ct[t][0] + branch_ct[t][1]; + count = count > MODE_COUNT_SAT ? MODE_COUNT_SAT : count; + factor = (MODE_MAX_UPDATE_FACTOR * count / MODE_COUNT_SAT); + prob = ((int)cm->fc.pre_mbsplit_prob[t] * (256 - factor) + + (int)mbsplit_probs[t] * factor + 128) >> 8; + if (prob <= 0) cm->fc.mbsplit_prob[t] = 1; + else if (prob > 255) cm->fc.mbsplit_prob[t] = 255; + else cm->fc.mbsplit_prob[t] = prob; + } } #endif diff --git a/vp8/common/entropymode.h b/vp8/common/entropymode.h index cfd5327..e8f22df 100644 --- a/vp8/common/entropymode.h +++ b/vp8/common/entropymode.h @@ -17,8 +17,6 @@ typedef const int vp8_mbsplit[16]; -#define VP8_NUMMBSPLITS 4 - extern vp8_mbsplit vp8_mbsplits [VP8_NUMMBSPLITS]; extern const int vp8_mbsplit_count [VP8_NUMMBSPLITS]; /* # of subsets */ @@ -26,7 +24,8 @@ extern const int vp8_mbsplit_count [VP8_NUMMBSPLITS]; /* # of subsets */ extern const vp8_prob vp8_mbsplit_probs [VP8_NUMMBSPLITS-1]; extern int vp8_mv_cont(const int_mv *l, const int_mv *a); -#define SUBMVREF_COUNT 5 + +extern const vp8_prob vp8_sub_mv_ref_prob [VP8_SUBMVREFS-1]; extern const vp8_prob vp8_sub_mv_ref_prob2 [SUBMVREF_COUNT][VP8_SUBMVREFS-1]; diff --git a/vp8/common/findnearmv.c b/vp8/common/findnearmv.c index 955f54a..ada9d3a 100644 --- a/vp8/common/findnearmv.c +++ b/vp8/common/findnearmv.c @@ -177,9 +177,9 @@ vp8_prob *vp8_mv_ref_probs(VP8_COMMON *pc, vp8_prob p[VP8_MVREFS-1], const int near_mv_ref_ct[4] ) { - p[0] = pc->vp8_mode_contexts [near_mv_ref_ct[0]] [0]; - p[1] = pc->vp8_mode_contexts [near_mv_ref_ct[1]] [1]; - p[2] = pc->vp8_mode_contexts [near_mv_ref_ct[2]] [2]; - p[3] = pc->vp8_mode_contexts [near_mv_ref_ct[3]] [3]; + p[0] = pc->fc.vp8_mode_contexts [near_mv_ref_ct[0]] [0]; + p[1] = pc->fc.vp8_mode_contexts [near_mv_ref_ct[1]] [1]; + p[2] = pc->fc.vp8_mode_contexts [near_mv_ref_ct[2]] [2]; + p[3] = pc->fc.vp8_mode_contexts [near_mv_ref_ct[3]] [3]; return p; } diff --git a/vp8/common/onyxc_int.h b/vp8/common/onyxc_int.h index a068b43..f2795a8 100644 --- a/vp8/common/onyxc_int.h +++ b/vp8/common/onyxc_int.h @@ -48,7 +48,8 @@ typedef struct frame_contexts vp8_prob ymode_prob [VP8_YMODES-1]; /* interframe intra mode probs */ vp8_prob uv_mode_prob [VP8_YMODES][VP8_UV_MODES-1]; vp8_prob i8x8_mode_prob [VP8_I8X8_MODES-1]; - vp8_prob sub_mv_ref_prob [VP8_SUBMVREFS-1]; + vp8_prob sub_mv_ref_prob [SUBMVREF_COUNT][VP8_SUBMVREFS-1]; + vp8_prob mbsplit_prob [VP8_NUMMBSPLITS-1]; vp8_prob coef_probs [BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [ENTROPY_NODES]; vp8_prob coef_probs_8x8 [BLOCK_TYPES_8X8] [COEF_BANDS] [PREV_COEF_CONTEXTS] [ENTROPY_NODES]; MV_CONTEXT mvc[2]; @@ -64,10 +65,14 @@ typedef struct frame_contexts vp8_prob pre_ymode_prob [VP8_YMODES-1]; /* interframe intra mode probs */ vp8_prob pre_uv_mode_prob [VP8_YMODES][VP8_UV_MODES-1]; vp8_prob pre_i8x8_mode_prob [VP8_I8X8_MODES-1]; + vp8_prob pre_sub_mv_ref_prob [SUBMVREF_COUNT][VP8_SUBMVREFS-1]; + vp8_prob pre_mbsplit_prob [VP8_NUMMBSPLITS-1]; unsigned int bmode_counts [VP8_BINTRAMODES]; unsigned int ymode_counts [VP8_YMODES]; /* interframe intra mode probs */ unsigned int uv_mode_counts [VP8_YMODES][VP8_UV_MODES]; unsigned int i8x8_mode_counts [VP8_I8X8_MODES]; /* interframe intra mode probs */ + unsigned int sub_mv_ref_counts [SUBMVREF_COUNT][VP8_SUBMVREFS]; + unsigned int mbsplit_counts [VP8_NUMMBSPLITS]; vp8_prob pre_coef_probs [BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [ENTROPY_NODES]; vp8_prob pre_coef_probs_8x8 [BLOCK_TYPES_8X8] [COEF_BANDS] [PREV_COEF_CONTEXTS] [ENTROPY_NODES]; @@ -80,6 +85,11 @@ typedef struct frame_contexts unsigned int MVcount_hp [2] [MVvals_hp]; #endif #endif /* CONFIG_ADAPTIVE_ENTROPY */ + int mode_context[6][4]; + int mode_context_a[6][4]; + int vp8_mode_contexts[6][4]; + int mv_ref_ct[6][4][2]; + int mv_ref_ct_a[6][4][2]; } FRAME_CONTEXT; typedef enum @@ -254,11 +264,11 @@ typedef struct VP8Common FRAME_CONTEXT lfc; /* last frame entropy */ FRAME_CONTEXT fc; /* this frame entropy */ - int mv_ref_ct[6][4][2]; - int mode_context[6][4]; - int mv_ref_ct_a[6][4][2]; - int mode_context_a[6][4]; - int vp8_mode_contexts[6][4]; + //int mv_ref_ct[6][4][2]; + //int mv_ref_ct_a[6][4][2]; + //int mode_context[6][4]; + //int mode_context_a[6][4]; + //int vp8_mode_contexts[6][4]; unsigned int current_video_frame; int near_boffset[3]; diff --git a/vp8/decoder/decodemv.c b/vp8/decoder/decodemv.c index 3b9a098..b7b5e49 100644 --- a/vp8/decoder/decodemv.c +++ b/vp8/decoder/decodemv.c @@ -759,9 +759,12 @@ static void read_mb_modes_mv(VP8D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi, case SPLITMV: { const int s = mbmi->partitioning = - vp8_treed_read(bc, vp8_mbsplit_tree, vp8_mbsplit_probs); + vp8_treed_read(bc, vp8_mbsplit_tree, cm->fc.mbsplit_prob); const int num_p = vp8_mbsplit_count [s]; int j = 0; +#if CONFIG_ADAPTIVE_ENTROPY + cm->fc.mbsplit_counts[s]++; +#endif mbmi->need_to_clamp_mvs = 0; do /* for each subset j */ @@ -782,7 +785,10 @@ static void read_mb_modes_mv(VP8D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi, second_abovemv.as_int = above_block_second_mv(mi, k, mis); } mv_contz = vp8_mv_cont(&leftmv, &abovemv); - blockmode = sub_mv_ref(bc, vp8_sub_mv_ref_prob2 [mv_contz]); + blockmode = sub_mv_ref(bc, cm->fc.sub_mv_ref_prob [mv_contz]); +#if CONFIG_ADAPTIVE_ENTROPY + cm->fc.sub_mv_ref_counts[mv_contz][blockmode-LEFT4X4]++; +#endif switch (blockmode) { @@ -812,10 +818,22 @@ static void read_mb_modes_mv(VP8D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi, { #if CONFIG_HIGH_PRECISION_MV if (xd->allow_high_precision_mv) + { read_mv_hp(bc, &secondmv.as_mv, (const MV_CONTEXT_HP *) mvc_hp); +#if CONFIG_ADAPTIVE_ENTROPY + cm->fc.MVcount_hp[0][mv_max_hp+(secondmv.as_mv.row)]++; + cm->fc.MVcount_hp[1][mv_max_hp+(secondmv.as_mv.col)]++; +#endif + } else #endif + { read_mv(bc, &secondmv.as_mv, (const MV_CONTEXT *) mvc); +#if CONFIG_ADAPTIVE_ENTROPY + cm->fc.MVcount[0][mv_max+(secondmv.as_mv.row>>1)]++; + cm->fc.MVcount[1][mv_max+(secondmv.as_mv.col>>1)]++; +#endif + } secondmv.as_mv.row += best_mv_second.as_mv.row; secondmv.as_mv.col += best_mv_second.as_mv.col; } @@ -843,9 +861,9 @@ static void read_mb_modes_mv(VP8D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi, blockmv.as_int = 0; if (mbmi->second_ref_frame) secondmv.as_int = 0; - #ifdef VPX_MODE_COUNT +#ifdef VPX_MODE_COUNT vp8_mv_cont_count[mv_contz][2]++; - #endif +#endif break; default: break; @@ -959,11 +977,23 @@ static void read_mb_modes_mv(VP8D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi, { #if CONFIG_HIGH_PRECISION_MV if (xd->allow_high_precision_mv) + { read_mv_hp(bc, &mbmi->second_mv.as_mv, (const MV_CONTEXT_HP *) mvc_hp); +#if CONFIG_ADAPTIVE_ENTROPY + cm->fc.MVcount_hp[0][mv_max_hp+(mbmi->second_mv.as_mv.row)]++; + cm->fc.MVcount_hp[1][mv_max_hp+(mbmi->second_mv.as_mv.col)]++; +#endif + } else #endif - read_mv(bc, &mbmi->second_mv.as_mv, (const MV_CONTEXT *) mvc); + { + read_mv(bc, &mbmi->second_mv.as_mv, (const MV_CONTEXT *) mvc); +#if CONFIG_ADAPTIVE_ENTROPY + cm->fc.MVcount[0][mv_max+(mbmi->second_mv.as_mv.row>>1)]++; + cm->fc.MVcount[1][mv_max+(mbmi->second_mv.as_mv.col>>1)]++; +#endif + } mbmi->second_mv.as_mv.row += best_mv_second.as_mv.row; mbmi->second_mv.as_mv.col += best_mv_second.as_mv.col; mbmi->need_to_clamp_secondmv |= vp8_check_mv_bounds(&mbmi->second_mv, diff --git a/vp8/decoder/decodframe.c b/vp8/decoder/decodframe.c index d720c00..cb1f6d1 100644 --- a/vp8/decoder/decodframe.c +++ b/vp8/decoder/decodframe.c @@ -729,13 +729,13 @@ static void init_frame(VP8D_COMP *pbi) pc->ref_frame_sign_bias[GOLDEN_FRAME] = 0; pc->ref_frame_sign_bias[ALTREF_FRAME] = 0; + vp8_init_mode_contexts(&pbi->common); vpx_memcpy(&pc->lfc, &pc->fc, sizeof(pc->fc)); vpx_memcpy(&pc->lfc_a, &pc->fc, sizeof(pc->fc)); - vp8_init_mode_contexts(&pbi->common); - vpx_memcpy( pbi->common.vp8_mode_contexts, - pbi->common.mode_context, - sizeof(pbi->common.mode_context)); + vpx_memcpy( pbi->common.fc.vp8_mode_contexts, + pbi->common.fc.mode_context, + sizeof(pbi->common.fc.mode_context)); } else { @@ -1331,16 +1331,16 @@ int vp8_decode_frame(VP8D_COMP *pbi) if(pc->refresh_alt_ref_frame) { vpx_memcpy(&pc->fc, &pc->lfc_a, sizeof(pc->fc)); - vpx_memcpy( pc->vp8_mode_contexts, - pc->mode_context_a, - sizeof(pc->vp8_mode_contexts)); + vpx_memcpy( pc->fc.vp8_mode_contexts, + pc->fc.mode_context_a, + sizeof(pc->fc.vp8_mode_contexts)); } else { vpx_memcpy(&pc->fc, &pc->lfc, sizeof(pc->fc)); - vpx_memcpy( pc->vp8_mode_contexts, - pc->mode_context, - sizeof(pc->vp8_mode_contexts)); + vpx_memcpy( pc->fc.vp8_mode_contexts, + pc->fc.mode_context, + sizeof(pc->fc.vp8_mode_contexts)); } /* Buffer to buffer copy flags. */ @@ -1436,6 +1436,8 @@ int vp8_decode_frame(VP8D_COMP *pbi) vp8_copy(pbi->common.fc.pre_uv_mode_prob, pbi->common.fc.uv_mode_prob); vp8_copy(pbi->common.fc.pre_bmode_prob, pbi->common.fc.bmode_prob); vp8_copy(pbi->common.fc.pre_i8x8_mode_prob, pbi->common.fc.i8x8_mode_prob); + vp8_copy(pbi->common.fc.pre_sub_mv_ref_prob, pbi->common.fc.sub_mv_ref_prob); + vp8_copy(pbi->common.fc.pre_mbsplit_prob, pbi->common.fc.mbsplit_prob); vp8_copy(pbi->common.fc.pre_mvc, pbi->common.fc.mvc); #if CONFIG_HIGH_PRECISION_MV vp8_copy(pbi->common.fc.pre_mvc_hp, pbi->common.fc.mvc_hp); @@ -1446,14 +1448,18 @@ int vp8_decode_frame(VP8D_COMP *pbi) vp8_zero(pbi->common.fc.uv_mode_counts); vp8_zero(pbi->common.fc.bmode_counts); vp8_zero(pbi->common.fc.i8x8_mode_counts); + vp8_zero(pbi->common.fc.sub_mv_ref_counts); + vp8_zero(pbi->common.fc.mbsplit_counts); vp8_zero(pbi->common.fc.MVcount); #if CONFIG_HIGH_PRECISION_MV vp8_zero(pbi->common.fc.MVcount_hp); #endif -#endif -#if COEFUPDATETYPE == 2 + vp8_zero(pbi->common.fc.mv_ref_ct); + vp8_zero(pbi->common.fc.mv_ref_ct_a); +#endif /* CONFIG_ADAPTIVE_ENTROPY */ +#if CONFIG_NEWUPDATE && COEFUPDATETYPE == 2 read_coef_probs2(pbi); -#elif COEFUPDATETYPE == 3 +#elif CONFIG_NEWUPDATE && COEFUPDATETYPE == 3 read_coef_probs3(pbi); #else read_coef_probs(pbi); @@ -1481,10 +1487,12 @@ int vp8_decode_frame(VP8D_COMP *pbi) pc->mb_no_coeff_skip = (int)vp8_read_bit(bc); vp8_decode_mode_mvs(pbi); - if(pbi->common.frame_type != KEY_FRAME) +#if CONFIG_ADAPTIVE_ENTROPY == 0 + if (pc->frame_type != KEY_FRAME) { vp8_update_mode_context(&pbi->common); } +#endif vpx_memset(pc->above_context, 0, sizeof(ENTROPY_CONTEXT_PLANES) * pc->mb_cols); @@ -1521,6 +1529,7 @@ int vp8_decode_frame(VP8D_COMP *pbi) { vp8_adapt_mode_probs(pc); vp8_adapt_mv_probs(pc); + vp8_update_mode_context(&pbi->common); } #endif diff --git a/vp8/encoder/bitstream.c b/vp8/encoder/bitstream.c index ee80511..e0cb2d4 100644 --- a/vp8/encoder/bitstream.c +++ b/vp8/encoder/bitstream.c @@ -300,10 +300,10 @@ static void write_bmode(vp8_writer *bc, int m, const vp8_prob *p) vp8_write_token(bc, vp8_bmode_tree, p, vp8_bmode_encodings + m); } -static void write_split(vp8_writer *bc, int x) +static void write_split(vp8_writer *bc, int x, const vp8_prob *p) { vp8_write_token( - bc, vp8_mbsplit_tree, vp8_mbsplit_probs, vp8_mbsplit_encodings + x + bc, vp8_mbsplit_tree, p, vp8_mbsplit_encodings + x ); } @@ -856,7 +856,7 @@ static void pack_inter_mode_mvs(VP8_COMP *const cpi) vp8_write_mvprobs_hp(cpi); else #endif - vp8_write_mvprobs(cpi); + vp8_write_mvprobs(cpi); mb_row = 0; for (row=0; row < pc->mb_rows; row += 2) @@ -1061,21 +1061,29 @@ static void pack_inter_mode_mvs(VP8_COMP *const cpi) #if CONFIG_HIGH_PRECISION_MV if (xd->allow_high_precision_mv) + { write_mv_hp(w, &mi->mv.as_mv, &best_mv, mvc_hp); + } else #endif - write_mv(w, &mi->mv.as_mv, &best_mv, mvc); + { + write_mv(w, &mi->mv.as_mv, &best_mv, mvc); + } if (mi->second_ref_frame) { #if CONFIG_HIGH_PRECISION_MV if (xd->allow_high_precision_mv) + { write_mv_hp(w, &mi->second_mv.as_mv, &best_second_mv, mvc_hp); + } else #endif - write_mv(w, &mi->second_mv.as_mv, + { + write_mv(w, &mi->second_mv.as_mv, &best_second_mv, mvc); + } } break; case SPLITMV: @@ -1086,7 +1094,10 @@ static void pack_inter_mode_mvs(VP8_COMP *const cpi) ++count_mb_seg [mi->partitioning]; #endif - write_split(w, mi->partitioning); + write_split(w, mi->partitioning, cpi->common.fc.mbsplit_prob); +#if CONFIG_ADAPTIVE_ENTROPY + cpi->mbsplit_count[mi->partitioning]++; +#endif do { @@ -1112,8 +1123,10 @@ static void pack_inter_mode_mvs(VP8_COMP *const cpi) mv_contz = vp8_mv_cont(&leftmv, &abovemv); write_sub_mv_ref(w, blockmode, - vp8_sub_mv_ref_prob2 [mv_contz]); - + cpi->common.fc.sub_mv_ref_prob [mv_contz]); +#if CONFIG_ADAPTIVE_ENTROPY + cpi->sub_mv_ref_count[mv_contz][blockmode-LEFT4X4]++; +#endif if (blockmode == NEW4X4) { #ifdef ENTROPY_STATS @@ -1121,23 +1134,31 @@ static void pack_inter_mode_mvs(VP8_COMP *const cpi) #endif #if CONFIG_HIGH_PRECISION_MV if (xd->allow_high_precision_mv) + { write_mv_hp(w, &blockmv.as_mv, &best_mv, (const MV_CONTEXT_HP *) mvc_hp); + } else #endif - write_mv(w, &blockmv.as_mv, &best_mv, + { + write_mv(w, &blockmv.as_mv, &best_mv, (const MV_CONTEXT *) mvc); + } if (mi->second_ref_frame) { #if CONFIG_HIGH_PRECISION_MV if (xd->allow_high_precision_mv) + { write_mv_hp(w, &cpi->mb.partition_info->bmi[j].second_mv.as_mv, &best_second_mv, (const MV_CONTEXT_HP *) mvc_hp); + } else #endif + { write_mv(w, &cpi->mb.partition_info->bmi[j].second_mv.as_mv, &best_second_mv, (const MV_CONTEXT *) mvc); + } } } } @@ -2229,8 +2250,6 @@ static void segment_reference_frames(VP8_COMP *cpi) enable_segfeature(xd,i,SEG_LVL_REF_FRAME); set_segdata( xd,i, SEG_LVL_REF_FRAME, ref[i]); } - - } void vp8_pack_bitstream(VP8_COMP *cpi, unsigned char *dest, unsigned long *size) @@ -2628,15 +2647,21 @@ void vp8_pack_bitstream(VP8_COMP *cpi, unsigned char *dest, unsigned long *size) vp8_copy(cpi->common.fc.pre_ymode_prob, cpi->common.fc.ymode_prob); vp8_copy(cpi->common.fc.pre_uv_mode_prob, cpi->common.fc.uv_mode_prob); vp8_copy(cpi->common.fc.pre_bmode_prob, cpi->common.fc.bmode_prob); + vp8_copy(cpi->common.fc.pre_sub_mv_ref_prob, cpi->common.fc.sub_mv_ref_prob); + vp8_copy(cpi->common.fc.pre_mbsplit_prob, cpi->common.fc.mbsplit_prob); vp8_copy(cpi->common.fc.pre_i8x8_mode_prob, cpi->common.fc.i8x8_mode_prob); vp8_copy(cpi->common.fc.pre_mvc, cpi->common.fc.mvc); #if CONFIG_HIGH_PRECISION_MV vp8_copy(cpi->common.fc.pre_mvc_hp, cpi->common.fc.mvc_hp); #endif + vp8_zero(cpi->sub_mv_ref_count); + vp8_zero(cpi->mbsplit_count); + vp8_zero(cpi->common.fc.mv_ref_ct) + vp8_zero(cpi->common.fc.mv_ref_ct_a) #endif -#if COEFUPDATETYPE == 2 +#if CONFIG_NEWUPDATE && COEFUPDATETYPE == 2 update_coef_probs2(cpi); -#elif COEFUPDATETYPE == 3 +#elif CONFIG_NEWUPDATE && COEFUPDATETYPE == 3 update_coef_probs3(cpi); #else update_coef_probs(cpi); @@ -2661,8 +2686,9 @@ void vp8_pack_bitstream(VP8_COMP *cpi, unsigned char *dest, unsigned long *size) else { pack_inter_mode_mvs(cpi); - +#if CONFIG_ADAPTIVE_ENTROPY == 0 vp8_update_mode_context(&cpi->common); +#endif #ifdef ENTROPY_STATS active_section = 1; diff --git a/vp8/encoder/block.h b/vp8/encoder/block.h index 98bc132..fb309f4 100644 --- a/vp8/encoder/block.h +++ b/vp8/encoder/block.h @@ -72,6 +72,7 @@ typedef struct MODE_INFO mic; PARTITION_INFO partition_info; int_mv best_ref_mv; + int_mv second_best_ref_mv; int rate; int distortion; int intra_error; diff --git a/vp8/encoder/encodeframe.c b/vp8/encoder/encodeframe.c index a92bdbc..55041c5 100644 --- a/vp8/encoder/encodeframe.c +++ b/vp8/encoder/encodeframe.c @@ -458,7 +458,7 @@ static void update_state (VP8_COMP *cpi, MACROBLOCK *x, PICK_MODE_CONTEXT *ctx) // Note how often each mode chosen as best cpi->mode_chosen_counts[mb_mode_index]++; - rd_update_mvcount(cpi, x, &ctx->best_ref_mv); + rd_update_mvcount(cpi, x, &ctx->best_ref_mv, &ctx->second_best_ref_mv); cpi->prediction_error += ctx->distortion; cpi->intra_error += ctx->intra_error; @@ -1068,6 +1068,12 @@ void init_encode_frame_mb_context(VP8_COMP *cpi) vp8_zero(cpi->ymode_count) vp8_zero(cpi->i8x8_mode_count) vp8_zero(cpi->y_uv_mode_count) + vp8_zero(cpi->sub_mv_ref_count) + vp8_zero(cpi->mbsplit_count) +#if CONFIG_ADAPTIVE_ENTROPY + vp8_zero(cpi->common.fc.mv_ref_ct) + vp8_zero(cpi->common.fc.mv_ref_ct_a) +#endif //vp8_zero(cpi->uv_mode_count) x->mvc = cm->fc.mvc; diff --git a/vp8/encoder/modecosts.c b/vp8/encoder/modecosts.c index e7d0711..6cd0da5 100644 --- a/vp8/encoder/modecosts.c +++ b/vp8/encoder/modecosts.c @@ -37,8 +37,14 @@ void vp8_init_mode_costs(VP8_COMP *c) vp8_cost_tokens((int *)c->mb.inter_bmode_costs, x->fc.bmode_prob, T); } +#if CONFIG_ADAPTIVE_ENTROPY vp8_cost_tokens((int *)c->mb.inter_bmode_costs, - x->fc.sub_mv_ref_prob, vp8_sub_mv_ref_tree); + vp8_sub_mv_ref_prob, vp8_sub_mv_ref_tree); + //x->fc.sub_mv_ref_prob[1], vp8_sub_mv_ref_tree); +#else + vp8_cost_tokens((int *)c->mb.inter_bmode_costs, + vp8_sub_mv_ref_prob, vp8_sub_mv_ref_tree); +#endif vp8_cost_tokens(c->mb.mbmode_cost[1], x->fc.ymode_prob, vp8_ymode_tree); vp8_cost_tokens(c->mb.mbmode_cost[0], @@ -48,6 +54,7 @@ void vp8_init_mode_costs(VP8_COMP *c) x->fc.uv_mode_prob[VP8_YMODES-1], vp8_uv_mode_tree); vp8_cost_tokens(c->mb.intra_uv_mode_cost[0], x->kf_uv_mode_prob[VP8_YMODES-1], vp8_uv_mode_tree); - vp8_cost_tokens((int *)c->mb.i8x8_mode_costs, + vp8_cost_tokens(c->mb.i8x8_mode_costs, x->fc.i8x8_mode_prob,vp8_i8x8_mode_tree); + } diff --git a/vp8/encoder/onyx_if.c b/vp8/encoder/onyx_if.c index aa46fb0..decb31b 100644 --- a/vp8/encoder/onyx_if.c +++ b/vp8/encoder/onyx_if.c @@ -3702,6 +3702,8 @@ static void encode_frame_to_data_rate vp8_copy(cpi->common.fc.uv_mode_counts, cpi->y_uv_mode_count); vp8_copy(cpi->common.fc.bmode_counts, cpi->bmode_count); vp8_copy(cpi->common.fc.i8x8_mode_counts, cpi->i8x8_mode_count); + vp8_copy(cpi->common.fc.sub_mv_ref_counts, cpi->sub_mv_ref_count); + vp8_copy(cpi->common.fc.mbsplit_counts, cpi->mbsplit_count); vp8_adapt_mode_probs(&cpi->common); vp8_copy(cpi->common.fc.MVcount, cpi->MVcount); @@ -3709,6 +3711,7 @@ static void encode_frame_to_data_rate vp8_copy(cpi->common.fc.MVcount_hp, cpi->MVcount_hp); #endif vp8_adapt_mv_probs(&cpi->common); + vp8_update_mode_context(&cpi->common); } #endif /* CONFIG_ADAPTIVE_ENTROPY */ @@ -3809,7 +3812,7 @@ static void encode_frame_to_data_rate // in this frame. update_base_skip_probs( cpi ); -#if 1 && CONFIG_INTERNAL_STATS +#if 0//1 && CONFIG_INTERNAL_STATS { FILE *f = fopen("tmp.stt", "a"); int recon_err; diff --git a/vp8/encoder/onyx_int.h b/vp8/encoder/onyx_int.h index f4e6f94..54ed233 100644 --- a/vp8/encoder/onyx_int.h +++ b/vp8/encoder/onyx_int.h @@ -23,6 +23,7 @@ #include "encodemb.h" #include "quantize.h" #include "vp8/common/entropy.h" +#include "vp8/common/entropymode.h" #include "vpx_ports/mem.h" #include "vpx/internal/vpx_codec_internal.h" #include "mcomp.h" @@ -99,6 +100,8 @@ typedef struct vp8_prob uv_mode_prob [VP8_YMODES][VP8_UV_MODES-1]; vp8_prob bmode_prob [VP8_BINTRAMODES-1]; vp8_prob i8x8_mode_prob [VP8_I8X8_MODES-1]; + vp8_prob sub_mv_ref_prob [SUBMVREF_COUNT][VP8_SUBMVREFS-1]; + vp8_prob mbsplit_prob [VP8_NUMMBSPLITS-1]; int mv_ref_ct[6][4][2]; int mode_context[6][4]; @@ -458,7 +461,10 @@ typedef struct VP8_COMP int ymode_count [VP8_YMODES]; /* intra MB type cts this frame */ int bmode_count [VP8_BINTRAMODES]; int i8x8_mode_count [VP8_I8X8_MODES]; + int sub_mv_ref_count [SUBMVREF_COUNT][VP8_SUBMVREFS]; + int mbsplit_count [VP8_NUMMBSPLITS]; //int uv_mode_count[VP8_UV_MODES]; /* intra MB type cts this frame */ + int y_uv_mode_count[VP8_YMODES][VP8_UV_MODES]; unsigned int MVcount [2] [MVvals]; /* (row,col) MV cts this frame */ #if CONFIG_HIGH_PRECISION_MV @@ -542,7 +548,6 @@ typedef struct VP8_COMP int t4x4_count; int t8x8_count; - int y_uv_mode_count[VP8_YMODES][VP8_UV_MODES]; unsigned char *segmentation_map; // segment threashold for encode breakout diff --git a/vp8/encoder/ratectrl.c b/vp8/encoder/ratectrl.c index 6d510e9..75246fc 100644 --- a/vp8/encoder/ratectrl.c +++ b/vp8/encoder/ratectrl.c @@ -150,15 +150,17 @@ void vp8_save_coding_context(VP8_COMP *cpi) vp8_copy(cc->mvcosts_hp, cpi->mb.mvcosts_hp); #endif - vp8_copy( cc->mv_ref_ct, cm->mv_ref_ct ); - vp8_copy( cc->mode_context, cm->mode_context ); - vp8_copy( cc->mv_ref_ct_a, cm->mv_ref_ct_a ); - vp8_copy( cc->mode_context_a, cm->mode_context_a ); + vp8_copy( cc->mv_ref_ct, cm->fc.mv_ref_ct ); + vp8_copy( cc->mode_context, cm->fc.mode_context ); + vp8_copy( cc->mv_ref_ct_a, cm->fc.mv_ref_ct_a ); + vp8_copy( cc->mode_context_a, cm->fc.mode_context_a ); vp8_copy( cc->ymode_prob, cm->fc.ymode_prob ); vp8_copy( cc->bmode_prob, cm->fc.bmode_prob ); vp8_copy( cc->uv_mode_prob, cm->fc.uv_mode_prob ); vp8_copy( cc->i8x8_mode_prob, cm->fc.i8x8_mode_prob ); + vp8_copy( cc->sub_mv_ref_prob, cm->fc.sub_mv_ref_prob ); + vp8_copy( cc->mbsplit_prob, cm->fc.mbsplit_prob ); // Stats #ifdef MODE_STATS @@ -201,15 +203,17 @@ void vp8_restore_coding_context(VP8_COMP *cpi) vp8_copy(cpi->mb.mvcosts_hp, cc->mvcosts_hp); #endif - vp8_copy( cm->mv_ref_ct, cc->mv_ref_ct ); - vp8_copy( cm->mode_context, cc->mode_context ); - vp8_copy( cm->mv_ref_ct_a, cc->mv_ref_ct_a ); - vp8_copy( cm->mode_context_a, cc->mode_context_a ); + vp8_copy( cm->fc.mv_ref_ct, cc->mv_ref_ct ); + vp8_copy( cm->fc.mode_context, cc->mode_context ); + vp8_copy( cm->fc.mv_ref_ct_a, cc->mv_ref_ct_a ); + vp8_copy( cm->fc.mode_context_a, cc->mode_context_a ); vp8_copy( cm->fc.ymode_prob, cc->ymode_prob); vp8_copy( cm->fc.bmode_prob, cc->bmode_prob); vp8_copy( cm->fc.i8x8_mode_prob, cc->i8x8_mode_prob); vp8_copy( cm->fc.uv_mode_prob, cc->uv_mode_prob); + vp8_copy( cm->fc.sub_mv_ref_prob, cc->sub_mv_ref_prob); + vp8_copy( cm->fc.mbsplit_prob, cc->mbsplit_prob ); // Stats #ifdef MODE_STATS @@ -271,14 +275,16 @@ void vp8_setup_key_frame(VP8_COMP *cpi) cpi->common.refresh_golden_frame = TRUE; cpi->common.refresh_alt_ref_frame = TRUE; + vp8_init_mode_contexts(&cpi->common); vpx_memcpy(&cpi->common.lfc, &cpi->common.fc, sizeof(cpi->common.fc)); vpx_memcpy(&cpi->common.lfc_a, &cpi->common.fc, sizeof(cpi->common.fc)); - vp8_init_mode_contexts(&cpi->common); - vpx_memcpy( cpi->common.vp8_mode_contexts, - cpi->common.mode_context, - sizeof(cpi->common.mode_context)); - vpx_memcpy( cpi->common.vp8_mode_contexts, + /* + vpx_memcpy( cpi->common.fc.vp8_mode_contexts, + cpi->common.fc.mode_context, + sizeof(cpi->common.fc.mode_context)); + */ + vpx_memcpy( cpi->common.fc.vp8_mode_contexts, default_vp8_mode_contexts, sizeof(default_vp8_mode_contexts)); @@ -293,18 +299,18 @@ void vp8_setup_inter_frame(VP8_COMP *cpi) vpx_memcpy( &cpi->common.fc, &cpi->common.lfc_a, sizeof(cpi->common.fc)); - vpx_memcpy( cpi->common.vp8_mode_contexts, - cpi->common.mode_context_a, - sizeof(cpi->common.vp8_mode_contexts)); + vpx_memcpy( cpi->common.fc.vp8_mode_contexts, + cpi->common.fc.mode_context_a, + sizeof(cpi->common.fc.vp8_mode_contexts)); } else { vpx_memcpy( &cpi->common.fc, &cpi->common.lfc, sizeof(cpi->common.fc)); - vpx_memcpy( cpi->common.vp8_mode_contexts, - cpi->common.mode_context, - sizeof(cpi->common.vp8_mode_contexts)); + vpx_memcpy( cpi->common.fc.vp8_mode_contexts, + cpi->common.fc.mode_context, + sizeof(cpi->common.fc.vp8_mode_contexts)); } } diff --git a/vp8/encoder/rdopt.c b/vp8/encoder/rdopt.c index e8ddd66..18b62bf 100644 --- a/vp8/encoder/rdopt.c +++ b/vp8/encoder/rdopt.c @@ -2502,7 +2502,8 @@ void vp8_cal_sad(VP8_COMP *cpi, MACROBLOCKD *xd, MACROBLOCK *x, int recon_yoffse } } -void rd_update_mvcount(VP8_COMP *cpi, MACROBLOCK *x, int_mv *best_ref_mv) +void rd_update_mvcount(VP8_COMP *cpi, MACROBLOCK *x, + int_mv *best_ref_mv, int_mv *second_best_ref_mv) { if (x->e_mbd.mode_info_context->mbmi.mode == SPLITMV) { @@ -2519,6 +2520,15 @@ void rd_update_mvcount(VP8_COMP *cpi, MACROBLOCK *x, int_mv *best_ref_mv) - best_ref_mv->as_mv.row)]++; cpi->MVcount_hp[1][mv_max_hp+(x->partition_info->bmi[i].mv.as_mv.col - best_ref_mv->as_mv.col)]++; +#if CONFIG_ADAPTIVE_ENTROPY + if (x->e_mbd.mode_info_context->mbmi.second_ref_frame) + { + cpi->MVcount_hp[0][mv_max_hp+(x->partition_info->bmi[i].second_mv.as_mv.row + - second_best_ref_mv->as_mv.row)]++; + cpi->MVcount_hp[1][mv_max_hp+(x->partition_info->bmi[i].second_mv.as_mv.col + - second_best_ref_mv->as_mv.col)]++; + } +#endif } else #endif @@ -2527,6 +2537,15 @@ void rd_update_mvcount(VP8_COMP *cpi, MACROBLOCK *x, int_mv *best_ref_mv) - best_ref_mv->as_mv.row) >> 1)]++; cpi->MVcount[1][mv_max+((x->partition_info->bmi[i].mv.as_mv.col - best_ref_mv->as_mv.col) >> 1)]++; +#if CONFIG_ADAPTIVE_ENTROPY + if (x->e_mbd.mode_info_context->mbmi.second_ref_frame) + { + cpi->MVcount[0][mv_max+((x->partition_info->bmi[i].second_mv.as_mv.row + - second_best_ref_mv->as_mv.row) >> 1)]++; + cpi->MVcount[1][mv_max+((x->partition_info->bmi[i].second_mv.as_mv.col + - second_best_ref_mv->as_mv.col) >> 1)]++; + } +#endif } } } @@ -2540,6 +2559,15 @@ void rd_update_mvcount(VP8_COMP *cpi, MACROBLOCK *x, int_mv *best_ref_mv) - best_ref_mv->as_mv.row)]++; cpi->MVcount_hp[1][mv_max_hp+(x->e_mbd.mode_info_context->mbmi.mv.as_mv.col - best_ref_mv->as_mv.col)]++; +#if CONFIG_ADAPTIVE_ENTROPY + if (x->e_mbd.mode_info_context->mbmi.second_ref_frame) + { + cpi->MVcount_hp[0][mv_max_hp+(x->e_mbd.mode_info_context->mbmi.second_mv.as_mv.row + - second_best_ref_mv->as_mv.row)]++; + cpi->MVcount_hp[1][mv_max_hp+(x->e_mbd.mode_info_context->mbmi.second_mv.as_mv.col + - second_best_ref_mv->as_mv.col)]++; + } +#endif } else #endif @@ -2548,6 +2576,15 @@ void rd_update_mvcount(VP8_COMP *cpi, MACROBLOCK *x, int_mv *best_ref_mv) - best_ref_mv->as_mv.row) >> 1)]++; cpi->MVcount[1][mv_max+((x->e_mbd.mode_info_context->mbmi.mv.as_mv.col - best_ref_mv->as_mv.col) >> 1)]++; +#if CONFIG_ADAPTIVE_ENTROPY + if (x->e_mbd.mode_info_context->mbmi.second_ref_frame) + { + cpi->MVcount[0][mv_max+((x->e_mbd.mode_info_context->mbmi.second_mv.as_mv.row + - second_best_ref_mv->as_mv.row) >> 1)]++; + cpi->MVcount[1][mv_max+((x->e_mbd.mode_info_context->mbmi.second_mv.as_mv.col + - second_best_ref_mv->as_mv.col) >> 1)]++; + } +#endif } } } @@ -2740,7 +2777,8 @@ static void vp8_estimate_ref_frame_costs(VP8_COMP *cpi, int segment_id, unsigned static void store_coding_context (MACROBLOCK *x, int mb_index, int mode_index, PARTITION_INFO *partition, - int_mv *ref_mv) + int_mv *ref_mv, + int_mv *second_ref_mv) { MACROBLOCKD *xd = &x->e_mbd; @@ -2752,6 +2790,7 @@ static void store_coding_context (MACROBLOCK *x, int mb_index, vpx_memcpy(&x->mb_context[mb_index].partition_info, partition, sizeof(PARTITION_INFO)); x->mb_context[mb_index].best_ref_mv.as_int = ref_mv->as_int; + x->mb_context[mb_index].second_best_ref_mv.as_int = second_ref_mv->as_int; //x->mb_context[mb_index].rddiv = x->rddiv; //x->mb_context[mb_index].rdmult = x->rdmult; @@ -3847,7 +3886,8 @@ void vp8_rd_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int *best_single_rd_diff = *best_comp_rd_diff = *best_hybrid_rd_diff = 0; store_coding_context (x, mb_index, best_mode_index, &best_partition, - &frame_best_ref_mv[xd->mode_info_context->mbmi.ref_frame] ); + &frame_best_ref_mv[xd->mode_info_context->mbmi.ref_frame], + &frame_best_ref_mv[xd->mode_info_context->mbmi.second_ref_frame]); return; } @@ -3898,7 +3938,8 @@ void vp8_rd_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int *best_hybrid_rd_diff = best_rd - best_hybrid_rd; store_coding_context (x, mb_index, best_mode_index, &best_partition, - &frame_best_ref_mv[xd->mode_info_context->mbmi.ref_frame] ); + &frame_best_ref_mv[xd->mode_info_context->mbmi.ref_frame], + &frame_best_ref_mv[xd->mode_info_context->mbmi.second_ref_frame]); } int vp8_rd_pick_intra_mode(VP8_COMP *cpi, MACROBLOCK *x) diff --git a/vp8/encoder/rdopt.h b/vp8/encoder/rdopt.h index 0a1920a..5e11c8d 100644 --- a/vp8/encoder/rdopt.h +++ b/vp8/encoder/rdopt.h @@ -35,6 +35,9 @@ extern void vp8_mv_pred extern void vp8_cal_sad(VP8_COMP *cpi, MACROBLOCKD *xd, MACROBLOCK *x, int recon_yoffset, int near_sadidx[]); extern void vp8_init_me_luts(); extern void vp8_set_mbmode_and_mvs(MACROBLOCK *x, MB_PREDICTION_MODE mb, int_mv *mv); -void rd_update_mvcount(VP8_COMP *cpi, MACROBLOCK *x, int_mv *best_ref_mv); +extern void rd_update_mvcount(VP8_COMP *cpi, + MACROBLOCK *x, + int_mv *best_ref_mv, + int_mv *second_best_ref_mv); #endif -- 2.7.4