libvpx: Pull from upstream

source/libvpx/vp9/common/vp9_entropy.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 55 matching lines @@
   7, 14, 11, 15,
 };
 
 DECLARE_ALIGNED(16, const int16_t, vp9_row_scan_4x4[16]) = {
   0,  1,  4,  2,
   5,  3,  6,  8,
   9,  7, 12, 10,
   13, 11, 14, 15,
 };
 
-DECLARE_ALIGNED(64, const int16_t, vp9_default_scan_8x8[64]) = {
+DECLARE_ALIGNED(16, const int16_t, vp9_default_scan_8x8[64]) = {
   0,  8,  1, 16,  9,  2, 17, 24,
   10,  3, 18, 25, 32, 11,  4, 26,
   33, 19, 40, 12, 34, 27,  5, 41,
   20, 48, 13, 35, 42, 28, 21,  6,
   49, 56, 36, 43, 29,  7, 14, 50,
   57, 44, 22, 37, 15, 51, 58, 30,
   45, 23, 52, 59, 38, 31, 60, 53,
   46, 39, 61, 54, 47, 62, 55, 63,
 };
 
@@ skipping 283 matching lines @@
   {255, 230, 233, 255, 231, 255, 252, 254},
   {255, 232, 235, 255, 232, 255, 252, 254},
   {255, 235, 237, 255, 233, 255, 252, 254},
   {255, 238, 240, 255, 235, 255, 252, 255},
   {255, 241, 243, 255, 236, 255, 252, 254},
   {255, 246, 247, 255, 239, 255, 253, 255}
 };
 
 static void extend_model_to_full_distribution(vp9_prob p,
                                               vp9_prob *tree_probs) {
-  const int l = ((p - 1) / 2);
+  const int l = (p - 1) / 2;
   const vp9_prob (*model)[MODEL_NODES] = modelcoefprobs_pareto8;
   if (p & 1) {
     vpx_memcpy(tree_probs + UNCONSTRAINED_NODES,
                model[l], MODEL_NODES * sizeof(vp9_prob));
   } else {
     // interpolate
     int i;
     for (i = UNCONSTRAINED_NODES; i < ENTROPY_NODES; ++i)
       tree_probs[i] = (model[l][i - UNCONSTRAINED_NODES] +
                        model[l + 1][i - UNCONSTRAINED_NODES]) >> 1;
@@ skipping 21 matching lines @@
 
 static void init_bit_trees() {
   init_bit_tree(cat1, 1);
   init_bit_tree(cat2, 2);
   init_bit_tree(cat3, 3);
   init_bit_tree(cat4, 4);
   init_bit_tree(cat5, 5);
   init_bit_tree(cat6, 14);
 }
 
-vp9_extra_bit vp9_extra_bits[12] = {
+const vp9_extra_bit vp9_extra_bits[12] = {
   { 0, 0, 0, 0},
   { 0, 0, 0, 1},
   { 0, 0, 0, 2},
   { 0, 0, 0, 3},
   { 0, 0, 0, 4},
   { cat1, Pcat1, 1, 5},
   { cat2, Pcat2, 2, 7},
   { cat3, Pcat3, 3, 11},
   { cat4, Pcat4, 4, 19},
   { cat5, Pcat5, 5, 35},
   { cat6, Pcat6, 14, 67},
   { 0, 0, 0, 0}
 };
 
 #include "vp9/common/vp9_default_coef_probs.h"
 
 void vp9_default_coef_probs(VP9_COMMON *pc) {
-  vpx_memcpy(pc->fc.coef_probs[TX_4X4], default_coef_probs_4x4,
-             sizeof(pc->fc.coef_probs[TX_4X4]));
-  vpx_memcpy(pc->fc.coef_probs[TX_8X8], default_coef_probs_8x8,
-             sizeof(pc->fc.coef_probs[TX_8X8]));
-  vpx_memcpy(pc->fc.coef_probs[TX_16X16], default_coef_probs_16x16,
-             sizeof(pc->fc.coef_probs[TX_16X16]));
-  vpx_memcpy(pc->fc.coef_probs[TX_32X32], default_coef_probs_32x32,
-             sizeof(pc->fc.coef_probs[TX_32X32]));
+  vp9_copy(pc->fc.coef_probs[TX_4X4], default_coef_probs_4x4);
+  vp9_copy(pc->fc.coef_probs[TX_8X8], default_coef_probs_8x8);
+  vp9_copy(pc->fc.coef_probs[TX_16X16], default_coef_probs_16x16);
+  vp9_copy(pc->fc.coef_probs[TX_32X32], default_coef_probs_32x32);
 }
 
 // Neighborhood 5-tuples for various scans and blocksizes,
 // in {top, left, topleft, topright, bottomleft} order
 // for each position in raster scan order.
 // -1 indicates the neighbor does not exist.
 DECLARE_ALIGNED(16, int16_t,
                 vp9_default_scan_4x4_neighbors[17 * MAX_NEIGHBORS]);
 DECLARE_ALIGNED(16, int16_t,
                 vp9_col_scan_4x4_neighbors[17 * MAX_NEIGHBORS]);
@@ skipping 148 matching lines @@
 
 // #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
 
-static void adapt_coef_probs(VP9_COMMON *cm, TX_SIZE txfm_size,
-                             int count_sat, int update_factor) {
+static void adapt_coef_probs(VP9_COMMON *cm, TX_SIZE tx_size,
+                             unsigned int count_sat,
+                             unsigned int update_factor) {
   FRAME_CONTEXT *pre_fc = &cm->frame_contexts[cm->frame_context_idx];
 
-  vp9_coeff_probs_model *dst_coef_probs = cm->fc.coef_probs[txfm_size];
-  vp9_coeff_probs_model *pre_coef_probs = pre_fc->coef_probs[txfm_size];
-  vp9_coeff_count_model *coef_counts = cm->counts.coef[txfm_size];
+  vp9_coeff_probs_model *dst_coef_probs = cm->fc.coef_probs[tx_size];
+  vp9_coeff_probs_model *pre_coef_probs = pre_fc->coef_probs[tx_size];
+  vp9_coeff_count_model *coef_counts = cm->counts.coef[tx_size];
   unsigned int (*eob_branch_count)[REF_TYPES][COEF_BANDS][PREV_COEF_CONTEXTS] =
-      cm->counts.eob_branch[txfm_size];
-  int t, i, j, k, l, count;
-  int factor;
+      cm->counts.eob_branch[tx_size];
+  int t, i, j, k, l;
   unsigned int branch_ct[UNCONSTRAINED_NODES][2];
   vp9_prob coef_probs[UNCONSTRAINED_NODES];
-  int entropy_nodes_adapt = UNCONSTRAINED_NODES;
 
   for (i = 0; i < BLOCK_TYPES; ++i)
     for (j = 0; j < REF_TYPES; ++j)
       for (k = 0; k < COEF_BANDS; ++k)
         for (l = 0; l < PREV_COEF_CONTEXTS; ++l) {
           if (l >= 3 && k == 0)
             continue;
-          vp9_tree_probs_from_distribution(
-              vp9_coefmodel_tree,
-              coef_probs, branch_ct,
-              coef_counts[i][j][k][l], 0);
+          vp9_tree_probs_from_distribution(vp9_coefmodel_tree, coef_probs,
+                                           branch_ct, coef_counts[i][j][k][l],
+                                           0);
           branch_ct[0][1] = eob_branch_count[i][j][k][l] - branch_ct[0][0];
           coef_probs[0] = get_binary_prob(branch_ct[0][0], branch_ct[0][1]);
-          for (t = 0; t < entropy_nodes_adapt; ++t) {
-            count = branch_ct[t][0] + branch_ct[t][1];
-            count = count > count_sat ? count_sat : count;
-            factor = (update_factor * count / count_sat);
-            dst_coef_probs[i][j][k][l][t] =
-                weighted_prob(pre_coef_probs[i][j][k][l][t],
-                              coef_probs[t], factor);
-          }
+          for (t = 0; t < UNCONSTRAINED_NODES; ++t)
+            dst_coef_probs[i][j][k][l][t] = merge_probs(
+                pre_coef_probs[i][j][k][l][t], coef_probs[t],
+                branch_ct[t], count_sat, update_factor);
         }
 }
 
 void vp9_adapt_coef_probs(VP9_COMMON *cm) {
   TX_SIZE t;
-  int count_sat;
-  int update_factor; /* denominator 256 */
+  unsigned int count_sat, update_factor;
 
-  if ((cm->frame_type == KEY_FRAME) || cm->intra_only) {
+  if (cm->frame_type == KEY_FRAME || cm->intra_only) {
     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;
   }
   for (t = TX_4X4; t <= TX_32X32; t++)
     adapt_coef_probs(cm, t, count_sat, update_factor);
 }