libvpx: Pull from upstream

source/libvpx/vp8/encoder/bitstream.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 100 matching lines @@
     VP8_COMMON *const x = & cpi->common;
 
     vp8_writer *const w = cpi->bc;
 
     {
         vp8_prob Pnew   [VP8_YMODES-1];
         unsigned int bct [VP8_YMODES-1] [2];
 
         update_mode(
             w, VP8_YMODES, vp8_ymode_encodings, vp8_ymode_tree,
-            Pnew, x->fc.ymode_prob, bct, (unsigned int *)cpi->ymode_count
+            Pnew, x->fc.ymode_prob, bct, (unsigned int *)cpi->mb.ymode_count
         );
     }
     {
         vp8_prob Pnew   [VP8_UV_MODES-1];
         unsigned int bct [VP8_UV_MODES-1] [2];
 
         update_mode(
             w, VP8_UV_MODES, vp8_uv_mode_encodings, vp8_uv_mode_tree,
-            Pnew, x->fc.uv_mode_prob, bct, (unsigned int *)cpi->uv_mode_count
+            Pnew, x->fc.uv_mode_prob, bct, (unsigned int *)cpi->mb.uv_mode_count
         );
     }
 }
 
 static void write_ymode(vp8_writer *bc, int m, const vp8_prob *p)
 {
     vp8_write_token(bc, vp8_ymode_tree, p, vp8_ymode_encodings + m);
 }
 
 static void kfwrite_ymode(vp8_writer *bc, int m, const vp8_prob *p)
@@ skipping 345 matching lines @@
             /* TRAP.. This should not happen */
         default:
             vp8_write(w, 0, x->mb_segment_tree_probs[0]);
             vp8_write(w, 0, x->mb_segment_tree_probs[1]);
             break;
         }
     }
 }
 void vp8_convert_rfct_to_prob(VP8_COMP *const cpi)
 {
-    const int *const rfct = cpi->count_mb_ref_frame_usage;
+    const int *const rfct = cpi->mb.count_mb_ref_frame_usage;
     const int rf_intra = rfct[INTRA_FRAME];
     const int rf_inter = rfct[LAST_FRAME] + rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME];
 
     /* Calculate the probabilities used to code the ref frame based on usage */
     if (!(cpi->prob_intra_coded = rf_intra * 255 / (rf_intra + rf_inter)))
         cpi->prob_intra_coded = 1;
 
     cpi->prob_last_coded = rf_inter ? (rfct[LAST_FRAME] * 255) / rf_inter : 128;
 
     if (!cpi->prob_last_coded)
@@ skipping 25 matching lines @@
     vp8_convert_rfct_to_prob(cpi);
 
 #ifdef ENTROPY_STATS
     active_section = 1;
 #endif
 
     if (pc->mb_no_coeff_skip)
     {
         int total_mbs = pc->mb_rows * pc->mb_cols;
 
-        prob_skip_false = (total_mbs - cpi->skip_true_count ) * 256 / total_mbs;
+        prob_skip_false = (total_mbs - cpi->mb.skip_true_count ) * 256 / total_mbs;
 
         if (prob_skip_false <= 1)
             prob_skip_false = 1;
 
         if (prob_skip_false > 255)
             prob_skip_false = 255;
 
         cpi->prob_skip_false = prob_skip_false;
         vp8_write_literal(w, prob_skip_false, 8);
     }
@@ skipping 170 matching lines @@
     /* const */
     MODE_INFO *m = c->mi;
 
     int mb_row = -1;
     int prob_skip_false = 0;
 
     if (c->mb_no_coeff_skip)
     {
         int total_mbs = c->mb_rows * c->mb_cols;
 
-        prob_skip_false = (total_mbs - cpi->skip_true_count ) * 256 / total_mbs;
+        prob_skip_false = (total_mbs - cpi->mb.skip_true_count ) * 256 / total_mbs;
 
         if (prob_skip_false <= 1)
             prob_skip_false = 1;
 
         if (prob_skip_false >= 255)
             prob_skip_false = 255;
 
         cpi->prob_skip_false = prob_skip_false;
         vp8_write_literal(bc, prob_skip_false, 8);
     }
@@ skipping 100 matching lines @@
     const int old_b = vp8_cost_branch(ct, oldp);
     const int new_b = vp8_cost_branch(ct, newp);
     const int update_b = 8 +
                          ((vp8_cost_one(upd) - vp8_cost_zero(upd)) >> 8);
 
     return old_b - new_b - update_b;
 }
 
 static int independent_coef_context_savings(VP8_COMP *cpi)
 {
+    MACROBLOCK *const x = & cpi->mb;
     int savings = 0;
     int i = 0;
     do
     {
         int j = 0;
         do
         {
             int k = 0;
             unsigned int prev_coef_count_sum[MAX_ENTROPY_TOKENS] = {0};
             int prev_coef_savings[MAX_ENTROPY_TOKENS] = {0};
             const unsigned int (*probs)[MAX_ENTROPY_TOKENS];
             /* Calculate new probabilities given the constraint that
              * they must be equal over the prev coef contexts
              */
 
             probs = (const unsigned int (*)[MAX_ENTROPY_TOKENS])
-                                                    cpi->coef_counts[i][j];
+                x->coef_counts[i][j];
 
             /* Reset to default probabilities at key frames */
             if (cpi->common.frame_type == KEY_FRAME)
                 probs = default_coef_counts[i][j];
 
             sum_probs_over_prev_coef_context(probs, prev_coef_count_sum);
 
             do
             {
                 /* at every context */
@@ skipping 38 matching lines @@
             while (++k < ENTROPY_NODES);
         }
         while (++j < COEF_BANDS);
     }
     while (++i < BLOCK_TYPES);
     return savings;
 }
 
 static int default_coef_context_savings(VP8_COMP *cpi)
 {
+    MACROBLOCK *const x = & cpi->mb;
     int savings = 0;
     int i = 0;
     do
     {
         int j = 0;
         do
         {
             int k = 0;
             do
             {
                 /* at every context */
 
                 /* calc probs and branch cts for this frame only */
                 int t = 0;      /* token/prob index */
 
                 vp8_tree_probs_from_distribution(
                     MAX_ENTROPY_TOKENS, vp8_coef_encodings, vp8_coef_tree,
                     cpi->frame_coef_probs [i][j][k],
                     cpi->frame_branch_ct [i][j][k],
-                    cpi->coef_counts [i][j][k],
+                    x->coef_counts [i][j][k],
                     256, 1
                 );
 
                 do
                 {
                     const unsigned int *ct  = cpi->frame_branch_ct [i][j][k][t];
                     const vp8_prob newp = cpi->frame_coef_probs [i][j][k][t];
                     const vp8_prob oldp = cpi->common.fc.coef_probs [i][j][k][t];
                     const vp8_prob upd = vp8_coef_update_probs [i][j][k][t];
                     const int s = prob_update_savings(ct, oldp, newp, upd);
@@ skipping 28 matching lines @@
     ref_frame_cost[ALTREF_FRAME]  = vp8_cost_one(prob_intra)
                                     + vp8_cost_one(prob_last)
                                     + vp8_cost_one(prob_garf);
 
 }
 
 int vp8_estimate_entropy_savings(VP8_COMP *cpi)
 {
     int savings = 0;
 
-    const int *const rfct = cpi->count_mb_ref_frame_usage;
+    const int *const rfct = cpi->mb.count_mb_ref_frame_usage;
     const int rf_intra = rfct[INTRA_FRAME];
     const int rf_inter = rfct[LAST_FRAME] + rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME];
     int new_intra, new_last, new_garf, oldtotal, newtotal;
     int ref_frame_cost[MAX_REF_FRAMES];
 
     vp8_clear_system_state();
 
     if (cpi->common.frame_type != KEY_FRAME)
     {
         if (!(new_intra = rf_intra * 255 / (rf_intra + rf_inter)))
@@ skipping 713 matching lines @@
             fprintf(f, "    },\n");
         }
 
         fprintf(f, "  },\n");
     }
 
     fprintf(f, "};\n");
     fclose(f);
 }
 #endif