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

   1 /***************************************************-*- coding: iso-8859-1 -*-
   2  * ratecontrol.c: h264 encoder library (Rate Control)
   3  *****************************************************************************
   4  * Copyright (C) 2005 x264 project
   5  * $Id: ratecontrol.c,v 1.1 2004/06/03 19:27:08 fenrir Exp $
   6  *
   7  * Authors: Loren Merritt <lorenm@u.washington.edu>
   8  *          Michael Niedermayer <michaelni@gmx.at>
   9  *          Måns Rullgård <mru@mru.ath.cx>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  24  *****************************************************************************/
  25
  26 #define _ISOC99_SOURCE
  27 #undef NDEBUG // always check asserts, the speed effect is far too small to disable them
  28 #include <math.h>
  29 #include <limits.h>
  30 #include <assert.h>
  31
  32 #include "common/common.h"
  33 #include "common/cpu.h"
  34 #include "ratecontrol.h"
  35
  36 typedef struct
  37 {
  38     int pict_type;
  39     int kept_as_ref;
  40     float qscale;
  41     int mv_bits;
  42     int i_tex_bits;
  43     int p_tex_bits;
  44     int misc_bits;
  45     uint64_t expected_bits;
  46     double expected_vbv;
  47     float 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 } ratecontrol_entry_t;
  55
  56 typedef struct
  57 {
  58     double coeff;
  59     double count;
  60     double decay;
  61 } predictor_t;
  62
  63 struct x264_ratecontrol_t
  64 {
  65     /* constants */
  66     int b_abr;
  67     int b_2pass;
  68     int b_vbv;
  69     int b_vbv_min_rate;
  70     double fps;
  71     double bitrate;
  72     double rate_tolerance;
  73     int nmb;                    /* number of macroblocks in a frame */
  74     int qp_constant[5];
  75
  76     /* current frame */
  77     ratecontrol_entry_t *rce;
  78     int qp;                     /* qp for current frame */
  79     int qpm;                    /* qp for current macroblock */
  80     float f_qpm;                /* qp for current macroblock: precise float for AQ */
  81     float qpa_rc;               /* average of macroblocks' qp before aq */
  82     float qpa_aq;               /* average of macroblocks' qp after aq */
  83     int qp_force;
  84
  85     /* VBV stuff */
  86     double buffer_size;
  87     double buffer_fill_final;   /* real buffer as of the last finished frame */
  88     double buffer_fill;         /* planned buffer, if all in-progress frames hit their bit budget */
  89     double buffer_rate;         /* # of bits added to buffer_fill after each frame */
  90     predictor_t *pred;          /* predict frame size from satd */
  91
  92     /* ABR stuff */
  93     int    last_satd;
  94     double last_rceq;
  95     double cplxr_sum;           /* sum of bits*qscale/rceq */
  96     double expected_bits_sum;   /* sum of qscale2bits after rceq, ratefactor, and overflow */
  97     double wanted_bits_window;  /* target bitrate * window */
  98     double cbr_decay;
  99     double short_term_cplxsum;
 100     double short_term_cplxcount;
 101     double rate_factor_constant;
 102     double ip_offset;
 103     double pb_offset;
 104
 105     /* 2pass stuff */
 106     FILE *p_stat_file_out;
 107     char *psz_stat_file_tmpname;
 108
 109     int num_entries;            /* number of ratecontrol_entry_ts */
 110     ratecontrol_entry_t *entry; /* FIXME: copy needed data and free this once init is done */
 111     double last_qscale;
 112     double last_qscale_for[5];  /* last qscale for a specific pict type, used for max_diff & ipb factor stuff  */
 113     int last_non_b_pict_type;
 114     double accum_p_qp;          /* for determining I-frame quant */
 115     double accum_p_norm;
 116     double last_accum_p_norm;
 117     double lmin[5];             /* min qscale by frame type */
 118     double lmax[5];
 119     double lstep;               /* max change (multiply) in qscale per frame */
 120     double i_cplx_sum[5];       /* estimated total texture bits in intra MBs at qscale=1 */
 121     double p_cplx_sum[5];
 122     double mv_bits_sum[5];
 123     int frame_count[5];         /* number of frames of each type */
 124
 125     /* MBRC stuff */
 126     double frame_size_estimated;
 127     double frame_size_planned;
 128     predictor_t *row_pred;
 129     predictor_t row_preds[5];
 130     predictor_t *pred_b_from_p; /* predict B-frame size from P-frame satd */
 131     int bframes;                /* # consecutive B-frames before this P-frame */
 132     int bframe_bits;            /* total cost of those frames */
 133
 134     /* AQ stuff */
 135     float aq_threshold;
 136     int *ac_energy;
 137
 138     int i_zones;
 139     x264_zone_t *zones;
 140     x264_zone_t *prev_zone;
 141 };
 142
 143
 144 static int parse_zones( x264_t *h );
 145 static int init_pass2(x264_t *);
 146 static float rate_estimate_qscale( x264_t *h );
 147 static void update_vbv( x264_t *h, int bits );
 148 static void update_vbv_plan( x264_t *h );
 149 static double predict_size( predictor_t *p, double q, double var );
 150 static void update_predictor( predictor_t *p, double q, double var, double bits );
 151 int  x264_rc_analyse_slice( x264_t *h );
 152
 153 /* Terminology:
 154  * qp = h.264's quantizer
 155  * qscale = linearized quantizer = Lagrange multiplier
 156  */
 157 static inline double qp2qscale(double qp)
 158 {
 159     return 0.85 * pow(2.0, ( qp - 12.0 ) / 6.0);
 160 }
 161 static inline double qscale2qp(double qscale)
 162 {
 163     return 12.0 + 6.0 * log(qscale/0.85) / log(2.0);
 164 }
 165
 166 /* Texture bitrate is not quite inversely proportional to qscale,
 167  * probably due the the changing number of SKIP blocks.
 168  * MV bits level off at about qp<=12, because the lambda used
 169  * for motion estimation is constant there. */
 170 static inline double qscale2bits(ratecontrol_entry_t *rce, double qscale)
 171 {
 172     if(qscale<0.1)
 173         qscale = 0.1;
 174     return (rce->i_tex_bits + rce->p_tex_bits + .1) * pow( rce->qscale / qscale, 1.1 )
 175            + rce->mv_bits * pow( X264_MAX(rce->qscale, 1) / X264_MAX(qscale, 1), 0.5 )
 176            + rce->misc_bits;
 177 }
 178
 179 // Find the total AC energy of the block in all planes.
 180 static NOINLINE int ac_energy_mb( x264_t *h, int mb_x, int mb_y, int *satd )
 181 {
 182     /* This function contains annoying hacks because GCC has a habit of reordering emms
 183      * and putting it after floating point ops.  As a result, we put the emms at the end of the
 184      * function and make sure that its always called before the float math.  Noinline makes
 185      * sure no reordering goes on. */
 186     DECLARE_ALIGNED_16( static uint8_t flat[16] ) = {128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128};
 187     unsigned int var=0, sad, ssd, i;
 188     if( satd || h->param.rc.i_aq_mode == X264_AQ_GLOBAL )
 189     {
 190         for( i=0; i<3; i++ )
 191         {
 192             int w = i ? 8 : 16;
 193             int stride = h->fenc->i_stride[i];
 194             int offset = h->mb.b_interlaced
 195                 ? w * (mb_x + (mb_y&~1) * stride) + (mb_y&1) * stride
 196                 : w * (mb_x + mb_y * stride);
 197             int pix = i ? PIXEL_8x8 : PIXEL_16x16;
 198             stride <<= h->mb.b_interlaced;
 199             sad = h->pixf.sad[pix]( flat, 0, h->fenc->plane[i]+offset, stride );
 200             ssd = h->pixf.ssd[pix]( flat, 0, h->fenc->plane[i]+offset, stride );
 201             var += ssd - (sad * sad >> (i?6:8));
 202             // SATD to represent the block's overall complexity (bit cost) for intra encoding.
 203             // exclude the DC coef, because nothing short of an actual intra prediction will estimate DC cost.
 204             if( var && satd )
 205                 *satd += h->pixf.satd[pix]( flat, 0, h->fenc->plane[i]+offset, stride ) - sad/2;
 206         }
 207         var = X264_MAX(var,1);
 208     }
 209     else var = h->rc->ac_energy[h->mb.i_mb_xy];
 210     x264_emms();
 211     return var;
 212 }
 213
 214 void x264_autosense_aq( x264_t *h )
 215 {
 216     double total = 0;
 217     double n = 0;
 218     int mb_x, mb_y;
 219     // FIXME: Some of the SATDs might be already calculated elsewhere (ratecontrol?). Can we reuse them?
 220     // FIXME: Is chroma SATD necessary?
 221     for( mb_y=0; mb_y<h->sps->i_mb_height; mb_y++ )
 222         for( mb_x=0; mb_x<h->sps->i_mb_width; mb_x++ )
 223         {
 224             int satd=0;
 225             int energy = ac_energy_mb( h, mb_x, mb_y, &satd );
 226             h->rc->ac_energy[mb_x + mb_y * h->sps->i_mb_width] = energy;
 227             /* Weight the energy value by the SATD value of the MB.
 228              * This represents the fact that the more complex blocks in a frame should
 229              * be weighted more when calculating the optimal threshold. This also helps
 230              * diminish the negative effect of large numbers of simple blocks in a frame,
 231              * such as in the case of a letterboxed film. */
 232             total += logf(energy) * satd;
 233             n += satd;
 234         }
 235     x264_emms();
 236     /* Calculate and store the threshold. */
 237     h->rc->aq_threshold = n ? total/n : 15;
 238 }
 239
 240 /*****************************************************************************
 241 * x264_adaptive_quant:
 242  * adjust macroblock QP based on variance (AC energy) of the MB.
 243  * high variance  = higher QP
 244  * low variance = lower QP
 245  * This generally increases SSIM and lowers PSNR.
 246 *****************************************************************************/
 247 void x264_adaptive_quant( x264_t *h )
 248 {
 249     int energy = ac_energy_mb( h, h->mb.i_mb_x, h->mb.i_mb_y, NULL );
 250     /* Adjust the QP based on the AC energy of the macroblock. */
 251     float qp = h->rc->f_qpm;
 252     float qp_adj = 1.5 * (logf(energy) - h->rc->aq_threshold);
 253     if( h->param.rc.i_aq_mode == X264_AQ_LOCAL )
 254         qp_adj = x264_clip3f( qp_adj, -5, 5 );
 255     h->mb.i_qp = x264_clip3( qp + qp_adj * h->param.rc.f_aq_strength + .5, h->param.rc.i_qp_min, h->param.rc.i_qp_max );
 256     /* If the QP of this MB is within 1 of the previous MB, code the same QP as the previous MB,
 257      * to lower the bit cost of the qp_delta. */
 258     if( abs(h->mb.i_qp - h->mb.i_last_qp) == 1 )
 259         h->mb.i_qp = h->mb.i_last_qp;
 260     h->mb.i_chroma_qp = i_chroma_qp_table[x264_clip3( h->mb.i_qp + h->pps->i_chroma_qp_index_offset, 0, 51 )];
 261 }
 262
 263 int x264_ratecontrol_new( x264_t *h )
 264 {
 265     x264_ratecontrol_t *rc;
 266     int i;
 267
 268     x264_emms();
 269
 270     rc = h->rc = x264_malloc( h->param.i_threads * sizeof(x264_ratecontrol_t) );
 271     memset( rc, 0, h->param.i_threads * sizeof(x264_ratecontrol_t) );
 272
 273     rc->b_abr = h->param.rc.i_rc_method != X264_RC_CQP && !h->param.rc.b_stat_read;
 274     rc->b_2pass = h->param.rc.i_rc_method == X264_RC_ABR && h->param.rc.b_stat_read;
 275
 276     /* FIXME: use integers */
 277     if(h->param.i_fps_num > 0 && h->param.i_fps_den > 0)
 278         rc->fps = (float) h->param.i_fps_num / h->param.i_fps_den;
 279     else
 280         rc->fps = 25.0;
 281
 282     rc->bitrate = h->param.rc.i_bitrate * 1000.;
 283     rc->rate_tolerance = h->param.rc.f_rate_tolerance;
 284     rc->nmb = h->mb.i_mb_count;
 285     rc->last_non_b_pict_type = -1;
 286     rc->cbr_decay = 1.0;
 287
 288     if( h->param.rc.i_rc_method == X264_RC_CRF && h->param.rc.b_stat_read )
 289     {
 290         x264_log(h, X264_LOG_ERROR, "constant rate-factor is incompatible with 2pass.\n");
 291         return -1;
 292     }
 293     if( h->param.rc.i_vbv_buffer_size )
 294     {
 295         if( h->param.rc.i_rc_method == X264_RC_CQP )
 296             x264_log(h, X264_LOG_WARNING, "VBV is incompatible with constant QP, ignored.\n");
 297         else if( h->param.rc.i_vbv_max_bitrate == 0 )
 298         {
 299             x264_log( h, X264_LOG_DEBUG, "VBV maxrate unspecified, assuming CBR\n" );
 300             h->param.rc.i_vbv_max_bitrate = h->param.rc.i_bitrate;
 301         }
 302     }
 303     if( h->param.rc.i_vbv_max_bitrate < h->param.rc.i_bitrate &&
 304         h->param.rc.i_vbv_max_bitrate > 0)
 305         x264_log(h, X264_LOG_WARNING, "max bitrate less than average bitrate, ignored.\n");
 306     else if( h->param.rc.i_vbv_max_bitrate > 0 &&
 307              h->param.rc.i_vbv_buffer_size > 0 )
 308     {
 309         if( h->param.rc.i_vbv_buffer_size < 3 * h->param.rc.i_vbv_max_bitrate / rc->fps )
 310         {
 311             h->param.rc.i_vbv_buffer_size = 3 * h->param.rc.i_vbv_max_bitrate / rc->fps;
 312             x264_log( h, X264_LOG_WARNING, "VBV buffer size too small, using %d kbit\n",
 313                       h->param.rc.i_vbv_buffer_size );
 314         }
 315         if( h->param.rc.f_vbv_buffer_init > 1. )
 316             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 );
 317         rc->buffer_rate = h->param.rc.i_vbv_max_bitrate * 1000. / rc->fps;
 318         rc->buffer_size = h->param.rc.i_vbv_buffer_size * 1000.;
 319         rc->buffer_fill_final = rc->buffer_size * h->param.rc.f_vbv_buffer_init;
 320         rc->cbr_decay = 1.0 - rc->buffer_rate / rc->buffer_size
 321                       * 0.5 * X264_MAX(0, 1.5 - rc->buffer_rate * rc->fps / rc->bitrate);
 322         rc->b_vbv = 1;
 323         rc->b_vbv_min_rate = !rc->b_2pass
 324                           && h->param.rc.i_rc_method == X264_RC_ABR
 325                           && h->param.rc.i_vbv_max_bitrate <= h->param.rc.i_bitrate;
 326     }
 327     else if( h->param.rc.i_vbv_max_bitrate )
 328     {
 329         x264_log(h, X264_LOG_WARNING, "VBV maxrate specified, but no bufsize.\n");
 330         h->param.rc.i_vbv_max_bitrate = 0;
 331     }
 332     if(rc->rate_tolerance < 0.01)
 333     {
 334         x264_log(h, X264_LOG_WARNING, "bitrate tolerance too small, using .01\n");
 335         rc->rate_tolerance = 0.01;
 336     }
 337
 338     h->mb.b_variable_qp = rc->b_vbv || h->param.rc.i_aq_mode;
 339
 340     if( rc->b_abr )
 341     {
 342         /* FIXME ABR_INIT_QP is actually used only in CRF */
 343 #define ABR_INIT_QP ( h->param.rc.i_rc_method == X264_RC_CRF ? h->param.rc.f_rf_constant : 24 )
 344         rc->accum_p_norm = .01;
 345         rc->accum_p_qp = ABR_INIT_QP * rc->accum_p_norm;
 346         /* estimated ratio that produces a reasonable QP for the first I-frame */
 347         rc->cplxr_sum = .01 * pow( 7.0e5, h->param.rc.f_qcompress ) * pow( h->mb.i_mb_count, 0.5 );
 348         rc->wanted_bits_window = 1.0 * rc->bitrate / rc->fps;
 349         rc->last_non_b_pict_type = SLICE_TYPE_I;
 350     }
 351
 352     if( h->param.rc.i_rc_method == X264_RC_CRF )
 353     {
 354         /* arbitrary rescaling to make CRF somewhat similar to QP */
 355         double base_cplx = h->mb.i_mb_count * (h->param.i_bframe ? 120 : 80);
 356         rc->rate_factor_constant = pow( base_cplx, 1 - h->param.rc.f_qcompress )
 357                                  / qp2qscale( h->param.rc.f_rf_constant );
 358     }
 359
 360     rc->ip_offset = 6.0 * log(h->param.rc.f_ip_factor) / log(2.0);
 361     rc->pb_offset = 6.0 * log(h->param.rc.f_pb_factor) / log(2.0);
 362     rc->qp_constant[SLICE_TYPE_P] = h->param.rc.i_qp_constant;
 363     rc->qp_constant[SLICE_TYPE_I] = x264_clip3( h->param.rc.i_qp_constant - rc->ip_offset + 0.5, 0, 51 );
 364     rc->qp_constant[SLICE_TYPE_B] = x264_clip3( h->param.rc.i_qp_constant + rc->pb_offset + 0.5, 0, 51 );
 365
 366     rc->lstep = pow( 2, h->param.rc.i_qp_step / 6.0 );
 367     rc->last_qscale = qp2qscale(26);
 368     rc->pred = x264_malloc( 5*sizeof(predictor_t) );
 369     rc->pred_b_from_p = x264_malloc( sizeof(predictor_t) );
 370     for( i = 0; i < 5; i++ )
 371     {
 372         rc->last_qscale_for[i] = qp2qscale( ABR_INIT_QP );
 373         rc->lmin[i] = qp2qscale( h->param.rc.i_qp_min );
 374         rc->lmax[i] = qp2qscale( h->param.rc.i_qp_max );
 375         rc->pred[i].coeff= 2.0;
 376         rc->pred[i].count= 1.0;
 377         rc->pred[i].decay= 0.5;
 378         rc->row_preds[i].coeff= .25;
 379         rc->row_preds[i].count= 1.0;
 380         rc->row_preds[i].decay= 0.5;
 381     }
 382     *rc->pred_b_from_p = rc->pred[0];
 383
 384     if( parse_zones( h ) < 0 )
 385     {
 386         x264_log( h, X264_LOG_ERROR, "failed to parse zones\n" );
 387         return -1;
 388     }
 389
 390     /* Load stat file and init 2pass algo */
 391     if( h->param.rc.b_stat_read )
 392     {
 393         char *p, *stats_in, *stats_buf;
 394
 395         /* read 1st pass stats */
 396         assert( h->param.rc.psz_stat_in );
 397         stats_buf = stats_in = x264_slurp_file( h->param.rc.psz_stat_in );
 398         if( !stats_buf )
 399         {
 400             x264_log(h, X264_LOG_ERROR, "ratecontrol_init: can't open stats file\n");
 401             return -1;
 402         }
 403
 404         /* check whether 1st pass options were compatible with current options */
 405         if( !strncmp( stats_buf, "#options:", 9 ) )
 406         {
 407             int i;
 408             char *opts = stats_buf;
 409             stats_in = strchr( stats_buf, '\n' );
 410             if( !stats_in )
 411                 return -1;
 412             *stats_in = '\0';
 413             stats_in++;
 414
 415             if( ( p = strstr( opts, "bframes=" ) ) && sscanf( p, "bframes=%d", &i )
 416                 && h->param.i_bframe != i )
 417             {
 418                 x264_log( h, X264_LOG_ERROR, "different number of B-frames than 1st pass (%d vs %d)\n",
 419                           h->param.i_bframe, i );
 420                 return -1;
 421             }
 422
 423             /* since B-adapt doesn't (yet) take into account B-pyramid,
 424              * the converse is not a problem */
 425             if( strstr( opts, "b_pyramid=1" ) && !h->param.b_bframe_pyramid )
 426                 x264_log( h, X264_LOG_WARNING, "1st pass used B-pyramid, 2nd doesn't\n" );
 427
 428             if( ( p = strstr( opts, "keyint=" ) ) && sscanf( p, "keyint=%d", &i )
 429                 && h->param.i_keyint_max != i )
 430                 x264_log( h, X264_LOG_WARNING, "different keyint than 1st pass (%d vs %d)\n",
 431                           h->param.i_keyint_max, i );
 432
 433             if( strstr( opts, "qp=0" ) && h->param.rc.i_rc_method == X264_RC_ABR )
 434                 x264_log( h, X264_LOG_WARNING, "1st pass was lossless, bitrate prediction will be inaccurate\n" );
 435         }
 436
 437         /* find number of pics */
 438         p = stats_in;
 439         for(i=-1; p; i++)
 440             p = strchr(p+1, ';');
 441         if(i==0)
 442         {
 443             x264_log(h, X264_LOG_ERROR, "empty stats file\n");
 444             return -1;
 445         }
 446         rc->num_entries = i;
 447
 448         if( h->param.i_frame_total < rc->num_entries && h->param.i_frame_total > 0 )
 449         {
 450             x264_log( h, X264_LOG_WARNING, "2nd pass has fewer frames than 1st pass (%d vs %d)\n",
 451                       h->param.i_frame_total, rc->num_entries );
 452         }
 453         if( h->param.i_frame_total > rc->num_entries + h->param.i_bframe )
 454         {
 455             x264_log( h, X264_LOG_ERROR, "2nd pass has more frames than 1st pass (%d vs %d)\n",
 456                       h->param.i_frame_total, rc->num_entries );
 457             return -1;
 458         }
 459
 460         /* FIXME: ugly padding because VfW drops delayed B-frames */
 461         rc->num_entries += h->param.i_bframe;
 462
 463         rc->entry = (ratecontrol_entry_t*) x264_malloc(rc->num_entries * sizeof(ratecontrol_entry_t));
 464         memset(rc->entry, 0, rc->num_entries * sizeof(ratecontrol_entry_t));
 465
 466         /* init all to skipped p frames */
 467         for(i=0; i<rc->num_entries; i++)
 468         {
 469             ratecontrol_entry_t *rce = &rc->entry[i];
 470             rce->pict_type = SLICE_TYPE_P;
 471             rce->qscale = rce->new_qscale = qp2qscale(20);
 472             rce->misc_bits = rc->nmb + 10;
 473             rce->new_qp = 0;
 474         }
 475
 476         /* read stats */
 477         p = stats_in;
 478         for(i=0; i < rc->num_entries - h->param.i_bframe; i++)
 479         {
 480             ratecontrol_entry_t *rce;
 481             int frame_number;
 482             char pict_type;
 483             int e;
 484             char *next;
 485             float qp;
 486
 487             next= strchr(p, ';');
 488             if(next)
 489             {
 490                 (*next)=0; //sscanf is unbelievably slow on long strings
 491                 next++;
 492             }
 493             e = sscanf(p, " in:%d ", &frame_number);
 494
 495             if(frame_number < 0 || frame_number >= rc->num_entries)
 496             {
 497                 x264_log(h, X264_LOG_ERROR, "bad frame number (%d) at stats line %d\n", frame_number, i);
 498                 return -1;
 499             }
 500             rce = &rc->entry[frame_number];
 501             rce->direct_mode = 0;
 502
 503             e += sscanf(p, " in:%*d out:%*d type:%c q:%f itex:%d ptex:%d mv:%d misc:%d imb:%d pmb:%d smb:%d d:%c",
 504                    &pict_type, &qp, &rce->i_tex_bits, &rce->p_tex_bits,
 505                    &rce->mv_bits, &rce->misc_bits, &rce->i_count, &rce->p_count,
 506                    &rce->s_count, &rce->direct_mode);
 507
 508             switch(pict_type)
 509             {
 510                 case 'I': rce->kept_as_ref = 1;
 511                 case 'i': rce->pict_type = SLICE_TYPE_I; break;
 512                 case 'P': rce->pict_type = SLICE_TYPE_P; break;
 513                 case 'B': rce->kept_as_ref = 1;
 514                 case 'b': rce->pict_type = SLICE_TYPE_B; break;
 515                 default:  e = -1; break;
 516             }
 517             if(e < 10)
 518             {
 519                 x264_log(h, X264_LOG_ERROR, "statistics are damaged at line %d, parser out=%d\n", i, e);
 520                 return -1;
 521             }
 522             rce->qscale = qp2qscale(qp);
 523             p = next;
 524         }
 525
 526         x264_free(stats_buf);
 527
 528         if(h->param.rc.i_rc_method == X264_RC_ABR)
 529         {
 530             if(init_pass2(h) < 0) return -1;
 531         } /* else we're using constant quant, so no need to run the bitrate allocation */
 532     }
 533
 534     /* Open output file */
 535     /* If input and output files are the same, output to a temp file
 536      * and move it to the real name only when it's complete */
 537     if( h->param.rc.b_stat_write )
 538     {
 539         char *p;
 540
 541         rc->psz_stat_file_tmpname = x264_malloc( strlen(h->param.rc.psz_stat_out) + 6 );
 542         strcpy( rc->psz_stat_file_tmpname, h->param.rc.psz_stat_out );
 543         strcat( rc->psz_stat_file_tmpname, ".temp" );
 544
 545         rc->p_stat_file_out = fopen( rc->psz_stat_file_tmpname, "wb" );
 546         if( rc->p_stat_file_out == NULL )
 547         {
 548             x264_log(h, X264_LOG_ERROR, "ratecontrol_init: can't open stats file\n");
 549             return -1;
 550         }
 551
 552         p = x264_param2string( &h->param, 1 );
 553         fprintf( rc->p_stat_file_out, "#options: %s\n", p );
 554         x264_free( p );
 555     }
 556
 557     for( i=0; i<h->param.i_threads; i++ )
 558     {
 559         h->thread[i]->rc = rc+i;
 560         if( i )
 561             rc[i] = rc[0];
 562         if( h->param.rc.i_aq_mode == X264_AQ_LOCAL )
 563             rc[i].ac_energy = x264_malloc( h->mb.i_mb_count * sizeof(int) );
 564     }
 565
 566     return 0;
 567 }
 568
 569 static int parse_zone( x264_t *h, x264_zone_t *z, char *p )
 570 {
 571     int len = 0;
 572     char *tok, *saveptr;
 573     z->param = NULL;
 574     z->f_bitrate_factor = 1;
 575     if( 3 <= sscanf(p, "%u,%u,q=%u%n", &z->i_start, &z->i_end, &z->i_qp, &len) )
 576         z->b_force_qp = 1;
 577     else if( 3 <= sscanf(p, "%u,%u,b=%f%n", &z->i_start, &z->i_end, &z->f_bitrate_factor, &len) )
 578         z->b_force_qp = 0;
 579     else if( 2 <= sscanf(p, "%u,%u%n", &z->i_start, &z->i_end, &len) )
 580         z->b_force_qp = 0;
 581     else
 582     {
 583         x264_log( h, X264_LOG_ERROR, "invalid zone: \"%s\"\n", p );
 584         return -1;
 585     }
 586     p += len;
 587     if( !*p )
 588         return 0;
 589     z->param = malloc( sizeof(x264_param_t) );
 590     memcpy( z->param, &h->param, sizeof(x264_param_t) );
 591     while( (tok = strtok_r( p, ",", &saveptr )) )
 592     {
 593         char *val = strchr( tok, '=' );
 594         if( val )
 595         {
 596             *val = '\0';
 597             val++;
 598         }
 599         if( x264_param_parse( z->param, tok, val ) )
 600         {
 601             x264_log( h, X264_LOG_ERROR, "invalid zone param: %s = %s\n", tok, val );
 602             return -1;
 603         }
 604         p = NULL;
 605     }
 606     return 0;
 607 }
 608
 609 static int parse_zones( x264_t *h )
 610 {
 611     x264_ratecontrol_t *rc = h->rc;
 612     int i;
 613     if( h->param.rc.psz_zones && !h->param.rc.i_zones )
 614     {
 615         char *p, *tok, *saveptr;
 616         char *psz_zones = x264_malloc( strlen(h->param.rc.psz_zones)+1 );
 617         strcpy( psz_zones, h->param.rc.psz_zones );
 618         h->param.rc.i_zones = 1;
 619         for( p = psz_zones; *p; p++ )
 620             h->param.rc.i_zones += (*p == '/');
 621         h->param.rc.zones = x264_malloc( h->param.rc.i_zones * sizeof(x264_zone_t) );
 622         p = psz_zones;
 623         for( i = 0; i < h->param.rc.i_zones; i++ )
 624         {
 625             tok = strtok_r( p, "/", &saveptr );
 626             if( !tok || parse_zone( h, &h->param.rc.zones[i], tok ) )
 627                 return -1;
 628             p = NULL;
 629         }
 630         x264_free( psz_zones );
 631     }
 632
 633     if( h->param.rc.i_zones > 0 )
 634     {
 635         for( i = 0; i < h->param.rc.i_zones; i++ )
 636         {
 637             x264_zone_t z = h->param.rc.zones[i];
 638             if( z.i_start < 0 || z.i_start > z.i_end )
 639             {
 640                 x264_log( h, X264_LOG_ERROR, "invalid zone: start=%d end=%d\n",
 641                           z.i_start, z.i_end );
 642                 return -1;
 643             }
 644             else if( !z.b_force_qp && z.f_bitrate_factor <= 0 )
 645             {
 646                 x264_log( h, X264_LOG_ERROR, "invalid zone: bitrate_factor=%f\n",
 647                           z.f_bitrate_factor );
 648                 return -1;
 649             }
 650         }
 651
 652         rc->i_zones = h->param.rc.i_zones + 1;
 653         rc->zones = x264_malloc( rc->i_zones * sizeof(x264_zone_t) );
 654         memcpy( rc->zones+1, h->param.rc.zones, (rc->i_zones-1) * sizeof(x264_zone_t) );
 655
 656         // default zone to fall back to if none of the others match
 657         rc->zones[0].i_start = 0;
 658         rc->zones[0].i_end = INT_MAX;
 659         rc->zones[0].b_force_qp = 0;
 660         rc->zones[0].f_bitrate_factor = 1;
 661         rc->zones[0].param = x264_malloc( sizeof(x264_param_t) );
 662         memcpy( rc->zones[0].param, &h->param, sizeof(x264_param_t) );
 663         for( i = 1; i < rc->i_zones; i++ )
 664         {
 665             if( !rc->zones[i].param )
 666                 rc->zones[i].param = rc->zones[0].param;
 667         }
 668     }
 669
 670     return 0;
 671 }
 672
 673 x264_zone_t *get_zone( x264_t *h, int frame_num )
 674 {
 675     int i;
 676     for( i = h->rc->i_zones-1; i >= 0; i-- )
 677     {
 678         x264_zone_t *z = &h->rc->zones[i];
 679         if( frame_num >= z->i_start && frame_num <= z->i_end )
 680             return z;
 681     }
 682     return NULL;
 683 }
 684
 685 void x264_ratecontrol_summary( x264_t *h )
 686 {
 687     x264_ratecontrol_t *rc = h->rc;
 688     if( rc->b_abr && h->param.rc.i_rc_method == X264_RC_ABR && rc->cbr_decay > .9999 )
 689     {
 690         double base_cplx = h->mb.i_mb_count * (h->param.i_bframe ? 120 : 80);
 691         x264_log( h, X264_LOG_INFO, "final ratefactor: %.2f\n",
 692                   qscale2qp( pow( base_cplx, 1 - h->param.rc.f_qcompress )
 693                              * rc->cplxr_sum / rc->wanted_bits_window ) );
 694     }
 695 }
 696
 697 void x264_ratecontrol_delete( x264_t *h )
 698 {
 699     x264_ratecontrol_t *rc = h->rc;
 700     int i;
 701
 702     if( rc->p_stat_file_out )
 703     {
 704         fclose( rc->p_stat_file_out );
 705         if( h->i_frame >= rc->num_entries - h->param.i_bframe )
 706             if( rename( rc->psz_stat_file_tmpname, h->param.rc.psz_stat_out ) != 0 )
 707             {
 708                 x264_log( h, X264_LOG_ERROR, "failed to rename \"%s\" to \"%s\"\n",
 709                           rc->psz_stat_file_tmpname, h->param.rc.psz_stat_out );
 710             }
 711         x264_free( rc->psz_stat_file_tmpname );
 712     }
 713     x264_free( rc->pred );
 714     x264_free( rc->pred_b_from_p );
 715     x264_free( rc->entry );
 716     if( rc->zones )
 717     {
 718         x264_free( rc->zones[0].param );
 719         if( h->param.rc.psz_zones )
 720             for( i=1; i<rc->i_zones; i++ )
 721                 if( rc->zones[i].param != rc->zones[0].param )
 722                     x264_free( rc->zones[i].param );
 723         x264_free( rc->zones );
 724     }
 725     for( i=0; i<h->param.i_threads; i++ )
 726         x264_free( rc[i].ac_energy );
 727     x264_free( rc );
 728 }
 729
 730 void x264_ratecontrol_set_estimated_size( x264_t *h, int bits )
 731 {
 732     h->rc->frame_size_estimated = bits;
 733 }
 734
 735 int x264_ratecontrol_get_estimated_size( x264_t const *h)
 736 {
 737     return h->rc->frame_size_estimated;
 738 }
 739
 740 static void accum_p_qp_update( x264_t *h, float qp )
 741 {
 742     x264_ratecontrol_t *rc = h->rc;
 743     rc->accum_p_qp   *= .95;
 744     rc->accum_p_norm *= .95;
 745     rc->accum_p_norm += 1;
 746     if( h->sh.i_type == SLICE_TYPE_I )
 747         rc->accum_p_qp += qp + rc->ip_offset;
 748     else
 749         rc->accum_p_qp += qp;
 750 }
 751
 752 /* Before encoding a frame, choose a QP for it */
 753 void x264_ratecontrol_start( x264_t *h, int i_force_qp )
 754 {
 755     x264_ratecontrol_t *rc = h->rc;
 756     ratecontrol_entry_t *rce = NULL;
 757     x264_zone_t *zone = get_zone( h, h->fenc->i_frame );
 758     float q;
 759
 760     x264_emms();
 761
 762     if( zone && (!rc->prev_zone || zone->param != rc->prev_zone->param) )
 763         x264_encoder_reconfig( h, zone->param );
 764     rc->prev_zone = zone;
 765
 766     rc->qp_force = i_force_qp;
 767
 768     if( h->param.rc.b_stat_read )
 769     {
 770         int frame = h->fenc->i_frame;
 771         assert( frame >= 0 && frame < rc->num_entries );
 772         rce = h->rc->rce = &h->rc->entry[frame];
 773
 774         if( h->sh.i_type == SLICE_TYPE_B
 775             && h->param.analyse.i_direct_mv_pred == X264_DIRECT_PRED_AUTO )
 776         {
 777             h->sh.b_direct_spatial_mv_pred = ( rce->direct_mode == 's' );
 778             h->mb.b_direct_auto_read = ( rce->direct_mode == 's' || rce->direct_mode == 't' );
 779         }
 780     }
 781
 782     if( rc->b_vbv )
 783     {
 784         memset( h->fdec->i_row_bits, 0, h->sps->i_mb_height * sizeof(int) );
 785         rc->row_pred = &rc->row_preds[h->sh.i_type];
 786         update_vbv_plan( h );
 787     }
 788
 789     if( h->sh.i_type != SLICE_TYPE_B )
 790     {
 791         rc->bframes = 0;
 792         while( h->frames.current[rc->bframes] && IS_X264_TYPE_B(h->frames.current[rc->bframes]->i_type) )
 793             rc->bframes++;
 794     }
 795
 796     if( i_force_qp )
 797     {
 798         q = i_force_qp - 1;
 799     }
 800     else if( rc->b_abr )
 801     {
 802         q = qscale2qp( rate_estimate_qscale( h ) );
 803     }
 804     else if( rc->b_2pass )
 805     {
 806         rce->new_qscale = rate_estimate_qscale( h );
 807         q = qscale2qp( rce->new_qscale );
 808     }
 809     else /* CQP */
 810     {
 811         if( h->sh.i_type == SLICE_TYPE_B && h->fdec->b_kept_as_ref )
 812             q = ( rc->qp_constant[ SLICE_TYPE_B ] + rc->qp_constant[ SLICE_TYPE_P ] ) / 2;
 813         else
 814             q = rc->qp_constant[ h->sh.i_type ];
 815
 816         if( zone )
 817         {
 818             if( zone->b_force_qp )
 819                 q += zone->i_qp - rc->qp_constant[SLICE_TYPE_P];
 820             else
 821                 q -= 6*log(zone->f_bitrate_factor)/log(2);
 822         }
 823     }
 824
 825     rc->qpa_rc =
 826     rc->qpa_aq = 0;
 827     h->fdec->f_qp_avg_rc =
 828     h->fdec->f_qp_avg_aq =
 829     rc->qpm =
 830     rc->qp = x264_clip3( (int)(q + 0.5), 0, 51 );
 831     rc->f_qpm = q;
 832     if( rce )
 833         rce->new_qp = rc->qp;
 834
 835     /* accum_p_qp needs to be here so that future frames can benefit from the
 836      * data before this frame is done. but this only works because threading
 837      * guarantees to not re-encode any frames. so the non-threaded case does
 838      * accum_p_qp later. */
 839     if( h->param.i_threads > 1 )
 840         accum_p_qp_update( h, rc->qp );
 841
 842     if( h->sh.i_type != SLICE_TYPE_B )
 843         rc->last_non_b_pict_type = h->sh.i_type;
 844
 845     /* Adaptive AQ thresholding algorithm. */
 846     if( h->param.rc.i_aq_mode == X264_AQ_GLOBAL )
 847         /* Arbitrary value for "center" of the AQ curve.
 848          * Chosen so that any given value of CRF has on average similar bitrate with and without AQ. */
 849         h->rc->aq_threshold = logf(5000);
 850     else if( h->param.rc.i_aq_mode == X264_AQ_LOCAL )
 851         x264_autosense_aq(h);
 852 }
 853
 854 double predict_row_size( x264_t *h, int y, int qp )
 855 {
 856     /* average between two predictors:
 857      * absolute SATD, and scaled bit cost of the colocated row in the previous frame */
 858     x264_ratecontrol_t *rc = h->rc;
 859     double pred_s = predict_size( rc->row_pred, qp2qscale(qp), h->fdec->i_row_satd[y] );
 860     double pred_t = 0;
 861     if( h->sh.i_type != SLICE_TYPE_I
 862         && h->fref0[0]->i_type == h->fdec->i_type
 863         && h->fref0[0]->i_row_satd[y] > 0 )
 864     {
 865         pred_t = h->fref0[0]->i_row_bits[y] * h->fdec->i_row_satd[y] / h->fref0[0]->i_row_satd[y]
 866                  * qp2qscale(h->fref0[0]->i_row_qp[y]) / qp2qscale(qp);
 867     }
 868     if( pred_t == 0 )
 869         pred_t = pred_s;
 870
 871     return (pred_s + pred_t) / 2;
 872 }
 873
 874 double row_bits_so_far( x264_t *h, int y )
 875 {
 876     int i;
 877     double bits = 0;
 878     for( i = 0; i <= y; i++ )
 879         bits += h->fdec->i_row_bits[i];
 880     return bits;
 881 }
 882
 883 double predict_row_size_sum( x264_t *h, int y, int qp )
 884 {
 885     int i;
 886     double bits = row_bits_so_far(h, y);
 887     for( i = y+1; i < h->sps->i_mb_height; i++ )
 888         bits += predict_row_size( h, i, qp );
 889     return bits;
 890 }
 891
 892
 893 void x264_ratecontrol_mb( x264_t *h, int bits )
 894 {
 895     x264_ratecontrol_t *rc = h->rc;
 896     const int y = h->mb.i_mb_y;
 897
 898     x264_emms();
 899
 900     h->fdec->i_row_bits[y] += bits;
 901     rc->qpa_rc += rc->f_qpm;
 902     rc->qpa_aq += h->mb.i_qp;
 903
 904     if( h->mb.i_mb_x != h->sps->i_mb_width - 1 || !rc->b_vbv)
 905         return;
 906
 907     h->fdec->i_row_qp[y] = rc->qpm;
 908
 909     if( h->sh.i_type == SLICE_TYPE_B )
 910     {
 911         /* B-frames shouldn't use lower QP than their reference frames.
 912          * This code is a bit overzealous in limiting B-frame quantizers, but it helps avoid
 913          * underflows due to the fact that B-frames are not explicitly covered by VBV. */
 914         if( y < h->sps->i_mb_height-1 )
 915         {
 916             int i_estimated;
 917             int avg_qp = X264_MAX(h->fref0[0]->i_row_qp[y+1], h->fref1[0]->i_row_qp[y+1])
 918                        + rc->pb_offset * ((h->fenc->i_type == X264_TYPE_BREF) ? 0.5 : 1);
 919             rc->qpm = X264_MIN(X264_MAX( rc->qp, avg_qp), 51); //avg_qp could go higher than 51 due to pb_offset
 920             i_estimated = row_bits_so_far(h, y); //FIXME: compute full estimated size
 921             if (i_estimated > h->rc->frame_size_planned)
 922                 x264_frame_size_estimated_set(h, i_estimated);
 923         }
 924     }
 925     else
 926     {
 927         update_predictor( rc->row_pred, qp2qscale(rc->qpm), h->fdec->i_row_satd[y], h->fdec->i_row_bits[y] );
 928
 929         /* tweak quality based on difference from predicted size */
 930         if( y < h->sps->i_mb_height-1 && h->stat.i_slice_count[h->sh.i_type] > 0 )
 931         {
 932             int prev_row_qp = h->fdec->i_row_qp[y];
 933             int b0 = predict_row_size_sum( h, y, rc->qpm );
 934             int b1 = b0;
 935             int i_qp_max = X264_MIN( prev_row_qp + h->param.rc.i_qp_step, h->param.rc.i_qp_max );
 936             int i_qp_min = X264_MAX( prev_row_qp - h->param.rc.i_qp_step, h->param.rc.i_qp_min );
 937             float buffer_left_planned = rc->buffer_fill - rc->frame_size_planned;
 938             float rc_tol = 1;
 939             float headroom = 0;
 940
 941             /* Don't modify the row QPs until a sufficent amount of the bits of the frame have been processed, in case a flat */
 942             /* area at the top of the frame was measured inaccurately. */
 943             if(row_bits_so_far(h,y) < 0.05 * rc->frame_size_planned)
 944                 return;
 945
 946             headroom = buffer_left_planned/rc->buffer_size;
 947             if(h->sh.i_type != SLICE_TYPE_I)
 948                 headroom /= 2;
 949             rc_tol += headroom;
 950
 951             if( !rc->b_vbv_min_rate )
 952                 i_qp_min = X264_MAX( i_qp_min, h->sh.i_qp );
 953
 954             while( rc->qpm < i_qp_max
 955                    && (b1 > rc->frame_size_planned * rc_tol
 956                     || (rc->buffer_fill - b1 < buffer_left_planned * 0.5)))
 957             {
 958                 rc->qpm ++;
 959                 b1 = predict_row_size_sum( h, y, rc->qpm );
 960             }
 961
 962             /* avoid VBV underflow */
 963             while( (rc->qpm < h->param.rc.i_qp_max)
 964                    && (rc->buffer_fill - b1 < rc->buffer_size * 0.005))
 965             {
 966                 rc->qpm ++;
 967                 b1 = predict_row_size_sum( h, y, rc->qpm );
 968             }
 969
 970             while( rc->qpm > i_qp_min
 971                    && ((buffer_left_planned > rc->buffer_size * 0.4) || rc->qpm > h->fdec->i_row_qp[0])
 972                    && ((b1 < rc->frame_size_planned * 0.8 && rc->qpm <= prev_row_qp)
 973                      || b1 < (rc->buffer_fill - rc->buffer_size + rc->buffer_rate) * 1.1) )
 974             {
 975                 rc->qpm --;
 976                 b1 = predict_row_size_sum( h, y, rc->qpm );
 977             }
 978             x264_frame_size_estimated_set(h, b1);
 979         }
 980     }
 981     /* loses the fractional part of the frame-wise qp */
 982     rc->f_qpm = rc->qpm;
 983 }
 984
 985 int x264_ratecontrol_qp( x264_t *h )
 986 {
 987     return h->rc->qpm;
 988 }
 989
 990 /* In 2pass, force the same frame types as in the 1st pass */
 991 int x264_ratecontrol_slice_type( x264_t *h, int frame_num )
 992 {
 993     x264_ratecontrol_t *rc = h->rc;
 994     if( h->param.rc.b_stat_read )
 995     {
 996         if( frame_num >= rc->num_entries )
 997         {
 998             /* We could try to initialize everything required for ABR and
 999              * adaptive B-frames, but that would be complicated.
1000              * So just calculate the average QP used so far. */
1001
1002             h->param.rc.i_qp_constant = (h->stat.i_slice_count[SLICE_TYPE_P] == 0) ? 24
1003                                       : 1 + h->stat.f_slice_qp[SLICE_TYPE_P] / h->stat.i_slice_count[SLICE_TYPE_P];
1004             rc->qp_constant[SLICE_TYPE_P] = x264_clip3( h->param.rc.i_qp_constant, 0, 51 );
1005             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 );
1006             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 );
1007
1008             x264_log(h, X264_LOG_ERROR, "2nd pass has more frames than 1st pass (%d)\n", rc->num_entries);
1009             x264_log(h, X264_LOG_ERROR, "continuing anyway, at constant QP=%d\n", h->param.rc.i_qp_constant);
1010             if( h->param.b_bframe_adaptive )
1011                 x264_log(h, X264_LOG_ERROR, "disabling adaptive B-frames\n");
1012
1013             rc->b_abr = 0;
1014             rc->b_2pass = 0;
1015             h->param.rc.i_rc_method = X264_RC_CQP;
1016             h->param.rc.b_stat_read = 0;
1017             h->param.b_bframe_adaptive = 0;
1018             if( h->param.i_bframe > 1 )
1019                 h->param.i_bframe = 1;
1020             return X264_TYPE_P;
1021         }
1022         switch( rc->entry[frame_num].pict_type )
1023         {
1024             case SLICE_TYPE_I:
1025                 return rc->entry[frame_num].kept_as_ref ? X264_TYPE_IDR : X264_TYPE_I;
1026
1027             case SLICE_TYPE_B:
1028                 return rc->entry[frame_num].kept_as_ref ? X264_TYPE_BREF : X264_TYPE_B;
1029
1030             case SLICE_TYPE_P:
1031             default:
1032                 return X264_TYPE_P;
1033         }
1034     }
1035     else
1036     {
1037         return X264_TYPE_AUTO;
1038     }
1039 }
1040
1041 /* After encoding one frame, save stats and update ratecontrol state */
1042 void x264_ratecontrol_end( x264_t *h, int bits )
1043 {
1044     x264_ratecontrol_t *rc = h->rc;
1045     const int *mbs = h->stat.frame.i_mb_count;
1046     int i;
1047
1048     x264_emms();
1049
1050     h->stat.frame.i_mb_count_skip = mbs[P_SKIP] + mbs[B_SKIP];
1051     h->stat.frame.i_mb_count_i = mbs[I_16x16] + mbs[I_8x8] + mbs[I_4x4];
1052     h->stat.frame.i_mb_count_p = mbs[P_L0] + mbs[P_8x8];
1053     for( i = B_DIRECT; i < B_8x8; i++ )
1054         h->stat.frame.i_mb_count_p += mbs[i];
1055
1056     h->fdec->f_qp_avg_rc = rc->qpa_rc /= h->mb.i_mb_count;
1057     h->fdec->f_qp_avg_aq = rc->qpa_aq /= h->mb.i_mb_count;
1058
1059     if( h->param.rc.b_stat_write )
1060     {
1061         char c_type = h->sh.i_type==SLICE_TYPE_I ? (h->fenc->i_poc==0 ? 'I' : 'i')
1062                     : h->sh.i_type==SLICE_TYPE_P ? 'P'
1063                     : h->fenc->b_kept_as_ref ? 'B' : 'b';
1064         int dir_frame = h->stat.frame.i_direct_score[1] - h->stat.frame.i_direct_score[0];
1065         int dir_avg = h->stat.i_direct_score[1] - h->stat.i_direct_score[0];
1066         char c_direct = h->mb.b_direct_auto_write ?
1067                         ( dir_frame>0 ? 's' : dir_frame<0 ? 't' :
1068                           dir_avg>0 ? 's' : dir_avg<0 ? 't' : '-' )
1069                         : '-';
1070         fprintf( rc->p_stat_file_out,
1071                  "in:%d out:%d type:%c q:%.2f itex:%d ptex:%d mv:%d misc:%d imb:%d pmb:%d smb:%d d:%c;\n",
1072                  h->fenc->i_frame, h->i_frame,
1073                  c_type, rc->qpa_rc,
1074                  h->stat.frame.i_itex_bits, h->stat.frame.i_ptex_bits,
1075                  h->stat.frame.i_hdr_bits, h->stat.frame.i_misc_bits,
1076                  h->stat.frame.i_mb_count_i,
1077                  h->stat.frame.i_mb_count_p,
1078                  h->stat.frame.i_mb_count_skip,
1079                  c_direct);
1080     }
1081
1082     if( rc->b_abr )
1083     {
1084         if( h->sh.i_type != SLICE_TYPE_B )
1085             rc->cplxr_sum += bits * qp2qscale(rc->qpa_rc) / rc->last_rceq;
1086         else
1087         {
1088             /* Depends on the fact that B-frame's QP is an offset from the following P-frame's.
1089              * Not perfectly accurate with B-refs, but good enough. */
1090             rc->cplxr_sum += bits * qp2qscale(rc->qpa_rc) / (rc->last_rceq * fabs(h->param.rc.f_pb_factor));
1091         }
1092         rc->cplxr_sum *= rc->cbr_decay;
1093         rc->wanted_bits_window += rc->bitrate / rc->fps;
1094         rc->wanted_bits_window *= rc->cbr_decay;
1095
1096         if( h->param.i_threads == 1 )
1097             accum_p_qp_update( h, rc->qpa_rc );
1098     }
1099
1100     if( rc->b_2pass )
1101     {
1102         rc->expected_bits_sum += qscale2bits( rc->rce, qp2qscale(rc->rce->new_qp) );
1103     }
1104
1105     if( h->mb.b_variable_qp )
1106     {
1107         if( h->sh.i_type == SLICE_TYPE_B )
1108         {
1109             rc->bframe_bits += bits;
1110             if( !h->frames.current[0] || !IS_X264_TYPE_B(h->frames.current[0]->i_type) )
1111             {
1112                 update_predictor( rc->pred_b_from_p, qp2qscale(rc->qpa_rc),
1113                                   h->fref1[h->i_ref1-1]->i_satd, rc->bframe_bits / rc->bframes );
1114                 rc->bframe_bits = 0;
1115             }
1116         }
1117     }
1118
1119     update_vbv( h, bits );
1120 }
1121
1122 /****************************************************************************
1123  * 2 pass functions
1124  ***************************************************************************/
1125
1126 double x264_eval( char *s, double *const_value, const char **const_name,
1127                   double (**func1)(void *, double), const char **func1_name,
1128                   double (**func2)(void *, double, double), char **func2_name,
1129                   void *opaque );
1130
1131 /**
1132  * modify the bitrate curve from pass1 for one frame
1133  */
1134 static double get_qscale(x264_t *h, ratecontrol_entry_t *rce, double rate_factor, int frame_num)
1135 {
1136     x264_ratecontrol_t *rcc= h->rc;
1137     const int pict_type = rce->pict_type;
1138     double q;
1139     x264_zone_t *zone = get_zone( h, frame_num );
1140
1141     double const_values[]={
1142         rce->i_tex_bits * rce->qscale,
1143         rce->p_tex_bits * rce->qscale,
1144         (rce->i_tex_bits + rce->p_tex_bits) * rce->qscale,
1145         rce->mv_bits * rce->qscale,
1146         (double)rce->i_count / rcc->nmb,
1147         (double)rce->p_count / rcc->nmb,
1148         (double)rce->s_count / rcc->nmb,
1149         rce->pict_type == SLICE_TYPE_I,
1150         rce->pict_type == SLICE_TYPE_P,
1151         rce->pict_type == SLICE_TYPE_B,
1152         h->param.rc.f_qcompress,
1153         rcc->i_cplx_sum[SLICE_TYPE_I] / rcc->frame_count[SLICE_TYPE_I],
1154         rcc->i_cplx_sum[SLICE_TYPE_P] / rcc->frame_count[SLICE_TYPE_P],
1155         rcc->p_cplx_sum[SLICE_TYPE_P] / rcc->frame_count[SLICE_TYPE_P],
1156         rcc->p_cplx_sum[SLICE_TYPE_B] / rcc->frame_count[SLICE_TYPE_B],
1157         (rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / rcc->frame_count[pict_type],
1158         rce->blurred_complexity,
1159         0
1160     };
1161     static const char *const_names[]={
1162         "iTex",
1163         "pTex",
1164         "tex",
1165         "mv",
1166         "iCount",
1167         "pCount",
1168         "sCount",
1169         "isI",
1170         "isP",
1171         "isB",
1172         "qComp",
1173         "avgIITex",
1174         "avgPITex",
1175         "avgPPTex",
1176         "avgBPTex",
1177         "avgTex",
1178         "blurCplx",
1179         NULL
1180     };
1181     static double (*func1[])(void *, double)={
1182 //      (void *)bits2qscale,
1183         (void *)qscale2bits,
1184         NULL
1185     };
1186     static const char *func1_names[]={
1187 //      "bits2qp",
1188         "qp2bits",
1189         NULL
1190     };
1191
1192     q = x264_eval((char*)h->param.rc.psz_rc_eq, const_values, const_names, func1, func1_names, NULL, NULL, rce);
1193
1194     // avoid NaN's in the rc_eq
1195     if(!isfinite(q) || rce->i_tex_bits + rce->p_tex_bits + rce->mv_bits == 0)
1196         q = rcc->last_qscale;
1197     else
1198     {
1199         rcc->last_rceq = q;
1200         q /= rate_factor;
1201         rcc->last_qscale = q;
1202     }
1203
1204     if( zone )
1205     {
1206         if( zone->b_force_qp )
1207             q = qp2qscale(zone->i_qp);
1208         else
1209             q /= zone->f_bitrate_factor;
1210     }
1211
1212     return q;
1213 }
1214
1215 static double get_diff_limited_q(x264_t *h, ratecontrol_entry_t *rce, double q)
1216 {
1217     x264_ratecontrol_t *rcc = h->rc;
1218     const int pict_type = rce->pict_type;
1219
1220     // force I/B quants as a function of P quants
1221     const double last_p_q    = rcc->last_qscale_for[SLICE_TYPE_P];
1222     const double last_non_b_q= rcc->last_qscale_for[rcc->last_non_b_pict_type];
1223     if( pict_type == SLICE_TYPE_I )
1224     {
1225         double iq = q;
1226         double pq = qp2qscale( rcc->accum_p_qp / rcc->accum_p_norm );
1227         double ip_factor = fabs( h->param.rc.f_ip_factor );
1228         /* don't apply ip_factor if the following frame is also I */
1229         if( rcc->accum_p_norm <= 0 )
1230             q = iq;
1231         else if( h->param.rc.f_ip_factor < 0 )
1232             q = iq / ip_factor;
1233         else if( rcc->accum_p_norm >= 1 )
1234             q = pq / ip_factor;
1235         else
1236             q = rcc->accum_p_norm * pq / ip_factor + (1 - rcc->accum_p_norm) * iq;
1237     }
1238     else if( pict_type == SLICE_TYPE_B )
1239     {
1240         if( h->param.rc.f_pb_factor > 0 )
1241             q = last_non_b_q;
1242         if( !rce->kept_as_ref )
1243             q *= fabs( h->param.rc.f_pb_factor );
1244     }
1245     else if( pict_type == SLICE_TYPE_P
1246              && rcc->last_non_b_pict_type == SLICE_TYPE_P
1247              && rce->i_tex_bits + rce->p_tex_bits == 0 )
1248     {
1249         q = last_p_q;
1250     }
1251
1252     /* last qscale / qdiff stuff */
1253     if(rcc->last_non_b_pict_type==pict_type
1254        && (pict_type!=SLICE_TYPE_I || rcc->last_accum_p_norm < 1))
1255     {
1256         double last_q = rcc->last_qscale_for[pict_type];
1257         double max_qscale = last_q * rcc->lstep;
1258         double min_qscale = last_q / rcc->lstep;
1259
1260         if     (q > max_qscale) q = max_qscale;
1261         else if(q < min_qscale) q = min_qscale;
1262     }
1263
1264     rcc->last_qscale_for[pict_type] = q;
1265     if(pict_type!=SLICE_TYPE_B)
1266         rcc->last_non_b_pict_type = pict_type;
1267     if(pict_type==SLICE_TYPE_I)
1268     {
1269         rcc->last_accum_p_norm = rcc->accum_p_norm;
1270         rcc->accum_p_norm = 0;
1271         rcc->accum_p_qp = 0;
1272     }
1273     if(pict_type==SLICE_TYPE_P)
1274     {
1275         float mask = 1 - pow( (float)rce->i_count / rcc->nmb, 2 );
1276         rcc->accum_p_qp   = mask * (qscale2qp(q) + rcc->accum_p_qp);
1277         rcc->accum_p_norm = mask * (1 + rcc->accum_p_norm);
1278     }
1279     return q;
1280 }
1281
1282 static double predict_size( predictor_t *p, double q, double var )
1283 {
1284      return p->coeff*var / (q*p->count);
1285 }
1286
1287 static void update_predictor( predictor_t *p, double q, double var, double bits )
1288 {
1289     if( var < 10 )
1290         return;
1291     p->count *= p->decay;
1292     p->coeff *= p->decay;
1293     p->count ++;
1294     p->coeff += bits*q / var;
1295 }
1296
1297 // update VBV after encoding a frame
1298 static void update_vbv( x264_t *h, int bits )
1299 {
1300     x264_ratecontrol_t *rcc = h->rc;
1301     x264_ratecontrol_t *rct = h->thread[0]->rc;
1302
1303     if( rcc->last_satd >= h->mb.i_mb_count )
1304         update_predictor( &rct->pred[h->sh.i_type], qp2qscale(rcc->qpa_rc), rcc->last_satd, bits );
1305
1306     if( !rcc->b_vbv )
1307         return;
1308
1309     rct->buffer_fill_final += rct->buffer_rate - bits;
1310     if( rct->buffer_fill_final < 0 )
1311         x264_log( h, X264_LOG_WARNING, "VBV underflow (%.0f bits)\n", rct->buffer_fill_final );
1312     rct->buffer_fill_final = x264_clip3f( rct->buffer_fill_final, 0, rct->buffer_size );
1313 }
1314
1315 // provisionally update VBV according to the planned size of all frames currently in progress
1316 static void update_vbv_plan( x264_t *h )
1317 {
1318     x264_ratecontrol_t *rcc = h->rc;
1319     rcc->buffer_fill = h->thread[0]->rc->buffer_fill_final;
1320     if( h->param.i_threads > 1 )
1321     {
1322         int j = h->rc - h->thread[0]->rc;
1323         int i;
1324         for( i=1; i<h->param.i_threads; i++ )
1325         {
1326             x264_t *t = h->thread[ (j+i)%h->param.i_threads ];
1327             double bits = t->rc->frame_size_planned;
1328             if( !t->b_thread_active )
1329                 continue;
1330             bits  = X264_MAX(bits, x264_frame_size_estimated_get(t));
1331             rcc->buffer_fill += rcc->buffer_rate - bits;
1332             rcc->buffer_fill = x264_clip3( rcc->buffer_fill, 0, rcc->buffer_size );
1333         }
1334     }
1335 }
1336
1337 // apply VBV constraints and clip qscale to between lmin and lmax
1338 static double clip_qscale( x264_t *h, int pict_type, double q )
1339 {
1340     x264_ratecontrol_t *rcc = h->rc;
1341     double lmin = rcc->lmin[pict_type];
1342     double lmax = rcc->lmax[pict_type];
1343     double q0 = q;
1344
1345     /* B-frames are not directly subject to VBV,
1346      * since they are controlled by the P-frames' QPs.
1347      * FIXME: in 2pass we could modify previous frames' QP too,
1348      *        instead of waiting for the buffer to fill */
1349     if( rcc->b_vbv &&
1350         ( pict_type == SLICE_TYPE_P ||
1351           ( pict_type == SLICE_TYPE_I && rcc->last_non_b_pict_type == SLICE_TYPE_I ) ) )
1352     {
1353         if( rcc->buffer_fill/rcc->buffer_size < 0.5 )
1354             q /= x264_clip3f( 2.0*rcc->buffer_fill/rcc->buffer_size, 0.5, 1.0 );
1355     }
1356
1357     if( rcc->b_vbv && rcc->last_satd > 0 )
1358     {
1359         /* Now a hard threshold to make sure the frame fits in VBV.
1360          * This one is mostly for I-frames. */
1361         double bits = predict_size( &rcc->pred[h->sh.i_type], q, rcc->last_satd );
1362         double qf = 1.0;
1363         if( bits > rcc->buffer_fill/2 )
1364             qf = x264_clip3f( rcc->buffer_fill/(2*bits), 0.2, 1.0 );
1365         q /= qf;
1366         bits *= qf;
1367         if( bits < rcc->buffer_rate/2 )
1368             q *= bits*2/rcc->buffer_rate;
1369         q = X264_MAX( q0, q );
1370
1371         /* Check B-frame complexity, and use up any bits that would
1372          * overflow before the next P-frame. */
1373         if( h->sh.i_type == SLICE_TYPE_P )
1374         {
1375             int nb = rcc->bframes;
1376             double pbbits = bits;
1377             double bbits = predict_size( rcc->pred_b_from_p, q * h->param.rc.f_pb_factor, rcc->last_satd );
1378             double space;
1379
1380             if( bbits > rcc->buffer_rate )
1381                 nb = 0;
1382             pbbits += nb * bbits;
1383
1384             space = rcc->buffer_fill + (1+nb)*rcc->buffer_rate - rcc->buffer_size;
1385             if( pbbits < space )
1386             {
1387                 q *= X264_MAX( pbbits / space,
1388                                bits / (0.5 * rcc->buffer_size) );
1389             }
1390             q = X264_MAX( q0-5, q );
1391         }
1392
1393         if( !rcc->b_vbv_min_rate )
1394             q = X264_MAX( q0, q );
1395     }
1396
1397     if(lmin==lmax)
1398         return lmin;
1399     else if(rcc->b_2pass)
1400     {
1401         double min2 = log(lmin);
1402         double max2 = log(lmax);
1403         q = (log(q) - min2)/(max2-min2) - 0.5;
1404         q = 1.0/(1.0 + exp(-4*q));
1405         q = q*(max2-min2) + min2;
1406         return exp(q);
1407     }
1408     else
1409         return x264_clip3f(q, lmin, lmax);
1410 }
1411
1412 // update qscale for 1 frame based on actual bits used so far
1413 static float rate_estimate_qscale( x264_t *h )
1414 {
1415     float q;
1416     x264_ratecontrol_t *rcc = h->rc;
1417     ratecontrol_entry_t rce;
1418     int pict_type = h->sh.i_type;
1419     double lmin = rcc->lmin[pict_type];
1420     double lmax = rcc->lmax[pict_type];
1421     int64_t total_bits = 8*(h->stat.i_slice_size[SLICE_TYPE_I]
1422                           + h->stat.i_slice_size[SLICE_TYPE_P]
1423                           + h->stat.i_slice_size[SLICE_TYPE_B]);
1424
1425     if( rcc->b_2pass )
1426     {
1427         rce = *rcc->rce;
1428         if(pict_type != rce.pict_type)
1429         {
1430             x264_log(h, X264_LOG_ERROR, "slice=%c but 2pass stats say %c\n",
1431                      slice_type_to_char[pict_type], slice_type_to_char[rce.pict_type]);
1432         }
1433     }
1434
1435     if( pict_type == SLICE_TYPE_B )
1436     {
1437         /* B-frames don't have independent ratecontrol, but rather get the
1438          * average QP of the two adjacent P-frames + an offset */
1439
1440         int i0 = IS_X264_TYPE_I(h->fref0[0]->i_type);
1441         int i1 = IS_X264_TYPE_I(h->fref1[0]->i_type);
1442         int dt0 = abs(h->fenc->i_poc - h->fref0[0]->i_poc);
1443         int dt1 = abs(h->fenc->i_poc - h->fref1[0]->i_poc);
1444         float q0 = h->fref0[0]->f_qp_avg_rc;
1445         float q1 = h->fref1[0]->f_qp_avg_rc;
1446
1447         if( h->fref0[0]->i_type == X264_TYPE_BREF )
1448             q0 -= rcc->pb_offset/2;
1449         if( h->fref1[0]->i_type == X264_TYPE_BREF )
1450             q1 -= rcc->pb_offset/2;
1451
1452         if(i0 && i1)
1453             q = (q0 + q1) / 2 + rcc->ip_offset;
1454         else if(i0)
1455             q = q1;
1456         else if(i1)
1457             q = q0;
1458         else
1459             q = (q0*dt1 + q1*dt0) / (dt0 + dt1);
1460
1461         if(h->fenc->b_kept_as_ref)
1462             q += rcc->pb_offset/2;
1463         else
1464             q += rcc->pb_offset;
1465
1466         rcc->frame_size_planned = predict_size( rcc->pred_b_from_p, q, h->fref1[h->i_ref1-1]->i_satd );
1467         x264_frame_size_estimated_set(h, rcc->frame_size_planned);
1468         rcc->last_satd = 0;
1469         return qp2qscale(q);
1470     }
1471     else
1472     {
1473         double abr_buffer = 2 * rcc->rate_tolerance * rcc->bitrate;
1474         if( rcc->b_2pass )
1475         {
1476             //FIXME adjust abr_buffer based on distance to the end of the video
1477             int64_t diff = total_bits - (int64_t)rce.expected_bits;
1478             q = rce.new_qscale;
1479             q /= x264_clip3f((double)(abr_buffer - diff) / abr_buffer, .5, 2);
1480             if( h->fenc->i_frame > 30 )
1481             {
1482                 /* Adjust quant based on the difference between
1483                  * achieved and expected bitrate so far */
1484                 double time = (double)h->fenc->i_frame / rcc->num_entries;
1485                 double w = x264_clip3f( time*100, 0.0, 1.0 );
1486                 q *= pow( (double)total_bits / rcc->expected_bits_sum, w );
1487             }
1488             if( rcc->b_vbv )
1489             {
1490                 double expected_size = qscale2bits(&rce, q);
1491                 double expected_vbv = rcc->buffer_fill + rcc->buffer_rate - expected_size;
1492                 double expected_fullness =  rce.expected_vbv / rcc->buffer_size;
1493                 double qmax = q*(2 - expected_fullness);
1494                 double size_constraint = 1 + expected_fullness;
1495                 if (expected_fullness < .05)
1496                     qmax = lmax;
1497                 qmax = X264_MIN(qmax, lmax);
1498                 while( (expected_vbv < rce.expected_vbv/size_constraint) && (q < qmax) )
1499                 {
1500                     q *= 1.05;
1501                     expected_size = qscale2bits(&rce, q);
1502                     expected_vbv = rcc->buffer_fill + rcc->buffer_rate - expected_size;
1503                 }
1504                 rcc->last_satd = x264_rc_analyse_slice( h );
1505             }
1506             q = x264_clip3f( q, lmin, lmax );
1507         }
1508         else /* 1pass ABR */
1509         {
1510             /* Calculate the quantizer which would have produced the desired
1511              * average bitrate if it had been applied to all frames so far.
1512              * Then modulate that quant based on the current frame's complexity
1513              * relative to the average complexity so far (using the 2pass RCEQ).
1514              * Then bias the quant up or down if total size so far was far from
1515              * the target.
1516              * Result: Depending on the value of rate_tolerance, there is a
1517              * tradeoff between quality and bitrate precision. But at large
1518              * tolerances, the bit distribution approaches that of 2pass. */
1519
1520             double wanted_bits, overflow=1, lmin, lmax;
1521
1522             rcc->last_satd = x264_rc_analyse_slice( h );
1523             rcc->short_term_cplxsum *= 0.5;
1524             rcc->short_term_cplxcount *= 0.5;
1525             rcc->short_term_cplxsum += rcc->last_satd;
1526             rcc->short_term_cplxcount ++;
1527
1528             rce.p_tex_bits = rcc->last_satd;
1529             rce.blurred_complexity = rcc->short_term_cplxsum / rcc->short_term_cplxcount;
1530             rce.i_tex_bits = 0;
1531             rce.mv_bits = 0;
1532             rce.p_count = rcc->nmb;
1533             rce.i_count = 0;
1534             rce.s_count = 0;
1535             rce.qscale = 1;
1536             rce.pict_type = pict_type;
1537
1538             if( h->param.rc.i_rc_method == X264_RC_CRF )
1539             {
1540                 q = get_qscale( h, &rce, rcc->rate_factor_constant, h->fenc->i_frame );
1541             }
1542             else
1543             {
1544                 int i_frame_done = h->fenc->i_frame + 1 - h->param.i_threads;
1545
1546                 q = get_qscale( h, &rce, rcc->wanted_bits_window / rcc->cplxr_sum, h->fenc->i_frame );
1547
1548                 // FIXME is it simpler to keep track of wanted_bits in ratecontrol_end?
1549                 wanted_bits = i_frame_done * rcc->bitrate / rcc->fps;
1550                 if( wanted_bits > 0 )
1551                 {
1552                     abr_buffer *= X264_MAX( 1, sqrt(i_frame_done/25) );
1553                     overflow = x264_clip3f( 1.0 + (total_bits - wanted_bits) / abr_buffer, .5, 2 );
1554                     q *= overflow;
1555                 }
1556             }
1557
1558             if( pict_type == SLICE_TYPE_I && h->param.i_keyint_max > 1
1559                 /* should test _next_ pict type, but that isn't decided yet */
1560                 && rcc->last_non_b_pict_type != SLICE_TYPE_I )
1561             {
1562                 q = qp2qscale( rcc->accum_p_qp / rcc->accum_p_norm );
1563                 q /= fabs( h->param.rc.f_ip_factor );
1564             }
1565             else if( h->i_frame > 0 )
1566             {
1567                 /* Asymmetric clipping, because symmetric would prevent
1568                  * overflow control in areas of rapidly oscillating complexity */
1569                 lmin = rcc->last_qscale_for[pict_type] / rcc->lstep;
1570                 lmax = rcc->last_qscale_for[pict_type] * rcc->lstep;
1571                 if( overflow > 1.1 && h->i_frame > 3 )
1572                     lmax *= rcc->lstep;
1573                 else if( overflow < 0.9 )
1574                     lmin /= rcc->lstep;
1575
1576                 q = x264_clip3f(q, lmin, lmax);
1577             }
1578             else if( h->param.rc.i_rc_method == X264_RC_CRF )
1579             {
1580                 q = qp2qscale( ABR_INIT_QP ) / fabs( h->param.rc.f_ip_factor );
1581             }
1582
1583             //FIXME use get_diff_limited_q() ?
1584             q = clip_qscale( h, pict_type, q );
1585         }
1586
1587         rcc->last_qscale_for[pict_type] =
1588         rcc->last_qscale = q;
1589
1590         if( !(rcc->b_2pass && !rcc->b_vbv) && h->fenc->i_frame == 0 )
1591             rcc->last_qscale_for[SLICE_TYPE_P] = q;
1592
1593         if( rcc->b_2pass && rcc->b_vbv)
1594             rcc->frame_size_planned = qscale2bits(&rce, q);
1595         else
1596             rcc->frame_size_planned = predict_size( &rcc->pred[h->sh.i_type], q, rcc->last_satd );
1597         x264_frame_size_estimated_set(h, rcc->frame_size_planned);
1598         return q;
1599     }
1600 }
1601
1602 void x264_thread_sync_ratecontrol( x264_t *cur, x264_t *prev, x264_t *next )
1603 {
1604     if( cur != prev )
1605     {
1606 #define COPY(var) memcpy(&cur->rc->var, &prev->rc->var, sizeof(cur->rc->var))
1607         /* these vars are updated in x264_ratecontrol_start()
1608          * so copy them from the context that most recently started (prev)
1609          * to the context that's about to start (cur).
1610          */
1611         COPY(accum_p_qp);
1612         COPY(accum_p_norm);
1613         COPY(last_satd);
1614         COPY(last_rceq);
1615         COPY(last_qscale_for);
1616         COPY(last_non_b_pict_type);
1617         COPY(short_term_cplxsum);
1618         COPY(short_term_cplxcount);
1619         COPY(bframes);
1620         COPY(prev_zone);
1621 #undef COPY
1622     }
1623     if( cur != next )
1624     {
1625 #define COPY(var) next->rc->var = cur->rc->var
1626         /* these vars are updated in x264_ratecontrol_end()
1627          * so copy them from the context that most recently ended (cur)
1628          * to the context that's about to end (next)
1629          */
1630         COPY(cplxr_sum);
1631         COPY(expected_bits_sum);
1632         COPY(wanted_bits_window);
1633         COPY(bframe_bits);
1634 #undef COPY
1635     }
1636     //FIXME row_preds[] (not strictly necessary, but would improve prediction)
1637     /* the rest of the variables are either constant or thread-local */
1638 }
1639
1640 static int find_underflow( x264_t *h, double *fills, int *t0, int *t1, int over )
1641 {
1642     /* find an interval ending on an overflow or underflow (depending on whether
1643      * we're adding or removing bits), and starting on the earliest frame that
1644      * can influence the buffer fill of that end frame. */
1645     x264_ratecontrol_t *rcc = h->rc;
1646     const double buffer_min = (over ? .1 : .1) * rcc->buffer_size;
1647     const double buffer_max = .9 * rcc->buffer_size;
1648     double fill = fills[*t0-1];
1649     double parity = over ? 1. : -1.;
1650     int i, start=-1, end=-1;
1651     for(i = *t0; i < rcc->num_entries; i++)
1652     {
1653         fill += (rcc->buffer_rate - qscale2bits(&rcc->entry[i], rcc->entry[i].new_qscale)) * parity;
1654         fill = x264_clip3f(fill, 0, rcc->buffer_size);
1655         fills[i] = fill;
1656         if(fill <= buffer_min || i == 0)
1657         {
1658             if(end >= 0)
1659                 break;
1660             start = i;
1661         }
1662         else if(fill >= buffer_max && start >= 0)
1663             end = i;
1664     }
1665     *t0 = start;
1666     *t1 = end;
1667     return start>=0 && end>=0;
1668 }
1669
1670 static int fix_underflow( x264_t *h, int t0, int t1, double adjustment, double qscale_min, double qscale_max)
1671 {
1672     x264_ratecontrol_t *rcc = h->rc;
1673     double qscale_orig, qscale_new;
1674     int i;
1675     int adjusted = 0;
1676     if(t0 > 0)
1677         t0++;
1678     for(i = t0; i <= t1; i++)
1679     {
1680         qscale_orig = rcc->entry[i].new_qscale;
1681         qscale_orig = x264_clip3f(qscale_orig, qscale_min, qscale_max);
1682         qscale_new  = qscale_orig * adjustment;
1683         qscale_new  = x264_clip3f(qscale_new, qscale_min, qscale_max);
1684         rcc->entry[i].new_qscale = qscale_new;
1685         adjusted = adjusted || (qscale_new != qscale_orig);
1686     }
1687     return adjusted;
1688 }
1689
1690 static double count_expected_bits( x264_t *h )
1691 {
1692     x264_ratecontrol_t *rcc = h->rc;
1693     double expected_bits = 0;
1694     int i;
1695     for(i = 0; i < rcc->num_entries; i++)
1696     {
1697         ratecontrol_entry_t *rce = &rcc->entry[i];
1698         rce->expected_bits = expected_bits;
1699         expected_bits += qscale2bits(rce, rce->new_qscale);
1700     }
1701     return expected_bits;
1702 }
1703
1704 static void vbv_pass2( x264_t *h )
1705 {
1706     /* for each interval of buffer_full .. underflow, uniformly increase the qp of all
1707      * frames in the interval until either buffer is full at some intermediate frame or the
1708      * last frame in the interval no longer underflows.  Recompute intervals and repeat.
1709      * Then do the converse to put bits back into overflow areas until target size is met */
1710
1711     x264_ratecontrol_t *rcc = h->rc;
1712     double *fills = x264_malloc((rcc->num_entries+1)*sizeof(double));
1713     double all_available_bits = h->param.rc.i_bitrate * 1000. * rcc->num_entries / rcc->fps;
1714     double expected_bits = 0;
1715     double adjustment;
1716     double prev_bits = 0;
1717     int i, t0, t1;
1718     double qscale_min = qp2qscale(h->param.rc.i_qp_min);
1719     double qscale_max = qp2qscale(h->param.rc.i_qp_max);
1720     int iterations = 0;
1721     int adj_min, adj_max;
1722
1723     fills++;
1724
1725     /* adjust overall stream size */
1726     do
1727     {
1728         iterations++;
1729         prev_bits = expected_bits;
1730
1731         if(expected_bits != 0)
1732         {   /* not first iteration */
1733             adjustment = X264_MAX(X264_MIN(expected_bits / all_available_bits, 0.999), 0.9);
1734             fills[-1] = rcc->buffer_size * h->param.rc.f_vbv_buffer_init;
1735             t0 = 0;
1736             /* fix overflows */
1737             adj_min = 1;
1738             while(adj_min && find_underflow(h, fills, &t0, &t1, 1))
1739             {
1740                 adj_min = fix_underflow(h, t0, t1, adjustment, qscale_min, qscale_max);
1741                 t0 = t1;
1742             }
1743         }
1744
1745         fills[-1] = rcc->buffer_size * (1. - h->param.rc.f_vbv_buffer_init);
1746         t0 = 0;
1747         /* fix underflows -- should be done after overflow, as we'd better undersize target than underflowing VBV */
1748         adj_max = 1;
1749         while(adj_max && find_underflow(h, fills, &t0, &t1, 0))
1750             adj_max = fix_underflow(h, t0, t1, 1.001, qscale_min, qscale_max);
1751
1752         expected_bits = count_expected_bits(h);
1753     } while(expected_bits < .995 * all_available_bits && expected_bits > prev_bits);
1754
1755     if (!adj_max)
1756         x264_log( h, X264_LOG_WARNING, "vbv-maxrate issue, qpmax or vbv-maxrate too low\n");
1757
1758     /* store expected vbv filling values for tracking when encoding */
1759     for(i = 0; i < rcc->num_entries; i++)
1760         rcc->entry[i].expected_vbv = rcc->buffer_size - fills[i];
1761
1762     x264_free(fills-1);
1763 }
1764
1765 static int init_pass2( x264_t *h )
1766 {
1767     x264_ratecontrol_t *rcc = h->rc;
1768     uint64_t all_const_bits = 0;
1769     uint64_t all_available_bits = (uint64_t)(h->param.rc.i_bitrate * 1000. * rcc->num_entries / rcc->fps);
1770     double rate_factor, step, step_mult;
1771     double qblur = h->param.rc.f_qblur;
1772     double cplxblur = h->param.rc.f_complexity_blur;
1773     const int filter_size = (int)(qblur*4) | 1;
1774     double expected_bits;
1775     double *qscale, *blurred_qscale;
1776     int i;
1777
1778     /* find total/average complexity & const_bits */
1779     for(i=0; i<rcc->num_entries; i++)
1780     {
1781         ratecontrol_entry_t *rce = &rcc->entry[i];
1782         all_const_bits += rce->misc_bits;
1783         rcc->i_cplx_sum[rce->pict_type] += rce->i_tex_bits * rce->qscale;
1784         rcc->p_cplx_sum[rce->pict_type] += rce->p_tex_bits * rce->qscale;
1785         rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits * rce->qscale;
1786         rcc->frame_count[rce->pict_type] ++;
1787     }
1788
1789     if( all_available_bits < all_const_bits)
1790     {
1791         x264_log(h, X264_LOG_ERROR, "requested bitrate is too low. estimated minimum is %d kbps\n",
1792                  (int)(all_const_bits * rcc->fps / (rcc->num_entries * 1000.)));
1793         return -1;
1794     }
1795
1796     /* Blur complexities, to reduce local fluctuation of QP.
1797      * We don't blur the QPs directly, because then one very simple frame
1798      * could drag down the QP of a nearby complex frame and give it more
1799      * bits than intended. */
1800     for(i=0; i<rcc->num_entries; i++)
1801     {
1802         ratecontrol_entry_t *rce = &rcc->entry[i];
1803         double weight_sum = 0;
1804         double cplx_sum = 0;
1805         double weight = 1.0;
1806         double gaussian_weight;
1807         int j;
1808         /* weighted average of cplx of future frames */
1809         for(j=1; j<cplxblur*2 && j<rcc->num_entries-i; j++)
1810         {
1811             ratecontrol_entry_t *rcj = &rcc->entry[i+j];
1812             weight *= 1 - pow( (float)rcj->i_count / rcc->nmb, 2 );
1813             if(weight < .0001)
1814                 break;
1815             gaussian_weight = weight * exp(-j*j/200.0);
1816             weight_sum += gaussian_weight;
1817             cplx_sum += gaussian_weight * (qscale2bits(rcj, 1) - rcj->misc_bits);
1818         }
1819         /* weighted average of cplx of past frames */
1820         weight = 1.0;
1821         for(j=0; j<=cplxblur*2 && j<=i; j++)
1822         {
1823             ratecontrol_entry_t *rcj = &rcc->entry[i-j];
1824             gaussian_weight = weight * exp(-j*j/200.0);
1825             weight_sum += gaussian_weight;
1826             cplx_sum += gaussian_weight * (qscale2bits(rcj, 1) - rcj->misc_bits);
1827             weight *= 1 - pow( (float)rcj->i_count / rcc->nmb, 2 );
1828             if(weight < .0001)
1829                 break;
1830         }
1831         rce->blurred_complexity = cplx_sum / weight_sum;
1832     }
1833
1834     qscale = x264_malloc(sizeof(double)*rcc->num_entries);
1835     if(filter_size > 1)
1836         blurred_qscale = x264_malloc(sizeof(double)*rcc->num_entries);
1837     else
1838         blurred_qscale = qscale;
1839
1840     /* Search for a factor which, when multiplied by the RCEQ values from
1841      * each frame, adds up to the desired total size.
1842      * There is no exact closed-form solution because of VBV constraints and
1843      * because qscale2bits is not invertible, but we can start with the simple
1844      * approximation of scaling the 1st pass by the ratio of bitrates.
1845      * The search range is probably overkill, but speed doesn't matter here. */
1846
1847     expected_bits = 1;
1848     for(i=0; i<rcc->num_entries; i++)
1849         expected_bits += qscale2bits(&rcc->entry[i], get_qscale(h, &rcc->entry[i], 1.0, i));
1850     step_mult = all_available_bits / expected_bits;
1851
1852     rate_factor = 0;
1853     for(step = 1E4 * step_mult; step > 1E-7 * step_mult; step *= 0.5)
1854     {
1855         expected_bits = 0;
1856         rate_factor += step;
1857
1858         rcc->last_non_b_pict_type = -1;
1859         rcc->last_accum_p_norm = 1;
1860         rcc->accum_p_norm = 0;
1861
1862         /* find qscale */
1863         for(i=0; i<rcc->num_entries; i++)
1864         {
1865             qscale[i] = get_qscale(h, &rcc->entry[i], rate_factor, i);
1866         }
1867
1868         /* fixed I/B qscale relative to P */
1869         for(i=rcc->num_entries-1; i>=0; i--)
1870         {
1871             qscale[i] = get_diff_limited_q(h, &rcc->entry[i], qscale[i]);
1872             assert(qscale[i] >= 0);
1873         }
1874
1875         /* smooth curve */
1876         if(filter_size > 1)
1877         {
1878             assert(filter_size%2==1);
1879             for(i=0; i<rcc->num_entries; i++)
1880             {
1881                 ratecontrol_entry_t *rce = &rcc->entry[i];
1882                 int j;
1883                 double q=0.0, sum=0.0;
1884
1885                 for(j=0; j<filter_size; j++)
1886                 {
1887                     int index = i+j-filter_size/2;
1888                     double d = index-i;
1889                     double coeff = qblur==0 ? 1.0 : exp(-d*d/(qblur*qblur));
1890                     if(index < 0 || index >= rcc->num_entries)
1891                         continue;
1892                     if(rce->pict_type != rcc->entry[index].pict_type)
1893                         continue;
1894                     q += qscale[index] * coeff;
1895                     sum += coeff;
1896                 }
1897                 blurred_qscale[i] = q/sum;
1898             }
1899         }
1900
1901         /* find expected bits */
1902         for(i=0; i<rcc->num_entries; i++)
1903         {
1904             ratecontrol_entry_t *rce = &rcc->entry[i];
1905             rce->new_qscale = clip_qscale(h, rce->pict_type, blurred_qscale[i]);
1906             assert(rce->new_qscale >= 0);
1907             expected_bits += qscale2bits(rce, rce->new_qscale);
1908         }
1909
1910         if(expected_bits > all_available_bits) rate_factor -= step;
1911     }
1912
1913     x264_free(qscale);
1914     if(filter_size > 1)
1915         x264_free(blurred_qscale);
1916
1917     if(rcc->b_vbv)
1918         vbv_pass2(h);
1919     expected_bits = count_expected_bits(h);
1920
1921     if(fabs(expected_bits/all_available_bits - 1.0) > 0.01)
1922     {
1923         double avgq = 0;
1924         for(i=0; i<rcc->num_entries; i++)
1925             avgq += rcc->entry[i].new_qscale;
1926         avgq = qscale2qp(avgq / rcc->num_entries);
1927
1928         if ((expected_bits > all_available_bits) || (!rcc->b_vbv))
1929             x264_log(h, X264_LOG_WARNING, "Error: 2pass curve failed to converge\n");
1930         x264_log(h, X264_LOG_WARNING, "target: %.2f kbit/s, expected: %.2f kbit/s, avg QP: %.4f\n",
1931                  (float)h->param.rc.i_bitrate,
1932                  expected_bits * rcc->fps / (rcc->num_entries * 1000.),
1933                  avgq);
1934         if(expected_bits < all_available_bits && avgq < h->param.rc.i_qp_min + 2)
1935         {
1936             if(h->param.rc.i_qp_min > 0)
1937                 x264_log(h, X264_LOG_WARNING, "try reducing target bitrate or reducing qp_min (currently %d)\n", h->param.rc.i_qp_min);
1938             else
1939                 x264_log(h, X264_LOG_WARNING, "try reducing target bitrate\n");
1940         }
1941         else if(expected_bits > all_available_bits && avgq > h->param.rc.i_qp_max - 2)
1942         {
1943             if(h->param.rc.i_qp_max < 51)
1944                 x264_log(h, X264_LOG_WARNING, "try increasing target bitrate or increasing qp_max (currently %d)\n", h->param.rc.i_qp_max);
1945             else
1946                 x264_log(h, X264_LOG_WARNING, "try increasing target bitrate\n");
1947         }
1948         else if(!(rcc->b_2pass && rcc->b_vbv))
1949             x264_log(h, X264_LOG_WARNING, "internal error\n");
1950     }
1951
1952     return 0;
1953 }
1954
1955