The Tor Browser / annotate

media/libvpx/vp8/encoder/ratectrl.c@6474c204b198 (annotated)

media/libvpx/vp8/encoder/ratectrl.c

Wed, 31 Dec 2014 06:09:35 +0100

author
Michael Schloh von Bennewitz <michael@schloh.com>
date
Wed, 31 Dec 2014 06:09:35 +0100
changeset 0
6474c204b198
permissions
-rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

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

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial