ratectrl.c 23.8 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
25
26
#include "encodemv.h"


27
#define MIN_BPB_FACTOR          0.005
John Koleszar's avatar
John Koleszar committed
28
29
30
31
32
33
34
35
#define MAX_BPB_FACTOR          50

extern const MB_PREDICTION_MODE vp8_mode_order[MAX_MODES];
extern const MV_REFERENCE_FRAME vp8_ref_frame_order[MAX_MODES];



#ifdef MODE_STATS
Yaowu Xu's avatar
Yaowu Xu committed
36
37
extern int y_modes[VP8_YMODES];
extern int uv_modes[VP8_UV_MODES];
38
extern int b_modes[B_MODE_COUNT];
John Koleszar's avatar
John Koleszar committed
39

40
extern int inter_y_modes[MB_MODE_COUNT];
Yaowu Xu's avatar
Yaowu Xu committed
41
extern int inter_uv_modes[VP8_UV_MODES];
42
extern int inter_b_modes[B_MODE_COUNT];
John Koleszar's avatar
John Koleszar committed
43
44
45
46
47
48
#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
49
static const int kf_boost_seperation_adjustment[16] =
John Koleszar's avatar
John Koleszar committed
50
51
52
53
54
{
    30,   40,   50,   55,   60,   65,   70,   75,
    80,   85,   90,   95,  100,  100,  100,  100,
};

55
static const int gf_adjust_table[101] =
John Koleszar's avatar
John Koleszar committed
56
57
58
59
60
61
62
63
64
65
66
67
68
69
{
    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,
};

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

76
static const int gf_interval_table[101] =
John Koleszar's avatar
John Koleszar committed
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
{
    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
93
94
95
96
97
98
99
100
101
102
103
// 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)
    return (double)vp8_ac_yquant( qindex, 0 ) / 4.0;
}

int vp8_gfboost_qadjust( int qindex )
{
104
105
106
107
108
109
110
111
    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
112
113
114
115
}

int kfboost_qadjust( int qindex )
{
116
117
118
119
120
121
122
123
    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
124
125
126
127
128
129
130
131
132
133
}

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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222

void vp8_save_coding_context(VP8_COMP *cpi)
{
    CODING_CONTEXT *const cc = & cpi->coding_context;

    // 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.

    cc->frames_since_key          = cpi->frames_since_key;
    cc->filter_level             = cpi->common.filter_level;
    cc->frames_till_gf_update_due   = cpi->frames_till_gf_update_due;
    cc->frames_since_golden       = cpi->common.frames_since_golden;

    vp8_copy(cc->mvc,      cpi->common.fc.mvc);
    vp8_copy(cc->mvcosts,  cpi->mb.mvcosts);

    vp8_copy(cc->kf_ymode_prob,   cpi->common.kf_ymode_prob);
    vp8_copy(cc->ymode_prob,   cpi->common.fc.ymode_prob);
    vp8_copy(cc->kf_uv_mode_prob,  cpi->common.kf_uv_mode_prob);
    vp8_copy(cc->uv_mode_prob,  cpi->common.fc.uv_mode_prob);

    vp8_copy(cc->ymode_count, cpi->ymode_count);
    vp8_copy(cc->uv_mode_count, cpi->uv_mode_count);


    // 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

    cc->this_frame_percent_intra = cpi->this_frame_percent_intra;
}


void vp8_restore_coding_context(VP8_COMP *cpi)
{
    CODING_CONTEXT *const cc = & cpi->coding_context;

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

    cpi->frames_since_key         =   cc->frames_since_key;
    cpi->common.filter_level     =   cc->filter_level;
    cpi->frames_till_gf_update_due  =   cc->frames_till_gf_update_due;
    cpi->common.frames_since_golden       =   cc->frames_since_golden;

    vp8_copy(cpi->common.fc.mvc, cc->mvc);

    vp8_copy(cpi->mb.mvcosts, cc->mvcosts);
    vp8_copy(cpi->common.kf_ymode_prob,   cc->kf_ymode_prob);
    vp8_copy(cpi->common.fc.ymode_prob,   cc->ymode_prob);
    vp8_copy(cpi->common.kf_uv_mode_prob,  cc->kf_uv_mode_prob);
    vp8_copy(cpi->common.fc.uv_mode_prob,  cc->uv_mode_prob);

    vp8_copy(cpi->ymode_count, cc->ymode_count);
    vp8_copy(cpi->uv_mode_count, cc->uv_mode_count);

    // 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


    cpi->this_frame_percent_intra = cc->this_frame_percent_intra;
}


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);

    vpx_memcpy(cpi->common.fc.mvc, vp8_default_mv_context, sizeof(vp8_default_mv_context));
    {
        int flag[2] = {1, 1};
223
        vp8_build_component_cost_table(cpi->mb.mvcost, (const MV_CONTEXT *) cpi->common.fc.mvc, flag);
John Koleszar's avatar
John Koleszar committed
224
225
226
227
    }

    vpx_memset(cpi->common.fc.pre_mvc, 0, sizeof(cpi->common.fc.pre_mvc));  //initialize pre_mvc to all zero.

228
229
230
231
#if CONFIG_T8X8
    cpi->common.txfm_mode = ONLY_4X4;
#endif

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

235
236
    // interval before next GF
    cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
John Koleszar's avatar
John Koleszar committed
237
238

    cpi->common.refresh_golden_frame = TRUE;
239
    cpi->common.refresh_alt_ref_frame = TRUE;
240
241
242
243

    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));

244
245
246
247
248
249
250
    vp8_init_mode_contexts(&cpi->common);
    vpx_memcpy( cpi->common.vp8_mode_contexts,
                cpi->common.mode_context,
                sizeof(cpi->common.mode_context));
    vpx_memcpy( cpi->common.vp8_mode_contexts,
                default_vp8_mode_contexts,
                sizeof(default_vp8_mode_contexts));
John Koleszar's avatar
John Koleszar committed
251
}
252
253
void vp8_setup_inter_frame(VP8_COMP *cpi)
{
254
255
256
257
258
259
260
#if CONFIG_T8X8
    if(cpi->common.Width * cpi->common.Height > 640*360)
        cpi->common.txfm_mode = ALLOW_8X8;
    else
        cpi->common.txfm_mode = ONLY_4X4;
#endif

261
    if(cpi->common.refresh_alt_ref_frame)
262
263
264
265
266
267
268
269
    {
        vpx_memcpy( &cpi->common.fc,
                    &cpi->common.lfc_a,
                    sizeof(cpi->common.fc));
        vpx_memcpy( cpi->common.vp8_mode_contexts,
                    cpi->common.mode_context_a,
                    sizeof(cpi->common.vp8_mode_contexts));
    }
270
    else
271
272
273
274
275
276
277
278
    {
        vpx_memcpy( &cpi->common.fc,
                    &cpi->common.lfc,
                    sizeof(cpi->common.fc));
        vpx_memcpy( cpi->common.vp8_mode_contexts,
                    cpi->common.mode_context,
                    sizeof(cpi->common.vp8_mode_contexts));
    }
279
}
John Koleszar's avatar
John Koleszar committed
280

281

282
283
284
static int estimate_bits_at_q(int frame_kind, int Q, int MBs,
                              double correction_factor)
{
Paul Wilkins's avatar
Paul Wilkins committed
285
    int Bpm = (int)(.5 + correction_factor * vp8_bits_per_mb(frame_kind, Q));
286
287
288
289
290
291
292
293
294
295

    /* 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;
}
296
297


298
static void calc_iframe_target_size(VP8_COMP *cpi)
John Koleszar's avatar
John Koleszar committed
299
300
301
{
    // boost defaults to half second
    int kf_boost;
302
    int target;
John Koleszar's avatar
John Koleszar committed
303
304
305
306

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

307
308
    // New Two pass RC
    target = cpi->per_frame_bandwidth;
John Koleszar's avatar
John Koleszar committed
309

310
    if (cpi->oxcf.rc_max_intra_bitrate_pct)
John Koleszar's avatar
John Koleszar committed
311
    {
312
313
        unsigned int max_rate = cpi->per_frame_bandwidth
                                * cpi->oxcf.rc_max_intra_bitrate_pct / 100;
John Koleszar's avatar
John Koleszar committed
314

315
316
        if (target > max_rate)
            target = max_rate;
John Koleszar's avatar
John Koleszar committed
317
318
    }

319
320
    cpi->this_frame_target = target;

John Koleszar's avatar
John Koleszar committed
321
322
}

323

Paul Wilkins's avatar
Paul Wilkins committed
324
325
//  Do the best we can to define the parameteres for the next GF based
//  on what information we have available.
326
327
328
//
//  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
329
330
static void calc_gf_params(VP8_COMP *cpi)
{
Paul Wilkins's avatar
Paul Wilkins committed
331
332
    // Set the gf interval
    cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
John Koleszar's avatar
John Koleszar committed
333
334
335
}


336
static void calc_pframe_target_size(VP8_COMP *cpi)
John Koleszar's avatar
John Koleszar committed
337
{
338
    int min_frame_target;
John Koleszar's avatar
John Koleszar committed
339
340
    int Adjustment;

341
    min_frame_target = 0;
John Koleszar's avatar
John Koleszar committed
342

Paul Wilkins's avatar
Paul Wilkins committed
343
    min_frame_target = cpi->min_frame_bandwidth;
John Koleszar's avatar
John Koleszar committed
344

Paul Wilkins's avatar
Paul Wilkins committed
345
346
    if (min_frame_target < (cpi->av_per_frame_bandwidth >> 5))
        min_frame_target = cpi->av_per_frame_bandwidth >> 5;
347

John Koleszar's avatar
John Koleszar committed
348
349
350
351

    // Special alt reference frame case
    if (cpi->common.refresh_alt_ref_frame)
    {
Paul Wilkins's avatar
Paul Wilkins committed
352
353
354
        // 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
355
356
357
358
359
    }

    // Normal frames (gf,and inter)
    else
    {
Paul Wilkins's avatar
Paul Wilkins committed
360
        cpi->this_frame_target = cpi->per_frame_bandwidth;
John Koleszar's avatar
John Koleszar committed
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
    }

    // 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:
376
377
    if ( cpi->oxcf.error_resilient_mode == 0 &&
         (cpi->frames_till_gf_update_due == 0) )
John Koleszar's avatar
John Koleszar committed
378
379
380
381
    {
        //int Boost = 0;
        int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;

382
        cpi->common.refresh_golden_frame = TRUE;
John Koleszar's avatar
John Koleszar committed
383

384
        calc_gf_params(cpi);
John Koleszar's avatar
John Koleszar committed
385

386
387
388
389
        // 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
390
        {
391
            if (cpi->oxcf.fixed_q < 0)
John Koleszar's avatar
John Koleszar committed
392
            {
393
394
395
                // 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
396
            }
397
            else
398
399
400
                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
401
402

        }
403
404
405
406
407
408
409
410
411
412
        // 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
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
    }
}


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
443
444
445
446
    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
447
448
449
450
451
452
453
454
455
456
457

    // 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 --;
458
459
            projected_size_based_on_q =
                (int)(Factor * projected_size_based_on_q);
John Koleszar's avatar
John Koleszar committed
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
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
            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;

527
528
529
530
531
532
    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
533
534
535
    // Reset Zbin OQ value
    cpi->zbin_over_quant = 0;

536
537
538
    // 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
539
540
    else
    {
541
542
        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
543
        else
544
545
            correction_factor = cpi->rate_correction_factor;
    }
John Koleszar's avatar
John Koleszar committed
546

547
548
549
550
551
    // 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
552

553
    i = cpi->active_best_quality;
John Koleszar's avatar
John Koleszar committed
554

555
556
557
558
559
    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
560

561
        if (bits_per_mb_at_this_q <= target_bits_per_mb)
John Koleszar's avatar
John Koleszar committed
562
        {
563
564
            if ((target_bits_per_mb - bits_per_mb_at_this_q) <= last_error)
                Q = i;
John Koleszar's avatar
John Koleszar committed
565
            else
566
                Q = i - 1;
John Koleszar's avatar
John Koleszar committed
567

568
569
570
571
572
573
            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
574
575


576
577
578
579
580
    // 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
581

582
583
        double Factor = 0.99;
        double factor_adjustment = 0.01 / 256.0; //(double)ZBIN_OQ_MAX;
John Koleszar's avatar
John Koleszar committed
584

585
586
587
588
589
590
        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
591

592
593
594
595
596
597
598
        // 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
599

600
601
            if (cpi->zbin_over_quant > zbin_oqmax)
                cpi->zbin_over_quant = zbin_oqmax;
John Koleszar's avatar
John Koleszar committed
602

603
604
605
            // 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
606

607
608
            if (Factor  >= 0.999)
                Factor = 0.999;
John Koleszar's avatar
John Koleszar committed
609

610
611
            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
612
        }
613

John Koleszar's avatar
John Koleszar committed
614
615
616
617
618
    }

    return Q;
}

619
620

static int estimate_keyframe_frequency(VP8_COMP *cpi)
John Koleszar's avatar
John Koleszar committed
621
622
623
{
    int i;

624
625
    // Average key frame frequency
    int av_key_frame_frequency = 0;
John Koleszar's avatar
John Koleszar committed
626

627
628
629
    /* First key frame at start of sequence is a special case. We have no
     * frequency data.
     */
John Koleszar's avatar
John Koleszar committed
630
631
    if (cpi->key_frame_count == 1)
    {
632
633
634
        /* Assume a default of 1 kf every 2 seconds, or the max kf interval,
         * whichever is smaller.
         */
635
        int key_freq = cpi->oxcf.key_freq>0 ? cpi->oxcf.key_freq : 1;
636
        av_key_frame_frequency = (int)cpi->output_frame_rate * 2;
637
638

        if (cpi->oxcf.auto_key && av_key_frame_frequency > key_freq)
639
640
641
642
            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
643
644
645
    }
    else
    {
646
        unsigned int total_weight = 0;
647
648
649
        int last_kf_interval =
                (cpi->frames_since_key > 0) ? cpi->frames_since_key : 1;

650
651
652
        /* reset keyframe context and calculate weighted average of last
         * KEY_FRAME_CONTEXT keyframes
         */
John Koleszar's avatar
John Koleszar committed
653
654
655
        for (i = 0; i < KEY_FRAME_CONTEXT; i++)
        {
            if (i < KEY_FRAME_CONTEXT - 1)
656
657
                cpi->prior_key_frame_distance[i]
                    = cpi->prior_key_frame_distance[i+1];
John Koleszar's avatar
John Koleszar committed
658
            else
659
                cpi->prior_key_frame_distance[i] = last_kf_interval;
John Koleszar's avatar
John Koleszar committed
660

661
662
663
            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
664
665
666
667
668
        }

        av_key_frame_frequency  /= total_weight;

    }
669
670
671
672
673
674
675
676
    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
677
678
679
680
681

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

682

John Koleszar's avatar
John Koleszar committed
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
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
            {
708
709
                // Stron overshoot limit for constrained quality
                if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY)
John Koleszar's avatar
John Koleszar committed
710
                {
711
712
                    *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
713
714
715
                }
                else
                {
716
717
                    *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
718
719
720
                }
            }
        }
721
722
723
724
725
726
727
728

        // 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
729
730
    }
}
731
732
733
734
735
736
737


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

738
    if (cm->frame_type == KEY_FRAME)
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
        calc_iframe_target_size(cpi);
    else
    {
        calc_pframe_target_size(cpi);

        // Check if we're dropping the frame:
        if (cpi->drop_frame)
        {
            cpi->drop_frame = FALSE;
            cpi->drop_count++;
            return 0;
        }
    }
    return 1;
}