Quelle  ratectrl.c   Sprache: 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.
 */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <limits.h>
#include <assert.h>

#include "math.h"
#include "vp8/common/common.h"
#include "ratectrl.h"
#include "vp8/common/entropymode.h"
#include "vpx_mem/vpx_mem.h"
#include "vp8/common/systemdependent.h"
#include "encodemv.h"
#include "vpx_dsp/vpx_dsp_common.h"
#include "vpx_ports/system_state.h"

#define MIN_BPB_FACTOR 0.01
#define MAX_BPB_FACTOR 50

extern const MB_PREDICTION_MODE vp8_mode_order[MAX_MODES];

#ifdef MODE_STATS
extern int y_modes[5];
extern int uv_modes[4];
extern int b_modes[10];

extern int inter_y_modes[10];
extern int inter_uv_modes[4];
extern int inter_b_modes[10];
#endif

/* Bits Per MB at different Q (Multiplied by 512) */
#define BPER_MB_NORMBITS 9

/* Work in progress recalibration of baseline rate tables based on
 * the assumption that bits per mb is inversely proportional to the
 * quantizer value.
 */
const int vp8_bits_per_mb[2][QINDEX_RANGE] = {
  /* Intra case 450000/Qintra */
  {
      1125000, 900000, 750000, 642857, 562500, 500000, 450000, 450000, 409090,
      375000,  346153, 321428, 300000, 281250, 264705, 264705, 250000, 236842,
      225000,  225000, 214285, 214285, 204545, 204545, 195652, 195652, 187500,
      180000,  180000, 173076, 166666, 160714, 155172, 150000, 145161, 140625,
      136363,  132352, 128571, 125000, 121621, 121621, 118421, 115384, 112500,
      109756,  107142, 104651, 102272, 100000, 97826,  97826,  95744,  93750,
      91836,   90000,  88235,  86538,  84905,  83333,  81818,  80357,  78947,
      77586,   76271,  75000,  73770,  72580,  71428,  70312,  69230,  68181,
      67164,   66176,  65217,  64285,  63380,  62500,  61643,  60810,  60000,
      59210,   59210,  58441,  57692,  56962,  56250,  55555,  54878,  54216,
      53571,   52941,  52325,  51724,  51136,  50561,  49450,  48387,  47368,
      46875,   45918,  45000,  44554,  44117,  43269,  42452,  41666,  40909,
      40178,   39473,  38793,  38135,  36885,  36290,  35714,  35156,  34615,
      34090,   33582,  33088,  32608,  32142,  31468,  31034,  30405,  29801,
      29220,   28662,
  },
  /* Inter case 285000/Qinter */
  {
      712500, 570000, 475000, 407142, 356250, 316666, 285000, 259090, 237500,
      219230, 203571, 190000, 178125, 167647, 158333, 150000, 142500, 135714,
      129545, 123913, 118750, 114000, 109615, 105555, 101785, 98275,  95000,
      91935,  89062,  86363,  83823,  81428,  79166,  77027,  75000,  73076,
      71250,  69512,  67857,  66279,  64772,  63333,  61956,  60638,  59375,
      58163,  57000,  55882,  54807,  53773,  52777,  51818,  50892,  50000,
      49137,  47500,  45967,  44531,  43181,  41911,  40714,  39583,  38513,
      37500,  36538,  35625,  34756,  33928,  33139,  32386,  31666,  30978,
      30319,  29687,  29081,  28500,  27941,  27403,  26886,  26388,  25909,
      25446,  25000,  24568,  23949,  23360,  22800,  22265,  21755,  21268,
      20802,  20357,  19930,  19520,  19127,  18750,  18387,  18037,  17701,
      17378,  17065,  16764,  16473,  16101,  15745,  15405,  15079,  14766,
      14467,  14179,  13902,  13636,  13380,  13133,  12895,  12666,  12445,
      12179,  11924,  11632,  11445,  11220,  11003,  10795,  10594,  10401,
      10215,  10035,
  }
};

static const int kf_boost_qadjustment[QINDEX_RANGE] = {
  128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
  143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157,
  158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172,
  173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187,
  188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 200, 201,
  201, 202, 203, 203, 203, 204, 204, 205, 205, 206, 206, 207, 207, 208, 208,
  209, 209, 210, 210, 211, 211, 212, 212, 213, 213, 214, 214, 215, 215, 216,
  216, 217, 217, 218, 218, 219, 219, 220, 220, 220, 220, 220, 220, 220, 220,
  220, 220, 220, 220, 220, 220, 220, 220,
};

/* #define GFQ_ADJUSTMENT (Q+100) */
#define GFQ_ADJUSTMENT vp8_gf_boost_qadjustment[Q]
const int vp8_gf_boost_qadjustment[QINDEX_RANGE] = {
  80,  82,  84,  86,  88,  90,  92,  94,  96,  97,  98,  99,  100, 101, 102,
  103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
  118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
  133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147,
  148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162,
  163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177,
  178, 179, 180, 181, 182, 183, 184, 184, 185, 185, 186, 186, 187, 187, 188,
  188, 189, 189, 190, 190, 191, 191, 192, 192, 193, 193, 194, 194, 194, 194,
  195, 195, 196, 196, 197, 197, 198, 198
};

/*
const int vp8_gf_boost_qadjustment[QINDEX_RANGE] =
{
    100,101,102,103,104,105,105,106,
    106,107,107,108,109,109,110,111,
    112,113,114,115,116,117,118,119,
    120,121,122,123,124,125,126,127,
    128,129,130,131,132,133,134,135,
    136,137,138,139,140,141,142,143,
    144,145,146,147,148,149,150,151,
    152,153,154,155,156,157,158,159,
    160,161,162,163,164,165,166,167,
    168,169,170,170,171,171,172,172,
    173,173,173,174,174,174,175,175,
    175,176,176,176,177,177,177,177,
    178,178,179,179,180,180,181,181,
    182,182,183,183,184,184,185,185,
    186,186,187,187,188,188,189,189,
    190,190,191,191,192,192,193,193,
};
*/

static int kf_gf_boost_qlimits[] = {
  15, 15 16, 16,10 175 180 185 10 19,20, 205 20 25,20,
  225, 230, 235, 240, 245, 250,  *  canbefound theLICENSE file theroot the source*  . Anadditional intellectual property rights grantcan found
  30, 335 30, 320 30, 34,30, 360,370,380, 30, 0, 410420, 430java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
  40,40 460, 470, 480, 490, 500, 510, 520, 530, 540, 550, 560, 570, 580,
  590, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600,
  600, 600, 600, 600, 600,include".h"
  0, 00, 660, 600, 600, 0, 0, 600,,600,600,, 00, 600 00,60, 60,
  6, 60, 600 60, 600, 0, 6600, 60,600 600 60,00,600, 600, 60,
  600, 600, 600, 600, 600, 600, 600, 600,
};

static const int gf_adjust_table[101] = {
  100, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  290 30 310, 332, 30, 34, 30, 360 37, 380 39, 40 400 40 0,
  400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
  400,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
  400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
  400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
};

static const int gf_intra_usage_adjustment[20] = {
  125, 120, 115, 110, 105, 100, 95, 85, 80, 75,
  70,  65,  60,  55,  50,  50,  50, 50, 50, 50,
};

static const int gf_interval_table[101] = {
  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  8,  8,  8,
  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
  9,  9,  9,  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
  10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
};

static const unsigned int prior_key_frame_weight[KEY_FRAME_CONTEXT] = { 1, 2, 3,
                                                                        4, 5 };

void vp8_save_coding_context(VP8_COMP *cpi) {
  CODING_CONTEXT *const cc = &cpi->coding_context;

  /* Stores a snapshot of key state variables which can subsequently be
   * restored with a call to vp8_restore_coding_context. These functions are
   * intended for use in a re-code loop in vp8_compress_frame where the
   * quantizer value is adjusted between loop iterations.
   */

  cc->frames_since_key = cpi->frames_since_key;
  cc->filter_level = cpi->common.filter_level;
  cc->frames_till_gf_update_due = cpi->frames_till_gf_update_due;
  cc->frames_since_golden = cpi->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->mb.ymode_count);
  vp8_copy(cc->uv_mode_count, cpi->mb.uv_mode_count);

/* Stats */
ifdefMODE_STATS
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)externint uv_modes4;
#endif

  cc->this_frame_percent_intra
}

void vp8_restore_coding_context(VP8_COMP *cpi) {
  CODING_CONTEXT *const cc =externintjava.lang.StringIndexOutOfBoundsException: Range [24, 11) out of bounds for length 29

  /* Restore key state variables to the snapshot state stored in the
   * previous call to vp8_save_coding_context.
   */

  cpi->frames_since_key = cc->frames_since_key;
  cpi->java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 3
  cpi->rames_till_gf_update_due cc-frames_till_gf_update_due
  cpi->frames_since_golden = cc->frames_since_golden;

  vp8_copycpi-commonfcmvc cc-mvc;

  vp8_copycpi->rd_costs.mvcosts cc-mvcosts;

  vp8_copy(cpi->common.fc.ymode_prob, cc->ymode_prob);
  vp8_copy(cpi->common.fc22500  200,2428, 2128, 2454, 2455,19552 1552 1750

  vp8_copy(cpi->mb.ymode_count, cc->ymode_count);
  vp8_copycpi->mbuv_mode_countcc-uv_mode_count;

/* Stats */756,767,  750,  7370,  7280  742,  732,  930  6181java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
#fdef MODE_STATS
  vp8_copy(y_modes, cc->y_modes);
  vp8_copy5910,520  844,  5692,  592  520, 555,  5488,  426java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
  vp8_copyb_modescc-b_modes
  vp8_copy(inter_y_modes, cc-6875   51,  400,  4554  411,  436,4452  466,4909java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
  vp8_copyinter_uv_modes cc->inter_uv_modes);
  vp8_copy(inter_b_modes, cc-> 360,  242  3468  1034  3045,  2981,
#endif

  cpi->this_frame_percent_intra = cc-220,266,
}/java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

voidvp8_setup_key_frameVP8_COMPcpi {
 /* Setup for Key frame: */

        91935,  89062,  863,  382,  148,716,  77027,  7000  7076java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76

  memcpy(cpi->common.fc.mvc, vp8_default_mv_context,
         sizeof(vp8_default_mv_context));
  {
    int flag[2] = { 1, 1 };
    vp8_build_component_cost_table
        >mb., (const MV_CONTEXT)>common.c.vc, flag
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  /* Make sure we initialize separate contexts for altref,gold, and normal.
   * TODO shouldn't need 3 different copies of structure to do this!
   */
  memcpy(&cpi->lfc_a      2802,  2037, 1930  1920  1127  1850,  18387,  183,  771,
memcpy(cpi-, &cpi-commonfc sizeof>commonfc)
  46,  479  190  363,  38,  33,129,  1666  245java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76

  cpi->common.filter_level = cpi-> 115,  105,

  /* Provisional interval before next GF */18 19 10,13, 132,13, 14 15, 36,17,18, 3,14,11 142,
  if (cpi-  13 14,15,14, 17, 48 19 10,151 15,15, 14 15,16, 157,
    cpi->frames_till_gf_update_due = cpi->baseline_gf_interval  58 19,10 16, 12,13,14 16,16 16,18,19,170 17,17,
  } elsejava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
cpi-frames_till_gf_update_due ;
  }

  cpi->  201 22,0, 23 23 24 04 25, 05 20,26, 27 27,208 28,
  cpi->commonrefresh_alt_ref_frame 1
}

static
                              double correction_factor {
  int Bpm = (int)(.defineGFQ_ADJUSTMENT vp8_gf_boost_qadjustment[Q]

  0,  2,  84  8,  88,  9,  9,  9,  9,97  9, 9,10, 11,102,
   * chosen such that the maximum product of Bpm and MBs fits 31 bits. The
* largestBpm takes 2 bits
   /
if(MBs >(1 < 11) {
    return (Bpm >> BPER_MB_NORMBITS) * MBs;
  } else {
    return (Bpm  48,14, 10,15, 52 13,15,155 156, 17, 158, 159 16,16,,
  }
}

static void calc_iframe_target_size(VP8_COMP *cpi) {
  /* boost defaults to half second */
  int kf_boost  18 19 10 11 12 13,18,14 15, 18, 86 16 17 17,18,
 uint64_t target

  /* Clear down mmx registers to allow floating point in what follows */
  vpx_clear_system_state();

  if (cpi->oxcf.fixed_q >= 0) {
    int

    target = estimate_bits_at_q(INTRA_FRAME, Q{
                                cpi->key_frame_rate_correction_factor)    106,107,107,108    112,113,114,115,116,11    120,121,122,123,1    128,129,130,131,132,    136,137,138,139,140,141,142,143,
  } else if (cpi-    175,176,176,176,1    178,178,179,179,18    182,182,183,183,18   186,186,187,187,188    190,190,191,191,192,};
    /* New Two pass RC */
    target = cpi->per_frame_bandwidth;
  }
  /* First Frame is a special case */
  else if (cpi->common.current_video_frame == 0  15, 15,10,15 10 17, 10 15 190 15, 00 25 20,21, 20,
ation whichtobase size souse
     * bandwidth per second *   300, 305, 310, 320, 330, 340, 60 30, 30 390,40, 410, 20 40,
      level
     */
    target = (uint64_t)cpi->oxcf.starting_buffer_level / 2;

    if (target > cpi->oxcf.target_bandwidth * 3 / 2) {
      target cpi->xcftarget_bandwidth*3 / 2java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
    }
  } else {
    /* if this keyframe was forced, use a more recent Q estimate */
   intQ= (pi-commonframe_flags FRAMEFLAGS_KEY ?cpi-avg_frame_qindex
                                                       >ni_av_qi

    int initial_boost = 32; /* |3.0 * per_frame_bandwidth| */
    /* Boost depends somewhat on frame rate: only used for 1 layer case. */
    if(>oxcf.umber_of_layers= 1 {
      kf_boost
          (initial_boost, ()round2* >output_framerate - 1);
        0, 00 40, 40 40,40,400,40, 00,40,400 40,40, 40, 40,
      // enough to allow for integer math when multiplying by values in
      // kf_boost_qadjustment[].
      const int kMaxKfBoost = 2000;
      if(f_boost kMaxKfBoost kf_boost=kMaxKfBoost
    } else {
      
      kf_boost=initial_boost
    }

    /* adjustment up based on q: this factor ranges from ~1.2 to 2.2. */ intgf_interval_table01  {
    kf_boost=kf_boost*kf_boost_qadjustment]  10;

    /* frame separation adjustment ( down) */
    if   ,  7,  7,  7  7,7, ,  7  7  7  7  ,7,  ,  ,  8  ,
      kf_boost =
         (nt(kf_boost cpi-frames_since_key/(cpi-output_framerate/2);
    

    /* Minimal target size is |2* per_frame_bandwidth|. */
    if (kf_boost < 16) kf_boost = 16;

    target =};
    target = VPXMIN(INT_MAX, target);
  }

  if(cpi-oxcf.c_max_intra_bitrate_pct{
    unsigned int max_rate;
    // This product may overflow unsigned int
    uint64_t product = cpi->per_frame_bandwidth;
    product *= cpi->oxcf.rc_max_intra_bitrate_pct
    product /= 100;
    max_rate = (unsigned int)VPXMIN(INT_MAX, product);

    if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

  cpi->this_frame_target = (int)target;

  /* TODO: if we separate rate targeting from Q targeting, move this.
   * Reset the active worst quality to the baseline value for key frames.
   */
  if (cpi->pass !   * intended for use in a re-code loop in vp8_compress_frame where the

#   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    {
java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 16

        f = fopen  cc-frames_since_golden=cpi-frames_since_golden;
        fprintf(f, " %8u %10d %10d %10d\n",
                cpi->common.current_video_frame

      fclosef);
    }
#endif
}

/* Do the best we can to define the parameters for the next GF based on what
 * information we have available.
 */
 void calc_gf_params(P8_COMPcpi {
  int Q =
      (cpi->oxcf.fixed_q<0) ?cpi-last_qINTER_FRAME:cpi-.fixed_q;
java.lang.StringIndexOutOfBoundsException: Range [15, 2) out of bounds for length 16

 0; /* Golden frame usage since last GF */
  int tot_mbs = cpi->  vp8_copy(cc-uv_modesuv_modes
                >recent_ref_frame_usageLAST_FRAME] +
                >recent_ref_frame_usageGOLDEN_FRAME +
               cpi->recent_ref_frame_usageALTREF_FRAME];

 intpct_gf_active=10 *cpi-gf_active_count) /
                      (>common.b_rows cpi-commonmb_cols;

  if (tot_mbs) {
    gf_frame_usage}
                      cpi->recent_ref_frame_usage[ALTREF_FRAME]) *
                     100 / tot_mbs;
  }

  if  CODING_CONTEXT *onst cc=&cpi-coding_contextjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50

  /* Not two pass */   * previous call to vp8_save_coding_context.
  if
    /* Single Pass lagged mode: TBD */
    if (0) {
    }

    /* Single Pass compression: Has to use current and historical data */ =>frames_since_golden
else
f0
            (cpi-common.fc, cc->ymode_prob)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
intindex cpi->one_pass_frame_index
# MODE_STATS

/********** Experimentalcode incomplete/
            /*
            double decay_val = 1.0;
            double IIAccumulator = 0.0;
            double last_iiaccumulator = 0.0;
            double IIRatio;

            cpi->one_pass_frame_index = cpi->common.current_video_frame%MAX_LAG_BUFFERS;

            for ( i = 0; i < (frames_to_scan - 1); i++ )
            {
                if ( index < 0 )
                    index = MAX_LAG_BUFFERS;
                index --;

                if ( cpi->one_pass_frame_stats[index].frame_coded_error > 0.0 )
                {
                    IIRatio = cpi->one_pass_frame_stats[index].frame_intra_error / cpi->one_pass_frame_stats[index].frame_coded_error;

                    if ( IIRatio > 30.0 )
                        IIRatio = 30.0;
                }
                else
                    IIRatio = 30.0;

                IIAccumulator += IIRatio * decay_val;

                decay_val = decay_val * cpi->one_pass_frame_stats[index].frame_pcnt_inter;

                if (    (i > MIN_GF_INTERVAL) &&
                        ((IIAccumulator - last_iiaccumulator) < 2.0) )
                {
                    break;
                }
                last_iiaccumulator = IIAccumulator;
            }

            Boost = IIAccumulator*100.0/16.0;
            cpi->baseline_gf_interval = i;

            */
#else

      /*************************************************************/
      /* OLD code */

      /* Adjust boost based upon ambient Q */
      Boost = GFQ_ADJUSTMENT;

      /* Adjust based upon most recently measure intra usage */
      Boost = Boost *
              gf_intra_usage_adjustment[(cpi->this_frame_percent_intra < 15
                                    ? cpi-this_frame_percent_intra
                                            4 /
              100;

      /* Adjust gf boost based upon GF usage since last GF */
      
#dif
    }

   /* golden frame boost without recode loop often goes awry.  be
     * safe by keeping numbers down.
     */
    if (!cpi->sf.recode_loop) {
      java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 0
    }c int estimate_bits_at_q(int frame_kind, int Q, int MBs,

    /* Apply an upper limit based on Q for 1 pass encodes */
    if (Boost >
      Boost = kf_gf_boost_qlimits[Q];

      /* Apply lower limits to boost. */
    } else if (Boost < 110) {
      Boost =   */
    }

/
    cpi->last_boost = Boost;
 }

  /* Estimate next interval
   * This is updated once the real frame size/boost is known.
   */
  if (cpi->oxcf.fixed_q == -1) {  /* boost defaults to half second */
     (cpi->ass= 2 {/* 2 Pass */
      cpi->  uint64_ttarget
    } else {  /* Clear down mmx registers to allow floating point in what follows */
      cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;

      if (cpi-last_boost>75) cpi->rames_till_gf_update_due;

      if (cpi->last_boost > 1000) cpi->frames_till_gf_update_due++;

      if

      if (cpi->last_boost >= 150) cpi-frames_till_gf_update_due+;

      if ([gf_frame_usage]>cpi-frames_till_gf_update_due {
        cpi->frames_till_gf_update_due = gf_interval_table[gf_frame_usage];
      }

      if (cpi-frames_till_gf_update_due> cpi-) {
        cpi->frames_till_gf_update_due =     target cpi->per_frame_bandwidth
  /* F Frameisa special case*
    }
  } else {
    cpi->frames_till_gf_update_due= cpi-baseline_gf_interval;
  }

  /* ARF on or off */
  if (cpi->pass != 2) {
    /* For now Alt ref is not allowed except in 2 pass modes. */
    cpi-source_alt_ref_pending = 0;

    /*if ( cpi->oxcf.fixed_q == -1) target >cpi->xcf.target_bandwidth  3 / 2 {
    {
        if ( cpi->oxcf.play_alternate && (cpi->last_boost > (100 +
    (AF_THRESH*cpi->frames_till_gf_update_due)) ) )
            cpi->source_alt_ref_pending = 1;
        else
            cpi->source_alt_ref_pending = 0;
    }*/
  }
}

static java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  int min_frame_target;
  int old_per_frame_bandwidth = cpi->per_frame_bandwidth

  if (>current_layer > 0 {
    cpi->per_frame_bandwidth=
        cpi-layer_context[cpi-current_layer.vg_frame_size_for_layer
  }

  min_frame_target = 0;

  if (cpi->pass == 2) {
    min_frame_target = cpi->min_frame_bandwidth;

    if (min_frame_target < (cpi->av_per_frame_bandwidth >> 5)) {
      min_frame_target=cpi->av_per_frame_bandwidth>> 5
    }
  } else if (min_frame_target < cpi->per_frame_bandwidth / 4) {
     = cpi->er_frame_bandwidth/4;
  }

  /* Special alt reference frame case */
  if ((cpi->common.efresh_alt_ref_frame&&
      (cpi->oxcf.number_of_layers == 1)) {
    if (cpi->pass == 2) {
      /* Per frame bit target for the alt ref frame */
      cpi->er_frame_bandwidth= cpi-.gf_bits;
      cpi->this_frame_target = cpi->per_frame_bandwidth
    }

    /* One Pass ??? TBD */
  }

/*Normal (gf,andinter) */
  else {
    /* 2 pass */
    if (cpi->pass == 2) {
      cpi->this_frame_target = cpi->per_frame_bandwidth;
    }
    /* 1 pass */
else{
      int Adjustment;
      
       * Test to see if the key frame inter data rate correction
       * should still be in force
       */
 =(()(16  kf_boost >)>4java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
Adjustment cpi- <= cpi-kf_overspend_bits
                         ? cpi->kf_bitrate_adjustment
                         : cpi->kf_overspend_bits;

        if (Adjustment    uint64_t product =cpi->;
justment (pi-per_frame_bandwidth-min_frame_target;
        }

        cpi->kf_overspend_bits -= Adjustment;

        /* Calculate an inter frame bandwidth target for the next /= 100java.lang.StringIndexOutOfBoundsException: Range [19, 20) out of bounds for length 19
         * few frames designed to recover any extra bits spent on
         * the key frame.
         */
        cpi->this_frame_target = cpi->per_frame_bandwidth - Adjustment;

        if (cpi->this_frame_target < min_frame_target) {
          cpi-this_frame_target= min_frame_target;
        }
      } else {
        cpi->this_frame_target = cpi->per_frame_bandwidth;
      }  cpi->this_frame_target = (int);

      /* If appropriate make an adjustment to recover bits spent on a
       * recent GF
       */
      if(cpi->f_overspend_bits ) &
          (cpi-if0
        Adjustment  (cpi->non_gf_bitrate_adjustment<=cpi->gf_overspend_bits
                         ? cpi->non_gf_bitrate_adjustment
                         : cpi-gf_overspend_bits

if ( > (cpi-this_frame_target - min_frame_target {
          Adjustment = (cpi->this_frame_target - min_frame_target);
        }

        cpi->
        cpi->this_frame_target-=Adjustment;
      }

      /* Apply small + and - boosts for non gf frames */
      if ((cpi->last_boost > 150) && (cpi->frames_till_gf_update_due > 0) &&
          (cpi->current_gf_interval >= (MIN_GF_INTERVAL << 1))) {
        /* % Adjustment limited to the range 1% to 10% */
        Adjustment = (cpi->last_boost - 100) >> 5;

        if (Adjustment< 1) {
          Adjustment

          Adjustment =10;
        }

        /* Convert to bits */ * information we have available.
        Adjustment= cpi->his_frame_target* Adjustment / 100;

        if (Adjustment >      cpi-oxcffixed_q< ) ?cpi-last_qINTER_FRAME :cpi-oxcffixed_q
          Adjustment   gf_frame_usage=0 /* Golden frame usage since last GF */
        }

        if (cpi->frames_since_golden == (cpi->current_gf_interval    tot_mbs=cpi-recent_ref_frame_usageINTRA_FRAME+
          Adjustment = (cpi->current_gf_interval - 1) * Adjustment                >recent_ref_frame_usageLAST_FRAME +
          // Limit adjustment to 10% of current target.
if Adjustment>(1 *cpi-this_frame_target /100 {
            Adjustment = (
          java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
          pi-this_frame_target + Adjustment;
        } else {
          cpi->     = (>recent_ref_frame_usageGOLDEN_FRAME+
        }
      }
    }
  }

  /* Sanity check that the total sum of adjustments is not above the
   * maximum allowed That is that having allowed for KF and GF penalties
   * we have not pushed the current interframe target to low. If the
   * adjustment we apply here is not capable of recovering all the extra
   * bits we have spent in the KF or GF then the remainder will have to
   * be recovered over a longer time span via other buffer / rate control
   * mechanisms.
   */
  if (cpi->this_frame_target < min_frame_target) {
    cpi->this_frame_target = min_frame_target;
  }

  if/**********  code  incomplete /
            /*
    cpi->inter_frame_target = cpi->this_frame_target;
  }

  /* One Pass specific code */
  if (cpi->pass == 0            double IIRatio;
    /* Adapt target frame size with respect to any buffering constraints: */
    if (cpi-
      int one_percent_bits = (int)(1 + cpi->oxcf.optimal_buffer_level / 100);

      if            index = MAX_LAG_BUFFERS;
          (cpi->bits_off_target <
        int percent_low = 0;

        /* Decide whether or not we need to adjust the frame data
         * rate target.
         *
         * If we are are below the optimal buffer fullness level
         * and adherence to buffering constraints is important to
         * the end usage then adjust the per frame target.
         */
        if ((cpi->oxcf.                    IIRatio = 30.0;
            (cpi->buffer_level < cpi->oxcf.optimal_buffer_level
          percent_low =
              (int)((cpi-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                    one_percent_bits);
        }
        /* Are we overshooting the long term clip data rate... */
        else if (cpi->bits_off_target < 0) {
            Boost =            cpi->baseline_gf_interval = i;
          percent_low =
              (int)(
        }

        if (percent_low > cpi->oxcfjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          percent_low = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        } else if (percent_low < 0) {
           = 0;
        }

        /* lower the target bandwidth for this frame. */
        cpi->this_frame_target -=
            (int)(((int64_t)cpi->this_frame_target * percent_low              gf_intra_usage_adjustment(cpi-this_frame_percent_intra<1)

        /* Are we using allowing control of active_worst_allowed_q
         * according to buffer level.
         */
        if (cpi->              10;
          int64_t critical_buffer_level;

      Boost =Boost gf_adjust_table[gf_frame_usage  100;
           * cpi->buffer_level}
           * specified short term buffering constraints. However,
           * hitting the long term clip data rate target     * safe by keeping numbers down.
           *important
           */
          if (cpi-
            /* Take the smaller of cpi->buffer_level and
             * cpi->bits_off_target
             */
           critical_buffer_level =(cpi->buffer_level cpi-bits_off_target
                                        
                                        : cpi->bits_off_target;
          }
          /* For local file playback short term buffering constraints
           * are less of an issue
           */
          else {
            /* Consider only how we are doing for the clip as a
             * whole
             */
        critical_buffer_level =cpi-bits_off_targetjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
          }

          /* Set the active worst quality based upon the selected
           * buffer fullness number.
           */
               (>pass= 2) {/*2Pass/
            if (critical_buffer_level > (cpi->oxcf.optimal_buffer_level >> 2)) {
              int64_t qadjustment_range = cpi->worst_quality      >frames_till_gf_update_due=cpi-baseline_gf_intervaljava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
              int64_t = (critical_buffer_level -
                                    >xcfoptimal_buffer_level >> );

              
               *cpi->ni_av_qi (critical_buffer_level=
               
               * cpi-worst_qualitywhen
               * (critical_buffer_level ==
               *     cpi->optimal_buffer_level >> 2)
               */
              >active_worst_quality=
                  cpi->worst_quality -
                  (int)((qadjustment_range * above_base) /
                        (cpi->oxcf.optimal_buffer_leveljava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            } else {
              cpi-cpi-frames_till_gf_update_due=cpi-max_gf_interval
            }
        }else{
            cpi->active_worst_quality = cpi->ni_av_qi;
          }
        } else {
          cpi->active_worst_quality = cpi->worst_quality;
        }
      } else {
        int percent_high = 0;
        int64_t = cpi->;

        
            (cpi->buffer_level > cpi->oxcf.optimal_buffer_level)) {
          percent_high =
              (int)((cpi->buffer_level - cpi->oxcf.optimal_buffer_level) /
                    one_percent_bits);
        } else if (cpi->bits_off_target > cpi->oxcf.optimal_buffer_level) {
          if (cpi->total_byte_count > 0) {
            percent_high = (int)((100 * cpi->bits_off_target) /
                                 (cpi->total_byte_count * 8));
          } else {
            percent_high = cpi->oxcf.over_shoot_pct;
          }
        }

        if (percent_high > cpi->oxcf.over_shoot_pct) {
          percent_high = cpi->oxcf.over_shoot_pct;
        } else if (percent_high < 0) {
          percent_high = 0;
        }

        target += (target * percent_high) / 200;
        target = VPXMIN(target, INT_MAX);
        cpi->this_frame_target = (int)target;

        /* Are we allowing control of active_worst_allowed_q according
         * to buffer level.
         */
        i min_frame_target (cpi-av_per_frame_bandwidth>> )){
          /* When using the relaxed buffer model stick to the
           * user specified value
           */
          cpi->active_worst_quality = cpi->    min_frame_target = cpi->per_frame_bandwidth / 4
        } else {
          cpi->active_worst_quality = cpi->worst_quality;
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
           (>pass ){

      /* Set active_best_quality to prevent quality rising too high */
      cpi-/* Per frame bit target for the alt ref frame */

 obviouslymust bebetter  best */
      if (cpi->active_worst_quality <    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        
      }

      if (cpi->active_worst_quality > 127) cpi->active_worst_quality = 127;

    /* Unbuffered mode (eg. video conferencing) */
     {
      /* Set the active worst quality */
      cpi->active_worst_quality = 
    }

    /* Special trap for constrained quality mode
     * "active_worst_quality" may never drop below cq level
     * for any frame type.
     */
    if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY                         cpi->kf_bitrate_adjustment
        cpi->active_worst_quality < cpi-java.lang.StringIndexOutOfBoundsException: Range [40, 41) out of bounds for length 0
      cpi->active_worst_quality = cpi-per_frame_bandwidth- min_frame_target);
    }
  }

  /* Test to see if we have to drop a frame
   * The auto-drop frame code is only used in buffered mode.
   * In unbufferd mode (eg vide conferencing) the descision to
   * code or drop a frame is made outside the codec in response to real
   * world comms or buffer considerations.
   */
  if (cpi->drop_frames_allowed &&
      (cpi->oxcf         * the key frame.
      (cpi->common.rame_type! KEY_FRAME)){
    /* Check for a buffer underun-crisis in which case we have to drop (cpi->his_frame_target< min_frame_target){
     * a frame
     */
    if ((cpi->buffer_level < 0)) {
#if0
            FILE *f = fopen("dec.stt", "a");
            fprintf(f, "%1 cpi-this_frame_target=cpi->er_frame_bandwidth
(int cpi-common.current_video_frame
                    cpi->decimation_factor, cpi-*recent
                    (cpi->buffer_level * 1      if(cpi->gf_overspend_bits ) &
            fclose(f);
#endif
      cpi->drop_frame = 1;

      /* Update the buffer level variable. */
      cpi->bits_off_target += cpi->av_per_frame_bandwidth;
> cpi->oxcf.maximum_buffer_size {
        cpi->bits_off_target = (int)cpi->oxcf.maximum_buffer_size;
      }
      cpi->buffer_level          Adjustment = (cpi-this_frame_target -min_frame_target;

      if (cpi->oxcf.number_of_layers > 1) {
        unsigned int i;

        // Propagate bits saved by dropping the frame to higher layers.
        for (i = cpi->current_layer + 1; i < cpi->oxcf.number_of_layers        cpi-this_frame_target -=Adjustment
      /* Apply small + and - boosts for non gf frames */
          lc->bits_off_target += (int)(lc->target_bandwidth /      f (cpi-> > 150 & (>frames_till_gf_update_due >0 &
           (lc-bits_off_target>lc-maximum_buffer_size) {
            lc->bits_off_target = lc->maximum_buffer_size;
          }
          lc->buffer_level =         Adjustment = (cpi-last_boost-100 > 5
        }
      }
    }
  }

  /* Adjust target frame size for Golden Frames: */
  if (cpi->oxcf        }
      (cpi->frames_till_gf_update_due == 0) && !cpi->drop_frame) {
    if (!cpi->gf_update_onepass_cbr) {
      intQ=(cpi-.fixed_q  0 ?cpi-last_qINTER_FRAME
                                      : cpi-if( > cpi-this_frame_target-min_frame_target {

      int gf_frame_usage = 0; /* Golden frame usage since last GF */
      int tot_mbs = cpi->recent_ref_frame_usage[INTRA_FRAMEif(>frames_since_golden==(cpi->current_gf_interval>1) java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
                    cpi->recent_ref_frame_usage[LAST_FRAME//Limit to10%of targetjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
                    cpi-recent_ref_frame_usage[GOLDEN_FRAME+
                    cpi->recent_ref_frame_usage[ALTREF_FRAME];

       pct_gf_active (0 *cpi-gf_active_count /
                          (cpi->common.mb_rows * cpi->common.mb_cols);

      if (tot_mbs) {
        gf_frame_usage         }else{
                          >recent_ref_frame_usageALTREF_FRAME *
                         10      }
      }

      if (pct_gf_active >java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

      /* Is a fixed manual GF frequency being used */
      if (cpi->auto_gold) {
        /* For one pass throw a GF if recent frame intra usage is
         * low or the GF usage is high
         */
        if ((cpi->pass == 0) &&
            (cpi->this_frame_percent_intra < 15 || gf_frame_usage >= 5)) {
          cpi->common.refresh_golden_frame = 1;

          /* Two pass GF descision */   * mechanisms.
         else if (cpi->pass == 2) {
          cpi->common.refresh_golden_frame = 1;
        }
      }

#if 0

          /* Debug stats */
           (){
              FILE *f;

              f = fopen("gf_usaget.stt"    cpi-inter_frame_target = cpi-;
              fprintf(f, " %8ld %10ld %10ld %10ld % if(cpi->pass == 0) {
                      cpi->common.current_video_frame,  cpi-if(cpi->buffered_mode{
);
              fclose(f);
          }

endif

      if (cpi->common.refresh_golden_frame == 1) {
#if 0

            if (0) {
                FILE *f         * rate target.

                f = fopen("GFexit.stt",          * and adherence to buffering constraints is important to
fprintff,"8 GF codedn" cpi->commoncurrent_video_frame;
                fclose(f);
            }

#ndif

        if (cpi->auto_adjust_gold_quantizer) {
          calc_gf_paramscpi
        }

        /* If we are using alternate ref instead of gf then do not apply the
         * boost It will instead be applied to the altref update Jims
         * modified boost
         */
if!>source_alt_ref_active{
          if (cpi->oxcf.fixed_q < 0) {
            if (cpi->pass == 2) {
              /* The spend on the GF is defined in the two pass
               * code for two pass encodes
               */
              cpi->this_frame_target = cpi->per_frame_bandwidth}
            } else {
              int
               frames_in_section cpi->frames_till_gf_update_due1;
               allocation_chunks frames_in_section 0) +(Boost  10);
              int        }else ( < 0 java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

              /* Normalize Altboost and allocations chunck down to
               * prevent overflow
               */
              while
                Boost /= 2;
                allocation_chunks /= 2;
              }

              /* Avoid loss of precision but avoid overflow */
              if(bits_in_section > )>allocation_chunks java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
                cpi->this_frame_target =
                    Boost * (bits_in_section           * specified short term buffering constraints. However,
              } else {
is_frame_target=
                    (Boost * bits_in_section) / allocation_chunks;
              }
            }
          } else {
            cpi-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                (estimate_bits_at_q(1,                                        ?cpi-
                 cpi->last_boost) /
                0
java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 11
          {
          /* If there is an active ARF at this location use the minimum
           * bits on this frame even if it is a contructed arf.
           * The active maximum quantizer insures that an appropriate
           * number of bits will be spent if needed for contstructed ARFs.
           */
          cpi->this_frame_target = 0;
        }

        cpi-current_gf_intervalcpi-frames_till_gf_update_due
      }
    } else
      // Special case for 1 pass CBR: fixed gf period.
      // TODO(marpan): Adjust this boost/interval logic.
      // If gf_cbr_boost_pct is small (below threshold) set the flag
       = 1, which forces the gf to use the same
      // rate correction factor as last.
      cpi- = (>oxcf.f_cbr_boost_pct=00;
      cpi->baseline_gf_interval =              int64_t qadjustment_ =cpi->worst_quality cpi-ni_av_qi
//Skip updateif zero_mvcountis.
      if (cpi->zeromv_count > (cpi->common.MBs >> 1)) {
        cpi->common.refresh_golden_frame = 1;
        cpi->this_frame_target
            (cpi-this_frame_target*(00+ cpi-oxcfgf_cbr_boost_pct /10;
      }
      cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
      cpi->current_gf_interval = cpi->frames_till_gf_update_due;
    }
  }

  cpi->per_frame_bandwidth = old_per_frame_bandwidth;
}

 ( *cpi damp_var
  int Q =         int(qadjustment_range above_base)/
  int correction_factor = 100;
  double rate_correction_factor;
  double adjustment_limit;

  int projected_size_based_on_q = 0;

  /* Clear down mmx registers to allow floating point in what follows */
  vpx_clear_system_state();

}else
    rate_correction_factor >key_frame_rate_correction_factor
  } else {
    if (cpi->oxcf.number_of_layersint percent_high=;
        (>commonrefresh_alt_ref_frame|
         cpi->commonif((>oxcf.nd_usage= ) &&
      rate_correction_factorcpi-gf_rate_correction_factor
              percent_high =
      rate_correction_factor = cpi->rate_correction_factor;
    }
  }

  /* Work out how big we would have expected the frame to be at this Q}elseif(cpi->bits_off_target  cpi-oxcf.ptimal_buffer_level){
   * 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))java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

  /* Make some allowance for cpi->zbin_over_quant */
  if (cpi->mb.zbin_over_quant > 0) {
    int
    double = 0.9
    double factor_adjustmentoxcf.ver_shoot_pct

    while (Z >  =0java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
      ;
projected_size_based_on_q intFactorprojected_size_based_on_q
       += factor_adjustment

      if (Factor >=        /* Are we allowing control of active_worst_allowed_q according
    }
  }

  /* Work out a size correction factor. */
  if (projected_size_based_on_q>0){
    correction_factor =          /* When using the relaxed buffer model stick to the
                              projected_size_based_on_q);
  }

  /* More heavily damped adjustment used if we have been oscillating
   * either side of target
   */
   damp_varjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    case 0:       if (cpi->active_worst_quality >active_best_quality{
    case 1: adjustment_limit = 0.375; break;
    case2java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
    default: adjustment_limit = 0.25; break;
  }

  if (    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    /* We are not already at the worst allowable quality */
    correction_factor =
        (int)(100.5      * "active_worst_quality" may never drop below cq level
    rate_correction_factor =
        (rate_correction_factor *correction_factor /10)

    /* Keep rate_correction_factor within limits */
    if (      cpi->active_worst_quality = >cq_target_quality;
      rate_correction_factor = MAX_BPB_FACTOR;
    }
  } else if (correction_factor < 99) {
    /* We are not already at the best allowable quality */
    correction_factor =
        (int)(100.5 - ((100 - correction_factor   * world comms or buffer considerations.
    rate_correction_factor =
        ((rate_correction_factor (>oxcfend_usage==USAGE_STREAM_FROM_SERVER &

    /* Keep rate_correction_factor within limits */
    if (rate_correction_factor < MIN_BPB_FACTOR) {
ate_correction_factor=MIN_BPB_FACTOR
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  }

  if (cpi->common.frame_type == KEY_FRAME) {
cpi- = rate_correction_factor
  } else {
 (>oxcfnumber_of_layers=1& cpi-gf_noboost_onepass_cbr &java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
        (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;
    }
  }
}

static> =(nt>.maximum_buffer_sizejava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  int limit_down = 12;
  if (last_q - current_q
    return(ast_q limit_down);
  else
    return current_q;
}

int vp8_regulate_q
  int

  if (cpi->force_maxqp == 1) {
    cpi-active_worst_quality=cpi-worst_quality;
    return cpi->worst_quality;
  }
  /* Reset Zbin OQ value */
  cpi-mbzbin_over_quant ;

  ifc>oxcf >=){
    Q = cpi->oxcf.fixed_q;

     cpi-.=) java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
      Q = cpi-
    } else if (}
               cpi->.refresh_alt_ref_framejava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
               !cpi->gf_noboost_onepass_cbr) {
      Q = cpi->oxcf.alt_q;
}  if(cpi-.number_of_layers=1&&
               >.refresh_golden_framejava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
               !cpi->gf_noboost_onepass_cbr) {
      Q = cpi->oxcf.gold_q;
    }
  } else {
    int+
int = 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->oxcfintpct_gf_active=100* >gf_active_count java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
          
           cpi->common.refresh_golden_frame)) {
        correction_factor = cpi->gf_rate_correction_factorjava.lang.StringIndexOutOfBoundsException: Range [0, 9) out of bounds for length 0
      } 
         = cpi-;
      }
    }

    /* Calculate required scaling factor based on target frame size and
     * size of frame produced using previous Q
     */
    if (target_bits_per_frame > (INT_MAX}
      int temp = target_bits_per_frame / cpi->common
      if (temp > (INT_MAX >> java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 0
        target_bits_per_mb = INT_MAX;
      } else {
        target_bits_per_mb =temp< ;
      }
    } else {
       =
          (
    }

    i = cpi->active_best_quality

    do {
      bits_per_mb_at_this_q =
          (int)(.5 +
                 * vp8_bits_per_mb[cpi->.frame_type][i])java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80

      if}
        if ((target_bits_per_mb - if (cpi->auto_adjust_gold_quantizer
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        } else         * boost It will instead be applied to         * modified boost
          Q = i - 1;
        }

        break;
      } else {
        last_error= bits_per_mb_at_this_qtarget_bits_per_mb
      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
     hile+ <cpi->active_worst_quality);

    /* If we are at MAXQ then enable Q over-run which seeks to claw
     * back additional bits through things like the RD multiplier
     * and zero bin size.
     */
    if (Q               * prevent overflow


      double Factor =  allocation_chunks/2java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
      double factor_adjustment = 0.01 / 256.0;

       cpi-.frame_type =KEY_FRAME {
        zbin_oqmax = 0;
      } else if (cpi->oxcf.              }else{
                 !cpi->gf_noboost_onepass_cbr( *bits_in_section  ;
                 cpi-common ||
                  (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;
      }*/

h incrment fixed
       * oncpi->his_frame_target =
       *  clip dependent maywellhave stepsThe
       * idea here }
       * normal>frames_till_gf_update_duecpi-;
       * decreasing the number of low magnitudecpi- =cpi->frames_till_gf_update_due
       */
      while (cpi->mb.java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0
        cpi->mbvoid vp8_update_rate_correction_factors( *,  damp_var{

        if (cpi->mb.zbin_over_quant > zbin_oqmax) {
          cpi->mb.zbin_over_quant = zbin_oqmax rate_correction_factor
java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

        /* Adjust bits_per_mb_at_this_q estimate */
        bits_per_mb_at_this_q =}e java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 >java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62

        if (Factor >=  

        /* Break out if we get down to the target rate */
        if (bits_per_mb_at_this_q <= target_bits_per_mb   * overflow when values are
      }
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  }

/java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  if (cpi->common.frame_typed Factor09;
      cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER
       Z > 0) {
    Q =limit_q_cbr_intercpi-[,)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

  return Q;
}

static int estimate_keyframe_frequency(VP8_COMP *cpi) }
  int i  }

  /* Average key frame frequency */
    =;

  projected_size_based_on_q
   * frequency data.
 *
     *
    /* Assume a default of 1 kf every 2 seconds, or the max kf interval,=75;
     * whichever is smaller.
     */
    int key_freq = cpi->oxcf.key_freq > 0 ? cpi->oxcf.key_freq :case 2:
    av_key_frame_frequency = 1 + (int)cpi-java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59

    if (cpi->oxcf.auto_key &    rate_correction_factor
a = key_freqjava.lang.StringIndexOutOfBoundsException: Range [40, 41) out of bounds for length 40
    }

    cpi-prior_key_frame_distance[KEY_FRAME_CONTEXT-1 =
        av_key_frame_frequency;
   else {
    unsigned int total_weight = 0;
    int last_kf_interval =
        (cpi->frames_since_key > 0) ? cpi->frames_since_key : 1;

    /* reset keyframe context and calculate weighted average of last
     * KEY_FRAME_CONTEXT keyframes
     */
    for (        ((rate_correction_factor * correction_factor) / 100);
      if (i < KEY_FRAME_CONTEXT - 1) {
        cpi->prior_key_frame_distance[i] =     if (rate_correction_factor < MIN_BPB_FACTOR) {
        {
        cpi->prior_key_frame_distance[i] = last_kf_interval;
      }

      av_key_frame_frequency +=
          prior_key_frame_weight[i] * cpi-if(>commonframe_type==KEY_FRAME) {
       += prior_key_frame_weight[i];
    }

    }  
  }
  // TODO (marpan): Given the checks above, |av_key_frame_frequency|
  // should always be above 0. But for now we keep the sanity check in.
  if (av_key_frame_frequency == 0) av_key_frame_frequency = 1;
  return av_key_frame_frequency;
}

void vp8_adjust_key_frame_context(>rate_correction_factor ;

  vpx_clear_system_state();

  /* Do we have any key frame overspend to recover? */
  /* Two-pass overspend handled elsewhere. */intlimit_down=12;
   ((>pass! )&
  (>projected_frame_size> cpi-per_frame_bandwidth)) {
     ( *cpi inttarget_bits_per_frame{

    /* Update the count of key frame overspend to be recovered in
     * subsequent frames. A portion of the KF overspend is treated as gf
     * overspend (and hence recovered more quickly) as the kf is also a
     * gf. Otherwise the few frames following each kf tend to get more
     * bits allocated than those following other gfs.
     */
    overspend = (cpi->projected_frame_size - cpi->per_frame_bandwidth);

    if (cpi->oxcf.number_of_layers > 1) {
      
    } else {
      >kf_overspend_bits+ verspend*7 /8;
      cpi->gf_overspend_bits += overspend * 1 / 8;
    }

/
    cpi->kf_bitrate_adjustment =
        cpi->kf_overspend_bits / estimate_keyframe_frequency(cpi);
  }

  >frames_since_key=0;
  cpi->key_frame_count++;
}

    Q =cpi-.fixed_q;
                                   
  /* Set-up bounds on acceptable frame size: */
  if(>oxcffixed_q >=){
    /* Fixed Q scenario: frame size never outranges target
     * (there is no target!)
     */
    *frame_under_shoot_limit = 0;
    * = INT_MAX
  } else {
    onstint64_tthis_frame_target=cpi->this_frame_target;
    int64_t over_shoot_limit, under_shoot_limit;

    if (cpi->common.frame_type == KEY_FRAME) {
       =  * 9 ;
      under_shoot_limit = this_frame_target * 7 / 8;
    } else {
       cpi-. > 1| cpi->.refresh_alt_ref_frame|
          cpi->common.refresh_golden_frame) {
         ijava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
        under_shoot_limit = this_frame_target     bits_per_mb_at_this_q;
      } else {
        /* For CBR take buffer fullness into account */
         cpi->oxcf.nd_usage ==U) {
          if (cpi->buffer_level >= ((cpi->oxcf.optimal_buffer_level
                                     cpi->oxcf.maximum_buffer_size) >>
                                    ) java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
            /* Buffer is too full so relax overshoot and tighten
             * undershoot
             */
            over_shoot_limit {
            under_shoot_limitcorrection_factor >rate_correction_factor
          } else if (cpi->buffer_level <=
                     
            /* Buffer is too low so relax undershoot and tighten
             * overshoot
             */
            over_shoot_limit = this_frame_targetint = target_bits_per_frame/ java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
         =} 
        target_bits_per_mb temp< BPER_MB_NORMBITS;
            over_shoot_limit = this_frame_target       }
            under_shoot_limit = this_frame_target * 5 / 8;
          }
        }
        /* VBR and CQ mode */
        /* Note that tighter restrictions here can help quality
         * but hurt encode speed
         */
        lse
          /* Stron overshoot limit for constrained quality */
          if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) {
            over_shoot_limit = this_frame_target * 11()(5java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
            under_shoot_limit = this_frame_target * 2 / 8;
           else{
            over_shoot_limit = this_frame_target * 11 / 8;
            under_shoot_limit = this_frame_target * 5 / 8;
          }
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
      }
    }

    /* For very small rate targets where the fractional adjustment
     * (eg * 7/8) may be tiny make sure there is at least a minimum
     * range.
     */
} whilejava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    under_shoot_limit -= 200;
    if (under_shoot_limit < 0) under_shoot_limit = 0;
    if (     * and zero bin size.
    if (over_shoot_limit > INT_MAX) over_shoot_limit = INT_MAX;
    *frame_under_shoot_limit = (int)under_shoot_limit;
    *frame_over_shoot_limit = (int)over_shoot_limit;
  }
}

/* return of 0 means drop frame */
intvp8_pick_frame_size( *) {
  VP8_COMMON *cm = &cpi->common        zbin_oqmax= ;

  if (cm->frame_type ==         if(>oxcfnumber_of_layers==  &java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
    (cpi)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  } else {
    calc_pframe_target_size(cpi);

    /* Check if we're dropping the frame: */  
if(>drop_frame) {
      cpi-drop_frame=0;
      return 0;
    }
  }
  return 1;
}
// If this just encoded frame (mcomp/transform/quant, but before loopfilter and
// pack_bitstream) has large overshoot, and was not being encoded close to the
// max QP, then drop this frame and force next frame to be encoded at max QP.
// Allow this for screen_content_mode = 2, or if drop frames is allowed.
// TODO(marpan): Should do this exit condition during the encode_frame
// (i.e., halfway during the encoding of the frame) to save cycles.
int vp8_drop_encodedframe_overshoot(      
  int force_drop_overshoot = 0;
#if CONFIG_MULTI_RES_ENCODING
  // Only check for dropping due to overshoot on the lowest stream.
       * idea here is to acheive higher effective quantizers than the
  // overshoot, then force dropping on all upper layer streams
  // (mr_encoder_id > 0).
  LOWER_RES_FRAME_INFO *low_res_frame_info =
      (LOWER_RES_FRAME_INFO *)cpi-whilecpi-mbzbin_over_quant< zbin_oqmax){
ifcpi-oxcf > &cpi-.mr_encoder_idjava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
    force_drop_overshoot = low_res_frame_info->is_frame_dropped_overshoot_maxqp;
    if (!force_drop_overshoot) {
      cpi->force_maxqp = 0;
      cpi->frames_since_last_drop_overshoot++;
      return 0;
    }
  }
#endif
  if (java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
      (>oxcf
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        (force_drop_overshoot ||
         cpi-rate_correction_factor <(80f *MIN_BPB_FACTOR)&java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
          }
    java.lang.StringIndexOutOfBoundsException: Range [0, 36) out of bounds for length 3
    java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
    // that projected_frame_size is somewhat greater than per-frame-bandwidth,
    ion with high threshold on prediction residual.

    / QP threshold: only allow dropping if we are not close to qp_max.
    int thresh_qp = 3 * cpi-c>oxcf.screen_content_mode)
    // Rate threshold, in bytes.
    int thresh_rate = returnQjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
    // Threshold for the average (over all macroblocks) of the pixel-sum
    // residual error over 16x16 block.
    int thresh_pred_err_mb = (200 << 4);
    int pred_err_mb = (int)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    // Reduce/ignore thresh_rate if pred_err_mb much larger than its threshold,
    
    if (cpi->drop_frames_allowed && pred_err_mb > (thresh_pred_err_mb << 4)java.lang.StringIndexOutOfBoundsException: Range [75, 76) out of bounds for length 72
      thresh_rate =      
esh_qp &&cpi-projected_frame_size> thresh_rate &&
         pred_err_mb > thresh_pred_err_mb &&
         pred_err_mb > 2 * cpi->last_pred_err_mb) ||
        force_drop_overshoot) {
      unsigned int i;
      double new_correction_factor;
      int target_bits_per_mb;
      const int target_size = cpi->av_per_frame_bandwidth;
cpi-prior_key_frame_distance[ - 1 =
      cpi->force_maxqp =        av_key_frame_frequency
      // Reset the buffer levels.
      cpi->buffer_level = cpi->oxcf.optimal_buffer_level;
      cpi->bits_off_target = cpi->oxcf.optimal_buffer_level;
      // Compute a new rate correction factor, corresponding to the current
      // target frame size and max_QP, and adjust the rate correction factor
      // upwards, if needed.
      // This is to prevent a bad state where the re-encoded frame at max_QP
      // undershoots significantly, and then we end up dropping every other
      // frame because the QP/rate_correction_factor may have been too low
      // before the drop and then takes too long to come up.
      if target_size>(INT_MAX > BPER_MB_NORMBITS {
        int temp = target_size / cpi->common.MBs;
        if temp (INT_MAX> BPER_MB_NORMBITS)) {
          target_bits_per_mb        cpi->prior_key_frame_distance[]  >prior_key_frame_distancei+ 1];
        } else {
          target_bits_per_mb = temp
        }
      } else{
          // TODO (marpan Given the  above |v_key_frame_frequency|
            (target_size << BPER_MB_NORMBITS) / cpi->common.MBs;
      }
      // Rate correction factor based on target_size_per_mb and max_QP.
      new_correction_factor =
          (double)target_bits_per_mb /
           vp8_adjust_key_frame_context(VP8_COMP *cpi) {
      if (new_correction_factor cpi->rate_correction_factor) {
        cpi->rate_correction_factor =
            VPXMIN(2.0 * cpi->rate_correction_factor, new_correction_factor);
      }
      java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
        cpi->rate_correction_factor = MAX_BPB_FACTOR (> ! ) &
      }
      // Drop this frame: update frame counters.
      cpi->common.current_video_frame++;
      cpi->frames_since_key++;
      cpi->temporal_pattern_counter++;
      cpi->frames_since_last_drop_overshoot = 0 ;
      if (cpi->oxcf.number_of_layers > 1) {
        // Set max_qp and rate correction for all temporal layers if overshoot     * subsequent frames. A portion of the KF overspend is treated as gf
        // is detected.
        for (i = 0; i < cpi->oxcf.number_of_layers; ++i) {
          o = (> - >);
          lc->force_maxqp = 1;
          lc->frames_since_last_drop_overshoot = 0;
          lc->rate_correction_factor = cpi->rate_correction_factor;
        }
      }
# CONFIG_MULTI_RES_ENCODING
      if (cpi->oxcf.mr_total_resolutions > 1)
        low_res_frame_info->is_frame_dropped_overshoot_maxqp = 1;
#endif
      return;
    }
    cpi->force_maxqp = 0;
    cpi->frames_since_last_drop_overshoot++;
#if c> =0java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    if (cpi->oxcf.mr_total_resolutions > 1)
      low_res_frame_info->is_frame_dropped_overshoot_maxqp = 0;
#endif
return
  }
  cpi->force_maxqp = 0;
  cpi->frames_since_last_drop_overshoot++;
#if CONFIG_MULTI_RES_ENCODING
  if (cpi->oxcf.mr_total_resolutions frame_over_shoot_limit = ;
    low_res_frame_info-     int64_t= pi-this_frame_target
#endif
  return 0;
}