expanded_coef_context
int_8x8fdct
newintramodes
+ adaptive_entropy
"
CONFIG_LIST="
external_build
#include "onyxc_int.h"
#include "findnearmv.h"
#include "entropymode.h"
+#include "entropymv.h"
#include "systemdependent.h"
vp8_entropy_mode_init();
+ vp8_entropy_mv_init();
+
vp8_init_scan_order_mask();
}
#include "string.h"
#include "blockd.h"
#include "onyxc_int.h"
+#include "entropymode.h"
#include "vpx_mem/vpx_mem.h"
#define uchar unsigned char /* typedefs can clash */
init_bit_trees();
vp8_tokens_from_tree(vp8_coef_encodings, vp8_coef_tree);
}
+
+#if CONFIG_ADAPTIVE_ENTROPY
+
+//#define COEF_COUNT_TESTING
+
+#define COEF_COUNT_SAT 24
+#define COEF_MAX_UPDATE_FACTOR 112
+#define COEF_COUNT_SAT_KEY 24
+#define COEF_MAX_UPDATE_FACTOR_KEY 112
+#define COEF_COUNT_SAT_AFTER_KEY 24
+#define COEF_MAX_UPDATE_FACTOR_AFTER_KEY 128
+
+void vp8_adapt_coef_probs(VP8_COMMON *cm)
+{
+ int t, i, j, k, count;
+ unsigned int branch_ct[ENTROPY_NODES][2];
+ vp8_prob coef_probs[ENTROPY_NODES];
+ int update_factor; /* denominator 256 */
+ int factor;
+ int count_sat;
+
+ //printf("Frame type: %d\n", cm->frame_type);
+ if (cm->frame_type == KEY_FRAME)
+ {
+ update_factor = COEF_MAX_UPDATE_FACTOR_KEY;
+ count_sat = COEF_COUNT_SAT_KEY;
+ }
+ else if (cm->last_frame_type == KEY_FRAME)
+ {
+ update_factor = COEF_MAX_UPDATE_FACTOR_AFTER_KEY; /* adapt quickly */
+ count_sat = COEF_COUNT_SAT_AFTER_KEY;
+ }
+ else
+ {
+ update_factor = COEF_MAX_UPDATE_FACTOR;
+ count_sat = COEF_COUNT_SAT;
+ }
+
+#ifdef COEF_COUNT_TESTING
+ {
+ printf("static const unsigned int\ncoef_counts"
+ "[BLOCK_TYPES] [COEF_BANDS]"
+ "[PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS] = {\n");
+ for (i = 0; i<BLOCK_TYPES; ++i)
+ {
+ printf(" {\n");
+ for (j = 0; j<COEF_BANDS; ++j)
+ {
+ printf(" {\n");
+ for (k = 0; k<PREV_COEF_CONTEXTS; ++k)
+ {
+ printf(" {");
+ for (t = 0; t<MAX_ENTROPY_TOKENS; ++t) printf("%d, ", cm->fc.coef_counts[i][j][k][t]);
+ printf("},\n");
+ }
+ printf(" },\n");
+ }
+ printf(" },\n");
+ }
+ printf("};\n");
+ printf("static const unsigned int\ncoef_counts_8x8"
+ "[BLOCK_TYPES_8X8] [COEF_BANDS]"
+ "[PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS] = {\n");
+ for (i = 0; i<BLOCK_TYPES_8X8; ++i)
+ {
+ printf(" {\n");
+ for (j = 0; j<COEF_BANDS; ++j)
+ {
+ printf(" {\n");
+ for (k = 0; k<PREV_COEF_CONTEXTS; ++k)
+ {
+ printf(" {");
+ for (t = 0; t<MAX_ENTROPY_TOKENS; ++t) printf("%d, ", cm->fc.coef_counts_8x8[i][j][k][t]);
+ printf("},\n");
+ }
+ printf(" },\n");
+ }
+ printf(" },\n");
+ }
+ printf("};\n");
+ }
+#endif
+
+ for (i = 0; i<BLOCK_TYPES; ++i)
+ for (j = 0; j<COEF_BANDS; ++j)
+ for (k = 0; k<PREV_COEF_CONTEXTS; ++k)
+ {
+#if CONFIG_EXPANDED_COEF_CONTEXT
+ if (k >=3 && ((i == 0 && j == 1) || (i > 0 && j == 0)))
+ continue;
+#endif
+ vp8_tree_probs_from_distribution(
+ MAX_ENTROPY_TOKENS, vp8_coef_encodings, vp8_coef_tree,
+ coef_probs, branch_ct, cm->fc.coef_counts [i][j][k],
+ 256, 1);
+ for (t=0; t<ENTROPY_NODES; ++t)
+ {
+ int prob;
+ count = branch_ct[t][0] + branch_ct[t][1];
+ count = count > count_sat ? count_sat : count;
+ factor = (update_factor * count / count_sat);
+ prob = ((int)cm->fc.pre_coef_probs[i][j][k][t] * (256-factor) +
+ (int)coef_probs[t] * factor + 128) >> 8;
+ if (prob <= 0) cm->fc.coef_probs[i][j][k][t] = 1;
+ else if (prob > 255) cm->fc.coef_probs[i][j][k][t] = 255;
+ else cm->fc.coef_probs[i][j][k][t] = prob;
+ }
+ }
+
+ for (i = 0; i<BLOCK_TYPES_8X8; ++i)
+ for (j = 0; j<COEF_BANDS; ++j)
+ for (k = 0; k<PREV_COEF_CONTEXTS; ++k)
+ {
+#if CONFIG_EXPANDED_COEF_CONTEXT
+ if (k >=3 && ((i == 0 && j == 1) || (i > 0 && j == 0)))
+ continue;
+#endif
+ vp8_tree_probs_from_distribution(
+ MAX_ENTROPY_TOKENS, vp8_coef_encodings, vp8_coef_tree,
+ coef_probs, branch_ct, cm->fc.coef_counts_8x8 [i][j][k],
+ 256, 1);
+ for (t=0; t<ENTROPY_NODES; ++t)
+ {
+ int prob;
+ count = branch_ct[t][0] + branch_ct[t][1];
+ count = count > count_sat ? count_sat : count;
+ factor = (update_factor * count / count_sat);
+ prob = ((int)cm->fc.pre_coef_probs_8x8[i][j][k][t] * (256-factor) +
+ (int)coef_probs[t] * factor + 128) >> 8;
+ if (prob <= 0) cm->fc.coef_probs_8x8[i][j][k][t] = 1;
+ else if (prob > 255) cm->fc.coef_probs_8x8[i][j][k][t] = 255;
+ else cm->fc.coef_probs_8x8[i][j][k][t] = prob;
+ }
+ }
+}
+#endif
#endif
#if CONFIG_NEWUPDATE
-#define SUBEXP_PARAM 2 /* Subexponential code parameter */
-#define MODULUS_PARAM 21 /* Modulus parameter */
-#define COEFUPDATETYPE 2 /* coef update type to use (1/2/3) */
+#define SUBEXP_PARAM 4 /* Subexponential code parameter */
+#define MODULUS_PARAM 13 /* Modulus parameter */
+#define COEFUPDATETYPE 1 /* coef update type to use (1/2/3) */
#endif
extern DECLARE_ALIGNED(64, const int, vp8_default_zig_zag1d_8x8[64]);
extern short vp8_default_zig_zag_mask_8x8[64];//int64_t
void vp8_coef_tree_initialize(void);
+
+#if CONFIG_ADAPTIVE_ENTROPY
+void vp8_adapt_coef_probs(struct VP8Common *);
+#endif
#endif
#include "modecont.h"
#include "entropymode.h"
+#include "entropymv.h"
#include "entropy.h"
#include "vpx_mem/vpx_mem.h"
struct vp8_token_struct vp8_mv_ref_encoding_array [VP8_MVREFS];
struct vp8_token_struct vp8_sub_mv_ref_encoding_array [VP8_SUBMVREFS];
-#if CONFIG_HIGH_PRECISION_MV
-const vp8_tree_index vp8_small_mvtree_hp [30] =
-{
- 2, 16,
- 4, 10,
- 6, 8,
- -0, -1,
- -2, -3,
- 12, 14,
- -4, -5,
- -6, -7,
- 18, 24,
- 20, 22,
- -8, -9,
- -10, -11,
- 26, 28,
- -12, -13,
- -14, -15
-};
-struct vp8_token_struct vp8_small_mvencodings_hp [16];
-#endif /* CONFIG_HIGH_PRECISION_MV */
-
-const vp8_tree_index vp8_small_mvtree [14] =
-{
- 2, 8,
- 4, 6,
- -0, -1,
- -2, -3,
- 10, 12,
- -4, -5,
- -6, -7
-};
-struct vp8_token_struct vp8_small_mvencodings [8];
-
void vp8_init_mbmode_probs(VP8_COMMON *x)
vp8_tree_probs_from_distribution(
VP8_I8X8_MODES, vp8_i8x8_mode_encodings, vp8_i8x8_mode_tree,
- x->i8x8_mode_prob, bct, i8x8_mode_cts,
+ 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));
vp8_mv_ref_tree, NEARESTMV);
vp8_tokens_from_tree_offset(vp8_sub_mv_ref_encoding_array,
vp8_sub_mv_ref_tree, LEFT4X4);
-
- vp8_tokens_from_tree(vp8_small_mvencodings, vp8_small_mvtree);
-#if CONFIG_HIGH_PRECISION_MV
- vp8_tokens_from_tree(vp8_small_mvencodings_hp, vp8_small_mvtree_hp);
-#endif
}
void vp8_init_mode_contexts(VP8_COMMON *pc)
printf("\n");
}
}
+
+#if CONFIG_ADAPTIVE_ENTROPY
+//#define MODE_COUNT_TESTING
+#define MODE_COUNT_SAT 16
+#define MODE_MAX_UPDATE_FACTOR 96
+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];
+#ifdef MODE_COUNT_TESTING
+ printf("static const unsigned int\nymode_counts"
+ "[VP8_YMODES] = {\n");
+ for (t = 0; t<VP8_YMODES; ++t) printf("%d, ", cm->fc.ymode_counts[t]);
+ printf("};\n");
+ printf("static const unsigned int\nuv_mode_counts"
+ "[VP8_YMODES] [VP8_UV_MODES] = {\n");
+ for (i = 0; i < VP8_YMODES; ++i)
+ {
+ printf(" {");
+ for (t = 0; t < VP8_UV_MODES; ++t) printf("%d, ", cm->fc.uv_mode_counts[i][t]);
+ printf("},\n");
+ }
+ printf("};\n");
+ printf("static const unsigned int\nbmode_counts"
+ "[VP8_BINTRAMODES] = {\n");
+ for (t = 0; t<VP8_BINTRAMODES; ++t) printf("%d, ", cm->fc.bmode_counts[t]);
+ printf("};\n");
+ printf("static const unsigned int\ni8x8_mode_counts"
+ "[VP8_I8X8_MODES] = {\n");
+ for (t = 0; t<VP8_I8X8_MODES; ++t) printf("%d, ", cm->fc.i8x8_mode_counts[t]);
+ printf("};\n");
+#endif
+ vp8_tree_probs_from_distribution(
+ VP8_YMODES, vp8_ymode_encodings, vp8_ymode_tree,
+ ymode_probs, branch_ct, cm->fc.ymode_counts,
+ 256, 1);
+ for (t=0; t<VP8_YMODES-1; ++t)
+ {
+ int prob;
+ count = branch_ct[t][0] + branch_ct[t][1];
+ count = count > count_sat ? count_sat : count;
+ factor = (update_factor * count / 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;
+ else if (prob > 255) cm->fc.ymode_prob[t] = 255;
+ else cm->fc.ymode_prob[t] = prob;
+ }
+ for (i = 0; i < VP8_YMODES; ++i)
+ {
+ vp8_tree_probs_from_distribution(
+ VP8_UV_MODES, vp8_uv_mode_encodings, vp8_uv_mode_tree,
+ uvmode_probs, branch_ct, cm->fc.uv_mode_counts[i],
+ 256, 1);
+ for (t = 0; t < VP8_UV_MODES-1; ++t)
+ {
+ int prob;
+ count = branch_ct[t][0] + branch_ct[t][1];
+ count = count > count_sat ? count_sat : count;
+ factor = (update_factor * count / 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;
+ else if (prob > 255) cm->fc.uv_mode_prob[i][t] = 255;
+ else cm->fc.uv_mode_prob[i][t] = prob;
+ }
+ }
+ vp8_tree_probs_from_distribution(
+ VP8_BINTRAMODES, vp8_bmode_encodings, vp8_bmode_tree,
+ bmode_probs, branch_ct, cm->fc.bmode_counts,
+ 256, 1);
+ for (t=0; t<VP8_BINTRAMODES-1; ++t)
+ {
+ int prob;
+ count = branch_ct[t][0] + branch_ct[t][1];
+ count = count > count_sat ? count_sat : count;
+ factor = (update_factor * count / 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;
+ else if (prob > 255) cm->fc.bmode_prob[t] = 255;
+ else cm->fc.bmode_prob[t] = prob;
+ }
+ vp8_tree_probs_from_distribution(
+ VP8_I8X8_MODES, vp8_i8x8_mode_encodings, vp8_i8x8_mode_tree,
+ i8x8_mode_probs, branch_ct, cm->fc.i8x8_mode_counts,
+ 256, 1);
+ for (t=0; t<VP8_I8X8_MODES-1; ++t)
+ {
+ int prob;
+ count = branch_ct[t][0] + branch_ct[t][1];
+ count = count > count_sat ? count_sat : count;
+ factor = (update_factor * count / 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;
+ }
+}
+#endif
extern struct vp8_token_struct vp8_mv_ref_encoding_array [VP8_MVREFS];
extern struct vp8_token_struct vp8_sub_mv_ref_encoding_array [VP8_SUBMVREFS];
-extern const vp8_tree_index vp8_small_mvtree[];
-extern struct vp8_token_struct vp8_small_mvencodings [8];
-#if CONFIG_HIGH_PRECISION_MV
-extern const vp8_tree_index vp8_small_mvtree_hp[];
-extern struct vp8_token_struct vp8_small_mvencodings_hp [16];
-#endif
-
void vp8_entropy_mode_init(void);
void vp8_init_mbmode_probs(VP8_COMMON *x);
MB_PREDICTION_MODE m,
const int ct[4]);
-void vp8_default_bmode_probs(vp8_prob dest [VP8_BINTRAMODES-1]);
+void vp8_default_bmode_probs(vp8_prob dest [VP8_BINTRAMODES-1]);
void vp8_kf_default_bmode_probs(vp8_prob dest [VP8_BINTRAMODES] [VP8_BINTRAMODES] [VP8_BINTRAMODES-1]);
+#if CONFIG_ADAPTIVE_ENTROPY
+void vp8_adapt_mode_probs(struct VP8Common *);
+#endif
#endif
*/
+#include "onyxc_int.h"
#include "entropymv.h"
#if CONFIG_HIGH_PRECISION_MV
128, 130, 130, 74, 148, 180, 203, 236, 254, 254 /* long bits */
}}
};
+
+#if CONFIG_HIGH_PRECISION_MV
+const vp8_tree_index vp8_small_mvtree_hp [30] =
+{
+ 2, 16,
+ 4, 10,
+ 6, 8,
+ -0, -1,
+ -2, -3,
+ 12, 14,
+ -4, -5,
+ -6, -7,
+ 18, 24,
+ 20, 22,
+ -8, -9,
+ -10, -11,
+ 26, 28,
+ -12, -13,
+ -14, -15
+};
+struct vp8_token_struct vp8_small_mvencodings_hp [16];
+#endif /* CONFIG_HIGH_PRECISION_MV */
+
+const vp8_tree_index vp8_small_mvtree [14] =
+{
+ 2, 8,
+ 4, 6,
+ -0, -1,
+ -2, -3,
+ 10, 12,
+ -4, -5,
+ -6, -7
+};
+struct vp8_token_struct vp8_small_mvencodings [8];
+
+
+__inline static void calc_prob(vp8_prob *p, const unsigned int ct[2], int pbits)
+{
+ const unsigned int tot = ct[0] + ct[1];
+ if (tot)
+ {
+ const vp8_prob x = ((ct[0] * 255) / tot) & -(1<<(8-pbits));
+ *p = x ? x : 1;
+ }
+}
+
+static void compute_component_probs(
+ const unsigned int events [MVvals],
+ vp8_prob Pnew [MVPcount],
+ unsigned int is_short_ct[2],
+ unsigned int sign_ct[2],
+ unsigned int bit_ct [mvlong_width] [2],
+ unsigned int short_ct [mvnum_short],
+ unsigned int short_bct [mvnum_short-1] [2]
+)
+{
+ is_short_ct[0] = is_short_ct[1] = 0;
+ sign_ct[0] = sign_ct[1] = 0;
+ vpx_memset(bit_ct, 0, sizeof(unsigned int)*mvlong_width*2);
+ vpx_memset(short_ct, 0, sizeof(unsigned int)*mvnum_short);
+ vpx_memset(short_bct, 0, sizeof(unsigned int)*(mvnum_short-1)*2);
+
+ {
+ const int c = events [mv_max];
+ is_short_ct [0] += c; // Short vector
+ short_ct [0] += c; // Magnitude distribution
+ }
+ {
+ int j = 1;
+ do
+ {
+ const int c1 = events [mv_max + j]; //positive
+ const int c2 = events [mv_max - j]; //negative
+ const int c = c1 + c2;
+ int a = j;
+
+ sign_ct [0] += c1;
+ sign_ct [1] += c2;
+
+ if (a < mvnum_short)
+ {
+ is_short_ct [0] += c; // Short vector
+ short_ct [a] += c; // Magnitude distribution
+ }
+ else
+ {
+ int k = mvlong_width - 1;
+ is_short_ct [1] += c; // Long vector
+
+ do
+ bit_ct [k] [(a >> k) & 1] += c;
+
+ while (--k >= 0);
+ }
+ }
+ while (++j <= mv_max);
+ }
+ calc_prob(Pnew + mvpis_short, is_short_ct, 8);
+
+ calc_prob(Pnew + MVPsign, sign_ct, 8);
+
+ {
+ vp8_prob p [mvnum_short - 1]; /* actually only need branch ct */
+ int j = 0;
+
+ vp8_tree_probs_from_distribution(
+ mvnum_short, vp8_small_mvencodings, vp8_small_mvtree,
+ p, short_bct, short_ct,
+ 256, 1
+ );
+
+ do
+ calc_prob(Pnew + MVPshort + j, short_bct[j], 8);
+ while (++j < mvnum_short - 1);
+ }
+
+ {
+ int j = 0;
+ do
+ calc_prob(Pnew + MVPbits + j, bit_ct[j], 8);
+ while (++j < mvlong_width);
+ }
+}
+
+#if CONFIG_HIGH_PRECISION_MV
+static void compute_component_probs_hp(
+ const unsigned int events [MVvals_hp],
+ vp8_prob Pnew [MVPcount_hp],
+ unsigned int is_short_ct[2],
+ unsigned int sign_ct[2],
+ unsigned int bit_ct [mvlong_width_hp] [2],
+ unsigned int short_ct [mvnum_short_hp],
+ unsigned int short_bct [mvnum_short_hp-1] [2]
+)
+{
+ is_short_ct[0] = is_short_ct[1] = 0;
+ sign_ct[0] = sign_ct[1] = 0;
+ vpx_memset(bit_ct, 0, sizeof(unsigned int)*mvlong_width_hp*2);
+ vpx_memset(short_ct, 0, sizeof(unsigned int)*mvnum_short_hp);
+ vpx_memset(short_bct, 0, sizeof(unsigned int)*(mvnum_short_hp-1)*2);
+
+ {
+ const int c = events [mv_max_hp];
+ is_short_ct [0] += c; // Short vector
+ short_ct [0] += c; // Magnitude distribution
+ }
+ {
+ int j = 1;
+ do
+ {
+ const int c1 = events [mv_max_hp + j]; //positive
+ const int c2 = events [mv_max_hp - j]; //negative
+ const int c = c1 + c2;
+ int a = j;
+
+ sign_ct [0] += c1;
+ sign_ct [1] += c2;
+
+ if (a < mvnum_short_hp)
+ {
+ is_short_ct [0] += c; // Short vector
+ short_ct [a] += c; // Magnitude distribution
+ }
+ else
+ {
+ int k = mvlong_width_hp - 1;
+ is_short_ct [1] += c; // Long vector
+
+ do
+ bit_ct [k] [(a >> k) & 1] += c;
+
+ while (--k >= 0);
+ }
+ }
+ while (++j <= mv_max_hp);
+ }
+ calc_prob(Pnew + mvpis_short_hp, is_short_ct, 8);
+
+ calc_prob(Pnew + MVPsign_hp, sign_ct, 8);
+
+ {
+ vp8_prob p [mvnum_short_hp - 1]; /* actually only need branch ct */
+ int j = 0;
+
+ vp8_tree_probs_from_distribution(
+ mvnum_short_hp, vp8_small_mvencodings_hp, vp8_small_mvtree_hp,
+ p, short_bct, short_ct,
+ 256, 1
+ );
+
+ do
+ calc_prob(Pnew + MVPshort_hp + j, short_bct[j], 8);
+ while (++j < mvnum_short_hp - 1);
+ }
+
+ {
+ int j = 0;
+ do
+ calc_prob(Pnew + MVPbits_hp + j, bit_ct[j], 8);
+ while (++j < mvlong_width_hp);
+ }
+}
+#endif /* CONFIG_HIGH_PRECISION_MV */
+
+void vp8_entropy_mv_init()
+{
+ vp8_tokens_from_tree(vp8_small_mvencodings, vp8_small_mvtree);
+#if CONFIG_HIGH_PRECISION_MV
+ vp8_tokens_from_tree(vp8_small_mvencodings_hp, vp8_small_mvtree_hp);
+#endif
+}
+
+#if CONFIG_ADAPTIVE_ENTROPY
+//#define MV_COUNT_TESTING
+#define MV_COUNT_SAT 16
+#define MV_MAX_UPDATE_FACTOR 128
+void vp8_adapt_mv_probs(VP8_COMMON *cm)
+{
+ int i, t, count, factor;
+#ifdef MV_COUNT_TESTING
+ printf("static const unsigned int\nMVcount[2][MVvals]={\n");
+ for (i = 0; i < 2; ++i)
+ {
+ printf(" { ");
+ for (t = 0; t < MVvals; t++)
+ {
+ printf("%d, ", cm->fc.MVcount[i][t]);
+ if (t%16 == 15 && t!=MVvals-1) printf("\n ");
+ }
+ printf("},\n");
+ }
+ printf("};\n");
+#if CONFIG_HIGH_PRECISION_MV
+ printf("static const unsigned int\nMVcount_hp[2][MVvals_hp]={\n");
+ for (i = 0; i < 2; ++i)
+ {
+ printf(" { ");
+ for (t = 0; t < MVvals_hp; t++)
+ {
+ printf("%d, ", cm->fc.MVcount_hp[i][t]);
+ if (t%16 == 15 && t!=MVvals_hp-1) printf("\n ");
+ }
+ printf("},\n");
+ }
+ printf("};\n");
+#endif
+#endif /* MV_COUNT_TESTING */
+
+ for (i = 0; i < 2; ++i)
+ {
+ int prob;
+ unsigned int is_short_ct[2];
+ unsigned int sign_ct[2];
+ unsigned int bit_ct [mvlong_width] [2];
+ unsigned int short_ct [mvnum_short];
+ unsigned int short_bct [mvnum_short-1] [2];
+ vp8_prob Pnew [MVPcount];
+ compute_component_probs(cm->fc.MVcount[i], Pnew,
+ is_short_ct, sign_ct,
+ bit_ct, short_ct, short_bct);
+ count = is_short_ct[0] + is_short_ct[1];
+ count = count > MV_COUNT_SAT ? MV_COUNT_SAT : count;
+ factor = (MV_MAX_UPDATE_FACTOR * count / MV_COUNT_SAT);
+ prob = ((int)cm->fc.pre_mvc[i].prob[mvpis_short] * (256-factor) +
+ (int)Pnew[mvpis_short] * factor + 128) >> 8;
+ if (prob <= 0) cm->fc.mvc[i].prob[mvpis_short] = 1;
+ else if (prob > 255) cm->fc.mvc[i].prob[mvpis_short] = 255;
+ else cm->fc.mvc[i].prob[mvpis_short] = prob;
+
+ count = sign_ct[0] + sign_ct[1];
+ count = count > MV_COUNT_SAT ? MV_COUNT_SAT : count;
+ factor = (MV_MAX_UPDATE_FACTOR * count / MV_COUNT_SAT);
+ prob = ((int)cm->fc.pre_mvc[i].prob[MVPsign] * (256-factor) +
+ (int)Pnew[MVPsign] * factor + 128) >> 8;
+ if (prob <= 0) cm->fc.mvc[i].prob[MVPsign] = 1;
+ else if (prob > 255) cm->fc.mvc[i].prob[MVPsign] = 255;
+ else cm->fc.mvc[i].prob[MVPsign] = prob;
+
+ for (t = 0; t < mvnum_short - 1; ++t)
+ {
+ count = short_bct[t][0] + short_bct[t][1];
+ count = count > MV_COUNT_SAT ? MV_COUNT_SAT : count;
+ factor = (MV_MAX_UPDATE_FACTOR * count / MV_COUNT_SAT);
+ prob = ((int)cm->fc.pre_mvc[i].prob[MVPshort+t] * (256-factor) +
+ (int)Pnew[MVPshort+t] * factor + 128) >> 8;
+ if (prob <= 0) cm->fc.mvc[i].prob[MVPshort+t] = 1;
+ else if (prob > 255) cm->fc.mvc[i].prob[MVPshort+t] = 255;
+ else cm->fc.mvc[i].prob[MVPshort+t] = prob;
+ }
+ for (t = 0; t < mvlong_width; ++t)
+ {
+ count = bit_ct[t][0] + bit_ct[t][1];
+ count = count > MV_COUNT_SAT ? MV_COUNT_SAT : count;
+ factor = (MV_MAX_UPDATE_FACTOR * count / MV_COUNT_SAT);
+ prob = ((int)cm->fc.pre_mvc[i].prob[MVPbits+t] * (256-factor) +
+ (int)Pnew[MVPbits+t] * factor + 128) >> 8;
+ if (prob <= 0) cm->fc.mvc[i].prob[MVPbits+t] = 1;
+ else if (prob > 255) cm->fc.mvc[i].prob[MVPbits+t] = 255;
+ else cm->fc.mvc[i].prob[MVPbits+t] = prob;
+ }
+ }
+#if CONFIG_HIGH_PRECISION_MV
+ for (i = 0; i < 2; ++i)
+ {
+ int prob;
+ unsigned int is_short_ct[2];
+ unsigned int sign_ct[2];
+ unsigned int bit_ct [mvlong_width_hp] [2];
+ unsigned int short_ct [mvnum_short_hp];
+ unsigned int short_bct [mvnum_short_hp-1] [2];
+ vp8_prob Pnew [MVPcount_hp];
+ compute_component_probs_hp(cm->fc.MVcount_hp[i], Pnew,
+ is_short_ct, sign_ct,
+ bit_ct, short_ct, short_bct);
+ count = is_short_ct[0] + is_short_ct[1];
+ count = count > MV_COUNT_SAT ? MV_COUNT_SAT : count;
+ factor = (MV_MAX_UPDATE_FACTOR * count / MV_COUNT_SAT);
+ prob = ((int)cm->fc.pre_mvc_hp[i].prob[mvpis_short_hp] * (256-factor) +
+ (int)Pnew[mvpis_short_hp] * factor + 128) >> 8;
+ if (prob <= 0) cm->fc.mvc_hp[i].prob[mvpis_short_hp] = 1;
+ else if (prob > 255) cm->fc.mvc_hp[i].prob[mvpis_short_hp] = 255;
+ else cm->fc.mvc_hp[i].prob[mvpis_short_hp] = prob;
+
+ count = sign_ct[0] + sign_ct[1];
+ count = count > MV_COUNT_SAT ? MV_COUNT_SAT : count;
+ factor = (MV_MAX_UPDATE_FACTOR * count / MV_COUNT_SAT);
+ prob = ((int)cm->fc.pre_mvc_hp[i].prob[MVPsign_hp] * (256-factor) +
+ (int)Pnew[MVPsign_hp] * factor + 128) >> 8;
+ if (prob <= 0) cm->fc.mvc_hp[i].prob[MVPsign_hp] = 1;
+ else if (prob > 255) cm->fc.mvc_hp[i].prob[MVPsign_hp] = 255;
+ else cm->fc.mvc_hp[i].prob[MVPsign_hp] = prob;
+
+ for (t = 0; t < mvnum_short_hp - 1; ++t)
+ {
+ count = short_bct[t][0] + short_bct[t][1];
+ count = count > MV_COUNT_SAT ? MV_COUNT_SAT : count;
+ factor = (MV_MAX_UPDATE_FACTOR * count / MV_COUNT_SAT);
+ prob = ((int)cm->fc.pre_mvc_hp[i].prob[MVPshort_hp+t] * (256-factor) +
+ (int)Pnew[MVPshort_hp+t] * factor + 128) >> 8;
+ if (prob <= 0) cm->fc.mvc_hp[i].prob[MVPshort_hp+t] = 1;
+ else if (prob > 255) cm->fc.mvc_hp[i].prob[MVPshort_hp+t] = 255;
+ else cm->fc.mvc_hp[i].prob[MVPshort_hp+t] = prob;
+ }
+ for (t = 0; t < mvlong_width_hp; ++t)
+ {
+ count = bit_ct[t][0] + bit_ct[t][1];
+ count = count > MV_COUNT_SAT ? MV_COUNT_SAT : count;
+ factor = (MV_MAX_UPDATE_FACTOR * count / MV_COUNT_SAT);
+ prob = ((int)cm->fc.pre_mvc_hp[i].prob[MVPbits_hp+t] * (256-factor) +
+ (int)Pnew[MVPbits_hp+t] * factor + 128) >> 8;
+ if (prob <= 0) cm->fc.mvc_hp[i].prob[MVPbits_hp+t] = 1;
+ else if (prob > 255) cm->fc.mvc_hp[i].prob[MVPbits_hp+t] = 255;
+ else cm->fc.mvc_hp[i].prob[MVPbits_hp+t] = prob;
+ }
+ }
+#endif
+}
+#endif /* CONFIG_ADAPTIVE_ENTROPY */
} MV_CONTEXT_HP;
extern const MV_CONTEXT_HP vp8_mv_update_probs_hp[2], vp8_default_mv_context_hp[2];
+
#endif /* CONFIG_HIGH_PRECISION_MV */
+extern const vp8_tree_index vp8_small_mvtree[];
+extern struct vp8_token_struct vp8_small_mvencodings [8];
+#if CONFIG_HIGH_PRECISION_MV
+extern const vp8_tree_index vp8_small_mvtree_hp[];
+extern struct vp8_token_struct vp8_small_mvencodings_hp [16];
+#endif
+
+void vp8_entropy_mv_init();
+
#endif
vp8_prob bmode_prob [VP8_BINTRAMODES-1];
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 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];
#if CONFIG_HIGH_PRECISION_MV
MV_CONTEXT_HP mvc_hp[2];
#endif
+#if CONFIG_ADAPTIVE_ENTROPY
+ MV_CONTEXT pre_mvc[2];
+#if CONFIG_HIGH_PRECISION_MV
+ MV_CONTEXT_HP pre_mvc_hp[2];
+#endif
+ vp8_prob pre_bmode_prob [VP8_BINTRAMODES-1];
+ 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];
+ 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 */
+
+ 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];
+ unsigned int coef_counts [BLOCK_TYPES] [COEF_BANDS]
+ [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS];
+ unsigned int coef_counts_8x8 [BLOCK_TYPES_8X8] [COEF_BANDS]
+ [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS];
+ unsigned int MVcount [2] [MVvals];
+#if CONFIG_HIGH_PRECISION_MV
+ unsigned int MVcount_hp [2] [MVvals_hp];
+#endif
+#endif /* CONFIG_ADAPTIVE_ENTROPY */
} FRAME_CONTEXT;
typedef enum
} VP8_COMMON_RTCD;
typedef struct VP8Common
-
{
struct vpx_internal_error_info error;
int kf_ymode_probs_index;
int kf_ymode_probs_update;
vp8_prob kf_uv_mode_prob[VP8_YMODES] [VP8_UV_MODES-1];
- vp8_prob i8x8_mode_prob [VP8_UV_MODES-1];
vp8_prob prob_intra_coded;
vp8_prob prob_last_coded;
for(i=0;i<4;i++)
{
int ib = vp8_i8x8_block[i];
- mode8x8 = vp8_read_i8x8_mode(bc, pbi->common.i8x8_mode_prob);
+ mode8x8 = vp8_read_i8x8_mode(bc, pbi->common.fc.i8x8_mode_prob);
m->bmi[ib+0].as_mode.first= mode8x8;
m->bmi[ib+1].as_mode.first= mode8x8;
m->bmi[ib+4].as_mode.first= mode8x8;
case NEW4X4:
#if CONFIG_HIGH_PRECISION_MV
if (xd->allow_high_precision_mv)
+ {
read_mv_hp(bc, &blockmv.as_mv, (const MV_CONTEXT_HP *) mvc_hp);
+#if CONFIG_ADAPTIVE_ENTROPY
+ cm->fc.MVcount_hp[0][mv_max_hp+(blockmv.as_mv.row)]++;
+ cm->fc.MVcount_hp[1][mv_max_hp+(blockmv.as_mv.col)]++;
+#endif
+ }
else
#endif
- read_mv(bc, &blockmv.as_mv, (const MV_CONTEXT *) mvc);
+ {
+ read_mv(bc, &blockmv.as_mv, (const MV_CONTEXT *) mvc);
+#if CONFIG_ADAPTIVE_ENTROPY
+ cm->fc.MVcount[0][mv_max+(blockmv.as_mv.row>>1)]++;
+ cm->fc.MVcount[1][mv_max+(blockmv.as_mv.col>>1)]++;
+#endif
+ }
blockmv.as_mv.row += best_mv.as_mv.row;
blockmv.as_mv.col += best_mv.as_mv.col;
secondmv.as_mv.row += best_mv_second.as_mv.row;
secondmv.as_mv.col += best_mv_second.as_mv.col;
}
- #ifdef VPX_MODE_COUNT
+#ifdef VPX_MODE_COUNT
vp8_mv_cont_count[mv_contz][3]++;
- #endif
+#endif
break;
case LEFT4X4:
blockmv.as_int = leftmv.as_int;
if (mbmi->second_ref_frame)
secondmv.as_int = second_leftmv.as_int;
- #ifdef VPX_MODE_COUNT
+#ifdef VPX_MODE_COUNT
vp8_mv_cont_count[mv_contz][0]++;
- #endif
+#endif
break;
case ABOVE4X4:
blockmv.as_int = abovemv.as_int;
if (mbmi->second_ref_frame)
secondmv.as_int = second_abovemv.as_int;
- #ifdef VPX_MODE_COUNT
+#ifdef VPX_MODE_COUNT
vp8_mv_cont_count[mv_contz][1]++;
- #endif
+#endif
break;
case ZERO4X4:
blockmv.as_int = 0;
case NEWMV:
#if CONFIG_HIGH_PRECISION_MV
if (xd->allow_high_precision_mv)
+ {
read_mv_hp(bc, &mv->as_mv, (const MV_CONTEXT_HP *) mvc_hp);
+#if CONFIG_ADAPTIVE_ENTROPY
+ cm->fc.MVcount_hp[0][mv_max_hp+(mv->as_mv.row)]++;
+ cm->fc.MVcount_hp[1][mv_max_hp+(mv->as_mv.col)]++;
+#endif
+ }
else
#endif
- read_mv(bc, &mv->as_mv, (const MV_CONTEXT *) mvc);
+ {
+ read_mv(bc, &mv->as_mv, (const MV_CONTEXT *) mvc);
+#if CONFIG_ADAPTIVE_ENTROPY
+ cm->fc.MVcount[0][mv_max+(mv->as_mv.row>>1)]++;
+ cm->fc.MVcount[1][mv_max+(mv->as_mv.col>>1)]++;
+#endif
+ }
mv->as_mv.row += best_mv.as_mv.row;
mv->as_mv.col += best_mv.as_mv.col;
{
mbmi->mode = (MB_PREDICTION_MODE)
vp8_read_ymode(bc, pbi->common.fc.ymode_prob);
+#if CONFIG_ADAPTIVE_ENTROPY
+ pbi->common.fc.ymode_counts[mbmi->mode]++;
+#endif
}
#if CONFIG_COMP_INTRA_PRED
mbmi->second_mode = (MB_PREDICTION_MODE) (DC_PRED - 1);
do
{
mi->bmi[j].as_mode.first = (B_PREDICTION_MODE)vp8_read_bmode(bc, pbi->common.fc.bmode_prob);
+#if CONFIG_ADAPTIVE_ENTROPY
+ pbi->common.fc.bmode_counts[mi->bmi[j].as_mode.first]++;
+#endif
#if CONFIG_COMP_INTRA_PRED
if (use_comp_pred)
{
for(i=0;i<4;i++)
{
int ib = vp8_i8x8_block[i];
- mode8x8 = vp8_read_i8x8_mode(bc, pbi->common.i8x8_mode_prob);
+ mode8x8 = vp8_read_i8x8_mode(bc, pbi->common.fc.i8x8_mode_prob);
mi->bmi[ib+0].as_mode.first= mode8x8;
mi->bmi[ib+1].as_mode.first= mode8x8;
mi->bmi[ib+4].as_mode.first= mode8x8;
mi->bmi[ib+5].as_mode.first= mode8x8;
+#if CONFIG_ADAPTIVE_ENTROPY
+ pbi->common.fc.i8x8_mode_counts[mode8x8]++;
+#endif
#if CONFIG_COMP_INTRA_PRED
mi->bmi[ib+0].as_mode.second= (MB_PREDICTION_MODE) (DC_PRED - 1);
mi->bmi[ib+1].as_mode.second= (MB_PREDICTION_MODE) (DC_PRED - 1);
}
}
else
+ {
mbmi->uv_mode = (MB_PREDICTION_MODE)vp8_read_uv_mode(bc,
pbi->common.fc.uv_mode_prob[mbmi->mode]);
+#if CONFIG_ADAPTIVE_ENTROPY
+ pbi->common.fc.uv_mode_counts[mbmi->mode][mbmi->uv_mode]++;
+#endif
+ }
#if CONFIG_COMP_INTRA_PRED
mbmi->second_uv_mode = (MB_PREDICTION_MODE) (DC_PRED - 1);
int dec_debug = 0;
#endif
+#define COEFCOUNT_TESTING
+
#if CONFIG_NEWUPDATE
static int merge_index(int v, int n, int modulus)
}
else
{
+ pc->last_frame_type = pc->frame_type;
pc->frame_type = (FRAME_TYPE)(data[0] & 1);
pc->version = (data[0] >> 1) & 7;
pc->show_frame = (data[0] >> 4) & 1;
fclose(z);
}
+#if CONFIG_ADAPTIVE_ENTROPY
+ vp8_copy(pbi->common.fc.pre_coef_probs, pbi->common.fc.coef_probs);
+ vp8_copy(pbi->common.fc.pre_coef_probs_8x8, pbi->common.fc.coef_probs_8x8);
+ vp8_copy(pbi->common.fc.pre_ymode_prob, pbi->common.fc.ymode_prob);
+ 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_mvc, pbi->common.fc.mvc);
+#if CONFIG_HIGH_PRECISION_MV
+ vp8_copy(pbi->common.fc.pre_mvc_hp, pbi->common.fc.mvc_hp);
+#endif
+ vp8_zero(pbi->common.fc.coef_counts);
+ vp8_zero(pbi->common.fc.coef_counts_8x8);
+ vp8_zero(pbi->common.fc.ymode_counts);
+ 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.MVcount);
+#if CONFIG_HIGH_PRECISION_MV
+ vp8_zero(pbi->common.fc.MVcount_hp);
+#endif
+#endif
#if COEFUPDATETYPE == 2
read_coef_probs2(pbi);
#elif COEFUPDATETYPE == 3
vpx_memcpy(&xd->pre, &pc->yv12_fb[pc->lst_fb_idx], sizeof(YV12_BUFFER_CONFIG));
vpx_memcpy(&xd->dst, &pc->yv12_fb[pc->new_fb_idx], sizeof(YV12_BUFFER_CONFIG));
- // Create the segmentation map structure and set to 0
- if (!pc->last_frame_seg_map)
+ // Create the segmentation map structure and set to 0
+ if (!pc->last_frame_seg_map)
CHECK_MEM_ERROR(pc->last_frame_seg_map,
vpx_calloc((pc->mb_rows * pc->mb_cols), 1));
}
/* vpx_log("Decoder: Frame Decoded, Size Roughly:%d bytes \n",bc->pos+pbi->bc2.pos); */
+#if CONFIG_ADAPTIVE_ENTROPY
+ vp8_adapt_coef_probs(pc);
+ if (pc->frame_type != KEY_FRAME)
+ {
+ vp8_adapt_mode_probs(pc);
+ vp8_adapt_mv_probs(pc);
+ }
+#endif
/* If this was a kf or Gf note the Q used */
if ((pc->frame_type == KEY_FRAME) ||
++c; \
goto DO_WHILE; }\
qcoeff_ptr [ 15 ] = (INT16) v; \
+ c++; \
goto BLOCK_FINISHED;
++c; \
goto DO_WHILE_8x8; }\
qcoeff_ptr [ scan[3] ] = (INT16) v; \
+ c++; \
goto BLOCK_FINISHED_8x8;
#define DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT_8x8(val) \
DECODE_AND_APPLYSIGN(val) \
++c; \
goto DO_WHILE_8x8; }\
qcoeff_ptr [ scan[63] ] = (INT16) v; \
+ c++; \
goto BLOCK_FINISHED_8x8;
NORMALIZE
+#if CONFIG_ADAPTIVE_ENTROPY
+int get_token(int v)
+{
+ if (v < 0) v = -v;
+ if (v == 0) return ZERO_TOKEN;
+ else if (v == 1) return ONE_TOKEN;
+ else if (v == 2) return TWO_TOKEN;
+ else if (v == 3) return THREE_TOKEN;
+ else if (v == 4) return FOUR_TOKEN;
+ else if (v <= 6) return DCT_VAL_CATEGORY1;
+ else if (v <= 10) return DCT_VAL_CATEGORY2;
+ else if (v <= 18) return DCT_VAL_CATEGORY3;
+ else if (v <= 34) return DCT_VAL_CATEGORY4;
+ else if (v <= 66) return DCT_VAL_CATEGORY5;
+ else return DCT_VAL_CATEGORY6;
+}
+
+void static count_tokens(INT16 *qcoeff_ptr, int block, int type,
+ ENTROPY_CONTEXT *a, ENTROPY_CONTEXT *l,
+ int eob, int seg_eob, FRAME_CONTEXT *fc)
+{
+ int c, pt, token, band;
+ VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l);
+ for (c = !type; c < eob; ++c)
+ {
+ int rc = vp8_default_zig_zag1d[c];
+ int v = qcoeff_ptr[rc];
+ band = vp8_coef_bands[c];
+ token = get_token(v);
+ fc->coef_counts[type][band][pt][token]++;
+ pt = vp8_prev_token_class[token];
+ }
+ if (eob < seg_eob)
+ {
+ band = vp8_coef_bands[c];
+ fc->coef_counts[type][band][pt][DCT_EOB_TOKEN]++;
+ }
+}
+
+void static count_tokens_8x8(INT16 *qcoeff_ptr, int block, int type,
+ ENTROPY_CONTEXT *a, ENTROPY_CONTEXT *l,
+ int eob, int seg_eob, FRAME_CONTEXT *fc)
+{
+ int c, pt, token, band;
+ VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l);
+ for (c = !type; c < eob; ++c)
+ {
+ int rc = (type == 1 ? vp8_default_zig_zag1d[c] : vp8_default_zig_zag1d_8x8[c]);
+ int v = qcoeff_ptr[rc];
+ band = (type == 1 ? vp8_coef_bands[c] : vp8_coef_bands_8x8[c]);
+ token = get_token(v);
+ fc->coef_counts_8x8[type][band][pt][token]++;
+ pt = vp8_prev_token_class[token];
+ }
+ if (eob < seg_eob)
+ {
+ band = (type == 1 ? vp8_coef_bands[c] : vp8_coef_bands_8x8[c]);
+ fc->coef_counts_8x8[type][band][pt][DCT_EOB_TOKEN]++;
+ }
+}
+#endif
+
int vp8_decode_mb_tokens_8x8(VP8D_COMP *dx, MACROBLOCKD *x)
{
ENTROPY_CONTEXT *A = (ENTROPY_CONTEXT *)x->above_context;
qcoeff_ptr [ scan[3] ] = (INT16) v;//15
else
qcoeff_ptr [ scan[63] ] = (INT16) v;
+ c++;
BLOCK_FINISHED_8x8:
+#if CONFIG_ADAPTIVE_ENTROPY
+ count_tokens_8x8(qcoeff_ptr, i, type, a, l, c, seg_eob, &dx->common.fc);
+#endif
*a = *l = ((eobs[i] = c) != !type); // any nonzero data?
if (i!=24)
{
}
qcoeff_ptr [ 15 ] = (INT16) v;
+ ++c;
BLOCK_FINISHED:
+#if CONFIG_ADAPTIVE_ENTROPY
+ count_tokens(qcoeff_ptr, i, type, a, l, c, seg_eob, &dx->common.fc);
+#endif
*a = *l = ((eobs[i] = c) != !type); /* any nonzero data? */
eobtotal += c;
#endif
if ( !segfeature_active( xd, segment_id, SEG_LVL_MODE ) )
+ {
write_ymode(w, mode, pc->fc.ymode_prob);
+ }
if (mode == B_PRED)
{
if(mode == I8X8_PRED)
{
write_i8x8_mode(w, m->bmi[0].as_mode.first,
- pc->i8x8_mode_prob);
+ pc->fc.i8x8_mode_prob);
write_i8x8_mode(w, m->bmi[2].as_mode.first,
- pc->i8x8_mode_prob);
+ pc->fc.i8x8_mode_prob);
write_i8x8_mode(w, m->bmi[8].as_mode.first,
- pc->i8x8_mode_prob);
+ pc->fc.i8x8_mode_prob);
write_i8x8_mode(w, m->bmi[10].as_mode.first,
- pc->i8x8_mode_prob);
+ pc->fc.i8x8_mode_prob);
}
else
{
write_uv_mode(w, mi->uv_mode,
pc->fc.uv_mode_prob[mode]);
-#ifdef MODE_STATS
- if(mode!=B_PRED)
- ++cpi->y_uv_mode_count[mode][mi->uv_mode];
-#endif
}
}
else
if(ym == I8X8_PRED)
{
write_i8x8_mode(bc, m->bmi[0].as_mode.first,
- c->i8x8_mode_prob);
+ c->fc.i8x8_mode_prob);
//printf(" mode: %d\n", m->bmi[0].as_mode.first); fflush(stdout);
write_i8x8_mode(bc, m->bmi[2].as_mode.first,
- c->i8x8_mode_prob);
+ c->fc.i8x8_mode_prob);
//printf(" mode: %d\n", m->bmi[2].as_mode.first); fflush(stdout);
write_i8x8_mode(bc, m->bmi[8].as_mode.first,
- c->i8x8_mode_prob);
+ c->fc.i8x8_mode_prob);
//printf(" mode: %d\n", m->bmi[8].as_mode.first); fflush(stdout);
write_i8x8_mode(bc, m->bmi[10].as_mode.first,
- c->i8x8_mode_prob);
+ c->fc.i8x8_mode_prob);
//printf(" mode: %d\n", m->bmi[10].as_mode.first); fflush(stdout);
}
else
vp8_clear_system_state(); //__asm emms;
// Build the cofficient contexts based on counts collected in encode loop
+
build_coeff_contexts(cpi);
//vp8_prob bestupd = find_coef_update_prob(cpi);
vp8_prob *Pold = cpi->common.fc.coef_probs_8x8 [i][j][k] + t;
const vp8_prob oldp = *Pold;
const vp8_prob upd = COEF_UPDATE_PROB_8X8;
-#if CONFIG_NEWUPDATE && defined(SEARCH_NEWP)
- const int s = prob_diff_update_savings_search(ct, oldp, &newp, upd);
- const int u = s > 0 && newp != oldp ? 1 : 0;
-#else
- const int s = prob_update_savings(ct, oldp, newp, upd);
- const int u = s > 0 ? 1 : 0;
+ int s, u;
#if CONFIG_EXPANDED_COEF_CONTEXT
if (k >=3 && ((i == 0 && j == 1) ||
(i > 0 && j == 0)))
continue;
#endif
+#if CONFIG_NEWUPDATE && defined(SEARCH_NEWP)
+ s = prob_diff_update_savings_search(ct, oldp, &newp, upd);
+ u = s > 0 && newp != oldp ? 1 : 0;
+#else
+ s = prob_update_savings(ct, oldp, newp, upd);
+ u = s > 0 ? 1 : 0;
#endif
vp8_write(w, u, upd);
#ifdef ENTROPY_STATS
vp8_clear_system_state(); //__asm emms;
+#if CONFIG_ADAPTIVE_ENTROPY
+ vp8_copy(cpi->common.fc.pre_coef_probs, cpi->common.fc.coef_probs);
+ vp8_copy(cpi->common.fc.pre_coef_probs_8x8, cpi->common.fc.coef_probs_8x8);
+ 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_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
+#endif
#if COEFUPDATETYPE == 2
update_coef_probs2(cpi);
#elif COEFUPDATETYPE == 3
vp8_stop_encode(&cpi->bc2);
*size += cpi->bc2.pos;
+
}
#ifdef ENTROPY_STATS
int b = (i?k+i-1:k);
int a = (1<<b);
if (num_syms<=mk+3*a) {
- count += vp8_count_uniform(num_syms-mk, word-mk);
+ count += vp8_count_uniform(word-mk, num_syms-mk);
break;
} else {
int t = (word>=mk+a);
xd->left_context = &cm->left_context;
vp8_zero(cpi->count_mb_ref_frame_usage)
+ vp8_zero(cpi->bmode_count)
vp8_zero(cpi->ymode_count)
- vp8_zero(cpi->uv_mode_count)
+ vp8_zero(cpi->i8x8_mode_count)
+ vp8_zero(cpi->y_uv_mode_count)
+ //vp8_zero(cpi->uv_mode_count)
x->mvc = cm->fc.mvc;
#if CONFIG_HIGH_PRECISION_MV
vp8_zero(cpi->MVcount_hp);
#endif
vp8_zero(cpi->coef_counts);
+ vp8_zero(cpi->coef_counts_8x8);
vp8cx_frame_init_quantizer(cpi);
#endif
++cpi->ymode_count[m];
- ++cpi->uv_mode_count[uvm];
-
+ if (m!=I8X8_PRED)
+ ++cpi->y_uv_mode_count[m][uvm];
+ else
+ {
+ cpi->i8x8_mode_count[xd->block[0].bmi.as_mode.first]++;
+ cpi->i8x8_mode_count[xd->block[2].bmi.as_mode.first]++;
+ cpi->i8x8_mode_count[xd->block[8].bmi.as_mode.first]++;
+ cpi->i8x8_mode_count[xd->block[10].bmi.as_mode.first]++;
+ }
+ if (m == B_PRED)
+ {
+ int b = 0;
+ do
+ {
+ ++ cpi->bmode_count[xd->block[b].bmi.as_mode.first];
+ }
+ while (++b < 16);
+ }
}
// Experimental stub function to create a per MB zbin adjustment based on
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(c->mb.i8x8_mode_costs,
- x->i8x8_mode_prob,vp8_i8x8_mode_tree);
+ x->fc.i8x8_mode_prob,vp8_i8x8_mode_tree);
}
vp8_pack_bitstream(cpi, dest, size);
update_reference_frames(cm);
+#if CONFIG_ADAPTIVE_ENTROPY
+ vp8_copy(cpi->common.fc.coef_counts, cpi->coef_counts);
+ vp8_copy(cpi->common.fc.coef_counts_8x8, cpi->coef_counts_8x8);
+ vp8_adapt_coef_probs(&cpi->common);
+ if (cpi->common.frame_type != KEY_FRAME)
+ {
+ vp8_copy(cpi->common.fc.ymode_counts, cpi->ymode_count);
+ 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_adapt_mode_probs(&cpi->common);
+
+ vp8_copy(cpi->common.fc.MVcount, cpi->MVcount);
+#if CONFIG_HIGH_PRECISION_MV
+ vp8_copy(cpi->common.fc.MVcount_hp, cpi->MVcount_hp);
+#endif
+ vp8_adapt_mv_probs(&cpi->common);
+ }
+#endif /* CONFIG_ADAPTIVE_ENTROPY */
/* Move storing frame_type out of the above loop since it is also
* needed in motion search besides loopfilter */
vp8_prob ymode_prob [VP8_YMODES-1]; /* interframe intra mode probs */
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];
int mv_ref_ct[6][4][2];
int mode_context[6][4];
int cq_target_quality;
int ymode_count [VP8_YMODES]; /* intra MB type cts this frame */
- int uv_mode_count[VP8_UV_MODES]; /* intra MB type cts this frame */
+ int bmode_count [VP8_BINTRAMODES];
+ int i8x8_mode_count [VP8_I8X8_MODES];
+ //int uv_mode_count[VP8_UV_MODES]; /* intra MB type cts this frame */
unsigned int MVcount [2] [MVvals]; /* (row,col) MV cts this frame */
#if CONFIG_HIGH_PRECISION_MV
vp8_copy( cc->mode_context_a, cm->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 );
// Stats
#ifdef MODE_STATS
vp8_copy( cm->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);
// Stats
projects / platform / upstream / libvpx.git / commitdiff