ratectrl.c 25 KB
Newer Older
John Koleszar's avatar
John Koleszar committed
1
/*
2
 *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
John Koleszar's avatar
John Koleszar committed
3
 *
4
 *  Use of this source code is governed by a BSD-style license
5 6
 *  that can be found in the LICENSE file in the root of the source
 *  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.
John Koleszar's avatar
John Koleszar committed
9 10 11 12 13 14 15 16 17 18
 */


#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <limits.h>
#include <assert.h>

#include "math.h"
John Koleszar's avatar
John Koleszar committed
19
#include "vp8/common/common.h"
John Koleszar's avatar
John Koleszar committed
20
#include "ratectrl.h"
John Koleszar's avatar
John Koleszar committed
21
#include "vp8/common/entropymode.h"
John Koleszar's avatar
John Koleszar committed
22
#include "vpx_mem/vpx_mem.h"
John Koleszar's avatar
John Koleszar committed
23
#include "vp8/common/systemdependent.h"
John Koleszar's avatar
John Koleszar committed
24
#include "encodemv.h"
Christian Duvivier's avatar
Christian Duvivier committed
25
#include "vp8/common/quant_common.h"
John Koleszar's avatar
John Koleszar committed
26

27
#define MIN_BPB_FACTOR          0.005
John Koleszar's avatar
John Koleszar committed
28 29
#define MAX_BPB_FACTOR          50

30
extern const MODE_DEFINITION vp8_mode_order[MAX_MODES];
John Koleszar's avatar
John Koleszar committed
31 32 33


#ifdef MODE_STATS
34 35 36
extern unsigned int y_modes[VP8_YMODES];
extern unsigned int uv_modes[VP8_UV_MODES];
extern unsigned int b_modes[B_MODE_COUNT];
John Koleszar's avatar
John Koleszar committed
37

38 39 40
extern unsigned int inter_y_modes[MB_MODE_COUNT];
extern unsigned int inter_uv_modes[VP8_UV_MODES];
extern unsigned int inter_b_modes[B_MODE_COUNT];
John Koleszar's avatar
John Koleszar committed
41 42 43 44 45 46
#endif

// Bits Per MB at different Q (Multiplied by 512)
#define BPER_MB_NORMBITS    9

// % adjustment to target kf size based on seperation from previous frame
47
static const int kf_boost_seperation_adjustment[16] =
John Koleszar's avatar
John Koleszar committed
48 49 50 51 52
{
    30,   40,   50,   55,   60,   65,   70,   75,
    80,   85,   90,   95,  100,  100,  100,  100,
};

53
static const int gf_adjust_table[101] =
John Koleszar's avatar
John Koleszar committed
54 55 56 57 58 59 60 61 62 63 64 65 66 67
{
    100,
    115, 130, 145, 160, 175, 190, 200, 210, 220, 230,
    240, 260, 270, 280, 290, 300, 310, 320, 330, 340,
    350, 360, 370, 380, 390, 400, 400, 400, 400, 400,
    400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
    400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
    400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
    400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
    400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
    400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
    400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
};

68
static const int gf_intra_usage_adjustment[20] =
John Koleszar's avatar
John Koleszar committed
69 70 71 72 73
{
    125, 120, 115, 110, 105, 100,  95,  85,  80,  75,
    70,  65,  60,  55,  50,  50,  50,  50,  50,  50,
};

74
static const int gf_interval_table[101] =
John Koleszar's avatar
John Koleszar committed
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
{
    7,
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
    8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
    8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
    9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
    9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
    10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
    10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
    11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
};

static const unsigned int prior_key_frame_weight[KEY_FRAME_CONTEXT] = { 1, 2, 3, 4, 5 };

Paul Wilkins's avatar
Paul Wilkins committed
91 92 93 94 95 96
// These functions use formulaic calculations to make playing with the
// quantizer tables easier. If necessary they can be replaced by lookup
// tables if and when things settle down in the experimental bitstream
double vp8_convert_qindex_to_q( int qindex )
{
    // Convert the index to a real Q value (scaled down to match old Q values)
Christian Duvivier's avatar
Christian Duvivier committed
97
    return (double)vp8_ac_yquant( qindex ) / 4.0;
Paul Wilkins's avatar
Paul Wilkins committed
98 99 100 101
}

int vp8_gfboost_qadjust( int qindex )
{
102 103 104 105 106 107 108 109
    int retval;
    double q;

    q = vp8_convert_qindex_to_q(qindex);
    retval = (int)( ( 0.00000828 * q * q * q ) +
                    ( -0.0055 * q * q ) +
                    ( 1.32 * q ) + 79.3 );
    return retval;
Paul Wilkins's avatar
Paul Wilkins committed
110 111 112 113
}

int kfboost_qadjust( int qindex )
{
114 115 116 117 118 119 120 121
    int retval;
    double q;

    q = vp8_convert_qindex_to_q(qindex);
    retval = (int)( ( 0.00000973 * q * q * q ) +
                    ( -0.00613 * q * q ) +
                    ( 1.316 * q ) + 121.2 );
    return retval;
Paul Wilkins's avatar
Paul Wilkins committed
122 123 124 125 126 127 128 129 130 131
}

int vp8_bits_per_mb( FRAME_TYPE frame_type, int qindex  )
{
    if ( frame_type == KEY_FRAME )
        return (int)(4500000 / vp8_convert_qindex_to_q(qindex));
    else
        return (int)(2850000 / vp8_convert_qindex_to_q(qindex));
}

John Koleszar's avatar
John Koleszar committed
132 133 134 135

void vp8_save_coding_context(VP8_COMP *cpi)
{
    CODING_CONTEXT *const cc = & cpi->coding_context;
136 137
    VP8_COMMON *cm = &cpi->common;
    MACROBLOCKD *xd = &cpi->mb.e_mbd;
John Koleszar's avatar
John Koleszar committed
138 139 140 141 142 143

    // Stores a snapshot of key state variables which can subsequently be
    // restored with a call to vp8_restore_coding_context. These functions are
    // intended for use in a re-code loop in vp8_compress_frame where the
    // quantizer value is adjusted between loop iterations.

144
    vp8_copy(cc->mvc,      cm->fc.mvc);
John Koleszar's avatar
John Koleszar committed
145
    vp8_copy(cc->mvcosts,  cpi->mb.mvcosts);
146
#if CONFIG_HIGH_PRECISION_MV
147
    vp8_copy(cc->mvc_hp,     cm->fc.mvc_hp);
148 149
    vp8_copy(cc->mvcosts_hp,  cpi->mb.mvcosts_hp);
#endif
John Koleszar's avatar
John Koleszar committed
150

151 152 153 154
    vp8_copy( cc->mv_ref_ct, cm->fc.mv_ref_ct );
    vp8_copy( cc->mode_context, cm->fc.mode_context );
    vp8_copy( cc->mv_ref_ct_a, cm->fc.mv_ref_ct_a );
    vp8_copy( cc->mode_context_a, cm->fc.mode_context_a );
John Koleszar's avatar
John Koleszar committed
155

156
    vp8_copy( cc->ymode_prob, cm->fc.ymode_prob );
157
    vp8_copy( cc->bmode_prob, cm->fc.bmode_prob );
158
    vp8_copy( cc->uv_mode_prob, cm->fc.uv_mode_prob );
159
    vp8_copy( cc->i8x8_mode_prob, cm->fc.i8x8_mode_prob );
160 161
    vp8_copy( cc->sub_mv_ref_prob, cm->fc.sub_mv_ref_prob );
    vp8_copy( cc->mbsplit_prob, cm->fc.mbsplit_prob );
162

John Koleszar's avatar
John Koleszar committed
163 164 165 166 167 168 169 170 171 172
    // Stats
#ifdef MODE_STATS
    vp8_copy(cc->y_modes,       y_modes);
    vp8_copy(cc->uv_modes,      uv_modes);
    vp8_copy(cc->b_modes,       b_modes);
    vp8_copy(cc->inter_y_modes,  inter_y_modes);
    vp8_copy(cc->inter_uv_modes, inter_uv_modes);
    vp8_copy(cc->inter_b_modes,  inter_b_modes);
#endif

173 174 175 176 177 178 179
    vp8_copy( cc->segment_pred_probs, cm->segment_pred_probs );
    vp8_copy( cc->ref_pred_probs_update, cpi->ref_pred_probs_update );
    vp8_copy( cc->ref_pred_probs, cm->ref_pred_probs );
    vp8_copy( cc->prob_comppred, cm->prob_comppred );

    vpx_memcpy( cpi->coding_context.last_frame_seg_map_copy,
                cm->last_frame_seg_map, (cm->mb_rows * cm->mb_cols) );
John Koleszar's avatar
John Koleszar committed
180

181 182 183 184 185 186
    vp8_copy( cc->last_ref_lf_deltas, xd->last_ref_lf_deltas );
    vp8_copy( cc->last_mode_lf_deltas, xd->last_mode_lf_deltas );

    vp8_copy( cc->coef_probs, cm->fc.coef_probs );
    vp8_copy( cc->coef_probs_8x8, cm->fc.coef_probs_8x8 );
}
John Koleszar's avatar
John Koleszar committed
187 188 189 190

void vp8_restore_coding_context(VP8_COMP *cpi)
{
    CODING_CONTEXT *const cc = & cpi->coding_context;
191 192
    VP8_COMMON *cm = &cpi->common;
    MACROBLOCKD *xd = &cpi->mb.e_mbd;
John Koleszar's avatar
John Koleszar committed
193 194 195 196

    // Restore key state variables to the snapshot state stored in the
    // previous call to vp8_save_coding_context.

197
    vp8_copy(cm->fc.mvc, cc->mvc);
John Koleszar's avatar
John Koleszar committed
198
    vp8_copy(cpi->mb.mvcosts, cc->mvcosts);
199
#if CONFIG_HIGH_PRECISION_MV
200
    vp8_copy(cm->fc.mvc_hp, cc->mvc_hp);
201 202
    vp8_copy(cpi->mb.mvcosts_hp, cc->mvcosts_hp);
#endif
John Koleszar's avatar
John Koleszar committed
203

204 205 206 207
    vp8_copy( cm->fc.mv_ref_ct, cc->mv_ref_ct );
    vp8_copy( cm->fc.mode_context, cc->mode_context );
    vp8_copy( cm->fc.mv_ref_ct_a, cc->mv_ref_ct_a );
    vp8_copy( cm->fc.mode_context_a, cc->mode_context_a );
John Koleszar's avatar
John Koleszar committed
208

209
    vp8_copy( cm->fc.ymode_prob, cc->ymode_prob);
210 211
    vp8_copy( cm->fc.bmode_prob, cc->bmode_prob);
    vp8_copy( cm->fc.i8x8_mode_prob, cc->i8x8_mode_prob);
212
    vp8_copy( cm->fc.uv_mode_prob, cc->uv_mode_prob);
213 214
    vp8_copy( cm->fc.sub_mv_ref_prob, cc->sub_mv_ref_prob);
    vp8_copy( cm->fc.mbsplit_prob, cc->mbsplit_prob );
215

John Koleszar's avatar
John Koleszar committed
216 217 218 219 220 221 222 223 224 225
    // Stats
#ifdef MODE_STATS
    vp8_copy(y_modes, cc->y_modes);
    vp8_copy(uv_modes, cc->uv_modes);
    vp8_copy(b_modes, cc->b_modes);
    vp8_copy(inter_y_modes, cc->inter_y_modes);
    vp8_copy(inter_uv_modes, cc->inter_uv_modes);
    vp8_copy(inter_b_modes, cc->inter_b_modes);
#endif

226 227 228 229 230 231 232 233
    vp8_copy( cm->segment_pred_probs, cc->segment_pred_probs );
    vp8_copy( cpi->ref_pred_probs_update, cc->ref_pred_probs_update );
    vp8_copy( cm->ref_pred_probs, cc->ref_pred_probs );
    vp8_copy( cm->prob_comppred, cc->prob_comppred );

    vpx_memcpy( cm->last_frame_seg_map,
                cpi->coding_context.last_frame_seg_map_copy,
                (cm->mb_rows * cm->mb_cols) );
John Koleszar's avatar
John Koleszar committed
234

235 236 237 238 239
    vp8_copy( xd->last_ref_lf_deltas, cc->last_ref_lf_deltas );
    vp8_copy( xd->last_mode_lf_deltas, cc->last_mode_lf_deltas );

    vp8_copy( cm->fc.coef_probs, cc->coef_probs );
    vp8_copy( cm->fc.coef_probs_8x8, cc->coef_probs_8x8 );
John Koleszar's avatar
John Koleszar committed
240 241 242 243 244 245 246 247
}


void vp8_setup_key_frame(VP8_COMP *cpi)
{
    // Setup for Key frame:
    vp8_default_coef_probs(& cpi->common);
    vp8_kf_default_bmode_probs(cpi->common.kf_bmode_prob);
248
    vp8_init_mbmode_probs(& cpi->common);
John Koleszar's avatar
John Koleszar committed
249 250 251 252

    vpx_memcpy(cpi->common.fc.mvc, vp8_default_mv_context, sizeof(vp8_default_mv_context));
    {
        int flag[2] = {1, 1};
253
        vp8_build_component_cost_table(cpi->mb.mvcost, (const MV_CONTEXT *) cpi->common.fc.mvc, flag);
John Koleszar's avatar
John Koleszar committed
254
    }
255 256 257 258 259 260 261 262
#if CONFIG_HIGH_PRECISION_MV
    vpx_memcpy(cpi->common.fc.mvc_hp, vp8_default_mv_context_hp, sizeof(vp8_default_mv_context_hp));
    {
        int flag[2] = {1, 1};
        vp8_build_component_cost_table_hp(cpi->mb.mvcost_hp, (const MV_CONTEXT_HP *) cpi->common.fc.mvc_hp, flag);
    }
#endif

263

264

265
    cpi->common.txfm_mode = ALLOW_8X8;
266

John Koleszar's avatar
John Koleszar committed
267 268 269
    //cpi->common.filter_level = 0;      // Reset every key frame.
    cpi->common.filter_level = cpi->common.base_qindex * 3 / 8 ;

270 271
    // interval before next GF
    cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
John Koleszar's avatar
John Koleszar committed
272 273

    cpi->common.refresh_golden_frame = TRUE;
274
    cpi->common.refresh_alt_ref_frame = TRUE;
275

276
    vp8_init_mode_contexts(&cpi->common);
277 278 279
    vpx_memcpy(&cpi->common.lfc, &cpi->common.fc, sizeof(cpi->common.fc));
    vpx_memcpy(&cpi->common.lfc_a, &cpi->common.fc, sizeof(cpi->common.fc));

280 281 282 283 284 285
    /*
    vpx_memcpy( cpi->common.fc.vp8_mode_contexts,
                cpi->common.fc.mode_context,
                sizeof(cpi->common.fc.mode_context));
                */
    vpx_memcpy( cpi->common.fc.vp8_mode_contexts,
286 287
                default_vp8_mode_contexts,
                sizeof(default_vp8_mode_contexts));
288

John Koleszar's avatar
John Koleszar committed
289
}
290 291
void vp8_setup_inter_frame(VP8_COMP *cpi)
{
Yaowu Xu's avatar
Yaowu Xu committed
292

293
    cpi->common.txfm_mode = ALLOW_8X8;
294

295
    if(cpi->common.refresh_alt_ref_frame)
296 297 298 299
    {
        vpx_memcpy( &cpi->common.fc,
                    &cpi->common.lfc_a,
                    sizeof(cpi->common.fc));
300 301 302
        vpx_memcpy( cpi->common.fc.vp8_mode_contexts,
                    cpi->common.fc.mode_context_a,
                    sizeof(cpi->common.fc.vp8_mode_contexts));
303
    }
304
    else
305 306 307 308
    {
        vpx_memcpy( &cpi->common.fc,
                    &cpi->common.lfc,
                    sizeof(cpi->common.fc));
309 310 311
        vpx_memcpy( cpi->common.fc.vp8_mode_contexts,
                    cpi->common.fc.mode_context,
                    sizeof(cpi->common.fc.vp8_mode_contexts));
312
    }
313
}
John Koleszar's avatar
John Koleszar committed
314

315

316 317 318
static int estimate_bits_at_q(int frame_kind, int Q, int MBs,
                              double correction_factor)
{
Paul Wilkins's avatar
Paul Wilkins committed
319
    int Bpm = (int)(.5 + correction_factor * vp8_bits_per_mb(frame_kind, Q));
320 321 322 323 324 325 326 327 328 329

    /* Attempt to retain reasonable accuracy without overflow. The cutoff is
     * chosen such that the maximum product of Bpm and MBs fits 31 bits. The
     * largest Bpm takes 20 bits.
     */
    if (MBs > (1 << 11))
        return (Bpm >> BPER_MB_NORMBITS) * MBs;
    else
        return (Bpm * MBs) >> BPER_MB_NORMBITS;
}
330 331


332
static void calc_iframe_target_size(VP8_COMP *cpi)
John Koleszar's avatar
John Koleszar committed
333 334
{
    // boost defaults to half second
335
    int target;
John Koleszar's avatar
John Koleszar committed
336 337 338 339

    // Clear down mmx registers to allow floating point in what follows
    vp8_clear_system_state();  //__asm emms;

340 341
    // New Two pass RC
    target = cpi->per_frame_bandwidth;
John Koleszar's avatar
John Koleszar committed
342

343
    if (cpi->oxcf.rc_max_intra_bitrate_pct)
John Koleszar's avatar
John Koleszar committed
344
    {
345 346
        unsigned int max_rate = cpi->per_frame_bandwidth
                                * cpi->oxcf.rc_max_intra_bitrate_pct / 100;
John Koleszar's avatar
John Koleszar committed
347

348 349
        if (target > max_rate)
            target = max_rate;
John Koleszar's avatar
John Koleszar committed
350 351
    }

352 353
    cpi->this_frame_target = target;

John Koleszar's avatar
John Koleszar committed
354 355
}

356

Paul Wilkins's avatar
Paul Wilkins committed
357 358
//  Do the best we can to define the parameteres for the next GF based
//  on what information we have available.
359 360 361
//
//  In this experimental code only two pass is supported
//  so we just use the interval determined in the two pass code.
John Koleszar's avatar
John Koleszar committed
362 363
static void calc_gf_params(VP8_COMP *cpi)
{
Paul Wilkins's avatar
Paul Wilkins committed
364 365
    // Set the gf interval
    cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
John Koleszar's avatar
John Koleszar committed
366 367 368
}


369
static void calc_pframe_target_size(VP8_COMP *cpi)
John Koleszar's avatar
John Koleszar committed
370
{
371
    int min_frame_target;
John Koleszar's avatar
John Koleszar committed
372

373
    min_frame_target = 0;
John Koleszar's avatar
John Koleszar committed
374

Paul Wilkins's avatar
Paul Wilkins committed
375
    min_frame_target = cpi->min_frame_bandwidth;
John Koleszar's avatar
John Koleszar committed
376

Paul Wilkins's avatar
Paul Wilkins committed
377 378
    if (min_frame_target < (cpi->av_per_frame_bandwidth >> 5))
        min_frame_target = cpi->av_per_frame_bandwidth >> 5;
379

John Koleszar's avatar
John Koleszar committed
380 381 382 383

    // Special alt reference frame case
    if (cpi->common.refresh_alt_ref_frame)
    {
Paul Wilkins's avatar
Paul Wilkins committed
384 385 386
        // Per frame bit target for the alt ref frame
        cpi->per_frame_bandwidth = cpi->twopass.gf_bits;
        cpi->this_frame_target = cpi->per_frame_bandwidth;
John Koleszar's avatar
John Koleszar committed
387 388 389 390 391
    }

    // Normal frames (gf,and inter)
    else
    {
Paul Wilkins's avatar
Paul Wilkins committed
392
        cpi->this_frame_target = cpi->per_frame_bandwidth;
John Koleszar's avatar
John Koleszar committed
393 394 395 396 397 398 399 400 401 402 403 404 405 406 407
    }

    // Sanity check that the total sum of adjustments is not above the maximum allowed
    // That is that having allowed for KF and GF penalties we have not pushed the
    // current interframe target to low. If the adjustment we apply here is not capable of recovering
    // all the extra bits we have spent in the KF or GF then the remainder will have to be recovered over
    // a longer time span via other buffer / rate control mechanisms.
    if (cpi->this_frame_target < min_frame_target)
        cpi->this_frame_target = min_frame_target;

    if (!cpi->common.refresh_alt_ref_frame)
        // Note the baseline target data rate for this inter frame.
        cpi->inter_frame_target = cpi->this_frame_target;

    // Adjust target frame size for Golden Frames:
Paul Wilkins's avatar
Paul Wilkins committed
408
    if ( cpi->frames_till_gf_update_due == 0 )
John Koleszar's avatar
John Koleszar committed
409 410 411 412
    {
        //int Boost = 0;
        int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;

413
        cpi->common.refresh_golden_frame = TRUE;
John Koleszar's avatar
John Koleszar committed
414

415
        calc_gf_params(cpi);
John Koleszar's avatar
John Koleszar committed
416

417 418 419 420
        // If we are using alternate ref instead of gf then do not apply the boost
        // It will instead be applied to the altref update
        // Jims modified boost
        if (!cpi->source_alt_ref_active)
John Koleszar's avatar
John Koleszar committed
421
        {
422
            if (cpi->oxcf.fixed_q < 0)
John Koleszar's avatar
John Koleszar committed
423
            {
424 425 426
                // The spend on the GF is defined in the two pass code
                // for two pass encodes
                cpi->this_frame_target = cpi->per_frame_bandwidth;
John Koleszar's avatar
John Koleszar committed
427
            }
428
            else
429 430 431
                cpi->this_frame_target =
                    (estimate_bits_at_q(1, Q, cpi->common.MBs, 1.0)
                     * cpi->last_boost) / 100;
John Koleszar's avatar
John Koleszar committed
432 433

        }
434 435 436 437 438 439 440 441 442 443
        // If there is an active ARF at this location use the minimum
        // bits on this frame even if it is a contructed arf.
        // The active maximum quantizer insures that an appropriate
        // number of bits will be spent if needed for contstructed ARFs.
        else
        {
            cpi->this_frame_target = 0;
        }

        cpi->current_gf_interval = cpi->frames_till_gf_update_due;
John Koleszar's avatar
John Koleszar committed
444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473
    }
}


void vp8_update_rate_correction_factors(VP8_COMP *cpi, int damp_var)
{
    int    Q = cpi->common.base_qindex;
    int    correction_factor = 100;
    double rate_correction_factor;
    double adjustment_limit;

    int    projected_size_based_on_q = 0;

    // Clear down mmx registers to allow floating point in what follows
    vp8_clear_system_state();  //__asm emms;

    if (cpi->common.frame_type == KEY_FRAME)
    {
        rate_correction_factor = cpi->key_frame_rate_correction_factor;
    }
    else
    {
        if (cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame)
            rate_correction_factor = cpi->gf_rate_correction_factor;
        else
            rate_correction_factor = cpi->rate_correction_factor;
    }

    // Work out how big we would have expected the frame to be at this Q given the current correction factor.
    // Stay in double to avoid int overflow when values are large
Paul Wilkins's avatar
Paul Wilkins committed
474 475 476 477
    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));
John Koleszar's avatar
John Koleszar committed
478 479 480 481 482 483 484 485 486 487 488

    // Make some allowance for cpi->zbin_over_quant
    if (cpi->zbin_over_quant > 0)
    {
        int Z = cpi->zbin_over_quant;
        double Factor = 0.99;
        double factor_adjustment = 0.01 / 256.0; //(double)ZBIN_OQ_MAX;

        while (Z > 0)
        {
            Z --;
489 490
            projected_size_based_on_q =
                (int)(Factor * projected_size_based_on_q);
John Koleszar's avatar
John Koleszar committed
491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557
            Factor += factor_adjustment;

            if (Factor  >= 0.999)
                Factor = 0.999;
        }
    }

    // Work out a size correction factor.
    //if ( cpi->this_frame_target > 0 )
    //  correction_factor = (100 * cpi->projected_frame_size) / cpi->this_frame_target;
    if (projected_size_based_on_q > 0)
        correction_factor = (100 * cpi->projected_frame_size) / projected_size_based_on_q;

    // More heavily damped adjustment used if we have been oscillating either side of target
    switch (damp_var)
    {
    case 0:
        adjustment_limit = 0.75;
        break;
    case 1:
        adjustment_limit = 0.375;
        break;
    case 2:
    default:
        adjustment_limit = 0.25;
        break;
    }

    //if ( (correction_factor > 102) && (Q < cpi->active_worst_quality) )
    if (correction_factor > 102)
    {
        // We are not already at the worst allowable quality
        correction_factor = (int)(100.5 + ((correction_factor - 100) * adjustment_limit));
        rate_correction_factor = ((rate_correction_factor * correction_factor) / 100);

        // Keep rate_correction_factor within limits
        if (rate_correction_factor > MAX_BPB_FACTOR)
            rate_correction_factor = MAX_BPB_FACTOR;
    }
    //else if ( (correction_factor < 99) && (Q > cpi->active_best_quality) )
    else if (correction_factor < 99)
    {
        // We are not already at the best allowable quality
        correction_factor = (int)(100.5 - ((100 - correction_factor) * adjustment_limit));
        rate_correction_factor = ((rate_correction_factor * correction_factor) / 100);

        // Keep rate_correction_factor within limits
        if (rate_correction_factor < MIN_BPB_FACTOR)
            rate_correction_factor = MIN_BPB_FACTOR;
    }

    if (cpi->common.frame_type == KEY_FRAME)
        cpi->key_frame_rate_correction_factor = rate_correction_factor;
    else
    {
        if (cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame)
            cpi->gf_rate_correction_factor = rate_correction_factor;
        else
            cpi->rate_correction_factor = rate_correction_factor;
    }
}


int vp8_regulate_q(VP8_COMP *cpi, int target_bits_per_frame)
{
    int Q = cpi->active_worst_quality;

558 559 560 561 562 563
    int i;
    int last_error = INT_MAX;
    int target_bits_per_mb;
    int bits_per_mb_at_this_q;
    double correction_factor;

John Koleszar's avatar
John Koleszar committed
564 565 566
    // Reset Zbin OQ value
    cpi->zbin_over_quant = 0;

567 568 569
    // Select the appropriate correction factor based upon type of frame.
    if (cpi->common.frame_type == KEY_FRAME)
        correction_factor = cpi->key_frame_rate_correction_factor;
John Koleszar's avatar
John Koleszar committed
570 571
    else
    {
572 573
        if (cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame)
            correction_factor = cpi->gf_rate_correction_factor;
John Koleszar's avatar
John Koleszar committed
574
        else
575 576
            correction_factor = cpi->rate_correction_factor;
    }
John Koleszar's avatar
John Koleszar committed
577

578 579 580 581 582
    // Calculate required scaling factor based on target frame size and size of frame produced using previous Q
    if (target_bits_per_frame >= (INT_MAX >> BPER_MB_NORMBITS))
        target_bits_per_mb = (target_bits_per_frame / cpi->common.MBs) << BPER_MB_NORMBITS;       // Case where we would overflow int
    else
        target_bits_per_mb = (target_bits_per_frame << BPER_MB_NORMBITS) / cpi->common.MBs;
John Koleszar's avatar
John Koleszar committed
583

584
    i = cpi->active_best_quality;
John Koleszar's avatar
John Koleszar committed
585

586 587 588 589 590
    do
    {
        bits_per_mb_at_this_q =
            (int)(.5 + correction_factor *
                       vp8_bits_per_mb(cpi->common.frame_type, i ));
John Koleszar's avatar
John Koleszar committed
591

592
        if (bits_per_mb_at_this_q <= target_bits_per_mb)
John Koleszar's avatar
John Koleszar committed
593
        {
594 595
            if ((target_bits_per_mb - bits_per_mb_at_this_q) <= last_error)
                Q = i;
John Koleszar's avatar
John Koleszar committed
596
            else
597
                Q = i - 1;
John Koleszar's avatar
John Koleszar committed
598

599 600 601 602 603 604
            break;
        }
        else
            last_error = bits_per_mb_at_this_q - target_bits_per_mb;
    }
    while (++i <= cpi->active_worst_quality);
John Koleszar's avatar
John Koleszar committed
605 606


607 608 609 610 611
    // If we are at MAXQ then enable Q over-run which seeks to claw back additional bits through things like
    // the RD multiplier and zero bin size.
    if (Q >= MAXQ)
    {
        int zbin_oqmax;
John Koleszar's avatar
John Koleszar committed
612

613 614
        double Factor = 0.99;
        double factor_adjustment = 0.01 / 256.0; //(double)ZBIN_OQ_MAX;
John Koleszar's avatar
John Koleszar committed
615

616 617 618 619 620 621
        if (cpi->common.frame_type == KEY_FRAME)
            zbin_oqmax = 0; //ZBIN_OQ_MAX/16
        else if (cpi->common.refresh_alt_ref_frame || (cpi->common.refresh_golden_frame && !cpi->source_alt_ref_active))
            zbin_oqmax = 16;
        else
            zbin_oqmax = ZBIN_OQ_MAX;
John Koleszar's avatar
John Koleszar committed
622

623 624 625 626 627 628 629
        // Each incrment in the zbin is assumed to have a fixed effect on bitrate. This is not of course true.
        // The effect will be highly clip dependent and may well have sudden steps.
        // The idea here is to acheive higher effective quantizers than the normal maximum by expanding the zero
        // bin and hence decreasing the number of low magnitude non zero coefficients.
        while (cpi->zbin_over_quant < zbin_oqmax)
        {
            cpi->zbin_over_quant ++;
John Koleszar's avatar
John Koleszar committed
630

631 632
            if (cpi->zbin_over_quant > zbin_oqmax)
                cpi->zbin_over_quant = zbin_oqmax;
John Koleszar's avatar
John Koleszar committed
633

634 635 636
            // Adjust bits_per_mb_at_this_q estimate
            bits_per_mb_at_this_q = (int)(Factor * bits_per_mb_at_this_q);
            Factor += factor_adjustment;
John Koleszar's avatar
John Koleszar committed
637

638 639
            if (Factor  >= 0.999)
                Factor = 0.999;
John Koleszar's avatar
John Koleszar committed
640

641 642
            if (bits_per_mb_at_this_q <= target_bits_per_mb)    // Break out if we get down to the target rate
                break;
John Koleszar's avatar
John Koleszar committed
643
        }
644

John Koleszar's avatar
John Koleszar committed
645 646 647 648 649
    }

    return Q;
}

650 651

static int estimate_keyframe_frequency(VP8_COMP *cpi)
John Koleszar's avatar
John Koleszar committed
652 653 654
{
    int i;

655 656
    // Average key frame frequency
    int av_key_frame_frequency = 0;
John Koleszar's avatar
John Koleszar committed
657

658 659 660
    /* First key frame at start of sequence is a special case. We have no
     * frequency data.
     */
John Koleszar's avatar
John Koleszar committed
661 662
    if (cpi->key_frame_count == 1)
    {
663 664 665
        /* Assume a default of 1 kf every 2 seconds, or the max kf interval,
         * whichever is smaller.
         */
666
        int key_freq = cpi->oxcf.key_freq>0 ? cpi->oxcf.key_freq : 1;
667
        av_key_frame_frequency = (int)cpi->output_frame_rate * 2;
668 669

        if (cpi->oxcf.auto_key && av_key_frame_frequency > key_freq)
670 671 672 673
            av_key_frame_frequency = cpi->oxcf.key_freq;

        cpi->prior_key_frame_distance[KEY_FRAME_CONTEXT - 1]
            = av_key_frame_frequency;
John Koleszar's avatar
John Koleszar committed
674 675 676
    }
    else
    {
677
        unsigned int total_weight = 0;
678 679 680
        int last_kf_interval =
                (cpi->frames_since_key > 0) ? cpi->frames_since_key : 1;

681 682 683
        /* reset keyframe context and calculate weighted average of last
         * KEY_FRAME_CONTEXT keyframes
         */
John Koleszar's avatar
John Koleszar committed
684 685 686
        for (i = 0; i < KEY_FRAME_CONTEXT; i++)
        {
            if (i < KEY_FRAME_CONTEXT - 1)
687 688
                cpi->prior_key_frame_distance[i]
                    = cpi->prior_key_frame_distance[i+1];
John Koleszar's avatar
John Koleszar committed
689
            else
690
                cpi->prior_key_frame_distance[i] = last_kf_interval;
John Koleszar's avatar
John Koleszar committed
691

692 693 694
            av_key_frame_frequency += prior_key_frame_weight[i]
                                      * cpi->prior_key_frame_distance[i];
            total_weight += prior_key_frame_weight[i];
John Koleszar's avatar
John Koleszar committed
695 696 697 698 699
        }

        av_key_frame_frequency  /= total_weight;

    }
700 701 702 703 704 705 706 707
    return av_key_frame_frequency;
}


void vp8_adjust_key_frame_context(VP8_COMP *cpi)
{
    // Clear down mmx registers to allow floating point in what follows
    vp8_clear_system_state();
John Koleszar's avatar
John Koleszar committed
708 709 710 711 712

    cpi->frames_since_key = 0;
    cpi->key_frame_count++;
}

713

John Koleszar's avatar
John Koleszar committed
714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738
void vp8_compute_frame_size_bounds(VP8_COMP *cpi, int *frame_under_shoot_limit, int *frame_over_shoot_limit)
{
    // Set-up bounds on acceptable frame size:
    if (cpi->oxcf.fixed_q >= 0)
    {
        // Fixed Q scenario: frame size never outranges target (there is no target!)
        *frame_under_shoot_limit = 0;
        *frame_over_shoot_limit  = INT_MAX;
    }
    else
    {
        if (cpi->common.frame_type == KEY_FRAME)
        {
            *frame_over_shoot_limit  = cpi->this_frame_target * 9 / 8;
            *frame_under_shoot_limit = cpi->this_frame_target * 7 / 8;
        }
        else
        {
            if (cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame)
            {
                *frame_over_shoot_limit  = cpi->this_frame_target * 9 / 8;
                *frame_under_shoot_limit = cpi->this_frame_target * 7 / 8;
            }
            else
            {
739 740
                // Stron overshoot limit for constrained quality
                if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY)
John Koleszar's avatar
John Koleszar committed
741
                {
742 743
                    *frame_over_shoot_limit  = cpi->this_frame_target * 11 / 8;
                    *frame_under_shoot_limit = cpi->this_frame_target * 2 / 8;
John Koleszar's avatar
John Koleszar committed
744 745 746
                }
                else
                {
747 748
                    *frame_over_shoot_limit  = cpi->this_frame_target * 11 / 8;
                    *frame_under_shoot_limit = cpi->this_frame_target * 5 / 8;
John Koleszar's avatar
John Koleszar committed
749 750 751
                }
            }
        }
752 753 754 755 756 757 758 759

        // For very small rate targets where the fractional adjustment
        // (eg * 7/8) may be tiny make sure there is at least a minimum
        // range.
        *frame_over_shoot_limit += 200;
        *frame_under_shoot_limit -= 200;
        if ( *frame_under_shoot_limit < 0 )
            *frame_under_shoot_limit = 0;
John Koleszar's avatar
John Koleszar committed
760 761
    }
}
762 763 764 765 766 767 768


// return of 0 means drop frame
int vp8_pick_frame_size(VP8_COMP *cpi)
{
    VP8_COMMON *cm = &cpi->common;

769
    if (cm->frame_type == KEY_FRAME)
770 771 772 773 774 775
        calc_iframe_target_size(cpi);
    else
        calc_pframe_target_size(cpi);

    return 1;
}