Merge remote branch 'internal/upstream' into HEAD

Conflicts:
	vp8/encoder/encodeframe.c
	vp8/encoder/rdopt.c

Change-Id: I183fd3ce9e94617ec888c9f891055b9f1f8ca6c5

diff --cc vp8/common/blockd.h
Simple merge

diff --cc vp8/decoder/decodemv.c
Simple merge

diff --cc vp8/decoder/decodframe.c
Simple merge

diff --cc vp8/decoder/onyxd_if.c
Simple merge

diff --cc vp8/encoder/bitstream.c
Simple merge

diff --cc vp8/encoder/encodeframe.c
index 616e702b415433ce2b37a85cdd0a67ae057cc50c,892284ed2cb5e5d20117b44c546e295cba32ad72..b4fc22c0b55406a288db8aa7be320a9a61c30a0e
--- 1/vp8/encoder/encodeframe.c
--- 2/vp8/encoder/encodeframe.c
+++ b/vp8/encoder/encodeframe.c
@@@ -487,13 -526,7 +537,12 @@@ void encode_mb_row(VP8_COMP *cpi
  
          // Increment the activity mask pointers.
          x->mb_activity_ptr++;
-         x->mb_norm_activity_ptr++;
  
 +        if ((xd->mode_info_context->mbmi.mode == ZEROMV) && (xd->mode_info_context->mbmi.ref_frame == LAST_FRAME))
 +            xd->mode_info_context->mbmi.segment_id = 0;
 +        else
 +            xd->mode_info_context->mbmi.segment_id = 1;
 +
          /* save the block info */
          for (i = 0; i < 16; i++)
              xd->mode_info_context->bmi[i] = xd->block[i].bmi;
@@@ -572,6 -573,93 +621,92 @@@
      }
  #endif
  }
 -
+ void init_encode_frame_mb_context(VP8_COMP *cpi)
+ {
+     MACROBLOCK *const x = & cpi->mb;
+     VP8_COMMON *const cm = & cpi->common;
+     MACROBLOCKD *const xd = & x->e_mbd;
+ 
+     // GF active flags data structure
+     x->gf_active_ptr = (signed char *)cpi->gf_active_flags;
+ 
+     // Activity map pointer
+     x->mb_activity_ptr = cpi->mb_activity_map;
+ 
+     x->vector_range = 32;
+ 
+     x->act_zbin_adj = 0;
+ 
+     x->partition_info = x->pi;
+ 
+     xd->mode_info_context = cm->mi;
+     xd->mode_info_stride = cm->mode_info_stride;
+ 
+     xd->frame_type = cm->frame_type;
+ 
+     xd->frames_since_golden = cm->frames_since_golden;
+     xd->frames_till_alt_ref_frame = cm->frames_till_alt_ref_frame;
+ 
+     // reset intra mode contexts
+     if (cm->frame_type == KEY_FRAME)
+         vp8_init_mbmode_probs(cm);
+ 
+     // Copy data over into macro block data sturctures.
+     x->src = * cpi->Source;
+     xd->pre = cm->yv12_fb[cm->lst_fb_idx];
+     xd->dst = cm->yv12_fb[cm->new_fb_idx];
+ 
+     // set up frame for intra coded blocks
+     vp8_setup_intra_recon(&cm->yv12_fb[cm->new_fb_idx]);
+ 
+     vp8_build_block_offsets(x);
+ 
+     vp8_setup_block_dptrs(&x->e_mbd);
+ 
+     vp8_setup_block_ptrs(x);
+ 
+     xd->mode_info_context->mbmi.mode = DC_PRED;
+     xd->mode_info_context->mbmi.uv_mode = DC_PRED;
+ 
+     xd->left_context = &cm->left_context;
+ 
+     vp8_zero(cpi->count_mb_ref_frame_usage)
+     vp8_zero(cpi->ymode_count)
+     vp8_zero(cpi->uv_mode_count)
+ 
+     x->mvc = cm->fc.mvc;
+ 
+     vpx_memset(cm->above_context, 0,
+                sizeof(ENTROPY_CONTEXT_PLANES) * cm->mb_cols);
+ 
+     xd->ref_frame_cost[INTRA_FRAME]   = vp8_cost_zero(cpi->prob_intra_coded);
+ 
+     // Special case treatment when GF and ARF are not sensible options for reference
+     if (cpi->ref_frame_flags == VP8_LAST_FLAG)
+     {
+         xd->ref_frame_cost[LAST_FRAME]    = vp8_cost_one(cpi->prob_intra_coded)
+                                         + vp8_cost_zero(255);
+         xd->ref_frame_cost[GOLDEN_FRAME]  = vp8_cost_one(cpi->prob_intra_coded)
+                                         + vp8_cost_one(255)
+                                         + vp8_cost_zero(128);
+         xd->ref_frame_cost[ALTREF_FRAME]  = vp8_cost_one(cpi->prob_intra_coded)
+                                         + vp8_cost_one(255)
+                                         + vp8_cost_one(128);
+     }
+     else
+     {
+         xd->ref_frame_cost[LAST_FRAME]    = vp8_cost_one(cpi->prob_intra_coded)
+                                         + vp8_cost_zero(cpi->prob_last_coded);
+         xd->ref_frame_cost[GOLDEN_FRAME]  = vp8_cost_one(cpi->prob_intra_coded)
+                                         + vp8_cost_one(cpi->prob_last_coded)
+                                         + vp8_cost_zero(cpi->prob_gf_coded);
+         xd->ref_frame_cost[ALTREF_FRAME]  = vp8_cost_one(cpi->prob_intra_coded)
+                                         + vp8_cost_one(cpi->prob_last_coded)
+                                         + vp8_cost_one(cpi->prob_gf_coded);
+     }
+ 
+ }
+ 
  void vp8_encode_frame(VP8_COMP *cpi)
  {
      int mb_row;
@@@ -580,15 -668,20 +715,26 @@@
      MACROBLOCKD *const xd = & x->e_mbd;
  
      TOKENEXTRA *tp = cpi->tok;
 +#if CONFIG_SEGMENTATION
 +    int segment_counts[MAX_MB_SEGMENTS + SEEK_SEGID];
 +    int prob[3];
 +    int new_cost, original_cost;
 +#else
      int segment_counts[MAX_MB_SEGMENTS];
 +#endif
      int totalrate;
  
+     vpx_memset(segment_counts, 0, sizeof(segment_counts));
+     totalrate = 0;
+ 
+     if (cpi->compressor_speed == 2)
+     {
+         if (cpi->oxcf.cpu_used < 0)
+             cpi->Speed = -(cpi->oxcf.cpu_used);
+         else
+             vp8_auto_select_speed(cpi);
+     }
+ 
      // Functions setup for all frame types so we can use MC in AltRef
      if (cm->mcomp_filter_type == SIXTAP)
      {

diff --cc vp8/encoder/firstpass.c
Simple merge

diff --cc vp8/encoder/generic/csystemdependent.c
Simple merge

diff --cc vp8/encoder/onyx_if.c
Simple merge

diff --cc vp8/encoder/onyx_int.h
Simple merge

diff --cc vp8/encoder/ratectrl.c
Simple merge

diff --cc vp8/encoder/rdopt.c
index 3186fa6ed03671f6d2a28d10a2bc9d873730e30f,5ce61a04e22f224ba66ff30998a2d5683277f656..0bea7b1418aa578747a2ea610edbb48393accc6c
--- 1/vp8/encoder/rdopt.c
--- 2/vp8/encoder/rdopt.c
+++ b/vp8/encoder/rdopt.c
@@@ -155,49 -155,6 +155,48 @@@ static int rd_iifactor [ 32 ] =  {    4
                                        0,   0,   0,   0,   0,   0,   0,   0,
                                   };
  
- 
 +// 3* dc_qlookup[Q]*dc_qlookup[Q];
 +#if !CONFIG_EXTEND_QRANGE
 +static int rdmult_lut[QINDEX_RANGE]=
 +{
 +    48,75,108,147,192,243,300,300,
 +    363,432,507,588,675,768,867,867,
 +    972,1083,1200,1200,1323,1323,1452,1452,
 +    1587,1587,1728,1875,1875,2028,2187,2352,
 +    2523,2700,2883,3072,3267,3468,3675,3888,
 +    4107,4107,4332,4563,4800,5043,5292,5547,
 +    5808,6075,6348,6348,6627,6912,7203,7500,
 +    7803,8112,8427,8748,9075,9408,9747,10092,
 +    10443,10800,11163,11532,11907,12288,12675,13068,
 +    13467,13872,14283,14700,15123,15552,15987,16428,
 +    16875,17328,17328,17787,18252,18723,19200,19683,
 +    20172,20667,21168,21675,22188,22707,23232,23763,
 +    24843,25947,27075,27648,28812,30000,30603,31212,
 +    32448,33708,34992,36300,37632,38988,40368,41772,
 +    44652,46128,47628,49152,50700,52272,53868,55488,
 +    57132,58800,61347,63075,65712,68403,71148,73947,
 +};
 +#else
 +static int rdmult_lut[QINDEX_RANGE]=
 +{
 +    3,5,7,9,12,15,19,23,
 +    27,32,37,42,48,54,61,68,
 +    75,83,91,99,108,117,127,137,
 +    147,169,192,217,243,271,300,331,
 +    363,397,450,507,567,631,698,768,
 +    842,919,999,1083,1170,1261,1355,1452,
 +    1587,1728,1875,2028,2187,2352,2523,2700,
 +    2883,3072,3267,3468,3675,3888,4107,4332,
 +    4563,4800,5043,5292,5547,5808,6075,6348,
 +    6627,6912,7203,7500,7880,8269,8667,9075,
 +    9492,9919,10355,10800,11255,11719,12192,12675,
 +    13167,13669,14180,14700,15230,15769,16317,16875,
 +    18019,19200,20419,21675,22969,24300,25669,27075,
 +    28519,30000,31519,33075,34669,36300,37969,39675,
 +    41772,43923,46128,48387,50700,53067,55488,57963,
 +    61347,64827,69312,73947,78732,83667,89787,97200,
 +};
 +#endif
  /* values are now correlated to quantizer */
  static int sad_per_bit16lut[QINDEX_RANGE] =
  {
@@@ -240,15 -197,11 +239,15 @@@ static int sad_per_bit4lut[QINDEX_RANGE
  
  void vp8cx_initialize_me_consts(VP8_COMP *cpi, int QIndex)
  {
-     cpi->mb.sadperbit16 =  sad_per_bit16lut[QIndex]/2;
-     cpi->mb.sadperbit4  =  sad_per_bit4lut[QIndex]/2;
+     cpi->mb.sadperbit16 =  sad_per_bit16lut[QIndex];
+     cpi->mb.sadperbit4  =  sad_per_bit4lut[QIndex];
  }
  
 -void vp8_initialize_rd_consts(VP8_COMP *cpi, int Qvalue)
 +
 +
 +
 +
 +void vp8_initialize_rd_consts(VP8_COMP *cpi, int QIndex)
  {
      int q;
      int i;