libvpx: Pull from upstream

source/libvpx/vp8/encoder/ratectrl.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 224 matching lines @@
     cc->filter_level             = cpi->common.filter_level;
     cc->frames_till_gf_update_due   = cpi->frames_till_gf_update_due;
     cc->frames_since_golden       = cpi->common.frames_since_golden;
 
     vp8_copy(cc->mvc,      cpi->common.fc.mvc);
     vp8_copy(cc->mvcosts,  cpi->rd_costs.mvcosts);
 
     vp8_copy(cc->ymode_prob,   cpi->common.fc.ymode_prob);
     vp8_copy(cc->uv_mode_prob,  cpi->common.fc.uv_mode_prob);
 
-    vp8_copy(cc->ymode_count, cpi->ymode_count);
-    vp8_copy(cc->uv_mode_count, cpi->uv_mode_count);
+    vp8_copy(cc->ymode_count, cpi->mb.ymode_count);
+    vp8_copy(cc->uv_mode_count, cpi->mb.uv_mode_count);
 
 
     /* Stats */
 #ifdef MODE_STATS
     vp8_copy(cc->y_modes,       y_modes);
     vp8_copy(cc->uv_modes,      uv_modes);
     vp8_copy(cc->b_modes,       b_modes);
     vp8_copy(cc->inter_y_modes,  inter_y_modes);
     vp8_copy(cc->inter_uv_modes, inter_uv_modes);
     vp8_copy(cc->inter_b_modes,  inter_b_modes);
@@ skipping 16 matching lines @@
     cpi->frames_till_gf_update_due  =   cc->frames_till_gf_update_due;
     cpi->common.frames_since_golden       =   cc->frames_since_golden;
 
     vp8_copy(cpi->common.fc.mvc, cc->mvc);
 
     vp8_copy(cpi->rd_costs.mvcosts, cc->mvcosts);
 
     vp8_copy(cpi->common.fc.ymode_prob,   cc->ymode_prob);
     vp8_copy(cpi->common.fc.uv_mode_prob,  cc->uv_mode_prob);
 
-    vp8_copy(cpi->ymode_count, cc->ymode_count);
-    vp8_copy(cpi->uv_mode_count, cc->uv_mode_count);
+    vp8_copy(cpi->mb.ymode_count, cc->ymode_count);
+    vp8_copy(cpi->mb.uv_mode_count, cc->uv_mode_count);
 
     /* Stats */
 #ifdef MODE_STATS
     vp8_copy(y_modes, cc->y_modes);
     vp8_copy(uv_modes, cc->uv_modes);
     vp8_copy(b_modes, cc->b_modes);
     vp8_copy(inter_y_modes, cc->inter_y_modes);
     vp8_copy(inter_uv_modes, cc->inter_uv_modes);
     vp8_copy(inter_b_modes, cc->inter_b_modes);
 #endif
@@ skipping 807 matching lines @@
 
     /* Clear down mmx registers to allow floating point in what follows */
     vp8_clear_system_state();
 
     if (cpi->common.frame_type == KEY_FRAME)
     {
         rate_correction_factor = cpi->key_frame_rate_correction_factor;
     }
     else
     {
-        if (cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame)
+        if (cpi->oxcf.number_of_layers == 1 &&
+           (cpi->common.refresh_alt_ref_frame ||
+            cpi->common.refresh_golden_frame))
             rate_correction_factor = cpi->gf_rate_correction_factor;
         else
             rate_correction_factor = cpi->rate_correction_factor;
     }
 
     /* Work out how big we would have expected the frame to be at this Q
      * given the current correction factor. Stay in double to avoid int
      * overflow when values are large
      */
     projected_size_based_on_q = (int)(((.5 + rate_correction_factor * vp8_bits_per_mb[cpi->common.frame_type][Q]) * cpi->common.MBs) / (1 << BPER_MB_NORMBITS));
 
     /* Make some allowance for cpi->zbin_over_quant */
-    if (cpi->zbin_over_quant > 0)
+    if (cpi->mb.zbin_over_quant > 0)
     {
-        int Z = cpi->zbin_over_quant;
+        int Z = cpi->mb.zbin_over_quant;
         double Factor = 0.99;
         double factor_adjustment = 0.01 / 256.0;
 
         while (Z > 0)
         {
             Z --;
             projected_size_based_on_q =
                 (int)(Factor * projected_size_based_on_q);
             Factor += factor_adjustment;
 
@@ skipping 41 matching lines @@
 
         /* Keep rate_correction_factor within limits */
         if (rate_correction_factor < MIN_BPB_FACTOR)
             rate_correction_factor = MIN_BPB_FACTOR;
     }
 
     if (cpi->common.frame_type == KEY_FRAME)
         cpi->key_frame_rate_correction_factor = rate_correction_factor;
     else
     {
-        if (cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame)
+        if (cpi->oxcf.number_of_layers == 1 &&
+           (cpi->common.refresh_alt_ref_frame ||
+            cpi->common.refresh_golden_frame))
             cpi->gf_rate_correction_factor = rate_correction_factor;
         else
             cpi->rate_correction_factor = rate_correction_factor;
     }
 }
 
 
 int vp8_regulate_q(VP8_COMP *cpi, int target_bits_per_frame)
 {
     int Q = cpi->active_worst_quality;
 
     /* Reset Zbin OQ value */
-    cpi->zbin_over_quant = 0;
+    cpi->mb.zbin_over_quant = 0;
 
     if (cpi->oxcf.fixed_q >= 0)
     {
         Q = cpi->oxcf.fixed_q;
 
         if (cpi->common.frame_type == KEY_FRAME)
         {
             Q = cpi->oxcf.key_q;
         }
-        else if (cpi->common.refresh_alt_ref_frame)
+        else if (cpi->oxcf.number_of_layers == 1 &&
+            cpi->common.refresh_alt_ref_frame)
         {
             Q = cpi->oxcf.alt_q;
         }
-        else if (cpi->common.refresh_golden_frame)
+        else if (cpi->oxcf.number_of_layers == 1  &&
+            cpi->common.refresh_golden_frame)
         {
             Q = cpi->oxcf.gold_q;
         }
 
     }
     else
     {
         int i;
         int last_error = INT_MAX;
         int target_bits_per_mb;
         int bits_per_mb_at_this_q;
         double correction_factor;
 
         /* Select the appropriate correction factor based upon type of frame. */
         if (cpi->common.frame_type == KEY_FRAME)
             correction_factor = cpi->key_frame_rate_correction_factor;
         else
         {
-            if (cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame)
+            if (cpi->oxcf.number_of_layers == 1 &&
+               (cpi->common.refresh_alt_ref_frame ||
+                cpi->common.refresh_golden_frame))
                 correction_factor = cpi->gf_rate_correction_factor;
             else
                 correction_factor = cpi->rate_correction_factor;
         }
 
         /* Calculate required scaling factor based on target frame size and
          * size of frame produced using previous Q
          */
         if (target_bits_per_frame >= (INT_MAX >> BPER_MB_NORMBITS))
             /* Case where we would overflow int */
@@ skipping 28 matching lines @@
          */
         if (Q >= MAXQ)
         {
             int zbin_oqmax;
 
             double Factor = 0.99;
             double factor_adjustment = 0.01 / 256.0;
 
             if (cpi->common.frame_type == KEY_FRAME)
                 zbin_oqmax = 0;
-            else if (cpi->common.refresh_alt_ref_frame || (cpi->common.refresh_golden_frame && !cpi->source_alt_ref_active))
+            else if (cpi->oxcf.number_of_layers == 1 &&
+                (cpi->common.refresh_alt_ref_frame ||
+                (cpi->common.refresh_golden_frame &&
+                 !cpi->source_alt_ref_active)))
                 zbin_oqmax = 16;
             else
                 zbin_oqmax = ZBIN_OQ_MAX;
 
             /*{
                 double Factor = (double)target_bits_per_mb/(double)bits_per_mb_at_this_q;
                 double Oq;
 
                 Factor = Factor/1.2683;
 
                 Oq = pow( Factor, (1.0/-0.165) );
 
                 if ( Oq > zbin_oqmax )
                     Oq = zbin_oqmax;
 
                 cpi->zbin_over_quant = (int)Oq;
             }*/
 
             /* Each incrment in the zbin is assumed to have a fixed effect
              * on bitrate. This is not of course true. The effect will be
              * highly clip dependent and may well have sudden steps. The
              * idea here is to acheive higher effective quantizers than the
              * normal maximum by expanding the zero bin and hence
              * decreasing the number of low magnitude non zero coefficients.
              */
-            while (cpi->zbin_over_quant < zbin_oqmax)
+            while (cpi->mb.zbin_over_quant < zbin_oqmax)
             {
-                cpi->zbin_over_quant ++;
+                cpi->mb.zbin_over_quant ++;
 
-                if (cpi->zbin_over_quant > zbin_oqmax)
-                    cpi->zbin_over_quant = zbin_oqmax;
+                if (cpi->mb.zbin_over_quant > zbin_oqmax)
+                    cpi->mb.zbin_over_quant = zbin_oqmax;
 
                 /* Adjust bits_per_mb_at_this_q estimate */
                 bits_per_mb_at_this_q = (int)(Factor * bits_per_mb_at_this_q);
                 Factor += factor_adjustment;
 
                 if (Factor  >= 0.999)
                     Factor = 0.999;
 
                 /* Break out if we get down to the target rate */
                 if (bits_per_mb_at_this_q <= target_bits_per_mb)
@@ skipping 199 matching lines @@
 
         /* Check if we're dropping the frame: */
         if (cpi->drop_frame)
         {
             cpi->drop_frame = 0;
             return 0;
         }
     }
     return 1;
 }