granicus.if.org Git - libvpx/blob - vp8/encoder/ratectrl.c

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