ratectrl.c 54 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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include "encodemv.h"


#define MIN_BPB_FACTOR          0.01
#define MAX_BPB_FACTOR          50

extern const MB_PREDICTION_MODE vp8_mode_order[MAX_MODES];



#ifdef MODE_STATS
extern int y_modes[5];
extern int uv_modes[4];
extern int b_modes[10];

extern int inter_y_modes[10];
extern int inter_uv_modes[4];
extern int inter_b_modes[10];
#endif

John Koleszar's avatar
John Koleszar committed
44
/* Bits Per MB at different Q (Multiplied by 512) */
John Koleszar's avatar
John Koleszar committed
45
46
#define BPER_MB_NORMBITS    9

John Koleszar's avatar
John Koleszar committed
47
48
49
50
/* Work in progress recalibration of baseline rate tables based on
 * the assumption that bits per mb is inversely proportional to the
 * quantizer value.
 */
John Koleszar's avatar
John Koleszar committed
51
52
const int vp8_bits_per_mb[2][QINDEX_RANGE] =
{
John Koleszar's avatar
John Koleszar committed
53
    /* Intra case 450000/Qintra */
John Koleszar's avatar
John Koleszar committed
54
    {
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
        1125000,900000, 750000, 642857, 562500, 500000, 450000, 450000,
        409090, 375000, 346153, 321428, 300000, 281250, 264705, 264705,
        250000, 236842, 225000, 225000, 214285, 214285, 204545, 204545,
        195652, 195652, 187500, 180000, 180000, 173076, 166666, 160714,
        155172, 150000, 145161, 140625, 136363, 132352, 128571, 125000,
        121621, 121621, 118421, 115384, 112500, 109756, 107142, 104651,
        102272, 100000, 97826,  97826,  95744,  93750,  91836,  90000,
        88235,  86538,  84905,  83333,  81818,  80357,  78947,  77586,
        76271,  75000,  73770,  72580,  71428,  70312,  69230,  68181,
        67164,  66176,  65217,  64285,  63380,  62500,  61643,  60810,
        60000,  59210,  59210,  58441,  57692,  56962,  56250,  55555,
        54878,  54216,  53571,  52941,  52325,  51724,  51136,  50561,
        49450,  48387,  47368,  46875,  45918,  45000,  44554,  44117,
        43269,  42452,  41666,  40909,  40178,  39473,  38793,  38135,
        36885,  36290,  35714,  35156,  34615,  34090,  33582,  33088,
        32608,  32142,  31468,  31034,  30405,  29801,  29220,  28662,
John Koleszar's avatar
John Koleszar committed
71
    },
John Koleszar's avatar
John Koleszar committed
72
    /* Inter case 285000/Qinter */
John Koleszar's avatar
John Koleszar committed
73
    {
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
        712500, 570000, 475000, 407142, 356250, 316666, 285000, 259090,
        237500, 219230, 203571, 190000, 178125, 167647, 158333, 150000,
        142500, 135714, 129545, 123913, 118750, 114000, 109615, 105555,
        101785, 98275,  95000,  91935,  89062,  86363,  83823,  81428,
        79166,  77027,  75000,  73076,  71250,  69512,  67857,  66279,
        64772,  63333,  61956,  60638,  59375,  58163,  57000,  55882,
        54807,  53773,  52777,  51818,  50892,  50000,  49137,  47500,
        45967,  44531,  43181,  41911,  40714,  39583,  38513,  37500,
        36538,  35625,  34756,  33928,  33139,  32386,  31666,  30978,
        30319,  29687,  29081,  28500,  27941,  27403,  26886,  26388,
        25909,  25446,  25000,  24568,  23949,  23360,  22800,  22265,
        21755,  21268,  20802,  20357,  19930,  19520,  19127,  18750,
        18387,  18037,  17701,  17378,  17065,  16764,  16473,  16101,
        15745,  15405,  15079,  14766,  14467,  14179,  13902,  13636,
        13380,  13133,  12895,  12666,  12445,  12179,  11924,  11632,
        11445,  11220,  11003,  10795,  10594,  10401,  10215,  10035,
John Koleszar's avatar
John Koleszar committed
90
91
92
    }
};

93
static const int kf_boost_qadjustment[QINDEX_RANGE] =
John Koleszar's avatar
John Koleszar committed
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
{
    128, 129, 130, 131, 132, 133, 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, 200, 201, 201, 202, 203, 203, 203,
    204, 204, 205, 205, 206, 206, 207, 207,
    208, 208, 209, 209, 210, 210, 211, 211,
    212, 212, 213, 213, 214, 214, 215, 215,
    216, 216, 217, 217, 218, 218, 219, 219,
    220, 220, 220, 220, 220, 220, 220, 220,
    220, 220, 220, 220, 220, 220, 220, 220,
};

John Koleszar's avatar
John Koleszar committed
113
/* #define GFQ_ADJUSTMENT (Q+100) */
John Koleszar's avatar
John Koleszar committed
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
#define GFQ_ADJUSTMENT vp8_gf_boost_qadjustment[Q]
const int vp8_gf_boost_qadjustment[QINDEX_RANGE] =
{
    80, 82, 84, 86, 88, 90, 92, 94,
    96, 97, 98, 99, 100, 101, 102, 103,
    104, 105, 106, 107, 108, 109, 110, 111,
    112, 113, 114, 115, 116, 117, 118, 119,
    120, 121, 122, 123, 124, 125, 126, 127,
    128, 129, 130, 131, 132, 133, 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, 184, 185, 185, 186, 186, 187, 187,
    188, 188, 189, 189, 190, 190, 191, 191,
    192, 192, 193, 193, 194, 194, 194, 194,
    195, 195, 196, 196, 197, 197, 198, 198
};

/*
const int vp8_gf_boost_qadjustment[QINDEX_RANGE] =
{
    100,101,102,103,104,105,105,106,
    106,107,107,108,109,109,110,111,
    112,113,114,115,116,117,118,119,
    120,121,122,123,124,125,126,127,
    128,129,130,131,132,133,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,170,171,171,172,172,
    173,173,173,174,174,174,175,175,
    175,176,176,176,177,177,177,177,
    178,178,179,179,180,180,181,181,
    182,182,183,183,184,184,185,185,
    186,186,187,187,188,188,189,189,
    190,190,191,191,192,192,193,193,
};
*/

157
static const int kf_gf_boost_qlimits[QINDEX_RANGE] =
John Koleszar's avatar
John Koleszar committed
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
{
    150, 155, 160, 165, 170, 175, 180, 185,
    190, 195, 200, 205, 210, 215, 220, 225,
    230, 235, 240, 245, 250, 255, 260, 265,
    270, 275, 280, 285, 290, 295, 300, 305,
    310, 320, 330, 340, 350, 360, 370, 380,
    390, 400, 410, 420, 430, 440, 450, 460,
    470, 480, 490, 500, 510, 520, 530, 540,
    550, 560, 570, 580, 590, 600, 600, 600,
    600, 600, 600, 600, 600, 600, 600, 600,
    600, 600, 600, 600, 600, 600, 600, 600,
    600, 600, 600, 600, 600, 600, 600, 600,
    600, 600, 600, 600, 600, 600, 600, 600,
    600, 600, 600, 600, 600, 600, 600, 600,
    600, 600, 600, 600, 600, 600, 600, 600,
    600, 600, 600, 600, 600, 600, 600, 600,
    600, 600, 600, 600, 600, 600, 600, 600,
};

John Koleszar's avatar
John Koleszar committed
177
/* % adjustment to target kf size based on seperation from previous frame */
178
static const int kf_boost_seperation_adjustment[16] =
John Koleszar's avatar
John Koleszar committed
179
180
181
182
183
184
{
    30,   40,   50,   55,   60,   65,   70,   75,
    80,   85,   90,   95,  100,  100,  100,  100,
};


185
static const int gf_adjust_table[101] =
John Koleszar's avatar
John Koleszar committed
186
187
188
189
190
191
192
193
194
195
196
197
198
199
{
    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,
};

200
static const int gf_intra_usage_adjustment[20] =
John Koleszar's avatar
John Koleszar committed
201
202
203
204
205
{
    125, 120, 115, 110, 105, 100,  95,  85,  80,  75,
    70,  65,  60,  55,  50,  50,  50,  50,  50,  50,
};

206
static const int gf_interval_table[101] =
John Koleszar's avatar
John Koleszar committed
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
{
    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 };


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

John Koleszar's avatar
John Koleszar committed
228
229
230
231
232
    /* 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.
     */
John Koleszar's avatar
John Koleszar committed
233
234
235
236
237
238
239

    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);
240
    vp8_copy(cc->mvcosts,  cpi->rd_costs.mvcosts);
John Koleszar's avatar
John Koleszar committed
241
242
243
244

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

245
246
    vp8_copy(cc->ymode_count, cpi->mb.ymode_count);
    vp8_copy(cc->uv_mode_count, cpi->mb.uv_mode_count);
John Koleszar's avatar
John Koleszar committed
247
248


John Koleszar's avatar
John Koleszar committed
249
    /* Stats */
John Koleszar's avatar
John Koleszar committed
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
#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;

John Koleszar's avatar
John Koleszar committed
267
268
269
    /* Restore key state variables to the snapshot state stored in the
     * previous call to vp8_save_coding_context.
     */
John Koleszar's avatar
John Koleszar committed
270
271
272
273
274
275
276
277

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

278
    vp8_copy(cpi->rd_costs.mvcosts, cc->mvcosts);
John Koleszar's avatar
John Koleszar committed
279
280
281
282

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

283
284
    vp8_copy(cpi->mb.ymode_count, cc->ymode_count);
    vp8_copy(cpi->mb.uv_mode_count, cc->uv_mode_count);
John Koleszar's avatar
John Koleszar committed
285

John Koleszar's avatar
John Koleszar committed
286
    /* Stats */
John Koleszar's avatar
John Koleszar committed
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
#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)
{
John Koleszar's avatar
John Koleszar committed
303
    /* Setup for Key frame: */
John Koleszar's avatar
John Koleszar committed
304
305

    vp8_default_coef_probs(& cpi->common);
306

John Koleszar's avatar
John Koleszar committed
307
308
309
    vpx_memcpy(cpi->common.fc.mvc, vp8_default_mv_context, sizeof(vp8_default_mv_context));
    {
        int flag[2] = {1, 1};
310
        vp8_build_component_cost_table(cpi->mb.mvcost, (const MV_CONTEXT *) cpi->common.fc.mvc, flag);
John Koleszar's avatar
John Koleszar committed
311
312
    }

John Koleszar's avatar
John Koleszar committed
313
314
315
    /* Make sure we initialize separate contexts for altref,gold, and normal.
     * TODO shouldn't need 3 different copies of structure to do this!
     */
316
317
318
319
    vpx_memcpy(&cpi->lfc_a, &cpi->common.fc, sizeof(cpi->common.fc));
    vpx_memcpy(&cpi->lfc_g, &cpi->common.fc, sizeof(cpi->common.fc));
    vpx_memcpy(&cpi->lfc_n, &cpi->common.fc, sizeof(cpi->common.fc));

John Koleszar's avatar
John Koleszar committed
320
321
    cpi->common.filter_level = cpi->common.base_qindex * 3 / 8 ;

John Koleszar's avatar
John Koleszar committed
322
    /* Provisional interval before next GF */
John Koleszar's avatar
John Koleszar committed
323
324
325
    if (cpi->auto_gold)
        cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
    else
Yunqing Wang's avatar
Yunqing Wang committed
326
        cpi->frames_till_gf_update_due = DEFAULT_GF_INTERVAL;
John Koleszar's avatar
John Koleszar committed
327

John Koleszar's avatar
John Koleszar committed
328
329
    cpi->common.refresh_golden_frame = 1;
    cpi->common.refresh_alt_ref_frame = 1;
John Koleszar's avatar
John Koleszar committed
330
331
}

332

333
334
335
336
337
338
339
340
341
342
343
344
345
346
static int estimate_bits_at_q(int frame_kind, int Q, int MBs,
                              double correction_factor)
{
    int Bpm = (int)(.5 + correction_factor * vp8_bits_per_mb[frame_kind][Q]);

    /* 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;
}
347
348


349
static void calc_iframe_target_size(VP8_COMP *cpi)
John Koleszar's avatar
John Koleszar committed
350
{
John Koleszar's avatar
John Koleszar committed
351
    /* boost defaults to half second */
John Koleszar's avatar
John Koleszar committed
352
    int kf_boost;
353
    uint64_t target;
John Koleszar's avatar
John Koleszar committed
354

John Koleszar's avatar
John Koleszar committed
355
356
    /* Clear down mmx registers to allow floating point in what follows */
    vp8_clear_system_state();
John Koleszar's avatar
John Koleszar committed
357
358
359

    if (cpi->oxcf.fixed_q >= 0)
    {
360
        int Q = cpi->oxcf.key_q;
John Koleszar's avatar
John Koleszar committed
361

362
363
364
365
        target = estimate_bits_at_q(INTRA_FRAME, Q, cpi->common.MBs,
                                    cpi->key_frame_rate_correction_factor);
    }
    else if (cpi->pass == 2)
John Koleszar's avatar
John Koleszar committed
366
    {
John Koleszar's avatar
John Koleszar committed
367
        /* New Two pass RC */
368
369
        target = cpi->per_frame_bandwidth;
    }
John Koleszar's avatar
John Koleszar committed
370
    /* First Frame is a special case */
371
372
373
374
375
376
377
378
379
380
    else if (cpi->common.current_video_frame == 0)
    {
        /* 1 Pass there is no information on which to base size so use
         * bandwidth per second * fraction of the initial buffer
         * level
         */
        target = cpi->oxcf.starting_buffer_level / 2;

        if(target > cpi->oxcf.target_bandwidth * 3 / 2)
            target = cpi->oxcf.target_bandwidth * 3 / 2;
John Koleszar's avatar
John Koleszar committed
381
382
383
    }
    else
    {
John Koleszar's avatar
John Koleszar committed
384
        /* if this keyframe was forced, use a more recent Q estimate */
385
386
387
        int Q = (cpi->common.frame_flags & FRAMEFLAGS_KEY)
                ? cpi->avg_frame_qindex : cpi->ni_av_qi;

388
        int initial_boost = 32; /* |3.0 * per_frame_bandwidth| */
John Koleszar's avatar
John Koleszar committed
389
        /* Boost depends somewhat on frame rate: only used for 1 layer case. */
390
        if (cpi->oxcf.number_of_layers == 1) {
391
          kf_boost = MAX(initial_boost, (int)(2 * cpi->output_frame_rate - 16));
392
393
        }
        else {
394
          /* Initial factor: set target size to: |3.0 * per_frame_bandwidth|. */
395
          kf_boost = initial_boost;
396
397
        }

John Koleszar's avatar
John Koleszar committed
398
        /* adjustment up based on q: this factor ranges from ~1.2 to 2.2. */
399
        kf_boost = kf_boost * kf_boost_qadjustment[Q] / 100;
John Koleszar's avatar
John Koleszar committed
400

John Koleszar's avatar
John Koleszar committed
401
        /* frame separation adjustment ( down) */
John Koleszar's avatar
John Koleszar committed
402
        if (cpi->frames_since_key  < cpi->output_frame_rate / 2)
403
404
            kf_boost = (int)(kf_boost
                       * cpi->frames_since_key / (cpi->output_frame_rate / 2));
John Koleszar's avatar
John Koleszar committed
405

John Koleszar's avatar
John Koleszar committed
406
        /* Minimal target size is |2* per_frame_bandwidth|. */
John Koleszar's avatar
John Koleszar committed
407
408
409
        if (kf_boost < 16)
            kf_boost = 16;

410
        target = ((16 + kf_boost) * cpi->per_frame_bandwidth) >> 4;
John Koleszar's avatar
John Koleszar committed
411
412
413
    }


414
    if (cpi->oxcf.rc_max_intra_bitrate_pct)
John Koleszar's avatar
John Koleszar committed
415
    {
416
417
        unsigned int max_rate = cpi->per_frame_bandwidth
                                * cpi->oxcf.rc_max_intra_bitrate_pct / 100;
John Koleszar's avatar
John Koleszar committed
418

419
420
        if (target > max_rate)
            target = max_rate;
John Koleszar's avatar
John Koleszar committed
421
422
    }

423
    cpi->this_frame_target = (int)target;
424

John Koleszar's avatar
John Koleszar committed
425
426
427
    /* TODO: if we separate rate targeting from Q targetting, move this.
     * Reset the active worst quality to the baseline value for key frames.
     */
428
429
    if (cpi->pass != 2)
        cpi->active_worst_quality = cpi->worst_quality;
430
431

#if 0
John Koleszar's avatar
John Koleszar committed
432
433
434
435
436
437
438
439
440
    {
        FILE *f;

        f = fopen("kf_boost.stt", "a");
        fprintf(f, " %8u %10d %10d %10d\n",
                cpi->common.current_video_frame,  cpi->gfu_boost, cpi->baseline_gf_interval, cpi->source_alt_ref_pending);

        fclose(f);
    }
441
#endif
John Koleszar's avatar
John Koleszar committed
442
443
}

444

John Koleszar's avatar
John Koleszar committed
445
446
447
/* Do the best we can to define the parameters for the next GF based on what
 * information we have available.
 */
John Koleszar's avatar
John Koleszar committed
448
449
450
451
452
static void calc_gf_params(VP8_COMP *cpi)
{
    int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;
    int Boost = 0;

John Koleszar's avatar
John Koleszar committed
453
    int gf_frame_useage = 0;      /* Golden frame useage since last GF */
John Koleszar's avatar
John Koleszar committed
454
455
456
457
458
    int tot_mbs = cpi->recent_ref_frame_usage[INTRA_FRAME]  +
                  cpi->recent_ref_frame_usage[LAST_FRAME]   +
                  cpi->recent_ref_frame_usage[GOLDEN_FRAME] +
                  cpi->recent_ref_frame_usage[ALTREF_FRAME];

459
    int pct_gf_active = (100 * cpi->gf_active_count) / (cpi->common.mb_rows * cpi->common.mb_cols);
John Koleszar's avatar
John Koleszar committed
460
461
462
463
464
465
466

    if (tot_mbs)
        gf_frame_useage = (cpi->recent_ref_frame_usage[GOLDEN_FRAME] + cpi->recent_ref_frame_usage[ALTREF_FRAME]) * 100 / tot_mbs;

    if (pct_gf_active > gf_frame_useage)
        gf_frame_useage = pct_gf_active;

John Koleszar's avatar
John Koleszar committed
467
    /* Not two pass */
John Koleszar's avatar
John Koleszar committed
468
469
    if (cpi->pass != 2)
    {
John Koleszar's avatar
John Koleszar committed
470
        /* Single Pass lagged mode: TBD */
John Koleszar's avatar
John Koleszar committed
471
        if (0)
John Koleszar's avatar
John Koleszar committed
472
473
474
        {
        }

John Koleszar's avatar
John Koleszar committed
475
        /* Single Pass compression: Has to use current and historical data */
John Koleszar's avatar
John Koleszar committed
476
477
478
        else
        {
#if 0
John Koleszar's avatar
John Koleszar committed
479
            /* Experimental code */
John Koleszar's avatar
John Koleszar committed
480
481
482
            int index = cpi->one_pass_frame_index;
            int frames_to_scan = (cpi->max_gf_interval <= MAX_LAG_BUFFERS) ? cpi->max_gf_interval : MAX_LAG_BUFFERS;

John Koleszar's avatar
John Koleszar committed
483
            /* ************** Experimental code - incomplete */
John Koleszar's avatar
John Koleszar committed
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
            /*
            double decay_val = 1.0;
            double IIAccumulator = 0.0;
            double last_iiaccumulator = 0.0;
            double IIRatio;

            cpi->one_pass_frame_index = cpi->common.current_video_frame%MAX_LAG_BUFFERS;

            for ( i = 0; i < (frames_to_scan - 1); i++ )
            {
                if ( index < 0 )
                    index = MAX_LAG_BUFFERS;
                index --;

                if ( cpi->one_pass_frame_stats[index].frame_coded_error > 0.0 )
                {
                    IIRatio = cpi->one_pass_frame_stats[index].frame_intra_error / cpi->one_pass_frame_stats[index].frame_coded_error;

                    if ( IIRatio > 30.0 )
                        IIRatio = 30.0;
                }
                else
                    IIRatio = 30.0;

                IIAccumulator += IIRatio * decay_val;

                decay_val = decay_val * cpi->one_pass_frame_stats[index].frame_pcnt_inter;

                if (    (i > MIN_GF_INTERVAL) &&
                        ((IIAccumulator - last_iiaccumulator) < 2.0) )
                {
                    break;
                }
                last_iiaccumulator = IIAccumulator;
            }

            Boost = IIAccumulator*100.0/16.0;
            cpi->baseline_gf_interval = i;

            */
#else

            /*************************************************************/
John Koleszar's avatar
John Koleszar committed
527
            /* OLD code */
John Koleszar's avatar
John Koleszar committed
528

John Koleszar's avatar
John Koleszar committed
529
            /* Adjust boost based upon ambient Q */
John Koleszar's avatar
John Koleszar committed
530
531
            Boost = GFQ_ADJUSTMENT;

John Koleszar's avatar
John Koleszar committed
532
            /* Adjust based upon most recently measure intra useage */
533
            Boost = Boost * gf_intra_usage_adjustment[(cpi->this_frame_percent_intra < 15) ? cpi->this_frame_percent_intra : 14] / 100;
John Koleszar's avatar
John Koleszar committed
534

John Koleszar's avatar
John Koleszar committed
535
            /* Adjust gf boost based upon GF usage since last GF */
536
            Boost = Boost * gf_adjust_table[gf_frame_useage] / 100;
John Koleszar's avatar
John Koleszar committed
537
538
539
#endif
        }

John Koleszar's avatar
John Koleszar committed
540
541
542
        /* golden frame boost without recode loop often goes awry.  be
         * safe by keeping numbers down.
         */
John Koleszar's avatar
John Koleszar committed
543
544
545
546
547
548
        if (!cpi->sf.recode_loop)
        {
            if (cpi->compressor_speed == 2)
                Boost = Boost / 2;
        }

John Koleszar's avatar
John Koleszar committed
549
        /* Apply an upper limit based on Q for 1 pass encodes */
550
551
        if (Boost > kf_gf_boost_qlimits[Q] && (cpi->pass == 0))
            Boost = kf_gf_boost_qlimits[Q];
John Koleszar's avatar
John Koleszar committed
552

John Koleszar's avatar
John Koleszar committed
553
        /* Apply lower limits to boost. */
John Koleszar's avatar
John Koleszar committed
554
555
556
        else if (Boost < 110)
            Boost = 110;

John Koleszar's avatar
John Koleszar committed
557
        /* Note the boost used */
John Koleszar's avatar
John Koleszar committed
558
559
560
561
        cpi->last_boost = Boost;

    }

John Koleszar's avatar
John Koleszar committed
562
563
564
    /* Estimate next interval
     * This is updated once the real frame size/boost is known.
     */
John Koleszar's avatar
John Koleszar committed
565
566
    if (cpi->oxcf.fixed_q == -1)
    {
John Koleszar's avatar
John Koleszar committed
567
        if (cpi->pass == 2)         /* 2 Pass */
John Koleszar's avatar
John Koleszar committed
568
569
570
        {
            cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
        }
John Koleszar's avatar
John Koleszar committed
571
        else                            /* 1 Pass */
John Koleszar's avatar
John Koleszar committed
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
        {
            cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;

            if (cpi->last_boost > 750)
                cpi->frames_till_gf_update_due++;

            if (cpi->last_boost > 1000)
                cpi->frames_till_gf_update_due++;

            if (cpi->last_boost > 1250)
                cpi->frames_till_gf_update_due++;

            if (cpi->last_boost >= 1500)
                cpi->frames_till_gf_update_due ++;

587
588
            if (gf_interval_table[gf_frame_useage] > cpi->frames_till_gf_update_due)
                cpi->frames_till_gf_update_due = gf_interval_table[gf_frame_useage];
John Koleszar's avatar
John Koleszar committed
589
590
591
592
593
594
595
596

            if (cpi->frames_till_gf_update_due > cpi->max_gf_interval)
                cpi->frames_till_gf_update_due = cpi->max_gf_interval;
        }
    }
    else
        cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;

John Koleszar's avatar
John Koleszar committed
597
    /* ARF on or off */
John Koleszar's avatar
John Koleszar committed
598
599
    if (cpi->pass != 2)
    {
John Koleszar's avatar
John Koleszar committed
600
        /* For now Alt ref is not allowed except in 2 pass modes. */
John Koleszar's avatar
John Koleszar committed
601
        cpi->source_alt_ref_pending = 0;
John Koleszar's avatar
John Koleszar committed
602
603
604
605

        /*if ( cpi->oxcf.fixed_q == -1)
        {
            if ( cpi->oxcf.play_alternate && (cpi->last_boost > (100 + (AF_THRESH*cpi->frames_till_gf_update_due)) ) )
John Koleszar's avatar
John Koleszar committed
606
                cpi->source_alt_ref_pending = 1;
John Koleszar's avatar
John Koleszar committed
607
            else
John Koleszar's avatar
John Koleszar committed
608
                cpi->source_alt_ref_pending = 0;
John Koleszar's avatar
John Koleszar committed
609
610
611
612
613
        }*/
    }
}


614
static void calc_pframe_target_size(VP8_COMP *cpi)
John Koleszar's avatar
John Koleszar committed
615
{
616
    int min_frame_target;
John Koleszar's avatar
John Koleszar committed
617
    int Adjustment;
618
619
620
621
622
    int old_per_frame_bandwidth = cpi->per_frame_bandwidth;

    if ( cpi->current_layer > 0)
        cpi->per_frame_bandwidth =
            cpi->layer_context[cpi->current_layer].avg_frame_size_for_layer;
John Koleszar's avatar
John Koleszar committed
623

624
    min_frame_target = 0;
John Koleszar's avatar
John Koleszar committed
625
626
627
628
629
630
631
632

    if (cpi->pass == 2)
    {
        min_frame_target = cpi->min_frame_bandwidth;

        if (min_frame_target < (cpi->av_per_frame_bandwidth >> 5))
            min_frame_target = cpi->av_per_frame_bandwidth >> 5;
    }
633
634
635
    else if (min_frame_target < cpi->per_frame_bandwidth / 4)
        min_frame_target = cpi->per_frame_bandwidth / 4;

John Koleszar's avatar
John Koleszar committed
636

John Koleszar's avatar
John Koleszar committed
637
    /* Special alt reference frame case */
638
    if((cpi->common.refresh_alt_ref_frame) && (cpi->oxcf.number_of_layers == 1))
John Koleszar's avatar
John Koleszar committed
639
640
641
    {
        if (cpi->pass == 2)
        {
John Koleszar's avatar
John Koleszar committed
642
643
            /* Per frame bit target for the alt ref frame */
            cpi->per_frame_bandwidth = cpi->twopass.gf_bits;
John Koleszar's avatar
John Koleszar committed
644
645
646
647
648
649
            cpi->this_frame_target = cpi->per_frame_bandwidth;
        }

        /* One Pass ??? TBD */
    }

John Koleszar's avatar
John Koleszar committed
650
    /* Normal frames (gf,and inter) */
John Koleszar's avatar
John Koleszar committed
651
652
    else
    {
John Koleszar's avatar
John Koleszar committed
653
        /* 2 pass */
John Koleszar's avatar
John Koleszar committed
654
655
656
657
        if (cpi->pass == 2)
        {
            cpi->this_frame_target = cpi->per_frame_bandwidth;
        }
John Koleszar's avatar
John Koleszar committed
658
        /* 1 pass */
John Koleszar's avatar
John Koleszar committed
659
660
        else
        {
John Koleszar's avatar
John Koleszar committed
661
662
663
664
            /* Make rate adjustment to recover bits spent in key frame
             * Test to see if the key frame inter data rate correction
             * should still be in force
             */
John Koleszar's avatar
John Koleszar committed
665
666
667
668
669
670
671
672
673
            if (cpi->kf_overspend_bits > 0)
            {
                Adjustment = (cpi->kf_bitrate_adjustment <= cpi->kf_overspend_bits) ? cpi->kf_bitrate_adjustment : cpi->kf_overspend_bits;

                if (Adjustment > (cpi->per_frame_bandwidth - min_frame_target))
                    Adjustment = (cpi->per_frame_bandwidth - min_frame_target);

                cpi->kf_overspend_bits -= Adjustment;

John Koleszar's avatar
John Koleszar committed
674
675
676
677
                /* Calculate an inter frame bandwidth target for the next
                 * few frames designed to recover any extra bits spent on
                 * the key frame.
                 */
John Koleszar's avatar
John Koleszar committed
678
679
680
681
682
683
684
685
                cpi->this_frame_target = cpi->per_frame_bandwidth - Adjustment;

                if (cpi->this_frame_target < min_frame_target)
                    cpi->this_frame_target = min_frame_target;
            }
            else
                cpi->this_frame_target = cpi->per_frame_bandwidth;

John Koleszar's avatar
John Koleszar committed
686
687
688
            /* If appropriate make an adjustment to recover bits spent on a
             * recent GF
             */
John Koleszar's avatar
John Koleszar committed
689
690
691
692
693
694
695
696
697
698
699
            if ((cpi->gf_overspend_bits > 0) && (cpi->this_frame_target > min_frame_target))
            {
                int Adjustment = (cpi->non_gf_bitrate_adjustment <= cpi->gf_overspend_bits) ? cpi->non_gf_bitrate_adjustment : cpi->gf_overspend_bits;

                if (Adjustment > (cpi->this_frame_target - min_frame_target))
                    Adjustment = (cpi->this_frame_target - min_frame_target);

                cpi->gf_overspend_bits -= Adjustment;
                cpi->this_frame_target -= Adjustment;
            }

John Koleszar's avatar
John Koleszar committed
700
            /* Apply small + and - boosts for non gf frames */
John Koleszar's avatar
John Koleszar committed
701
702
703
            if ((cpi->last_boost > 150) && (cpi->frames_till_gf_update_due > 0) &&
                (cpi->current_gf_interval >= (MIN_GF_INTERVAL << 1)))
            {
John Koleszar's avatar
John Koleszar committed
704
                /* % Adjustment limited to the range 1% to 10% */
John Koleszar's avatar
John Koleszar committed
705
706
707
708
709
710
711
                Adjustment = (cpi->last_boost - 100) >> 5;

                if (Adjustment < 1)
                    Adjustment = 1;
                else if (Adjustment > 10)
                    Adjustment = 10;

John Koleszar's avatar
John Koleszar committed
712
                /* Convert to bits */
John Koleszar's avatar
John Koleszar committed
713
714
715
716
717
718
719
720
721
722
723
724
725
                Adjustment = (cpi->this_frame_target * Adjustment) / 100;

                if (Adjustment > (cpi->this_frame_target - min_frame_target))
                    Adjustment = (cpi->this_frame_target - min_frame_target);

                if (cpi->common.frames_since_golden == (cpi->current_gf_interval >> 1))
                    cpi->this_frame_target += ((cpi->current_gf_interval - 1) * Adjustment);
                else
                    cpi->this_frame_target -= Adjustment;
            }
        }
    }

John Koleszar's avatar
John Koleszar committed
726
727
728
729
730
731
732
733
    /* 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.
     */
John Koleszar's avatar
John Koleszar committed
734
735
736
737
    if (cpi->this_frame_target < min_frame_target)
        cpi->this_frame_target = min_frame_target;

    if (!cpi->common.refresh_alt_ref_frame)
John Koleszar's avatar
John Koleszar committed
738
        /* Note the baseline target data rate for this inter frame. */
John Koleszar's avatar
John Koleszar committed
739
740
        cpi->inter_frame_target = cpi->this_frame_target;

John Koleszar's avatar
John Koleszar committed
741
    /* One Pass specific code */
John Koleszar's avatar
John Koleszar committed
742
743
    if (cpi->pass == 0)
    {
John Koleszar's avatar
John Koleszar committed
744
        /* Adapt target frame size with respect to any buffering constraints: */
John Koleszar's avatar
John Koleszar committed
745
746
        if (cpi->buffered_mode)
        {
747
748
            int one_percent_bits = (int)
                (1 + cpi->oxcf.optimal_buffer_level / 100);
John Koleszar's avatar
John Koleszar committed
749

Paul Wilkins's avatar
Paul Wilkins committed
750
751
            if ((cpi->buffer_level < cpi->oxcf.optimal_buffer_level) ||
                (cpi->bits_off_target < cpi->oxcf.optimal_buffer_level))
John Koleszar's avatar
John Koleszar committed
752
753
754
            {
                int percent_low = 0;

John Koleszar's avatar
John Koleszar committed
755
756
757
758
759
760
761
                /* Decide whether or not we need to adjust the frame data
                 * rate target.
                 *
                 * If we are are below the optimal buffer fullness level
                 * and adherence to buffering constraints is important to
                 * the end usage then adjust the per frame target.
                 */
Paul Wilkins's avatar
Paul Wilkins committed
762
763
                if ((cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
                    (cpi->buffer_level < cpi->oxcf.optimal_buffer_level))
John Koleszar's avatar
John Koleszar committed
764
                {
765
766
767
                    percent_low = (int)
                        ((cpi->oxcf.optimal_buffer_level - cpi->buffer_level) /
                        one_percent_bits);
John Koleszar's avatar
John Koleszar committed
768
                }
John Koleszar's avatar
John Koleszar committed
769
                /* Are we overshooting the long term clip data rate... */
John Koleszar's avatar
John Koleszar committed
770
771
                else if (cpi->bits_off_target < 0)
                {
John Koleszar's avatar
John Koleszar committed
772
                    /* Adjust per frame data target downwards to compensate. */
Paul Wilkins's avatar
Paul Wilkins committed
773
774
                    percent_low = (int)(100 * -cpi->bits_off_target /
                                       (cpi->total_byte_count * 8));
John Koleszar's avatar
John Koleszar committed
775
776
                }

777
778
779
780
781
                if (percent_low > cpi->oxcf.under_shoot_pct)
                    percent_low = cpi->oxcf.under_shoot_pct;
                else if (percent_low < 0)
                    percent_low = 0;

John Koleszar's avatar
John Koleszar committed
782
                /* lower the target bandwidth for this frame. */
783
784
                cpi->this_frame_target -=
                        (cpi->this_frame_target * percent_low) / 200;
John Koleszar's avatar
John Koleszar committed
785

John Koleszar's avatar
John Koleszar committed
786
787
788
                /* Are we using allowing control of active_worst_allowed_q
                 * according to buffer level.
                 */
789
                if (cpi->auto_worst_q && cpi->ni_frames > 150)
John Koleszar's avatar
John Koleszar committed
790
                {
791
                    int64_t critical_buffer_level;
John Koleszar's avatar
John Koleszar committed
792

John Koleszar's avatar
John Koleszar committed
793
794
795
796
797
798
                    /* For streaming applications the most important factor is
                     * cpi->buffer_level as this takes into account the
                     * specified short term buffering constraints. However,
                     * hitting the long term clip data rate target is also
                     * important.
                     */
John Koleszar's avatar
John Koleszar committed
799
800
                    if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
                    {
John Koleszar's avatar
John Koleszar committed
801
802
803
                        /* Take the smaller of cpi->buffer_level and
                         * cpi->bits_off_target
                         */
Paul Wilkins's avatar
Paul Wilkins committed
804
805
806
                        critical_buffer_level =
                            (cpi->buffer_level < cpi->bits_off_target)
                            ? cpi->buffer_level : cpi->bits_off_target;
John Koleszar's avatar
John Koleszar committed
807
                    }
John Koleszar's avatar
John Koleszar committed
808
809
810
                    /* For local file playback short term buffering constraints
                     * are less of an issue
                     */
John Koleszar's avatar
John Koleszar committed
811
812
                    else
                    {
John Koleszar's avatar
John Koleszar committed
813
814
815
                        /* Consider only how we are doing for the clip as a
                         * whole
                         */
John Koleszar's avatar
John Koleszar committed
816
817
818
                        critical_buffer_level = cpi->bits_off_target;
                    }

John Koleszar's avatar
John Koleszar committed
819
820
821
                    /* Set the active worst quality based upon the selected
                     * buffer fullness number.
                     */
John Koleszar's avatar
John Koleszar committed
822
823
                    if (critical_buffer_level < cpi->oxcf.optimal_buffer_level)
                    {
Paul Wilkins's avatar
Paul Wilkins committed
824
825
                        if ( critical_buffer_level >
                             (cpi->oxcf.optimal_buffer_level >> 2) )
John Koleszar's avatar
John Koleszar committed
826
                        {
827
                            int64_t qadjustment_range =
Paul Wilkins's avatar
Paul Wilkins committed
828
                                      cpi->worst_quality - cpi->ni_av_qi;
829
                            int64_t above_base =
Paul Wilkins's avatar
Paul Wilkins committed
830
831
832
                                      (critical_buffer_level -
                                       (cpi->oxcf.optimal_buffer_level >> 2));

John Koleszar's avatar
John Koleszar committed
833
834
835
836
837
838
839
                            /* Step active worst quality down from
                             * cpi->ni_av_qi when (critical_buffer_level ==
                             * cpi->optimal_buffer_level) to
                             * cpi->worst_quality when
                             * (critical_buffer_level ==
                             *     cpi->optimal_buffer_level >> 2)
                             */
Paul Wilkins's avatar
Paul Wilkins committed
840
841
                            cpi->active_worst_quality =
                                cpi->worst_quality -
842
                                (int)((qadjustment_range * above_base) /
Paul Wilkins's avatar
Paul Wilkins committed
843
                                 (cpi->oxcf.optimal_buffer_level*3>>2));
John Koleszar's avatar
John Koleszar committed
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
                        }
                        else
                        {
                            cpi->active_worst_quality = cpi->worst_quality;
                        }
                    }
                    else
                    {
                        cpi->active_worst_quality = cpi->ni_av_qi;
                    }
                }
                else
                {
                    cpi->active_worst_quality = cpi->worst_quality;
                }
            }
            else
            {
862
                int percent_high = 0;
John Koleszar's avatar
John Koleszar committed
863

864
865
                if ((cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
                     && (cpi->buffer_level > cpi->oxcf.optimal_buffer_level))
John Koleszar's avatar
John Koleszar committed
866
                {
867
                    percent_high = (int)((cpi->buffer_level
868
                                    - cpi->oxcf.optimal_buffer_level)
869
                                   / one_percent_bits);
870
871
                }
                else if (cpi->bits_off_target > cpi->oxcf.optimal_buffer_level)
John Koleszar's avatar
John Koleszar committed
872
                {
873
874
875
                    percent_high = (int)((100 * cpi->bits_off_target)
                                         / (cpi->total_byte_count * 8));
                }
John Koleszar's avatar
John Koleszar committed
876

877
878
879
880
                if (percent_high > cpi->oxcf.over_shoot_pct)
                    percent_high = cpi->oxcf.over_shoot_pct;
                else if (percent_high < 0)
                    percent_high = 0;
John Koleszar's avatar
John Koleszar committed
881

882
                cpi->this_frame_target += (cpi->this_frame_target *
883
                                          percent_high) / 200;
John Koleszar's avatar
John Koleszar committed
884

John Koleszar's avatar
John Koleszar committed
885
886
887
                /* Are we allowing control of active_worst_allowed_q according
                 * to buffer level.
                 */
888
                if (cpi->auto_worst_q && cpi->ni_frames > 150)
John Koleszar's avatar
John Koleszar committed
889
                {
John Koleszar's avatar
John Koleszar committed
890
891
892
                    /* When using the relaxed buffer model stick to the
                     * user specified value
                     */
John Koleszar's avatar
John Koleszar committed
893
894
895
896
897
898
899
900
                    cpi->active_worst_quality = cpi->ni_av_qi;
                }
                else
                {
                    cpi->active_worst_quality = cpi->worst_quality;
                }
            }

John Koleszar's avatar
John Koleszar committed
901
            /* Set active_best_quality to prevent quality rising too high */
John Koleszar's avatar
John Koleszar committed
902
903
            cpi->active_best_quality = cpi->best_quality;

John Koleszar's avatar
John Koleszar committed
904
            /* Worst quality obviously must not be better than best quality */
John Koleszar's avatar
John Koleszar committed
905
906
907
            if (cpi->active_worst_quality <= cpi->active_best_quality)
                cpi->active_worst_quality = cpi->active_best_quality + 1;

908
909
            if(cpi->active_worst_quality > 127)
                cpi->active_worst_quality = 127;
John Koleszar's avatar
John Koleszar committed
910
        }
John Koleszar's avatar
John Koleszar committed
911
        /* Unbuffered mode (eg. video conferencing) */
John Koleszar's avatar
John Koleszar committed
912
913
        else
        {
John Koleszar's avatar
John Koleszar committed
914
            /* Set the active worst quality */
John Koleszar's avatar
John Koleszar committed
915
916
            cpi->active_worst_quality = cpi->worst_quality;
        }
Paul Wilkins's avatar
Paul Wilkins committed
917

John Koleszar's avatar
John Koleszar committed
918
919
920
921
        /* Special trap for constrained quality mode
         * "active_worst_quality" may never drop below cq level
         * for any frame type.
         */
Paul Wilkins's avatar
Paul Wilkins committed
922
923
924
925
926
        if ( cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY &&
             cpi->active_worst_quality < cpi->cq_target_quality)
        {
            cpi->active_worst_quality = cpi->cq_target_quality;
        }
John Koleszar's avatar
John Koleszar committed
927
928
    }

John Koleszar's avatar
John Koleszar committed
929
930
931
932
933
934
    /* Test to see if we have to drop a frame
     * The auto-drop frame code is only used in buffered mode.
     * In unbufferd mode (eg vide conferencing) the descision to
     * code or drop a frame is made outside the codec in response to real
     * world comms or buffer considerations.
     */
935
    if (cpi->drop_frames_allowed &&
John Koleszar's avatar
John Koleszar committed
936
        (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
John Koleszar's avatar
John Koleszar committed
937
        ((cpi->common.frame_type != KEY_FRAME)))
John Koleszar's avatar
John Koleszar committed
938
    {
John Koleszar's avatar
John Koleszar committed
939
940
941
        /* Check for a buffer underun-crisis in which case we have to drop
         * a frame
         */
John Koleszar's avatar
John Koleszar committed
942
943
944
945
946
947
948
949
950
951
        if ((cpi->buffer_level < 0))
        {
#if 0
            FILE *f = fopen("dec.stt", "a");
            fprintf(f, "%10d %10d %10d %10d ***** BUFFER EMPTY\n",
                    (int) cpi->common.current_video_frame,
                    cpi->decimation_factor, cpi->common.horiz_scale,
                    (cpi->buffer_level * 100) / cpi->oxcf.optimal_buffer_level);
            fclose(f);
#endif
John Koleszar's avatar
John Koleszar committed
952
            cpi->drop_frame = 1;
John Koleszar's avatar
John Koleszar committed
953

John Koleszar's avatar
John Koleszar committed
954
            /* Update the buffer level variable. */
John Koleszar's avatar
John Koleszar committed
955
            cpi->bits_off_target += cpi->av_per_frame_bandwidth;
956
            if (cpi->bits_off_target > cpi->oxcf.maximum_buffer_size)
957
              cpi->bits_off_target = (int)cpi->oxcf.maximum_buffer_size;
John Koleszar's avatar
John Koleszar committed
958
959
960
961
            cpi->buffer_level = cpi->bits_off_target;
        }
    }

John Koleszar's avatar
John Koleszar committed
962
    /* Adjust target frame size for Golden Frames: */
John Koleszar's avatar
John Koleszar committed
963
964
965
966
967
    if (cpi->oxcf.error_resilient_mode == 0 &&
        (cpi->frames_till_gf_update_due == 0) && !cpi->drop_frame)
    {
        int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;

John Koleszar's avatar
John Koleszar committed
968
        int gf_frame_useage = 0;      /* Golden frame useage since last GF */
John Koleszar's avatar
John Koleszar committed
969
970
971
972
973
        int tot_mbs = cpi->recent_ref_frame_usage[INTRA_FRAME]  +
                      cpi->recent_ref_frame_usage[LAST_FRAME]   +
                      cpi->recent_ref_frame_usage[GOLDEN_FRAME] +
                      cpi->recent_ref_frame_usage[ALTREF_FRAME];

974
        int pct_gf_active = (100 * cpi->gf_active_count) / (cpi->common.mb_rows * cpi->common.mb_cols);
John Koleszar's avatar
John Koleszar committed
975
976
977
978
979
980
981

        if (tot_mbs)
            gf_frame_useage = (cpi->recent_ref_frame_usage[GOLDEN_FRAME] + cpi->recent_ref_frame_usage[ALTREF_FRAME]) * 100 / tot_mbs;

        if (pct_gf_active > gf_frame_useage)
            gf_frame_useage = pct_gf_active;

John Koleszar's avatar
John Koleszar committed
982
        /* Is a fixed manual GF frequency being used */
983
        if (cpi->auto_gold)
John Koleszar's avatar
John Koleszar committed
984
        {
John Koleszar's avatar
John Koleszar committed
985
986
987
            /* For one pass throw a GF if recent frame intra useage is
             * low or the GF useage is high
             */
John Koleszar's avatar
John Koleszar committed
988
            if ((cpi->pass == 0) && (cpi->this_frame_percent_intra < 15 || gf_frame_useage >= 5))
John Koleszar's avatar
John Koleszar committed
989
                cpi->common.refresh_golden_frame = 1;
John Koleszar's avatar
John Koleszar committed
990

John Koleszar's avatar
John Koleszar committed
991
            /* Two pass GF descision */
John Koleszar's avatar
John Koleszar committed
992
            else if (cpi->pass == 2)
John Koleszar's avatar
John Koleszar committed
993
                cpi->common.refresh_golden_frame = 1;
John Koleszar's avatar
John Koleszar committed
994
995
996
997
        }

#if 0

John Koleszar's avatar
John Koleszar committed
998
        /* Debug stats */
John Koleszar's avatar
John Koleszar committed
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
        if (0)
        {
            FILE *f;

            f = fopen("gf_useaget.stt", "a");
            fprintf(f, " %8ld %10ld %10ld %10ld %10ld\n",
                    cpi->common.current_video_frame,  cpi->gfu_boost, GFQ_ADJUSTMENT, cpi->gfu_boost, gf_frame_useage);
            fclose(f);
        }

#endif

John Koleszar's avatar
John Koleszar committed
1011
        if (cpi->common.refresh_golden_frame == 1)
John Koleszar's avatar
John Koleszar committed
1012
1013
1014
        {
#if 0

John Koleszar's avatar
John Koleszar committed
1015
            if (0)
John Koleszar's avatar
John Koleszar committed
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
            {
                FILE *f;

                f = fopen("GFexit.stt", "a");
                fprintf(f, "%8ld GF coded\n", cpi->common.current_video_frame);
                fclose(f);
            }

#endif

            if (cpi->auto_adjust_gold_quantizer)
            {
                calc_gf_params(cpi);
            }

John Koleszar's avatar
John Koleszar committed
1031
1032
1033
1034
            /* 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
             */
John Koleszar's avatar
John Koleszar committed
1035
1036
1037
1038
1039
1040
            if (!cpi->source_alt_ref_active)
            {
                if (cpi->oxcf.fixed_q < 0)
                {
                    if (cpi->pass == 2)
                    {
John Koleszar's avatar
John Koleszar committed
1041
1042
1043
1044
                        /* 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
1045
1046
1047
1048
1049
1050
1051
1052
                    }
                    else
                    {
                        int Boost = cpi->last_boost;
                        int frames_in_section = cpi->frames_till_gf_update_due + 1;
                        int allocation_chunks = (frames_in_section * 100) + (Boost - 100);
                        int bits_in_section = cpi->inter_frame_target * frames_in_section;

John Koleszar's avatar
John Koleszar committed
1053
1054
1055
                        /* Normalize Altboost and allocations chunck down to
                         * prevent overflow
                         */
John Koleszar's avatar
John Koleszar committed
1056
1057
1058
1059
1060
1061
                        while (Boost > 1000)
                        {
                            Boost /= 2;
                            allocation_chunks /= 2;
                        }

John Koleszar's avatar
John Koleszar committed
1062
                        /* Avoid loss of precision but avoid overflow */
John Koleszar's avatar
John Koleszar committed
1063
1064
1065
1066
1067
1068
1069
                        if ((bits_in_section >> 7) > allocation_chunks)
                            cpi->this_frame_target = Boost * (bits_in_section / allocation_chunks);
                        else
                            cpi->this_frame_target = (Boost * bits_in_section) / allocation_chunks;
                    }
                }
                else
1070
1071
1072
                    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
1073
1074

            }
John Koleszar's avatar
John Koleszar committed
1075
1076
1077
1078
1079
            /* 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.
             */
1080
            else
John Koleszar's avatar
John Koleszar committed
1081
            {
1082
                cpi->this_frame_target = 0;
John Koleszar's avatar
John Koleszar committed
1083
1084
1085
1086
1087
1088
            }

            cpi->current_gf_interval = cpi->frames_till_gf_update_due;

        }
    }
1089
1090

    cpi->per_frame_bandwidth = old_per_frame_bandwidth;
John Koleszar's avatar
John Koleszar committed
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
}


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;

John Koleszar's avatar
John Koleszar committed
1103
1104
    /* Clear down mmx registers to allow floating point in what follows */
    vp8_clear_system_state();
John Koleszar's avatar
John Koleszar committed
1105
1106
1107
1108
1109
1110
1111

    if (cpi->common.frame_type == KEY_FRAME)
    {
        rate_correction_factor = cpi->key_frame_rate_correction_factor;
    }
    else
    {
1112
1113
1114
        if (cpi->oxcf.number_of_layers == 1 &&
           (cpi->common.refresh_alt_ref_frame ||
            cpi->common.refresh_golden_frame))
John Koleszar's avatar
John Koleszar committed
1115
1116
1117
1118
1119
            rate_correction_factor = cpi->gf_rate_correction_factor;
        else
            rate_correction_factor = cpi->rate_correction_factor;
    }

John Koleszar's avatar
John Koleszar committed
1120
1121
1122
1123
    /* 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
     */
John Koleszar's avatar
John Koleszar committed
1124
1125
    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
1126
    /* Make some allowance for cpi->zbin_over_quant */
1127
    if (cpi->mb.zbin_over_quant > 0)
John Koleszar's avatar
John Koleszar committed
1128
    {
1129
        int Z = cpi->mb.zbin_over_quant;
John Koleszar's avatar
John Koleszar committed
1130
        double Factor = 0.99;
John Koleszar's avatar
John Koleszar committed
1131
        double factor_adjustment = 0.01 / 256.0;
John Koleszar's avatar
John Koleszar committed
1132
1133
1134
1135

        while (Z > 0)
        {
            Z --;
1136
1137
            projected_size_based_on_q =
                (int)(Factor * projected_size_based_on_q);
John Koleszar's avatar
John Koleszar committed
1138
1139
1140
1141
1142
1143
1144
            Factor += factor_adjustment;

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

John Koleszar's avatar
John Koleszar committed
1145
    /* Work out a size correction factor. */
John Koleszar's avatar
John Koleszar committed
1146
1147
1148
    if (projected_size_based_on_q > 0)
        correction_factor = (100 * cpi->projected_frame_size) / projected_size_based_on_q;

John Koleszar's avatar
John Koleszar committed
1149
1150
1151
    /* More heavily damped adjustment used if we have been oscillating
     * either side of target
     */
John Koleszar's avatar
John Koleszar committed
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
    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)
    {
John Koleszar's avatar
John Koleszar committed
1168
        /* We are not already at the worst allowable quality */
John Koleszar's avatar
John Koleszar committed
1169
1170
1171
        correction_factor = (int)(100.5 + ((correction_factor - 100) * adjustment_limit));
        rate_correction_factor = ((rate_correction_factor * correction_factor) / 100);

John Koleszar's avatar
John Koleszar committed
1172
        /* Keep rate_correction_factor within limits */
John Koleszar's avatar
John Koleszar committed
1173
1174
1175
1176
1177
        if (rate_correction_factor > MAX_BPB_FACTOR)
            rate_correction_factor = MAX_BPB_FACTOR;
    }
    else if (correction_factor < 99)
    {
John Koleszar's avatar
John Koleszar committed
1178
        /* We are not already at the best allowable quality */
John Koleszar's avatar
John Koleszar committed
1179
1180
1181
        correction_factor = (int)(100.5 - ((100 - correction_factor) * adjustment_limit));
        rate_correction_factor = ((rate_correction_factor * correction_factor) / 100);

John Koleszar's avatar
John Koleszar committed
1182
        /* Keep rate_correction_factor within limits */
John Koleszar's avatar
John Koleszar committed
1183
1184
1185
1186
1187
1188
1189
1190
        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
    {
1191
1192
1193
        if (cpi->oxcf.number_of_layers == 1 &&
           (cpi->common.refresh_alt_ref_frame ||
            cpi->common.refresh_golden_frame))
John Koleszar's avatar
John Koleszar committed
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
            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;

John Koleszar's avatar
John Koleszar committed
1205
    /* Reset Zbin OQ value */
1206
    cpi->mb.zbin_over_quant = 0;
John Koleszar's avatar
John Koleszar committed
1207
1208
1209
1210
1211
1212
1213
1214
1215

    if (cpi->oxcf.fixed_q >= 0)
    {
        Q = cpi->oxcf.fixed_q;

        if (cpi->common.frame_type == KEY_FRAME)
        {
            Q = cpi->oxcf.key_q;
        }
1216
1217
        else if (cpi->oxcf.number_of_layers == 1 &&
            cpi->common.refresh_alt_ref_frame)
John Koleszar's avatar
John Koleszar committed
1218
1219
1220
        {
            Q = cpi->oxcf.alt_q;
        }
1221
1222
        else if (cpi->oxcf.number_of_layers == 1  &&
            cpi->common.refresh_golden_frame)
John Koleszar's avatar
John Koleszar committed
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
        {
            Q = cpi->oxcf.gold_q;
        }

    }
    else
    {
        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
1236
        /* Select the appropriate correction factor based upon type of frame. */
John Koleszar's avatar
John Koleszar committed
1237
1238
1239
1240
        if (cpi->common.frame_type == KEY_FRAME)
            correction_factor = cpi->key_frame_rate_correction_factor;
        else
        {
1241
1242
1243
            if (cpi->oxcf.number_of_layers == 1 &&
               (cpi->common.refresh_alt_ref_frame ||
                cpi->common.refresh_golden_frame))
John Koleszar's avatar
John Koleszar committed
1244
1245
1246
1247
1248
                correction_factor = cpi->gf_rate_correction_factor;
            else
                correction_factor = cpi->rate_correction_factor;
        }

John Koleszar's avatar
John Koleszar committed
1249
1250
1251
        /* Calculate required scaling factor based on target frame size and
         * size of frame produced using previous Q
         */
John Koleszar's avatar
John Koleszar committed
1252
        if (target_bits_per_frame >= (INT_MAX >> BPER_MB_NORMBITS))
John Koleszar's avatar
John Koleszar committed
1253
1254
            /* Case where we would overflow int */
            target_bits_per_mb = (target_bits_per_frame / cpi->common.MBs) << BPER_MB_NORMBITS;
John Koleszar's avatar
John Koleszar committed
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
        else
            target_bits_per_mb = (target_bits_per_frame << BPER_MB_NORMBITS) / cpi->common.MBs;

        i = cpi->active_best_quality;

        do
        {
            bits_per_mb_at_this_q = (int)(.5 + correction_factor * vp8_bits_per_mb[cpi->common.frame_type][i]);

            if (bits_per_mb_at_this_q <= target_bits_per_mb)
            {
                if ((target_bits_per_mb - bits_per_mb_at_this_q) <= last_error)
                    Q = i;
                else
                    Q = i - 1;

                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
1279
1280
1281
1282
        /* 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.
         */
John Koleszar's avatar
John Koleszar committed
1283
1284
1285
1286
1287
        if (Q >= MAXQ)
        {
            int zbin_oqmax;

            double Factor = 0.99;
John Koleszar's avatar
John Koleszar committed
1288
            double factor_adjustment = 0.01 / 256.0;
John Koleszar's avatar
John Koleszar committed
1289
1290

            if (cpi->common.frame_type == KEY_FRAME)
John Koleszar's avatar
John Koleszar committed
1291
                zbin_oqmax = 0;
1292
1293
1294
1295
            else if (cpi->oxcf.number_of_layers == 1 &&
                (cpi->common.refresh_alt_ref_frame ||
                (cpi->common.refresh_golden_frame &&
                 !cpi->source_alt_ref_active)))
John Koleszar's avatar
John Koleszar committed
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
                zbin_oqmax = 16;
            else
                zbin_oqmax = ZBIN_OQ_MAX;

            /*{
                double Factor = (double)target_bits_per_mb/(double)bits_per_mb_at_this_q;
                double Oq;

                Factor = Factor/1.2683;

                Oq = pow( Factor, (1.0/-0.165) );

                if ( Oq > zbin_oqmax )
                    Oq = zbin_oqmax;

                cpi->zbin_over_quant = (int)Oq;
            }*/