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 "common.h"
  20 #include "ratectrl.h"
  21 #include "entropymode.h"
  22 #include "vpx_mem/vpx_mem.h"
  23 #include "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 const int vp8_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 const int vp8_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 const int vp8_kf_boost_seperationt_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 const int vp8_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 const int vp8_gf_intra_useage_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 const int vp8_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, cpi->mb.mvsadcost, (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 * vp8_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 * vp8_gf_intra_useage_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 * vp8_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 > vp8_kf_gf_boost_qlimits[Q] && (cpi->pass == 0))
 507             Boost = vp8_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 (vp8_gf_interval_table[gf_frame_useage] > cpi->frames_till_gf_update_due)
 543                 cpi->frames_till_gf_update_due = vp8_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 = vp8_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 * vp8_kf_boost_seperationt_adjustment[cpi->frames_since_key] / 100;
 602         else
 603             Boost = Boost * vp8_kf_boost_seperationt_adjustment[15] / 100;
 604
 605         // Apply limits on boost
 606         if (Boost > vp8_kf_gf_boost_qlimits[Q])
 607             Boost = vp8_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     // Set the min frame bandwidth.
 666     //min_frame_target = estimate_min_frame_size( cpi );
 667     min_frame_target = 0;
 668
 669     if (cpi->pass == 2)
 670     {
 671         min_frame_target = cpi->min_frame_bandwidth;
 672
 673         if (min_frame_target < (cpi->av_per_frame_bandwidth >> 5))
 674             min_frame_target = cpi->av_per_frame_bandwidth >> 5;
 675     }
 676     else if (min_frame_target < cpi->per_frame_bandwidth / 4)
 677         min_frame_target = cpi->per_frame_bandwidth / 4;
 678
 679
 680     // Special alt reference frame case
 681     if (cpi->common.refresh_alt_ref_frame)
 682     {
 683         if (cpi->pass == 2)
 684         {
 685             cpi->per_frame_bandwidth = cpi->gf_bits;                       // Per frame bit target for the alt ref frame
 686             cpi->this_frame_target = cpi->per_frame_bandwidth;
 687         }
 688
 689         /* One Pass ??? TBD */
 690         /*else
 691         {
 692             int frames_in_section;
 693             int allocation_chunks;
 694             int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;
 695             int alt_boost;
 696             int max_arf_rate;
 697
 698             alt_boost = (cpi->gfu_boost * 3 * GFQ_ADJUSTMENT) / (2 * 100);
 699             alt_boost += (cpi->frames_till_gf_update_due * 50);
 700
 701             // If alt ref is not currently active then we have a pottential double hit with GF and ARF so reduce the boost a bit.
 702             // A similar thing is done on GFs that preceed a arf update.
 703             if ( !cpi->source_alt_ref_active )
 704                 alt_boost = alt_boost * 3 / 4;
 705
 706             frames_in_section = cpi->frames_till_gf_update_due+1;                                   // Standard frames + GF
 707             allocation_chunks = (frames_in_section * 100) + alt_boost;
 708
 709             // Normalize Altboost and allocations chunck down to prevent overflow
 710             while ( alt_boost > 1000 )
 711             {
 712                 alt_boost /= 2;
 713                 allocation_chunks /= 2;
 714             }
 715
 716             else
 717             {
 718                 int bits_in_section;
 719
 720                 if ( cpi->kf_overspend_bits > 0 )
 721                 {
 722                     Adjustment = (cpi->kf_bitrate_adjustment <= cpi->kf_overspend_bits) ? cpi->kf_bitrate_adjustment : cpi->kf_overspend_bits;
 723
 724                     if ( Adjustment > (cpi->per_frame_bandwidth - min_frame_target) )
 725                         Adjustment = (cpi->per_frame_bandwidth - min_frame_target);
 726
 727                     cpi->kf_overspend_bits -= Adjustment;
 728
 729                     // Calculate an inter frame bandwidth target for the next few frames designed to recover
 730                     // any extra bits spent on the key frame.
 731                     cpi->inter_frame_target = cpi->per_frame_bandwidth - Adjustment;
 732                     if ( cpi->inter_frame_target < min_frame_target )
 733                         cpi->inter_frame_target = min_frame_target;
 734                 }
 735                 else
 736                     cpi->inter_frame_target = cpi->per_frame_bandwidth;
 737
 738                 bits_in_section = cpi->inter_frame_target * frames_in_section;
 739
 740                 // Avoid loss of precision but avoid overflow
 741                 if ( (bits_in_section>>7) > allocation_chunks )
 742                     cpi->this_frame_target = alt_boost * (bits_in_section / allocation_chunks);
 743                 else
 744                     cpi->this_frame_target = (alt_boost * bits_in_section) / allocation_chunks;
 745             }
 746         }
 747         */
 748     }
 749
 750     // Normal frames (gf,and inter)
 751     else
 752     {
 753         // 2 pass
 754         if (cpi->pass == 2)
 755         {
 756             cpi->this_frame_target = cpi->per_frame_bandwidth;
 757         }
 758         // 1 pass
 759         else
 760         {
 761             // Make rate adjustment to recover bits spent in key frame
 762             // Test to see if the key frame inter data rate correction should still be in force
 763             if (cpi->kf_overspend_bits > 0)
 764             {
 765                 Adjustment = (cpi->kf_bitrate_adjustment <= cpi->kf_overspend_bits) ? cpi->kf_bitrate_adjustment : cpi->kf_overspend_bits;
 766
 767                 if (Adjustment > (cpi->per_frame_bandwidth - min_frame_target))
 768                     Adjustment = (cpi->per_frame_bandwidth - min_frame_target);
 769
 770                 cpi->kf_overspend_bits -= Adjustment;
 771
 772                 // Calculate an inter frame bandwidth target for the next few frames designed to recover
 773                 // any extra bits spent on the key frame.
 774                 cpi->this_frame_target = cpi->per_frame_bandwidth - Adjustment;
 775
 776                 if (cpi->this_frame_target < min_frame_target)
 777                     cpi->this_frame_target = min_frame_target;
 778             }
 779             else
 780                 cpi->this_frame_target = cpi->per_frame_bandwidth;
 781
 782             // If appropriate make an adjustment to recover bits spent on a recent GF
 783             if ((cpi->gf_overspend_bits > 0) && (cpi->this_frame_target > min_frame_target))
 784             {
 785                 int Adjustment = (cpi->non_gf_bitrate_adjustment <= cpi->gf_overspend_bits) ? cpi->non_gf_bitrate_adjustment : cpi->gf_overspend_bits;
 786
 787                 if (Adjustment > (cpi->this_frame_target - min_frame_target))
 788                     Adjustment = (cpi->this_frame_target - min_frame_target);
 789
 790                 cpi->gf_overspend_bits -= Adjustment;
 791                 cpi->this_frame_target -= Adjustment;
 792             }
 793
 794             // Apply small + and - boosts for non gf frames
 795             if ((cpi->last_boost > 150) && (cpi->frames_till_gf_update_due > 0) &&
 796                 (cpi->current_gf_interval >= (MIN_GF_INTERVAL << 1)))
 797             {
 798                 // % Adjustment limited to the range 1% to 10%
 799                 Adjustment = (cpi->last_boost - 100) >> 5;
 800
 801                 if (Adjustment < 1)
 802                     Adjustment = 1;
 803                 else if (Adjustment > 10)
 804                     Adjustment = 10;
 805
 806                 // Convert to bits
 807                 Adjustment = (cpi->this_frame_target * Adjustment) / 100;
 808
 809                 if (Adjustment > (cpi->this_frame_target - min_frame_target))
 810                     Adjustment = (cpi->this_frame_target - min_frame_target);
 811
 812                 if (cpi->common.frames_since_golden == (cpi->current_gf_interval >> 1))
 813                     cpi->this_frame_target += ((cpi->current_gf_interval - 1) * Adjustment);
 814                 else
 815                     cpi->this_frame_target -= Adjustment;
 816             }
 817         }
 818     }
 819
 820     // Set a reduced data rate target for our initial Q calculation.
 821     // This should help to save bits during earier sections.
 822     if ((cpi->oxcf.under_shoot_pct > 0) && (cpi->oxcf.under_shoot_pct <= 100))
 823         cpi->this_frame_target = (cpi->this_frame_target * cpi->oxcf.under_shoot_pct) / 100;
 824
 825     // Sanity check that the total sum of adjustments is not above the maximum allowed
 826     // That is that having allowed for KF and GF penalties we have not pushed the
 827     // current interframe target to low. If the adjustment we apply here is not capable of recovering
 828     // all the extra bits we have spent in the KF or GF then the remainder will have to be recovered over
 829     // a longer time span via other buffer / rate control mechanisms.
 830     if (cpi->this_frame_target < min_frame_target)
 831         cpi->this_frame_target = min_frame_target;
 832
 833     if (!cpi->common.refresh_alt_ref_frame)
 834         // Note the baseline target data rate for this inter frame.
 835         cpi->inter_frame_target = cpi->this_frame_target;
 836
 837     // One Pass specific code
 838     if (cpi->pass == 0)
 839     {
 840         // Adapt target frame size with respect to any buffering constraints:
 841         if (cpi->buffered_mode)
 842         {
 843             int one_percent_bits = 1 + cpi->oxcf.optimal_buffer_level / 100;
 844
 845             if ((cpi->buffer_level < cpi->oxcf.optimal_buffer_level) || (cpi->bits_off_target < cpi->oxcf.optimal_buffer_level))
 846             {
 847                 int percent_low = 0;
 848
 849                 // Decide whether or not we need to adjust the frame data rate target.
 850                 //
 851                 // If we are are below the optimal buffer fullness level and adherence
 852                 // to buffering contraints is important to the end useage then adjust
 853                 // the per frame target.
 854                 if ((cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) && (cpi->buffer_level < cpi->oxcf.optimal_buffer_level))
 855                 {
 856                     percent_low = (cpi->oxcf.optimal_buffer_level - cpi->buffer_level) / one_percent_bits;
 857
 858                     if (percent_low > 100)
 859                         percent_low = 100;
 860                     else if (percent_low < 0)
 861                         percent_low = 0;
 862                 }
 863                 // Are we overshooting the long term clip data rate...
 864                 else if (cpi->bits_off_target < 0)
 865                 {
 866                     // Adjust per frame data target downwards to compensate.
 867                     percent_low = (int)(100 * -cpi->bits_off_target / (cpi->total_byte_count * 8));
 868
 869                     if (percent_low > 100)
 870                         percent_low = 100;
 871                     else if (percent_low < 0)
 872                         percent_low = 0;
 873                 }
 874
 875                 // lower the target bandwidth for this frame.
 876                 cpi->this_frame_target = (cpi->this_frame_target * (100 - (percent_low / 2))) / 100;
 877
 878                 // Are we using allowing control of active_worst_allowed_q according to buffer level.
 879                 if (cpi->auto_worst_q)
 880                 {
 881                     int critical_buffer_level;
 882
 883                     // For streaming applications the most important factor is cpi->buffer_level as this takes
 884                     // into account the specified short term buffering constraints. However, hitting the long
 885                     // term clip data rate target is also important.
 886                     if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
 887                     {
 888                         // Take the smaller of cpi->buffer_level and cpi->bits_off_target
 889                         critical_buffer_level = (cpi->buffer_level < cpi->bits_off_target) ? cpi->buffer_level : cpi->bits_off_target;
 890                     }
 891                     // For local file playback short term buffering contraints are less of an issue
 892                     else
 893                     {
 894                         // Consider only how we are doing for the clip as a whole
 895                         critical_buffer_level = cpi->bits_off_target;
 896                     }
 897
 898                     // Set the active worst quality based upon the selected buffer fullness number.
 899                     if (critical_buffer_level < cpi->oxcf.optimal_buffer_level)
 900                     {
 901                         if (critical_buffer_level > (cpi->oxcf.optimal_buffer_level / 4))
 902                         {
 903                             int qadjustment_range = cpi->worst_quality - cpi->ni_av_qi;
 904                             int above_base = (critical_buffer_level - (cpi->oxcf.optimal_buffer_level / 4));
 905
 906                             // Step active worst quality down from cpi->ni_av_qi when (critical_buffer_level == cpi->optimal_buffer_level)
 907                             // to cpi->oxcf.worst_allowed_q when (critical_buffer_level == cpi->optimal_buffer_level/4)
 908                             cpi->active_worst_quality = cpi->worst_quality - ((qadjustment_range * above_base) / (cpi->oxcf.optimal_buffer_level * 3 / 4));
 909                         }
 910                         else
 911                         {
 912                             cpi->active_worst_quality = cpi->worst_quality;
 913                         }
 914                     }
 915                     else
 916                     {
 917                         cpi->active_worst_quality = cpi->ni_av_qi;
 918                     }
 919                 }
 920                 else
 921                 {
 922                     cpi->active_worst_quality = cpi->worst_quality;
 923                 }
 924             }
 925             else
 926             {
 927                 int percent_high;
 928
 929                 if (cpi->bits_off_target > cpi->oxcf.optimal_buffer_level)
 930                 {
 931                     percent_high = (int)(100 * (cpi->bits_off_target - cpi->oxcf.optimal_buffer_level) / (cpi->total_byte_count * 8));
 932
 933                     if (percent_high > 100)
 934                         percent_high = 100;
 935                     else if (percent_high < 0)
 936                         percent_high = 0;
 937
 938                     cpi->this_frame_target = (cpi->this_frame_target * (100 + (percent_high / 2))) / 100;
 939
 940                 }
 941
 942                 // Are we allowing control of active_worst_allowed_q according to bufferl level.
 943                 if (cpi->auto_worst_q)
 944                 {
 945                     // When using the relaxed buffer model stick to the user specified value
 946                     cpi->active_worst_quality = cpi->ni_av_qi;
 947                 }
 948                 else
 949                 {
 950                     cpi->active_worst_quality = cpi->worst_quality;
 951                 }
 952             }
 953
 954             // Set active_best_quality to prevent quality rising too high
 955             cpi->active_best_quality = cpi->best_quality;
 956
 957             // Worst quality obviously must not be better than best quality
 958             if (cpi->active_worst_quality <= cpi->active_best_quality)
 959                 cpi->active_worst_quality = cpi->active_best_quality + 1;
 960
 961         }
 962         // Unbuffered mode (eg. video conferencing)
 963         else
 964         {
 965             // Set the active worst quality
 966             cpi->active_worst_quality = cpi->worst_quality;
 967         }
 968     }
 969
 970     // Test to see if we have to drop a frame
 971     // The auto-drop frame code is only used in buffered mode.
 972     // In unbufferd mode (eg vide conferencing) the descision to
 973     // code or drop a frame is made outside the codec in response to real
 974     // world comms or buffer considerations.
 975     if (cpi->drop_frames_allowed && cpi->buffered_mode &&
 976         (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
 977         ((cpi->common.frame_type != KEY_FRAME))) //|| !cpi->oxcf.allow_spatial_resampling) )
 978     {
 979         // Check for a buffer underun-crisis in which case we have to drop a frame
 980         if ((cpi->buffer_level < 0))
 981         {
 982 #if 0
 983             FILE *f = fopen("dec.stt", "a");
 984             fprintf(f, "%10d %10d %10d %10d ***** BUFFER EMPTY\n",
 985                     (int) cpi->common.current_video_frame,
 986                     cpi->decimation_factor, cpi->common.horiz_scale,
 987                     (cpi->buffer_level * 100) / cpi->oxcf.optimal_buffer_level);
 988             fclose(f);
 989 #endif
 990             //vpx_log("Decoder: Drop frame due to bandwidth: %d \n",cpi->buffer_level, cpi->av_per_frame_bandwidth);
 991
 992             cpi->drop_frame = TRUE;
 993         }
 994
 995 #if 0
 996         // Check for other drop frame crtieria (Note 2 pass cbr uses decimation on whole KF sections)
 997         else if ((cpi->buffer_level < cpi->oxcf.drop_frames_water_mark * cpi->oxcf.optimal_buffer_level / 100) &&
 998                  (cpi->drop_count < cpi->max_drop_count) && (cpi->pass == 0))
 999         {
1000             cpi->drop_frame = TRUE;
1001         }
1002
1003 #endif
1004
1005         if (cpi->drop_frame)
1006         {
1007             // Update the buffer level variable.
1008             cpi->bits_off_target += cpi->av_per_frame_bandwidth;
1009             cpi->buffer_level = cpi->bits_off_target;
1010         }
1011         else
1012             cpi->drop_count = 0;
1013     }
1014
1015     // Adjust target frame size for Golden Frames:
1016     if (cpi->oxcf.error_resilient_mode == 0 &&
1017         (cpi->frames_till_gf_update_due == 0) && !cpi->drop_frame)
1018     {
1019         //int Boost = 0;
1020         int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;
1021
1022         int gf_frame_useage = 0;      // Golden frame useage since last GF
1023         int tot_mbs = cpi->recent_ref_frame_usage[INTRA_FRAME]  +
1024                       cpi->recent_ref_frame_usage[LAST_FRAME]   +
1025                       cpi->recent_ref_frame_usage[GOLDEN_FRAME] +
1026                       cpi->recent_ref_frame_usage[ALTREF_FRAME];
1027
1028         int pct_gf_active = (100 * cpi->gf_active_count) / (cpi->common.mb_rows * cpi->common.mb_cols);
1029
1030         // Reset the last boost indicator
1031         //cpi->last_boost = 100;
1032
1033         if (tot_mbs)
1034             gf_frame_useage = (cpi->recent_ref_frame_usage[GOLDEN_FRAME] + cpi->recent_ref_frame_usage[ALTREF_FRAME]) * 100 / tot_mbs;
1035
1036         if (pct_gf_active > gf_frame_useage)
1037             gf_frame_useage = pct_gf_active;
1038
1039         // Is a fixed manual GF frequency being used
1040         if (cpi->auto_gold)
1041         {
1042             // For one pass throw a GF if recent frame intra useage is low or the GF useage is high
1043             if ((cpi->pass == 0) && (cpi->this_frame_percent_intra < 15 || gf_frame_useage >= 5))
1044                 cpi->common.refresh_golden_frame = TRUE;
1045
1046             // Two pass GF descision
1047             else if (cpi->pass == 2)
1048                 cpi->common.refresh_golden_frame = TRUE;
1049         }
1050
1051 #if 0
1052
1053         // Debug stats
1054         if (0)
1055         {
1056             FILE *f;
1057
1058             f = fopen("gf_useaget.stt", "a");
1059             fprintf(f, " %8ld %10ld %10ld %10ld %10ld\n",
1060                     cpi->common.current_video_frame,  cpi->gfu_boost, GFQ_ADJUSTMENT, cpi->gfu_boost, gf_frame_useage);
1061             fclose(f);
1062         }
1063
1064 #endif
1065
1066         if (cpi->common.refresh_golden_frame == TRUE)
1067         {
1068 #if 0
1069
1070             if (0)   // p_gw
1071             {
1072                 FILE *f;
1073
1074                 f = fopen("GFexit.stt", "a");
1075                 fprintf(f, "%8ld GF coded\n", cpi->common.current_video_frame);
1076                 fclose(f);
1077             }
1078
1079 #endif
1080             cpi->initial_gf_use = 0;
1081
1082             if (cpi->auto_adjust_gold_quantizer)
1083             {
1084                 calc_gf_params(cpi);
1085             }
1086
1087             // If we are using alternate ref instead of gf then do not apply the boost
1088             // It will instead be applied to the altref update
1089             // Jims modified boost
1090             if (!cpi->source_alt_ref_active)
1091             {
1092                 if (cpi->oxcf.fixed_q < 0)
1093                 {
1094                     if (cpi->pass == 2)
1095                     {
1096                         cpi->this_frame_target = cpi->per_frame_bandwidth;          // The spend on the GF is defined in the two pass code for two pass encodes
1097                     }
1098                     else
1099                     {
1100                         int Boost = cpi->last_boost;
1101                         int frames_in_section = cpi->frames_till_gf_update_due + 1;
1102                         int allocation_chunks = (frames_in_section * 100) + (Boost - 100);
1103                         int bits_in_section = cpi->inter_frame_target * frames_in_section;
1104
1105                         // Normalize Altboost and allocations chunck down to prevent overflow
1106                         while (Boost > 1000)
1107                         {
1108                             Boost /= 2;
1109                             allocation_chunks /= 2;
1110                         }
1111
1112                         // Avoid loss of precision but avoid overflow
1113                         if ((bits_in_section >> 7) > allocation_chunks)
1114                             cpi->this_frame_target = Boost * (bits_in_section / allocation_chunks);
1115                         else
1116                             cpi->this_frame_target = (Boost * bits_in_section) / allocation_chunks;
1117                     }
1118                 }
1119                 else
1120                     cpi->this_frame_target = (baseline_bits_at_q(1, Q, cpi->common.MBs) * cpi->last_boost) / 100;
1121
1122             }
1123             // If there is an active ARF at this location use the minimum
1124             // bits on this frame even if it is a contructed arf.
1125             // The active maximum quantizer insures that an appropriate
1126             // number of bits will be spent if needed for contstructed ARFs.
1127             else
1128             {
1129                 cpi->this_frame_target = 0;
1130             }
1131
1132             cpi->current_gf_interval = cpi->frames_till_gf_update_due;
1133
1134         }
1135     }
1136 }
1137
1138
1139 void vp8_update_rate_correction_factors(VP8_COMP *cpi, int damp_var)
1140 {
1141     int    Q = cpi->common.base_qindex;
1142     int    correction_factor = 100;
1143     double rate_correction_factor;
1144     double adjustment_limit;
1145
1146     int    projected_size_based_on_q = 0;
1147
1148     // Clear down mmx registers to allow floating point in what follows
1149     vp8_clear_system_state();  //__asm emms;
1150
1151     if (cpi->common.frame_type == KEY_FRAME)
1152     {
1153         rate_correction_factor = cpi->key_frame_rate_correction_factor;
1154     }
1155     else
1156     {
1157         if (cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame)
1158             rate_correction_factor = cpi->gf_rate_correction_factor;
1159         else
1160             rate_correction_factor = cpi->rate_correction_factor;
1161     }
1162
1163     // Work out how big we would have expected the frame to be at this Q given the current correction factor.
1164     // Stay in double to avoid int overflow when values are large
1165     //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;
1166     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));
1167
1168     // Make some allowance for cpi->zbin_over_quant
1169     if (cpi->zbin_over_quant > 0)
1170     {
1171         int Z = cpi->zbin_over_quant;
1172         double Factor = 0.99;
1173         double factor_adjustment = 0.01 / 256.0; //(double)ZBIN_OQ_MAX;
1174
1175         while (Z > 0)
1176         {
1177             Z --;
1178             projected_size_based_on_q =
1179                 (int)(Factor * projected_size_based_on_q);
1180             Factor += factor_adjustment;
1181
1182             if (Factor  >= 0.999)
1183                 Factor = 0.999;
1184         }
1185     }
1186
1187     // Work out a size correction factor.
1188     //if ( cpi->this_frame_target > 0 )
1189     //  correction_factor = (100 * cpi->projected_frame_size) / cpi->this_frame_target;
1190     if (projected_size_based_on_q > 0)
1191         correction_factor = (100 * cpi->projected_frame_size) / projected_size_based_on_q;
1192
1193     // More heavily damped adjustment used if we have been oscillating either side of target
1194     switch (damp_var)
1195     {
1196     case 0:
1197         adjustment_limit = 0.75;
1198         break;
1199     case 1:
1200         adjustment_limit = 0.375;
1201         break;
1202     case 2:
1203     default:
1204         adjustment_limit = 0.25;
1205         break;
1206     }
1207
1208     //if ( (correction_factor > 102) && (Q < cpi->active_worst_quality) )
1209     if (correction_factor > 102)
1210     {
1211         // We are not already at the worst allowable quality
1212         correction_factor = (int)(100.5 + ((correction_factor - 100) * adjustment_limit));
1213         rate_correction_factor = ((rate_correction_factor * correction_factor) / 100);
1214
1215         // Keep rate_correction_factor within limits
1216         if (rate_correction_factor > MAX_BPB_FACTOR)
1217             rate_correction_factor = MAX_BPB_FACTOR;
1218     }
1219     //else if ( (correction_factor < 99) && (Q > cpi->active_best_quality) )
1220     else if (correction_factor < 99)
1221     {
1222         // We are not already at the best allowable quality
1223         correction_factor = (int)(100.5 - ((100 - correction_factor) * adjustment_limit));
1224         rate_correction_factor = ((rate_correction_factor * correction_factor) / 100);
1225
1226         // Keep rate_correction_factor within limits
1227         if (rate_correction_factor < MIN_BPB_FACTOR)
1228             rate_correction_factor = MIN_BPB_FACTOR;
1229     }
1230
1231     if (cpi->common.frame_type == KEY_FRAME)
1232         cpi->key_frame_rate_correction_factor = rate_correction_factor;
1233     else
1234     {
1235         if (cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame)
1236             cpi->gf_rate_correction_factor = rate_correction_factor;
1237         else
1238             cpi->rate_correction_factor = rate_correction_factor;
1239     }
1240 }
1241
1242 static int estimate_bits_at_q(VP8_COMP *cpi, int Q)
1243 {
1244     int Bpm = (int)(.5 + cpi->rate_correction_factor * vp8_bits_per_mb[INTER_FRAME][Q]);
1245
1246     /* Attempt to retain reasonable accuracy without overflow. The cutoff is
1247      * chosen such that the maximum product of Bpm and MBs fits 31 bits. The
1248      * largest Bpm takes 20 bits.
1249      */
1250     if (cpi->common.MBs > (1 << 11))
1251         return (Bpm >> BPER_MB_NORMBITS) * cpi->common.MBs;
1252     else
1253         return (Bpm * cpi->common.MBs) >> BPER_MB_NORMBITS;
1254
1255 }
1256
1257
1258 int vp8_regulate_q(VP8_COMP *cpi, int target_bits_per_frame)
1259 {
1260     int Q = cpi->active_worst_quality;
1261
1262     // Reset Zbin OQ value
1263     cpi->zbin_over_quant = 0;
1264
1265     if (cpi->oxcf.fixed_q >= 0)
1266     {
1267         Q = cpi->oxcf.fixed_q;
1268
1269         if (cpi->common.frame_type == KEY_FRAME)
1270         {
1271             Q = cpi->oxcf.key_q;
1272         }
1273         else if (cpi->common.refresh_alt_ref_frame)
1274         {
1275             Q = cpi->oxcf.alt_q;
1276         }
1277         else if (cpi->common.refresh_golden_frame)
1278         {
1279             Q = cpi->oxcf.gold_q;
1280         }
1281
1282     }
1283     else
1284     {
1285         int i;
1286         int last_error = INT_MAX;
1287         int target_bits_per_mb;
1288         int bits_per_mb_at_this_q;
1289         double correction_factor;
1290
1291         // Select the appropriate correction factor based upon type of frame.
1292         if (cpi->common.frame_type == KEY_FRAME)
1293             correction_factor = cpi->key_frame_rate_correction_factor;
1294         else
1295         {
1296             if (cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame)
1297                 correction_factor = cpi->gf_rate_correction_factor;
1298             else
1299                 correction_factor = cpi->rate_correction_factor;
1300         }
1301
1302         // Calculate required scaling factor based on target frame size and size of frame produced using previous Q
1303         if (target_bits_per_frame >= (INT_MAX >> BPER_MB_NORMBITS))
1304             target_bits_per_mb = (target_bits_per_frame / cpi->common.MBs) << BPER_MB_NORMBITS;       // Case where we would overflow int
1305         else
1306             target_bits_per_mb = (target_bits_per_frame << BPER_MB_NORMBITS) / cpi->common.MBs;
1307
1308         i = cpi->active_best_quality;
1309
1310         do
1311         {
1312             bits_per_mb_at_this_q = (int)(.5 + correction_factor * vp8_bits_per_mb[cpi->common.frame_type][i]);
1313
1314             if (bits_per_mb_at_this_q <= target_bits_per_mb)
1315             {
1316                 if ((target_bits_per_mb - bits_per_mb_at_this_q) <= last_error)
1317                     Q = i;
1318                 else
1319                     Q = i - 1;
1320
1321                 break;
1322             }
1323             else
1324                 last_error = bits_per_mb_at_this_q - target_bits_per_mb;
1325         }
1326         while (++i <= cpi->active_worst_quality);
1327
1328
1329         // If we are at MAXQ then enable Q over-run which seeks to claw back additional bits through things like
1330         // the RD multiplier and zero bin size.
1331         if (Q >= MAXQ)
1332         {
1333             int zbin_oqmax;
1334
1335             double Factor = 0.99;
1336             double factor_adjustment = 0.01 / 256.0; //(double)ZBIN_OQ_MAX;
1337
1338             if (cpi->common.frame_type == KEY_FRAME)
1339                 zbin_oqmax = 0; //ZBIN_OQ_MAX/16
1340             else if (cpi->common.refresh_alt_ref_frame || (cpi->common.refresh_golden_frame && !cpi->source_alt_ref_active))
1341                 zbin_oqmax = 16;
1342             else
1343                 zbin_oqmax = ZBIN_OQ_MAX;
1344
1345             /*{
1346                 double Factor = (double)target_bits_per_mb/(double)bits_per_mb_at_this_q;
1347                 double Oq;
1348
1349                 Factor = Factor/1.2683;
1350
1351                 Oq = pow( Factor, (1.0/-0.165) );
1352
1353                 if ( Oq > zbin_oqmax )
1354                     Oq = zbin_oqmax;
1355
1356                 cpi->zbin_over_quant = (int)Oq;
1357             }*/
1358
1359             // Each incrment in the zbin is assumed to have a fixed effect on bitrate. This is not of course true.
1360             // The effect will be highly clip dependent and may well have sudden steps.
1361             // The idea here is to acheive higher effective quantizers than the normal maximum by expanding the zero
1362             // bin and hence decreasing the number of low magnitude non zero coefficients.
1363             while (cpi->zbin_over_quant < zbin_oqmax)
1364             {
1365                 cpi->zbin_over_quant ++;
1366
1367                 if (cpi->zbin_over_quant > zbin_oqmax)
1368                     cpi->zbin_over_quant = zbin_oqmax;
1369
1370                 // Adjust bits_per_mb_at_this_q estimate
1371                 bits_per_mb_at_this_q = (int)(Factor * bits_per_mb_at_this_q);
1372                 Factor += factor_adjustment;
1373
1374                 if (Factor  >= 0.999)
1375                     Factor = 0.999;
1376
1377                 if (bits_per_mb_at_this_q <= target_bits_per_mb)    // Break out if we get down to the target rate
1378                     break;
1379             }
1380
1381         }
1382     }
1383
1384     return Q;
1385 }
1386
1387 static int estimate_min_frame_size(VP8_COMP *cpi)
1388 {
1389     double correction_factor;
1390     int bits_per_mb_at_max_q;
1391
1392     // This funtion returns a default value for the first few frames untill the correction factor has had time to adapt.
1393     if (cpi->common.current_video_frame < 10)
1394     {
1395         if (cpi->pass == 2)
1396             return (cpi->min_frame_bandwidth);
1397         else
1398             return cpi->per_frame_bandwidth / 3;
1399     }
1400
1401     /*  // Select the appropriate correction factor based upon type of frame.
1402         if ( cpi->common.frame_type == KEY_FRAME )
1403             correction_factor = cpi->key_frame_rate_correction_factor;
1404         else
1405         {
1406             if ( cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame )
1407                 correction_factor = cpi->gf_rate_correction_factor;
1408             else
1409                 correction_factor = cpi->rate_correction_factor;
1410         }*/
1411
1412     // We estimate at half the value we get from vp8_bits_per_mb
1413     correction_factor = cpi->rate_correction_factor / 2.0;
1414
1415     bits_per_mb_at_max_q = (int)(.5 + correction_factor * vp8_bits_per_mb[cpi->common.frame_type][MAXQ]);
1416
1417     return (bits_per_mb_at_max_q * cpi->common.MBs) >> BPER_MB_NORMBITS;
1418 }
1419
1420 void vp8_adjust_key_frame_context(VP8_COMP *cpi)
1421 {
1422     int i;
1423     int av_key_frames_per_second;
1424
1425     // Average key frame frequency and size
1426     unsigned int total_weight = 0;
1427     unsigned int av_key_frame_frequency = 0;
1428     unsigned int av_key_frame_bits = 0;
1429
1430     unsigned int output_frame_rate = (unsigned int)(100 * cpi->output_frame_rate);
1431     unsigned int target_bandwidth = (unsigned int)(100 * cpi->target_bandwidth);
1432
1433     // Clear down mmx registers to allow floating point in what follows
1434     vp8_clear_system_state();  //__asm emms;
1435
1436     // Update the count of total key frame bits
1437     cpi->tot_key_frame_bits += cpi->projected_frame_size;
1438
1439     // First key frame at start of sequence is a special case. We have no frequency data.
1440     if (cpi->key_frame_count == 1)
1441     {
1442         av_key_frame_frequency = (int)cpi->output_frame_rate * 2;            // Assume a default of 1 kf every 2 seconds
1443         av_key_frame_bits = cpi->projected_frame_size;
1444         av_key_frames_per_second  = output_frame_rate / av_key_frame_frequency;  // Note output_frame_rate not cpi->output_frame_rate
1445     }
1446     else
1447     {
1448         int last_kf_interval =
1449                 (cpi->frames_since_key > 0) ? cpi->frames_since_key : 1;
1450
1451         // reset keyframe context and calculate weighted average of last KEY_FRAME_CONTEXT keyframes
1452         for (i = 0; i < KEY_FRAME_CONTEXT; i++)
1453         {
1454             if (i < KEY_FRAME_CONTEXT - 1)
1455             {
1456                 cpi->prior_key_frame_size[i]     = cpi->prior_key_frame_size[i+1];
1457                 cpi->prior_key_frame_distance[i] = cpi->prior_key_frame_distance[i+1];
1458             }
1459             else
1460             {
1461                 cpi->prior_key_frame_size[i]     = cpi->projected_frame_size;
1462                 cpi->prior_key_frame_distance[i] = last_kf_interval;
1463             }
1464
1465             av_key_frame_bits      += prior_key_frame_weight[i] * cpi->prior_key_frame_size[i];
1466             av_key_frame_frequency += prior_key_frame_weight[i] * cpi->prior_key_frame_distance[i];
1467             total_weight         += prior_key_frame_weight[i];
1468         }
1469
1470         av_key_frame_bits       /= total_weight;
1471         av_key_frame_frequency  /= total_weight;
1472         av_key_frames_per_second  = output_frame_rate / av_key_frame_frequency;
1473
1474     }
1475
1476     // Do we have any key frame overspend to recover?
1477     if ((cpi->pass != 2) && (cpi->projected_frame_size > cpi->per_frame_bandwidth))
1478     {
1479         // Update the count of key frame overspend to be recovered in subsequent frames
1480         // A portion of the KF overspend is treated as gf overspend (and hence recovered more quickly)
1481         // as the kf is also a gf. Otherwise the few frames following each kf tend to get more bits
1482         // allocated than those following other gfs.
1483         cpi->kf_overspend_bits += (cpi->projected_frame_size - cpi->per_frame_bandwidth) * 7 / 8;
1484         cpi->gf_overspend_bits += (cpi->projected_frame_size - cpi->per_frame_bandwidth) * 1 / 8;
1485         if(!av_key_frame_frequency)
1486             av_key_frame_frequency = 60;
1487
1488         // Work out how much to try and recover per frame.
1489         // For one pass we estimate the number of frames to spread it over based upon past history.
1490         // For two pass we know how many frames there will be till the next kf.
1491         if (cpi->pass == 2)
1492         {
1493             if (cpi->frames_to_key > 16)
1494                 cpi->kf_bitrate_adjustment = cpi->kf_overspend_bits / (int)cpi->frames_to_key;
1495             else
1496                 cpi->kf_bitrate_adjustment = cpi->kf_overspend_bits / 16;
1497         }
1498         else
1499             cpi->kf_bitrate_adjustment = cpi->kf_overspend_bits / (int)av_key_frame_frequency;
1500     }
1501
1502     cpi->frames_since_key = 0;
1503     cpi->last_key_frame_size = cpi->projected_frame_size;
1504     cpi->key_frame_count++;
1505 }
1506
1507 void vp8_compute_frame_size_bounds(VP8_COMP *cpi, int *frame_under_shoot_limit, int *frame_over_shoot_limit)
1508 {
1509     // Set-up bounds on acceptable frame size:
1510     if (cpi->oxcf.fixed_q >= 0)
1511     {
1512         // Fixed Q scenario: frame size never outranges target (there is no target!)
1513         *frame_under_shoot_limit = 0;
1514         *frame_over_shoot_limit  = INT_MAX;
1515     }
1516     else
1517     {
1518         if (cpi->common.frame_type == KEY_FRAME)
1519         {
1520             *frame_over_shoot_limit  = cpi->this_frame_target * 9 / 8;
1521             *frame_under_shoot_limit = cpi->this_frame_target * 7 / 8;
1522         }
1523         else
1524         {
1525             if (cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame)
1526             {
1527                 *frame_over_shoot_limit  = cpi->this_frame_target * 9 / 8;
1528                 *frame_under_shoot_limit = cpi->this_frame_target * 7 / 8;
1529             }
1530             else
1531             {
1532                 // For CBR take buffer fullness into account
1533                 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
1534                 {
1535                     if (cpi->buffer_level >= ((cpi->oxcf.optimal_buffer_level + cpi->oxcf.maximum_buffer_size) >> 1))
1536                     {
1537                         // Buffer is too full so relax overshoot and tighten undershoot
1538                         *frame_over_shoot_limit  = cpi->this_frame_target * 12 / 8;
1539                         *frame_under_shoot_limit = cpi->this_frame_target * 6 / 8;
1540                     }
1541                     else if (cpi->buffer_level <= (cpi->oxcf.optimal_buffer_level >> 1))
1542                     {
1543                         // Buffer is too low so relax undershoot and tighten overshoot
1544                         *frame_over_shoot_limit  = cpi->this_frame_target * 10 / 8;
1545                         *frame_under_shoot_limit = cpi->this_frame_target * 4 / 8;
1546                     }
1547                     else
1548                     {
1549                         *frame_over_shoot_limit  = cpi->this_frame_target * 11 / 8;
1550                         *frame_under_shoot_limit = cpi->this_frame_target * 5 / 8;
1551                     }
1552                 }
1553                 // VBR
1554                 // Note that tighter restrictions here can help quality but hurt encode speed
1555                 else
1556                 {
1557                     *frame_over_shoot_limit  = cpi->this_frame_target * 11 / 8;
1558                     *frame_under_shoot_limit = cpi->this_frame_target * 5 / 8;
1559                 }
1560             }
1561         }
1562     }
1563 }