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