Make the backward updates work with bitshifts

Removes integer divides from backward updates for VP10.
Currently this is put in as part of the entropy experiment.
Coding efficiency change is in the noise level.

Change-Id: I5b3c0ab6169ee6d82d0ca1778e264fd4577cdd32

diff --git a/vp10/common/entropy.c b/vp10/common/entropy.c
index 20594dfed33516810dd04a658f850df386ee0428..eea552cf419046f878fbe40131e31372a616fc3c 100644 (file)
--- a/vp10/common/entropy.c
+++ b/vp10/common/entropy.c
@@ -2840,13 +2840,6 @@ void vp10_default_coef_probs(VP10_COMMON *cm) {
 #endif  // CONFIG_ANS
 }
 
-#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
-
 static void adapt_coef_probs(VP10_COMMON *cm, TX_SIZE tx_size,
                              unsigned int count_sat,
                              unsigned int update_factor) {
@@ -2880,9 +2873,9 @@ static void adapt_coef_probs(VP10_COMMON *cm, TX_SIZE tx_size,
             { n1, n2 }
           };
           for (m = 0; m < UNCONSTRAINED_NODES; ++m)
-            probs[i][j][k][l][m] = merge_probs(pre_probs[i][j][k][l][m],
-                                               branch_ct[m],
-                                               count_sat, update_factor);
+            probs[i][j][k][l][m] = vp10_merge_probs(pre_probs[i][j][k][l][m],
+                                                    branch_ct[m],
+                                                    count_sat, update_factor);
         }
 }
 
@@ -2890,20 +2883,25 @@ void vp10_adapt_coef_probs(VP10_COMMON *cm) {
   TX_SIZE t;
   unsigned int count_sat, update_factor;
 
-  if (frame_is_intra_only(cm)) {
-    update_factor = COEF_MAX_UPDATE_FACTOR_KEY;
-    count_sat = COEF_COUNT_SAT_KEY;
-  } else if (cm->last_frame_type == KEY_FRAME) {
+#if CONFIG_ENTROPY
+  if (cm->last_frame_type == KEY_FRAME) {
+    update_factor = COEF_MAX_UPDATE_FACTOR_AFTER_KEY_BITS;  /* adapt quickly */
+    count_sat = COEF_COUNT_SAT_AFTER_KEY_BITS;
+  } else {
+    update_factor = COEF_MAX_UPDATE_FACTOR_BITS;
+    count_sat = COEF_COUNT_SAT_BITS;
+  }
+  if (cm->partial_prob_update == 1) {
+    update_factor = COEF_MAX_UPDATE_FACTOR_BITS;
+  }
+#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;
   }
-#if CONFIG_ENTROPY
-  if (cm->partial_prob_update == 1) {
-    update_factor = COEF_MAX_UPDATE_FACTOR;
-  }
 #endif  // CONFIG_ENTROPY
   for (t = TX_4X4; t <= TX_32X32; t++)
     adapt_coef_probs(cm, t, count_sat, update_factor);

diff --git a/vp10/common/entropy.h b/vp10/common/entropy.h
index 34da5259c6adbb63dde361a28555e14509341396..d0ca880aa01e3f9949ea6f67fe55ea039720c836 100644 (file)
--- a/vp10/common/entropy.h
+++ b/vp10/common/entropy.h
@@ -231,6 +231,51 @@ static INLINE int get_entropy_context(TX_SIZE tx_size, const ENTROPY_CONTEXT *a,
 struct frame_contexts;
 void vp10_coef_pareto_cdfs(struct frame_contexts *fc);
 #endif  // CONFIG_ANS
+
+#if CONFIG_ENTROPY
+#define COEF_COUNT_SAT_BITS                   5
+#define COEF_MAX_UPDATE_FACTOR_BITS           7
+#define COEF_COUNT_SAT_AFTER_KEY_BITS         5
+#define COEF_MAX_UPDATE_FACTOR_AFTER_KEY_BITS 7
+#define MODE_MV_COUNT_SAT_BITS                5
+#define MODE_MV_MAX_UPDATE_FACTOR_BITS        7
+
+#else
+
+#define COEF_COUNT_SAT 24
+#define COEF_MAX_UPDATE_FACTOR 112
+#define COEF_COUNT_SAT_AFTER_KEY 24
+#define COEF_MAX_UPDATE_FACTOR_AFTER_KEY 128
+
+#endif  // CONFIG_ENTROPY
+
+static INLINE vpx_prob vp10_merge_probs(vpx_prob pre_prob,
+                                        const unsigned int ct[2],
+                                        unsigned int count_sat,
+                                        unsigned int max_update_factor) {
+#if CONFIG_ENTROPY
+  const vpx_prob prob = get_binary_prob(ct[0], ct[1]);
+  const unsigned int count =
+      VPXMIN(ct[0] + ct[1], (unsigned int)(1 << count_sat));
+  const unsigned int factor =
+      count << (max_update_factor - count_sat);
+  return weighted_prob(pre_prob, prob, factor);
+#else
+  return merge_probs(pre_prob, ct, count_sat, max_update_factor);
+#endif  // CONFIG_ENTROPY
+}
+
+static INLINE vpx_prob vp10_mode_mv_merge_probs(vpx_prob pre_prob,
+                                                const unsigned int ct[2]) {
+#if CONFIG_ENTROPY
+  return vp10_merge_probs(pre_prob, ct,
+                          MODE_MV_COUNT_SAT_BITS,
+                          MODE_MV_MAX_UPDATE_FACTOR_BITS);
+#else
+  return mode_mv_merge_probs(pre_prob, ct);
+#endif  // CONFIG_ENTROPY
+}
+
 #ifdef __cplusplus
 }  // extern "C"
 #endif

diff --git a/vp10/common/entropymode.c b/vp10/common/entropymode.c
index f1c8e30d0118902a4d1954ff8ff8fd6a8837e2c7..f335b97807c8322852a0a43b49bee1361e5cdb47 100644 (file)
--- a/vp10/common/entropymode.c
+++ b/vp10/common/entropymode.c
@@ -1270,37 +1270,37 @@ void vp10_adapt_inter_frame_probs(VP10_COMMON *cm) {
   const FRAME_COUNTS *counts = &cm->counts;
 
   for (i = 0; i < INTRA_INTER_CONTEXTS; i++)
-    fc->intra_inter_prob[i] = mode_mv_merge_probs(pre_fc->intra_inter_prob[i],
-                                                  counts->intra_inter[i]);
+    fc->intra_inter_prob[i] = vp10_mode_mv_merge_probs(
+        pre_fc->intra_inter_prob[i], counts->intra_inter[i]);
   for (i = 0; i < COMP_INTER_CONTEXTS; i++)
-    fc->comp_inter_prob[i] = mode_mv_merge_probs(pre_fc->comp_inter_prob[i],
-                                                 counts->comp_inter[i]);
+    fc->comp_inter_prob[i] = vp10_mode_mv_merge_probs(
+        pre_fc->comp_inter_prob[i], counts->comp_inter[i]);
   for (i = 0; i < REF_CONTEXTS; i++)
     for (j = 0; j < (COMP_REFS - 1); j++)
-      fc->comp_ref_prob[i][j] = mode_mv_merge_probs(pre_fc->comp_ref_prob[i][j],
-                                                    counts->comp_ref[i][j]);
+      fc->comp_ref_prob[i][j] = vp10_mode_mv_merge_probs(
+          pre_fc->comp_ref_prob[i][j], counts->comp_ref[i][j]);
   for (i = 0; i < REF_CONTEXTS; i++)
     for (j = 0; j < (SINGLE_REFS - 1); j++)
-      fc->single_ref_prob[i][j] = mode_mv_merge_probs(
+      fc->single_ref_prob[i][j] = vp10_mode_mv_merge_probs(
           pre_fc->single_ref_prob[i][j], counts->single_ref[i][j]);
 
 #if CONFIG_REF_MV
   for (i = 0; i < NEWMV_MODE_CONTEXTS; ++i)
-    fc->newmv_prob[i] = mode_mv_merge_probs(pre_fc->newmv_prob[i],
-                                            counts->newmv_mode[i]);
+    fc->newmv_prob[i] = vp10_mode_mv_merge_probs(pre_fc->newmv_prob[i],
+                                                 counts->newmv_mode[i]);
   for (i = 0; i < ZEROMV_MODE_CONTEXTS; ++i)
-    fc->zeromv_prob[i] = mode_mv_merge_probs(pre_fc->zeromv_prob[i],
-                                             counts->zeromv_mode[i]);
+    fc->zeromv_prob[i] = vp10_mode_mv_merge_probs(pre_fc->zeromv_prob[i],
+                                                  counts->zeromv_mode[i]);
   for (i = 0; i < REFMV_MODE_CONTEXTS; ++i)
-    fc->refmv_prob[i] = mode_mv_merge_probs(pre_fc->refmv_prob[i],
-                                            counts->refmv_mode[i]);
+    fc->refmv_prob[i] = vp10_mode_mv_merge_probs(pre_fc->refmv_prob[i],
+                                                 counts->refmv_mode[i]);
 
   for (i = 0; i < DRL_MODE_CONTEXTS; ++i)
-    fc->drl_prob[i] = mode_mv_merge_probs(pre_fc->drl_prob[i],
-                                          counts->drl_mode[i]);
+    fc->drl_prob[i] = vp10_mode_mv_merge_probs(pre_fc->drl_prob[i],
+                                               counts->drl_mode[i]);
 #if CONFIG_EXT_INTER
-  fc->new2mv_prob = mode_mv_merge_probs(pre_fc->new2mv_prob,
-                                        counts->new2mv_mode);
+  fc->new2mv_prob = vp10_mode_mv_merge_probs(pre_fc->new2mv_prob,
+                                             counts->new2mv_mode);
 #endif  // CONFIG_EXT_INTER
 #else
   for (i = 0; i < INTER_MODE_CONTEXTS; i++)
@@ -1310,16 +1310,16 @@ void vp10_adapt_inter_frame_probs(VP10_COMMON *cm) {
 
 #if CONFIG_OBMC
   for (i = BLOCK_8X8; i < BLOCK_SIZES; ++i)
-    fc->obmc_prob[i] = mode_mv_merge_probs(pre_fc->obmc_prob[i],
-                                           counts->obmc[i]);
+    fc->obmc_prob[i] = vp10_mode_mv_merge_probs(pre_fc->obmc_prob[i],
+                                                counts->obmc[i]);
 #endif  // CONFIG_OBMC
 
 #if CONFIG_SUPERTX
   for (i = 0; i < PARTITION_SUPERTX_CONTEXTS; ++i) {
     int j;
     for (j = 1; j < TX_SIZES; ++j) {
-      fc->supertx_prob[i][j] = mode_mv_merge_probs(pre_fc->supertx_prob[i][j],
-                                                   counts->supertx[i][j]);
+      fc->supertx_prob[i][j] = vp10_mode_mv_merge_probs(
+          pre_fc->supertx_prob[i][j], counts->supertx[i][j]);
     }
   }
 #endif  // CONFIG_SUPERTX
@@ -1332,8 +1332,8 @@ void vp10_adapt_inter_frame_probs(VP10_COMMON *cm) {
                          fc->inter_compound_mode_probs[i]);
   for (i = 0; i < BLOCK_SIZE_GROUPS; ++i) {
     if (is_interintra_allowed_bsize_group(i))
-      fc->interintra_prob[i] = mode_mv_merge_probs(pre_fc->interintra_prob[i],
-                                                   counts->interintra[i]);
+      fc->interintra_prob[i] = vp10_mode_mv_merge_probs(
+          pre_fc->interintra_prob[i], counts->interintra[i]);
   }
   for (i = 0; i < BLOCK_SIZE_GROUPS; i++) {
     vpx_tree_merge_probs(
@@ -1342,12 +1342,12 @@ void vp10_adapt_inter_frame_probs(VP10_COMMON *cm) {
   }
   for (i = 0; i < BLOCK_SIZES; ++i) {
     if (is_interintra_allowed_bsize(i) && is_interintra_wedge_used(i))
-      fc->wedge_interintra_prob[i] = mode_mv_merge_probs(
+      fc->wedge_interintra_prob[i] = vp10_mode_mv_merge_probs(
           pre_fc->wedge_interintra_prob[i], counts->wedge_interintra[i]);
   }
   for (i = 0; i < BLOCK_SIZES; ++i) {
     if (is_interinter_wedge_used(i))
-      fc->wedge_interinter_prob[i] = mode_mv_merge_probs(
+      fc->wedge_interinter_prob[i] = vp10_mode_mv_merge_probs(
           pre_fc->wedge_interinter_prob[i], counts->wedge_interinter[i]);
   }
 #endif  // CONFIG_EXT_INTER
@@ -1385,12 +1385,12 @@ void vp10_adapt_intra_frame_probs(VP10_COMMON *cm) {
   if (cm->tx_mode == TX_MODE_SELECT)
     for (i = 0; i < TXFM_PARTITION_CONTEXTS; ++i)
       fc->txfm_partition_prob[i] =
-          mode_mv_merge_probs(pre_fc->txfm_partition_prob[i],
+          vp10_mode_mv_merge_probs(pre_fc->txfm_partition_prob[i],
                               counts->txfm_partition[i]);
 #endif
 
   for (i = 0; i < SKIP_CONTEXTS; ++i)
-    fc->skip_probs[i] = mode_mv_merge_probs(
+    fc->skip_probs[i] = vp10_mode_mv_merge_probs(
         pre_fc->skip_probs[i], counts->skip[i]);
 
 #if CONFIG_EXT_TX
@@ -1433,8 +1433,8 @@ void vp10_adapt_intra_frame_probs(VP10_COMMON *cm) {
 
   if (cm->seg.temporal_update) {
     for (i = 0; i < PREDICTION_PROBS; i++)
-      fc->seg.pred_probs[i] = mode_mv_merge_probs(pre_fc->seg.pred_probs[i],
-                                                  counts->seg.pred[i]);
+      fc->seg.pred_probs[i] = vp10_mode_mv_merge_probs(
+          pre_fc->seg.pred_probs[i], counts->seg.pred[i]);
 
     vpx_tree_merge_probs(vp10_segment_tree, pre_fc->seg.tree_probs,
                          counts->seg.tree_mispred, fc->seg.tree_probs);
@@ -1461,7 +1461,7 @@ void vp10_adapt_intra_frame_probs(VP10_COMMON *cm) {
 
 #if CONFIG_EXT_INTRA
   for (i = 0; i < PLANE_TYPES; ++i) {
-    fc->ext_intra_probs[i] = mode_mv_merge_probs(
+    fc->ext_intra_probs[i] = vp10_mode_mv_merge_probs(
               pre_fc->ext_intra_probs[i], counts->ext_intra[i]);
   }
 

diff --git a/vp10/common/entropymv.c b/vp10/common/entropymv.c
index 6e8c9931b936745491a4566a979b650bcfca7b08..35f589a348493a16497ee2b59d3c581d69d528a2 100644 (file)
--- a/vp10/common/entropymv.c
+++ b/vp10/common/entropymv.c
@@ -207,7 +207,7 @@ void vp10_adapt_mv_probs(VP10_COMMON *cm, int allow_hp) {
     vpx_tree_merge_probs(vp10_mv_joint_tree, pre_fc->joints, counts->joints,
                          fc->joints);
 #if CONFIG_REF_MV
-    fc->zero_rmv = mode_mv_merge_probs(pre_fc->zero_rmv, counts->zero_rmv);
+    fc->zero_rmv = vp10_mode_mv_merge_probs(pre_fc->zero_rmv, counts->zero_rmv);
 #endif
 
     for (i = 0; i < 2; ++i) {
@@ -215,14 +215,14 @@ void vp10_adapt_mv_probs(VP10_COMMON *cm, int allow_hp) {
       const nmv_component *pre_comp = &pre_fc->comps[i];
       const nmv_component_counts *c = &counts->comps[i];
 
-      comp->sign = mode_mv_merge_probs(pre_comp->sign, c->sign);
+      comp->sign = vp10_mode_mv_merge_probs(pre_comp->sign, c->sign);
       vpx_tree_merge_probs(vp10_mv_class_tree, pre_comp->classes, c->classes,
                            comp->classes);
       vpx_tree_merge_probs(vp10_mv_class0_tree, pre_comp->class0, c->class0,
                            comp->class0);
 
       for (j = 0; j < MV_OFFSET_BITS; ++j)
-        comp->bits[j] = mode_mv_merge_probs(pre_comp->bits[j], c->bits[j]);
+        comp->bits[j] = vp10_mode_mv_merge_probs(pre_comp->bits[j], c->bits[j]);
 
       for (j = 0; j < CLASS0_SIZE; ++j)
         vpx_tree_merge_probs(vp10_mv_fp_tree, pre_comp->class0_fp[j],
@@ -231,9 +231,9 @@ void vp10_adapt_mv_probs(VP10_COMMON *cm, int allow_hp) {
       vpx_tree_merge_probs(vp10_mv_fp_tree, pre_comp->fp, c->fp, comp->fp);
 
       if (allow_hp) {
-        comp->class0_hp = mode_mv_merge_probs(pre_comp->class0_hp,
-                                              c->class0_hp);
-        comp->hp = mode_mv_merge_probs(pre_comp->hp, c->hp);
+        comp->class0_hp = vp10_mode_mv_merge_probs(pre_comp->class0_hp,
+                                                   c->class0_hp);
+        comp->hp = vp10_mode_mv_merge_probs(pre_comp->hp, c->hp);
       }
     }
   }
@@ -250,14 +250,14 @@ void vp10_adapt_mv_probs(VP10_COMMON *cm, int allow_hp) {
     const nmv_component *pre_comp = &pre_fc->comps[i];
     const nmv_component_counts *c = &counts->comps[i];
 
-    comp->sign = mode_mv_merge_probs(pre_comp->sign, c->sign);
+    comp->sign = vp10_mode_mv_merge_probs(pre_comp->sign, c->sign);
     vpx_tree_merge_probs(vp10_mv_class_tree, pre_comp->classes, c->classes,
                          comp->classes);
     vpx_tree_merge_probs(vp10_mv_class0_tree, pre_comp->class0, c->class0,
                          comp->class0);
 
     for (j = 0; j < MV_OFFSET_BITS; ++j)
-      comp->bits[j] = mode_mv_merge_probs(pre_comp->bits[j], c->bits[j]);
+      comp->bits[j] = vp10_mode_mv_merge_probs(pre_comp->bits[j], c->bits[j]);
 
     for (j = 0; j < CLASS0_SIZE; ++j)
       vpx_tree_merge_probs(vp10_mv_fp_tree, pre_comp->class0_fp[j],
@@ -266,8 +266,9 @@ void vp10_adapt_mv_probs(VP10_COMMON *cm, int allow_hp) {
     vpx_tree_merge_probs(vp10_mv_fp_tree, pre_comp->fp, c->fp, comp->fp);
 
     if (allow_hp) {
-      comp->class0_hp = mode_mv_merge_probs(pre_comp->class0_hp, c->class0_hp);
-      comp->hp = mode_mv_merge_probs(pre_comp->hp, c->hp);
+      comp->class0_hp = vp10_mode_mv_merge_probs(
+          pre_comp->class0_hp, c->class0_hp);
+      comp->hp = vp10_mode_mv_merge_probs(pre_comp->hp, c->hp);
     }
   }
 #endif

diff --git a/vp10/encoder/subexp.c b/vp10/encoder/subexp.c
index 6d9c45f4469eb32b9ae15e1eac162569ea929acc..4aaffae7952d472363012a90af0d482c7b899c5c 100644 (file)
--- a/vp10/encoder/subexp.c
+++ b/vp10/encoder/subexp.c
@@ -191,9 +191,9 @@ static int get_cost(unsigned int ct[][2], vpx_prob p, int n) {
     total_ct[0] += ct[i][0];
     total_ct[1] += ct[i][1];
     if (i < n)
-      p = merge_probs(p0, total_ct, 24, 112);
+      p = vp10_merge_probs(p0, total_ct,
+                           COEF_COUNT_SAT_BITS, COEF_MAX_UPDATE_FACTOR_BITS);
   }
-
   return cost;
 }