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 32 matching lines @@
     101, 98,  95,  92,  89,  86,  83, 80,
     77,  74,  71,  68,  65,  62,  59, 56,
     53,  50,  47,  44,  41,  38,  35, 32,
     30,  28,  26,  24,  22,  20,  18, 16,
 };
 
 #if defined(SECTIONBITS_OUTPUT)
 unsigned __int64 Sectionbits[500];
 #endif
 
-#ifdef ENTROPY_STATS
+#ifdef VP8_ENTROPY_STATS
 int intra_mode_stats[10][10][10];
 static unsigned int tree_update_hist [BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [ENTROPY_NODES] [2];
 extern unsigned int active_section;
 #endif
 
 #ifdef MODE_STATS
 int count_mb_seg[4] = { 0, 0, 0, 0 };
 #endif
 
 
@@ skipping 460 matching lines @@
     MODE_INFO *m = pc->mi;
     const int mis = pc->mode_info_stride;
     int mb_row = -1;
 
     int prob_skip_false = 0;
 
     cpi->mb.partition_info = cpi->mb.pi;
 
     vp8_convert_rfct_to_prob(cpi);
 
-#ifdef ENTROPY_STATS
+#ifdef VP8_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->mb.skip_true_count ) * 256 / total_mbs;
 
         if (prob_skip_false <= 1)
@@ skipping 28 matching lines @@
 
             /* Distance of Mb to the various image edges.
              * These specified to 8th pel as they are always compared to MV
              * values that are in 1/8th pel units
              */
             xd->mb_to_left_edge = -((mb_col * 16) << 3);
             xd->mb_to_right_edge = ((pc->mb_cols - 1 - mb_col) * 16) << 3;
             xd->mb_to_top_edge = -((mb_row * 16)) << 3;
             xd->mb_to_bottom_edge = ((pc->mb_rows - 1 - mb_row) * 16) << 3;
 
-#ifdef ENTROPY_STATS
+#ifdef VP8_ENTROPY_STATS
             active_section = 9;
 #endif
 
             if (cpi->mb.e_mbd.update_mb_segmentation_map)
                 write_mb_features(w, mi, &cpi->mb.e_mbd);
 
             if (pc->mb_no_coeff_skip)
                 vp8_encode_bool(w, m->mbmi.mb_skip_coeff, prob_skip_false);
 
             if (rf == INTRA_FRAME)
             {
                 vp8_write(w, 0, cpi->prob_intra_coded);
-#ifdef ENTROPY_STATS
+#ifdef VP8_ENTROPY_STATS
                 active_section = 6;
 #endif
                 write_ymode(w, mode, pc->fc.ymode_prob);
 
                 if (mode == B_PRED)
                 {
                     int j = 0;
 
                     do
                         write_bmode(w, m->bmi[j].as_mode, pc->fc.bmode_prob);
@@ skipping 19 matching lines @@
 
                 {
                     int_mv n1, n2;
                     int ct[4];
 
                     vp8_find_near_mvs(xd, m, &n1, &n2, &best_mv, ct, rf, cpi->common.ref_frame_sign_bias);
                     vp8_clamp_mv2(&best_mv, xd);
 
                     vp8_mv_ref_probs(mv_ref_p, ct);
 
-#ifdef ENTROPY_STATS
+#ifdef VP8_ENTROPY_STATS
                     accum_mv_refs(mode, ct);
 #endif
 
                 }
 
-#ifdef ENTROPY_STATS
+#ifdef VP8_ENTROPY_STATS
                 active_section = 3;
 #endif
 
                 write_mv_ref(w, mode, mv_ref_p);
 
                 switch (mode)   /* new, split require MVs */
                 {
                 case NEWMV:
 
-#ifdef ENTROPY_STATS
+#ifdef VP8_ENTROPY_STATS
                     active_section = 5;
 #endif
 
                     write_mv(w, &mi->mv.as_mv, &best_mv, mvc);
                     break;
 
                 case SPLITMV:
                 {
                     int j = 0;
 
@@ skipping 22 matching lines @@
                         while (j != L[++k]);
 #endif
                         leftmv.as_int = left_block_mv(m, k);
                         abovemv.as_int = above_block_mv(m, k, mis);
                         mv_contz = vp8_mv_cont(&leftmv, &abovemv);
 
                         write_sub_mv_ref(w, blockmode, vp8_sub_mv_ref_prob2 [mv_contz]);
 
                         if (blockmode == NEW4X4)
                         {
-#ifdef ENTROPY_STATS
+#ifdef VP8_ENTROPY_STATS
                             active_section = 11;
 #endif
                             write_mv(w, &blockmv.as_mv, &best_mv, (const MV_CONTEXT *) mvc);
                         }
                     }
                     while (++j < cpi->mb.partition_info->count);
                 }
                 break;
                 default:
                     break;
@@ skipping 56 matching lines @@
             {
                 const int mis = c->mode_info_stride;
                 int i = 0;
 
                 do
                 {
                     const B_PREDICTION_MODE A = above_block_mode(m, i, mis);
                     const B_PREDICTION_MODE L = left_block_mode(m, i);
                     const int bm = m->bmi[i].as_mode;
 
-#ifdef ENTROPY_STATS
+#ifdef VP8_ENTROPY_STATS
                     ++intra_mode_stats [A] [L] [bm];
 #endif
 
                     write_bmode(bc, bm, vp8_kf_bmode_prob [A] [L]);
                 }
                 while (++i < 16);
             }
 
             write_uv_mode(bc, (m++)->mbmi.uv_mode, vp8_kf_uv_mode_prob);
         }
@@ skipping 370 matching lines @@
                         cpi->common.frame_type == KEY_FRAME && newp != *Pold)
                         u = 1;
 
 #if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING
                     cpi->update_probs[i][j][k][t] = u;
 #else
                     vp8_write(w, u, upd);
 #endif
 
 
-#ifdef ENTROPY_STATS
+#ifdef VP8_ENTROPY_STATS
                     ++ tree_update_hist [i][j][k][t] [u];
 #endif
 
                     if (u)
                     {
                         /* send/use new probability */
 
                         *Pold = newp;
 #if !(CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING)
                         vp8_write_literal(w, newp, 8);
 #endif
 
                         savings += s;
 
                     }
 
                 }
                 while (++t < ENTROPY_NODES);
 
                 /* Accum token counts for generation of default statistics */
-#ifdef ENTROPY_STATS
+#ifdef VP8_ENTROPY_STATS
                 t = 0;
 
                 do
                 {
                     context_counters [i][j][k][t] += cpi->coef_counts [i][j][k][t];
                 }
                 while (++t < MAX_ENTROPY_TOKENS);
 
 #endif
 
@@ skipping 325 matching lines @@
         else
             pc->refresh_entropy_probs = 0;
     }
 #endif
 
     vp8_write_bit(bc, pc->refresh_entropy_probs);
 
     if (pc->frame_type != KEY_FRAME)
         vp8_write_bit(bc, pc->refresh_last_frame);
 
-#ifdef ENTROPY_STATS
+#ifdef VP8_ENTROPY_STATS
 
     if (pc->frame_type == INTER_FRAME)
         active_section = 0;
     else
         active_section = 7;
 
 #endif
 
     vp8_clear_system_state();
 
 #if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING
     pack_coef_probs(cpi);
 #else
     if (pc->refresh_entropy_probs == 0)
     {
         /* save a copy for later refresh */
         vpx_memcpy(&cpi->common.lfc, &cpi->common.fc, sizeof(cpi->common.fc));
     }
 
     vp8_update_coef_probs(cpi);
 #endif
 
-#ifdef ENTROPY_STATS
+#ifdef VP8_ENTROPY_STATS
     active_section = 2;
 #endif
 
     /* Write out the mb_no_coeff_skip flag */
     vp8_write_bit(bc, pc->mb_no_coeff_skip);
 
     if (pc->frame_type == KEY_FRAME)
     {
         write_kfmodes(cpi);
 
-#ifdef ENTROPY_STATS
+#ifdef VP8_ENTROPY_STATS
         active_section = 8;
 #endif
     }
     else
     {
         pack_inter_mode_mvs(cpi);
 
-#ifdef ENTROPY_STATS
+#ifdef VP8_ENTROPY_STATS
         active_section = 1;
 #endif
     }
 
     vp8_stop_encode(bc);
 
     cx_data += bc->pos;
 
     oh.first_partition_length_in_bytes = cpi->bc->pos;
 
@@ skipping 97 matching lines @@
             pack_tokens(&cpi->bc[1], cpi->tok, cpi->tok_count);
 
         vp8_stop_encode(&cpi->bc[1]);
 
         *size += cpi->bc[1].pos;
         cpi->partition_sz[1] = cpi->bc[1].pos;
     }
 #endif
 }
 
-#ifdef ENTROPY_STATS
+#ifdef VP8_ENTROPY_STATS
 void print_tree_update_probs()
 {
     int i, j, k, l;
     FILE *f = fopen("context.c", "a");
     int Sum;
     fprintf(f, "\n/* Update probabilities for token entropy tree. */\n\n");
     fprintf(f, "const vp8_prob tree_update_probs[BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [ENTROPY_NODES] = {\n");
 
     for (i = 0; i < BLOCK_TYPES; i++)
     {
@@ skipping 28 matching lines @@
             fprintf(f, "    },\n");
         }
 
         fprintf(f, "  },\n");
     }
 
     fprintf(f, "};\n");
     fclose(f);
 }
 #endif