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 96 matching lines @@
   else if (z < CLASS0_SIZE * 1024) c = MV_CLASS_7;
   else if (z < CLASS0_SIZE * 2048) c = MV_CLASS_8;
   else if (z < CLASS0_SIZE * 4096) c = MV_CLASS_9;
   else if (z < CLASS0_SIZE * 8192) c = MV_CLASS_10;
   else assert(0);
   if (offset)
     *offset = z - mv_class_base(c);
   return c;
 }
 
-int vp9_use_nmv_hp(const MV *ref) {
+int vp9_use_mv_hp(const MV *ref) {
   return (abs(ref->row) >> 3) < COMPANDED_MVREF_THRESH &&
          (abs(ref->col) >> 3) < COMPANDED_MVREF_THRESH;
 }
 
 int vp9_get_mv_mag(MV_CLASS_TYPE c, int offset) {
   return mv_class_base(c) + offset;
 }
 
-static void increment_nmv_component_count(int v,
-                                          nmv_component_counts *mvcomp,
-                                          int incr,
-                                          int usehp) {
-  assert (v != 0);            /* should not be zero */
-  mvcomp->mvcount[MV_MAX + v] += incr;
+static void inc_mv_component_count(int v, nmv_component_counts *comp_counts,
+                                   int incr) {
+  assert (v != 0);
+  comp_counts->mvcount[MV_MAX + v] += incr;
 }
 
-static void increment_nmv_component(int v,
-                                    nmv_component_counts *mvcomp,
-                                    int incr,
-                                    int usehp) {
+static void inc_mv_component(int v, nmv_component_counts *comp_counts,
+                             int incr, int usehp) {
   int s, z, c, o, d, e, f;
   if (!incr)
     return;
   assert (v != 0);            /* should not be zero */
   s = v < 0;
-  mvcomp->sign[s] += incr;
+  comp_counts->sign[s] += incr;
   z = (s ? -v : v) - 1;       /* magnitude - 1 */
 
   c = vp9_get_mv_class(z, &o);
-  mvcomp->classes[c] += incr;
+  comp_counts->classes[c] += incr;
 
   d = (o >> 3);               /* int mv data */
   f = (o >> 1) & 3;           /* fractional pel mv data */
   e = (o & 1);                /* high precision mv data */
   if (c == MV_CLASS_0) {
-    mvcomp->class0[d] += incr;
+    comp_counts->class0[d] += incr;
   } else {
     int i;
     int b = c + CLASS0_BITS - 1;  // number of bits
     for (i = 0; i < b; ++i)
-      mvcomp->bits[i][((d >> i) & 1)] += incr;
+      comp_counts->bits[i][((d >> i) & 1)] += incr;
   }
 
   /* Code the fractional pel bits */
   if (c == MV_CLASS_0) {
-    mvcomp->class0_fp[d][f] += incr;
+    comp_counts->class0_fp[d][f] += incr;
   } else {
-    mvcomp->fp[f] += incr;
+    comp_counts->fp[f] += incr;
   }
 
   /* Code the high precision bit */
   if (usehp) {
     if (c == MV_CLASS_0) {
-      mvcomp->class0_hp[e] += incr;
+      comp_counts->class0_hp[e] += incr;
     } else {
-      mvcomp->hp[e] += incr;
+      comp_counts->hp[e] += incr;
     }
   }
 }
 
 #ifdef SMOOTH_MV_COUNTS
 static void smooth_counts(nmv_component_counts *mvcomp) {
   static const int flen = 3;  // (filter_length + 1) / 2
   static const int fval[] = {8, 3, 1};
   static const int fvalbits = 4;
   int i;
   unsigned int smvcount[MV_VALS];
   vpx_memcpy(smvcount, mvcomp->mvcount, sizeof(smvcount));
   smvcount[MV_MAX] = (smvcount[MV_MAX - 1] + smvcount[MV_MAX + 1]) >> 1;
   for (i = flen - 1; i <= MV_VALS - flen; ++i) {
     int j, s = smvcount[i] * fval[0];
     for (j = 1; j < flen; ++j)
       s += (smvcount[i - j] + smvcount[i + j]) * fval[j];
     mvcomp->mvcount[i] = (s + (1 << (fvalbits - 1))) >> fvalbits;
   }
 }
 #endif
 
 static void counts_to_context(nmv_component_counts *mvcomp, int usehp) {
   int v;
   vpx_memset(mvcomp->sign, 0, sizeof(nmv_component_counts) - sizeof(mvcomp->mvcount));
   for (v = 1; v <= MV_MAX; v++) {
-    increment_nmv_component(-v, mvcomp, mvcomp->mvcount[MV_MAX - v], usehp);
-    increment_nmv_component( v, mvcomp, mvcomp->mvcount[MV_MAX + v], usehp);
+    inc_mv_component(-v, mvcomp, mvcomp->mvcount[MV_MAX - v], usehp);
+    inc_mv_component( v, mvcomp, mvcomp->mvcount[MV_MAX + v], usehp);
   }
 }
 
 void vp9_increment_nmv(const MV *mv, const MV *ref, nmv_context_counts *mvctx,
                        int usehp) {
   const MV_JOINT_TYPE j = vp9_get_mv_joint(mv);
   mvctx->joints[j]++;
-  usehp = usehp && vp9_use_nmv_hp(ref);
+  usehp = usehp && vp9_use_mv_hp(ref);
   if (mv_joint_vertical(j))
-    increment_nmv_component_count(mv->row, &mvctx->comps[0], 1, usehp);
+    inc_mv_component_count(mv->row, &mvctx->comps[0], 1);
 
   if (mv_joint_horizontal(j))
-    increment_nmv_component_count(mv->col, &mvctx->comps[1], 1, usehp);
+    inc_mv_component_count(mv->col, &mvctx->comps[1], 1);
 }
 
 static void adapt_prob(vp9_prob *dest, vp9_prob prep, unsigned int ct[2]) {
   const int count = MIN(ct[0] + ct[1], MV_COUNT_SAT);
   if (count) {
     const vp9_prob newp = get_binary_prob(ct[0], ct[1]);
     const int factor = MV_MAX_UPDATE_FACTOR * count / MV_COUNT_SAT;
     *dest = weighted_prob(prep, newp, factor);
   } else {
     *dest = prep;
@@ skipping 100 matching lines @@
     this_prob = weighted_prob(last_probs[i >> 1], this_prob,
                               MV_MAX_UPDATE_FACTOR * weight / MV_COUNT_SAT);
   } else {
     this_prob = last_probs[i >> 1];
   }
   this_probs[i >> 1] = this_prob;
   return left + right;
 }
 
 
-void vp9_adapt_nmv_probs(VP9_COMMON *cm, int usehp) {
+void vp9_adapt_mv_probs(VP9_COMMON *cm, int usehp) {
   int i, j;
 #ifdef MV_COUNT_TESTING
   printf("joints count: ");
   for (j = 0; j < MV_JOINTS; ++j) printf("%d ", cm->fc.NMVcount.joints[j]);
   printf("\n"); fflush(stdout);
   printf("signs count:\n");
   for (i = 0; i < 2; ++i)
     printf("%d/%d ", cm->fc.NMVcount.comps[i].sign[0], cm->fc.NMVcount.comps[i].sign[1]);
   printf("\n"); fflush(stdout);
   printf("classes count:\n");
@@ skipping 97 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));
 }