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             cpi->common.refresh_golden_frame = TRUE;
1042         else
1043         {
1044             // For one pass throw a GF if recent frame intra useage is low or the GF useage is high
1045             if ((cpi->pass == 0) && (cpi->this_frame_percent_intra < 15 || gf_frame_useage >= 5))
1046                 cpi->common.refresh_golden_frame = TRUE;
1047
1048             // Two pass GF descision
1049             else if (cpi->pass == 2)
1050                 cpi->common.refresh_golden_frame = TRUE;
1051         }
1052
1053 #if 0
1054
1055         // Debug stats
1056         if (0)
1057         {
1058             FILE *f;
1059
1060             f = fopen("gf_useaget.stt", "a");
1061             fprintf(f, " %8ld %10ld %10ld %10ld %10ld\n",
1062                     cpi->common.current_video_frame,  cpi->gfu_boost, GFQ_ADJUSTMENT, cpi->gfu_boost, gf_frame_useage);
1063             fclose(f);
1064         }
1065
1066 #endif
1067
1068         if (cpi->common.refresh_golden_frame == TRUE)
1069         {
1070 #if 0
1071
1072             if (0)   // p_gw
1073             {
1074                 FILE *f;
1075
1076                 f = fopen("GFexit.stt", "a");
1077                 fprintf(f, "%8ld GF coded\n", cpi->common.current_video_frame);
1078                 fclose(f);
1079             }
1080
1081 #endif
1082             cpi->initial_gf_use = 0;
1083
1084             if (cpi->auto_adjust_gold_quantizer)
1085             {
1086                 calc_gf_params(cpi);
1087             }
1088
1089             // If we are using alternate ref instead of gf then do not apply the boost
1090             // It will instead be applied to the altref update
1091             // Jims modified boost
1092             if (!cpi->source_alt_ref_active)
1093             {
1094                 if (cpi->oxcf.fixed_q < 0)
1095                 {
1096                     if (cpi->pass == 2)
1097                     {
1098                         cpi->this_frame_target = cpi->per_frame_bandwidth;          // The spend on the GF is defined in the two pass code for two pass encodes
1099                     }
1100                     else
1101                     {
1102                         int Boost = cpi->last_boost;
1103                         int frames_in_section = cpi->frames_till_gf_update_due + 1;
1104                         int allocation_chunks = (frames_in_section * 100) + (Boost - 100);
1105                         int bits_in_section = cpi->inter_frame_target * frames_in_section;
1106
1107                         // Normalize Altboost and allocations chunck down to prevent overflow
1108                         while (Boost > 1000)
1109                         {
1110                             Boost /= 2;
1111                             allocation_chunks /= 2;
1112                         }
1113
1114                         // Avoid loss of precision but avoid overflow
1115                         if ((bits_in_section >> 7) > allocation_chunks)
1116                             cpi->this_frame_target = Boost * (bits_in_section / allocation_chunks);
1117                         else
1118                             cpi->this_frame_target = (Boost * bits_in_section) / allocation_chunks;
1119                     }
1120                 }
1121                 else
1122                     cpi->this_frame_target = (baseline_bits_at_q(1, Q, cpi->common.MBs) * cpi->last_boost) / 100;
1123
1124             }
1125             // If there is an active ARF at this location use the minimum
1126             // bits on this frame even if it is a contructed arf.
1127             // The active maximum quantizer insures that an appropriate
1128             // number of bits will be spent if needed for contstructed ARFs.
1129             else
1130             {
1131                 cpi->this_frame_target = 0;
1132             }
1133
1134             cpi->current_gf_interval = cpi->frames_till_gf_update_due;
1135
1136         }
1137     }
1138 }
1139
1140
1141 void vp8_update_rate_correction_factors(VP8_COMP *cpi, int damp_var)
1142 {
1143     int    Q = cpi->common.base_qindex;
1144     int    correction_factor = 100;
1145     double rate_correction_factor;
1146     double adjustment_limit;
1147
1148     int    projected_size_based_on_q = 0;
1149
1150     // Clear down mmx registers to allow floating point in what follows
1151     vp8_clear_system_state();  //__asm emms;
1152
1153     if (cpi->common.frame_type == KEY_FRAME)
1154     {
1155         rate_correction_factor = cpi->key_frame_rate_correction_factor;
1156     }
1157     else
1158     {
1159         if (cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame)
1160             rate_correction_factor = cpi->gf_rate_correction_factor;
1161         else
1162             rate_correction_factor = cpi->rate_correction_factor;
1163     }
1164
1165     // Work out how big we would have expected the frame to be at this Q given the current correction factor.
1166     // Stay in double to avoid int overflow when values are large
1167     //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;
1168     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));
1169
1170     // Make some allowance for cpi->zbin_over_quant
1171     if (cpi->zbin_over_quant > 0)
1172     {
1173         int Z = cpi->zbin_over_quant;
1174         double Factor = 0.99;
1175         double factor_adjustment = 0.01 / 256.0; //(double)ZBIN_OQ_MAX;
1176
1177         while (Z > 0)
1178         {
1179             Z --;
1180             projected_size_based_on_q =
1181                 (int)(Factor * projected_size_based_on_q);
1182             Factor += factor_adjustment;
1183
1184             if (Factor  >= 0.999)
1185                 Factor = 0.999;
1186         }
1187     }
1188
1189     // Work out a size correction factor.
1190     //if ( cpi->this_frame_target > 0 )
1191     //  correction_factor = (100 * cpi->projected_frame_size) / cpi->this_frame_target;
1192     if (projected_size_based_on_q > 0)
1193         correction_factor = (100 * cpi->projected_frame_size) / projected_size_based_on_q;
1194
1195     // More heavily damped adjustment used if we have been oscillating either side of target
1196     switch (damp_var)
1197     {
1198     case 0:
1199         adjustment_limit = 0.75;
1200         break;
1201     case 1:
1202         adjustment_limit = 0.375;
1203         break;
1204     case 2:
1205     default:
1206         adjustment_limit = 0.25;
1207         break;
1208     }
1209
1210     //if ( (correction_factor > 102) && (Q < cpi->active_worst_quality) )
1211     if (correction_factor > 102)
1212     {
1213         // We are not already at the worst allowable quality
1214         correction_factor = (int)(100.5 + ((correction_factor - 100) * adjustment_limit));
1215         rate_correction_factor = ((rate_correction_factor * correction_factor) / 100);
1216
1217         // Keep rate_correction_factor within limits
1218         if (rate_correction_factor > MAX_BPB_FACTOR)
1219             rate_correction_factor = MAX_BPB_FACTOR;
1220     }
1221     //else if ( (correction_factor < 99) && (Q > cpi->active_best_quality) )
1222     else if (correction_factor < 99)
1223     {
1224         // We are not already at the best allowable quality
1225         correction_factor = (int)(100.5 - ((100 - correction_factor) * adjustment_limit));
1226         rate_correction_factor = ((rate_correction_factor * correction_factor) / 100);
1227
1228         // Keep rate_correction_factor within limits
1229         if (rate_correction_factor < MIN_BPB_FACTOR)
1230             rate_correction_factor = MIN_BPB_FACTOR;
1231     }
1232
1233     if (cpi->common.frame_type == KEY_FRAME)
1234         cpi->key_frame_rate_correction_factor = rate_correction_factor;
1235     else
1236     {
1237         if (cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame)
1238             cpi->gf_rate_correction_factor = rate_correction_factor;
1239         else
1240             cpi->rate_correction_factor = rate_correction_factor;
1241     }
1242 }
1243
1244 static int estimate_bits_at_q(VP8_COMP *cpi, int Q)
1245 {
1246     int Bpm = (int)(.5 + cpi->rate_correction_factor * vp8_bits_per_mb[INTER_FRAME][Q]);
1247
1248     /* Attempt to retain reasonable accuracy without overflow. The cutoff is
1249      * chosen such that the maximum product of Bpm and MBs fits 31 bits. The
1250      * largest Bpm takes 20 bits.
1251      */
1252     if (cpi->common.MBs > (1 << 11))
1253         return (Bpm >> BPER_MB_NORMBITS) * cpi->common.MBs;
1254     else
1255         return (Bpm * cpi->common.MBs) >> BPER_MB_NORMBITS;
1256
1257 }
1258
1259
1260 int vp8_regulate_q(VP8_COMP *cpi, int target_bits_per_frame)
1261 {
1262     int Q = cpi->active_worst_quality;
1263
1264     // Reset Zbin OQ value
1265     cpi->zbin_over_quant = 0;
1266
1267     if (cpi->oxcf.fixed_q >= 0)
1268     {
1269         Q = cpi->oxcf.fixed_q;
1270
1271         if (cpi->common.frame_type == KEY_FRAME)
1272         {
1273             Q = cpi->oxcf.key_q;
1274         }
1275         else if (cpi->common.refresh_alt_ref_frame)
1276         {
1277             Q = cpi->oxcf.alt_q;
1278         }
1279         else if (cpi->common.refresh_golden_frame)
1280         {
1281             Q = cpi->oxcf.gold_q;
1282         }
1283
1284     }
1285     else
1286     {
1287         int i;
1288         int last_error = INT_MAX;
1289         int target_bits_per_mb;
1290         int bits_per_mb_at_this_q;
1291         double correction_factor;
1292
1293         // Select the appropriate correction factor based upon type of frame.
1294         if (cpi->common.frame_type == KEY_FRAME)
1295             correction_factor = cpi->key_frame_rate_correction_factor;
1296         else
1297         {
1298             if (cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame)
1299                 correction_factor = cpi->gf_rate_correction_factor;
1300             else
1301                 correction_factor = cpi->rate_correction_factor;
1302         }
1303
1304         // Calculate required scaling factor based on target frame size and size of frame produced using previous Q
1305         if (target_bits_per_frame >= (INT_MAX >> BPER_MB_NORMBITS))
1306             target_bits_per_mb = (target_bits_per_frame / cpi->common.MBs) << BPER_MB_NORMBITS;       // Case where we would overflow int
1307         else
1308             target_bits_per_mb = (target_bits_per_frame << BPER_MB_NORMBITS) / cpi->common.MBs;
1309
1310         i = cpi->active_best_quality;
1311
1312         do
1313         {
1314             bits_per_mb_at_this_q = (int)(.5 + correction_factor * vp8_bits_per_mb[cpi->common.frame_type][i]);
1315
1316             if (bits_per_mb_at_this_q <= target_bits_per_mb)
1317             {
1318                 if ((target_bits_per_mb - bits_per_mb_at_this_q) <= last_error)
1319                     Q = i;
1320                 else
1321                     Q = i - 1;
1322
1323                 break;
1324             }
1325             else
1326                 last_error = bits_per_mb_at_this_q - target_bits_per_mb;
1327         }
1328         while (++i <= cpi->active_worst_quality);
1329
1330
1331         // If we are at MAXQ then enable Q over-run which seeks to claw back additional bits through things like
1332         // the RD multiplier and zero bin size.
1333         if (Q >= MAXQ)
1334         {
1335             int zbin_oqmax;
1336
1337             double Factor = 0.99;
1338             double factor_adjustment = 0.01 / 256.0; //(double)ZBIN_OQ_MAX;
1339
1340             if (cpi->common.frame_type == KEY_FRAME)
1341                 zbin_oqmax = 0; //ZBIN_OQ_MAX/16
1342             else if (cpi->common.refresh_alt_ref_frame || (cpi->common.refresh_golden_frame && !cpi->source_alt_ref_active))
1343                 zbin_oqmax = 16;
1344             else
1345                 zbin_oqmax = ZBIN_OQ_MAX;
1346
1347             /*{
1348                 double Factor = (double)target_bits_per_mb/(double)bits_per_mb_at_this_q;
1349                 double Oq;
1350
1351                 Factor = Factor/1.2683;
1352
1353                 Oq = pow( Factor, (1.0/-0.165) );
1354
1355                 if ( Oq > zbin_oqmax )
1356                     Oq = zbin_oqmax;
1357
1358                 cpi->zbin_over_quant = (int)Oq;
1359             }*/
1360
1361             // Each incrment in the zbin is assumed to have a fixed effect on bitrate. This is not of course true.
1362             // The effect will be highly clip dependent and may well have sudden steps.
1363             // The idea here is to acheive higher effective quantizers than the normal maximum by expanding the zero
1364             // bin and hence decreasing the number of low magnitude non zero coefficients.
1365             while (cpi->zbin_over_quant < zbin_oqmax)
1366             {
1367                 cpi->zbin_over_quant ++;
1368
1369                 if (cpi->zbin_over_quant > zbin_oqmax)
1370                     cpi->zbin_over_quant = zbin_oqmax;
1371
1372                 // Adjust bits_per_mb_at_this_q estimate
1373                 bits_per_mb_at_this_q = (int)(Factor * bits_per_mb_at_this_q);
1374                 Factor += factor_adjustment;
1375
1376                 if (Factor  >= 0.999)
1377                     Factor = 0.999;
1378
1379                 if (bits_per_mb_at_this_q <= target_bits_per_mb)    // Break out if we get down to the target rate
1380                     break;
1381             }
1382
1383         }
1384     }
1385
1386     return Q;
1387 }
1388
1389 static int estimate_min_frame_size(VP8_COMP *cpi)
1390 {
1391     double correction_factor;
1392     int bits_per_mb_at_max_q;
1393
1394     // This funtion returns a default value for the first few frames untill the correction factor has had time to adapt.
1395     if (cpi->common.current_video_frame < 10)
1396     {
1397         if (cpi->pass == 2)
1398             return (cpi->min_frame_bandwidth);
1399         else
1400             return cpi->per_frame_bandwidth / 3;
1401     }
1402
1403     /*  // Select the appropriate correction factor based upon type of frame.
1404         if ( cpi->common.frame_type == KEY_FRAME )
1405             correction_factor = cpi->key_frame_rate_correction_factor;
1406         else
1407         {
1408             if ( cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame )
1409                 correction_factor = cpi->gf_rate_correction_factor;
1410             else
1411                 correction_factor = cpi->rate_correction_factor;
1412         }*/
1413
1414     // We estimate at half the value we get from vp8_bits_per_mb
1415     correction_factor = cpi->rate_correction_factor / 2.0;
1416
1417     bits_per_mb_at_max_q = (int)(.5 + correction_factor * vp8_bits_per_mb[cpi->common.frame_type][MAXQ]);
1418
1419     return (bits_per_mb_at_max_q * cpi->common.MBs) >> BPER_MB_NORMBITS;
1420 }
1421
1422 void vp8_adjust_key_frame_context(VP8_COMP *cpi)
1423 {
1424     int i;
1425     int av_key_frames_per_second;
1426
1427     // Average key frame frequency and size
1428     unsigned int total_weight = 0;
1429     unsigned int av_key_frame_frequency = 0;
1430     unsigned int av_key_frame_bits = 0;
1431
1432     unsigned int output_frame_rate = (unsigned int)(100 * cpi->output_frame_rate);
1433     unsigned int target_bandwidth = (unsigned int)(100 * cpi->target_bandwidth);
1434
1435     // Clear down mmx registers to allow floating point in what follows
1436     vp8_clear_system_state();  //__asm emms;
1437
1438     // Update the count of total key frame bits
1439     cpi->tot_key_frame_bits += cpi->projected_frame_size;
1440
1441     // First key frame at start of sequence is a special case. We have no frequency data.
1442     if (cpi->key_frame_count == 1)
1443     {
1444         av_key_frame_frequency = (int)cpi->output_frame_rate * 2;            // Assume a default of 1 kf every 2 seconds
1445         av_key_frame_bits = cpi->projected_frame_size;
1446         av_key_frames_per_second  = output_frame_rate / av_key_frame_frequency;  // Note output_frame_rate not cpi->output_frame_rate
1447     }
1448     else
1449     {
1450         int last_kf_interval =
1451                 (cpi->frames_since_key > 0) ? cpi->frames_since_key : 1;
1452
1453         // reset keyframe context and calculate weighted average of last KEY_FRAME_CONTEXT keyframes
1454         for (i = 0; i < KEY_FRAME_CONTEXT; i++)
1455         {
1456             if (i < KEY_FRAME_CONTEXT - 1)
1457             {
1458                 cpi->prior_key_frame_size[i]     = cpi->prior_key_frame_size[i+1];
1459                 cpi->prior_key_frame_distance[i] = cpi->prior_key_frame_distance[i+1];
1460             }
1461             else
1462             {
1463                 cpi->prior_key_frame_size[i]     = cpi->projected_frame_size;
1464                 cpi->prior_key_frame_distance[i] = last_kf_interval;
1465             }
1466
1467             av_key_frame_bits      += prior_key_frame_weight[i] * cpi->prior_key_frame_size[i];
1468             av_key_frame_frequency += prior_key_frame_weight[i] * cpi->prior_key_frame_distance[i];
1469             total_weight         += prior_key_frame_weight[i];
1470         }
1471
1472         av_key_frame_bits       /= total_weight;
1473         av_key_frame_frequency  /= total_weight;
1474         av_key_frames_per_second  = output_frame_rate / av_key_frame_frequency;
1475
1476     }
1477
1478     // Do we have any key frame overspend to recover?
1479     if ((cpi->pass != 2) && (cpi->projected_frame_size > cpi->per_frame_bandwidth))
1480     {
1481         // Update the count of key frame overspend to be recovered in subsequent frames
1482         // A portion of the KF overspend is treated as gf overspend (and hence recovered more quickly)
1483         // as the kf is also a gf. Otherwise the few frames following each kf tend to get more bits
1484         // allocated than those following other gfs.
1485         cpi->kf_overspend_bits += (cpi->projected_frame_size - cpi->per_frame_bandwidth) * 7 / 8;
1486         cpi->gf_overspend_bits += (cpi->projected_frame_size - cpi->per_frame_bandwidth) * 1 / 8;
1487         if(!av_key_frame_frequency)
1488             av_key_frame_frequency = 60;
1489
1490         // Work out how much to try and recover per frame.
1491         // For one pass we estimate the number of frames to spread it over based upon past history.
1492         // For two pass we know how many frames there will be till the next kf.
1493         if (cpi->pass == 2)
1494         {
1495             if (cpi->frames_to_key > 16)
1496                 cpi->kf_bitrate_adjustment = cpi->kf_overspend_bits / (int)cpi->frames_to_key;
1497             else
1498                 cpi->kf_bitrate_adjustment = cpi->kf_overspend_bits / 16;
1499         }
1500         else
1501             cpi->kf_bitrate_adjustment = cpi->kf_overspend_bits / (int)av_key_frame_frequency;
1502     }
1503
1504     cpi->frames_since_key = 0;
1505     cpi->last_key_frame_size = cpi->projected_frame_size;
1506     cpi->key_frame_count++;
1507 }
1508
1509 void vp8_compute_frame_size_bounds(VP8_COMP *cpi, int *frame_under_shoot_limit, int *frame_over_shoot_limit)
1510 {
1511     // Set-up bounds on acceptable frame size:
1512     if (cpi->oxcf.fixed_q >= 0)
1513     {
1514         // Fixed Q scenario: frame size never outranges target (there is no target!)
1515         *frame_under_shoot_limit = 0;
1516         *frame_over_shoot_limit  = INT_MAX;
1517     }
1518     else
1519     {
1520         if (cpi->common.frame_type == KEY_FRAME)
1521         {
1522             *frame_over_shoot_limit  = cpi->this_frame_target * 9 / 8;
1523             *frame_under_shoot_limit = cpi->this_frame_target * 7 / 8;
1524         }
1525         else
1526         {
1527             if (cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame)
1528             {
1529                 *frame_over_shoot_limit  = cpi->this_frame_target * 9 / 8;
1530                 *frame_under_shoot_limit = cpi->this_frame_target * 7 / 8;
1531             }
1532             else
1533             {
1534                 // For CBR take buffer fullness into account
1535                 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
1536                 {
1537                     if (cpi->buffer_level >= ((cpi->oxcf.optimal_buffer_level + cpi->oxcf.maximum_buffer_size) >> 1))
1538                     {
1539                         // Buffer is too full so relax overshoot and tighten undershoot
1540                         *frame_over_shoot_limit  = cpi->this_frame_target * 12 / 8;
1541                         *frame_under_shoot_limit = cpi->this_frame_target * 6 / 8;
1542                     }
1543                     else if (cpi->buffer_level <= (cpi->oxcf.optimal_buffer_level >> 1))
1544                     {
1545                         // Buffer is too low so relax undershoot and tighten overshoot
1546                         *frame_over_shoot_limit  = cpi->this_frame_target * 10 / 8;
1547                         *frame_under_shoot_limit = cpi->this_frame_target * 4 / 8;
1548                     }
1549                     else
1550                     {
1551                         *frame_over_shoot_limit  = cpi->this_frame_target * 11 / 8;
1552                         *frame_under_shoot_limit = cpi->this_frame_target * 5 / 8;
1553                     }
1554                 }
1555                 // VBR
1556                 // Note that tighter restrictions here can help quality but hurt encode speed
1557                 else
1558                 {
1559                     *frame_over_shoot_limit  = cpi->this_frame_target * 11 / 8;
1560                     *frame_under_shoot_limit = cpi->this_frame_target * 5 / 8;
1561                 }
1562             }
1563         }
1564     }
1565 }