libvpx: Pull from upstream

source/libvpx/vp9/common/vp9_entropy.c

Index: source/libvpx/vp9/common/vp9_entropy.c
===================================================================
--- source/libvpx/vp9/common/vp9_entropy.c	(revision 219822)
+++ source/libvpx/vp9/common/vp9_entropy.c	(working copy)
@@ -73,7 +73,7 @@
   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,
@@ -377,7 +377,7 @@
 
 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,
@@ -419,7 +419,7 @@
   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},
@@ -437,14 +437,10 @@
 #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,
@@ -613,20 +609,19 @@
 #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)
@@ -634,29 +629,23 @@
         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) {