vp8/encoder/ratectrl.c

   1 /*
   2  *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 #include <stdlib.h>
  12 #include <stdio.h>
  13 #include <string.h>
  14 #include <limits.h>
  15 #include <assert.h>
  16
  17 #include "math.h"
  18 #include "vp8/common/common.h"
  19 #include "ratectrl.h"
  20 #include "vp8/common/entropymode.h"
  21 #include "vpx_mem/vpx_mem.h"
  22 #include "vp8/common/systemdependent.h"
  23 #include "encodemv.h"
  24 #include "vpx_dsp/vpx_dsp_common.h"
  25 #include "vpx_ports/system_state.h"
  26
  27 #define MIN_BPB_FACTOR 0.01
  28 #define MAX_BPB_FACTOR 50
  29
  30 extern const MB_PREDICTION_MODE vp8_mode_order[MAX_MODES];
  31
  32 #ifdef MODE_STATS
  33 extern int y_modes[5];
  34 extern int uv_modes[4];
  35 extern int b_modes[10];
  36
  37 extern int inter_y_modes[10];
  38 extern int inter_uv_modes[4];
  39 extern int inter_b_modes[10];
  40 #endif
  41
  42 /* Bits Per MB at different Q (Multiplied by 512) */
  43 #define BPER_MB_NORMBITS 9
  44
  45 /* Work in progress recalibration of baseline rate tables based on
  46  * the assumption that bits per mb is inversely proportional to the
  47  * quantizer value.
  48  */
  49 const int vp8_bits_per_mb[2][QINDEX_RANGE] = {
  50   /* Intra case 450000/Qintra */
  51   {
  52       1125000, 900000, 750000, 642857, 562500, 500000, 450000, 450000, 409090,
  53       375000,  346153, 321428, 300000, 281250, 264705, 264705, 250000, 236842,
  54       225000,  225000, 214285, 214285, 204545, 204545, 195652, 195652, 187500,
  55       180000,  180000, 173076, 166666, 160714, 155172, 150000, 145161, 140625,
  56       136363,  132352, 128571, 125000, 121621, 121621, 118421, 115384, 112500,
  57       109756,  107142, 104651, 102272, 100000, 97826,  97826,  95744,  93750,
  58       91836,   90000,  88235,  86538,  84905,  83333,  81818,  80357,  78947,
  59       77586,   76271,  75000,  73770,  72580,  71428,  70312,  69230,  68181,
  60       67164,   66176,  65217,  64285,  63380,  62500,  61643,  60810,  60000,
  61       59210,   59210,  58441,  57692,  56962,  56250,  55555,  54878,  54216,
  62       53571,   52941,  52325,  51724,  51136,  50561,  49450,  48387,  47368,
  63       46875,   45918,  45000,  44554,  44117,  43269,  42452,  41666,  40909,
  64       40178,   39473,  38793,  38135,  36885,  36290,  35714,  35156,  34615,
  65       34090,   33582,  33088,  32608,  32142,  31468,  31034,  30405,  29801,
  66       29220,   28662,
  67   },
  68   /* Inter case 285000/Qinter */
  69   {
  70       712500, 570000, 475000, 407142, 356250, 316666, 285000, 259090, 237500,
  71       219230, 203571, 190000, 178125, 167647, 158333, 150000, 142500, 135714,
  72       129545, 123913, 118750, 114000, 109615, 105555, 101785, 98275,  95000,
  73       91935,  89062,  86363,  83823,  81428,  79166,  77027,  75000,  73076,
  74       71250,  69512,  67857,  66279,  64772,  63333,  61956,  60638,  59375,
  75       58163,  57000,  55882,  54807,  53773,  52777,  51818,  50892,  50000,
  76       49137,  47500,  45967,  44531,  43181,  41911,  40714,  39583,  38513,
  77       37500,  36538,  35625,  34756,  33928,  33139,  32386,  31666,  30978,
  78       30319,  29687,  29081,  28500,  27941,  27403,  26886,  26388,  25909,
  79       25446,  25000,  24568,  23949,  23360,  22800,  22265,  21755,  21268,
  80       20802,  20357,  19930,  19520,  19127,  18750,  18387,  18037,  17701,
  81       17378,  17065,  16764,  16473,  16101,  15745,  15405,  15079,  14766,
  82       14467,  14179,  13902,  13636,  13380,  13133,  12895,  12666,  12445,
  83       12179,  11924,  11632,  11445,  11220,  11003,  10795,  10594,  10401,
  84       10215,  10035,
  85   }
  86 };
  87
  88 static const int kf_boost_qadjustment[QINDEX_RANGE] = {
  89   128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
  90   143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157,
  91   158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172,
  92   173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187,
  93   188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 200, 201,
  94   201, 202, 203, 203, 203, 204, 204, 205, 205, 206, 206, 207, 207, 208, 208,
  95   209, 209, 210, 210, 211, 211, 212, 212, 213, 213, 214, 214, 215, 215, 216,
  96   216, 217, 217, 218, 218, 219, 219, 220, 220, 220, 220, 220, 220, 220, 220,
  97   220, 220, 220, 220, 220, 220, 220, 220,
  98 };
  99
 100 /* #define GFQ_ADJUSTMENT (Q+100) */
 101 #define GFQ_ADJUSTMENT vp8_gf_boost_qadjustment[Q]
 102 const int vp8_gf_boost_qadjustment[QINDEX_RANGE] = {
 103   80,  82,  84,  86,  88,  90,  92,  94,  96,  97,  98,  99,  100, 101, 102,
 104   103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
 105   118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
 106   133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147,
 107   148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162,
 108   163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177,
 109   178, 179, 180, 181, 182, 183, 184, 184, 185, 185, 186, 186, 187, 187, 188,
 110   188, 189, 189, 190, 190, 191, 191, 192, 192, 193, 193, 194, 194, 194, 194,
 111   195, 195, 196, 196, 197, 197, 198, 198
 112 };
 113
 114 /*
 115 const int vp8_gf_boost_qadjustment[QINDEX_RANGE] =
 116 {
 117     100,101,102,103,104,105,105,106,
 118     106,107,107,108,109,109,110,111,
 119     112,113,114,115,116,117,118,119,
 120     120,121,122,123,124,125,126,127,
 121     128,129,130,131,132,133,134,135,
 122     136,137,138,139,140,141,142,143,
 123     144,145,146,147,148,149,150,151,
 124     152,153,154,155,156,157,158,159,
 125     160,161,162,163,164,165,166,167,
 126     168,169,170,170,171,171,172,172,
 127     173,173,173,174,174,174,175,175,
 128     175,176,176,176,177,177,177,177,
 129     178,178,179,179,180,180,181,181,
 130     182,182,183,183,184,184,185,185,
 131     186,186,187,187,188,188,189,189,
 132     190,190,191,191,192,192,193,193,
 133 };
 134 */
 135
 136 static const int kf_gf_boost_qlimits[QINDEX_RANGE] = {
 137   150, 155, 160, 165, 170, 175, 180, 185, 190, 195, 200, 205, 210, 215, 220,
 138   225, 230, 235, 240, 245, 250, 255, 260, 265, 270, 275, 280, 285, 290, 295,
 139   300, 305, 310, 320, 330, 340, 350, 360, 370, 380, 390, 400, 410, 420, 430,
 140   440, 450, 460, 470, 480, 490, 500, 510, 520, 530, 540, 550, 560, 570, 580,
 141   590, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600,
 142   600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600,
 143   600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600,
 144   600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600,
 145   600, 600, 600, 600, 600, 600, 600, 600,
 146 };
 147
 148 static const int gf_adjust_table[101] = {
 149   100, 115, 130, 145, 160, 175, 190, 200, 210, 220, 230, 240, 260, 270, 280,
 150   290, 300, 310, 320, 330, 340, 350, 360, 370, 380, 390, 400, 400, 400, 400,
 151   400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
 152   400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
 153   400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
 154   400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
 155   400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
 156 };
 157
 158 static const int gf_intra_usage_adjustment[20] = {
 159   125, 120, 115, 110, 105, 100, 95, 85, 80, 75,
 160   70,  65,  60,  55,  50,  50,  50, 50, 50, 50,
 161 };
 162
 163 static const int gf_interval_table[101] = {
 164   7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
 165   7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  8,  8,  8,
 166   8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
 167   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
 168   9,  9,  9,  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
 169   10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
 170 };
 171
 172 static const unsigned int prior_key_frame_weight[KEY_FRAME_CONTEXT] = { 1, 2, 3,
 173                                                                         4, 5 };
 174
 175 void vp8_save_coding_context(VP8_COMP *cpi) {
 176   CODING_CONTEXT *const cc = &cpi->coding_context;
 177
 178   /* Stores a snapshot of key state variables which can subsequently be
 179    * restored with a call to vp8_restore_coding_context. These functions are
 180    * intended for use in a re-code loop in vp8_compress_frame where the
 181    * quantizer value is adjusted between loop iterations.
 182    */
 183
 184   cc->frames_since_key = cpi->frames_since_key;
 185   cc->filter_level = cpi->common.filter_level;
 186   cc->frames_till_gf_update_due = cpi->frames_till_gf_update_due;
 187   cc->frames_since_golden = cpi->frames_since_golden;
 188
 189   vp8_copy(cc->mvc, cpi->common.fc.mvc);
 190   vp8_copy(cc->mvcosts, cpi->rd_costs.mvcosts);
 191
 192   vp8_copy(cc->ymode_prob, cpi->common.fc.ymode_prob);
 193   vp8_copy(cc->uv_mode_prob, cpi->common.fc.uv_mode_prob);
 194
 195   vp8_copy(cc->ymode_count, cpi->mb.ymode_count);
 196   vp8_copy(cc->uv_mode_count, cpi->mb.uv_mode_count);
 197
 198 /* Stats */
 199 #ifdef MODE_STATS
 200   vp8_copy(cc->y_modes, y_modes);
 201   vp8_copy(cc->uv_modes, uv_modes);
 202   vp8_copy(cc->b_modes, b_modes);
 203   vp8_copy(cc->inter_y_modes, inter_y_modes);
 204   vp8_copy(cc->inter_uv_modes, inter_uv_modes);
 205   vp8_copy(cc->inter_b_modes, inter_b_modes);
 206 #endif
 207
 208   cc->this_frame_percent_intra = cpi->this_frame_percent_intra;
 209 }
 210
 211 void vp8_restore_coding_context(VP8_COMP *cpi) {
 212   CODING_CONTEXT *const cc = &cpi->coding_context;
 213
 214   /* Restore key state variables to the snapshot state stored in the
 215    * previous call to vp8_save_coding_context.
 216    */
 217
 218   cpi->frames_since_key = cc->frames_since_key;
 219   cpi->common.filter_level = cc->filter_level;
 220   cpi->frames_till_gf_update_due = cc->frames_till_gf_update_due;
 221   cpi->frames_since_golden = cc->frames_since_golden;
 222
 223   vp8_copy(cpi->common.fc.mvc, cc->mvc);
 224
 225   vp8_copy(cpi->rd_costs.mvcosts, cc->mvcosts);
 226
 227   vp8_copy(cpi->common.fc.ymode_prob, cc->ymode_prob);
 228   vp8_copy(cpi->common.fc.uv_mode_prob, cc->uv_mode_prob);
 229
 230   vp8_copy(cpi->mb.ymode_count, cc->ymode_count);
 231   vp8_copy(cpi->mb.uv_mode_count, cc->uv_mode_count);
 232
 233 /* Stats */
 234 #ifdef MODE_STATS
 235   vp8_copy(y_modes, cc->y_modes);
 236   vp8_copy(uv_modes, cc->uv_modes);
 237   vp8_copy(b_modes, cc->b_modes);
 238   vp8_copy(inter_y_modes, cc->inter_y_modes);
 239   vp8_copy(inter_uv_modes, cc->inter_uv_modes);
 240   vp8_copy(inter_b_modes, cc->inter_b_modes);
 241 #endif
 242
 243   cpi->this_frame_percent_intra = cc->this_frame_percent_intra;
 244 }
 245
 246 void vp8_setup_key_frame(VP8_COMP *cpi) {
 247   /* Setup for Key frame: */
 248
 249   vp8_default_coef_probs(&cpi->common);
 250
 251   memcpy(cpi->common.fc.mvc, vp8_default_mv_context,
 252          sizeof(vp8_default_mv_context));
 253   {
 254     int flag[2] = { 1, 1 };
 255     vp8_build_component_cost_table(
 256         cpi->mb.mvcost, (const MV_CONTEXT *)cpi->common.fc.mvc, flag);
 257   }
 258
 259   /* Make sure we initialize separate contexts for altref,gold, and normal.
 260    * TODO shouldn't need 3 different copies of structure to do this!
 261    */
 262   memcpy(&cpi->lfc_a, &cpi->common.fc, sizeof(cpi->common.fc));
 263   memcpy(&cpi->lfc_g, &cpi->common.fc, sizeof(cpi->common.fc));
 264   memcpy(&cpi->lfc_n, &cpi->common.fc, sizeof(cpi->common.fc));
 265
 266   cpi->common.filter_level = cpi->common.base_qindex * 3 / 8;
 267
 268   /* Provisional interval before next GF */
 269   if (cpi->auto_gold) {
 270     cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
 271   } else {
 272     cpi->frames_till_gf_update_due = DEFAULT_GF_INTERVAL;
 273   }
 274
 275   cpi->common.refresh_golden_frame = 1;
 276   cpi->common.refresh_alt_ref_frame = 1;
 277 }
 278
 279 static int estimate_bits_at_q(int frame_kind, int Q, int MBs,
 280                               double correction_factor) {
 281   int Bpm = (int)(.5 + correction_factor * vp8_bits_per_mb[frame_kind][Q]);
 282
 283   /* Attempt to retain reasonable accuracy without overflow. The cutoff is
 284    * chosen such that the maximum product of Bpm and MBs fits 31 bits. The
 285    * largest Bpm takes 20 bits.
 286    */
 287   if (MBs > (1 << 11)) {
 288     return (Bpm >> BPER_MB_NORMBITS) * MBs;
 289   } else {
 290     return (Bpm * MBs) >> BPER_MB_NORMBITS;
 291   }
 292 }
 293
 294 static void calc_iframe_target_size(VP8_COMP *cpi) {
 295   /* boost defaults to half second */
 296   int kf_boost;
 297   uint64_t target;
 298
 299   /* Clear down mmx registers to allow floating point in what follows */
 300   vpx_clear_system_state();
 301
 302   if (cpi->oxcf.fixed_q >= 0) {
 303     int Q = cpi->oxcf.key_q;
 304
 305     target = estimate_bits_at_q(INTRA_FRAME, Q, cpi->common.MBs,
 306                                 cpi->key_frame_rate_correction_factor);
 307   } else if (cpi->pass == 2) {
 308     /* New Two pass RC */
 309     target = cpi->per_frame_bandwidth;
 310   }
 311   /* First Frame is a special case */
 312   else if (cpi->common.current_video_frame == 0) {
 313     /* 1 Pass there is no information on which to base size so use
 314      * bandwidth per second * fraction of the initial buffer
 315      * level
 316      */
 317     target = cpi->oxcf.starting_buffer_level / 2;
 318
 319     if (target > cpi->oxcf.target_bandwidth * 3 / 2) {
 320       target = cpi->oxcf.target_bandwidth * 3 / 2;
 321     }
 322   } else {
 323     /* if this keyframe was forced, use a more recent Q estimate */
 324     int Q = (cpi->common.frame_flags & FRAMEFLAGS_KEY) ? cpi->avg_frame_qindex
 325                                                        : cpi->ni_av_qi;
 326
 327     int initial_boost = 32; /* |3.0 * per_frame_bandwidth| */
 328     /* Boost depends somewhat on frame rate: only used for 1 layer case. */
 329     if (cpi->oxcf.number_of_layers == 1) {
 330       kf_boost = VPXMAX(initial_boost, (int)(2 * cpi->output_framerate - 16));
 331     } else {
 332       /* Initial factor: set target size to: |3.0 * per_frame_bandwidth|. */
 333       kf_boost = initial_boost;
 334     }
 335
 336     /* adjustment up based on q: this factor ranges from ~1.2 to 2.2. */
 337     kf_boost = kf_boost * kf_boost_qadjustment[Q] / 100;
 338
 339     /* frame separation adjustment ( down) */
 340     if (cpi->frames_since_key < cpi->output_framerate / 2) {
 341       kf_boost =
 342           (int)(kf_boost * cpi->frames_since_key / (cpi->output_framerate / 2));
 343     }
 344
 345     /* Minimal target size is |2* per_frame_bandwidth|. */
 346     if (kf_boost < 16) kf_boost = 16;
 347
 348     target = ((16 + kf_boost) * cpi->per_frame_bandwidth) >> 4;
 349   }
 350
 351   if (cpi->oxcf.rc_max_intra_bitrate_pct) {
 352     unsigned int max_rate =
 353         cpi->per_frame_bandwidth * cpi->oxcf.rc_max_intra_bitrate_pct / 100;
 354
 355     if (target > max_rate) target = max_rate;
 356   }
 357
 358   cpi->this_frame_target = (int)target;
 359
 360   /* TODO: if we separate rate targeting from Q targetting, move this.
 361    * Reset the active worst quality to the baseline value for key frames.
 362    */
 363   if (cpi->pass != 2) cpi->active_worst_quality = cpi->worst_quality;
 364
 365 #if 0
 366     {
 367         FILE *f;
 368
 369         f = fopen("kf_boost.stt", "a");
 370         fprintf(f, " %8u %10d %10d %10d\n",
 371                 cpi->common.current_video_frame,  cpi->gfu_boost, cpi->baseline_gf_interval, cpi->source_alt_ref_pending);
 372
 373         fclose(f);
 374     }
 375 #endif
 376 }
 377
 378 /* Do the best we can to define the parameters for the next GF based on what
 379  * information we have available.
 380  */
 381 static void calc_gf_params(VP8_COMP *cpi) {
 382   int Q =
 383       (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;
 384   int Boost = 0;
 385
 386   int gf_frame_useage = 0; /* Golden frame useage since last GF */
 387   int tot_mbs = cpi->recent_ref_frame_usage[INTRA_FRAME] +
 388                 cpi->recent_ref_frame_usage[LAST_FRAME] +
 389                 cpi->recent_ref_frame_usage[GOLDEN_FRAME] +
 390                 cpi->recent_ref_frame_usage[ALTREF_FRAME];
 391
 392   int pct_gf_active = (100 * cpi->gf_active_count) /
 393                       (cpi->common.mb_rows * cpi->common.mb_cols);
 394
 395   if (tot_mbs) {
 396     gf_frame_useage = (cpi->recent_ref_frame_usage[GOLDEN_FRAME] +
 397                        cpi->recent_ref_frame_usage[ALTREF_FRAME]) *
 398                       100 / tot_mbs;
 399   }
 400
 401   if (pct_gf_active > gf_frame_useage) gf_frame_useage = pct_gf_active;
 402
 403   /* Not two pass */
 404   if (cpi->pass != 2) {
 405     /* Single Pass lagged mode: TBD */
 406     if (0) {
 407     }
 408
 409     /* Single Pass compression: Has to use current and historical data */
 410     else {
 411 #if 0
 412             /* Experimental code */
 413             int index = cpi->one_pass_frame_index;
 414             int frames_to_scan = (cpi->max_gf_interval <= MAX_LAG_BUFFERS) ? cpi->max_gf_interval : MAX_LAG_BUFFERS;
 415
 416             /* ************** Experimental code - incomplete */
 417             /*
 418             double decay_val = 1.0;
 419             double IIAccumulator = 0.0;
 420             double last_iiaccumulator = 0.0;
 421             double IIRatio;
 422
 423             cpi->one_pass_frame_index = cpi->common.current_video_frame%MAX_LAG_BUFFERS;
 424
 425             for ( i = 0; i < (frames_to_scan - 1); i++ )
 426             {
 427                 if ( index < 0 )
 428                     index = MAX_LAG_BUFFERS;
 429                 index --;
 430
 431                 if ( cpi->one_pass_frame_stats[index].frame_coded_error > 0.0 )
 432                 {
 433                     IIRatio = cpi->one_pass_frame_stats[index].frame_intra_error / cpi->one_pass_frame_stats[index].frame_coded_error;
 434
 435                     if ( IIRatio > 30.0 )
 436                         IIRatio = 30.0;
 437                 }
 438                 else
 439                     IIRatio = 30.0;
 440
 441                 IIAccumulator += IIRatio * decay_val;
 442
 443                 decay_val = decay_val * cpi->one_pass_frame_stats[index].frame_pcnt_inter;
 444
 445                 if (    (i > MIN_GF_INTERVAL) &&
 446                         ((IIAccumulator - last_iiaccumulator) < 2.0) )
 447                 {
 448                     break;
 449                 }
 450                 last_iiaccumulator = IIAccumulator;
 451             }
 452
 453             Boost = IIAccumulator*100.0/16.0;
 454             cpi->baseline_gf_interval = i;
 455
 456             */
 457 #else
 458
 459       /*************************************************************/
 460       /* OLD code */
 461
 462       /* Adjust boost based upon ambient Q */
 463       Boost = GFQ_ADJUSTMENT;
 464
 465       /* Adjust based upon most recently measure intra useage */
 466       Boost = Boost *
 467               gf_intra_usage_adjustment[(cpi->this_frame_percent_intra < 15)
 468                                             ? cpi->this_frame_percent_intra
 469                                             : 14] /
 470               100;
 471
 472       /* Adjust gf boost based upon GF usage since last GF */
 473       Boost = Boost * gf_adjust_table[gf_frame_useage] / 100;
 474 #endif
 475     }
 476
 477     /* golden frame boost without recode loop often goes awry.  be
 478      * safe by keeping numbers down.
 479      */
 480     if (!cpi->sf.recode_loop) {
 481       if (cpi->compressor_speed == 2) Boost = Boost / 2;
 482     }
 483
 484     /* Apply an upper limit based on Q for 1 pass encodes */
 485     if (Boost > kf_gf_boost_qlimits[Q] && (cpi->pass == 0)) {
 486       Boost = kf_gf_boost_qlimits[Q];
 487
 488       /* Apply lower limits to boost. */
 489     } else if (Boost < 110) {
 490       Boost = 110;
 491     }
 492
 493     /* Note the boost used */
 494     cpi->last_boost = Boost;
 495   }
 496
 497   /* Estimate next interval
 498    * This is updated once the real frame size/boost is known.
 499    */
 500   if (cpi->oxcf.fixed_q == -1) {
 501     if (cpi->pass == 2) { /* 2 Pass */
 502       cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
 503     } else { /* 1 Pass */
 504       cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
 505
 506       if (cpi->last_boost > 750) cpi->frames_till_gf_update_due++;
 507
 508       if (cpi->last_boost > 1000) cpi->frames_till_gf_update_due++;
 509
 510       if (cpi->last_boost > 1250) cpi->frames_till_gf_update_due++;
 511
 512       if (cpi->last_boost >= 1500) cpi->frames_till_gf_update_due++;
 513
 514       if (gf_interval_table[gf_frame_useage] > cpi->frames_till_gf_update_due) {
 515         cpi->frames_till_gf_update_due = gf_interval_table[gf_frame_useage];
 516       }
 517
 518       if (cpi->frames_till_gf_update_due > cpi->max_gf_interval) {
 519         cpi->frames_till_gf_update_due = cpi->max_gf_interval;
 520       }
 521     }
 522   } else {
 523     cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
 524   }
 525
 526   /* ARF on or off */
 527   if (cpi->pass != 2) {
 528     /* For now Alt ref is not allowed except in 2 pass modes. */
 529     cpi->source_alt_ref_pending = 0;
 530
 531     /*if ( cpi->oxcf.fixed_q == -1)
 532     {
 533         if ( cpi->oxcf.play_alternate && (cpi->last_boost > (100 +
 534     (AF_THRESH*cpi->frames_till_gf_update_due)) ) )
 535             cpi->source_alt_ref_pending = 1;
 536         else
 537             cpi->source_alt_ref_pending = 0;
 538     }*/
 539   }
 540 }
 541
 542 static void calc_pframe_target_size(VP8_COMP *cpi) {
 543   int min_frame_target;
 544   int old_per_frame_bandwidth = cpi->per_frame_bandwidth;
 545
 546   if (cpi->current_layer > 0) {
 547     cpi->per_frame_bandwidth =
 548         cpi->layer_context[cpi->current_layer].avg_frame_size_for_layer;
 549   }
 550
 551   min_frame_target = 0;
 552
 553   if (cpi->pass == 2) {
 554     min_frame_target = cpi->min_frame_bandwidth;
 555
 556     if (min_frame_target < (cpi->av_per_frame_bandwidth >> 5)) {
 557       min_frame_target = cpi->av_per_frame_bandwidth >> 5;
 558     }
 559   } else if (min_frame_target < cpi->per_frame_bandwidth / 4) {
 560     min_frame_target = cpi->per_frame_bandwidth / 4;
 561   }
 562
 563   /* Special alt reference frame case */
 564   if ((cpi->common.refresh_alt_ref_frame) &&
 565       (cpi->oxcf.number_of_layers == 1)) {
 566     if (cpi->pass == 2) {
 567       /* Per frame bit target for the alt ref frame */
 568       cpi->per_frame_bandwidth = cpi->twopass.gf_bits;
 569       cpi->this_frame_target = cpi->per_frame_bandwidth;
 570     }
 571
 572     /* One Pass ??? TBD */
 573   }
 574
 575   /* Normal frames (gf,and inter) */
 576   else {
 577     /* 2 pass */
 578     if (cpi->pass == 2) {
 579       cpi->this_frame_target = cpi->per_frame_bandwidth;
 580     }
 581     /* 1 pass */
 582     else {
 583       int Adjustment;
 584       /* Make rate adjustment to recover bits spent in key frame
 585        * Test to see if the key frame inter data rate correction
 586        * should still be in force
 587        */
 588       if (cpi->kf_overspend_bits > 0) {
 589         Adjustment = (cpi->kf_bitrate_adjustment <= cpi->kf_overspend_bits)
 590                          ? cpi->kf_bitrate_adjustment
 591                          : cpi->kf_overspend_bits;
 592
 593         if (Adjustment > (cpi->per_frame_bandwidth - min_frame_target)) {
 594           Adjustment = (cpi->per_frame_bandwidth - min_frame_target);
 595         }
 596
 597         cpi->kf_overspend_bits -= Adjustment;
 598
 599         /* Calculate an inter frame bandwidth target for the next
 600          * few frames designed to recover any extra bits spent on
 601          * the key frame.
 602          */
 603         cpi->this_frame_target = cpi->per_frame_bandwidth - Adjustment;
 604
 605         if (cpi->this_frame_target < min_frame_target) {
 606           cpi->this_frame_target = min_frame_target;
 607         }
 608       } else {
 609         cpi->this_frame_target = cpi->per_frame_bandwidth;
 610       }
 611
 612       /* If appropriate make an adjustment to recover bits spent on a
 613        * recent GF
 614        */
 615       if ((cpi->gf_overspend_bits > 0) &&
 616           (cpi->this_frame_target > min_frame_target)) {
 617         Adjustment = (cpi->non_gf_bitrate_adjustment <= cpi->gf_overspend_bits)
 618                          ? cpi->non_gf_bitrate_adjustment
 619                          : cpi->gf_overspend_bits;
 620
 621         if (Adjustment > (cpi->this_frame_target - min_frame_target)) {
 622           Adjustment = (cpi->this_frame_target - min_frame_target);
 623         }
 624
 625         cpi->gf_overspend_bits -= Adjustment;
 626         cpi->this_frame_target -= Adjustment;
 627       }
 628
 629       /* Apply small + and - boosts for non gf frames */
 630       if ((cpi->last_boost > 150) && (cpi->frames_till_gf_update_due > 0) &&
 631           (cpi->current_gf_interval >= (MIN_GF_INTERVAL << 1))) {
 632         /* % Adjustment limited to the range 1% to 10% */
 633         Adjustment = (cpi->last_boost - 100) >> 5;
 634
 635         if (Adjustment < 1) {
 636           Adjustment = 1;
 637         } else if (Adjustment > 10) {
 638           Adjustment = 10;
 639         }
 640
 641         /* Convert to bits */
 642         Adjustment = (cpi->this_frame_target * Adjustment) / 100;
 643
 644         if (Adjustment > (cpi->this_frame_target - min_frame_target)) {
 645           Adjustment = (cpi->this_frame_target - min_frame_target);
 646         }
 647
 648         if (cpi->frames_since_golden == (cpi->current_gf_interval >> 1)) {
 649           Adjustment = (cpi->current_gf_interval - 1) * Adjustment;
 650           // Limit adjustment to 10% of current target.
 651           if (Adjustment > (10 * cpi->this_frame_target) / 100) {
 652             Adjustment = (10 * cpi->this_frame_target) / 100;
 653           }
 654           cpi->this_frame_target += Adjustment;
 655         } else {
 656           cpi->this_frame_target -= Adjustment;
 657         }
 658       }
 659     }
 660   }
 661
 662   /* Sanity check that the total sum of adjustments is not above the
 663    * maximum allowed That is that having allowed for KF and GF penalties
 664    * we have not pushed the current interframe target to low. If the
 665    * adjustment we apply here is not capable of recovering all the extra
 666    * bits we have spent in the KF or GF then the remainder will have to
 667    * be recovered over a longer time span via other buffer / rate control
 668    * mechanisms.
 669    */
 670   if (cpi->this_frame_target < min_frame_target) {
 671     cpi->this_frame_target = min_frame_target;
 672   }
 673
 674   if (!cpi->common.refresh_alt_ref_frame) {
 675     /* Note the baseline target data rate for this inter frame. */
 676     cpi->inter_frame_target = cpi->this_frame_target;
 677   }
 678
 679   /* One Pass specific code */
 680   if (cpi->pass == 0) {
 681     /* Adapt target frame size with respect to any buffering constraints: */
 682     if (cpi->buffered_mode) {
 683       int one_percent_bits = (int)(1 + cpi->oxcf.optimal_buffer_level / 100);
 684
 685       if ((cpi->buffer_level < cpi->oxcf.optimal_buffer_level) ||
 686           (cpi->bits_off_target < cpi->oxcf.optimal_buffer_level)) {
 687         int percent_low = 0;
 688
 689         /* Decide whether or not we need to adjust the frame data
 690          * rate target.
 691          *
 692          * If we are are below the optimal buffer fullness level
 693          * and adherence to buffering constraints is important to
 694          * the end usage then adjust the per frame target.
 695          */
 696         if ((cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
 697             (cpi->buffer_level < cpi->oxcf.optimal_buffer_level)) {
 698           percent_low =
 699               (int)((cpi->oxcf.optimal_buffer_level - cpi->buffer_level) /
 700                     one_percent_bits);
 701         }
 702         /* Are we overshooting the long term clip data rate... */
 703         else if (cpi->bits_off_target < 0) {
 704           /* Adjust per frame data target downwards to compensate. */
 705           percent_low =
 706               (int)(100 * -cpi->bits_off_target / (cpi->total_byte_count * 8));
 707         }
 708
 709         if (percent_low > cpi->oxcf.under_shoot_pct) {
 710           percent_low = cpi->oxcf.under_shoot_pct;
 711         } else if (percent_low < 0) {
 712           percent_low = 0;
 713         }
 714
 715         /* lower the target bandwidth for this frame. */
 716         cpi->this_frame_target -= (cpi->this_frame_target * percent_low) / 200;
 717
 718         /* Are we using allowing control of active_worst_allowed_q
 719          * according to buffer level.
 720          */
 721         if (cpi->auto_worst_q && cpi->ni_frames > 150) {
 722           int64_t critical_buffer_level;
 723
 724           /* For streaming applications the most important factor is
 725            * cpi->buffer_level as this takes into account the
 726            * specified short term buffering constraints. However,
 727            * hitting the long term clip data rate target is also
 728            * important.
 729            */
 730           if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) {
 731             /* Take the smaller of cpi->buffer_level and
 732              * cpi->bits_off_target
 733              */
 734             critical_buffer_level = (cpi->buffer_level < cpi->bits_off_target)
 735                                         ? cpi->buffer_level
 736                                         : cpi->bits_off_target;
 737           }
 738           /* For local file playback short term buffering constraints
 739            * are less of an issue
 740            */
 741           else {
 742             /* Consider only how we are doing for the clip as a
 743              * whole
 744              */
 745             critical_buffer_level = cpi->bits_off_target;
 746           }
 747
 748           /* Set the active worst quality based upon the selected
 749            * buffer fullness number.
 750            */
 751           if (critical_buffer_level < cpi->oxcf.optimal_buffer_level) {
 752             if (critical_buffer_level > (cpi->oxcf.optimal_buffer_level >> 2)) {
 753               int64_t qadjustment_range = cpi->worst_quality - cpi->ni_av_qi;
 754               int64_t above_base = (critical_buffer_level -
 755                                     (cpi->oxcf.optimal_buffer_level >> 2));
 756
 757               /* Step active worst quality down from
 758                * cpi->ni_av_qi when (critical_buffer_level ==
 759                * cpi->optimal_buffer_level) to
 760                * cpi->worst_quality when
 761                * (critical_buffer_level ==
 762                *     cpi->optimal_buffer_level >> 2)
 763                */
 764               cpi->active_worst_quality =
 765                   cpi->worst_quality -
 766                   (int)((qadjustment_range * above_base) /
 767                         (cpi->oxcf.optimal_buffer_level * 3 >> 2));
 768             } else {
 769               cpi->active_worst_quality = cpi->worst_quality;
 770             }
 771           } else {
 772             cpi->active_worst_quality = cpi->ni_av_qi;
 773           }
 774         } else {
 775           cpi->active_worst_quality = cpi->worst_quality;
 776         }
 777       } else {
 778         int percent_high = 0;
 779
 780         if ((cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
 781             (cpi->buffer_level > cpi->oxcf.optimal_buffer_level)) {
 782           percent_high =
 783               (int)((cpi->buffer_level - cpi->oxcf.optimal_buffer_level) /
 784                     one_percent_bits);
 785         } else if (cpi->bits_off_target > cpi->oxcf.optimal_buffer_level) {
 786           percent_high =
 787               (int)((100 * cpi->bits_off_target) / (cpi->total_byte_count * 8));
 788         }
 789
 790         if (percent_high > cpi->oxcf.over_shoot_pct) {
 791           percent_high = cpi->oxcf.over_shoot_pct;
 792         } else if (percent_high < 0) {
 793           percent_high = 0;
 794         }
 795
 796         cpi->this_frame_target += (cpi->this_frame_target * percent_high) / 200;
 797
 798         /* Are we allowing control of active_worst_allowed_q according
 799          * to buffer level.
 800          */
 801         if (cpi->auto_worst_q && cpi->ni_frames > 150) {
 802           /* When using the relaxed buffer model stick to the
 803            * user specified value
 804            */
 805           cpi->active_worst_quality = cpi->ni_av_qi;
 806         } else {
 807           cpi->active_worst_quality = cpi->worst_quality;
 808         }
 809       }
 810
 811       /* Set active_best_quality to prevent quality rising too high */
 812       cpi->active_best_quality = cpi->best_quality;
 813
 814       /* Worst quality obviously must not be better than best quality */
 815       if (cpi->active_worst_quality <= cpi->active_best_quality) {
 816         cpi->active_worst_quality = cpi->active_best_quality + 1;
 817       }
 818
 819       if (cpi->active_worst_quality > 127) cpi->active_worst_quality = 127;
 820     }
 821     /* Unbuffered mode (eg. video conferencing) */
 822     else {
 823       /* Set the active worst quality */
 824       cpi->active_worst_quality = cpi->worst_quality;
 825     }
 826
 827     /* Special trap for constrained quality mode
 828      * "active_worst_quality" may never drop below cq level
 829      * for any frame type.
 830      */
 831     if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY &&
 832         cpi->active_worst_quality < cpi->cq_target_quality) {
 833       cpi->active_worst_quality = cpi->cq_target_quality;
 834     }
 835   }
 836
 837   /* Test to see if we have to drop a frame
 838    * The auto-drop frame code is only used in buffered mode.
 839    * In unbufferd mode (eg vide conferencing) the descision to
 840    * code or drop a frame is made outside the codec in response to real
 841    * world comms or buffer considerations.
 842    */
 843   if (cpi->drop_frames_allowed &&
 844       (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
 845       ((cpi->common.frame_type != KEY_FRAME))) {
 846     /* Check for a buffer underun-crisis in which case we have to drop
 847      * a frame
 848      */
 849     if ((cpi->buffer_level < 0)) {
 850 #if 0
 851             FILE *f = fopen("dec.stt", "a");
 852             fprintf(f, "%10d %10d %10d %10d ***** BUFFER EMPTY\n",
 853                     (int) cpi->common.current_video_frame,
 854                     cpi->decimation_factor, cpi->common.horiz_scale,
 855                     (cpi->buffer_level * 100) / cpi->oxcf.optimal_buffer_level);
 856             fclose(f);
 857 #endif
 858       cpi->drop_frame = 1;
 859
 860       /* Update the buffer level variable. */
 861       cpi->bits_off_target += cpi->av_per_frame_bandwidth;
 862       if (cpi->bits_off_target > cpi->oxcf.maximum_buffer_size) {
 863         cpi->bits_off_target = (int)cpi->oxcf.maximum_buffer_size;
 864       }
 865       cpi->buffer_level = cpi->bits_off_target;
 866
 867       if (cpi->oxcf.number_of_layers > 1) {
 868         unsigned int i;
 869
 870         // Propagate bits saved by dropping the frame to higher layers.
 871         for (i = cpi->current_layer + 1; i < cpi->oxcf.number_of_layers; ++i) {
 872           LAYER_CONTEXT *lc = &cpi->layer_context[i];
 873           lc->bits_off_target += (int)(lc->target_bandwidth / lc->framerate);
 874           if (lc->bits_off_target > lc->maximum_buffer_size) {
 875             lc->bits_off_target = lc->maximum_buffer_size;
 876           }
 877           lc->buffer_level = lc->bits_off_target;
 878         }
 879       }
 880     }
 881   }
 882
 883   /* Adjust target frame size for Golden Frames: */
 884   if (cpi->oxcf.error_resilient_mode == 0 &&
 885       (cpi->frames_till_gf_update_due == 0) && !cpi->drop_frame) {
 886     if (!cpi->gf_update_onepass_cbr) {
 887       int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME]
 888                                       : cpi->oxcf.fixed_q;
 889
 890       int gf_frame_useage = 0; /* Golden frame useage since last GF */
 891       int tot_mbs = cpi->recent_ref_frame_usage[INTRA_FRAME] +
 892                     cpi->recent_ref_frame_usage[LAST_FRAME] +
 893                     cpi->recent_ref_frame_usage[GOLDEN_FRAME] +
 894                     cpi->recent_ref_frame_usage[ALTREF_FRAME];
 895
 896       int pct_gf_active = (100 * cpi->gf_active_count) /
 897                           (cpi->common.mb_rows * cpi->common.mb_cols);
 898
 899       if (tot_mbs) {
 900         gf_frame_useage = (cpi->recent_ref_frame_usage[GOLDEN_FRAME] +
 901                            cpi->recent_ref_frame_usage[ALTREF_FRAME]) *
 902                           100 / tot_mbs;
 903       }
 904
 905       if (pct_gf_active > gf_frame_useage) gf_frame_useage = pct_gf_active;
 906
 907       /* Is a fixed manual GF frequency being used */
 908       if (cpi->auto_gold) {
 909         /* For one pass throw a GF if recent frame intra useage is
 910          * low or the GF useage is high
 911          */
 912         if ((cpi->pass == 0) &&
 913             (cpi->this_frame_percent_intra < 15 || gf_frame_useage >= 5)) {
 914           cpi->common.refresh_golden_frame = 1;
 915
 916           /* Two pass GF descision */
 917         } else if (cpi->pass == 2) {
 918           cpi->common.refresh_golden_frame = 1;
 919         }
 920       }
 921
 922 #if 0
 923
 924           /* Debug stats */
 925           if (0) {
 926               FILE *f;
 927
 928               f = fopen("gf_useaget.stt", "a");
 929               fprintf(f, " %8ld %10ld %10ld %10ld %10ld\n",
 930                       cpi->common.current_video_frame,  cpi->gfu_boost,
 931                       GFQ_ADJUSTMENT, cpi->gfu_boost, gf_frame_useage);
 932               fclose(f);
 933           }
 934
 935 #endif
 936
 937       if (cpi->common.refresh_golden_frame == 1) {
 938 #if 0
 939
 940             if (0) {
 941                 FILE *f;
 942
 943                 f = fopen("GFexit.stt", "a");
 944                 fprintf(f, "%8ld GF coded\n", cpi->common.current_video_frame);
 945                 fclose(f);
 946             }
 947
 948 #endif
 949
 950         if (cpi->auto_adjust_gold_quantizer) {
 951           calc_gf_params(cpi);
 952         }
 953
 954         /* If we are using alternate ref instead of gf then do not apply the
 955          * boost It will instead be applied to the altref update Jims
 956          * modified boost
 957          */
 958         if (!cpi->source_alt_ref_active) {
 959           if (cpi->oxcf.fixed_q < 0) {
 960             if (cpi->pass == 2) {
 961               /* The spend on the GF is defined in the two pass
 962                * code for two pass encodes
 963                */
 964               cpi->this_frame_target = cpi->per_frame_bandwidth;
 965             } else {
 966               int Boost = cpi->last_boost;
 967               int frames_in_section = cpi->frames_till_gf_update_due + 1;
 968               int allocation_chunks = (frames_in_section * 100) + (Boost - 100);
 969               int bits_in_section = cpi->inter_frame_target * frames_in_section;
 970
 971               /* Normalize Altboost and allocations chunck down to
 972                * prevent overflow
 973                */
 974               while (Boost > 1000) {
 975                 Boost /= 2;
 976                 allocation_chunks /= 2;
 977               }
 978
 979               /* Avoid loss of precision but avoid overflow */
 980               if ((bits_in_section >> 7) > allocation_chunks) {
 981                 cpi->this_frame_target =
 982                     Boost * (bits_in_section / allocation_chunks);
 983               } else {
 984                 cpi->this_frame_target =
 985                     (Boost * bits_in_section) / allocation_chunks;
 986               }
 987             }
 988           } else {
 989             cpi->this_frame_target =
 990                 (estimate_bits_at_q(1, Q, cpi->common.MBs, 1.0) *
 991                  cpi->last_boost) /
 992                 100;
 993           }
 994         } else {
 995           /* If there is an active ARF at this location use the minimum
 996            * bits on this frame even if it is a contructed arf.
 997            * The active maximum quantizer insures that an appropriate
 998            * number of bits will be spent if needed for contstructed ARFs.
 999            */
1000           cpi->this_frame_target = 0;
1001         }
1002
1003         cpi->current_gf_interval = cpi->frames_till_gf_update_due;
1004       }
1005     } else {
1006       // Special case for 1 pass CBR: fixed gf period.
1007       // TODO(marpan): Adjust this boost/interval logic.
1008       // If gf_cbr_boost_pct is small (below threshold) set the flag
1009       // gf_noboost_onepass_cbr = 1, which forces the gf to use the same
1010       // rate correction factor as last.
1011       cpi->gf_noboost_onepass_cbr = (cpi->oxcf.gf_cbr_boost_pct <= 100);
1012       cpi->baseline_gf_interval = cpi->gf_interval_onepass_cbr;
1013       // Skip this update if the zero_mvcount is low.
1014       if (cpi->zeromv_count > (cpi->common.MBs >> 1)) {
1015         cpi->common.refresh_golden_frame = 1;
1016         cpi->this_frame_target =
1017             (cpi->this_frame_target * (100 + cpi->oxcf.gf_cbr_boost_pct)) / 100;
1018       }
1019       cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
1020       cpi->current_gf_interval = cpi->frames_till_gf_update_due;
1021     }
1022   }
1023
1024   cpi->per_frame_bandwidth = old_per_frame_bandwidth;
1025 }
1026
1027 void vp8_update_rate_correction_factors(VP8_COMP *cpi, int damp_var) {
1028   int Q = cpi->common.base_qindex;
1029   int correction_factor = 100;
1030   double rate_correction_factor;
1031   double adjustment_limit;
1032
1033   int projected_size_based_on_q = 0;
1034
1035   /* Clear down mmx registers to allow floating point in what follows */
1036   vpx_clear_system_state();
1037
1038   if (cpi->common.frame_type == KEY_FRAME) {
1039     rate_correction_factor = cpi->key_frame_rate_correction_factor;
1040   } else {
1041     if (cpi->oxcf.number_of_layers == 1 && !cpi->gf_noboost_onepass_cbr &&
1042         (cpi->common.refresh_alt_ref_frame ||
1043          cpi->common.refresh_golden_frame)) {
1044       rate_correction_factor = cpi->gf_rate_correction_factor;
1045     } else {
1046       rate_correction_factor = cpi->rate_correction_factor;
1047     }
1048   }
1049
1050   /* Work out how big we would have expected the frame to be at this Q
1051    * given the current correction factor. Stay in double to avoid int
1052    * overflow when values are large
1053    */
1054   projected_size_based_on_q =
1055       (int)(((.5 + rate_correction_factor *
1056                        vp8_bits_per_mb[cpi->common.frame_type][Q]) *
1057              cpi->common.MBs) /
1058             (1 << BPER_MB_NORMBITS));
1059
1060   /* Make some allowance for cpi->zbin_over_quant */
1061   if (cpi->mb.zbin_over_quant > 0) {
1062     int Z = cpi->mb.zbin_over_quant;
1063     double Factor = 0.99;
1064     double factor_adjustment = 0.01 / 256.0;
1065
1066     while (Z > 0) {
1067       Z--;
1068       projected_size_based_on_q = (int)(Factor * projected_size_based_on_q);
1069       Factor += factor_adjustment;
1070
1071       if (Factor >= 0.999) Factor = 0.999;
1072     }
1073   }
1074
1075   /* Work out a size correction factor. */
1076   if (projected_size_based_on_q > 0) {
1077     correction_factor =
1078         (100 * cpi->projected_frame_size) / projected_size_based_on_q;
1079   }
1080
1081   /* More heavily damped adjustment used if we have been oscillating
1082    * either side of target
1083    */
1084   switch (damp_var) {
1085     case 0: adjustment_limit = 0.75; break;
1086     case 1: adjustment_limit = 0.375; break;
1087     case 2:
1088     default: adjustment_limit = 0.25; break;
1089   }
1090
1091   if (correction_factor > 102) {
1092     /* We are not already at the worst allowable quality */
1093     correction_factor =
1094         (int)(100.5 + ((correction_factor - 100) * adjustment_limit));
1095     rate_correction_factor =
1096         ((rate_correction_factor * correction_factor) / 100);
1097
1098     /* Keep rate_correction_factor within limits */
1099     if (rate_correction_factor > MAX_BPB_FACTOR) {
1100       rate_correction_factor = MAX_BPB_FACTOR;
1101     }
1102   } else if (correction_factor < 99) {
1103     /* We are not already at the best allowable quality */
1104     correction_factor =
1105         (int)(100.5 - ((100 - correction_factor) * adjustment_limit));
1106     rate_correction_factor =
1107         ((rate_correction_factor * correction_factor) / 100);
1108
1109     /* Keep rate_correction_factor within limits */
1110     if (rate_correction_factor < MIN_BPB_FACTOR) {
1111       rate_correction_factor = MIN_BPB_FACTOR;
1112     }
1113   }
1114
1115   if (cpi->common.frame_type == KEY_FRAME) {
1116     cpi->key_frame_rate_correction_factor = rate_correction_factor;
1117   } else {
1118     if (cpi->oxcf.number_of_layers == 1 && !cpi->gf_noboost_onepass_cbr &&
1119         (cpi->common.refresh_alt_ref_frame ||
1120          cpi->common.refresh_golden_frame)) {
1121       cpi->gf_rate_correction_factor = rate_correction_factor;
1122     } else {
1123       cpi->rate_correction_factor = rate_correction_factor;
1124     }
1125   }
1126 }
1127
1128 int vp8_regulate_q(VP8_COMP *cpi, int target_bits_per_frame) {
1129   int Q = cpi->active_worst_quality;
1130
1131   if (cpi->force_maxqp == 1) {
1132     cpi->active_worst_quality = cpi->worst_quality;
1133     return cpi->worst_quality;
1134   }
1135   /* Reset Zbin OQ value */
1136   cpi->mb.zbin_over_quant = 0;
1137
1138   if (cpi->oxcf.fixed_q >= 0) {
1139     Q = cpi->oxcf.fixed_q;
1140
1141     if (cpi->common.frame_type == KEY_FRAME) {
1142       Q = cpi->oxcf.key_q;
1143     } else if (cpi->oxcf.number_of_layers == 1 &&
1144                cpi->common.refresh_alt_ref_frame &&
1145                !cpi->gf_noboost_onepass_cbr) {
1146       Q = cpi->oxcf.alt_q;
1147     } else if (cpi->oxcf.number_of_layers == 1 &&
1148                cpi->common.refresh_golden_frame &&
1149                !cpi->gf_noboost_onepass_cbr) {
1150       Q = cpi->oxcf.gold_q;
1151     }
1152   } else {
1153     int i;
1154     int last_error = INT_MAX;
1155     int target_bits_per_mb;
1156     int bits_per_mb_at_this_q;
1157     double correction_factor;
1158
1159     /* Select the appropriate correction factor based upon type of frame. */
1160     if (cpi->common.frame_type == KEY_FRAME) {
1161       correction_factor = cpi->key_frame_rate_correction_factor;
1162     } else {
1163       if (cpi->oxcf.number_of_layers == 1 && !cpi->gf_noboost_onepass_cbr &&
1164           (cpi->common.refresh_alt_ref_frame ||
1165            cpi->common.refresh_golden_frame)) {
1166         correction_factor = cpi->gf_rate_correction_factor;
1167       } else {
1168         correction_factor = cpi->rate_correction_factor;
1169       }
1170     }
1171
1172     /* Calculate required scaling factor based on target frame size and
1173      * size of frame produced using previous Q
1174      */
1175     if (target_bits_per_frame >= (INT_MAX >> BPER_MB_NORMBITS)) {
1176       /* Case where we would overflow int */
1177       target_bits_per_mb = (target_bits_per_frame / cpi->common.MBs)
1178                            << BPER_MB_NORMBITS;
1179     } else {
1180       target_bits_per_mb =
1181           (target_bits_per_frame << BPER_MB_NORMBITS) / cpi->common.MBs;
1182     }
1183
1184     i = cpi->active_best_quality;
1185
1186     do {
1187       bits_per_mb_at_this_q =
1188           (int)(.5 +
1189                 correction_factor * vp8_bits_per_mb[cpi->common.frame_type][i]);
1190
1191       if (bits_per_mb_at_this_q <= target_bits_per_mb) {
1192         if ((target_bits_per_mb - bits_per_mb_at_this_q) <= last_error) {
1193           Q = i;
1194         } else {
1195           Q = i - 1;
1196         }
1197
1198         break;
1199       } else {
1200         last_error = bits_per_mb_at_this_q - target_bits_per_mb;
1201       }
1202     } while (++i <= cpi->active_worst_quality);
1203
1204     /* If we are at MAXQ then enable Q over-run which seeks to claw
1205      * back additional bits through things like the RD multiplier
1206      * and zero bin size.
1207      */
1208     if (Q >= MAXQ) {
1209       int zbin_oqmax;
1210
1211       double Factor = 0.99;
1212       double factor_adjustment = 0.01 / 256.0;
1213
1214       if (cpi->common.frame_type == KEY_FRAME) {
1215         zbin_oqmax = 0;
1216       } else if (cpi->oxcf.number_of_layers == 1 &&
1217                  !cpi->gf_noboost_onepass_cbr &&
1218                  (cpi->common.refresh_alt_ref_frame ||
1219                   (cpi->common.refresh_golden_frame &&
1220                    !cpi->source_alt_ref_active))) {
1221         zbin_oqmax = 16;
1222       } else {
1223         zbin_oqmax = ZBIN_OQ_MAX;
1224       }
1225
1226       /*{
1227           double Factor =
1228       (double)target_bits_per_mb/(double)bits_per_mb_at_this_q;
1229           double Oq;
1230
1231           Factor = Factor/1.2683;
1232
1233           Oq = pow( Factor, (1.0/-0.165) );
1234
1235           if ( Oq > zbin_oqmax )
1236               Oq = zbin_oqmax;
1237
1238           cpi->zbin_over_quant = (int)Oq;
1239       }*/
1240
1241       /* Each incrment in the zbin is assumed to have a fixed effect
1242        * on bitrate. This is not of course true. The effect will be
1243        * highly clip dependent and may well have sudden steps. The
1244        * idea here is to acheive higher effective quantizers than the
1245        * normal maximum by expanding the zero bin and hence
1246        * decreasing the number of low magnitude non zero coefficients.
1247        */
1248       while (cpi->mb.zbin_over_quant < zbin_oqmax) {
1249         cpi->mb.zbin_over_quant++;
1250
1251         if (cpi->mb.zbin_over_quant > zbin_oqmax) {
1252           cpi->mb.zbin_over_quant = zbin_oqmax;
1253         }
1254
1255         /* Adjust bits_per_mb_at_this_q estimate */
1256         bits_per_mb_at_this_q = (int)(Factor * bits_per_mb_at_this_q);
1257         Factor += factor_adjustment;
1258
1259         if (Factor >= 0.999) Factor = 0.999;
1260
1261         /* Break out if we get down to the target rate */
1262         if (bits_per_mb_at_this_q <= target_bits_per_mb) break;
1263       }
1264     }
1265   }
1266
1267   return Q;
1268 }
1269
1270 static int estimate_keyframe_frequency(VP8_COMP *cpi) {
1271   int i;
1272
1273   /* Average key frame frequency */
1274   int av_key_frame_frequency = 0;
1275
1276   /* First key frame at start of sequence is a special case. We have no
1277    * frequency data.
1278    */
1279   if (cpi->key_frame_count == 1) {
1280     /* Assume a default of 1 kf every 2 seconds, or the max kf interval,
1281      * whichever is smaller.
1282      */
1283     int key_freq = cpi->oxcf.key_freq > 0 ? cpi->oxcf.key_freq : 1;
1284     av_key_frame_frequency = 1 + (int)cpi->output_framerate * 2;
1285
1286     if (cpi->oxcf.auto_key && av_key_frame_frequency > key_freq) {
1287       av_key_frame_frequency = key_freq;
1288     }
1289
1290     cpi->prior_key_frame_distance[KEY_FRAME_CONTEXT - 1] =
1291         av_key_frame_frequency;
1292   } else {
1293     unsigned int total_weight = 0;
1294     int last_kf_interval =
1295         (cpi->frames_since_key > 0) ? cpi->frames_since_key : 1;
1296
1297     /* reset keyframe context and calculate weighted average of last
1298      * KEY_FRAME_CONTEXT keyframes
1299      */
1300     for (i = 0; i < KEY_FRAME_CONTEXT; ++i) {
1301       if (i < KEY_FRAME_CONTEXT - 1) {
1302         cpi->prior_key_frame_distance[i] = cpi->prior_key_frame_distance[i + 1];
1303       } else {
1304         cpi->prior_key_frame_distance[i] = last_kf_interval;
1305       }
1306
1307       av_key_frame_frequency +=
1308           prior_key_frame_weight[i] * cpi->prior_key_frame_distance[i];
1309       total_weight += prior_key_frame_weight[i];
1310     }
1311
1312     av_key_frame_frequency /= total_weight;
1313   }
1314   // TODO (marpan): Given the checks above, |av_key_frame_frequency|
1315   // should always be above 0. But for now we keep the sanity check in.
1316   if (av_key_frame_frequency == 0) av_key_frame_frequency = 1;
1317   return av_key_frame_frequency;
1318 }
1319
1320 void vp8_adjust_key_frame_context(VP8_COMP *cpi) {
1321   /* Clear down mmx registers to allow floating point in what follows */
1322   vpx_clear_system_state();
1323
1324   /* Do we have any key frame overspend to recover? */
1325   /* Two-pass overspend handled elsewhere. */
1326   if ((cpi->pass != 2) &&
1327       (cpi->projected_frame_size > cpi->per_frame_bandwidth)) {
1328     int overspend;
1329
1330     /* Update the count of key frame overspend to be recovered in
1331      * subsequent frames. A portion of the KF overspend is treated as gf
1332      * overspend (and hence recovered more quickly) as the kf is also a
1333      * gf. Otherwise the few frames following each kf tend to get more
1334      * bits allocated than those following other gfs.
1335      */
1336     overspend = (cpi->projected_frame_size - cpi->per_frame_bandwidth);
1337
1338     if (cpi->oxcf.number_of_layers > 1) {
1339       cpi->kf_overspend_bits += overspend;
1340     } else {
1341       cpi->kf_overspend_bits += overspend * 7 / 8;
1342       cpi->gf_overspend_bits += overspend * 1 / 8;
1343     }
1344
1345     /* Work out how much to try and recover per frame. */
1346     cpi->kf_bitrate_adjustment =
1347         cpi->kf_overspend_bits / estimate_keyframe_frequency(cpi);
1348   }
1349
1350   cpi->frames_since_key = 0;
1351   cpi->key_frame_count++;
1352 }
1353
1354 void vp8_compute_frame_size_bounds(VP8_COMP *cpi, int *frame_under_shoot_limit,
1355                                    int *frame_over_shoot_limit) {
1356   /* Set-up bounds on acceptable frame size: */
1357   if (cpi->oxcf.fixed_q >= 0) {
1358     /* Fixed Q scenario: frame size never outranges target
1359      * (there is no target!)
1360      */
1361     *frame_under_shoot_limit = 0;
1362     *frame_over_shoot_limit = INT_MAX;
1363   } else {
1364     if (cpi->common.frame_type == KEY_FRAME) {
1365       *frame_over_shoot_limit = cpi->this_frame_target * 9 / 8;
1366       *frame_under_shoot_limit = cpi->this_frame_target * 7 / 8;
1367     } else {
1368       if (cpi->oxcf.number_of_layers > 1 || cpi->common.refresh_alt_ref_frame ||
1369           cpi->common.refresh_golden_frame) {
1370         *frame_over_shoot_limit = cpi->this_frame_target * 9 / 8;
1371         *frame_under_shoot_limit = cpi->this_frame_target * 7 / 8;
1372       } else {
1373         /* For CBR take buffer fullness into account */
1374         if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) {
1375           if (cpi->buffer_level >= ((cpi->oxcf.optimal_buffer_level +
1376                                      cpi->oxcf.maximum_buffer_size) >>
1377                                     1)) {
1378             /* Buffer is too full so relax overshoot and tighten
1379              * undershoot
1380              */
1381             *frame_over_shoot_limit = cpi->this_frame_target * 12 / 8;
1382             *frame_under_shoot_limit = cpi->this_frame_target * 6 / 8;
1383           } else if (cpi->buffer_level <=
1384                      (cpi->oxcf.optimal_buffer_level >> 1)) {
1385             /* Buffer is too low so relax undershoot and tighten
1386              * overshoot
1387              */
1388             *frame_over_shoot_limit = cpi->this_frame_target * 10 / 8;
1389             *frame_under_shoot_limit = cpi->this_frame_target * 4 / 8;
1390           } else {
1391             *frame_over_shoot_limit = cpi->this_frame_target * 11 / 8;
1392             *frame_under_shoot_limit = cpi->this_frame_target * 5 / 8;
1393           }
1394         }
1395         /* VBR and CQ mode */
1396         /* Note that tighter restrictions here can help quality
1397          * but hurt encode speed
1398          */
1399         else {
1400           /* Stron overshoot limit for constrained quality */
1401           if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) {
1402             *frame_over_shoot_limit = cpi->this_frame_target * 11 / 8;
1403             *frame_under_shoot_limit = cpi->this_frame_target * 2 / 8;
1404           } else {
1405             *frame_over_shoot_limit = cpi->this_frame_target * 11 / 8;
1406             *frame_under_shoot_limit = cpi->this_frame_target * 5 / 8;
1407           }
1408         }
1409       }
1410     }
1411
1412     /* For very small rate targets where the fractional adjustment
1413      * (eg * 7/8) may be tiny make sure there is at least a minimum
1414      * range.
1415      */
1416     *frame_over_shoot_limit += 200;
1417     *frame_under_shoot_limit -= 200;
1418     if (*frame_under_shoot_limit < 0) *frame_under_shoot_limit = 0;
1419   }
1420 }
1421
1422 /* return of 0 means drop frame */
1423 int vp8_pick_frame_size(VP8_COMP *cpi) {
1424   VP8_COMMON *cm = &cpi->common;
1425
1426   if (cm->frame_type == KEY_FRAME) {
1427     calc_iframe_target_size(cpi);
1428   } else {
1429     calc_pframe_target_size(cpi);
1430
1431     /* Check if we're dropping the frame: */
1432     if (cpi->drop_frame) {
1433       cpi->drop_frame = 0;
1434       return 0;
1435     }
1436   }
1437   return 1;
1438 }
1439 // If this just encoded frame (mcomp/transform/quant, but before loopfilter and
1440 // pack_bitstream) has large overshoot, and was not being encoded close to the
1441 // max QP, then drop this frame and force next frame to be encoded at max QP.
1442 // Allow this for screen_content_mode = 2, or if drop frames is allowed.
1443 // TODO(marpan): Should do this exit condition during the encode_frame
1444 // (i.e., halfway during the encoding of the frame) to save cycles.
1445 int vp8_drop_encodedframe_overshoot(VP8_COMP *cpi, int Q) {
1446   int force_drop_overshoot = 0;
1447 #if CONFIG_MULTI_RES_ENCODING
1448   // Only check for dropping due to overshoot on the lowest stream.
1449   // If the lowest stream of the multi-res encoding was dropped due to
1450   // overshoot, then force dropping on all upper layer streams
1451   // (mr_encoder_id > 0).
1452   LOWER_RES_FRAME_INFO *low_res_frame_info =
1453       (LOWER_RES_FRAME_INFO *)cpi->oxcf.mr_low_res_mode_info;
1454   if (cpi->oxcf.mr_total_resolutions > 1 && cpi->oxcf.mr_encoder_id > 0) {
1455     force_drop_overshoot = low_res_frame_info->is_frame_dropped_overshoot_maxqp;
1456     if (!force_drop_overshoot) {
1457       cpi->force_maxqp = 0;
1458       cpi->frames_since_last_drop_overshoot++;
1459       return 0;
1460     }
1461   }
1462 #endif
1463   if (cpi->common.frame_type != KEY_FRAME &&
1464       (cpi->oxcf.screen_content_mode == 2 ||
1465        (cpi->drop_frames_allowed &&
1466         (force_drop_overshoot ||
1467          (cpi->rate_correction_factor < (8.0f * MIN_BPB_FACTOR) &&
1468           cpi->frames_since_last_drop_overshoot > (int)cpi->framerate))))) {
1469     // Note: the "projected_frame_size" from encode_frame() only gives estimate
1470     // of mode/motion vector rate (in non-rd mode): so below we only require
1471     // that projected_frame_size is somewhat greater than per-frame-bandwidth,
1472     // but add additional condition with high threshold on prediction residual.
1473
1474     // QP threshold: only allow dropping if we are not close to qp_max.
1475     int thresh_qp = 3 * cpi->worst_quality >> 2;
1476     // Rate threshold, in bytes.
1477     int thresh_rate = 2 * (cpi->av_per_frame_bandwidth >> 3);
1478     // Threshold for the average (over all macroblocks) of the pixel-sum
1479     // residual error over 16x16 block.
1480     int thresh_pred_err_mb = (200 << 4);
1481     int pred_err_mb = (int)(cpi->mb.prediction_error / cpi->common.MBs);
1482     // Reduce/ignore thresh_rate if pred_err_mb much larger than its threshold,
1483     // give more weight to pred_err metric for overshoot detection.
1484     if (cpi->drop_frames_allowed && pred_err_mb > (thresh_pred_err_mb << 4))
1485       thresh_rate = thresh_rate >> 3;
1486     if ((Q < thresh_qp && cpi->projected_frame_size > thresh_rate &&
1487          pred_err_mb > thresh_pred_err_mb) ||
1488         force_drop_overshoot) {
1489       unsigned int i;
1490       double new_correction_factor;
1491       int target_bits_per_mb;
1492       const int target_size = cpi->av_per_frame_bandwidth;
1493       // Flag to indicate we will force next frame to be encoded at max QP.
1494       cpi->force_maxqp = 1;
1495       // Reset the buffer levels.
1496       cpi->buffer_level = cpi->oxcf.optimal_buffer_level;
1497       cpi->bits_off_target = cpi->oxcf.optimal_buffer_level;
1498       // Compute a new rate correction factor, corresponding to the current
1499       // target frame size and max_QP, and adjust the rate correction factor
1500       // upwards, if needed.
1501       // This is to prevent a bad state where the re-encoded frame at max_QP
1502       // undershoots significantly, and then we end up dropping every other
1503       // frame because the QP/rate_correction_factor may have been too low
1504       // before the drop and then takes too long to come up.
1505       if (target_size >= (INT_MAX >> BPER_MB_NORMBITS)) {
1506         target_bits_per_mb = (target_size / cpi->common.MBs)
1507                              << BPER_MB_NORMBITS;
1508       } else {
1509         target_bits_per_mb =
1510             (target_size << BPER_MB_NORMBITS) / cpi->common.MBs;
1511       }
1512       // Rate correction factor based on target_size_per_mb and max_QP.
1513       new_correction_factor =
1514           (double)target_bits_per_mb /
1515           (double)vp8_bits_per_mb[INTER_FRAME][cpi->worst_quality];
1516       if (new_correction_factor > cpi->rate_correction_factor) {
1517         cpi->rate_correction_factor =
1518             VPXMIN(2.0 * cpi->rate_correction_factor, new_correction_factor);
1519       }
1520       if (cpi->rate_correction_factor > MAX_BPB_FACTOR) {
1521         cpi->rate_correction_factor = MAX_BPB_FACTOR;
1522       }
1523       // Drop this frame: update frame counters.
1524       cpi->common.current_video_frame++;
1525       cpi->frames_since_key++;
1526       cpi->temporal_pattern_counter++;
1527       cpi->frames_since_last_drop_overshoot = 0;
1528       if (cpi->oxcf.number_of_layers > 1) {
1529         // Set max_qp and rate correction for all temporal layers if overshoot
1530         // is detected.
1531         for (i = 0; i < cpi->oxcf.number_of_layers; ++i) {
1532           LAYER_CONTEXT *lc = &cpi->layer_context[i];
1533           lc->force_maxqp = 1;
1534           lc->frames_since_last_drop_overshoot = 0;
1535           lc->rate_correction_factor = cpi->rate_correction_factor;
1536         }
1537       }
1538 #if CONFIG_MULTI_RES_ENCODING
1539       if (cpi->oxcf.mr_total_resolutions > 1)
1540         low_res_frame_info->is_frame_dropped_overshoot_maxqp = 1;
1541 #endif
1542       return 1;
1543     }
1544     cpi->force_maxqp = 0;
1545     cpi->frames_since_last_drop_overshoot++;
1546 #if CONFIG_MULTI_RES_ENCODING
1547     if (cpi->oxcf.mr_total_resolutions > 1)
1548       low_res_frame_info->is_frame_dropped_overshoot_maxqp = 0;
1549 #endif
1550     return 0;
1551   }
1552   cpi->force_maxqp = 0;
1553   cpi->frames_since_last_drop_overshoot++;
1554 #if CONFIG_MULTI_RES_ENCODING
1555   if (cpi->oxcf.mr_total_resolutions > 1)
1556     low_res_frame_info->is_frame_dropped_overshoot_maxqp = 0;
1557 #endif
1558   return 0;
1559 }