8b8e76e643c35370f802620d436307b7b990b590
[x264/x264-sandbox.git] / encoder / ratecontrol.c
1 /*****************************************************************************
2  * ratecontrol.c: ratecontrol
3  *****************************************************************************
4  * Copyright (C) 2005-2015 x264 project
5  *
6  * Authors: Loren Merritt <lorenm@u.washington.edu>
7  *          Michael Niedermayer <michaelni@gmx.at>
8  *          Gabriel Bouvigne <gabriel.bouvigne@joost.com>
9  *          Fiona Glaser <fiona@x264.com>
10  *          Måns Rullgård <mru@mru.ath.cx>
11  *
12  * This program is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU General Public License as published by
14  * the Free Software Foundation; either version 2 of the License, or
15  * (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
25  *
26  * This program is also available under a commercial proprietary license.
27  * For more information, contact us at licensing@x264.com.
28  *****************************************************************************/
29
30 #define _ISOC99_SOURCE
31 #undef NDEBUG // always check asserts, the speed effect is far too small to disable them
32
33 #include "common/common.h"
34 #include "ratecontrol.h"
35 #include "me.h"
36
37 typedef struct
38 {
39     int pict_type;
40     int frame_type;
41     int kept_as_ref;
42     double qscale;
43     int mv_bits;
44     int tex_bits;
45     int misc_bits;
46     uint64_t expected_bits; /*total expected bits up to the current frame (current one excluded)*/
47     double expected_vbv;
48     double new_qscale;
49     int new_qp;
50     int i_count;
51     int p_count;
52     int s_count;
53     float blurred_complexity;
54     char direct_mode;
55     int16_t weight[3][2];
56     int16_t i_weight_denom[2];
57     int refcount[16];
58     int refs;
59     int64_t i_duration;
60     int64_t i_cpb_duration;
61 } ratecontrol_entry_t;
62
63 typedef struct
64 {
65     float coeff_min;
66     float coeff;
67     float count;
68     float decay;
69     float offset;
70 } predictor_t;
71
72 struct x264_ratecontrol_t
73 {
74     /* constants */
75     int b_abr;
76     int b_2pass;
77     int b_vbv;
78     int b_vbv_min_rate;
79     double fps;
80     double bitrate;
81     double rate_tolerance;
82     double qcompress;
83     int nmb;                    /* number of macroblocks in a frame */
84     int qp_constant[3];
85
86     /* current frame */
87     ratecontrol_entry_t *rce;
88     int qp;                     /* qp for current frame */
89     float qpm;                  /* qp for current macroblock: precise float for AQ */
90     float qpa_rc;               /* average of macroblocks' qp before aq */
91     float qpa_rc_prev;
92     int   qpa_aq;               /* average of macroblocks' qp after aq */
93     int   qpa_aq_prev;
94     float qp_novbv;             /* QP for the current frame if 1-pass VBV was disabled. */
95
96     /* VBV stuff */
97     double buffer_size;
98     int64_t buffer_fill_final;
99     int64_t buffer_fill_final_min;
100     double buffer_fill;         /* planned buffer, if all in-progress frames hit their bit budget */
101     double buffer_rate;         /* # of bits added to buffer_fill after each frame */
102     double vbv_max_rate;        /* # of bits added to buffer_fill per second */
103     predictor_t *pred;          /* predict frame size from satd */
104     int single_frame_vbv;
105     float rate_factor_max_increment; /* Don't allow RF above (CRF + this value). */
106
107     /* ABR stuff */
108     int    last_satd;
109     double last_rceq;
110     double cplxr_sum;           /* sum of bits*qscale/rceq */
111     double expected_bits_sum;   /* sum of qscale2bits after rceq, ratefactor, and overflow, only includes finished frames */
112     int64_t filler_bits_sum;    /* sum in bits of finished frames' filler data */
113     double wanted_bits_window;  /* target bitrate * window */
114     double cbr_decay;
115     double short_term_cplxsum;
116     double short_term_cplxcount;
117     double rate_factor_constant;
118     double ip_offset;
119     double pb_offset;
120
121     /* 2pass stuff */
122     FILE *p_stat_file_out;
123     char *psz_stat_file_tmpname;
124     FILE *p_mbtree_stat_file_out;
125     char *psz_mbtree_stat_file_tmpname;
126     char *psz_mbtree_stat_file_name;
127     FILE *p_mbtree_stat_file_in;
128
129     int num_entries;            /* number of ratecontrol_entry_ts */
130     ratecontrol_entry_t *entry; /* FIXME: copy needed data and free this once init is done */
131     double last_qscale;
132     double last_qscale_for[3];  /* last qscale for a specific pict type, used for max_diff & ipb factor stuff */
133     int last_non_b_pict_type;
134     double accum_p_qp;          /* for determining I-frame quant */
135     double accum_p_norm;
136     double last_accum_p_norm;
137     double lmin[3];             /* min qscale by frame type */
138     double lmax[3];
139     double lstep;               /* max change (multiply) in qscale per frame */
140     struct
141     {
142         uint16_t *qp_buffer[2]; /* Global buffers for converting MB-tree quantizer data. */
143         int qpbuf_pos;          /* In order to handle pyramid reordering, QP buffer acts as a stack.
144                                  * This value is the current position (0 or 1). */
145         int src_mb_count;
146
147         /* For rescaling */
148         int rescale_enabled;
149         float *scale_buffer[2]; /* Intermediate buffers */
150         int filtersize[2];      /* filter size (H/V) */
151         float *coeffs[2];
152         int *pos[2];
153         int srcdim[2];          /* Source dimensions (W/H) */
154     } mbtree;
155
156     /* MBRC stuff */
157     float frame_size_estimated; /* Access to this variable must be atomic: double is
158                                  * not atomic on all arches we care about */
159     double frame_size_maximum;  /* Maximum frame size due to MinCR */
160     double frame_size_planned;
161     double slice_size_planned;
162     predictor_t *row_pred;
163     predictor_t row_preds[3][2];
164     predictor_t *pred_b_from_p; /* predict B-frame size from P-frame satd */
165     int bframes;                /* # consecutive B-frames before this P-frame */
166     int bframe_bits;            /* total cost of those frames */
167
168     int i_zones;
169     x264_zone_t *zones;
170     x264_zone_t *prev_zone;
171
172     /* hrd stuff */
173     int initial_cpb_removal_delay;
174     int initial_cpb_removal_delay_offset;
175     double nrt_first_access_unit; /* nominal removal time */
176     double previous_cpb_final_arrival_time;
177     uint64_t hrd_multiply_denom;
178 };
179
180
181 static int parse_zones( x264_t *h );
182 static int init_pass2(x264_t *);
183 static float rate_estimate_qscale( x264_t *h );
184 static int update_vbv( x264_t *h, int bits );
185 static void update_vbv_plan( x264_t *h, int overhead );
186 static float predict_size( predictor_t *p, float q, float var );
187 static void update_predictor( predictor_t *p, float q, float var, float bits );
188
189 #define CMP_OPT_FIRST_PASS( opt, param_val )\
190 {\
191     if( ( p = strstr( opts, opt "=" ) ) && sscanf( p, opt "=%d" , &i ) && param_val != i )\
192     {\
193         x264_log( h, X264_LOG_ERROR, "different " opt " setting than first pass (%d vs %d)\n", param_val, i );\
194         return -1;\
195     }\
196 }
197
198 /* Terminology:
199  * qp = h.264's quantizer
200  * qscale = linearized quantizer = Lagrange multiplier
201  */
202 static inline float qp2qscale( float qp )
203 {
204     return 0.85f * powf( 2.0f, ( qp - (12.0f + QP_BD_OFFSET) ) / 6.0f );
205 }
206 static inline float qscale2qp( float qscale )
207 {
208     return (12.0f + QP_BD_OFFSET) + 6.0f * log2f( qscale/0.85f );
209 }
210
211 /* Texture bitrate is not quite inversely proportional to qscale,
212  * probably due the the changing number of SKIP blocks.
213  * MV bits level off at about qp<=12, because the lambda used
214  * for motion estimation is constant there. */
215 static inline double qscale2bits( ratecontrol_entry_t *rce, double qscale )
216 {
217     if( qscale<0.1 )
218         qscale = 0.1;
219     return (rce->tex_bits + .1) * pow( rce->qscale / qscale, 1.1 )
220            + rce->mv_bits * pow( X264_MAX(rce->qscale, 1) / X264_MAX(qscale, 1), 0.5 )
221            + rce->misc_bits;
222 }
223
224 static ALWAYS_INLINE uint32_t ac_energy_var( uint64_t sum_ssd, int shift, x264_frame_t *frame, int i, int b_store )
225 {
226     uint32_t sum = sum_ssd;
227     uint32_t ssd = sum_ssd >> 32;
228     if( b_store )
229     {
230         frame->i_pixel_sum[i] += sum;
231         frame->i_pixel_ssd[i] += ssd;
232     }
233     return ssd - ((uint64_t)sum * sum >> shift);
234 }
235
236 static ALWAYS_INLINE uint32_t ac_energy_plane( x264_t *h, int mb_x, int mb_y, x264_frame_t *frame, int i, int b_chroma, int b_field, int b_store )
237 {
238     int height = b_chroma ? 16>>CHROMA_V_SHIFT : 16;
239     int stride = frame->i_stride[i];
240     int offset = b_field
241         ? 16 * mb_x + height * (mb_y&~1) * stride + (mb_y&1) * stride
242         : 16 * mb_x + height * mb_y * stride;
243     stride <<= b_field;
244     if( b_chroma )
245     {
246         ALIGNED_ARRAY_16( pixel, pix,[FENC_STRIDE*16] );
247         int chromapix = h->luma2chroma_pixel[PIXEL_16x16];
248         int shift = 7 - CHROMA_V_SHIFT;
249
250         h->mc.load_deinterleave_chroma_fenc( pix, frame->plane[1] + offset, stride, height );
251         return ac_energy_var( h->pixf.var[chromapix]( pix,               FENC_STRIDE ), shift, frame, 1, b_store )
252              + ac_energy_var( h->pixf.var[chromapix]( pix+FENC_STRIDE/2, FENC_STRIDE ), shift, frame, 2, b_store );
253     }
254     else
255         return ac_energy_var( h->pixf.var[PIXEL_16x16]( frame->plane[i] + offset, stride ), 8, frame, i, b_store );
256 }
257
258 // Find the total AC energy of the block in all planes.
259 static NOINLINE uint32_t x264_ac_energy_mb( x264_t *h, int mb_x, int mb_y, x264_frame_t *frame )
260 {
261     /* This function contains annoying hacks because GCC has a habit of reordering emms
262      * and putting it after floating point ops.  As a result, we put the emms at the end of the
263      * function and make sure that its always called before the float math.  Noinline makes
264      * sure no reordering goes on. */
265     uint32_t var;
266     x264_prefetch_fenc( h, frame, mb_x, mb_y );
267     if( h->mb.b_adaptive_mbaff )
268     {
269         /* We don't know the super-MB mode we're going to pick yet, so
270          * simply try both and pick the lower of the two. */
271         uint32_t var_interlaced, var_progressive;
272         var_interlaced   = ac_energy_plane( h, mb_x, mb_y, frame, 0, 0, 1, 1 );
273         var_progressive  = ac_energy_plane( h, mb_x, mb_y, frame, 0, 0, 0, 0 );
274         if( CHROMA444 )
275         {
276             var_interlaced  += ac_energy_plane( h, mb_x, mb_y, frame, 1, 0, 1, 1 );
277             var_progressive += ac_energy_plane( h, mb_x, mb_y, frame, 1, 0, 0, 0 );
278             var_interlaced  += ac_energy_plane( h, mb_x, mb_y, frame, 2, 0, 1, 1 );
279             var_progressive += ac_energy_plane( h, mb_x, mb_y, frame, 2, 0, 0, 0 );
280         }
281         else
282         {
283             var_interlaced  += ac_energy_plane( h, mb_x, mb_y, frame, 1, 1, 1, 1 );
284             var_progressive += ac_energy_plane( h, mb_x, mb_y, frame, 1, 1, 0, 0 );
285         }
286         var = X264_MIN( var_interlaced, var_progressive );
287     }
288     else
289     {
290         var  = ac_energy_plane( h, mb_x, mb_y, frame, 0, 0, PARAM_INTERLACED, 1 );
291         if( CHROMA444 )
292         {
293             var += ac_energy_plane( h, mb_x, mb_y, frame, 1, 0, PARAM_INTERLACED, 1 );
294             var += ac_energy_plane( h, mb_x, mb_y, frame, 2, 0, PARAM_INTERLACED, 1 );
295         }
296         else
297             var += ac_energy_plane( h, mb_x, mb_y, frame, 1, 1, PARAM_INTERLACED, 1 );
298     }
299     x264_emms();
300     return var;
301 }
302
303 void x264_adaptive_quant_frame( x264_t *h, x264_frame_t *frame, float *quant_offsets )
304 {
305     /* Initialize frame stats */
306     for( int i = 0; i < 3; i++ )
307     {
308         frame->i_pixel_sum[i] = 0;
309         frame->i_pixel_ssd[i] = 0;
310     }
311
312     /* Degenerate cases */
313     if( h->param.rc.i_aq_mode == X264_AQ_NONE || h->param.rc.f_aq_strength == 0 )
314     {
315         /* Need to init it anyways for MB tree */
316         if( h->param.rc.i_aq_mode && h->param.rc.f_aq_strength == 0 )
317         {
318             if( quant_offsets )
319             {
320                 for( int mb_xy = 0; mb_xy < h->mb.i_mb_count; mb_xy++ )
321                     frame->f_qp_offset[mb_xy] = frame->f_qp_offset_aq[mb_xy] = quant_offsets[mb_xy];
322                 if( h->frames.b_have_lowres )
323                     for( int mb_xy = 0; mb_xy < h->mb.i_mb_count; mb_xy++ )
324                         frame->i_inv_qscale_factor[mb_xy] = x264_exp2fix8( frame->f_qp_offset[mb_xy] );
325             }
326             else
327             {
328                 memset( frame->f_qp_offset, 0, h->mb.i_mb_count * sizeof(float) );
329                 memset( frame->f_qp_offset_aq, 0, h->mb.i_mb_count * sizeof(float) );
330                 if( h->frames.b_have_lowres )
331                     for( int mb_xy = 0; mb_xy < h->mb.i_mb_count; mb_xy++ )
332                         frame->i_inv_qscale_factor[mb_xy] = 256;
333             }
334         }
335         /* Need variance data for weighted prediction */
336         if( h->param.analyse.i_weighted_pred )
337         {
338             for( int mb_y = 0; mb_y < h->mb.i_mb_height; mb_y++ )
339                 for( int mb_x = 0; mb_x < h->mb.i_mb_width; mb_x++ )
340                     x264_ac_energy_mb( h, mb_x, mb_y, frame );
341         }
342         else
343             return;
344     }
345     /* Actual adaptive quantization */
346     else
347     {
348         /* constants chosen to result in approximately the same overall bitrate as without AQ.
349          * FIXME: while they're written in 5 significant digits, they're only tuned to 2. */
350         float strength;
351         float avg_adj = 0.f;
352         float bias_strength = 0.f;
353
354         if( h->param.rc.i_aq_mode == X264_AQ_AUTOVARIANCE || h->param.rc.i_aq_mode == X264_AQ_AUTOVARIANCE_BIASED )
355         {
356             float bit_depth_correction = 1.f / (1 << (2*(BIT_DEPTH-8)));
357             float avg_adj_pow2 = 0.f;
358             for( int mb_y = 0; mb_y < h->mb.i_mb_height; mb_y++ )
359                 for( int mb_x = 0; mb_x < h->mb.i_mb_width; mb_x++ )
360                 {
361                     uint32_t energy = x264_ac_energy_mb( h, mb_x, mb_y, frame );
362                     float qp_adj = powf( energy * bit_depth_correction + 1, 0.125f );
363                     frame->f_qp_offset[mb_x + mb_y*h->mb.i_mb_stride] = qp_adj;
364                     avg_adj += qp_adj;
365                     avg_adj_pow2 += qp_adj * qp_adj;
366                 }
367             avg_adj /= h->mb.i_mb_count;
368             avg_adj_pow2 /= h->mb.i_mb_count;
369             strength = h->param.rc.f_aq_strength * avg_adj;
370             avg_adj = avg_adj - 0.5f * (avg_adj_pow2 - 14.f) / avg_adj;
371             bias_strength = h->param.rc.f_aq_strength;
372         }
373         else
374             strength = h->param.rc.f_aq_strength * 1.0397f;
375
376         for( int mb_y = 0; mb_y < h->mb.i_mb_height; mb_y++ )
377             for( int mb_x = 0; mb_x < h->mb.i_mb_width; mb_x++ )
378             {
379                 float qp_adj;
380                 int mb_xy = mb_x + mb_y*h->mb.i_mb_stride;
381                 if( h->param.rc.i_aq_mode == X264_AQ_AUTOVARIANCE_BIASED )
382                 {
383                     qp_adj = frame->f_qp_offset[mb_xy];
384                     qp_adj = strength * (qp_adj - avg_adj) + bias_strength * (1.f - 14.f / (qp_adj * qp_adj));
385                 }
386                 else if( h->param.rc.i_aq_mode == X264_AQ_AUTOVARIANCE )
387                 {
388                     qp_adj = frame->f_qp_offset[mb_xy];
389                     qp_adj = strength * (qp_adj - avg_adj);
390                 }
391                 else
392                 {
393                     uint32_t energy = x264_ac_energy_mb( h, mb_x, mb_y, frame );
394                     qp_adj = strength * (x264_log2( X264_MAX(energy, 1) ) - (14.427f + 2*(BIT_DEPTH-8)));
395                 }
396                 if( quant_offsets )
397                     qp_adj += quant_offsets[mb_xy];
398                 frame->f_qp_offset[mb_xy] =
399                 frame->f_qp_offset_aq[mb_xy] = qp_adj;
400                 if( h->frames.b_have_lowres )
401                     frame->i_inv_qscale_factor[mb_xy] = x264_exp2fix8(qp_adj);
402             }
403     }
404
405     /* Remove mean from SSD calculation */
406     for( int i = 0; i < 3; i++ )
407     {
408         uint64_t ssd = frame->i_pixel_ssd[i];
409         uint64_t sum = frame->i_pixel_sum[i];
410         int width  = 16*h->mb.i_mb_width  >> (i && CHROMA_H_SHIFT);
411         int height = 16*h->mb.i_mb_height >> (i && CHROMA_V_SHIFT);
412         frame->i_pixel_ssd[i] = ssd - (sum * sum + width * height / 2) / (width * height);
413     }
414 }
415
416 static int x264_macroblock_tree_rescale_init( x264_t *h, x264_ratecontrol_t *rc )
417 {
418     /* Use fractional QP array dimensions to compensate for edge padding */
419     float srcdim[2] = {rc->mbtree.srcdim[0] / 16.f, rc->mbtree.srcdim[1] / 16.f};
420     float dstdim[2] = {    h->param.i_width / 16.f,    h->param.i_height / 16.f};
421     int srcdimi[2] = {ceil(srcdim[0]), ceil(srcdim[1])};
422     int dstdimi[2] = {ceil(dstdim[0]), ceil(dstdim[1])};
423     if( PARAM_INTERLACED )
424     {
425         srcdimi[1] = (srcdimi[1]+1)&~1;
426         dstdimi[1] = (dstdimi[1]+1)&~1;
427     }
428
429     rc->mbtree.src_mb_count = srcdimi[0] * srcdimi[1];
430
431     CHECKED_MALLOC( rc->mbtree.qp_buffer[0], rc->mbtree.src_mb_count * sizeof(uint16_t) );
432     if( h->param.i_bframe_pyramid && h->param.rc.b_stat_read )
433         CHECKED_MALLOC( rc->mbtree.qp_buffer[1], rc->mbtree.src_mb_count * sizeof(uint16_t) );
434     rc->mbtree.qpbuf_pos = -1;
435
436     /* No rescaling to do */
437     if( srcdimi[0] == dstdimi[0] && srcdimi[1] == dstdimi[1] )
438         return 0;
439
440     rc->mbtree.rescale_enabled = 1;
441
442     /* Allocate intermediate scaling buffers */
443     CHECKED_MALLOC( rc->mbtree.scale_buffer[0], srcdimi[0] * srcdimi[1] * sizeof(float) );
444     CHECKED_MALLOC( rc->mbtree.scale_buffer[1], dstdimi[0] * srcdimi[1] * sizeof(float) );
445
446     /* Allocate and calculate resize filter parameters and coefficients */
447     for( int i = 0; i < 2; i++ )
448     {
449         if( srcdim[i] > dstdim[i] ) // downscale
450             rc->mbtree.filtersize[i] = 1 + (2 * srcdimi[i] + dstdimi[i] - 1) / dstdimi[i];
451         else                        // upscale
452             rc->mbtree.filtersize[i] = 3;
453
454         CHECKED_MALLOC( rc->mbtree.coeffs[i], rc->mbtree.filtersize[i] * dstdimi[i] * sizeof(float) );
455         CHECKED_MALLOC( rc->mbtree.pos[i], dstdimi[i] * sizeof(int) );
456
457         /* Initialize filter coefficients */
458         float inc = srcdim[i] / dstdim[i];
459         float dmul = inc > 1.f ? dstdim[i] / srcdim[i] : 1.f;
460         float dstinsrc = 0.5f * inc - 0.5f;
461         int filtersize = rc->mbtree.filtersize[i];
462         for( int j = 0; j < dstdimi[i]; j++ )
463         {
464             int pos = dstinsrc - (filtersize - 2.f) * 0.5f;
465             float sum = 0.0;
466             rc->mbtree.pos[i][j] = pos;
467             for( int k = 0; k < filtersize; k++ )
468             {
469                 float d = fabs( pos + k - dstinsrc ) * dmul;
470                 float coeff = X264_MAX( 1.f - d, 0 );
471                 rc->mbtree.coeffs[i][j * filtersize + k] = coeff;
472                 sum += coeff;
473             }
474             sum = 1.0f / sum;
475             for( int k = 0; k < filtersize; k++ )
476                 rc->mbtree.coeffs[i][j * filtersize + k] *= sum;
477             dstinsrc += inc;
478         }
479     }
480
481     /* Write back actual qp array dimensions */
482     rc->mbtree.srcdim[0] = srcdimi[0];
483     rc->mbtree.srcdim[1] = srcdimi[1];
484     return 0;
485 fail:
486     return -1;
487 }
488
489 static void x264_macroblock_tree_rescale_destroy( x264_ratecontrol_t *rc )
490 {
491     for( int i = 0; i < 2; i++ )
492     {
493         x264_free( rc->mbtree.qp_buffer[i] );
494         x264_free( rc->mbtree.scale_buffer[i] );
495         x264_free( rc->mbtree.coeffs[i] );
496         x264_free( rc->mbtree.pos[i] );
497     }
498 }
499
500 static ALWAYS_INLINE float tapfilter( float *src, int pos, int max, int stride, float *coeff, int filtersize )
501 {
502     float sum = 0.f;
503     for( int i = 0; i < filtersize; i++, pos++ )
504         sum += src[x264_clip3( pos, 0, max-1 )*stride] * coeff[i];
505     return sum;
506 }
507
508 static void x264_macroblock_tree_rescale( x264_t *h, x264_ratecontrol_t *rc, float *dst )
509 {
510     float *input, *output;
511     int filtersize, stride, height;
512
513     /* H scale first */
514     input = rc->mbtree.scale_buffer[0];
515     output = rc->mbtree.scale_buffer[1];
516     filtersize = rc->mbtree.filtersize[0];
517     stride = rc->mbtree.srcdim[0];
518     height = rc->mbtree.srcdim[1];
519     for( int y = 0; y < height; y++, input += stride, output += h->mb.i_mb_width )
520     {
521         float *coeff = rc->mbtree.coeffs[0];
522         for( int x = 0; x < h->mb.i_mb_width; x++, coeff+=filtersize )
523             output[x] = tapfilter( input, rc->mbtree.pos[0][x], stride, 1, coeff, filtersize );
524     }
525
526     /* V scale next */
527     input = rc->mbtree.scale_buffer[1];
528     output = dst;
529     filtersize = rc->mbtree.filtersize[1];
530     stride = h->mb.i_mb_width;
531     height = rc->mbtree.srcdim[1];
532     for( int x = 0; x < h->mb.i_mb_width; x++, input++, output++ )
533     {
534         float *coeff = rc->mbtree.coeffs[1];
535         for( int y = 0; y < h->mb.i_mb_height; y++, coeff+=filtersize )
536             output[y*stride] = tapfilter( input, rc->mbtree.pos[1][y], height, stride, coeff, filtersize );
537     }
538 }
539
540 int x264_macroblock_tree_read( x264_t *h, x264_frame_t *frame, float *quant_offsets )
541 {
542     x264_ratecontrol_t *rc = h->rc;
543     uint8_t i_type_actual = rc->entry[frame->i_frame].pict_type;
544
545     if( rc->entry[frame->i_frame].kept_as_ref )
546     {
547         uint8_t i_type;
548         if( rc->mbtree.qpbuf_pos < 0 )
549         {
550             do
551             {
552                 rc->mbtree.qpbuf_pos++;
553
554                 if( !fread( &i_type, 1, 1, rc->p_mbtree_stat_file_in ) )
555                     goto fail;
556                 if( fread( rc->mbtree.qp_buffer[rc->mbtree.qpbuf_pos], sizeof(uint16_t), rc->mbtree.src_mb_count, rc->p_mbtree_stat_file_in ) != rc->mbtree.src_mb_count )
557                     goto fail;
558
559                 if( i_type != i_type_actual && rc->mbtree.qpbuf_pos == 1 )
560                 {
561                     x264_log( h, X264_LOG_ERROR, "MB-tree frametype %d doesn't match actual frametype %d.\n", i_type, i_type_actual );
562                     return -1;
563                 }
564             } while( i_type != i_type_actual );
565         }
566
567         float *dst = rc->mbtree.rescale_enabled ? rc->mbtree.scale_buffer[0] : frame->f_qp_offset;
568         for( int i = 0; i < rc->mbtree.src_mb_count; i++ )
569         {
570             int16_t qp_fix8 = endian_fix16( rc->mbtree.qp_buffer[rc->mbtree.qpbuf_pos][i] );
571             dst[i] = qp_fix8 * (1.f/256.f);
572         }
573         if( rc->mbtree.rescale_enabled )
574             x264_macroblock_tree_rescale( h, rc, frame->f_qp_offset );
575         if( h->frames.b_have_lowres )
576             for( int i = 0; i < h->mb.i_mb_count; i++ )
577                 frame->i_inv_qscale_factor[i] = x264_exp2fix8( frame->f_qp_offset[i] );
578         rc->mbtree.qpbuf_pos--;
579     }
580     else
581         x264_stack_align( x264_adaptive_quant_frame, h, frame, quant_offsets );
582     return 0;
583 fail:
584     x264_log( h, X264_LOG_ERROR, "Incomplete MB-tree stats file.\n" );
585     return -1;
586 }
587
588 int x264_reference_build_list_optimal( x264_t *h )
589 {
590     ratecontrol_entry_t *rce = h->rc->rce;
591     x264_frame_t *frames[16];
592     x264_weight_t weights[16][3];
593     int refcount[16];
594
595     if( rce->refs != h->i_ref[0] )
596         return -1;
597
598     memcpy( frames, h->fref[0], sizeof(frames) );
599     memcpy( refcount, rce->refcount, sizeof(refcount) );
600     memcpy( weights, h->fenc->weight, sizeof(weights) );
601     memset( &h->fenc->weight[1][0], 0, sizeof(x264_weight_t[15][3]) );
602
603     /* For now don't reorder ref 0; it seems to lower quality
604        in most cases due to skips. */
605     for( int ref = 1; ref < h->i_ref[0]; ref++ )
606     {
607         int max = -1;
608         int bestref = 1;
609
610         for( int i = 1; i < h->i_ref[0]; i++ )
611             /* Favor lower POC as a tiebreaker. */
612             COPY2_IF_GT( max, refcount[i], bestref, i );
613
614         /* FIXME: If there are duplicates from frames other than ref0 then it is possible
615          * that the optimal ordering doesnt place every duplicate. */
616
617         refcount[bestref] = -1;
618         h->fref[0][ref] = frames[bestref];
619         memcpy( h->fenc->weight[ref], weights[bestref], sizeof(weights[bestref]) );
620     }
621
622     return 0;
623 }
624
625 static char *x264_strcat_filename( char *input, char *suffix )
626 {
627     char *output = x264_malloc( strlen( input ) + strlen( suffix ) + 1 );
628     if( !output )
629         return NULL;
630     strcpy( output, input );
631     strcat( output, suffix );
632     return output;
633 }
634
635 void x264_ratecontrol_init_reconfigurable( x264_t *h, int b_init )
636 {
637     x264_ratecontrol_t *rc = h->rc;
638     if( !b_init && rc->b_2pass )
639         return;
640
641     if( h->param.rc.i_rc_method == X264_RC_CRF )
642     {
643         /* Arbitrary rescaling to make CRF somewhat similar to QP.
644          * Try to compensate for MB-tree's effects as well. */
645         double base_cplx = h->mb.i_mb_count * (h->param.i_bframe ? 120 : 80);
646         double mbtree_offset = h->param.rc.b_mb_tree ? (1.0-h->param.rc.f_qcompress)*13.5 : 0;
647         rc->rate_factor_constant = pow( base_cplx, 1 - rc->qcompress )
648                                  / qp2qscale( h->param.rc.f_rf_constant + mbtree_offset + QP_BD_OFFSET );
649     }
650
651     if( h->param.rc.i_vbv_max_bitrate > 0 && h->param.rc.i_vbv_buffer_size > 0 )
652     {
653         /* We don't support changing the ABR bitrate right now,
654            so if the stream starts as CBR, keep it CBR. */
655         if( rc->b_vbv_min_rate )
656             h->param.rc.i_vbv_max_bitrate = h->param.rc.i_bitrate;
657
658         if( h->param.rc.i_vbv_buffer_size < (int)(h->param.rc.i_vbv_max_bitrate / rc->fps) )
659         {
660             h->param.rc.i_vbv_buffer_size = h->param.rc.i_vbv_max_bitrate / rc->fps;
661             x264_log( h, X264_LOG_WARNING, "VBV buffer size cannot be smaller than one frame, using %d kbit\n",
662                       h->param.rc.i_vbv_buffer_size );
663         }
664
665         int kilobit_size = h->param.i_avcintra_class ? 1024 : 1000;
666         int vbv_buffer_size = h->param.rc.i_vbv_buffer_size * kilobit_size;
667         int vbv_max_bitrate = h->param.rc.i_vbv_max_bitrate * kilobit_size;
668
669         /* Init HRD */
670         if( h->param.i_nal_hrd && b_init )
671         {
672             h->sps->vui.hrd.i_cpb_cnt = 1;
673             h->sps->vui.hrd.b_cbr_hrd = h->param.i_nal_hrd == X264_NAL_HRD_CBR;
674             h->sps->vui.hrd.i_time_offset_length = 0;
675
676             #define BR_SHIFT  6
677             #define CPB_SHIFT 4
678
679             // normalize HRD size and rate to the value / scale notation
680             h->sps->vui.hrd.i_bit_rate_scale = x264_clip3( x264_ctz( vbv_max_bitrate ) - BR_SHIFT, 0, 15 );
681             h->sps->vui.hrd.i_bit_rate_value = vbv_max_bitrate >> ( h->sps->vui.hrd.i_bit_rate_scale + BR_SHIFT );
682             h->sps->vui.hrd.i_bit_rate_unscaled = h->sps->vui.hrd.i_bit_rate_value << ( h->sps->vui.hrd.i_bit_rate_scale + BR_SHIFT );
683             h->sps->vui.hrd.i_cpb_size_scale = x264_clip3( x264_ctz( vbv_buffer_size ) - CPB_SHIFT, 0, 15 );
684             h->sps->vui.hrd.i_cpb_size_value = vbv_buffer_size >> ( h->sps->vui.hrd.i_cpb_size_scale + CPB_SHIFT );
685             h->sps->vui.hrd.i_cpb_size_unscaled = h->sps->vui.hrd.i_cpb_size_value << ( h->sps->vui.hrd.i_cpb_size_scale + CPB_SHIFT );
686
687             #undef CPB_SHIFT
688             #undef BR_SHIFT
689
690             // arbitrary
691             #define MAX_DURATION 0.5
692
693             int max_cpb_output_delay = X264_MIN( h->param.i_keyint_max * MAX_DURATION * h->sps->vui.i_time_scale / h->sps->vui.i_num_units_in_tick, INT_MAX );
694             int max_dpb_output_delay = h->sps->vui.i_max_dec_frame_buffering * MAX_DURATION * h->sps->vui.i_time_scale / h->sps->vui.i_num_units_in_tick;
695             int max_delay = (int)(90000.0 * (double)h->sps->vui.hrd.i_cpb_size_unscaled / h->sps->vui.hrd.i_bit_rate_unscaled + 0.5);
696
697             h->sps->vui.hrd.i_initial_cpb_removal_delay_length = 2 + x264_clip3( 32 - x264_clz( max_delay ), 4, 22 );
698             h->sps->vui.hrd.i_cpb_removal_delay_length = x264_clip3( 32 - x264_clz( max_cpb_output_delay ), 4, 31 );
699             h->sps->vui.hrd.i_dpb_output_delay_length  = x264_clip3( 32 - x264_clz( max_dpb_output_delay ), 4, 31 );
700
701             #undef MAX_DURATION
702
703             vbv_buffer_size = h->sps->vui.hrd.i_cpb_size_unscaled;
704             vbv_max_bitrate = h->sps->vui.hrd.i_bit_rate_unscaled;
705         }
706         else if( h->param.i_nal_hrd && !b_init )
707         {
708             x264_log( h, X264_LOG_WARNING, "VBV parameters cannot be changed when NAL HRD is in use\n" );
709             return;
710         }
711         h->sps->vui.hrd.i_bit_rate_unscaled = vbv_max_bitrate;
712         h->sps->vui.hrd.i_cpb_size_unscaled = vbv_buffer_size;
713
714         if( rc->b_vbv_min_rate )
715             rc->bitrate = (double)h->param.rc.i_bitrate * kilobit_size;
716         rc->buffer_rate = vbv_max_bitrate / rc->fps;
717         rc->vbv_max_rate = vbv_max_bitrate;
718         rc->buffer_size = vbv_buffer_size;
719         rc->single_frame_vbv = rc->buffer_rate * 1.1 > rc->buffer_size;
720         rc->cbr_decay = 1.0 - rc->buffer_rate / rc->buffer_size
721                       * 0.5 * X264_MAX(0, 1.5 - rc->buffer_rate * rc->fps / rc->bitrate);
722         if( h->param.rc.i_rc_method == X264_RC_CRF && h->param.rc.f_rf_constant_max )
723         {
724             rc->rate_factor_max_increment = h->param.rc.f_rf_constant_max - h->param.rc.f_rf_constant;
725             if( rc->rate_factor_max_increment <= 0 )
726             {
727                 x264_log( h, X264_LOG_WARNING, "CRF max must be greater than CRF\n" );
728                 rc->rate_factor_max_increment = 0;
729             }
730         }
731         if( b_init )
732         {
733             if( h->param.rc.f_vbv_buffer_init > 1. )
734                 h->param.rc.f_vbv_buffer_init = x264_clip3f( h->param.rc.f_vbv_buffer_init / h->param.rc.i_vbv_buffer_size, 0, 1 );
735             h->param.rc.f_vbv_buffer_init = x264_clip3f( X264_MAX( h->param.rc.f_vbv_buffer_init, rc->buffer_rate / rc->buffer_size ), 0, 1);
736             rc->buffer_fill_final =
737             rc->buffer_fill_final_min = rc->buffer_size * h->param.rc.f_vbv_buffer_init * h->sps->vui.i_time_scale;
738             rc->b_vbv = 1;
739             rc->b_vbv_min_rate = !rc->b_2pass
740                           && h->param.rc.i_rc_method == X264_RC_ABR
741                           && h->param.rc.i_vbv_max_bitrate <= h->param.rc.i_bitrate;
742         }
743     }
744 }
745
746 int x264_ratecontrol_new( x264_t *h )
747 {
748     x264_ratecontrol_t *rc;
749
750     x264_emms();
751
752     CHECKED_MALLOCZERO( h->rc, h->param.i_threads * sizeof(x264_ratecontrol_t) );
753     rc = h->rc;
754
755     rc->b_abr = h->param.rc.i_rc_method != X264_RC_CQP && !h->param.rc.b_stat_read;
756     rc->b_2pass = h->param.rc.i_rc_method == X264_RC_ABR && h->param.rc.b_stat_read;
757
758     /* FIXME: use integers */
759     if( h->param.i_fps_num > 0 && h->param.i_fps_den > 0 )
760         rc->fps = (float) h->param.i_fps_num / h->param.i_fps_den;
761     else
762         rc->fps = 25.0;
763
764     if( h->param.rc.b_mb_tree )
765     {
766         h->param.rc.f_pb_factor = 1;
767         rc->qcompress = 1;
768     }
769     else
770         rc->qcompress = h->param.rc.f_qcompress;
771
772     rc->bitrate = h->param.rc.i_bitrate * (h->param.i_avcintra_class ? 1024. : 1000.);
773     rc->rate_tolerance = h->param.rc.f_rate_tolerance;
774     rc->nmb = h->mb.i_mb_count;
775     rc->last_non_b_pict_type = -1;
776     rc->cbr_decay = 1.0;
777
778     if( h->param.rc.i_rc_method == X264_RC_CRF && h->param.rc.b_stat_read )
779     {
780         x264_log( h, X264_LOG_ERROR, "constant rate-factor is incompatible with 2pass.\n" );
781         return -1;
782     }
783
784     x264_ratecontrol_init_reconfigurable( h, 1 );
785
786     if( h->param.i_nal_hrd )
787     {
788         uint64_t denom = (uint64_t)h->sps->vui.hrd.i_bit_rate_unscaled * h->sps->vui.i_time_scale;
789         uint64_t num = 90000;
790         x264_reduce_fraction64( &num, &denom );
791         rc->hrd_multiply_denom = 90000 / num;
792
793         double bits_required = log2( 90000 / rc->hrd_multiply_denom )
794                              + log2( h->sps->vui.i_time_scale )
795                              + log2( h->sps->vui.hrd.i_cpb_size_unscaled );
796         if( bits_required >= 63 )
797         {
798             x264_log( h, X264_LOG_ERROR, "HRD with very large timescale and bufsize not supported\n" );
799             return -1;
800         }
801     }
802
803     if( rc->rate_tolerance < 0.01 )
804     {
805         x264_log( h, X264_LOG_WARNING, "bitrate tolerance too small, using .01\n" );
806         rc->rate_tolerance = 0.01;
807     }
808
809     h->mb.b_variable_qp = rc->b_vbv || h->param.rc.i_aq_mode;
810
811     if( rc->b_abr )
812     {
813         /* FIXME ABR_INIT_QP is actually used only in CRF */
814 #define ABR_INIT_QP (( h->param.rc.i_rc_method == X264_RC_CRF ? h->param.rc.f_rf_constant : 24 ) + QP_BD_OFFSET)
815         rc->accum_p_norm = .01;
816         rc->accum_p_qp = ABR_INIT_QP * rc->accum_p_norm;
817         /* estimated ratio that produces a reasonable QP for the first I-frame */
818         rc->cplxr_sum = .01 * pow( 7.0e5, rc->qcompress ) * pow( h->mb.i_mb_count, 0.5 );
819         rc->wanted_bits_window = 1.0 * rc->bitrate / rc->fps;
820         rc->last_non_b_pict_type = SLICE_TYPE_I;
821     }
822
823     rc->ip_offset = 6.0 * log2f( h->param.rc.f_ip_factor );
824     rc->pb_offset = 6.0 * log2f( h->param.rc.f_pb_factor );
825     rc->qp_constant[SLICE_TYPE_P] = h->param.rc.i_qp_constant;
826     rc->qp_constant[SLICE_TYPE_I] = x264_clip3( h->param.rc.i_qp_constant - rc->ip_offset + 0.5, 0, QP_MAX );
827     rc->qp_constant[SLICE_TYPE_B] = x264_clip3( h->param.rc.i_qp_constant + rc->pb_offset + 0.5, 0, QP_MAX );
828     h->mb.ip_offset = rc->ip_offset + 0.5;
829
830     rc->lstep = pow( 2, h->param.rc.i_qp_step / 6.0 );
831     rc->last_qscale = qp2qscale( 26 + QP_BD_OFFSET );
832     int num_preds = h->param.b_sliced_threads * h->param.i_threads + 1;
833     CHECKED_MALLOC( rc->pred, 5 * sizeof(predictor_t) * num_preds );
834     CHECKED_MALLOC( rc->pred_b_from_p, sizeof(predictor_t) );
835     static const float pred_coeff_table[3] = { 1.0, 1.0, 1.5 };
836     for( int i = 0; i < 3; i++ )
837     {
838         rc->last_qscale_for[i] = qp2qscale( ABR_INIT_QP );
839         rc->lmin[i] = qp2qscale( h->param.rc.i_qp_min );
840         rc->lmax[i] = qp2qscale( h->param.rc.i_qp_max );
841         for( int j = 0; j < num_preds; j++ )
842         {
843             rc->pred[i+j*5].coeff_min = pred_coeff_table[i] / 2;
844             rc->pred[i+j*5].coeff = pred_coeff_table[i];
845             rc->pred[i+j*5].count = 1.0;
846             rc->pred[i+j*5].decay = 0.5;
847             rc->pred[i+j*5].offset = 0.0;
848         }
849         for( int j = 0; j < 2; j++ )
850         {
851             rc->row_preds[i][j].coeff_min = .25 / 4;
852             rc->row_preds[i][j].coeff = .25;
853             rc->row_preds[i][j].count = 1.0;
854             rc->row_preds[i][j].decay = 0.5;
855             rc->row_preds[i][j].offset = 0.0;
856         }
857     }
858     rc->pred_b_from_p->coeff_min = 0.5 / 2;
859     rc->pred_b_from_p->coeff = 0.5;
860     rc->pred_b_from_p->count = 1.0;
861     rc->pred_b_from_p->decay = 0.5;
862     rc->pred_b_from_p->offset = 0.0;
863
864     if( parse_zones( h ) < 0 )
865     {
866         x264_log( h, X264_LOG_ERROR, "failed to parse zones\n" );
867         return -1;
868     }
869
870     /* Load stat file and init 2pass algo */
871     if( h->param.rc.b_stat_read )
872     {
873         char *p, *stats_in, *stats_buf;
874
875         /* read 1st pass stats */
876         assert( h->param.rc.psz_stat_in );
877         stats_buf = stats_in = x264_slurp_file( h->param.rc.psz_stat_in );
878         if( !stats_buf )
879         {
880             x264_log( h, X264_LOG_ERROR, "ratecontrol_init: can't open stats file\n" );
881             return -1;
882         }
883         if( h->param.rc.b_mb_tree )
884         {
885             char *mbtree_stats_in = x264_strcat_filename( h->param.rc.psz_stat_in, ".mbtree" );
886             if( !mbtree_stats_in )
887                 return -1;
888             rc->p_mbtree_stat_file_in = x264_fopen( mbtree_stats_in, "rb" );
889             x264_free( mbtree_stats_in );
890             if( !rc->p_mbtree_stat_file_in )
891             {
892                 x264_log( h, X264_LOG_ERROR, "ratecontrol_init: can't open mbtree stats file\n" );
893                 return -1;
894             }
895         }
896
897         /* check whether 1st pass options were compatible with current options */
898         if( strncmp( stats_buf, "#options:", 9 ) )
899         {
900             x264_log( h, X264_LOG_ERROR, "options list in stats file not valid\n" );
901             return -1;
902         }
903
904         float res_factor, res_factor_bits;
905         {
906             int i, j;
907             uint32_t k, l;
908             char *opts = stats_buf;
909             stats_in = strchr( stats_buf, '\n' );
910             if( !stats_in )
911                 return -1;
912             *stats_in = '\0';
913             stats_in++;
914             if( sscanf( opts, "#options: %dx%d", &i, &j ) != 2 )
915             {
916                 x264_log( h, X264_LOG_ERROR, "resolution specified in stats file not valid\n" );
917                 return -1;
918             }
919             else if( h->param.rc.b_mb_tree )
920             {
921                 rc->mbtree.srcdim[0] = i;
922                 rc->mbtree.srcdim[1] = j;
923             }
924             res_factor = (float)h->param.i_width * h->param.i_height / (i*j);
925             /* Change in bits relative to resolution isn't quite linear on typical sources,
926              * so we'll at least try to roughly approximate this effect. */
927             res_factor_bits = powf( res_factor, 0.7 );
928
929             if( !( p = strstr( opts, "timebase=" ) ) || sscanf( p, "timebase=%u/%u", &k, &l ) != 2 )
930             {
931                 x264_log( h, X264_LOG_ERROR, "timebase specified in stats file not valid\n" );
932                 return -1;
933             }
934             if( k != h->param.i_timebase_num || l != h->param.i_timebase_den )
935             {
936                 x264_log( h, X264_LOG_ERROR, "timebase mismatch with 1st pass (%u/%u vs %u/%u)\n",
937                           h->param.i_timebase_num, h->param.i_timebase_den, k, l );
938                 return -1;
939             }
940
941             CMP_OPT_FIRST_PASS( "bitdepth", BIT_DEPTH );
942             CMP_OPT_FIRST_PASS( "weightp", X264_MAX( 0, h->param.analyse.i_weighted_pred ) );
943             CMP_OPT_FIRST_PASS( "bframes", h->param.i_bframe );
944             CMP_OPT_FIRST_PASS( "b_pyramid", h->param.i_bframe_pyramid );
945             CMP_OPT_FIRST_PASS( "intra_refresh", h->param.b_intra_refresh );
946             CMP_OPT_FIRST_PASS( "open_gop", h->param.b_open_gop );
947             CMP_OPT_FIRST_PASS( "bluray_compat", h->param.b_bluray_compat );
948
949             if( (p = strstr( opts, "interlaced=" )) )
950             {
951                 char *current = h->param.b_interlaced ? h->param.b_tff ? "tff" : "bff" : h->param.b_fake_interlaced ? "fake" : "0";
952                 char buf[5];
953                 sscanf( p, "interlaced=%4s", buf );
954                 if( strcmp( current, buf ) )
955                 {
956                     x264_log( h, X264_LOG_ERROR, "different interlaced setting than first pass (%s vs %s)\n", current, buf );
957                     return -1;
958                 }
959             }
960
961             if( (p = strstr( opts, "keyint=" )) )
962             {
963                 p += 7;
964                 char buf[13] = "infinite ";
965                 if( h->param.i_keyint_max != X264_KEYINT_MAX_INFINITE )
966                     sprintf( buf, "%d ", h->param.i_keyint_max );
967                 if( strncmp( p, buf, strlen(buf) ) )
968                 {
969                     x264_log( h, X264_LOG_ERROR, "different keyint setting than first pass (%.*s vs %.*s)\n",
970                               strlen(buf)-1, buf, strcspn(p, " "), p );
971                     return -1;
972                 }
973             }
974
975             if( strstr( opts, "qp=0" ) && h->param.rc.i_rc_method == X264_RC_ABR )
976                 x264_log( h, X264_LOG_WARNING, "1st pass was lossless, bitrate prediction will be inaccurate\n" );
977
978             if( !strstr( opts, "direct=3" ) && h->param.analyse.i_direct_mv_pred == X264_DIRECT_PRED_AUTO )
979             {
980                 x264_log( h, X264_LOG_WARNING, "direct=auto not used on the first pass\n" );
981                 h->mb.b_direct_auto_write = 1;
982             }
983
984             if( ( p = strstr( opts, "b_adapt=" ) ) && sscanf( p, "b_adapt=%d", &i ) && i >= X264_B_ADAPT_NONE && i <= X264_B_ADAPT_TRELLIS )
985                 h->param.i_bframe_adaptive = i;
986             else if( h->param.i_bframe )
987             {
988                 x264_log( h, X264_LOG_ERROR, "b_adapt method specified in stats file not valid\n" );
989                 return -1;
990             }
991
992             if( (h->param.rc.b_mb_tree || h->param.rc.i_vbv_buffer_size) && ( p = strstr( opts, "rc_lookahead=" ) ) && sscanf( p, "rc_lookahead=%d", &i ) )
993                 h->param.rc.i_lookahead = i;
994         }
995
996         /* find number of pics */
997         p = stats_in;
998         int num_entries;
999         for( num_entries = -1; p; num_entries++ )
1000             p = strchr( p + 1, ';' );
1001         if( !num_entries )
1002         {
1003             x264_log( h, X264_LOG_ERROR, "empty stats file\n" );
1004             return -1;
1005         }
1006         rc->num_entries = num_entries;
1007
1008         if( h->param.i_frame_total < rc->num_entries && h->param.i_frame_total > 0 )
1009         {
1010             x264_log( h, X264_LOG_WARNING, "2nd pass has fewer frames than 1st pass (%d vs %d)\n",
1011                       h->param.i_frame_total, rc->num_entries );
1012         }
1013         if( h->param.i_frame_total > rc->num_entries )
1014         {
1015             x264_log( h, X264_LOG_ERROR, "2nd pass has more frames than 1st pass (%d vs %d)\n",
1016                       h->param.i_frame_total, rc->num_entries );
1017             return -1;
1018         }
1019
1020         CHECKED_MALLOCZERO( rc->entry, rc->num_entries * sizeof(ratecontrol_entry_t) );
1021
1022         /* init all to skipped p frames */
1023         for( int i = 0; i < rc->num_entries; i++ )
1024         {
1025             ratecontrol_entry_t *rce = &rc->entry[i];
1026             rce->pict_type = SLICE_TYPE_P;
1027             rce->qscale = rce->new_qscale = qp2qscale( 20 + QP_BD_OFFSET );
1028             rce->misc_bits = rc->nmb + 10;
1029             rce->new_qp = 0;
1030         }
1031
1032         /* read stats */
1033         p = stats_in;
1034         double total_qp_aq = 0;
1035         for( int i = 0; i < rc->num_entries; i++ )
1036         {
1037             ratecontrol_entry_t *rce;
1038             int frame_number;
1039             char pict_type;
1040             int e;
1041             char *next;
1042             float qp_rc, qp_aq;
1043             int ref;
1044
1045             next= strchr(p, ';');
1046             if( next )
1047                 *next++ = 0; //sscanf is unbelievably slow on long strings
1048             e = sscanf( p, " in:%d ", &frame_number );
1049
1050             if( frame_number < 0 || frame_number >= rc->num_entries )
1051             {
1052                 x264_log( h, X264_LOG_ERROR, "bad frame number (%d) at stats line %d\n", frame_number, i );
1053                 return -1;
1054             }
1055             rce = &rc->entry[frame_number];
1056             rce->direct_mode = 0;
1057
1058             e += sscanf( p, " in:%*d out:%*d type:%c dur:%"SCNd64" cpbdur:%"SCNd64" q:%f aq:%f tex:%d mv:%d misc:%d imb:%d pmb:%d smb:%d d:%c",
1059                    &pict_type, &rce->i_duration, &rce->i_cpb_duration, &qp_rc, &qp_aq, &rce->tex_bits,
1060                    &rce->mv_bits, &rce->misc_bits, &rce->i_count, &rce->p_count,
1061                    &rce->s_count, &rce->direct_mode );
1062             rce->tex_bits  *= res_factor_bits;
1063             rce->mv_bits   *= res_factor_bits;
1064             rce->misc_bits *= res_factor_bits;
1065             rce->i_count   *= res_factor;
1066             rce->p_count   *= res_factor;
1067             rce->s_count   *= res_factor;
1068
1069             p = strstr( p, "ref:" );
1070             if( !p )
1071                 goto parse_error;
1072             p += 4;
1073             for( ref = 0; ref < 16; ref++ )
1074             {
1075                 if( sscanf( p, " %d", &rce->refcount[ref] ) != 1 )
1076                     break;
1077                 p = strchr( p+1, ' ' );
1078                 if( !p )
1079                     goto parse_error;
1080             }
1081             rce->refs = ref;
1082
1083             /* find weights */
1084             rce->i_weight_denom[0] = rce->i_weight_denom[1] = -1;
1085             char *w = strchr( p, 'w' );
1086             if( w )
1087             {
1088                 int count = sscanf( w, "w:%hd,%hd,%hd,%hd,%hd,%hd,%hd,%hd",
1089                                     &rce->i_weight_denom[0], &rce->weight[0][0], &rce->weight[0][1],
1090                                     &rce->i_weight_denom[1], &rce->weight[1][0], &rce->weight[1][1],
1091                                     &rce->weight[2][0], &rce->weight[2][1] );
1092                 if( count == 3 )
1093                     rce->i_weight_denom[1] = -1;
1094                 else if ( count != 8 )
1095                     rce->i_weight_denom[0] = rce->i_weight_denom[1] = -1;
1096             }
1097
1098             if( pict_type != 'b' )
1099                 rce->kept_as_ref = 1;
1100             switch( pict_type )
1101             {
1102                 case 'I':
1103                     rce->frame_type = X264_TYPE_IDR;
1104                     rce->pict_type  = SLICE_TYPE_I;
1105                     break;
1106                 case 'i':
1107                     rce->frame_type = X264_TYPE_I;
1108                     rce->pict_type  = SLICE_TYPE_I;
1109                     break;
1110                 case 'P':
1111                     rce->frame_type = X264_TYPE_P;
1112                     rce->pict_type  = SLICE_TYPE_P;
1113                     break;
1114                 case 'B':
1115                     rce->frame_type = X264_TYPE_BREF;
1116                     rce->pict_type  = SLICE_TYPE_B;
1117                     break;
1118                 case 'b':
1119                     rce->frame_type = X264_TYPE_B;
1120                     rce->pict_type  = SLICE_TYPE_B;
1121                     break;
1122                 default:  e = -1; break;
1123             }
1124             if( e < 13 )
1125             {
1126 parse_error:
1127                 x264_log( h, X264_LOG_ERROR, "statistics are damaged at line %d, parser out=%d\n", i, e );
1128                 return -1;
1129             }
1130             rce->qscale = qp2qscale( qp_rc );
1131             total_qp_aq += qp_aq;
1132             p = next;
1133         }
1134         if( !h->param.b_stitchable )
1135             h->pps->i_pic_init_qp = SPEC_QP( (int)(total_qp_aq / rc->num_entries + 0.5) );
1136
1137         x264_free( stats_buf );
1138
1139         if( h->param.rc.i_rc_method == X264_RC_ABR )
1140         {
1141             if( init_pass2( h ) < 0 )
1142                 return -1;
1143         } /* else we're using constant quant, so no need to run the bitrate allocation */
1144     }
1145
1146     /* Open output file */
1147     /* If input and output files are the same, output to a temp file
1148      * and move it to the real name only when it's complete */
1149     if( h->param.rc.b_stat_write )
1150     {
1151         char *p;
1152         rc->psz_stat_file_tmpname = x264_strcat_filename( h->param.rc.psz_stat_out, ".temp" );
1153         if( !rc->psz_stat_file_tmpname )
1154             return -1;
1155
1156         rc->p_stat_file_out = x264_fopen( rc->psz_stat_file_tmpname, "wb" );
1157         if( rc->p_stat_file_out == NULL )
1158         {
1159             x264_log( h, X264_LOG_ERROR, "ratecontrol_init: can't open stats file\n" );
1160             return -1;
1161         }
1162
1163         p = x264_param2string( &h->param, 1 );
1164         if( p )
1165             fprintf( rc->p_stat_file_out, "#options: %s\n", p );
1166         x264_free( p );
1167         if( h->param.rc.b_mb_tree && !h->param.rc.b_stat_read )
1168         {
1169             rc->psz_mbtree_stat_file_tmpname = x264_strcat_filename( h->param.rc.psz_stat_out, ".mbtree.temp" );
1170             rc->psz_mbtree_stat_file_name = x264_strcat_filename( h->param.rc.psz_stat_out, ".mbtree" );
1171             if( !rc->psz_mbtree_stat_file_tmpname || !rc->psz_mbtree_stat_file_name )
1172                 return -1;
1173
1174             rc->p_mbtree_stat_file_out = x264_fopen( rc->psz_mbtree_stat_file_tmpname, "wb" );
1175             if( rc->p_mbtree_stat_file_out == NULL )
1176             {
1177                 x264_log( h, X264_LOG_ERROR, "ratecontrol_init: can't open mbtree stats file\n" );
1178                 return -1;
1179             }
1180         }
1181     }
1182
1183     if( h->param.rc.b_mb_tree && (h->param.rc.b_stat_read || h->param.rc.b_stat_write) )
1184     {
1185         if( !h->param.rc.b_stat_read )
1186         {
1187             rc->mbtree.srcdim[0] = h->param.i_width;
1188             rc->mbtree.srcdim[1] = h->param.i_height;
1189         }
1190         if( x264_macroblock_tree_rescale_init( h, rc ) < 0 )
1191             return -1;
1192     }
1193
1194     for( int i = 0; i<h->param.i_threads; i++ )
1195     {
1196         h->thread[i]->rc = rc+i;
1197         if( i )
1198         {
1199             rc[i] = rc[0];
1200             h->thread[i]->param = h->param;
1201             h->thread[i]->mb.b_variable_qp = h->mb.b_variable_qp;
1202             h->thread[i]->mb.ip_offset = h->mb.ip_offset;
1203         }
1204     }
1205
1206     return 0;
1207 fail:
1208     return -1;
1209 }
1210
1211 static int parse_zone( x264_t *h, x264_zone_t *z, char *p )
1212 {
1213     int len = 0;
1214     char *tok, UNUSED *saveptr=NULL;
1215     z->param = NULL;
1216     z->f_bitrate_factor = 1;
1217     if( 3 <= sscanf(p, "%d,%d,q=%d%n", &z->i_start, &z->i_end, &z->i_qp, &len) )
1218         z->b_force_qp = 1;
1219     else if( 3 <= sscanf(p, "%d,%d,b=%f%n", &z->i_start, &z->i_end, &z->f_bitrate_factor, &len) )
1220         z->b_force_qp = 0;
1221     else if( 2 <= sscanf(p, "%d,%d%n", &z->i_start, &z->i_end, &len) )
1222         z->b_force_qp = 0;
1223     else
1224     {
1225         x264_log( h, X264_LOG_ERROR, "invalid zone: \"%s\"\n", p );
1226         return -1;
1227     }
1228     p += len;
1229     if( !*p )
1230         return 0;
1231     CHECKED_MALLOC( z->param, sizeof(x264_param_t) );
1232     memcpy( z->param, &h->param, sizeof(x264_param_t) );
1233     z->param->param_free = x264_free;
1234     while( (tok = strtok_r( p, ",", &saveptr )) )
1235     {
1236         char *val = strchr( tok, '=' );
1237         if( val )
1238         {
1239             *val = '\0';
1240             val++;
1241         }
1242         if( x264_param_parse( z->param, tok, val ) )
1243         {
1244             x264_log( h, X264_LOG_ERROR, "invalid zone param: %s = %s\n", tok, val );
1245             return -1;
1246         }
1247         p = NULL;
1248     }
1249     return 0;
1250 fail:
1251     return -1;
1252 }
1253
1254 static int parse_zones( x264_t *h )
1255 {
1256     x264_ratecontrol_t *rc = h->rc;
1257     if( h->param.rc.psz_zones && !h->param.rc.i_zones )
1258     {
1259         char *psz_zones, *p;
1260         CHECKED_MALLOC( psz_zones, strlen( h->param.rc.psz_zones )+1 );
1261         strcpy( psz_zones, h->param.rc.psz_zones );
1262         h->param.rc.i_zones = 1;
1263         for( p = psz_zones; *p; p++ )
1264             h->param.rc.i_zones += (*p == '/');
1265         CHECKED_MALLOC( h->param.rc.zones, h->param.rc.i_zones * sizeof(x264_zone_t) );
1266         p = psz_zones;
1267         for( int i = 0; i < h->param.rc.i_zones; i++ )
1268         {
1269             int i_tok = strcspn( p, "/" );
1270             p[i_tok] = 0;
1271             if( parse_zone( h, &h->param.rc.zones[i], p ) )
1272                 return -1;
1273             p += i_tok + 1;
1274         }
1275         x264_free( psz_zones );
1276     }
1277
1278     if( h->param.rc.i_zones > 0 )
1279     {
1280         for( int i = 0; i < h->param.rc.i_zones; i++ )
1281         {
1282             x264_zone_t z = h->param.rc.zones[i];
1283             if( z.i_start < 0 || z.i_start > z.i_end )
1284             {
1285                 x264_log( h, X264_LOG_ERROR, "invalid zone: start=%d end=%d\n",
1286                           z.i_start, z.i_end );
1287                 return -1;
1288             }
1289             else if( !z.b_force_qp && z.f_bitrate_factor <= 0 )
1290             {
1291                 x264_log( h, X264_LOG_ERROR, "invalid zone: bitrate_factor=%f\n",
1292                           z.f_bitrate_factor );
1293                 return -1;
1294             }
1295         }
1296
1297         rc->i_zones = h->param.rc.i_zones + 1;
1298         CHECKED_MALLOC( rc->zones, rc->i_zones * sizeof(x264_zone_t) );
1299         memcpy( rc->zones+1, h->param.rc.zones, (rc->i_zones-1) * sizeof(x264_zone_t) );
1300
1301         // default zone to fall back to if none of the others match
1302         rc->zones[0].i_start = 0;
1303         rc->zones[0].i_end = INT_MAX;
1304         rc->zones[0].b_force_qp = 0;
1305         rc->zones[0].f_bitrate_factor = 1;
1306         CHECKED_MALLOC( rc->zones[0].param, sizeof(x264_param_t) );
1307         memcpy( rc->zones[0].param, &h->param, sizeof(x264_param_t) );
1308         for( int i = 1; i < rc->i_zones; i++ )
1309         {
1310             if( !rc->zones[i].param )
1311                 rc->zones[i].param = rc->zones[0].param;
1312         }
1313     }
1314
1315     return 0;
1316 fail:
1317     return -1;
1318 }
1319
1320 static x264_zone_t *get_zone( x264_t *h, int frame_num )
1321 {
1322     for( int i = h->rc->i_zones - 1; i >= 0; i-- )
1323     {
1324         x264_zone_t *z = &h->rc->zones[i];
1325         if( frame_num >= z->i_start && frame_num <= z->i_end )
1326             return z;
1327     }
1328     return NULL;
1329 }
1330
1331 void x264_ratecontrol_summary( x264_t *h )
1332 {
1333     x264_ratecontrol_t *rc = h->rc;
1334     if( rc->b_abr && h->param.rc.i_rc_method == X264_RC_ABR && rc->cbr_decay > .9999 )
1335     {
1336         double base_cplx = h->mb.i_mb_count * (h->param.i_bframe ? 120 : 80);
1337         double mbtree_offset = h->param.rc.b_mb_tree ? (1.0-h->param.rc.f_qcompress)*13.5 : 0;
1338         x264_log( h, X264_LOG_INFO, "final ratefactor: %.2f\n",
1339                   qscale2qp( pow( base_cplx, 1 - rc->qcompress )
1340                              * rc->cplxr_sum / rc->wanted_bits_window ) - mbtree_offset - QP_BD_OFFSET );
1341     }
1342 }
1343
1344 void x264_ratecontrol_delete( x264_t *h )
1345 {
1346     x264_ratecontrol_t *rc = h->rc;
1347     int b_regular_file;
1348
1349     if( rc->p_stat_file_out )
1350     {
1351         b_regular_file = x264_is_regular_file( rc->p_stat_file_out );
1352         fclose( rc->p_stat_file_out );
1353         if( h->i_frame >= rc->num_entries && b_regular_file )
1354             if( x264_rename( rc->psz_stat_file_tmpname, h->param.rc.psz_stat_out ) != 0 )
1355             {
1356                 x264_log( h, X264_LOG_ERROR, "failed to rename \"%s\" to \"%s\"\n",
1357                           rc->psz_stat_file_tmpname, h->param.rc.psz_stat_out );
1358             }
1359         x264_free( rc->psz_stat_file_tmpname );
1360     }
1361     if( rc->p_mbtree_stat_file_out )
1362     {
1363         b_regular_file = x264_is_regular_file( rc->p_mbtree_stat_file_out );
1364         fclose( rc->p_mbtree_stat_file_out );
1365         if( h->i_frame >= rc->num_entries && b_regular_file )
1366             if( x264_rename( rc->psz_mbtree_stat_file_tmpname, rc->psz_mbtree_stat_file_name ) != 0 )
1367             {
1368                 x264_log( h, X264_LOG_ERROR, "failed to rename \"%s\" to \"%s\"\n",
1369                           rc->psz_mbtree_stat_file_tmpname, rc->psz_mbtree_stat_file_name );
1370             }
1371         x264_free( rc->psz_mbtree_stat_file_tmpname );
1372         x264_free( rc->psz_mbtree_stat_file_name );
1373     }
1374     if( rc->p_mbtree_stat_file_in )
1375         fclose( rc->p_mbtree_stat_file_in );
1376     x264_free( rc->pred );
1377     x264_free( rc->pred_b_from_p );
1378     x264_free( rc->entry );
1379     x264_macroblock_tree_rescale_destroy( rc );
1380     if( rc->zones )
1381     {
1382         x264_free( rc->zones[0].param );
1383         for( int i = 1; i < rc->i_zones; i++ )
1384             if( rc->zones[i].param != rc->zones[0].param && rc->zones[i].param->param_free )
1385                 rc->zones[i].param->param_free( rc->zones[i].param );
1386         x264_free( rc->zones );
1387     }
1388     x264_free( rc );
1389 }
1390
1391 static void accum_p_qp_update( x264_t *h, float qp )
1392 {
1393     x264_ratecontrol_t *rc = h->rc;
1394     rc->accum_p_qp   *= .95;
1395     rc->accum_p_norm *= .95;
1396     rc->accum_p_norm += 1;
1397     if( h->sh.i_type == SLICE_TYPE_I )
1398         rc->accum_p_qp += qp + rc->ip_offset;
1399     else
1400         rc->accum_p_qp += qp;
1401 }
1402
1403 /* Before encoding a frame, choose a QP for it */
1404 void x264_ratecontrol_start( x264_t *h, int i_force_qp, int overhead )
1405 {
1406     x264_ratecontrol_t *rc = h->rc;
1407     ratecontrol_entry_t *rce = NULL;
1408     x264_zone_t *zone = get_zone( h, h->fenc->i_frame );
1409     float q;
1410
1411     x264_emms();
1412
1413     if( zone && (!rc->prev_zone || zone->param != rc->prev_zone->param) )
1414         x264_encoder_reconfig_apply( h, zone->param );
1415     rc->prev_zone = zone;
1416
1417     if( h->param.rc.b_stat_read )
1418     {
1419         int frame = h->fenc->i_frame;
1420         assert( frame >= 0 && frame < rc->num_entries );
1421         rce = h->rc->rce = &h->rc->entry[frame];
1422
1423         if( h->sh.i_type == SLICE_TYPE_B
1424             && h->param.analyse.i_direct_mv_pred == X264_DIRECT_PRED_AUTO )
1425         {
1426             h->sh.b_direct_spatial_mv_pred = ( rce->direct_mode == 's' );
1427             h->mb.b_direct_auto_read = ( rce->direct_mode == 's' || rce->direct_mode == 't' );
1428         }
1429     }
1430
1431     if( rc->b_vbv )
1432     {
1433         memset( h->fdec->i_row_bits, 0, h->mb.i_mb_height * sizeof(int) );
1434         memset( h->fdec->f_row_qp, 0, h->mb.i_mb_height * sizeof(float) );
1435         memset( h->fdec->f_row_qscale, 0, h->mb.i_mb_height * sizeof(float) );
1436         rc->row_pred = rc->row_preds[h->sh.i_type];
1437         rc->buffer_rate = h->fenc->i_cpb_duration * rc->vbv_max_rate * h->sps->vui.i_num_units_in_tick / h->sps->vui.i_time_scale;
1438         update_vbv_plan( h, overhead );
1439
1440         const x264_level_t *l = x264_levels;
1441         while( l->level_idc != 0 && l->level_idc != h->param.i_level_idc )
1442             l++;
1443
1444         int mincr = l->mincr;
1445
1446         if( h->param.b_bluray_compat )
1447             mincr = 4;
1448
1449         /* Profiles above High don't require minCR, so just set the maximum to a large value. */
1450         if( h->sps->i_profile_idc > PROFILE_HIGH )
1451             rc->frame_size_maximum = 1e9;
1452         else
1453         {
1454             /* The spec has a bizarre special case for the first frame. */
1455             if( h->i_frame == 0 )
1456             {
1457                 //384 * ( Max( PicSizeInMbs, fR * MaxMBPS ) + MaxMBPS * ( tr( 0 ) - tr,n( 0 ) ) ) / MinCR
1458                 double fr = 1. / 172;
1459                 int pic_size_in_mbs = h->mb.i_mb_width * h->mb.i_mb_height;
1460                 rc->frame_size_maximum = 384 * BIT_DEPTH * X264_MAX( pic_size_in_mbs, fr*l->mbps ) / mincr;
1461             }
1462             else
1463             {
1464                 //384 * MaxMBPS * ( tr( n ) - tr( n - 1 ) ) / MinCR
1465                 rc->frame_size_maximum = 384 * BIT_DEPTH * ((double)h->fenc->i_cpb_duration * h->sps->vui.i_num_units_in_tick / h->sps->vui.i_time_scale) * l->mbps / mincr;
1466             }
1467         }
1468     }
1469
1470     if( h->sh.i_type != SLICE_TYPE_B )
1471         rc->bframes = h->fenc->i_bframes;
1472
1473     if( rc->b_abr )
1474     {
1475         q = qscale2qp( rate_estimate_qscale( h ) );
1476     }
1477     else if( rc->b_2pass )
1478     {
1479         rce->new_qscale = rate_estimate_qscale( h );
1480         q = qscale2qp( rce->new_qscale );
1481     }
1482     else /* CQP */
1483     {
1484         if( h->sh.i_type == SLICE_TYPE_B && h->fdec->b_kept_as_ref )
1485             q = ( rc->qp_constant[ SLICE_TYPE_B ] + rc->qp_constant[ SLICE_TYPE_P ] ) / 2;
1486         else
1487             q = rc->qp_constant[ h->sh.i_type ];
1488
1489         if( zone )
1490         {
1491             if( zone->b_force_qp )
1492                 q += zone->i_qp - rc->qp_constant[SLICE_TYPE_P];
1493             else
1494                 q -= 6*log2f( zone->f_bitrate_factor );
1495         }
1496     }
1497     if( i_force_qp != X264_QP_AUTO )
1498         q = i_force_qp - 1;
1499
1500     q = x264_clip3f( q, h->param.rc.i_qp_min, h->param.rc.i_qp_max );
1501
1502     rc->qpa_rc = rc->qpa_rc_prev =
1503     rc->qpa_aq = rc->qpa_aq_prev = 0;
1504     rc->qp = x264_clip3( q + 0.5f, 0, QP_MAX );
1505     h->fdec->f_qp_avg_rc =
1506     h->fdec->f_qp_avg_aq =
1507     rc->qpm = q;
1508     if( rce )
1509         rce->new_qp = rc->qp;
1510
1511     accum_p_qp_update( h, rc->qpm );
1512
1513     if( h->sh.i_type != SLICE_TYPE_B )
1514         rc->last_non_b_pict_type = h->sh.i_type;
1515 }
1516
1517 static float predict_row_size( x264_t *h, int y, float qscale )
1518 {
1519     /* average between two predictors:
1520      * absolute SATD, and scaled bit cost of the colocated row in the previous frame */
1521     x264_ratecontrol_t *rc = h->rc;
1522     float pred_s = predict_size( &rc->row_pred[0], qscale, h->fdec->i_row_satd[y] );
1523     if( h->sh.i_type == SLICE_TYPE_I || qscale >= h->fref[0][0]->f_row_qscale[y] )
1524     {
1525         if( h->sh.i_type == SLICE_TYPE_P
1526             && h->fref[0][0]->i_type == h->fdec->i_type
1527             && h->fref[0][0]->f_row_qscale[y] > 0
1528             && h->fref[0][0]->i_row_satd[y] > 0
1529             && (abs(h->fref[0][0]->i_row_satd[y] - h->fdec->i_row_satd[y]) < h->fdec->i_row_satd[y]/2))
1530         {
1531             float pred_t = h->fref[0][0]->i_row_bits[y] * h->fdec->i_row_satd[y] / h->fref[0][0]->i_row_satd[y]
1532                          * h->fref[0][0]->f_row_qscale[y] / qscale;
1533             return (pred_s + pred_t) * 0.5f;
1534         }
1535         return pred_s;
1536     }
1537     /* Our QP is lower than the reference! */
1538     else
1539     {
1540         float pred_intra = predict_size( &rc->row_pred[1], qscale, h->fdec->i_row_satds[0][0][y] );
1541         /* Sum: better to overestimate than underestimate by using only one of the two predictors. */
1542         return pred_intra + pred_s;
1543     }
1544 }
1545
1546 static int row_bits_so_far( x264_t *h, int y )
1547 {
1548     int bits = 0;
1549     for( int i = h->i_threadslice_start; i <= y; i++ )
1550         bits += h->fdec->i_row_bits[i];
1551     return bits;
1552 }
1553
1554 static float predict_row_size_sum( x264_t *h, int y, float qp )
1555 {
1556     float qscale = qp2qscale( qp );
1557     float bits = row_bits_so_far( h, y );
1558     for( int i = y+1; i < h->i_threadslice_end; i++ )
1559         bits += predict_row_size( h, i, qscale );
1560     return bits;
1561 }
1562
1563 /* TODO:
1564  *  eliminate all use of qp in row ratecontrol: make it entirely qscale-based.
1565  *  make this function stop being needlessly O(N^2)
1566  *  update more often than once per row? */
1567 int x264_ratecontrol_mb( x264_t *h, int bits )
1568 {
1569     x264_ratecontrol_t *rc = h->rc;
1570     const int y = h->mb.i_mb_y;
1571
1572     h->fdec->i_row_bits[y] += bits;
1573     rc->qpa_aq += h->mb.i_qp;
1574
1575     if( h->mb.i_mb_x != h->mb.i_mb_width - 1 )
1576         return 0;
1577
1578     x264_emms();
1579     rc->qpa_rc += rc->qpm * h->mb.i_mb_width;
1580
1581     if( !rc->b_vbv )
1582         return 0;
1583
1584     float qscale = qp2qscale( rc->qpm );
1585     h->fdec->f_row_qp[y] = rc->qpm;
1586     h->fdec->f_row_qscale[y] = qscale;
1587
1588     update_predictor( &rc->row_pred[0], qscale, h->fdec->i_row_satd[y], h->fdec->i_row_bits[y] );
1589     if( h->sh.i_type != SLICE_TYPE_I && rc->qpm < h->fref[0][0]->f_row_qp[y] )
1590         update_predictor( &rc->row_pred[1], qscale, h->fdec->i_row_satds[0][0][y], h->fdec->i_row_bits[y] );
1591
1592     /* update ratecontrol per-mbpair in MBAFF */
1593     if( SLICE_MBAFF && !(y&1) )
1594         return 0;
1595
1596     /* FIXME: We don't currently support the case where there's a slice
1597      * boundary in between. */
1598     int can_reencode_row = h->sh.i_first_mb <= ((h->mb.i_mb_y - SLICE_MBAFF) * h->mb.i_mb_stride);
1599
1600     /* tweak quality based on difference from predicted size */
1601     float prev_row_qp = h->fdec->f_row_qp[y];
1602     float qp_absolute_max = h->param.rc.i_qp_max;
1603     if( rc->rate_factor_max_increment )
1604         qp_absolute_max = X264_MIN( qp_absolute_max, rc->qp_novbv + rc->rate_factor_max_increment );
1605     float qp_max = X264_MIN( prev_row_qp + h->param.rc.i_qp_step, qp_absolute_max );
1606     float qp_min = X264_MAX( prev_row_qp - h->param.rc.i_qp_step, h->param.rc.i_qp_min );
1607     float step_size = 0.5f;
1608     float buffer_left_planned = rc->buffer_fill - rc->frame_size_planned;
1609     float slice_size_planned = h->param.b_sliced_threads ? rc->slice_size_planned : rc->frame_size_planned;
1610     float max_frame_error = X264_MAX( 0.05f, 1.0f / h->mb.i_mb_height );
1611     float size_of_other_slices = 0;
1612     if( h->param.b_sliced_threads )
1613     {
1614         float size_of_other_slices_planned = 0;
1615         for( int i = 0; i < h->param.i_threads; i++ )
1616             if( h != h->thread[i] )
1617             {
1618                 size_of_other_slices += h->thread[i]->rc->frame_size_estimated;
1619                 size_of_other_slices_planned += h->thread[i]->rc->slice_size_planned;
1620             }
1621         float weight = rc->slice_size_planned / rc->frame_size_planned;
1622         size_of_other_slices = (size_of_other_slices - size_of_other_slices_planned) * weight + size_of_other_slices_planned;
1623     }
1624     if( y < h->i_threadslice_end-1 )
1625     {
1626         /* B-frames shouldn't use lower QP than their reference frames. */
1627         if( h->sh.i_type == SLICE_TYPE_B )
1628         {
1629             qp_min = X264_MAX( qp_min, X264_MAX( h->fref[0][0]->f_row_qp[y+1], h->fref[1][0]->f_row_qp[y+1] ) );
1630             rc->qpm = X264_MAX( rc->qpm, qp_min );
1631         }
1632
1633         /* More threads means we have to be more cautious in letting ratecontrol use up extra bits. */
1634         float rc_tol = buffer_left_planned / h->param.i_threads * rc->rate_tolerance;
1635         float b1 = predict_row_size_sum( h, y, rc->qpm ) + size_of_other_slices;
1636
1637         /* Don't increase the row QPs until a sufficent amount of the bits of the frame have been processed, in case a flat */
1638         /* area at the top of the frame was measured inaccurately. */
1639         if( row_bits_so_far( h, y ) < 0.05f * slice_size_planned )
1640             qp_max = qp_absolute_max = prev_row_qp;
1641
1642         if( h->sh.i_type != SLICE_TYPE_I )
1643             rc_tol *= 0.5f;
1644
1645         if( !rc->b_vbv_min_rate )
1646             qp_min = X264_MAX( qp_min, rc->qp_novbv );
1647
1648         while( rc->qpm < qp_max
1649                && ((b1 > rc->frame_size_planned + rc_tol) ||
1650                    (rc->buffer_fill - b1 < buffer_left_planned * 0.5f) ||
1651                    (b1 > rc->frame_size_planned && rc->qpm < rc->qp_novbv)) )
1652         {
1653             rc->qpm += step_size;
1654             b1 = predict_row_size_sum( h, y, rc->qpm ) + size_of_other_slices;
1655         }
1656
1657         while( rc->qpm > qp_min
1658                && (rc->qpm > h->fdec->f_row_qp[0] || rc->single_frame_vbv)
1659                && ((b1 < rc->frame_size_planned * 0.8f && rc->qpm <= prev_row_qp)
1660                || b1 < (rc->buffer_fill - rc->buffer_size + rc->buffer_rate) * 1.1f) )
1661         {
1662             rc->qpm -= step_size;
1663             b1 = predict_row_size_sum( h, y, rc->qpm ) + size_of_other_slices;
1664         }
1665
1666         /* avoid VBV underflow or MinCR violation */
1667         while( (rc->qpm < qp_absolute_max)
1668                && ((rc->buffer_fill - b1 < rc->buffer_rate * max_frame_error) ||
1669                    (rc->frame_size_maximum - b1 < rc->frame_size_maximum * max_frame_error)))
1670         {
1671             rc->qpm += step_size;
1672             b1 = predict_row_size_sum( h, y, rc->qpm ) + size_of_other_slices;
1673         }
1674
1675         h->rc->frame_size_estimated = b1 - size_of_other_slices;
1676
1677         /* If the current row was large enough to cause a large QP jump, try re-encoding it. */
1678         if( rc->qpm > qp_max && prev_row_qp < qp_max && can_reencode_row )
1679         {
1680             /* Bump QP to halfway in between... close enough. */
1681             rc->qpm = x264_clip3f( (prev_row_qp + rc->qpm)*0.5f, prev_row_qp + 1.0f, qp_max );
1682             rc->qpa_rc = rc->qpa_rc_prev;
1683             rc->qpa_aq = rc->qpa_aq_prev;
1684             h->fdec->i_row_bits[y] = 0;
1685             h->fdec->i_row_bits[y-SLICE_MBAFF] = 0;
1686             return -1;
1687         }
1688     }
1689     else
1690     {
1691         h->rc->frame_size_estimated = predict_row_size_sum( h, y, rc->qpm );
1692
1693         /* Last-ditch attempt: if the last row of the frame underflowed the VBV,
1694          * try again. */
1695         if( (h->rc->frame_size_estimated + size_of_other_slices) > (rc->buffer_fill - rc->buffer_rate * max_frame_error) &&
1696              rc->qpm < qp_max && can_reencode_row )
1697         {
1698             rc->qpm = qp_max;
1699             rc->qpa_rc = rc->qpa_rc_prev;
1700             rc->qpa_aq = rc->qpa_aq_prev;
1701             h->fdec->i_row_bits[y] = 0;
1702             h->fdec->i_row_bits[y-SLICE_MBAFF] = 0;
1703             return -1;
1704         }
1705     }
1706
1707     rc->qpa_rc_prev = rc->qpa_rc;
1708     rc->qpa_aq_prev = rc->qpa_aq;
1709
1710     return 0;
1711 }
1712
1713 int x264_ratecontrol_qp( x264_t *h )
1714 {
1715     x264_emms();
1716     return x264_clip3( h->rc->qpm + 0.5f, h->param.rc.i_qp_min, h->param.rc.i_qp_max );
1717 }
1718
1719 int x264_ratecontrol_mb_qp( x264_t *h )
1720 {
1721     x264_emms();
1722     float qp = h->rc->qpm;
1723     if( h->param.rc.i_aq_mode )
1724     {
1725          /* MB-tree currently doesn't adjust quantizers in unreferenced frames. */
1726         float qp_offset = h->fdec->b_kept_as_ref ? h->fenc->f_qp_offset[h->mb.i_mb_xy] : h->fenc->f_qp_offset_aq[h->mb.i_mb_xy];
1727         /* Scale AQ's effect towards zero in emergency mode. */
1728         if( qp > QP_MAX_SPEC )
1729             qp_offset *= (QP_MAX - qp) / (QP_MAX - QP_MAX_SPEC);
1730         qp += qp_offset;
1731     }
1732     return x264_clip3( qp + 0.5f, h->param.rc.i_qp_min, h->param.rc.i_qp_max );
1733 }
1734
1735 /* In 2pass, force the same frame types as in the 1st pass */
1736 int x264_ratecontrol_slice_type( x264_t *h, int frame_num )
1737 {
1738     x264_ratecontrol_t *rc = h->rc;
1739     if( h->param.rc.b_stat_read )
1740     {
1741         if( frame_num >= rc->num_entries )
1742         {
1743             /* We could try to initialize everything required for ABR and
1744              * adaptive B-frames, but that would be complicated.
1745              * So just calculate the average QP used so far. */
1746             h->param.rc.i_qp_constant = (h->stat.i_frame_count[SLICE_TYPE_P] == 0) ? 24 + QP_BD_OFFSET
1747                                       : 1 + h->stat.f_frame_qp[SLICE_TYPE_P] / h->stat.i_frame_count[SLICE_TYPE_P];
1748             rc->qp_constant[SLICE_TYPE_P] = x264_clip3( h->param.rc.i_qp_constant, 0, QP_MAX );
1749             rc->qp_constant[SLICE_TYPE_I] = x264_clip3( (int)( qscale2qp( qp2qscale( h->param.rc.i_qp_constant ) / fabs( h->param.rc.f_ip_factor )) + 0.5 ), 0, QP_MAX );
1750             rc->qp_constant[SLICE_TYPE_B] = x264_clip3( (int)( qscale2qp( qp2qscale( h->param.rc.i_qp_constant ) * fabs( h->param.rc.f_pb_factor )) + 0.5 ), 0, QP_MAX );
1751
1752             x264_log( h, X264_LOG_ERROR, "2nd pass has more frames than 1st pass (%d)\n", rc->num_entries );
1753             x264_log( h, X264_LOG_ERROR, "continuing anyway, at constant QP=%d\n", h->param.rc.i_qp_constant );
1754             if( h->param.i_bframe_adaptive )
1755                 x264_log( h, X264_LOG_ERROR, "disabling adaptive B-frames\n" );
1756
1757             for( int i = 0; i < h->param.i_threads; i++ )
1758             {
1759                 h->thread[i]->rc->b_abr = 0;
1760                 h->thread[i]->rc->b_2pass = 0;
1761                 h->thread[i]->param.rc.i_rc_method = X264_RC_CQP;
1762                 h->thread[i]->param.rc.b_stat_read = 0;
1763                 h->thread[i]->param.i_bframe_adaptive = 0;
1764                 h->thread[i]->param.i_scenecut_threshold = 0;
1765                 h->thread[i]->param.rc.b_mb_tree = 0;
1766                 if( h->thread[i]->param.i_bframe > 1 )
1767                     h->thread[i]->param.i_bframe = 1;
1768             }
1769             return X264_TYPE_AUTO;
1770         }
1771         return rc->entry[frame_num].frame_type;
1772     }
1773     else
1774         return X264_TYPE_AUTO;
1775 }
1776
1777 void x264_ratecontrol_set_weights( x264_t *h, x264_frame_t *frm )
1778 {
1779     ratecontrol_entry_t *rce = &h->rc->entry[frm->i_frame];
1780     if( h->param.analyse.i_weighted_pred <= 0 )
1781         return;
1782
1783     if( rce->i_weight_denom[0] >= 0 )
1784         SET_WEIGHT( frm->weight[0][0], 1, rce->weight[0][0], rce->i_weight_denom[0], rce->weight[0][1] );
1785
1786     if( rce->i_weight_denom[1] >= 0 )
1787     {
1788         SET_WEIGHT( frm->weight[0][1], 1, rce->weight[1][0], rce->i_weight_denom[1], rce->weight[1][1] );
1789         SET_WEIGHT( frm->weight[0][2], 1, rce->weight[2][0], rce->i_weight_denom[1], rce->weight[2][1] );
1790     }
1791 }
1792
1793 /* After encoding one frame, save stats and update ratecontrol state */
1794 int x264_ratecontrol_end( x264_t *h, int bits, int *filler )
1795 {
1796     x264_ratecontrol_t *rc = h->rc;
1797     const int *mbs = h->stat.frame.i_mb_count;
1798
1799     x264_emms();
1800
1801     h->stat.frame.i_mb_count_skip = mbs[P_SKIP] + mbs[B_SKIP];
1802     h->stat.frame.i_mb_count_i = mbs[I_16x16] + mbs[I_8x8] + mbs[I_4x4];
1803     h->stat.frame.i_mb_count_p = mbs[P_L0] + mbs[P_8x8];
1804     for( int i = B_DIRECT; i < B_8x8; i++ )
1805         h->stat.frame.i_mb_count_p += mbs[i];
1806
1807     h->fdec->f_qp_avg_rc = rc->qpa_rc /= h->mb.i_mb_count;
1808     h->fdec->f_qp_avg_aq = (float)rc->qpa_aq / h->mb.i_mb_count;
1809     h->fdec->f_crf_avg = h->param.rc.f_rf_constant + h->fdec->f_qp_avg_rc - rc->qp_novbv;
1810
1811     if( h->param.rc.b_stat_write )
1812     {
1813         char c_type = h->sh.i_type==SLICE_TYPE_I ? (h->fenc->i_poc==0 ? 'I' : 'i')
1814                     : h->sh.i_type==SLICE_TYPE_P ? 'P'
1815                     : h->fenc->b_kept_as_ref ? 'B' : 'b';
1816         int dir_frame = h->stat.frame.i_direct_score[1] - h->stat.frame.i_direct_score[0];
1817         int dir_avg = h->stat.i_direct_score[1] - h->stat.i_direct_score[0];
1818         char c_direct = h->mb.b_direct_auto_write ?
1819                         ( dir_frame>0 ? 's' : dir_frame<0 ? 't' :
1820                           dir_avg>0 ? 's' : dir_avg<0 ? 't' : '-' )
1821                         : '-';
1822         if( fprintf( rc->p_stat_file_out,
1823                  "in:%d out:%d type:%c dur:%"PRId64" cpbdur:%"PRId64" q:%.2f aq:%.2f tex:%d mv:%d misc:%d imb:%d pmb:%d smb:%d d:%c ref:",
1824                  h->fenc->i_frame, h->i_frame,
1825                  c_type, h->fenc->i_duration,
1826                  h->fenc->i_cpb_duration,
1827                  rc->qpa_rc, h->fdec->f_qp_avg_aq,
1828                  h->stat.frame.i_tex_bits,
1829                  h->stat.frame.i_mv_bits,
1830                  h->stat.frame.i_misc_bits,
1831                  h->stat.frame.i_mb_count_i,
1832                  h->stat.frame.i_mb_count_p,
1833                  h->stat.frame.i_mb_count_skip,
1834                  c_direct) < 0 )
1835             goto fail;
1836
1837         /* Only write information for reference reordering once. */
1838         int use_old_stats = h->param.rc.b_stat_read && rc->rce->refs > 1;
1839         for( int i = 0; i < (use_old_stats ? rc->rce->refs : h->i_ref[0]); i++ )
1840         {
1841             int refcount = use_old_stats         ? rc->rce->refcount[i]
1842                          : PARAM_INTERLACED      ? h->stat.frame.i_mb_count_ref[0][i*2]
1843                                                  + h->stat.frame.i_mb_count_ref[0][i*2+1]
1844                          :                         h->stat.frame.i_mb_count_ref[0][i];
1845             if( fprintf( rc->p_stat_file_out, "%d ", refcount ) < 0 )
1846                 goto fail;
1847         }
1848
1849         if( h->param.analyse.i_weighted_pred >= X264_WEIGHTP_SIMPLE && h->sh.weight[0][0].weightfn )
1850         {
1851             if( fprintf( rc->p_stat_file_out, "w:%d,%d,%d",
1852                          h->sh.weight[0][0].i_denom, h->sh.weight[0][0].i_scale, h->sh.weight[0][0].i_offset ) < 0 )
1853                 goto fail;
1854             if( h->sh.weight[0][1].weightfn || h->sh.weight[0][2].weightfn )
1855             {
1856                 if( fprintf( rc->p_stat_file_out, ",%d,%d,%d,%d,%d ",
1857                              h->sh.weight[0][1].i_denom, h->sh.weight[0][1].i_scale, h->sh.weight[0][1].i_offset,
1858                              h->sh.weight[0][2].i_scale, h->sh.weight[0][2].i_offset ) < 0 )
1859                     goto fail;
1860             }
1861             else if( fprintf( rc->p_stat_file_out, " " ) < 0 )
1862                 goto fail;
1863         }
1864
1865         if( fprintf( rc->p_stat_file_out, ";\n") < 0 )
1866             goto fail;
1867
1868         /* Don't re-write the data in multi-pass mode. */
1869         if( h->param.rc.b_mb_tree && h->fenc->b_kept_as_ref && !h->param.rc.b_stat_read )
1870         {
1871             uint8_t i_type = h->sh.i_type;
1872             /* Values are stored as big-endian FIX8.8 */
1873             for( int i = 0; i < h->mb.i_mb_count; i++ )
1874                 rc->mbtree.qp_buffer[0][i] = endian_fix16( h->fenc->f_qp_offset[i]*256.0 );
1875             if( fwrite( &i_type, 1, 1, rc->p_mbtree_stat_file_out ) < 1 )
1876                 goto fail;
1877             if( fwrite( rc->mbtree.qp_buffer[0], sizeof(uint16_t), h->mb.i_mb_count, rc->p_mbtree_stat_file_out ) < h->mb.i_mb_count )
1878                 goto fail;
1879         }
1880     }
1881
1882     if( rc->b_abr )
1883     {
1884         if( h->sh.i_type != SLICE_TYPE_B )
1885             rc->cplxr_sum += bits * qp2qscale( rc->qpa_rc ) / rc->last_rceq;
1886         else
1887         {
1888             /* Depends on the fact that B-frame's QP is an offset from the following P-frame's.
1889              * Not perfectly accurate with B-refs, but good enough. */
1890             rc->cplxr_sum += bits * qp2qscale( rc->qpa_rc ) / (rc->last_rceq * fabs( h->param.rc.f_pb_factor ));
1891         }
1892         rc->cplxr_sum *= rc->cbr_decay;
1893         rc->wanted_bits_window += h->fenc->f_duration * rc->bitrate;
1894         rc->wanted_bits_window *= rc->cbr_decay;
1895     }
1896
1897     if( rc->b_2pass )
1898         rc->expected_bits_sum += qscale2bits( rc->rce, qp2qscale( rc->rce->new_qp ) );
1899
1900     if( h->mb.b_variable_qp )
1901     {
1902         if( h->sh.i_type == SLICE_TYPE_B )
1903         {
1904             rc->bframe_bits += bits;
1905             if( h->fenc->b_last_minigop_bframe )
1906             {
1907                 update_predictor( rc->pred_b_from_p, qp2qscale( rc->qpa_rc ),
1908                                   h->fref[1][h->i_ref[1]-1]->i_satd, rc->bframe_bits / rc->bframes );
1909                 rc->bframe_bits = 0;
1910             }
1911         }
1912     }
1913
1914     *filler = update_vbv( h, bits );
1915     rc->filler_bits_sum += *filler * 8;
1916
1917     if( h->sps->vui.b_nal_hrd_parameters_present )
1918     {
1919         if( h->fenc->i_frame == 0 )
1920         {
1921             // access unit initialises the HRD
1922             h->fenc->hrd_timing.cpb_initial_arrival_time = 0;
1923             rc->initial_cpb_removal_delay = h->initial_cpb_removal_delay;
1924             rc->initial_cpb_removal_delay_offset = h->initial_cpb_removal_delay_offset;
1925             h->fenc->hrd_timing.cpb_removal_time = rc->nrt_first_access_unit = (double)rc->initial_cpb_removal_delay / 90000;
1926         }
1927         else
1928         {
1929             h->fenc->hrd_timing.cpb_removal_time = rc->nrt_first_access_unit + (double)(h->fenc->i_cpb_delay - h->i_cpb_delay_pir_offset) *
1930                                                    h->sps->vui.i_num_units_in_tick / h->sps->vui.i_time_scale;
1931
1932             if( h->fenc->b_keyframe )
1933             {
1934                 rc->nrt_first_access_unit = h->fenc->hrd_timing.cpb_removal_time;
1935                 rc->initial_cpb_removal_delay = h->initial_cpb_removal_delay;
1936                 rc->initial_cpb_removal_delay_offset = h->initial_cpb_removal_delay_offset;
1937             }
1938
1939             double cpb_earliest_arrival_time = h->fenc->hrd_timing.cpb_removal_time - (double)rc->initial_cpb_removal_delay / 90000;
1940             if( !h->fenc->b_keyframe )
1941                 cpb_earliest_arrival_time -= (double)rc->initial_cpb_removal_delay_offset / 90000;
1942
1943             if( h->sps->vui.hrd.b_cbr_hrd )
1944                 h->fenc->hrd_timing.cpb_initial_arrival_time = rc->previous_cpb_final_arrival_time;
1945             else
1946                 h->fenc->hrd_timing.cpb_initial_arrival_time = X264_MAX( rc->previous_cpb_final_arrival_time, cpb_earliest_arrival_time );
1947         }
1948         int filler_bits = *filler ? X264_MAX( (FILLER_OVERHEAD - h->param.b_annexb), *filler )*8 : 0;
1949         // Equation C-6
1950         h->fenc->hrd_timing.cpb_final_arrival_time = rc->previous_cpb_final_arrival_time = h->fenc->hrd_timing.cpb_initial_arrival_time +
1951                                                      (double)(bits + filler_bits) / h->sps->vui.hrd.i_bit_rate_unscaled;
1952
1953         h->fenc->hrd_timing.dpb_output_time = (double)h->fenc->i_dpb_output_delay * h->sps->vui.i_num_units_in_tick / h->sps->vui.i_time_scale +
1954                                               h->fenc->hrd_timing.cpb_removal_time;
1955     }
1956
1957     return 0;
1958 fail:
1959     x264_log( h, X264_LOG_ERROR, "ratecontrol_end: stats file could not be written to\n" );
1960     return -1;
1961 }
1962
1963 /****************************************************************************
1964  * 2 pass functions
1965  ***************************************************************************/
1966
1967 /**
1968  * modify the bitrate curve from pass1 for one frame
1969  */
1970 static double get_qscale(x264_t *h, ratecontrol_entry_t *rce, double rate_factor, int frame_num)
1971 {
1972     x264_ratecontrol_t *rcc= h->rc;
1973     x264_zone_t *zone = get_zone( h, frame_num );
1974     double q;
1975     if( h->param.rc.b_mb_tree )
1976     {
1977         double timescale = (double)h->sps->vui.i_num_units_in_tick / h->sps->vui.i_time_scale;
1978         q = pow( BASE_FRAME_DURATION / CLIP_DURATION(rce->i_duration * timescale), 1 - h->param.rc.f_qcompress );
1979     }
1980     else
1981         q = pow( rce->blurred_complexity, 1 - rcc->qcompress );
1982
1983     // avoid NaN's in the rc_eq
1984     if( !isfinite(q) || rce->tex_bits + rce->mv_bits == 0 )
1985         q = rcc->last_qscale_for[rce->pict_type];
1986     else
1987     {
1988         rcc->last_rceq = q;
1989         q /= rate_factor;
1990         rcc->last_qscale = q;
1991     }
1992
1993     if( zone )
1994     {
1995         if( zone->b_force_qp )
1996             q = qp2qscale( zone->i_qp );
1997         else
1998             q /= zone->f_bitrate_factor;
1999     }
2000
2001     return q;
2002 }
2003
2004 static double get_diff_limited_q(x264_t *h, ratecontrol_entry_t *rce, double q, int frame_num)
2005 {
2006     x264_ratecontrol_t *rcc = h->rc;
2007     const int pict_type = rce->pict_type;
2008     x264_zone_t *zone = get_zone( h, frame_num );
2009
2010     // force I/B quants as a function of P quants
2011     const double last_p_q    = rcc->last_qscale_for[SLICE_TYPE_P];
2012     const double last_non_b_q= rcc->last_qscale_for[rcc->last_non_b_pict_type];
2013     if( pict_type == SLICE_TYPE_I )
2014     {
2015         double iq = q;
2016         double pq = qp2qscale( rcc->accum_p_qp / rcc->accum_p_norm );
2017         double ip_factor = fabs( h->param.rc.f_ip_factor );
2018         /* don't apply ip_factor if the following frame is also I */
2019         if( rcc->accum_p_norm <= 0 )
2020             q = iq;
2021         else if( h->param.rc.f_ip_factor < 0 )
2022             q = iq / ip_factor;
2023         else if( rcc->accum_p_norm >= 1 )
2024             q = pq / ip_factor;
2025         else
2026             q = rcc->accum_p_norm * pq / ip_factor + (1 - rcc->accum_p_norm) * iq;
2027     }
2028     else if( pict_type == SLICE_TYPE_B )
2029     {
2030         if( h->param.rc.f_pb_factor > 0 )
2031             q = last_non_b_q;
2032         if( !rce->kept_as_ref )
2033             q *= fabs( h->param.rc.f_pb_factor );
2034     }
2035     else if( pict_type == SLICE_TYPE_P
2036              && rcc->last_non_b_pict_type == SLICE_TYPE_P
2037              && rce->tex_bits == 0 )
2038     {
2039         q = last_p_q;
2040     }
2041
2042     /* last qscale / qdiff stuff */
2043     if( rcc->last_non_b_pict_type == pict_type &&
2044         (pict_type!=SLICE_TYPE_I || rcc->last_accum_p_norm < 1) )
2045     {
2046         double last_q = rcc->last_qscale_for[pict_type];
2047         double max_qscale = last_q * rcc->lstep;
2048         double min_qscale = last_q / rcc->lstep;
2049
2050         if     ( q > max_qscale ) q = max_qscale;
2051         else if( q < min_qscale ) q = min_qscale;
2052     }
2053
2054     rcc->last_qscale_for[pict_type] = q;
2055     if( pict_type != SLICE_TYPE_B )
2056         rcc->last_non_b_pict_type = pict_type;
2057     if( pict_type == SLICE_TYPE_I )
2058     {
2059         rcc->last_accum_p_norm = rcc->accum_p_norm;
2060         rcc->accum_p_norm = 0;
2061         rcc->accum_p_qp = 0;
2062     }
2063     if( pict_type == SLICE_TYPE_P )
2064     {
2065         float mask = 1 - pow( (float)rce->i_count / rcc->nmb, 2 );
2066         rcc->accum_p_qp   = mask * (qscale2qp( q ) + rcc->accum_p_qp);
2067         rcc->accum_p_norm = mask * (1 + rcc->accum_p_norm);
2068     }
2069
2070     if( zone )
2071     {
2072         if( zone->b_force_qp )
2073             q = qp2qscale( zone->i_qp );
2074         else
2075             q /= zone->f_bitrate_factor;
2076     }
2077
2078     return q;
2079 }
2080
2081 static float predict_size( predictor_t *p, float q, float var )
2082 {
2083     return (p->coeff*var + p->offset) / (q*p->count);
2084 }
2085
2086 static void update_predictor( predictor_t *p, float q, float var, float bits )
2087 {
2088     float range = 1.5;
2089     if( var < 10 )
2090         return;
2091     float old_coeff = p->coeff / p->count;
2092     float old_offset = p->offset / p->count;
2093     float new_coeff = X264_MAX( (bits*q - old_offset) / var, p->coeff_min );
2094     float new_coeff_clipped = x264_clip3f( new_coeff, old_coeff/range, old_coeff*range );
2095     float new_offset = bits*q - new_coeff_clipped * var;
2096     if( new_offset >= 0 )
2097         new_coeff = new_coeff_clipped;
2098     else
2099         new_offset = 0;
2100     p->count  *= p->decay;
2101     p->coeff  *= p->decay;
2102     p->offset *= p->decay;
2103     p->count  ++;
2104     p->coeff  += new_coeff;
2105     p->offset += new_offset;
2106 }
2107
2108 // update VBV after encoding a frame
2109 static int update_vbv( x264_t *h, int bits )
2110 {
2111     int filler = 0;
2112     int bitrate = h->sps->vui.hrd.i_bit_rate_unscaled;
2113     x264_ratecontrol_t *rcc = h->rc;
2114     x264_ratecontrol_t *rct = h->thread[0]->rc;
2115     int64_t buffer_size = (int64_t)h->sps->vui.hrd.i_cpb_size_unscaled * h->sps->vui.i_time_scale;
2116
2117     if( rcc->last_satd >= h->mb.i_mb_count )
2118         update_predictor( &rct->pred[h->sh.i_type], qp2qscale( rcc->qpa_rc ), rcc->last_satd, bits );
2119
2120     if( !rcc->b_vbv )
2121         return filler;
2122
2123     uint64_t buffer_diff = (uint64_t)bits * h->sps->vui.i_time_scale;
2124     rct->buffer_fill_final -= buffer_diff;
2125     rct->buffer_fill_final_min -= buffer_diff;
2126
2127     if( rct->buffer_fill_final_min < 0 )
2128     {
2129         double underflow = (double)rct->buffer_fill_final_min / h->sps->vui.i_time_scale;
2130         if( rcc->rate_factor_max_increment && rcc->qpm >= rcc->qp_novbv + rcc->rate_factor_max_increment )
2131             x264_log( h, X264_LOG_DEBUG, "VBV underflow due to CRF-max (frame %d, %.0f bits)\n", h->i_frame, underflow );
2132         else
2133             x264_log( h, X264_LOG_WARNING, "VBV underflow (frame %d, %.0f bits)\n", h->i_frame, underflow );
2134         rct->buffer_fill_final =
2135         rct->buffer_fill_final_min = 0;
2136     }
2137
2138     if( h->param.i_avcintra_class )
2139         buffer_diff = buffer_size;
2140     else
2141         buffer_diff = (uint64_t)bitrate * h->sps->vui.i_num_units_in_tick * h->fenc->i_cpb_duration;
2142     rct->buffer_fill_final += buffer_diff;
2143     rct->buffer_fill_final_min += buffer_diff;
2144
2145     if( rct->buffer_fill_final > buffer_size )
2146     {
2147         if( h->param.rc.b_filler )
2148         {
2149             int64_t scale = (int64_t)h->sps->vui.i_time_scale * 8;
2150             filler = (rct->buffer_fill_final - buffer_size + scale - 1) / scale;
2151             bits = h->param.i_avcintra_class ? filler * 8 : X264_MAX( (FILLER_OVERHEAD - h->param.b_annexb), filler ) * 8;
2152             buffer_diff = (uint64_t)bits * h->sps->vui.i_time_scale;
2153             rct->buffer_fill_final -= buffer_diff;
2154             rct->buffer_fill_final_min -= buffer_diff;
2155         }
2156         else
2157         {
2158             rct->buffer_fill_final = X264_MIN( rct->buffer_fill_final, buffer_size );
2159             rct->buffer_fill_final_min = X264_MIN( rct->buffer_fill_final_min, buffer_size );
2160         }
2161     }
2162
2163     return filler;
2164 }
2165
2166 void x264_hrd_fullness( x264_t *h )
2167 {
2168     x264_ratecontrol_t *rct = h->thread[0]->rc;
2169     uint64_t denom = (uint64_t)h->sps->vui.hrd.i_bit_rate_unscaled * h->sps->vui.i_time_scale / rct->hrd_multiply_denom;
2170     uint64_t cpb_state = rct->buffer_fill_final;
2171     uint64_t cpb_size = (uint64_t)h->sps->vui.hrd.i_cpb_size_unscaled * h->sps->vui.i_time_scale;
2172     uint64_t multiply_factor = 90000 / rct->hrd_multiply_denom;
2173
2174     if( rct->buffer_fill_final < 0 || rct->buffer_fill_final > (int64_t)cpb_size )
2175     {
2176          x264_log( h, X264_LOG_WARNING, "CPB %s: %.0f bits in a %.0f-bit buffer\n",
2177                    rct->buffer_fill_final < 0 ? "underflow" : "overflow",
2178                    (double)rct->buffer_fill_final / h->sps->vui.i_time_scale, (double)cpb_size / h->sps->vui.i_time_scale );
2179     }
2180
2181     h->initial_cpb_removal_delay = (multiply_factor * cpb_state) / denom;
2182     h->initial_cpb_removal_delay_offset = (multiply_factor * cpb_size) / denom - h->initial_cpb_removal_delay;
2183
2184     int64_t decoder_buffer_fill = h->initial_cpb_removal_delay * denom / multiply_factor;
2185     rct->buffer_fill_final_min = X264_MIN( rct->buffer_fill_final_min, decoder_buffer_fill );
2186 }
2187
2188 // provisionally update VBV according to the planned size of all frames currently in progress
2189 static void update_vbv_plan( x264_t *h, int overhead )
2190 {
2191     x264_ratecontrol_t *rcc = h->rc;
2192     rcc->buffer_fill = h->thread[0]->rc->buffer_fill_final_min / h->sps->vui.i_time_scale;
2193     if( h->i_thread_frames > 1 )
2194     {
2195         int j = h->rc - h->thread[0]->rc;
2196         for( int i = 1; i < h->i_thread_frames; i++ )
2197         {
2198             x264_t *t = h->thread[ (j+i)%h->i_thread_frames ];
2199             double bits = t->rc->frame_size_planned;
2200             if( !t->b_thread_active )
2201                 continue;
2202             bits = X264_MAX(bits, t->rc->frame_size_estimated);
2203             rcc->buffer_fill -= bits;
2204             rcc->buffer_fill = X264_MAX( rcc->buffer_fill, 0 );
2205             rcc->buffer_fill += t->rc->buffer_rate;
2206             rcc->buffer_fill = X264_MIN( rcc->buffer_fill, rcc->buffer_size );
2207         }
2208     }
2209     rcc->buffer_fill = X264_MIN( rcc->buffer_fill, rcc->buffer_size );
2210     rcc->buffer_fill -= overhead;
2211 }
2212
2213 // apply VBV constraints and clip qscale to between lmin and lmax
2214 static double clip_qscale( x264_t *h, int pict_type, double q )
2215 {
2216     x264_ratecontrol_t *rcc = h->rc;
2217     double lmin = rcc->lmin[pict_type];
2218     double lmax = rcc->lmax[pict_type];
2219     if( rcc->rate_factor_max_increment )
2220         lmax = X264_MIN( lmax, qp2qscale( rcc->qp_novbv + rcc->rate_factor_max_increment ) );
2221     double q0 = q;
2222
2223     /* B-frames are not directly subject to VBV,
2224      * since they are controlled by the P-frames' QPs. */
2225
2226     if( rcc->b_vbv && rcc->last_satd > 0 )
2227     {
2228         double fenc_cpb_duration = (double)h->fenc->i_cpb_duration *
2229                                    h->sps->vui.i_num_units_in_tick / h->sps->vui.i_time_scale;
2230         /* Lookahead VBV: raise the quantizer as necessary such that no frames in
2231          * the lookahead overflow and such that the buffer is in a reasonable state
2232          * by the end of the lookahead. */
2233         if( h->param.rc.i_lookahead )
2234         {
2235             int terminate = 0;
2236
2237             /* Avoid an infinite loop. */
2238             for( int iterations = 0; iterations < 1000 && terminate != 3; iterations++ )
2239             {
2240                 double frame_q[3];
2241                 double cur_bits = predict_size( &rcc->pred[h->sh.i_type], q, rcc->last_satd );
2242                 double buffer_fill_cur = rcc->buffer_fill - cur_bits;
2243                 double target_fill;
2244                 double total_duration = 0;
2245                 double last_duration = fenc_cpb_duration;
2246                 frame_q[0] = h->sh.i_type == SLICE_TYPE_I ? q * h->param.rc.f_ip_factor : q;
2247                 frame_q[1] = frame_q[0] * h->param.rc.f_pb_factor;
2248                 frame_q[2] = frame_q[0] / h->param.rc.f_ip_factor;
2249
2250                 /* Loop over the planned future frames. */
2251                 for( int j = 0; buffer_fill_cur >= 0 && buffer_fill_cur <= rcc->buffer_size; j++ )
2252                 {
2253                     total_duration += last_duration;
2254                     buffer_fill_cur += rcc->vbv_max_rate * last_duration;
2255                     int i_type = h->fenc->i_planned_type[j];
2256                     int i_satd = h->fenc->i_planned_satd[j];
2257                     if( i_type == X264_TYPE_AUTO )
2258                         break;
2259                     i_type = IS_X264_TYPE_I( i_type ) ? SLICE_TYPE_I : IS_X264_TYPE_B( i_type ) ? SLICE_TYPE_B : SLICE_TYPE_P;
2260                     cur_bits = predict_size( &rcc->pred[i_type], frame_q[i_type], i_satd );
2261                     buffer_fill_cur -= cur_bits;
2262                     last_duration = h->fenc->f_planned_cpb_duration[j];
2263                 }
2264                 /* Try to get to get the buffer at least 50% filled, but don't set an impossible goal. */
2265                 target_fill = X264_MIN( rcc->buffer_fill + total_duration * rcc->vbv_max_rate * 0.5, rcc->buffer_size * 0.5 );
2266                 if( buffer_fill_cur < target_fill )
2267                 {
2268                     q *= 1.01;
2269                     terminate |= 1;
2270                     continue;
2271                 }
2272                 /* Try to get the buffer no more than 80% filled, but don't set an impossible goal. */
2273                 target_fill = x264_clip3f( rcc->buffer_fill - total_duration * rcc->vbv_max_rate * 0.5, rcc->buffer_size * 0.8, rcc->buffer_size );
2274                 if( rcc->b_vbv_min_rate && buffer_fill_cur > target_fill )
2275                 {
2276                     q /= 1.01;
2277                     terminate |= 2;
2278                     continue;
2279                 }
2280                 break;
2281             }
2282         }
2283         /* Fallback to old purely-reactive algorithm: no lookahead. */
2284         else
2285         {
2286             if( ( pict_type == SLICE_TYPE_P ||
2287                 ( pict_type == SLICE_TYPE_I && rcc->last_non_b_pict_type == SLICE_TYPE_I ) ) &&
2288                 rcc->buffer_fill/rcc->buffer_size < 0.5 )
2289             {
2290                 q /= x264_clip3f( 2.0*rcc->buffer_fill/rcc->buffer_size, 0.5, 1.0 );
2291             }
2292
2293             /* Now a hard threshold to make sure the frame fits in VBV.
2294              * This one is mostly for I-frames. */
2295             double bits = predict_size( &rcc->pred[h->sh.i_type], q, rcc->last_satd );
2296             /* For small VBVs, allow the frame to use up the entire VBV. */
2297             double max_fill_factor = h->param.rc.i_vbv_buffer_size >= 5*h->param.rc.i_vbv_max_bitrate / rcc->fps ? 2 : 1;
2298             /* For single-frame VBVs, request that the frame use up the entire VBV. */
2299             double min_fill_factor = rcc->single_frame_vbv ? 1 : 2;
2300
2301             if( bits > rcc->buffer_fill/max_fill_factor )
2302             {
2303                 double qf = x264_clip3f( rcc->buffer_fill/(max_fill_factor*bits), 0.2, 1.0 );
2304                 q /= qf;
2305                 bits *= qf;
2306             }
2307             if( bits < rcc->buffer_rate/min_fill_factor )
2308             {
2309                 double qf = x264_clip3f( bits*min_fill_factor/rcc->buffer_rate, 0.001, 1.0 );
2310                 q *= qf;
2311             }
2312             q = X264_MAX( q0, q );
2313         }
2314
2315         /* Check B-frame complexity, and use up any bits that would
2316          * overflow before the next P-frame. */
2317         if( h->sh.i_type == SLICE_TYPE_P && !rcc->single_frame_vbv )
2318         {
2319             int nb = rcc->bframes;
2320             double bits = predict_size( &rcc->pred[h->sh.i_type], q, rcc->last_satd );
2321             double pbbits = bits;
2322             double bbits = predict_size( rcc->pred_b_from_p, q * h->param.rc.f_pb_factor, rcc->last_satd );
2323             double space;
2324             double bframe_cpb_duration = 0;
2325             double minigop_cpb_duration;
2326             for( int i = 0; i < nb; i++ )
2327                 bframe_cpb_duration += h->fenc->f_planned_cpb_duration[i];
2328
2329             if( bbits * nb > bframe_cpb_duration * rcc->vbv_max_rate )
2330                 nb = 0;
2331             pbbits += nb * bbits;
2332
2333             minigop_cpb_duration = bframe_cpb_duration + fenc_cpb_duration;
2334             space = rcc->buffer_fill + minigop_cpb_duration*rcc->vbv_max_rate - rcc->buffer_size;
2335             if( pbbits < space )
2336             {
2337                 q *= X264_MAX( pbbits / space, bits / (0.5 * rcc->buffer_size) );
2338             }
2339             q = X264_MAX( q0/2, q );
2340         }
2341
2342         /* Apply MinCR and buffer fill restrictions */
2343         double bits = predict_size( &rcc->pred[h->sh.i_type], q, rcc->last_satd );
2344         double frame_size_maximum = X264_MIN( rcc->frame_size_maximum, X264_MAX( rcc->buffer_fill, 0.001 ) );
2345         if( bits > frame_size_maximum )
2346             q *= bits / frame_size_maximum;
2347
2348         if( !rcc->b_vbv_min_rate )
2349             q = X264_MAX( q0, q );
2350     }
2351
2352     if( lmin==lmax )
2353         return lmin;
2354     else if( rcc->b_2pass )
2355     {
2356         double min2 = log( lmin );
2357         double max2 = log( lmax );
2358         q = (log(q) - min2)/(max2-min2) - 0.5;
2359         q = 1.0/(1.0 + exp( -4*q ));
2360         q = q*(max2-min2) + min2;
2361         return exp( q );
2362     }
2363     else
2364         return x264_clip3f( q, lmin, lmax );
2365 }
2366
2367 // update qscale for 1 frame based on actual bits used so far
2368 static float rate_estimate_qscale( x264_t *h )
2369 {
2370     float q;
2371     x264_ratecontrol_t *rcc = h->rc;
2372     ratecontrol_entry_t rce = {0};
2373     int pict_type = h->sh.i_type;
2374     int64_t total_bits = 8*(h->stat.i_frame_size[SLICE_TYPE_I]
2375                           + h->stat.i_frame_size[SLICE_TYPE_P]
2376                           + h->stat.i_frame_size[SLICE_TYPE_B])
2377                        - rcc->filler_bits_sum;
2378
2379     if( rcc->b_2pass )
2380     {
2381         rce = *rcc->rce;
2382         if( pict_type != rce.pict_type )
2383         {
2384             x264_log( h, X264_LOG_ERROR, "slice=%c but 2pass stats say %c\n",
2385                       slice_type_to_char[pict_type], slice_type_to_char[rce.pict_type] );
2386         }
2387     }
2388
2389     if( pict_type == SLICE_TYPE_B )
2390     {
2391         /* B-frames don't have independent ratecontrol, but rather get the
2392          * average QP of the two adjacent P-frames + an offset */
2393
2394         int i0 = IS_X264_TYPE_I(h->fref_nearest[0]->i_type);
2395         int i1 = IS_X264_TYPE_I(h->fref_nearest[1]->i_type);
2396         int dt0 = abs(h->fenc->i_poc - h->fref_nearest[0]->i_poc);
2397         int dt1 = abs(h->fenc->i_poc - h->fref_nearest[1]->i_poc);
2398         float q0 = h->fref_nearest[0]->f_qp_avg_rc;
2399         float q1 = h->fref_nearest[1]->f_qp_avg_rc;
2400
2401         if( h->fref_nearest[0]->i_type == X264_TYPE_BREF )
2402             q0 -= rcc->pb_offset/2;
2403         if( h->fref_nearest[1]->i_type == X264_TYPE_BREF )
2404             q1 -= rcc->pb_offset/2;
2405
2406         if( i0 && i1 )
2407             q = (q0 + q1) / 2 + rcc->ip_offset;
2408         else if( i0 )
2409             q = q1;
2410         else if( i1 )
2411             q = q0;
2412         else
2413             q = (q0*dt1 + q1*dt0) / (dt0 + dt1);
2414
2415         if( h->fenc->b_kept_as_ref )
2416             q += rcc->pb_offset/2;
2417         else
2418             q += rcc->pb_offset;
2419
2420         if( rcc->b_2pass && rcc->b_vbv )
2421             rcc->frame_size_planned = qscale2bits( &rce, qp2qscale( q ) );
2422         else
2423             rcc->frame_size_planned = predict_size( rcc->pred_b_from_p, qp2qscale( q ), h->fref[1][h->i_ref[1]-1]->i_satd );
2424         /* Limit planned size by MinCR */
2425         if( rcc->b_vbv )
2426             rcc->frame_size_planned = X264_MIN( rcc->frame_size_planned, rcc->frame_size_maximum );
2427         h->rc->frame_size_estimated = rcc->frame_size_planned;
2428
2429         /* For row SATDs */
2430         if( rcc->b_vbv )
2431             rcc->last_satd = x264_rc_analyse_slice( h );
2432         rcc->qp_novbv = q;
2433         return qp2qscale( q );
2434     }
2435     else
2436     {
2437         double abr_buffer = 2 * rcc->rate_tolerance * rcc->bitrate;
2438
2439         if( rcc->b_2pass )
2440         {
2441             double lmin = rcc->lmin[pict_type];
2442             double lmax = rcc->lmax[pict_type];
2443             int64_t diff;
2444             int64_t predicted_bits = total_bits;
2445
2446             if( rcc->b_vbv )
2447             {
2448                 if( h->i_thread_frames > 1 )
2449                 {
2450                     int j = h->rc - h->thread[0]->rc;
2451                     for( int i = 1; i < h->i_thread_frames; i++ )
2452                     {
2453                         x264_t *t = h->thread[ (j+i)%h->i_thread_frames ];
2454                         double bits = t->rc->frame_size_planned;
2455                         if( !t->b_thread_active )
2456                             continue;
2457                         bits = X264_MAX(bits, t->rc->frame_size_estimated);
2458                         predicted_bits += (int64_t)bits;
2459                     }
2460                 }
2461             }
2462             else
2463             {
2464                 if( h->i_frame < h->i_thread_frames )
2465                     predicted_bits += (int64_t)h->i_frame * rcc->bitrate / rcc->fps;
2466                 else
2467                     predicted_bits += (int64_t)(h->i_thread_frames - 1) * rcc->bitrate / rcc->fps;
2468             }
2469
2470             /* Adjust ABR buffer based on distance to the end of the video. */
2471             if( rcc->num_entries > h->i_frame )
2472             {
2473                 double final_bits = rcc->entry[rcc->num_entries-1].expected_bits;
2474                 double video_pos = rce.expected_bits / final_bits;
2475                 double scale_factor = sqrt( (1 - video_pos) * rcc->num_entries );
2476                 abr_buffer *= 0.5 * X264_MAX( scale_factor, 0.5 );
2477             }
2478
2479             diff = predicted_bits - (int64_t)rce.expected_bits;
2480             q = rce.new_qscale;
2481             q /= x264_clip3f((double)(abr_buffer - diff) / abr_buffer, .5, 2);
2482             if( ((h->i_frame + 1 - h->i_thread_frames) >= rcc->fps) &&
2483                 (rcc->expected_bits_sum > 0))
2484             {
2485                 /* Adjust quant based on the difference between
2486                  * achieved and expected bitrate so far */
2487                 double cur_time = (double)h->i_frame / rcc->num_entries;
2488                 double w = x264_clip3f( cur_time*100, 0.0, 1.0 );
2489                 q *= pow( (double)total_bits / rcc->expected_bits_sum, w );
2490             }
2491             rcc->qp_novbv = qscale2qp( q );
2492             if( rcc->b_vbv )
2493             {
2494                 /* Do not overflow vbv */
2495                 double expected_size = qscale2bits( &rce, q );
2496                 double expected_vbv = rcc->buffer_fill + rcc->buffer_rate - expected_size;
2497                 double expected_fullness = rce.expected_vbv / rcc->buffer_size;
2498                 double qmax = q*(2 - expected_fullness);
2499                 double size_constraint = 1 + expected_fullness;
2500                 qmax = X264_MAX( qmax, rce.new_qscale );
2501                 if( expected_fullness < .05 )
2502                     qmax = lmax;
2503                 qmax = X264_MIN(qmax, lmax);
2504                 while( ((expected_vbv < rce.expected_vbv/size_constraint) && (q < qmax)) ||
2505                         ((expected_vbv < 0) && (q < lmax)))
2506                 {
2507                     q *= 1.05;
2508                     expected_size = qscale2bits(&rce, q);
2509                     expected_vbv = rcc->buffer_fill + rcc->buffer_rate - expected_size;
2510                 }
2511                 rcc->last_satd = x264_rc_analyse_slice( h );
2512             }
2513             q = x264_clip3f( q, lmin, lmax );
2514         }
2515         else /* 1pass ABR */
2516         {
2517             /* Calculate the quantizer which would have produced the desired
2518              * average bitrate if it had been applied to all frames so far.
2519              * Then modulate that quant based on the current frame's complexity
2520              * relative to the average complexity so far (using the 2pass RCEQ).
2521              * Then bias the quant up or down if total size so far was far from
2522              * the target.
2523              * Result: Depending on the value of rate_tolerance, there is a
2524              * tradeoff between quality and bitrate precision. But at large
2525              * tolerances, the bit distribution approaches that of 2pass. */
2526
2527             double wanted_bits, overflow = 1;
2528
2529             rcc->last_satd = x264_rc_analyse_slice( h );
2530             rcc->short_term_cplxsum *= 0.5;
2531             rcc->short_term_cplxcount *= 0.5;
2532             rcc->short_term_cplxsum += rcc->last_satd / (CLIP_DURATION(h->fenc->f_duration) / BASE_FRAME_DURATION);
2533             rcc->short_term_cplxcount ++;
2534
2535             rce.tex_bits = rcc->last_satd;
2536             rce.blurred_complexity = rcc->short_term_cplxsum / rcc->short_term_cplxcount;
2537             rce.mv_bits = 0;
2538             rce.p_count = rcc->nmb;
2539             rce.i_count = 0;
2540             rce.s_count = 0;
2541             rce.qscale = 1;
2542             rce.pict_type = pict_type;
2543             rce.i_duration = h->fenc->i_duration;
2544
2545             if( h->param.rc.i_rc_method == X264_RC_CRF )
2546             {
2547                 q = get_qscale( h, &rce, rcc->rate_factor_constant, h->fenc->i_frame );
2548             }
2549             else
2550             {
2551                 q = get_qscale( h, &rce, rcc->wanted_bits_window / rcc->cplxr_sum, h->fenc->i_frame );
2552
2553                 /* ABR code can potentially be counterproductive in CBR, so just don't bother.
2554                  * Don't run it if the frame complexity is zero either. */
2555                 if( !rcc->b_vbv_min_rate && rcc->last_satd )
2556                 {
2557                     // FIXME is it simpler to keep track of wanted_bits in ratecontrol_end?
2558                     int i_frame_done = h->i_frame + 1 - h->i_thread_frames;
2559                     double time_done = i_frame_done / rcc->fps;
2560                     if( h->param.b_vfr_input && i_frame_done > 0 )
2561                         time_done = ((double)(h->fenc->i_reordered_pts - h->i_reordered_pts_delay)) * h->param.i_timebase_num / h->param.i_timebase_den;
2562                     wanted_bits = time_done * rcc->bitrate;
2563                     if( wanted_bits > 0 )
2564                     {
2565                         abr_buffer *= X264_MAX( 1, sqrt( time_done ) );
2566                         overflow = x264_clip3f( 1.0 + (total_bits - wanted_bits) / abr_buffer, .5, 2 );
2567                         q *= overflow;
2568                     }
2569                 }
2570             }
2571
2572             if( pict_type == SLICE_TYPE_I && h->param.i_keyint_max > 1
2573                 /* should test _next_ pict type, but that isn't decided yet */
2574                 && rcc->last_non_b_pict_type != SLICE_TYPE_I )
2575             {
2576                 q = qp2qscale( rcc->accum_p_qp / rcc->accum_p_norm );
2577                 q /= fabs( h->param.rc.f_ip_factor );
2578             }
2579             else if( h->i_frame > 0 )
2580             {
2581                 if( h->param.rc.i_rc_method != X264_RC_CRF )
2582                 {
2583                     /* Asymmetric clipping, because symmetric would prevent
2584                      * overflow control in areas of rapidly oscillating complexity */
2585                     double lmin = rcc->last_qscale_for[pict_type] / rcc->lstep;
2586                     double lmax = rcc->last_qscale_for[pict_type] * rcc->lstep;
2587                     if( overflow > 1.1 && h->i_frame > 3 )
2588                         lmax *= rcc->lstep;
2589                     else if( overflow < 0.9 )
2590                         lmin /= rcc->lstep;
2591
2592                     q = x264_clip3f(q, lmin, lmax);
2593                 }
2594             }
2595             else if( h->param.rc.i_rc_method == X264_RC_CRF && rcc->qcompress != 1 )
2596             {
2597                 q = qp2qscale( ABR_INIT_QP ) / fabs( h->param.rc.f_ip_factor );
2598             }
2599             rcc->qp_novbv = qscale2qp( q );
2600
2601             //FIXME use get_diff_limited_q() ?
2602             q = clip_qscale( h, pict_type, q );
2603         }
2604
2605         rcc->last_qscale_for[pict_type] =
2606         rcc->last_qscale = q;
2607
2608         if( !(rcc->b_2pass && !rcc->b_vbv) && h->fenc->i_frame == 0 )
2609             rcc->last_qscale_for[SLICE_TYPE_P] = q * fabs( h->param.rc.f_ip_factor );
2610
2611         if( rcc->b_2pass && rcc->b_vbv )
2612             rcc->frame_size_planned = qscale2bits(&rce, q);
2613         else
2614             rcc->frame_size_planned = predict_size( &rcc->pred[h->sh.i_type], q, rcc->last_satd );
2615
2616         /* Always use up the whole VBV in this case. */
2617         if( rcc->single_frame_vbv )
2618             rcc->frame_size_planned = rcc->buffer_rate;
2619         /* Limit planned size by MinCR */
2620         if( rcc->b_vbv )
2621             rcc->frame_size_planned = X264_MIN( rcc->frame_size_planned, rcc->frame_size_maximum );
2622         h->rc->frame_size_estimated = rcc->frame_size_planned;
2623         return q;
2624     }
2625 }
2626
2627 static void x264_threads_normalize_predictors( x264_t *h )
2628 {
2629     double totalsize = 0;
2630     for( int i = 0; i < h->param.i_threads; i++ )
2631         totalsize += h->thread[i]->rc->slice_size_planned;
2632     double factor = h->rc->frame_size_planned / totalsize;
2633     for( int i = 0; i < h->param.i_threads; i++ )
2634         h->thread[i]->rc->slice_size_planned *= factor;
2635 }
2636
2637 void x264_threads_distribute_ratecontrol( x264_t *h )
2638 {
2639     int row;
2640     x264_ratecontrol_t *rc = h->rc;
2641     x264_emms();
2642     float qscale = qp2qscale( rc->qpm );
2643
2644     /* Initialize row predictors */
2645     if( h->i_frame == 0 )
2646         for( int i = 0; i < h->param.i_threads; i++ )
2647         {
2648             x264_t *t = h->thread[i];
2649             if( t != h )
2650                 memcpy( t->rc->row_preds, rc->row_preds, sizeof(rc->row_preds) );
2651         }
2652
2653     for( int i = 0; i < h->param.i_threads; i++ )
2654     {
2655         x264_t *t = h->thread[i];
2656         if( t != h )
2657             memcpy( t->rc, rc, offsetof(x264_ratecontrol_t, row_pred) );
2658         t->rc->row_pred = t->rc->row_preds[h->sh.i_type];
2659         /* Calculate the planned slice size. */
2660         if( rc->b_vbv && rc->frame_size_planned )
2661         {
2662             int size = 0;
2663             for( row = t->i_threadslice_start; row < t->i_threadslice_end; row++ )
2664                 size += h->fdec->i_row_satd[row];
2665             t->rc->slice_size_planned = predict_size( &rc->pred[h->sh.i_type + (i+1)*5], qscale, size );
2666         }
2667         else
2668             t->rc->slice_size_planned = 0;
2669     }
2670     if( rc->b_vbv && rc->frame_size_planned )
2671     {
2672         x264_threads_normalize_predictors( h );
2673
2674         if( rc->single_frame_vbv )
2675         {
2676             /* Compensate for our max frame error threshold: give more bits (proportionally) to smaller slices. */
2677             for( int i = 0; i < h->param.i_threads; i++ )
2678             {
2679                 x264_t *t = h->thread[i];
2680                 float max_frame_error = X264_MAX( 0.05, 1.0 / (t->i_threadslice_end - t->i_threadslice_start) );
2681                 t->rc->slice_size_planned += 2 * max_frame_error * rc->frame_size_planned;
2682             }
2683             x264_threads_normalize_predictors( h );
2684         }
2685
2686         for( int i = 0; i < h->param.i_threads; i++ )
2687             h->thread[i]->rc->frame_size_estimated = h->thread[i]->rc->slice_size_planned;
2688     }
2689 }
2690
2691 void x264_threads_merge_ratecontrol( x264_t *h )
2692 {
2693     x264_ratecontrol_t *rc = h->rc;
2694     x264_emms();
2695
2696     for( int i = 0; i < h->param.i_threads; i++ )
2697     {
2698         x264_t *t = h->thread[i];
2699         x264_ratecontrol_t *rct = h->thread[i]->rc;
2700         if( h->param.rc.i_vbv_buffer_size )
2701         {
2702             int size = 0;
2703             for( int row = t->i_threadslice_start; row < t->i_threadslice_end; row++ )
2704                 size += h->fdec->i_row_satd[row];
2705             int bits = t->stat.frame.i_mv_bits + t->stat.frame.i_tex_bits + t->stat.frame.i_misc_bits;
2706             int mb_count = (t->i_threadslice_end - t->i_threadslice_start) * h->mb.i_mb_width;
2707             update_predictor( &rc->pred[h->sh.i_type+(i+1)*5], qp2qscale( rct->qpa_rc/mb_count ), size, bits );
2708         }
2709         if( !i )
2710             continue;
2711         rc->qpa_rc += rct->qpa_rc;
2712         rc->qpa_aq += rct->qpa_aq;
2713     }
2714 }
2715
2716 void x264_thread_sync_ratecontrol( x264_t *cur, x264_t *prev, x264_t *next )
2717 {
2718     if( cur != prev )
2719     {
2720 #define COPY(var) memcpy(&cur->rc->var, &prev->rc->var, sizeof(cur->rc->var))
2721         /* these vars are updated in x264_ratecontrol_start()
2722          * so copy them from the context that most recently started (prev)
2723          * to the context that's about to start (cur). */
2724         COPY(accum_p_qp);
2725         COPY(accum_p_norm);
2726         COPY(last_satd);
2727         COPY(last_rceq);
2728         COPY(last_qscale_for);
2729         COPY(last_non_b_pict_type);
2730         COPY(short_term_cplxsum);
2731         COPY(short_term_cplxcount);
2732         COPY(bframes);
2733         COPY(prev_zone);
2734         COPY(mbtree.qpbuf_pos);
2735         /* these vars can be updated by x264_ratecontrol_init_reconfigurable */
2736         COPY(bitrate);
2737         COPY(buffer_size);
2738         COPY(buffer_rate);
2739         COPY(vbv_max_rate);
2740         COPY(single_frame_vbv);
2741         COPY(cbr_decay);
2742         COPY(rate_factor_constant);
2743         COPY(rate_factor_max_increment);
2744 #undef COPY
2745     }
2746     if( cur != next )
2747     {
2748 #define COPY(var) next->rc->var = cur->rc->var
2749         /* these vars are updated in x264_ratecontrol_end()
2750          * so copy them from the context that most recently ended (cur)
2751          * to the context that's about to end (next) */
2752         COPY(cplxr_sum);
2753         COPY(expected_bits_sum);
2754         COPY(filler_bits_sum);
2755         COPY(wanted_bits_window);
2756         COPY(bframe_bits);
2757         COPY(initial_cpb_removal_delay);
2758         COPY(initial_cpb_removal_delay_offset);
2759         COPY(nrt_first_access_unit);
2760         COPY(previous_cpb_final_arrival_time);
2761 #undef COPY
2762     }
2763     //FIXME row_preds[] (not strictly necessary, but would improve prediction)
2764     /* the rest of the variables are either constant or thread-local */
2765 }
2766
2767 static int find_underflow( x264_t *h, double *fills, int *t0, int *t1, int over )
2768 {
2769     /* find an interval ending on an overflow or underflow (depending on whether
2770      * we're adding or removing bits), and starting on the earliest frame that
2771      * can influence the buffer fill of that end frame. */
2772     x264_ratecontrol_t *rcc = h->rc;
2773     const double buffer_min = .1 * rcc->buffer_size;
2774     const double buffer_max = .9 * rcc->buffer_size;
2775     double fill = fills[*t0-1];
2776     double parity = over ? 1. : -1.;
2777     int start = -1, end = -1;
2778     for( int i = *t0; i < rcc->num_entries; i++ )
2779     {
2780         fill += (rcc->entry[i].i_cpb_duration * rcc->vbv_max_rate * h->sps->vui.i_num_units_in_tick / h->sps->vui.i_time_scale -
2781                  qscale2bits( &rcc->entry[i], rcc->entry[i].new_qscale )) * parity;
2782         fill = x264_clip3f(fill, 0, rcc->buffer_size);
2783         fills[i] = fill;
2784         if( fill <= buffer_min || i == 0 )
2785         {
2786             if( end >= 0 )
2787                 break;
2788             start = i;
2789         }
2790         else if( fill >= buffer_max && start >= 0 )
2791             end = i;
2792     }
2793     *t0 = start;
2794     *t1 = end;
2795     return start >= 0 && end >= 0;
2796 }
2797
2798 static int fix_underflow( x264_t *h, int t0, int t1, double adjustment, double qscale_min, double qscale_max)
2799 {
2800     x264_ratecontrol_t *rcc = h->rc;
2801     double qscale_orig, qscale_new;
2802     int adjusted = 0;
2803     if( t0 > 0 )
2804         t0++;
2805     for( int i = t0; i <= t1; i++ )
2806     {
2807         qscale_orig = rcc->entry[i].new_qscale;
2808         qscale_orig = x264_clip3f( qscale_orig, qscale_min, qscale_max );
2809         qscale_new  = qscale_orig * adjustment;
2810         qscale_new  = x264_clip3f( qscale_new, qscale_min, qscale_max );
2811         rcc->entry[i].new_qscale = qscale_new;
2812         adjusted = adjusted || (qscale_new != qscale_orig);
2813     }
2814     return adjusted;
2815 }
2816
2817 static double count_expected_bits( x264_t *h )
2818 {
2819     x264_ratecontrol_t *rcc = h->rc;
2820     double expected_bits = 0;
2821     for( int i = 0; i < rcc->num_entries; i++ )
2822     {
2823         ratecontrol_entry_t *rce = &rcc->entry[i];
2824         rce->expected_bits = expected_bits;
2825         expected_bits += qscale2bits( rce, rce->new_qscale );
2826     }
2827     return expected_bits;
2828 }
2829
2830 static int vbv_pass2( x264_t *h, double all_available_bits )
2831 {
2832     /* for each interval of buffer_full .. underflow, uniformly increase the qp of all
2833      * frames in the interval until either buffer is full at some intermediate frame or the
2834      * last frame in the interval no longer underflows.  Recompute intervals and repeat.
2835      * Then do the converse to put bits back into overflow areas until target size is met */
2836
2837     x264_ratecontrol_t *rcc = h->rc;
2838     double *fills;
2839     double expected_bits = 0;
2840     double adjustment;
2841     double prev_bits = 0;
2842     int t0, t1;
2843     double qscale_min = qp2qscale( h->param.rc.i_qp_min );
2844     double qscale_max = qp2qscale( h->param.rc.i_qp_max );
2845     int iterations = 0;
2846     int adj_min, adj_max;
2847     CHECKED_MALLOC( fills, (rcc->num_entries+1)*sizeof(double) );
2848
2849     fills++;
2850
2851     /* adjust overall stream size */
2852     do
2853     {
2854         iterations++;
2855         prev_bits = expected_bits;
2856
2857         if( expected_bits )
2858         {   /* not first iteration */
2859             adjustment = X264_MAX(X264_MIN(expected_bits / all_available_bits, 0.999), 0.9);
2860             fills[-1] = rcc->buffer_size * h->param.rc.f_vbv_buffer_init;
2861             t0 = 0;
2862             /* fix overflows */
2863             adj_min = 1;
2864             while(adj_min && find_underflow( h, fills, &t0, &t1, 1 ))
2865             {
2866                 adj_min = fix_underflow( h, t0, t1, adjustment, qscale_min, qscale_max );
2867                 t0 = t1;
2868             }
2869         }
2870
2871         fills[-1] = rcc->buffer_size * (1. - h->param.rc.f_vbv_buffer_init);
2872         t0 = 0;
2873         /* fix underflows -- should be done after overflow, as we'd better undersize target than underflowing VBV */
2874         adj_max = 1;
2875         while( adj_max && find_underflow( h, fills, &t0, &t1, 0 ) )
2876             adj_max = fix_underflow( h, t0, t1, 1.001, qscale_min, qscale_max );
2877
2878         expected_bits = count_expected_bits( h );
2879     } while( (expected_bits < .995*all_available_bits) && ((int64_t)(expected_bits+.5) > (int64_t)(prev_bits+.5)) );
2880
2881     if( !adj_max )
2882         x264_log( h, X264_LOG_WARNING, "vbv-maxrate issue, qpmax or vbv-maxrate too low\n");
2883
2884     /* store expected vbv filling values for tracking when encoding */
2885     for( int i = 0; i < rcc->num_entries; i++ )
2886         rcc->entry[i].expected_vbv = rcc->buffer_size - fills[i];
2887
2888     x264_free( fills-1 );
2889     return 0;
2890 fail:
2891     return -1;
2892 }
2893
2894 static int init_pass2( x264_t *h )
2895 {
2896     x264_ratecontrol_t *rcc = h->rc;
2897     uint64_t all_const_bits = 0;
2898     double timescale = (double)h->sps->vui.i_num_units_in_tick / h->sps->vui.i_time_scale;
2899     double duration = 0;
2900     for( int i = 0; i < rcc->num_entries; i++ )
2901         duration += rcc->entry[i].i_duration;
2902     duration *= timescale;
2903     uint64_t all_available_bits = h->param.rc.i_bitrate * 1000. * duration;
2904     double rate_factor, step_mult;
2905     double qblur = h->param.rc.f_qblur;
2906     double cplxblur = h->param.rc.f_complexity_blur;
2907     const int filter_size = (int)(qblur*4) | 1;
2908     double expected_bits;
2909     double *qscale, *blurred_qscale;
2910     double base_cplx = h->mb.i_mb_count * (h->param.i_bframe ? 120 : 80);
2911
2912     /* find total/average complexity & const_bits */
2913     for( int i = 0; i < rcc->num_entries; i++ )
2914     {
2915         ratecontrol_entry_t *rce = &rcc->entry[i];
2916         all_const_bits += rce->misc_bits;
2917     }
2918
2919     if( all_available_bits < all_const_bits)
2920     {
2921         x264_log( h, X264_LOG_ERROR, "requested bitrate is too low. estimated minimum is %d kbps\n",
2922                  (int)(all_const_bits * rcc->fps / (rcc->num_entries * 1000.)) );
2923         return -1;
2924     }
2925
2926     /* Blur complexities, to reduce local fluctuation of QP.
2927      * We don't blur the QPs directly, because then one very simple frame
2928      * could drag down the QP of a nearby complex frame and give it more
2929      * bits than intended. */
2930     for( int i = 0; i < rcc->num_entries; i++ )
2931     {
2932         ratecontrol_entry_t *rce = &rcc->entry[i];
2933         double weight_sum = 0;
2934         double cplx_sum = 0;
2935         double weight = 1.0;
2936         double gaussian_weight;
2937         /* weighted average of cplx of future frames */
2938         for( int j = 1; j < cplxblur*2 && j < rcc->num_entries-i; j++ )
2939         {
2940             ratecontrol_entry_t *rcj = &rcc->entry[i+j];
2941             double frame_duration = CLIP_DURATION(rcj->i_duration * timescale) / BASE_FRAME_DURATION;
2942             weight *= 1 - pow( (float)rcj->i_count / rcc->nmb, 2 );
2943             if( weight < .0001 )
2944                 break;
2945             gaussian_weight = weight * exp( -j*j/200.0 );
2946             weight_sum += gaussian_weight;
2947             cplx_sum += gaussian_weight * (qscale2bits( rcj, 1 ) - rcj->misc_bits) / frame_duration;
2948         }
2949         /* weighted average of cplx of past frames */
2950         weight = 1.0;
2951         for( int j = 0; j <= cplxblur*2 && j <= i; j++ )
2952         {
2953             ratecontrol_entry_t *rcj = &rcc->entry[i-j];
2954             double frame_duration = CLIP_DURATION(rcj->i_duration * timescale) / BASE_FRAME_DURATION;
2955             gaussian_weight = weight * exp( -j*j/200.0 );
2956             weight_sum += gaussian_weight;
2957             cplx_sum += gaussian_weight * (qscale2bits( rcj, 1 ) - rcj->misc_bits) / frame_duration;
2958             weight *= 1 - pow( (float)rcj->i_count / rcc->nmb, 2 );
2959             if( weight < .0001 )
2960                 break;
2961         }
2962         rce->blurred_complexity = cplx_sum / weight_sum;
2963     }
2964
2965     CHECKED_MALLOC( qscale, sizeof(double)*rcc->num_entries );
2966     if( filter_size > 1 )
2967         CHECKED_MALLOC( blurred_qscale, sizeof(double)*rcc->num_entries );
2968     else
2969         blurred_qscale = qscale;
2970
2971     /* Search for a factor which, when multiplied by the RCEQ values from
2972      * each frame, adds up to the desired total size.
2973      * There is no exact closed-form solution because of VBV constraints and
2974      * because qscale2bits is not invertible, but we can start with the simple
2975      * approximation of scaling the 1st pass by the ratio of bitrates.
2976      * The search range is probably overkill, but speed doesn't matter here. */
2977
2978     expected_bits = 1;
2979     for( int i = 0; i < rcc->num_entries; i++ )
2980     {
2981         double q = get_qscale(h, &rcc->entry[i], 1.0, i);
2982         expected_bits += qscale2bits(&rcc->entry[i], q);
2983         rcc->last_qscale_for[rcc->entry[i].pict_type] = q;
2984     }
2985     step_mult = all_available_bits / expected_bits;
2986
2987     rate_factor = 0;
2988     for( double step = 1E4 * step_mult; step > 1E-7 * step_mult; step *= 0.5)
2989     {
2990         expected_bits = 0;
2991         rate_factor += step;
2992
2993         rcc->last_non_b_pict_type = -1;
2994         rcc->last_accum_p_norm = 1;
2995         rcc->accum_p_norm = 0;
2996
2997         rcc->last_qscale_for[0] =
2998         rcc->last_qscale_for[1] =
2999         rcc->last_qscale_for[2] = pow( base_cplx, 1 - rcc->qcompress ) / rate_factor;
3000
3001         /* find qscale */
3002         for( int i = 0; i < rcc->num_entries; i++ )
3003         {
3004             qscale[i] = get_qscale( h, &rcc->entry[i], rate_factor, -1 );
3005             rcc->last_qscale_for[rcc->entry[i].pict_type] = qscale[i];
3006         }
3007
3008         /* fixed I/B qscale relative to P */
3009         for( int i = rcc->num_entries-1; i >= 0; i-- )
3010         {
3011             qscale[i] = get_diff_limited_q( h, &rcc->entry[i], qscale[i], i );
3012             assert(qscale[i] >= 0);
3013         }
3014
3015         /* smooth curve */
3016         if( filter_size > 1 )
3017         {
3018             assert( filter_size%2 == 1 );
3019             for( int i = 0; i < rcc->num_entries; i++ )
3020             {
3021                 ratecontrol_entry_t *rce = &rcc->entry[i];
3022                 double q = 0.0, sum = 0.0;
3023
3024                 for( int j = 0; j < filter_size; j++ )
3025                 {
3026                     int idx = i+j-filter_size/2;
3027                     double d = idx-i;
3028                     double coeff = qblur==0 ? 1.0 : exp( -d*d/(qblur*qblur) );
3029                     if( idx < 0 || idx >= rcc->num_entries )
3030                         continue;
3031                     if( rce->pict_type != rcc->entry[idx].pict_type )
3032                         continue;
3033                     q += qscale[idx] * coeff;
3034                     sum += coeff;
3035                 }
3036                 blurred_qscale[i] = q/sum;
3037             }
3038         }
3039
3040         /* find expected bits */
3041         for( int i = 0; i < rcc->num_entries; i++ )
3042         {
3043             ratecontrol_entry_t *rce = &rcc->entry[i];
3044             rce->new_qscale = clip_qscale( h, rce->pict_type, blurred_qscale[i] );
3045             assert(rce->new_qscale >= 0);
3046             expected_bits += qscale2bits( rce, rce->new_qscale );
3047         }
3048
3049         if( expected_bits > all_available_bits )
3050             rate_factor -= step;
3051     }
3052
3053     x264_free( qscale );
3054     if( filter_size > 1 )
3055         x264_free( blurred_qscale );
3056
3057     if( rcc->b_vbv )
3058         if( vbv_pass2( h, all_available_bits ) )
3059             return -1;
3060     expected_bits = count_expected_bits( h );
3061
3062     if( fabs( expected_bits/all_available_bits - 1.0 ) > 0.01 )
3063     {
3064         double avgq = 0;
3065         for( int i = 0; i < rcc->num_entries; i++ )
3066             avgq += rcc->entry[i].new_qscale;
3067         avgq = qscale2qp( avgq / rcc->num_entries );
3068
3069         if( expected_bits > all_available_bits || !rcc->b_vbv )
3070             x264_log( h, X264_LOG_WARNING, "Error: 2pass curve failed to converge\n" );
3071         x264_log( h, X264_LOG_WARNING, "target: %.2f kbit/s, expected: %.2f kbit/s, avg QP: %.4f\n",
3072                   (float)h->param.rc.i_bitrate,
3073                   expected_bits * rcc->fps / (rcc->num_entries * 1000.),
3074                   avgq );
3075         if( expected_bits < all_available_bits && avgq < h->param.rc.i_qp_min + 2 )
3076         {
3077             if( h->param.rc.i_qp_min > 0 )
3078                 x264_log( h, X264_LOG_WARNING, "try reducing target bitrate or reducing qp_min (currently %d)\n", h->param.rc.i_qp_min );
3079             else
3080                 x264_log( h, X264_LOG_WARNING, "try reducing target bitrate\n" );
3081         }
3082         else if( expected_bits > all_available_bits && avgq > h->param.rc.i_qp_max - 2 )
3083         {
3084             if( h->param.rc.i_qp_max < QP_MAX )
3085                 x264_log( h, X264_LOG_WARNING, "try increasing target bitrate or increasing qp_max (currently %d)\n", h->param.rc.i_qp_max );
3086             else
3087                 x264_log( h, X264_LOG_WARNING, "try increasing target bitrate\n");
3088         }
3089         else if( !(rcc->b_2pass && rcc->b_vbv) )
3090             x264_log( h, X264_LOG_WARNING, "internal error\n" );
3091     }
3092
3093     return 0;
3094 fail:
3095     return -1;
3096 }