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