libvpx: Pull from upstream

source/libvpx/vp9/common/vp9_entropymv.c

 /*
  *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 195 matching lines @@
   if (j == MV_JOINT_HZVNZ || j == MV_JOINT_HNZVNZ) {
     increment_nmv_component_count(mv->row, &mvctx->comps[0], 1, usehp);
   }
   if (j == MV_JOINT_HNZVZ || j == MV_JOINT_HNZVNZ) {
     increment_nmv_component_count(mv->col, &mvctx->comps[1], 1, usehp);
   }
 }
 
 static void adapt_prob(vp9_prob *dest, vp9_prob prep, vp9_prob newp,
                        unsigned int ct[2]) {
-  int factor;
-  int prob;
   int count = ct[0] + ct[1];
+
   if (count) {
     count = count > MV_COUNT_SAT ? MV_COUNT_SAT : count;
-    factor = (MV_MAX_UPDATE_FACTOR * count / MV_COUNT_SAT);
-    prob = ((int)prep * (256 - factor) + (int)(newp) * factor + 128) >> 8;
-    prob += !prob;
-    prob = (prob > 255 ? 255 : prob);
-    *dest = prob;
+    *dest = weighted_prob(prep, newp,
+                          MV_MAX_UPDATE_FACTOR * count / MV_COUNT_SAT);
   }
 }
 
 void vp9_counts_process(nmv_context_counts *NMVcount, int usehp) {
   counts_to_context(&NMVcount->comps[0], usehp);
   counts_to_context(&NMVcount->comps[1], usehp);
 }
 
 void vp9_counts_to_nmv_context(
     nmv_context_counts *NMVcount,
     nmv_context *prob,
     int usehp,
     unsigned int (*branch_ct_joint)[2],
     unsigned int (*branch_ct_sign)[2],
     unsigned int (*branch_ct_classes)[MV_CLASSES - 1][2],
     unsigned int (*branch_ct_class0)[CLASS0_SIZE - 1][2],
     unsigned int (*branch_ct_bits)[MV_OFFSET_BITS][2],
     unsigned int (*branch_ct_class0_fp)[CLASS0_SIZE][4 - 1][2],
     unsigned int (*branch_ct_fp)[4 - 1][2],
     unsigned int (*branch_ct_class0_hp)[2],
     unsigned int (*branch_ct_hp)[2]) {
   int i, j, k;
   vp9_counts_process(NMVcount, usehp);
   vp9_tree_probs_from_distribution(MV_JOINTS,
                                    vp9_mv_joint_encodings,
                                    vp9_mv_joint_tree,
                                    prob->joints,
                                    branch_ct_joint,
-                                   NMVcount->joints,
-                                   256, 1);
+                                   NMVcount->joints);
   for (i = 0; i < 2; ++i) {
-    prob->comps[i].sign =
-        vp9_bin_prob_from_distribution(NMVcount->comps[i].sign);
+    prob->comps[i].sign = get_binary_prob(NMVcount->comps[i].sign[0],
+                                          NMVcount->comps[i].sign[1]);
     branch_ct_sign[i][0] = NMVcount->comps[i].sign[0];
     branch_ct_sign[i][1] = NMVcount->comps[i].sign[1];
     vp9_tree_probs_from_distribution(MV_CLASSES,
                                      vp9_mv_class_encodings,
                                      vp9_mv_class_tree,
                                      prob->comps[i].classes,
                                      branch_ct_classes[i],
-                                     NMVcount->comps[i].classes,
-                                     256, 1);
+                                     NMVcount->comps[i].classes);
     vp9_tree_probs_from_distribution(CLASS0_SIZE,
                                      vp9_mv_class0_encodings,
                                      vp9_mv_class0_tree,
                                      prob->comps[i].class0,
                                      branch_ct_class0[i],
-                                     NMVcount->comps[i].class0,
-                                     256, 1);
+                                     NMVcount->comps[i].class0);
     for (j = 0; j < MV_OFFSET_BITS; ++j) {
-      prob->comps[i].bits[j] = vp9_bin_prob_from_distribution(
-          NMVcount->comps[i].bits[j]);
+      prob->comps[i].bits[j] = get_binary_prob(NMVcount->comps[i].bits[j][0],
+                                               NMVcount->comps[i].bits[j][1]);
       branch_ct_bits[i][j][0] = NMVcount->comps[i].bits[j][0];
       branch_ct_bits[i][j][1] = NMVcount->comps[i].bits[j][1];
     }
   }
   for (i = 0; i < 2; ++i) {
     for (k = 0; k < CLASS0_SIZE; ++k) {
       vp9_tree_probs_from_distribution(4,
                                        vp9_mv_fp_encodings,
                                        vp9_mv_fp_tree,
                                        prob->comps[i].class0_fp[k],
                                        branch_ct_class0_fp[i][k],
-                                       NMVcount->comps[i].class0_fp[k],
-                                       256, 1);
+                                       NMVcount->comps[i].class0_fp[k]);
     }
     vp9_tree_probs_from_distribution(4,
                                      vp9_mv_fp_encodings,
                                      vp9_mv_fp_tree,
                                      prob->comps[i].fp,
                                      branch_ct_fp[i],
-                                     NMVcount->comps[i].fp,
-                                     256, 1);
+                                     NMVcount->comps[i].fp);
   }
   if (usehp) {
     for (i = 0; i < 2; ++i) {
-      prob->comps[i].class0_hp = vp9_bin_prob_from_distribution(
-          NMVcount->comps[i].class0_hp);
+      prob->comps[i].class0_hp =
+          get_binary_prob(NMVcount->comps[i].class0_hp[0],
+                          NMVcount->comps[i].class0_hp[1]);
       branch_ct_class0_hp[i][0] = NMVcount->comps[i].class0_hp[0];
       branch_ct_class0_hp[i][1] = NMVcount->comps[i].class0_hp[1];
 
-      prob->comps[i].hp =
-          vp9_bin_prob_from_distribution(NMVcount->comps[i].hp);
+      prob->comps[i].hp = get_binary_prob(NMVcount->comps[i].hp[0],
+                                          NMVcount->comps[i].hp[1]);
       branch_ct_hp[i][0] = NMVcount->comps[i].hp[0];
       branch_ct_hp[i][1] = NMVcount->comps[i].hp[1];
     }
   }
 }
 
 void vp9_adapt_nmv_probs(VP9_COMMON *cm, int usehp) {
   int i, j, k;
   nmv_context prob;
   unsigned int branch_ct_joint[MV_JOINTS - 1][2];
@@ skipping 141 matching lines @@
 void vp9_entropy_mv_init() {
   vp9_tokens_from_tree(vp9_mv_joint_encodings, vp9_mv_joint_tree);
   vp9_tokens_from_tree(vp9_mv_class_encodings, vp9_mv_class_tree);
   vp9_tokens_from_tree(vp9_mv_class0_encodings, vp9_mv_class0_tree);
   vp9_tokens_from_tree(vp9_mv_fp_encodings, vp9_mv_fp_tree);
 }
 
 void vp9_init_mv_probs(VP9_COMMON *cm) {
   vpx_memcpy(&cm->fc.nmvc, &vp9_default_nmv_context, sizeof(nmv_context));
 }