git.sesse.net Git - x264/blob - encoder/ratecontrol.c

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