remove unused adaptive cabac_idc code
[x262.git] / encoder / ratecontrol.c
1 /***************************************************-*- coding: iso-8859-1 -*-
2  * ratecontrol.c: h264 encoder library (Rate Control)
3  *****************************************************************************
4  * Copyright (C) 2005 x264 project
5  * $Id: ratecontrol.c,v 1.1 2004/06/03 19:27:08 fenrir Exp $
6  *
7  * Authors: Loren Merritt <lorenm@u.washington.edu>
8  *          Michael Niedermayer <michaelni@gmx.at>
9  *          Måns Rullgård <mru@mru.ath.cx>
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or
14  * (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
24  *****************************************************************************/
25
26 #define _ISOC99_SOURCE
27 #undef NDEBUG // always check asserts, the speed effect is far too small to disable them
28 #include <stdlib.h>
29 #include <stdio.h>
30 #include <string.h>
31 #include <math.h>
32 #include <limits.h>
33 #include <assert.h>
34
35 #include "common/common.h"
36 #include "common/cpu.h"
37 #include "ratecontrol.h"
38
39 #if defined(SYS_FREEBSD) || defined(SYS_BEOS) || defined(SYS_NETBSD)
40 #define exp2f(x) powf( 2, (x) )
41 #endif
42 #if defined(_MSC_VER) || defined(SYS_SunOS)
43 #define exp2f(x) pow( 2, (x) )
44 #define sqrtf sqrt
45 #endif
46 #ifdef WIN32 // POSIX says that rename() removes the destination, but win32 doesn't.
47 #define rename(src,dst) (unlink(dst), rename(src,dst))
48 #endif
49
50 typedef struct
51 {
52     int pict_type;
53     int kept_as_ref;
54     float qscale;
55     int mv_bits;
56     int i_tex_bits;
57     int p_tex_bits;
58     int misc_bits;
59     uint64_t expected_bits;
60     float new_qscale;
61     int new_qp;
62     int i_count;
63     int p_count;
64     int s_count;
65     float blurred_complexity;
66 } ratecontrol_entry_t;
67
68 typedef struct
69 {
70     double coeff;
71     double count;
72     double decay;
73 } predictor_t;
74
75 struct x264_ratecontrol_t
76 {
77     /* constants */
78     int b_abr;
79     int b_2pass;
80     double fps;
81     double bitrate;
82     double rate_tolerance;
83     int nmb;                    /* number of macroblocks in a frame */
84     int qp_constant[5];
85
86     /* current frame */
87     ratecontrol_entry_t *rce;
88     int qp;                     /* qp for current frame */
89     float qpa;                  /* average of macroblocks' qp (same as qp if no adaptive quant) */
90     int slice_type;
91     int qp_force;
92
93     /* VBV stuff */
94     double buffer_size;
95     double buffer_fill;
96     double buffer_rate;         /* # of bits added to buffer_fill after each frame */
97     predictor_t pred[5];        /* predict frame size from satd */
98
99     /* ABR stuff */
100     int    last_satd;
101     double last_rceq;
102     double cplxr_sum;           /* sum of bits*qscale/rceq */
103     double expected_bits_sum;   /* sum of qscale2bits after rceq, ratefactor, and overflow */
104     double wanted_bits_window;  /* target bitrate * window */
105     double cbr_decay;
106     double short_term_cplxsum;
107     double short_term_cplxcount;
108     double rate_factor_constant;
109
110     /* 2pass stuff */
111     FILE *p_stat_file_out;
112     char *psz_stat_file_tmpname;
113
114     int num_entries;            /* number of ratecontrol_entry_ts */
115     ratecontrol_entry_t *entry; /* FIXME: copy needed data and free this once init is done */
116     double last_qscale;
117     double last_qscale_for[5];  /* last qscale for a specific pict type, used for max_diff & ipb factor stuff  */
118     int last_non_b_pict_type;
119     double accum_p_qp;          /* for determining I-frame quant */
120     double accum_p_norm;
121     double last_accum_p_norm;
122     double lmin[5];             /* min qscale by frame type */
123     double lmax[5];
124     double lstep;               /* max change (multiply) in qscale per frame */
125     double i_cplx_sum[5];       /* estimated total texture bits in intra MBs at qscale=1 */
126     double p_cplx_sum[5];
127     double mv_bits_sum[5];
128     int frame_count[5];         /* number of frames of each type */
129
130     int i_zones;
131     x264_zone_t *zones;
132 };
133
134
135 static int parse_zones( x264_t *h );
136 static int init_pass2(x264_t *);
137 static float rate_estimate_qscale( x264_t *h, int pict_type );
138 static void update_vbv( x264_t *h, int bits );
139 int  x264_rc_analyse_slice( x264_t *h );
140
141 /* Terminology:
142  * qp = h.264's quantizer
143  * qscale = linearized quantizer = Lagrange multiplier
144  */
145 static inline double qp2qscale(double qp)
146 {
147     return 0.85 * pow(2.0, ( qp - 12.0 ) / 6.0);
148 }
149 static inline double qscale2qp(double qscale)
150 {
151     return 12.0 + 6.0 * log(qscale/0.85) / log(2.0);
152 }
153
154 /* Texture bitrate is not quite inversely proportional to qscale,
155  * probably due the the changing number of SKIP blocks.
156  * MV bits level off at about qp<=12, because the lambda used
157  * for motion estimation is constant there. */
158 static inline double qscale2bits(ratecontrol_entry_t *rce, double qscale)
159 {
160     if(qscale<0.1)
161         qscale = 0.1;
162     return (rce->i_tex_bits + rce->p_tex_bits + .1) * pow( rce->qscale / qscale, 1.1 )
163            + rce->mv_bits * pow( X264_MAX(rce->qscale, 12) / X264_MAX(qscale, 12), 0.5 );
164 }
165
166
167 int x264_ratecontrol_new( x264_t *h )
168 {
169     x264_ratecontrol_t *rc;
170     int i;
171
172     x264_cpu_restore( h->param.cpu );
173
174     h->rc = rc = x264_malloc( sizeof( x264_ratecontrol_t ) );
175     memset(rc, 0, sizeof(*rc));
176
177     rc->b_abr = ( h->param.rc.b_cbr || h->param.rc.i_rf_constant ) && !h->param.rc.b_stat_read;
178     rc->b_2pass = h->param.rc.b_cbr && h->param.rc.b_stat_read;
179     h->mb.b_variable_qp = 0;
180     
181     /* FIXME: use integers */
182     if(h->param.i_fps_num > 0 && h->param.i_fps_den > 0)
183         rc->fps = (float) h->param.i_fps_num / h->param.i_fps_den;
184     else
185         rc->fps = 25.0;
186
187     rc->bitrate = h->param.rc.i_bitrate * 1000;
188     rc->rate_tolerance = h->param.rc.f_rate_tolerance;
189     rc->nmb = h->mb.i_mb_count;
190     rc->last_non_b_pict_type = -1;
191     rc->cbr_decay = 1.0;
192
193     if( rc->b_2pass && h->param.rc.i_rf_constant )
194         x264_log(h, X264_LOG_ERROR, "constant rate-factor is incompatible with 2pass.\n");
195     if( h->param.rc.i_vbv_max_bitrate < h->param.rc.i_bitrate &&
196         h->param.rc.i_vbv_max_bitrate > 0)
197         x264_log(h, X264_LOG_ERROR, "max bitrate less than average bitrate, ignored.\n");
198     else if( h->param.rc.i_vbv_max_bitrate > 0 &&
199              h->param.rc.i_vbv_buffer_size > 0 )
200     {
201         if( h->param.rc.i_vbv_buffer_size < 10 * h->param.rc.i_vbv_max_bitrate / rc->fps ) {
202             h->param.rc.i_vbv_buffer_size = 10 * h->param.rc.i_vbv_max_bitrate / rc->fps;
203             x264_log( h, X264_LOG_ERROR, "VBV buffer size too small, using %d kbit\n",
204                       h->param.rc.i_vbv_buffer_size );
205         }
206         rc->buffer_rate = h->param.rc.i_vbv_max_bitrate * 1000 / rc->fps;
207         rc->buffer_size = h->param.rc.i_vbv_buffer_size * 1000;
208         rc->buffer_fill = rc->buffer_size * h->param.rc.f_vbv_buffer_init;
209         rc->cbr_decay = 1.0 - rc->buffer_rate / rc->buffer_size
210                       * 0.5 * X264_MAX(0, 1.5 - rc->buffer_rate * rc->fps / rc->bitrate);
211     }
212     else if( h->param.rc.i_vbv_max_bitrate || h->param.rc.i_vbv_buffer_size )
213         x264_log(h, X264_LOG_ERROR, "VBV maxrate or buffer size specified, but not both.\n");
214     if(rc->rate_tolerance < 0.01) {
215         x264_log(h, X264_LOG_ERROR, "bitrate tolerance too small, using .01\n");
216         rc->rate_tolerance = 0.01;
217     }
218
219     if( rc->b_abr )
220     {
221         /* FIXME shouldn't need to arbitrarily specify a QP,
222          * but this is more robust than BPP measures */
223 #define ABR_INIT_QP ( h->param.rc.i_rf_constant > 0 ? h->param.rc.i_rf_constant : 24 )
224         rc->accum_p_norm = .01;
225         rc->accum_p_qp = ABR_INIT_QP * rc->accum_p_norm;
226         rc->cplxr_sum = .01;
227         rc->wanted_bits_window = .01;
228     }
229
230     if( h->param.rc.i_rf_constant )
231     {
232         /* arbitrary rescaling to make CRF somewhat similar to QP */
233         double base_cplx = h->mb.i_mb_count * (h->param.i_bframe ? 120 : 80);
234         rc->rate_factor_constant = pow( base_cplx, 1 - h->param.rc.f_qcompress )
235                                  / qp2qscale( h->param.rc.i_rf_constant );
236     }
237
238     rc->qp_constant[SLICE_TYPE_P] = h->param.rc.i_qp_constant;
239     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, 51 );
240     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, 51 );
241
242     rc->lstep = exp2f(h->param.rc.i_qp_step / 6.0);
243     rc->last_qscale = qp2qscale(26);
244     for( i = 0; i < 5; i++ )
245     {
246         rc->last_qscale_for[i] = qp2qscale(26);
247         rc->lmin[i] = qp2qscale( h->param.rc.i_qp_min );
248         rc->lmax[i] = qp2qscale( h->param.rc.i_qp_max );
249         rc->pred[i].coeff= 2.0;
250         rc->pred[i].count= 1.0;
251         rc->pred[i].decay= 0.5;
252     }
253
254     if( parse_zones( h ) < 0 )
255         return -1;
256
257     /* Load stat file and init 2pass algo */
258     if( h->param.rc.b_stat_read )
259     {
260         char *p, *stats_in;
261
262         /* read 1st pass stats */
263         assert( h->param.rc.psz_stat_in );
264         stats_in = x264_slurp_file( h->param.rc.psz_stat_in );
265         if( !stats_in )
266         {
267             x264_log(h, X264_LOG_ERROR, "ratecontrol_init: can't open stats file\n");
268             return -1;
269         }
270
271         /* find number of pics */
272         p = stats_in;
273         for(i=-1; p; i++)
274             p = strchr(p+1, ';');
275         if(i==0)
276         {
277             x264_log(h, X264_LOG_ERROR, "empty stats file\n");
278             return -1;
279         }
280         rc->num_entries = i;
281
282         if( h->param.i_frame_total < rc->num_entries )
283         {
284             x264_log( h, X264_LOG_WARNING, "2nd pass has fewer frames than 1st pass (%d vs %d)\n",
285                       h->param.i_frame_total, rc->num_entries );
286         }
287         if( h->param.i_frame_total > rc->num_entries + h->param.i_bframe )
288         {
289             x264_log( h, X264_LOG_ERROR, "2nd pass has more frames than 1st pass (%d vs %d)\n",
290                       h->param.i_frame_total, rc->num_entries );
291             return -1;
292         }
293
294         /* FIXME: ugly padding because VfW drops delayed B-frames */
295         rc->num_entries += h->param.i_bframe;
296
297         rc->entry = (ratecontrol_entry_t*) x264_malloc(rc->num_entries * sizeof(ratecontrol_entry_t));
298         memset(rc->entry, 0, rc->num_entries * sizeof(ratecontrol_entry_t));
299
300         /* init all to skipped p frames */
301         for(i=0; i<rc->num_entries; i++){
302             ratecontrol_entry_t *rce = &rc->entry[i];
303             rce->pict_type = SLICE_TYPE_P;
304             rce->qscale = rce->new_qscale = qp2qscale(20);
305             rce->misc_bits = rc->nmb + 10;
306             rce->new_qp = 0;
307         }
308
309         /* read stats */
310         p = stats_in;
311         for(i=0; i < rc->num_entries - h->param.i_bframe; i++){
312             ratecontrol_entry_t *rce;
313             int frame_number;
314             char pict_type;
315             int e;
316             char *next;
317             float qp;
318
319             next= strchr(p, ';');
320             if(next){
321                 (*next)=0; //sscanf is unbelievably slow on looong strings
322                 next++;
323             }
324             e = sscanf(p, " in:%d ", &frame_number);
325
326             if(frame_number < 0 || frame_number >= rc->num_entries)
327             {
328                 x264_log(h, X264_LOG_ERROR, "bad frame number (%d) at stats line %d\n", frame_number, i);
329                 return -1;
330             }
331             rce = &rc->entry[frame_number];
332
333             e += sscanf(p, " in:%*d out:%*d type:%c q:%f itex:%d ptex:%d mv:%d misc:%d imb:%d pmb:%d smb:%d",
334                    &pict_type, &qp, &rce->i_tex_bits, &rce->p_tex_bits,
335                    &rce->mv_bits, &rce->misc_bits, &rce->i_count, &rce->p_count, &rce->s_count);
336
337             switch(pict_type){
338                 case 'I': rce->kept_as_ref = 1;
339                 case 'i': rce->pict_type = SLICE_TYPE_I; break;
340                 case 'P': rce->pict_type = SLICE_TYPE_P; break;
341                 case 'B': rce->kept_as_ref = 1;
342                 case 'b': rce->pict_type = SLICE_TYPE_B; break;
343                 default:  e = -1; break;
344             }
345             if(e != 10){
346                 x264_log(h, X264_LOG_ERROR, "statistics are damaged at line %d, parser out=%d\n", i, e);
347                 return -1;
348             }
349             rce->qscale = qp2qscale(qp);
350             p = next;
351         }
352
353         x264_free(stats_in);
354
355         if(h->param.rc.b_cbr)
356         {
357             if(init_pass2(h) < 0) return -1;
358         } /* else we're using constant quant, so no need to run the bitrate allocation */
359     }
360
361     /* Open output file */
362     /* If input and output files are the same, output to a temp file
363      * and move it to the real name only when it's complete */
364     if( h->param.rc.b_stat_write )
365     {
366         rc->psz_stat_file_tmpname = x264_malloc( strlen(h->param.rc.psz_stat_out) + 6 );
367         strcpy( rc->psz_stat_file_tmpname, h->param.rc.psz_stat_out );
368         strcat( rc->psz_stat_file_tmpname, ".temp" );
369
370         rc->p_stat_file_out = fopen( rc->psz_stat_file_tmpname, "wb" );
371         if( rc->p_stat_file_out == NULL )
372         {
373             x264_log(h, X264_LOG_ERROR, "ratecontrol_init: can't open stats file\n");
374             return -1;
375         }
376     }
377
378     return 0;
379 }
380
381 static int parse_zones( x264_t *h )
382 {
383     x264_ratecontrol_t *rc = h->rc;
384     int i;
385     if( h->param.rc.psz_zones && !h->param.rc.i_zones )
386     {
387         char *p;
388         h->param.rc.i_zones = 1;
389         for( p = h->param.rc.psz_zones; *p; p++ )
390             h->param.rc.i_zones += (*p == '/');
391         h->param.rc.zones = x264_malloc( h->param.rc.i_zones * sizeof(x264_zone_t) );
392         p = h->param.rc.psz_zones;
393         for( i = 0; i < h->param.rc.i_zones; i++)
394         {
395             x264_zone_t *z = &h->param.rc.zones[i];
396             if( 3 == sscanf(p, "%u,%u,q=%u", &z->i_start, &z->i_end, &z->i_qp) )
397                 z->b_force_qp = 1;
398             else if( 3 == sscanf(p, "%u,%u,b=%f", &z->i_start, &z->i_end, &z->f_bitrate_factor) )
399                 z->b_force_qp = 0;
400             else
401             {
402                 char *slash = strchr(p, '/');
403                 if(slash) *slash = '\0';
404                 x264_log( h, X264_LOG_ERROR, "invalid zone: \"%s\"\n", p );
405                 return -1;
406             }
407             p = strchr(p, '/') + 1;
408         }
409     }
410
411     if( h->param.rc.i_zones > 0 )
412     {
413         for( i = 0; i < h->param.rc.i_zones; i++ )
414         {
415             x264_zone_t z = h->param.rc.zones[i];
416             if( z.i_start < 0 || z.i_start > z.i_end )
417             {
418                 x264_log( h, X264_LOG_ERROR, "invalid zone: start=%d end=%d\n",
419                           z.i_start, z.i_end );
420                 return -1;
421             }
422             else if( !z.b_force_qp && z.f_bitrate_factor <= 0 )
423             {
424                 x264_log( h, X264_LOG_ERROR, "invalid zone: bitrate_factor=%f\n",
425                           z.f_bitrate_factor );
426                 return -1;
427             }
428         }
429
430         rc->i_zones = h->param.rc.i_zones;
431         rc->zones = x264_malloc( rc->i_zones * sizeof(x264_zone_t) );
432         memcpy( rc->zones, h->param.rc.zones, rc->i_zones * sizeof(x264_zone_t) );
433     }
434
435     return 0;
436 }
437
438 void x264_ratecontrol_delete( x264_t *h )
439 {
440     x264_ratecontrol_t *rc = h->rc;
441
442     if( rc->p_stat_file_out )
443     {
444         fclose( rc->p_stat_file_out );
445         if( h->i_frame >= rc->num_entries - h->param.i_bframe )
446             if( rename( rc->psz_stat_file_tmpname, h->param.rc.psz_stat_out ) != 0 )
447             {
448                 x264_log( h, X264_LOG_ERROR, "failed to rename \"%s\" to \"%s\"\n",
449                           rc->psz_stat_file_tmpname, h->param.rc.psz_stat_out );
450             }
451         x264_free( rc->psz_stat_file_tmpname );
452     }
453     x264_free( rc->entry );
454     x264_free( rc->zones );
455     x264_free( rc );
456 }
457
458 /* Before encoding a frame, choose a QP for it */
459 void x264_ratecontrol_start( x264_t *h, int i_slice_type, int i_force_qp )
460 {
461     x264_ratecontrol_t *rc = h->rc;
462
463     x264_cpu_restore( h->param.cpu );
464
465     rc->qp_force = i_force_qp;
466     rc->slice_type = i_slice_type;
467
468     if( i_force_qp )
469     {
470         rc->qpa = rc->qp = i_force_qp - 1;
471     }
472     else if( rc->b_abr )
473     {
474         rc->qpa = rc->qp =
475             x264_clip3( (int)(qscale2qp( rate_estimate_qscale( h, i_slice_type ) ) + .5), 0, 51 );
476     }
477     else if( rc->b_2pass )
478     {
479         int frame = h->fenc->i_frame;
480         ratecontrol_entry_t *rce;
481         assert( frame >= 0 && frame < rc->num_entries );
482         rce = h->rc->rce = &h->rc->entry[frame];
483
484         rce->new_qscale = rate_estimate_qscale( h, i_slice_type );
485         rc->qpa = rc->qp = rce->new_qp =
486             x264_clip3( (int)(qscale2qp(rce->new_qscale) + 0.5), 0, 51 );
487     }
488     else /* CQP */
489     {
490         int q;
491         if( i_slice_type == SLICE_TYPE_B && h->fdec->b_kept_as_ref )
492             q = ( rc->qp_constant[ SLICE_TYPE_B ] + rc->qp_constant[ SLICE_TYPE_P ] ) / 2;
493         else
494             q = rc->qp_constant[ i_slice_type ];
495         rc->qpa = rc->qp = q;
496     }
497 }
498
499 void x264_ratecontrol_mb( x264_t *h, int bits )
500 {
501     /* currently no adaptive quant */
502 }
503
504 int x264_ratecontrol_qp( x264_t *h )
505 {
506     return h->rc->qp;
507 }
508
509 /* In 2pass, force the same frame types as in the 1st pass */
510 int x264_ratecontrol_slice_type( x264_t *h, int frame_num )
511 {
512     x264_ratecontrol_t *rc = h->rc;
513     if( h->param.rc.b_stat_read )
514     {
515         if( frame_num >= rc->num_entries )
516         {
517             /* We could try to initialize everything required for ABR and
518              * adaptive B-frames, but that would be complicated.
519              * So just calculate the average QP used so far. */
520
521             h->param.rc.i_qp_constant = (h->stat.i_slice_count[SLICE_TYPE_P] == 0) ? 24
522                                       : 1 + h->stat.i_slice_qp[SLICE_TYPE_P] / h->stat.i_slice_count[SLICE_TYPE_P];
523             rc->qp_constant[SLICE_TYPE_P] = x264_clip3( h->param.rc.i_qp_constant, 0, 51 );
524             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, 51 );
525             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, 51 );
526
527             x264_log(h, X264_LOG_ERROR, "2nd pass has more frames than 1st pass (%d)\n", rc->num_entries);
528             x264_log(h, X264_LOG_ERROR, "continuing anyway, at constant QP=%d\n", h->param.rc.i_qp_constant);
529             if( h->param.b_bframe_adaptive )
530                 x264_log(h, X264_LOG_ERROR, "disabling adaptive B-frames\n");
531
532             rc->b_abr = 0;
533             rc->b_2pass = 0;
534             h->param.rc.b_cbr = 0;
535             h->param.rc.b_stat_read = 0;
536             h->param.b_bframe_adaptive = 0;
537             if( h->param.i_bframe > 1 )
538                 h->param.i_bframe = 1;
539             return X264_TYPE_P;
540         }
541         switch( rc->entry[frame_num].pict_type )
542         {
543             case SLICE_TYPE_I:
544                 return rc->entry[frame_num].kept_as_ref ? X264_TYPE_IDR : X264_TYPE_I;
545
546             case SLICE_TYPE_B:
547                 return rc->entry[frame_num].kept_as_ref ? X264_TYPE_BREF : X264_TYPE_B;
548
549             case SLICE_TYPE_P:
550             default:
551                 return X264_TYPE_P;
552         }
553     }
554     else
555     {
556         return X264_TYPE_AUTO;
557     }
558 }
559
560 /* After encoding one frame, save stats and update ratecontrol state */
561 void x264_ratecontrol_end( x264_t *h, int bits )
562 {
563     x264_ratecontrol_t *rc = h->rc;
564     const int *mbs = h->stat.frame.i_mb_count;
565     int i;
566
567     x264_cpu_restore( h->param.cpu );
568
569     h->stat.frame.i_mb_count_skip = mbs[P_SKIP] + mbs[B_SKIP];
570     h->stat.frame.i_mb_count_i = mbs[I_16x16] + mbs[I_8x8] + mbs[I_4x4];
571     h->stat.frame.i_mb_count_p = mbs[P_L0] + mbs[P_8x8];
572     for( i = B_DIRECT; i < B_8x8; i++ )
573         h->stat.frame.i_mb_count_p += mbs[i];
574
575     if( h->param.rc.b_stat_write )
576     {
577         char c_type = rc->slice_type==SLICE_TYPE_I ? (h->fenc->i_poc==0 ? 'I' : 'i')
578                     : rc->slice_type==SLICE_TYPE_P ? 'P'
579                     : h->fenc->b_kept_as_ref ? 'B' : 'b';
580         fprintf( rc->p_stat_file_out,
581                  "in:%d out:%d type:%c q:%.2f itex:%d ptex:%d mv:%d misc:%d imb:%d pmb:%d smb:%d;\n",
582                  h->fenc->i_frame, h->i_frame-1,
583                  c_type, rc->qpa,
584                  h->stat.frame.i_itex_bits, h->stat.frame.i_ptex_bits,
585                  h->stat.frame.i_hdr_bits, h->stat.frame.i_misc_bits,
586                  h->stat.frame.i_mb_count_i,
587                  h->stat.frame.i_mb_count_p,
588                  h->stat.frame.i_mb_count_skip);
589     }
590
591     if( rc->b_abr )
592     {
593         if( rc->slice_type != SLICE_TYPE_B )
594             rc->cplxr_sum += bits * qp2qscale(rc->qpa) / rc->last_rceq;
595         else
596         {
597             /* Depends on the fact that B-frame's QP is an offset from the following P-frame's.
598              * Not perfectly accurate with B-refs, but good enough. */
599             rc->cplxr_sum += bits * qp2qscale(rc->qpa) / (rc->last_rceq * fabs(h->param.rc.f_pb_factor));
600         }
601         rc->cplxr_sum *= rc->cbr_decay;
602         rc->wanted_bits_window += rc->bitrate / rc->fps;
603         rc->wanted_bits_window *= rc->cbr_decay;
604
605         rc->accum_p_qp   *= .95;
606         rc->accum_p_norm *= .95;
607         rc->accum_p_norm += 1;
608         if( rc->slice_type == SLICE_TYPE_I )
609             rc->accum_p_qp += rc->qpa * fabs(h->param.rc.f_ip_factor);
610         else
611             rc->accum_p_qp += rc->qpa;
612     }
613
614     if( rc->b_2pass )
615     {
616         rc->expected_bits_sum += qscale2bits( rc->rce, qp2qscale(rc->rce->new_qp) );
617     }
618
619     update_vbv( h, bits );
620
621     if( rc->slice_type != SLICE_TYPE_B )
622         rc->last_non_b_pict_type = rc->slice_type;
623 }
624
625 /****************************************************************************
626  * 2 pass functions
627  ***************************************************************************/
628
629 double x264_eval( char *s, double *const_value, const char **const_name,
630                   double (**func1)(void *, double), const char **func1_name,
631                   double (**func2)(void *, double, double), char **func2_name,
632                   void *opaque );
633
634 /**
635  * modify the bitrate curve from pass1 for one frame
636  */
637 static double get_qscale(x264_t *h, ratecontrol_entry_t *rce, double rate_factor, int frame_num)
638 {
639     x264_ratecontrol_t *rcc= h->rc;
640     const int pict_type = rce->pict_type;
641     double q;
642     int i;
643
644     double const_values[]={
645         rce->i_tex_bits * rce->qscale,
646         rce->p_tex_bits * rce->qscale,
647         (rce->i_tex_bits + rce->p_tex_bits) * rce->qscale,
648         rce->mv_bits * rce->qscale,
649         (double)rce->i_count / rcc->nmb,
650         (double)rce->p_count / rcc->nmb,
651         (double)rce->s_count / rcc->nmb,
652         rce->pict_type == SLICE_TYPE_I,
653         rce->pict_type == SLICE_TYPE_P,
654         rce->pict_type == SLICE_TYPE_B,
655         h->param.rc.f_qcompress,
656         rcc->i_cplx_sum[SLICE_TYPE_I] / rcc->frame_count[SLICE_TYPE_I],
657         rcc->i_cplx_sum[SLICE_TYPE_P] / rcc->frame_count[SLICE_TYPE_P],
658         rcc->p_cplx_sum[SLICE_TYPE_P] / rcc->frame_count[SLICE_TYPE_P],
659         rcc->p_cplx_sum[SLICE_TYPE_B] / rcc->frame_count[SLICE_TYPE_B],
660         (rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / rcc->frame_count[pict_type],
661         rce->blurred_complexity,
662         0
663     };
664     static const char *const_names[]={
665         "iTex",
666         "pTex",
667         "tex",
668         "mv",
669         "iCount",
670         "pCount",
671         "sCount",
672         "isI",
673         "isP",
674         "isB",
675         "qComp",
676         "avgIITex",
677         "avgPITex",
678         "avgPPTex",
679         "avgBPTex",
680         "avgTex",
681         "blurCplx",
682         NULL
683     };
684     static double (*func1[])(void *, double)={
685 //      (void *)bits2qscale,
686         (void *)qscale2bits,
687         NULL
688     };
689     static const char *func1_names[]={
690 //      "bits2qp",
691         "qp2bits",
692         NULL
693     };
694
695     q = x264_eval((char*)h->param.rc.psz_rc_eq, const_values, const_names, func1, func1_names, NULL, NULL, rce);
696
697     // avoid NaN's in the rc_eq
698     if(q != q || rce->i_tex_bits + rce->p_tex_bits + rce->mv_bits == 0)
699         q = rcc->last_qscale;
700     else {
701         rcc->last_rceq = q;
702         q /= rate_factor;
703         rcc->last_qscale = q;
704     }
705
706     for( i = rcc->i_zones-1; i >= 0; i-- )
707     {
708         x264_zone_t *z = &rcc->zones[i];
709         if( frame_num >= z->i_start && frame_num <= z->i_end )
710         {
711             if( z->b_force_qp )
712                 q = qp2qscale(z->i_qp);
713             else
714                 q /= z->f_bitrate_factor;
715             break;
716         }
717     }
718
719     return q;
720 }
721
722 static double get_diff_limited_q(x264_t *h, ratecontrol_entry_t *rce, double q)
723 {
724     x264_ratecontrol_t *rcc = h->rc;
725     const int pict_type = rce->pict_type;
726
727     // force I/B quants as a function of P quants
728     const double last_p_q    = rcc->last_qscale_for[SLICE_TYPE_P];
729     const double last_non_b_q= rcc->last_qscale_for[rcc->last_non_b_pict_type];
730     if( pict_type == SLICE_TYPE_I )
731     {
732         double iq = q;
733         double pq = qp2qscale( rcc->accum_p_qp / rcc->accum_p_norm );
734         double ip_factor = fabs( h->param.rc.f_ip_factor );
735         /* don't apply ip_factor if the following frame is also I */
736         if( rcc->accum_p_norm <= 0 )
737             q = iq;
738         else if( h->param.rc.f_ip_factor < 0 )
739             q = iq / ip_factor;
740         else if( rcc->accum_p_norm >= 1 )
741             q = pq / ip_factor;
742         else
743             q = rcc->accum_p_norm * pq / ip_factor + (1 - rcc->accum_p_norm) * iq;
744     }
745     else if( pict_type == SLICE_TYPE_B )
746     {
747         if( h->param.rc.f_pb_factor > 0 )
748             q = last_non_b_q;
749         if( !rce->kept_as_ref )
750             q *= fabs( h->param.rc.f_pb_factor );
751     }
752     else if( pict_type == SLICE_TYPE_P
753              && rcc->last_non_b_pict_type == SLICE_TYPE_P
754              && rce->i_tex_bits + rce->p_tex_bits == 0 )
755     {
756         q = last_p_q;
757     }
758
759     /* last qscale / qdiff stuff */
760     if(rcc->last_non_b_pict_type==pict_type
761        && (pict_type!=SLICE_TYPE_I || rcc->last_accum_p_norm < 1))
762     {
763         double last_q = rcc->last_qscale_for[pict_type];
764         double max_qscale = last_q * rcc->lstep;
765         double min_qscale = last_q / rcc->lstep;
766
767         if     (q > max_qscale) q = max_qscale;
768         else if(q < min_qscale) q = min_qscale;
769     }
770
771     rcc->last_qscale_for[pict_type] = q;
772     if(pict_type!=SLICE_TYPE_B)
773         rcc->last_non_b_pict_type = pict_type;
774     if(pict_type==SLICE_TYPE_I)
775     {
776         rcc->last_accum_p_norm = rcc->accum_p_norm;
777         rcc->accum_p_norm = 0;
778         rcc->accum_p_qp = 0;
779     }
780     if(pict_type==SLICE_TYPE_P)
781     {
782         float mask = 1 - pow( (float)rce->i_count / rcc->nmb, 2 );
783         rcc->accum_p_qp   = mask * (qscale2qp(q) + rcc->accum_p_qp);
784         rcc->accum_p_norm = mask * (1 + rcc->accum_p_norm);
785     }
786     return q;
787 }
788
789 static double predict_size( predictor_t *p, double q, double var )
790 {
791      return p->coeff*var / (q*p->count);
792 }
793
794 static void update_predictor( predictor_t *p, double q, double var, double bits )
795 {
796     p->count *= p->decay;
797     p->coeff *= p->decay;
798     p->count ++;
799     p->coeff += bits*q / var;
800 }
801
802 static void update_vbv( x264_t *h, int bits )
803 {
804     x264_ratecontrol_t *rcc = h->rc;
805     if( !rcc->buffer_size )
806         return;
807
808     rcc->buffer_fill += rcc->buffer_rate - bits;
809     if( rcc->buffer_fill < 0 && !rcc->b_2pass )
810         x264_log( h, X264_LOG_WARNING, "VBV underflow (%.0f bits)\n", rcc->buffer_fill );
811     rcc->buffer_fill = x264_clip3( rcc->buffer_fill, 0, rcc->buffer_size );
812
813     if(rcc->last_satd > 100)
814         update_predictor( &rcc->pred[rcc->slice_type], qp2qscale(rcc->qpa), rcc->last_satd, bits );
815 }
816
817 // apply VBV constraints and clip qscale to between lmin and lmax
818 static double clip_qscale( x264_t *h, int pict_type, double q )
819 {
820     x264_ratecontrol_t *rcc = h->rc;
821     double lmin = rcc->lmin[pict_type];
822     double lmax = rcc->lmax[pict_type];
823     double q0 = q;
824
825     /* B-frames are not directly subject to VBV,
826      * since they are controlled by the P-frames' QPs.
827      * FIXME: in 2pass we could modify previous frames' QP too,
828      *        instead of waiting for the buffer to fill */
829     if( rcc->buffer_size &&
830         ( pict_type == SLICE_TYPE_P ||
831           ( pict_type == SLICE_TYPE_I && rcc->last_non_b_pict_type == SLICE_TYPE_I ) ) )
832     {
833         if( rcc->buffer_fill/rcc->buffer_size < 0.5 )
834             q /= x264_clip3f( 2.0*rcc->buffer_fill/rcc->buffer_size, 0.5, 1.0 );
835     }
836     /* Now a hard threshold to make sure the frame fits in VBV.
837      * This one is mostly for I-frames. */
838     if( rcc->buffer_size && rcc->last_satd > 0 )
839     {
840         double bits = predict_size( &rcc->pred[rcc->slice_type], q, rcc->last_satd );
841         double qf = 1.0;
842         if( bits > rcc->buffer_fill/2 )
843             qf = x264_clip3f( rcc->buffer_fill/(2*bits), 0.2, 1.0 );
844         q /= qf;
845         bits *= qf;
846         if( bits < rcc->buffer_rate/2 )
847             q *= bits*2/rcc->buffer_rate;
848         q = X264_MAX( q0, q );
849     }
850
851     if(lmin==lmax)
852         return lmin;
853     else if(rcc->b_2pass)
854     {
855         double min2 = log(lmin);
856         double max2 = log(lmax);
857         q = (log(q) - min2)/(max2-min2) - 0.5;
858         q = 1.0/(1.0 + exp(-4*q));
859         q = q*(max2-min2) + min2;
860         return exp(q);
861     }
862     else
863         return x264_clip3f(q, lmin, lmax);
864 }
865
866 // update qscale for 1 frame based on actual bits used so far
867 static float rate_estimate_qscale(x264_t *h, int pict_type)
868 {
869     float q;
870     x264_ratecontrol_t *rcc = h->rc;
871     ratecontrol_entry_t rce;
872     double lmin = rcc->lmin[pict_type];
873     double lmax = rcc->lmax[pict_type];
874     int64_t total_bits = 8*(h->stat.i_slice_size[SLICE_TYPE_I]
875                           + h->stat.i_slice_size[SLICE_TYPE_P]
876                           + h->stat.i_slice_size[SLICE_TYPE_B]);
877
878     if( rcc->b_2pass )
879     {
880         rce = *rcc->rce;
881         if(pict_type != rce.pict_type)
882         {
883             x264_log(h, X264_LOG_ERROR, "slice=%c but 2pass stats say %c\n",
884                      slice_type_to_char[pict_type], slice_type_to_char[rce.pict_type]);
885         }
886     }
887
888     if( pict_type == SLICE_TYPE_B )
889     {
890         rcc->last_satd = 0;
891         if(h->fenc->b_kept_as_ref)
892             q = rcc->last_qscale * sqrtf(h->param.rc.f_pb_factor);
893         else
894             q = rcc->last_qscale * h->param.rc.f_pb_factor;
895         return x264_clip3f(q, lmin, lmax);
896     }
897     else
898     {
899         double abr_buffer = 2 * rcc->rate_tolerance * rcc->bitrate;
900         if( rcc->b_2pass )
901         {
902             //FIXME adjust abr_buffer based on distance to the end of the video
903             int64_t diff = total_bits - (int64_t)rce.expected_bits;
904             q = rce.new_qscale;
905             q /= x264_clip3f((double)(abr_buffer - diff) / abr_buffer, .5, 2);
906             if( h->fenc->i_frame > 30 )
907             {
908                 /* Adjust quant based on the difference between
909                  * achieved and expected bitrate so far */
910                 double time = (double)h->fenc->i_frame / rcc->num_entries;
911                 double w = x264_clip3f( time*100, 0.0, 1.0 );
912                 q *= pow( (double)total_bits / rcc->expected_bits_sum, w );
913             }
914             q = x264_clip3f( q, lmin, lmax );
915         }
916         else /* 1pass ABR */
917         {
918             /* Calculate the quantizer which would have produced the desired
919              * average bitrate if it had been applied to all frames so far.
920              * Then modulate that quant based on the current frame's complexity
921              * relative to the average complexity so far (using the 2pass RCEQ).
922              * Then bias the quant up or down if total size so far was far from
923              * the target.
924              * Result: Depending on the value of rate_tolerance, there is a
925              * tradeoff between quality and bitrate precision. But at large
926              * tolerances, the bit distribution approaches that of 2pass. */
927
928             double wanted_bits, overflow, lmin, lmax;
929
930             rcc->last_satd = x264_rc_analyse_slice( h );
931             rcc->short_term_cplxsum *= 0.5;
932             rcc->short_term_cplxcount *= 0.5;
933             rcc->short_term_cplxsum += rcc->last_satd;
934             rcc->short_term_cplxcount ++;
935
936             rce.p_tex_bits = rcc->last_satd;
937             rce.blurred_complexity = rcc->short_term_cplxsum / rcc->short_term_cplxcount;
938             rce.i_tex_bits = 0;
939             rce.mv_bits = 0;
940             rce.p_count = rcc->nmb;
941             rce.i_count = 0;
942             rce.s_count = 0;
943             rce.qscale = 1;
944             rce.pict_type = pict_type;
945
946             if( h->param.rc.i_rf_constant )
947             {
948                 q = get_qscale( h, &rce, rcc->rate_factor_constant, h->fenc->i_frame );
949                 overflow = 1;
950             }
951             else
952             {
953                 q = get_qscale( h, &rce, rcc->wanted_bits_window / rcc->cplxr_sum, h->fenc->i_frame );
954
955                 wanted_bits = h->fenc->i_frame * rcc->bitrate / rcc->fps;
956                 abr_buffer *= X264_MAX( 1, sqrt(h->fenc->i_frame/25) );
957                 overflow = x264_clip3f( 1.0 + (total_bits - wanted_bits) / abr_buffer, .5, 2 );
958                 q *= overflow;
959             }
960
961             if( pict_type == SLICE_TYPE_I
962                 /* should test _next_ pict type, but that isn't decided yet */
963                 && rcc->last_non_b_pict_type != SLICE_TYPE_I )
964             {
965                 q = qp2qscale( rcc->accum_p_qp / rcc->accum_p_norm );
966                 q /= fabs( h->param.rc.f_ip_factor );
967                 q = clip_qscale( h, pict_type, q );
968             }
969             else
970             {
971                 if( h->stat.i_slice_count[SLICE_TYPE_P] < 5 )
972                 {
973                     float w = h->stat.i_slice_count[SLICE_TYPE_P] / 5.;
974                     float q2 = qp2qscale(ABR_INIT_QP);
975                     q = q*w + q2*(1-w);
976                 }
977
978                 /* Asymmetric clipping, because symmetric would prevent
979                  * overflow control in areas of rapidly oscillating complexity */
980                 lmin = rcc->last_qscale_for[pict_type] / rcc->lstep;
981                 lmax = rcc->last_qscale_for[pict_type] * rcc->lstep;
982                 if( overflow > 1.1 )
983                     lmax *= rcc->lstep;
984                 else if( overflow < 0.9 )
985                     lmin /= rcc->lstep;
986
987                 q = x264_clip3f(q, lmin, lmax);
988                 q = clip_qscale(h, pict_type, q);
989                 //FIXME use get_diff_limited_q() ?
990             }
991         }
992
993         rcc->last_qscale_for[pict_type] =
994         rcc->last_qscale = q;
995
996         return q;
997     }
998 }
999
1000 static int init_pass2( x264_t *h )
1001 {
1002     x264_ratecontrol_t *rcc = h->rc;
1003     uint64_t all_const_bits = 0;
1004     uint64_t all_available_bits = (uint64_t)(h->param.rc.i_bitrate * 1000 * (double)rcc->num_entries / rcc->fps);
1005     double rate_factor, step, step_mult;
1006     double qblur = h->param.rc.f_qblur;
1007     double cplxblur = h->param.rc.f_complexity_blur;
1008     const int filter_size = (int)(qblur*4) | 1;
1009     double expected_bits;
1010     double *qscale, *blurred_qscale;
1011     int i;
1012
1013     /* find total/average complexity & const_bits */
1014     for(i=0; i<rcc->num_entries; i++){
1015         ratecontrol_entry_t *rce = &rcc->entry[i];
1016         all_const_bits += rce->misc_bits;
1017         rcc->i_cplx_sum[rce->pict_type] += rce->i_tex_bits * rce->qscale;
1018         rcc->p_cplx_sum[rce->pict_type] += rce->p_tex_bits * rce->qscale;
1019         rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits * rce->qscale;
1020         rcc->frame_count[rce->pict_type] ++;
1021     }
1022
1023     if( all_available_bits < all_const_bits)
1024     {
1025         x264_log(h, X264_LOG_ERROR, "requested bitrate is too low. estimated minimum is %d kbps\n",
1026                  (int)(all_const_bits * rcc->fps / (rcc->num_entries * 1000)));
1027         return -1;
1028     }
1029
1030     /* Blur complexities, to reduce local fluctuation of QP.
1031      * We don't blur the QPs directly, because then one very simple frame
1032      * could drag down the QP of a nearby complex frame and give it more
1033      * bits than intended. */
1034     for(i=0; i<rcc->num_entries; i++){
1035         ratecontrol_entry_t *rce = &rcc->entry[i];
1036         double weight_sum = 0;
1037         double cplx_sum = 0;
1038         double weight = 1.0;
1039         int j;
1040         /* weighted average of cplx of future frames */
1041         for(j=1; j<cplxblur*2 && j<rcc->num_entries-i; j++){
1042             ratecontrol_entry_t *rcj = &rcc->entry[i+j];
1043             weight *= 1 - pow( (float)rcj->i_count / rcc->nmb, 2 );
1044             if(weight < .0001)
1045                 break;
1046             weight_sum += weight;
1047             cplx_sum += weight * qscale2bits(rcj, 1);
1048         }
1049         /* weighted average of cplx of past frames */
1050         weight = 1.0;
1051         for(j=0; j<=cplxblur*2 && j<=i; j++){
1052             ratecontrol_entry_t *rcj = &rcc->entry[i-j];
1053             weight_sum += weight;
1054             cplx_sum += weight * qscale2bits(rcj, 1);
1055             weight *= 1 - pow( (float)rcj->i_count / rcc->nmb, 2 );
1056             if(weight < .0001)
1057                 break;
1058         }
1059         rce->blurred_complexity = cplx_sum / weight_sum;
1060     }
1061
1062     qscale = x264_malloc(sizeof(double)*rcc->num_entries);
1063     if(filter_size > 1)
1064         blurred_qscale = x264_malloc(sizeof(double)*rcc->num_entries);
1065     else
1066         blurred_qscale = qscale;
1067
1068     /* Search for a factor which, when multiplied by the RCEQ values from
1069      * each frame, adds up to the desired total size.
1070      * There is no exact closed-form solution because of VBV constraints and
1071      * because qscale2bits is not invertible, but we can start with the simple
1072      * approximation of scaling the 1st pass by the ratio of bitrates.
1073      * The search range is probably overkill, but speed doesn't matter here. */
1074
1075     expected_bits = 1;
1076     for(i=0; i<rcc->num_entries; i++)
1077         expected_bits += qscale2bits(&rcc->entry[i], get_qscale(h, &rcc->entry[i], 1.0, i));
1078     step_mult = all_available_bits / expected_bits;
1079
1080     rate_factor = 0;
1081     for(step = 1E4 * step_mult; step > 1E-7 * step_mult; step *= 0.5){
1082         expected_bits = 0;
1083         rate_factor += step;
1084
1085         rcc->last_non_b_pict_type = -1;
1086         rcc->last_accum_p_norm = 1;
1087         rcc->accum_p_norm = 0;
1088         rcc->buffer_fill = rcc->buffer_size * h->param.rc.f_vbv_buffer_init;
1089
1090         /* find qscale */
1091         for(i=0; i<rcc->num_entries; i++){
1092             qscale[i] = get_qscale(h, &rcc->entry[i], rate_factor, i);
1093         }
1094
1095         /* fixed I/B qscale relative to P */
1096         for(i=rcc->num_entries-1; i>=0; i--){
1097             qscale[i] = get_diff_limited_q(h, &rcc->entry[i], qscale[i]);
1098             assert(qscale[i] >= 0);
1099         }
1100
1101         /* smooth curve */
1102         if(filter_size > 1){
1103             assert(filter_size%2==1);
1104             for(i=0; i<rcc->num_entries; i++){
1105                 ratecontrol_entry_t *rce = &rcc->entry[i];
1106                 int j;
1107                 double q=0.0, sum=0.0;
1108
1109                 for(j=0; j<filter_size; j++){
1110                     int index = i+j-filter_size/2;
1111                     double d = index-i;
1112                     double coeff = qblur==0 ? 1.0 : exp(-d*d/(qblur*qblur));
1113                     if(index < 0 || index >= rcc->num_entries) continue;
1114                     if(rce->pict_type != rcc->entry[index].pict_type) continue;
1115                     q += qscale[index] * coeff;
1116                     sum += coeff;
1117                 }
1118                 blurred_qscale[i] = q/sum;
1119             }
1120         }
1121
1122         /* find expected bits */
1123         for(i=0; i<rcc->num_entries; i++){
1124             ratecontrol_entry_t *rce = &rcc->entry[i];
1125             double bits;
1126             rce->new_qscale = clip_qscale(h, rce->pict_type, blurred_qscale[i]);
1127             assert(rce->new_qscale >= 0);
1128             bits = qscale2bits(rce, rce->new_qscale) + rce->misc_bits;
1129
1130             rce->expected_bits = expected_bits;
1131             expected_bits += bits;
1132             update_vbv(h, bits);
1133         }
1134
1135 //printf("expected:%llu available:%llu factor:%lf avgQ:%lf\n", (uint64_t)expected_bits, all_available_bits, rate_factor);
1136         if(expected_bits > all_available_bits) rate_factor -= step;
1137     }
1138
1139     x264_free(qscale);
1140     if(filter_size > 1)
1141         x264_free(blurred_qscale);
1142
1143     if(fabs(expected_bits/all_available_bits - 1.0) > 0.01)
1144     {
1145         double avgq = 0;
1146         for(i=0; i<rcc->num_entries; i++)
1147             avgq += rcc->entry[i].new_qscale;
1148         avgq = qscale2qp(avgq / rcc->num_entries);
1149
1150         x264_log(h, X264_LOG_ERROR, "Error: 2pass curve failed to converge\n");
1151         x264_log(h, X264_LOG_ERROR, "target: %.2f kbit/s, expected: %.2f kbit/s, avg QP: %.4f\n",
1152                  (float)h->param.rc.i_bitrate,
1153                  expected_bits * rcc->fps / (rcc->num_entries * 1000.),
1154                  avgq);
1155         if(expected_bits < all_available_bits && avgq < h->param.rc.i_qp_min + 2)
1156         {
1157             if(h->param.rc.i_qp_min > 0)
1158                 x264_log(h, X264_LOG_ERROR, "try reducing target bitrate or reducing qp_min (currently %d)\n", h->param.rc.i_qp_min);
1159             else
1160                 x264_log(h, X264_LOG_ERROR, "try reducing target bitrate\n");
1161         }
1162         else if(expected_bits > all_available_bits && avgq > h->param.rc.i_qp_max - 2)
1163         {
1164             if(h->param.rc.i_qp_max < 51)
1165                 x264_log(h, X264_LOG_ERROR, "try increasing target bitrate or increasing qp_max (currently %d)\n", h->param.rc.i_qp_max);
1166             else
1167                 x264_log(h, X264_LOG_ERROR, "try increasing target bitrate\n");
1168         }
1169         else
1170             x264_log(h, X264_LOG_ERROR, "internal error\n");
1171     }
1172
1173     return 0;
1174 }
1175
1176