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-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 #include <limits.h>
  31 #include <assert.h>
  32
  33 #include "common/common.h"
  34 #include "common/cpu.h"
  35 #include "ratecontrol.h"
  36
  37 typedef struct
  38 {
  39     int pict_type;
  40     int kept_as_ref;
  41     float qscale;
  42     int mv_bits;
  43     int i_tex_bits;
  44     int p_tex_bits;
  45     int misc_bits;
  46     uint64_t expected_bits;
  47     double expected_vbv;
  48     float new_qscale;
  49     int new_qp;
  50     int i_count;
  51     int p_count;
  52     int s_count;
  53     float blurred_complexity;
  54     char direct_mode;
  55 } ratecontrol_entry_t;
  56
  57 typedef struct
  58 {
  59     double coeff;
  60     double count;
  61     double decay;
  62 } predictor_t;
  63
  64 struct x264_ratecontrol_t
  65 {
  66     /* constants */
  67     int b_abr;
  68     int b_2pass;
  69     int b_vbv;
  70     int b_vbv_min_rate;
  71     double fps;
  72     double bitrate;
  73     double rate_tolerance;
  74     int nmb;                    /* number of macroblocks in a frame */
  75     int qp_constant[5];
  76
  77     /* current frame */
  78     ratecontrol_entry_t *rce;
  79     int qp;                     /* qp for current frame */
  80     int qpm;                    /* qp for current macroblock */
  81     float f_qpm;                /* qp for current macroblock: precise float for AQ */
  82     float qpa_rc;               /* average of macroblocks' qp before aq */
  83     float qpa_aq;               /* average of macroblocks' qp after aq */
  84     int qp_force;
  85
  86     /* VBV stuff */
  87     double buffer_size;
  88     double buffer_fill_final;   /* real buffer as of the last finished frame */
  89     double buffer_fill;         /* planned buffer, if all in-progress frames hit their bit budget */
  90     double buffer_rate;         /* # of bits added to buffer_fill after each frame */
  91     predictor_t *pred;          /* predict frame size from satd */
  92
  93     /* ABR stuff */
  94     int    last_satd;
  95     double last_rceq;
  96     double cplxr_sum;           /* sum of bits*qscale/rceq */
  97     double expected_bits_sum;   /* sum of qscale2bits after rceq, ratefactor, and overflow */
  98     double wanted_bits_window;  /* target bitrate * window */
  99     double cbr_decay;
 100     double short_term_cplxsum;
 101     double short_term_cplxcount;
 102     double rate_factor_constant;
 103     double ip_offset;
 104     double pb_offset;
 105
 106     /* 2pass stuff */
 107     FILE *p_stat_file_out;
 108     char *psz_stat_file_tmpname;
 109
 110     int num_entries;            /* number of ratecontrol_entry_ts */
 111     ratecontrol_entry_t *entry; /* FIXME: copy needed data and free this once init is done */
 112     double last_qscale;
 113     double last_qscale_for[5];  /* last qscale for a specific pict type, used for max_diff & ipb factor stuff  */
 114     int last_non_b_pict_type;
 115     double accum_p_qp;          /* for determining I-frame quant */
 116     double accum_p_norm;
 117     double last_accum_p_norm;
 118     double lmin[5];             /* min qscale by frame type */
 119     double lmax[5];
 120     double lstep;               /* max change (multiply) in qscale per frame */
 121     double i_cplx_sum[5];       /* estimated total texture bits in intra MBs at qscale=1 */
 122     double p_cplx_sum[5];
 123     double mv_bits_sum[5];
 124     int frame_count[5];         /* number of frames of each type */
 125
 126     /* MBRC stuff */
 127     double frame_size_estimated;
 128     double frame_size_planned;
 129     predictor_t *row_pred;
 130     predictor_t row_preds[5];
 131     predictor_t *pred_b_from_p; /* predict B-frame size from P-frame satd */
 132     int bframes;                /* # consecutive B-frames before this P-frame */
 133     int bframe_bits;            /* total cost of those frames */
 134
 135     /* AQ stuff */
 136     float aq_threshold;
 137     int *ac_energy;
 138
 139     int i_zones;
 140     x264_zone_t *zones;
 141     x264_zone_t *prev_zone;
 142 };
 143
 144
 145 static int parse_zones( x264_t *h );
 146 static int init_pass2(x264_t *);
 147 static float rate_estimate_qscale( x264_t *h );
 148 static void update_vbv( x264_t *h, int bits );
 149 static void update_vbv_plan( x264_t *h );
 150 static double predict_size( predictor_t *p, double q, double var );
 151 static void update_predictor( predictor_t *p, double q, double var, double bits );
 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     /* FIXME: This array is larger than necessary because a bug in GCC causes an all-zero
 187     * array to be placed in .bss despite .bss not being correctly aligned on some platforms (win32?) */
 188     DECLARE_ALIGNED_16( static uint8_t zero[17] ) = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1};
 189     unsigned int var=0, sad, i;
 190     if( satd || h->param.rc.i_aq_mode == X264_AQ_GLOBAL )
 191     {
 192         for( i=0; i<3; i++ )
 193         {
 194             int w = i ? 8 : 16;
 195             int stride = h->fenc->i_stride[i];
 196             int offset = h->mb.b_interlaced
 197                 ? w * (mb_x + (mb_y&~1) * stride) + (mb_y&1) * stride
 198                 : w * (mb_x + mb_y * stride);
 199             int pix = i ? PIXEL_8x8 : PIXEL_16x16;
 200             stride <<= h->mb.b_interlaced;
 201             var += h->pixf.var[pix]( h->fenc->plane[i]+offset, stride, &sad );
 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]( zero, 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 static 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 = h->chroma_qp_table[h->mb.i_qp];
 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 static 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     x264_pthread_mutex_lock( &h->fenc->mutex );
 733     h->rc->frame_size_estimated = bits;
 734     x264_pthread_mutex_unlock( &h->fenc->mutex );
 735 }
 736
 737 int x264_ratecontrol_get_estimated_size( x264_t const *h)
 738 {
 739     int size;
 740     x264_pthread_mutex_lock( &h->fenc->mutex );
 741     size = h->rc->frame_size_estimated;
 742     x264_pthread_mutex_unlock( &h->fenc->mutex );
 743     return size;
 744 }
 745
 746 static void accum_p_qp_update( x264_t *h, float qp )
 747 {
 748     x264_ratecontrol_t *rc = h->rc;
 749     rc->accum_p_qp   *= .95;
 750     rc->accum_p_norm *= .95;
 751     rc->accum_p_norm += 1;
 752     if( h->sh.i_type == SLICE_TYPE_I )
 753         rc->accum_p_qp += qp + rc->ip_offset;
 754     else
 755         rc->accum_p_qp += qp;
 756 }
 757
 758 /* Before encoding a frame, choose a QP for it */
 759 void x264_ratecontrol_start( x264_t *h, int i_force_qp )
 760 {
 761     x264_ratecontrol_t *rc = h->rc;
 762     ratecontrol_entry_t *rce = NULL;
 763     x264_zone_t *zone = get_zone( h, h->fenc->i_frame );
 764     float q;
 765
 766     x264_emms();
 767
 768     if( zone && (!rc->prev_zone || zone->param != rc->prev_zone->param) )
 769         x264_encoder_reconfig( h, zone->param );
 770     rc->prev_zone = zone;
 771
 772     rc->qp_force = i_force_qp;
 773
 774     if( h->param.rc.b_stat_read )
 775     {
 776         int frame = h->fenc->i_frame;
 777         assert( frame >= 0 && frame < rc->num_entries );
 778         rce = h->rc->rce = &h->rc->entry[frame];
 779
 780         if( h->sh.i_type == SLICE_TYPE_B
 781             && h->param.analyse.i_direct_mv_pred == X264_DIRECT_PRED_AUTO )
 782         {
 783             h->sh.b_direct_spatial_mv_pred = ( rce->direct_mode == 's' );
 784             h->mb.b_direct_auto_read = ( rce->direct_mode == 's' || rce->direct_mode == 't' );
 785         }
 786     }
 787
 788     if( rc->b_vbv )
 789     {
 790         memset( h->fdec->i_row_bits, 0, h->sps->i_mb_height * sizeof(int) );
 791         rc->row_pred = &rc->row_preds[h->sh.i_type];
 792         update_vbv_plan( h );
 793     }
 794
 795     if( h->sh.i_type != SLICE_TYPE_B )
 796     {
 797         rc->bframes = 0;
 798         while( h->frames.current[rc->bframes] && IS_X264_TYPE_B(h->frames.current[rc->bframes]->i_type) )
 799             rc->bframes++;
 800     }
 801
 802     if( i_force_qp )
 803     {
 804         q = i_force_qp - 1;
 805     }
 806     else if( rc->b_abr )
 807     {
 808         q = qscale2qp( rate_estimate_qscale( h ) );
 809     }
 810     else if( rc->b_2pass )
 811     {
 812         rce->new_qscale = rate_estimate_qscale( h );
 813         q = qscale2qp( rce->new_qscale );
 814     }
 815     else /* CQP */
 816     {
 817         if( h->sh.i_type == SLICE_TYPE_B && h->fdec->b_kept_as_ref )
 818             q = ( rc->qp_constant[ SLICE_TYPE_B ] + rc->qp_constant[ SLICE_TYPE_P ] ) / 2;
 819         else
 820             q = rc->qp_constant[ h->sh.i_type ];
 821
 822         if( zone )
 823         {
 824             if( zone->b_force_qp )
 825                 q += zone->i_qp - rc->qp_constant[SLICE_TYPE_P];
 826             else
 827                 q -= 6*log(zone->f_bitrate_factor)/log(2);
 828         }
 829     }
 830
 831     rc->qpa_rc =
 832     rc->qpa_aq = 0;
 833     h->fdec->f_qp_avg_rc =
 834     h->fdec->f_qp_avg_aq =
 835     rc->qpm =
 836     rc->qp = x264_clip3( (int)(q + 0.5), 0, 51 );
 837     rc->f_qpm = q;
 838     if( rce )
 839         rce->new_qp = rc->qp;
 840
 841     /* accum_p_qp needs to be here so that future frames can benefit from the
 842      * data before this frame is done. but this only works because threading
 843      * guarantees to not re-encode any frames. so the non-threaded case does
 844      * accum_p_qp later. */
 845     if( h->param.i_threads > 1 )
 846         accum_p_qp_update( h, rc->qp );
 847
 848     if( h->sh.i_type != SLICE_TYPE_B )
 849         rc->last_non_b_pict_type = h->sh.i_type;
 850
 851     /* Adaptive AQ thresholding algorithm. */
 852     if( h->param.rc.i_aq_mode == X264_AQ_GLOBAL )
 853         /* Arbitrary value for "center" of the AQ curve.
 854          * Chosen so that any given value of CRF has on average similar bitrate with and without AQ. */
 855         h->rc->aq_threshold = logf(5000);
 856     else if( h->param.rc.i_aq_mode == X264_AQ_LOCAL )
 857         x264_autosense_aq(h);
 858 }
 859
 860 static double predict_row_size( x264_t *h, int y, int qp )
 861 {
 862     /* average between two predictors:
 863      * absolute SATD, and scaled bit cost of the colocated row in the previous frame */
 864     x264_ratecontrol_t *rc = h->rc;
 865     double pred_s = predict_size( rc->row_pred, qp2qscale(qp), h->fdec->i_row_satd[y] );
 866     double pred_t = 0;
 867     if( h->sh.i_type != SLICE_TYPE_I
 868         && h->fref0[0]->i_type == h->fdec->i_type
 869         && h->fref0[0]->i_row_satd[y] > 0
 870         && (abs(h->fref0[0]->i_row_satd[y] - h->fdec->i_row_satd[y]) < h->fdec->i_row_satd[y]/2))
 871     {
 872         pred_t = h->fref0[0]->i_row_bits[y] * h->fdec->i_row_satd[y] / h->fref0[0]->i_row_satd[y]
 873                  * qp2qscale(h->fref0[0]->i_row_qp[y]) / qp2qscale(qp);
 874     }
 875     if( pred_t == 0 )
 876         pred_t = pred_s;
 877
 878     return (pred_s + pred_t) / 2;
 879 }
 880
 881 static double row_bits_so_far( x264_t *h, int y )
 882 {
 883     int i;
 884     double bits = 0;
 885     for( i = 0; i <= y; i++ )
 886         bits += h->fdec->i_row_bits[i];
 887     return bits;
 888 }
 889
 890 static double predict_row_size_sum( x264_t *h, int y, int qp )
 891 {
 892     int i;
 893     double bits = row_bits_so_far(h, y);
 894     for( i = y+1; i < h->sps->i_mb_height; i++ )
 895         bits += predict_row_size( h, i, qp );
 896     return bits;
 897 }
 898
 899
 900 void x264_ratecontrol_mb( x264_t *h, int bits )
 901 {
 902     x264_ratecontrol_t *rc = h->rc;
 903     const int y = h->mb.i_mb_y;
 904
 905     x264_emms();
 906
 907     h->fdec->i_row_bits[y] += bits;
 908     rc->qpa_rc += rc->f_qpm;
 909     rc->qpa_aq += h->mb.i_qp;
 910
 911     if( h->mb.i_mb_x != h->sps->i_mb_width - 1 || !rc->b_vbv)
 912         return;
 913
 914     h->fdec->i_row_qp[y] = rc->qpm;
 915
 916     if( h->sh.i_type == SLICE_TYPE_B )
 917     {
 918         /* B-frames shouldn't use lower QP than their reference frames.
 919          * This code is a bit overzealous in limiting B-frame quantizers, but it helps avoid
 920          * underflows due to the fact that B-frames are not explicitly covered by VBV. */
 921         if( y < h->sps->i_mb_height-1 )
 922         {
 923             int i_estimated;
 924             int avg_qp = X264_MAX(h->fref0[0]->i_row_qp[y+1], h->fref1[0]->i_row_qp[y+1])
 925                        + rc->pb_offset * ((h->fenc->i_type == X264_TYPE_BREF) ? 0.5 : 1);
 926             rc->qpm = X264_MIN(X264_MAX( rc->qp, avg_qp), 51); //avg_qp could go higher than 51 due to pb_offset
 927             i_estimated = row_bits_so_far(h, y); //FIXME: compute full estimated size
 928             if (i_estimated > h->rc->frame_size_planned)
 929                 x264_ratecontrol_set_estimated_size(h, i_estimated);
 930         }
 931     }
 932     else
 933     {
 934         update_predictor( rc->row_pred, qp2qscale(rc->qpm), h->fdec->i_row_satd[y], h->fdec->i_row_bits[y] );
 935
 936         /* tweak quality based on difference from predicted size */
 937         if( y < h->sps->i_mb_height-1 && h->stat.i_slice_count[h->sh.i_type] > 0 )
 938         {
 939             int prev_row_qp = h->fdec->i_row_qp[y];
 940             int b0 = predict_row_size_sum( h, y, rc->qpm );
 941             int b1 = b0;
 942             int i_qp_max = X264_MIN( prev_row_qp + h->param.rc.i_qp_step, h->param.rc.i_qp_max );
 943             int i_qp_min = X264_MAX( prev_row_qp - h->param.rc.i_qp_step, h->param.rc.i_qp_min );
 944             float buffer_left_planned = rc->buffer_fill - rc->frame_size_planned;
 945             float rc_tol = 1;
 946             float headroom = 0;
 947
 948             /* Don't modify the row QPs until a sufficent amount of the bits of the frame have been processed, in case a flat */
 949             /* area at the top of the frame was measured inaccurately. */
 950             if(row_bits_so_far(h,y) < 0.05 * rc->frame_size_planned)
 951                 return;
 952
 953             headroom = buffer_left_planned/rc->buffer_size;
 954             if(h->sh.i_type != SLICE_TYPE_I)
 955                 headroom /= 2;
 956             rc_tol += headroom;
 957
 958             if( !rc->b_vbv_min_rate )
 959                 i_qp_min = X264_MAX( i_qp_min, h->sh.i_qp );
 960
 961             while( rc->qpm < i_qp_max
 962                    && (b1 > rc->frame_size_planned * rc_tol
 963                     || (rc->buffer_fill - b1 < buffer_left_planned * 0.5)))
 964             {
 965                 rc->qpm ++;
 966                 b1 = predict_row_size_sum( h, y, rc->qpm );
 967             }
 968
 969             /* avoid VBV underflow */
 970             while( (rc->qpm < h->param.rc.i_qp_max)
 971                    && (rc->buffer_fill - b1 < rc->buffer_size * 0.005))
 972             {
 973                 rc->qpm ++;
 974                 b1 = predict_row_size_sum( h, y, rc->qpm );
 975             }
 976
 977             while( rc->qpm > i_qp_min
 978                    && rc->qpm > h->fdec->i_row_qp[0]
 979                    && ((b1 < rc->frame_size_planned * 0.8 && rc->qpm <= prev_row_qp)
 980                      || b1 < (rc->buffer_fill - rc->buffer_size + rc->buffer_rate) * 1.1) )
 981             {
 982                 rc->qpm --;
 983                 b1 = predict_row_size_sum( h, y, rc->qpm );
 984             }
 985             x264_ratecontrol_set_estimated_size(h, b1);
 986         }
 987     }
 988     /* loses the fractional part of the frame-wise qp */
 989     rc->f_qpm = rc->qpm;
 990 }
 991
 992 int x264_ratecontrol_qp( x264_t *h )
 993 {
 994     return h->rc->qpm;
 995 }
 996
 997 /* In 2pass, force the same frame types as in the 1st pass */
 998 int x264_ratecontrol_slice_type( x264_t *h, int frame_num )
 999 {
1000     x264_ratecontrol_t *rc = h->rc;
1001     if( h->param.rc.b_stat_read )
1002     {
1003         if( frame_num >= rc->num_entries )
1004         {
1005             /* We could try to initialize everything required for ABR and
1006              * adaptive B-frames, but that would be complicated.
1007              * So just calculate the average QP used so far. */
1008
1009             h->param.rc.i_qp_constant = (h->stat.i_slice_count[SLICE_TYPE_P] == 0) ? 24
1010                                       : 1 + h->stat.f_slice_qp[SLICE_TYPE_P] / h->stat.i_slice_count[SLICE_TYPE_P];
1011             rc->qp_constant[SLICE_TYPE_P] = x264_clip3( h->param.rc.i_qp_constant, 0, 51 );
1012             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 );
1013             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 );
1014
1015             x264_log(h, X264_LOG_ERROR, "2nd pass has more frames than 1st pass (%d)\n", rc->num_entries);
1016             x264_log(h, X264_LOG_ERROR, "continuing anyway, at constant QP=%d\n", h->param.rc.i_qp_constant);
1017             if( h->param.b_bframe_adaptive )
1018                 x264_log(h, X264_LOG_ERROR, "disabling adaptive B-frames\n");
1019
1020             rc->b_abr = 0;
1021             rc->b_2pass = 0;
1022             h->param.rc.i_rc_method = X264_RC_CQP;
1023             h->param.rc.b_stat_read = 0;
1024             h->param.b_bframe_adaptive = 0;
1025             if( h->param.i_bframe > 1 )
1026                 h->param.i_bframe = 1;
1027             return X264_TYPE_P;
1028         }
1029         switch( rc->entry[frame_num].pict_type )
1030         {
1031             case SLICE_TYPE_I:
1032                 return rc->entry[frame_num].kept_as_ref ? X264_TYPE_IDR : X264_TYPE_I;
1033
1034             case SLICE_TYPE_B:
1035                 return rc->entry[frame_num].kept_as_ref ? X264_TYPE_BREF : X264_TYPE_B;
1036
1037             case SLICE_TYPE_P:
1038             default:
1039                 return X264_TYPE_P;
1040         }
1041     }
1042     else
1043     {
1044         return X264_TYPE_AUTO;
1045     }
1046 }
1047
1048 /* After encoding one frame, save stats and update ratecontrol state */
1049 void x264_ratecontrol_end( x264_t *h, int bits )
1050 {
1051     x264_ratecontrol_t *rc = h->rc;
1052     const int *mbs = h->stat.frame.i_mb_count;
1053     int i;
1054
1055     x264_emms();
1056
1057     h->stat.frame.i_mb_count_skip = mbs[P_SKIP] + mbs[B_SKIP];
1058     h->stat.frame.i_mb_count_i = mbs[I_16x16] + mbs[I_8x8] + mbs[I_4x4];
1059     h->stat.frame.i_mb_count_p = mbs[P_L0] + mbs[P_8x8];
1060     for( i = B_DIRECT; i < B_8x8; i++ )
1061         h->stat.frame.i_mb_count_p += mbs[i];
1062
1063     h->fdec->f_qp_avg_rc = rc->qpa_rc /= h->mb.i_mb_count;
1064     h->fdec->f_qp_avg_aq = rc->qpa_aq /= h->mb.i_mb_count;
1065
1066     if( h->param.rc.b_stat_write )
1067     {
1068         char c_type = h->sh.i_type==SLICE_TYPE_I ? (h->fenc->i_poc==0 ? 'I' : 'i')
1069                     : h->sh.i_type==SLICE_TYPE_P ? 'P'
1070                     : h->fenc->b_kept_as_ref ? 'B' : 'b';
1071         int dir_frame = h->stat.frame.i_direct_score[1] - h->stat.frame.i_direct_score[0];
1072         int dir_avg = h->stat.i_direct_score[1] - h->stat.i_direct_score[0];
1073         char c_direct = h->mb.b_direct_auto_write ?
1074                         ( dir_frame>0 ? 's' : dir_frame<0 ? 't' :
1075                           dir_avg>0 ? 's' : dir_avg<0 ? 't' : '-' )
1076                         : '-';
1077         fprintf( rc->p_stat_file_out,
1078                  "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",
1079                  h->fenc->i_frame, h->i_frame,
1080                  c_type, rc->qpa_rc,
1081                  h->stat.frame.i_itex_bits, h->stat.frame.i_ptex_bits,
1082                  h->stat.frame.i_hdr_bits, h->stat.frame.i_misc_bits,
1083                  h->stat.frame.i_mb_count_i,
1084                  h->stat.frame.i_mb_count_p,
1085                  h->stat.frame.i_mb_count_skip,
1086                  c_direct);
1087     }
1088
1089     if( rc->b_abr )
1090     {
1091         if( h->sh.i_type != SLICE_TYPE_B )
1092             rc->cplxr_sum += bits * qp2qscale(rc->qpa_rc) / rc->last_rceq;
1093         else
1094         {
1095             /* Depends on the fact that B-frame's QP is an offset from the following P-frame's.
1096              * Not perfectly accurate with B-refs, but good enough. */
1097             rc->cplxr_sum += bits * qp2qscale(rc->qpa_rc) / (rc->last_rceq * fabs(h->param.rc.f_pb_factor));
1098         }
1099         rc->cplxr_sum *= rc->cbr_decay;
1100         rc->wanted_bits_window += rc->bitrate / rc->fps;
1101         rc->wanted_bits_window *= rc->cbr_decay;
1102
1103         if( h->param.i_threads == 1 )
1104             accum_p_qp_update( h, rc->qpa_rc );
1105     }
1106
1107     if( rc->b_2pass )
1108     {
1109         rc->expected_bits_sum += qscale2bits( rc->rce, qp2qscale(rc->rce->new_qp) );
1110     }
1111
1112     if( h->mb.b_variable_qp )
1113     {
1114         if( h->sh.i_type == SLICE_TYPE_B )
1115         {
1116             rc->bframe_bits += bits;
1117             if( !h->frames.current[0] || !IS_X264_TYPE_B(h->frames.current[0]->i_type) )
1118             {
1119                 update_predictor( rc->pred_b_from_p, qp2qscale(rc->qpa_rc),
1120                                   h->fref1[h->i_ref1-1]->i_satd, rc->bframe_bits / rc->bframes );
1121                 rc->bframe_bits = 0;
1122             }
1123         }
1124     }
1125
1126     update_vbv( h, bits );
1127 }
1128
1129 /****************************************************************************
1130  * 2 pass functions
1131  ***************************************************************************/
1132
1133 double x264_eval( char *s, double *const_value, const char **const_name,
1134                   double (**func1)(void *, double), const char **func1_name,
1135                   double (**func2)(void *, double, double), char **func2_name,
1136                   void *opaque );
1137
1138 /**
1139  * modify the bitrate curve from pass1 for one frame
1140  */
1141 static double get_qscale(x264_t *h, ratecontrol_entry_t *rce, double rate_factor, int frame_num)
1142 {
1143     x264_ratecontrol_t *rcc= h->rc;
1144     const int pict_type = rce->pict_type;
1145     double q;
1146     x264_zone_t *zone = get_zone( h, frame_num );
1147
1148     double const_values[]={
1149         rce->i_tex_bits * rce->qscale,
1150         rce->p_tex_bits * rce->qscale,
1151         (rce->i_tex_bits + rce->p_tex_bits) * rce->qscale,
1152         rce->mv_bits * rce->qscale,
1153         (double)rce->i_count / rcc->nmb,
1154         (double)rce->p_count / rcc->nmb,
1155         (double)rce->s_count / rcc->nmb,
1156         rce->pict_type == SLICE_TYPE_I,
1157         rce->pict_type == SLICE_TYPE_P,
1158         rce->pict_type == SLICE_TYPE_B,
1159         h->param.rc.f_qcompress,
1160         rcc->i_cplx_sum[SLICE_TYPE_I] / rcc->frame_count[SLICE_TYPE_I],
1161         rcc->i_cplx_sum[SLICE_TYPE_P] / rcc->frame_count[SLICE_TYPE_P],
1162         rcc->p_cplx_sum[SLICE_TYPE_P] / rcc->frame_count[SLICE_TYPE_P],
1163         rcc->p_cplx_sum[SLICE_TYPE_B] / rcc->frame_count[SLICE_TYPE_B],
1164         (rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / rcc->frame_count[pict_type],
1165         rce->blurred_complexity,
1166         0
1167     };
1168     static const char *const_names[]={
1169         "iTex",
1170         "pTex",
1171         "tex",
1172         "mv",
1173         "iCount",
1174         "pCount",
1175         "sCount",
1176         "isI",
1177         "isP",
1178         "isB",
1179         "qComp",
1180         "avgIITex",
1181         "avgPITex",
1182         "avgPPTex",
1183         "avgBPTex",
1184         "avgTex",
1185         "blurCplx",
1186         NULL
1187     };
1188     static double (*func1[])(void *, double)={
1189 //      (void *)bits2qscale,
1190         (void *)qscale2bits,
1191         NULL
1192     };
1193     static const char *func1_names[]={
1194 //      "bits2qp",
1195         "qp2bits",
1196         NULL
1197     };
1198
1199     q = x264_eval((char*)h->param.rc.psz_rc_eq, const_values, const_names, func1, func1_names, NULL, NULL, rce);
1200
1201     // avoid NaN's in the rc_eq
1202     if(!isfinite(q) || rce->i_tex_bits + rce->p_tex_bits + rce->mv_bits == 0)
1203         q = rcc->last_qscale;
1204     else
1205     {
1206         rcc->last_rceq = q;
1207         q /= rate_factor;
1208         rcc->last_qscale = q;
1209     }
1210
1211     if( zone )
1212     {
1213         if( zone->b_force_qp )
1214             q = qp2qscale(zone->i_qp);
1215         else
1216             q /= zone->f_bitrate_factor;
1217     }
1218
1219     return q;
1220 }
1221
1222 static double get_diff_limited_q(x264_t *h, ratecontrol_entry_t *rce, double q)
1223 {
1224     x264_ratecontrol_t *rcc = h->rc;
1225     const int pict_type = rce->pict_type;
1226
1227     // force I/B quants as a function of P quants
1228     const double last_p_q    = rcc->last_qscale_for[SLICE_TYPE_P];
1229     const double last_non_b_q= rcc->last_qscale_for[rcc->last_non_b_pict_type];
1230     if( pict_type == SLICE_TYPE_I )
1231     {
1232         double iq = q;
1233         double pq = qp2qscale( rcc->accum_p_qp / rcc->accum_p_norm );
1234         double ip_factor = fabs( h->param.rc.f_ip_factor );
1235         /* don't apply ip_factor if the following frame is also I */
1236         if( rcc->accum_p_norm <= 0 )
1237             q = iq;
1238         else if( h->param.rc.f_ip_factor < 0 )
1239             q = iq / ip_factor;
1240         else if( rcc->accum_p_norm >= 1 )
1241             q = pq / ip_factor;
1242         else
1243             q = rcc->accum_p_norm * pq / ip_factor + (1 - rcc->accum_p_norm) * iq;
1244     }
1245     else if( pict_type == SLICE_TYPE_B )
1246     {
1247         if( h->param.rc.f_pb_factor > 0 )
1248             q = last_non_b_q;
1249         if( !rce->kept_as_ref )
1250             q *= fabs( h->param.rc.f_pb_factor );
1251     }
1252     else if( pict_type == SLICE_TYPE_P
1253              && rcc->last_non_b_pict_type == SLICE_TYPE_P
1254              && rce->i_tex_bits + rce->p_tex_bits == 0 )
1255     {
1256         q = last_p_q;
1257     }
1258
1259     /* last qscale / qdiff stuff */
1260     if(rcc->last_non_b_pict_type==pict_type
1261        && (pict_type!=SLICE_TYPE_I || rcc->last_accum_p_norm < 1))
1262     {
1263         double last_q = rcc->last_qscale_for[pict_type];
1264         double max_qscale = last_q * rcc->lstep;
1265         double min_qscale = last_q / rcc->lstep;
1266
1267         if     (q > max_qscale) q = max_qscale;
1268         else if(q < min_qscale) q = min_qscale;
1269     }
1270
1271     rcc->last_qscale_for[pict_type] = q;
1272     if(pict_type!=SLICE_TYPE_B)
1273         rcc->last_non_b_pict_type = pict_type;
1274     if(pict_type==SLICE_TYPE_I)
1275     {
1276         rcc->last_accum_p_norm = rcc->accum_p_norm;
1277         rcc->accum_p_norm = 0;
1278         rcc->accum_p_qp = 0;
1279     }
1280     if(pict_type==SLICE_TYPE_P)
1281     {
1282         float mask = 1 - pow( (float)rce->i_count / rcc->nmb, 2 );
1283         rcc->accum_p_qp   = mask * (qscale2qp(q) + rcc->accum_p_qp);
1284         rcc->accum_p_norm = mask * (1 + rcc->accum_p_norm);
1285     }
1286     return q;
1287 }
1288
1289 static double predict_size( predictor_t *p, double q, double var )
1290 {
1291      return p->coeff*var / (q*p->count);
1292 }
1293
1294 static void update_predictor( predictor_t *p, double q, double var, double bits )
1295 {
1296     if( var < 10 )
1297         return;
1298     p->count *= p->decay;
1299     p->coeff *= p->decay;
1300     p->count ++;
1301     p->coeff += bits*q / var;
1302 }
1303
1304 // update VBV after encoding a frame
1305 static void update_vbv( x264_t *h, int bits )
1306 {
1307     x264_ratecontrol_t *rcc = h->rc;
1308     x264_ratecontrol_t *rct = h->thread[0]->rc;
1309
1310     if( rcc->last_satd >= h->mb.i_mb_count )
1311         update_predictor( &rct->pred[h->sh.i_type], qp2qscale(rcc->qpa_rc), rcc->last_satd, bits );
1312
1313     if( !rcc->b_vbv )
1314         return;
1315
1316     rct->buffer_fill_final += rct->buffer_rate - bits;
1317     if( rct->buffer_fill_final < 0 )
1318         x264_log( h, X264_LOG_WARNING, "VBV underflow (%.0f bits)\n", rct->buffer_fill_final );
1319     rct->buffer_fill_final = x264_clip3f( rct->buffer_fill_final, 0, rct->buffer_size );
1320 }
1321
1322 // provisionally update VBV according to the planned size of all frames currently in progress
1323 static void update_vbv_plan( x264_t *h )
1324 {
1325     x264_ratecontrol_t *rcc = h->rc;
1326     rcc->buffer_fill = h->thread[0]->rc->buffer_fill_final;
1327     if( h->param.i_threads > 1 )
1328     {
1329         int j = h->rc - h->thread[0]->rc;
1330         int i;
1331         for( i=1; i<h->param.i_threads; i++ )
1332         {
1333             x264_t *t = h->thread[ (j+i)%h->param.i_threads ];
1334             double bits = t->rc->frame_size_planned;
1335             if( !t->b_thread_active )
1336                 continue;
1337             bits  = X264_MAX(bits, x264_ratecontrol_get_estimated_size(t));
1338             rcc->buffer_fill += rcc->buffer_rate - bits;
1339             rcc->buffer_fill = x264_clip3( rcc->buffer_fill, 0, rcc->buffer_size );
1340         }
1341     }
1342 }
1343
1344 // apply VBV constraints and clip qscale to between lmin and lmax
1345 static double clip_qscale( x264_t *h, int pict_type, double q )
1346 {
1347     x264_ratecontrol_t *rcc = h->rc;
1348     double lmin = rcc->lmin[pict_type];
1349     double lmax = rcc->lmax[pict_type];
1350     double q0 = q;
1351
1352     /* B-frames are not directly subject to VBV,
1353      * since they are controlled by the P-frames' QPs.
1354      * FIXME: in 2pass we could modify previous frames' QP too,
1355      *        instead of waiting for the buffer to fill */
1356     if( rcc->b_vbv &&
1357         ( pict_type == SLICE_TYPE_P ||
1358           ( pict_type == SLICE_TYPE_I && rcc->last_non_b_pict_type == SLICE_TYPE_I ) ) )
1359     {
1360         if( rcc->buffer_fill/rcc->buffer_size < 0.5 )
1361             q /= x264_clip3f( 2.0*rcc->buffer_fill/rcc->buffer_size, 0.5, 1.0 );
1362     }
1363
1364     if( rcc->b_vbv && rcc->last_satd > 0 )
1365     {
1366         /* Now a hard threshold to make sure the frame fits in VBV.
1367          * This one is mostly for I-frames. */
1368         double bits = predict_size( &rcc->pred[h->sh.i_type], q, rcc->last_satd );
1369         double qf = 1.0;
1370         if( bits > rcc->buffer_fill/2 )
1371             qf = x264_clip3f( rcc->buffer_fill/(2*bits), 0.2, 1.0 );
1372         q /= qf;
1373         bits *= qf;
1374         if( bits < rcc->buffer_rate/2 )
1375             q *= bits*2/rcc->buffer_rate;
1376         q = X264_MAX( q0, q );
1377
1378         /* Check B-frame complexity, and use up any bits that would
1379          * overflow before the next P-frame. */
1380         if( h->sh.i_type == SLICE_TYPE_P )
1381         {
1382             int nb = rcc->bframes;
1383             double pbbits = bits;
1384             double bbits = predict_size( rcc->pred_b_from_p, q * h->param.rc.f_pb_factor, rcc->last_satd );
1385             double space;
1386
1387             if( bbits > rcc->buffer_rate )
1388                 nb = 0;
1389             pbbits += nb * bbits;
1390
1391             space = rcc->buffer_fill + (1+nb)*rcc->buffer_rate - rcc->buffer_size;
1392             if( pbbits < space )
1393             {
1394                 q *= X264_MAX( pbbits / space,
1395                                bits / (0.5 * rcc->buffer_size) );
1396             }
1397             q = X264_MAX( q0-5, q );
1398         }
1399
1400         if( !rcc->b_vbv_min_rate )
1401             q = X264_MAX( q0, q );
1402     }
1403
1404     if(lmin==lmax)
1405         return lmin;
1406     else if(rcc->b_2pass)
1407     {
1408         double min2 = log(lmin);
1409         double max2 = log(lmax);
1410         q = (log(q) - min2)/(max2-min2) - 0.5;
1411         q = 1.0/(1.0 + exp(-4*q));
1412         q = q*(max2-min2) + min2;
1413         return exp(q);
1414     }
1415     else
1416         return x264_clip3f(q, lmin, lmax);
1417 }
1418
1419 // update qscale for 1 frame based on actual bits used so far
1420 static float rate_estimate_qscale( x264_t *h )
1421 {
1422     float q;
1423     x264_ratecontrol_t *rcc = h->rc;
1424     ratecontrol_entry_t rce;
1425     int pict_type = h->sh.i_type;
1426     double lmin = rcc->lmin[pict_type];
1427     double lmax = rcc->lmax[pict_type];
1428     int64_t total_bits = 8*(h->stat.i_slice_size[SLICE_TYPE_I]
1429                           + h->stat.i_slice_size[SLICE_TYPE_P]
1430                           + h->stat.i_slice_size[SLICE_TYPE_B]);
1431
1432     if( rcc->b_2pass )
1433     {
1434         rce = *rcc->rce;
1435         if(pict_type != rce.pict_type)
1436         {
1437             x264_log(h, X264_LOG_ERROR, "slice=%c but 2pass stats say %c\n",
1438                      slice_type_to_char[pict_type], slice_type_to_char[rce.pict_type]);
1439         }
1440     }
1441
1442     if( pict_type == SLICE_TYPE_B )
1443     {
1444         /* B-frames don't have independent ratecontrol, but rather get the
1445          * average QP of the two adjacent P-frames + an offset */
1446
1447         int i0 = IS_X264_TYPE_I(h->fref0[0]->i_type);
1448         int i1 = IS_X264_TYPE_I(h->fref1[0]->i_type);
1449         int dt0 = abs(h->fenc->i_poc - h->fref0[0]->i_poc);
1450         int dt1 = abs(h->fenc->i_poc - h->fref1[0]->i_poc);
1451         float q0 = h->fref0[0]->f_qp_avg_rc;
1452         float q1 = h->fref1[0]->f_qp_avg_rc;
1453
1454         if( h->fref0[0]->i_type == X264_TYPE_BREF )
1455             q0 -= rcc->pb_offset/2;
1456         if( h->fref1[0]->i_type == X264_TYPE_BREF )
1457             q1 -= rcc->pb_offset/2;
1458
1459         if(i0 && i1)
1460             q = (q0 + q1) / 2 + rcc->ip_offset;
1461         else if(i0)
1462             q = q1;
1463         else if(i1)
1464             q = q0;
1465         else
1466             q = (q0*dt1 + q1*dt0) / (dt0 + dt1);
1467
1468         if(h->fenc->b_kept_as_ref)
1469             q += rcc->pb_offset/2;
1470         else
1471             q += rcc->pb_offset;
1472
1473         rcc->frame_size_planned = predict_size( rcc->pred_b_from_p, q, h->fref1[h->i_ref1-1]->i_satd );
1474         x264_ratecontrol_set_estimated_size(h, rcc->frame_size_planned);
1475         rcc->last_satd = 0;
1476         return qp2qscale(q);
1477     }
1478     else
1479     {
1480         double abr_buffer = 2 * rcc->rate_tolerance * rcc->bitrate;
1481         if( rcc->b_2pass )
1482         {
1483             //FIXME adjust abr_buffer based on distance to the end of the video
1484             int64_t diff = total_bits - (int64_t)rce.expected_bits;
1485             q = rce.new_qscale;
1486             q /= x264_clip3f((double)(abr_buffer - diff) / abr_buffer, .5, 2);
1487             if( h->fenc->i_frame > 30 )
1488             {
1489                 /* Adjust quant based on the difference between
1490                  * achieved and expected bitrate so far */
1491                 double time = (double)h->fenc->i_frame / rcc->num_entries;
1492                 double w = x264_clip3f( time*100, 0.0, 1.0 );
1493                 q *= pow( (double)total_bits / rcc->expected_bits_sum, w );
1494             }
1495             if( rcc->b_vbv )
1496             {
1497                 double expected_size = qscale2bits(&rce, q);
1498                 double expected_vbv = rcc->buffer_fill + rcc->buffer_rate - expected_size;
1499                 double expected_fullness =  rce.expected_vbv / rcc->buffer_size;
1500                 double qmax = q*(2 - expected_fullness);
1501                 double size_constraint = 1 + expected_fullness;
1502                 if (expected_fullness < .05)
1503                     qmax = lmax;
1504                 qmax = X264_MIN(qmax, lmax);
1505                 while( (expected_vbv < rce.expected_vbv/size_constraint) && (q < qmax) )
1506                 {
1507                     q *= 1.05;
1508                     expected_size = qscale2bits(&rce, q);
1509                     expected_vbv = rcc->buffer_fill + rcc->buffer_rate - expected_size;
1510                 }
1511                 rcc->last_satd = x264_rc_analyse_slice( h );
1512             }
1513             q = x264_clip3f( q, lmin, lmax );
1514         }
1515         else /* 1pass ABR */
1516         {
1517             /* Calculate the quantizer which would have produced the desired
1518              * average bitrate if it had been applied to all frames so far.
1519              * Then modulate that quant based on the current frame's complexity
1520              * relative to the average complexity so far (using the 2pass RCEQ).
1521              * Then bias the quant up or down if total size so far was far from
1522              * the target.
1523              * Result: Depending on the value of rate_tolerance, there is a
1524              * tradeoff between quality and bitrate precision. But at large
1525              * tolerances, the bit distribution approaches that of 2pass. */
1526
1527             double wanted_bits, overflow=1, lmin, lmax;
1528
1529             rcc->last_satd = x264_rc_analyse_slice( h );
1530             rcc->short_term_cplxsum *= 0.5;
1531             rcc->short_term_cplxcount *= 0.5;
1532             rcc->short_term_cplxsum += rcc->last_satd;
1533             rcc->short_term_cplxcount ++;
1534
1535             rce.p_tex_bits = rcc->last_satd;
1536             rce.blurred_complexity = rcc->short_term_cplxsum / rcc->short_term_cplxcount;
1537             rce.i_tex_bits = 0;
1538             rce.mv_bits = 0;
1539             rce.p_count = rcc->nmb;
1540             rce.i_count = 0;
1541             rce.s_count = 0;
1542             rce.qscale = 1;
1543             rce.pict_type = pict_type;
1544
1545             if( h->param.rc.i_rc_method == X264_RC_CRF )
1546             {
1547                 q = get_qscale( h, &rce, rcc->rate_factor_constant, h->fenc->i_frame );
1548             }
1549             else
1550             {
1551                 int i_frame_done = h->fenc->i_frame + 1 - h->param.i_threads;
1552
1553                 q = get_qscale( h, &rce, rcc->wanted_bits_window / rcc->cplxr_sum, h->fenc->i_frame );
1554
1555                 // FIXME is it simpler to keep track of wanted_bits in ratecontrol_end?
1556                 wanted_bits = i_frame_done * rcc->bitrate / rcc->fps;
1557                 if( wanted_bits > 0 )
1558                 {
1559                     abr_buffer *= X264_MAX( 1, sqrt(i_frame_done/25) );
1560                     overflow = x264_clip3f( 1.0 + (total_bits - wanted_bits) / abr_buffer, .5, 2 );
1561                     q *= overflow;
1562                 }
1563             }
1564
1565             if( pict_type == SLICE_TYPE_I && h->param.i_keyint_max > 1
1566                 /* should test _next_ pict type, but that isn't decided yet */
1567                 && rcc->last_non_b_pict_type != SLICE_TYPE_I )
1568             {
1569                 q = qp2qscale( rcc->accum_p_qp / rcc->accum_p_norm );
1570                 q /= fabs( h->param.rc.f_ip_factor );
1571             }
1572             else if( h->i_frame > 0 )
1573             {
1574                 /* Asymmetric clipping, because symmetric would prevent
1575                  * overflow control in areas of rapidly oscillating complexity */
1576                 lmin = rcc->last_qscale_for[pict_type] / rcc->lstep;
1577                 lmax = rcc->last_qscale_for[pict_type] * rcc->lstep;
1578                 if( overflow > 1.1 && h->i_frame > 3 )
1579                     lmax *= rcc->lstep;
1580                 else if( overflow < 0.9 )
1581                     lmin /= rcc->lstep;
1582
1583                 q = x264_clip3f(q, lmin, lmax);
1584             }
1585             else if( h->param.rc.i_rc_method == X264_RC_CRF )
1586             {
1587                 q = qp2qscale( ABR_INIT_QP ) / fabs( h->param.rc.f_ip_factor );
1588             }
1589
1590             //FIXME use get_diff_limited_q() ?
1591             q = clip_qscale( h, pict_type, q );
1592         }
1593
1594         rcc->last_qscale_for[pict_type] =
1595         rcc->last_qscale = q;
1596
1597         if( !(rcc->b_2pass && !rcc->b_vbv) && h->fenc->i_frame == 0 )
1598             rcc->last_qscale_for[SLICE_TYPE_P] = q;
1599
1600         if( rcc->b_2pass && rcc->b_vbv)
1601             rcc->frame_size_planned = qscale2bits(&rce, q);
1602         else
1603             rcc->frame_size_planned = predict_size( &rcc->pred[h->sh.i_type], q, rcc->last_satd );
1604         x264_ratecontrol_set_estimated_size(h, rcc->frame_size_planned);
1605         return q;
1606     }
1607 }
1608
1609 void x264_thread_sync_ratecontrol( x264_t *cur, x264_t *prev, x264_t *next )
1610 {
1611     if( cur != prev )
1612     {
1613 #define COPY(var) memcpy(&cur->rc->var, &prev->rc->var, sizeof(cur->rc->var))
1614         /* these vars are updated in x264_ratecontrol_start()
1615          * so copy them from the context that most recently started (prev)
1616          * to the context that's about to start (cur).
1617          */
1618         COPY(accum_p_qp);
1619         COPY(accum_p_norm);
1620         COPY(last_satd);
1621         COPY(last_rceq);
1622         COPY(last_qscale_for);
1623         COPY(last_non_b_pict_type);
1624         COPY(short_term_cplxsum);
1625         COPY(short_term_cplxcount);
1626         COPY(bframes);
1627         COPY(prev_zone);
1628 #undef COPY
1629     }
1630     if( cur != next )
1631     {
1632 #define COPY(var) next->rc->var = cur->rc->var
1633         /* these vars are updated in x264_ratecontrol_end()
1634          * so copy them from the context that most recently ended (cur)
1635          * to the context that's about to end (next)
1636          */
1637         COPY(cplxr_sum);
1638         COPY(expected_bits_sum);
1639         COPY(wanted_bits_window);
1640         COPY(bframe_bits);
1641 #undef COPY
1642     }
1643     //FIXME row_preds[] (not strictly necessary, but would improve prediction)
1644     /* the rest of the variables are either constant or thread-local */
1645 }
1646
1647 static int find_underflow( x264_t *h, double *fills, int *t0, int *t1, int over )
1648 {
1649     /* find an interval ending on an overflow or underflow (depending on whether
1650      * we're adding or removing bits), and starting on the earliest frame that
1651      * can influence the buffer fill of that end frame. */
1652     x264_ratecontrol_t *rcc = h->rc;
1653     const double buffer_min = (over ? .1 : .1) * rcc->buffer_size;
1654     const double buffer_max = .9 * rcc->buffer_size;
1655     double fill = fills[*t0-1];
1656     double parity = over ? 1. : -1.;
1657     int i, start=-1, end=-1;
1658     for(i = *t0; i < rcc->num_entries; i++)
1659     {
1660         fill += (rcc->buffer_rate - qscale2bits(&rcc->entry[i], rcc->entry[i].new_qscale)) * parity;
1661         fill = x264_clip3f(fill, 0, rcc->buffer_size);
1662         fills[i] = fill;
1663         if(fill <= buffer_min || i == 0)
1664         {
1665             if(end >= 0)
1666                 break;
1667             start = i;
1668         }
1669         else if(fill >= buffer_max && start >= 0)
1670             end = i;
1671     }
1672     *t0 = start;
1673     *t1 = end;
1674     return start>=0 && end>=0;
1675 }
1676
1677 static int fix_underflow( x264_t *h, int t0, int t1, double adjustment, double qscale_min, double qscale_max)
1678 {
1679     x264_ratecontrol_t *rcc = h->rc;
1680     double qscale_orig, qscale_new;
1681     int i;
1682     int adjusted = 0;
1683     if(t0 > 0)
1684         t0++;
1685     for(i = t0; i <= t1; i++)
1686     {
1687         qscale_orig = rcc->entry[i].new_qscale;
1688         qscale_orig = x264_clip3f(qscale_orig, qscale_min, qscale_max);
1689         qscale_new  = qscale_orig * adjustment;
1690         qscale_new  = x264_clip3f(qscale_new, qscale_min, qscale_max);
1691         rcc->entry[i].new_qscale = qscale_new;
1692         adjusted = adjusted || (qscale_new != qscale_orig);
1693     }
1694     return adjusted;
1695 }
1696
1697 static double count_expected_bits( x264_t *h )
1698 {
1699     x264_ratecontrol_t *rcc = h->rc;
1700     double expected_bits = 0;
1701     int i;
1702     for(i = 0; i < rcc->num_entries; i++)
1703     {
1704         ratecontrol_entry_t *rce = &rcc->entry[i];
1705         rce->expected_bits = expected_bits;
1706         expected_bits += qscale2bits(rce, rce->new_qscale);
1707     }
1708     return expected_bits;
1709 }
1710
1711 static void vbv_pass2( x264_t *h )
1712 {
1713     /* for each interval of buffer_full .. underflow, uniformly increase the qp of all
1714      * frames in the interval until either buffer is full at some intermediate frame or the
1715      * last frame in the interval no longer underflows.  Recompute intervals and repeat.
1716      * Then do the converse to put bits back into overflow areas until target size is met */
1717
1718     x264_ratecontrol_t *rcc = h->rc;
1719     double *fills = x264_malloc((rcc->num_entries+1)*sizeof(double));
1720     double all_available_bits = h->param.rc.i_bitrate * 1000. * rcc->num_entries / rcc->fps;
1721     double expected_bits = 0;
1722     double adjustment;
1723     double prev_bits = 0;
1724     int i, t0, t1;
1725     double qscale_min = qp2qscale(h->param.rc.i_qp_min);
1726     double qscale_max = qp2qscale(h->param.rc.i_qp_max);
1727     int iterations = 0;
1728     int adj_min, adj_max;
1729
1730     fills++;
1731
1732     /* adjust overall stream size */
1733     do
1734     {
1735         iterations++;
1736         prev_bits = expected_bits;
1737
1738         if(expected_bits != 0)
1739         {   /* not first iteration */
1740             adjustment = X264_MAX(X264_MIN(expected_bits / all_available_bits, 0.999), 0.9);
1741             fills[-1] = rcc->buffer_size * h->param.rc.f_vbv_buffer_init;
1742             t0 = 0;
1743             /* fix overflows */
1744             adj_min = 1;
1745             while(adj_min && find_underflow(h, fills, &t0, &t1, 1))
1746             {
1747                 adj_min = fix_underflow(h, t0, t1, adjustment, qscale_min, qscale_max);
1748                 t0 = t1;
1749             }
1750         }
1751
1752         fills[-1] = rcc->buffer_size * (1. - h->param.rc.f_vbv_buffer_init);
1753         t0 = 0;
1754         /* fix underflows -- should be done after overflow, as we'd better undersize target than underflowing VBV */
1755         adj_max = 1;
1756         while(adj_max && find_underflow(h, fills, &t0, &t1, 0))
1757             adj_max = fix_underflow(h, t0, t1, 1.001, qscale_min, qscale_max);
1758
1759         expected_bits = count_expected_bits(h);
1760     } while(expected_bits < .995 * all_available_bits && expected_bits > prev_bits);
1761
1762     if (!adj_max)
1763         x264_log( h, X264_LOG_WARNING, "vbv-maxrate issue, qpmax or vbv-maxrate too low\n");
1764
1765     /* store expected vbv filling values for tracking when encoding */
1766     for(i = 0; i < rcc->num_entries; i++)
1767         rcc->entry[i].expected_vbv = rcc->buffer_size - fills[i];
1768
1769     x264_free(fills-1);
1770 }
1771
1772 static int init_pass2( x264_t *h )
1773 {
1774     x264_ratecontrol_t *rcc = h->rc;
1775     uint64_t all_const_bits = 0;
1776     uint64_t all_available_bits = (uint64_t)(h->param.rc.i_bitrate * 1000. * rcc->num_entries / rcc->fps);
1777     double rate_factor, step, step_mult;
1778     double qblur = h->param.rc.f_qblur;
1779     double cplxblur = h->param.rc.f_complexity_blur;
1780     const int filter_size = (int)(qblur*4) | 1;
1781     double expected_bits;
1782     double *qscale, *blurred_qscale;
1783     int i;
1784
1785     /* find total/average complexity & const_bits */
1786     for(i=0; i<rcc->num_entries; i++)
1787     {
1788         ratecontrol_entry_t *rce = &rcc->entry[i];
1789         all_const_bits += rce->misc_bits;
1790         rcc->i_cplx_sum[rce->pict_type] += rce->i_tex_bits * rce->qscale;
1791         rcc->p_cplx_sum[rce->pict_type] += rce->p_tex_bits * rce->qscale;
1792         rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits * rce->qscale;
1793         rcc->frame_count[rce->pict_type] ++;
1794     }
1795
1796     if( all_available_bits < all_const_bits)
1797     {
1798         x264_log(h, X264_LOG_ERROR, "requested bitrate is too low. estimated minimum is %d kbps\n",
1799                  (int)(all_const_bits * rcc->fps / (rcc->num_entries * 1000.)));
1800         return -1;
1801     }
1802
1803     /* Blur complexities, to reduce local fluctuation of QP.
1804      * We don't blur the QPs directly, because then one very simple frame
1805      * could drag down the QP of a nearby complex frame and give it more
1806      * bits than intended. */
1807     for(i=0; i<rcc->num_entries; i++)
1808     {
1809         ratecontrol_entry_t *rce = &rcc->entry[i];
1810         double weight_sum = 0;
1811         double cplx_sum = 0;
1812         double weight = 1.0;
1813         double gaussian_weight;
1814         int j;
1815         /* weighted average of cplx of future frames */
1816         for(j=1; j<cplxblur*2 && j<rcc->num_entries-i; j++)
1817         {
1818             ratecontrol_entry_t *rcj = &rcc->entry[i+j];
1819             weight *= 1 - pow( (float)rcj->i_count / rcc->nmb, 2 );
1820             if(weight < .0001)
1821                 break;
1822             gaussian_weight = weight * exp(-j*j/200.0);
1823             weight_sum += gaussian_weight;
1824             cplx_sum += gaussian_weight * (qscale2bits(rcj, 1) - rcj->misc_bits);
1825         }
1826         /* weighted average of cplx of past frames */
1827         weight = 1.0;
1828         for(j=0; j<=cplxblur*2 && j<=i; j++)
1829         {
1830             ratecontrol_entry_t *rcj = &rcc->entry[i-j];
1831             gaussian_weight = weight * exp(-j*j/200.0);
1832             weight_sum += gaussian_weight;
1833             cplx_sum += gaussian_weight * (qscale2bits(rcj, 1) - rcj->misc_bits);
1834             weight *= 1 - pow( (float)rcj->i_count / rcc->nmb, 2 );
1835             if(weight < .0001)
1836                 break;
1837         }
1838         rce->blurred_complexity = cplx_sum / weight_sum;
1839     }
1840
1841     qscale = x264_malloc(sizeof(double)*rcc->num_entries);
1842     if(filter_size > 1)
1843         blurred_qscale = x264_malloc(sizeof(double)*rcc->num_entries);
1844     else
1845         blurred_qscale = qscale;
1846
1847     /* Search for a factor which, when multiplied by the RCEQ values from
1848      * each frame, adds up to the desired total size.
1849      * There is no exact closed-form solution because of VBV constraints and
1850      * because qscale2bits is not invertible, but we can start with the simple
1851      * approximation of scaling the 1st pass by the ratio of bitrates.
1852      * The search range is probably overkill, but speed doesn't matter here. */
1853
1854     expected_bits = 1;
1855     for(i=0; i<rcc->num_entries; i++)
1856         expected_bits += qscale2bits(&rcc->entry[i], get_qscale(h, &rcc->entry[i], 1.0, i));
1857     step_mult = all_available_bits / expected_bits;
1858
1859     rate_factor = 0;
1860     for(step = 1E4 * step_mult; step > 1E-7 * step_mult; step *= 0.5)
1861     {
1862         expected_bits = 0;
1863         rate_factor += step;
1864
1865         rcc->last_non_b_pict_type = -1;
1866         rcc->last_accum_p_norm = 1;
1867         rcc->accum_p_norm = 0;
1868
1869         /* find qscale */
1870         for(i=0; i<rcc->num_entries; i++)
1871         {
1872             qscale[i] = get_qscale(h, &rcc->entry[i], rate_factor, i);
1873         }
1874
1875         /* fixed I/B qscale relative to P */
1876         for(i=rcc->num_entries-1; i>=0; i--)
1877         {
1878             qscale[i] = get_diff_limited_q(h, &rcc->entry[i], qscale[i]);
1879             assert(qscale[i] >= 0);
1880         }
1881
1882         /* smooth curve */
1883         if(filter_size > 1)
1884         {
1885             assert(filter_size%2==1);
1886             for(i=0; i<rcc->num_entries; i++)
1887             {
1888                 ratecontrol_entry_t *rce = &rcc->entry[i];
1889                 int j;
1890                 double q=0.0, sum=0.0;
1891
1892                 for(j=0; j<filter_size; j++)
1893                 {
1894                     int index = i+j-filter_size/2;
1895                     double d = index-i;
1896                     double coeff = qblur==0 ? 1.0 : exp(-d*d/(qblur*qblur));
1897                     if(index < 0 || index >= rcc->num_entries)
1898                         continue;
1899                     if(rce->pict_type != rcc->entry[index].pict_type)
1900                         continue;
1901                     q += qscale[index] * coeff;
1902                     sum += coeff;
1903                 }
1904                 blurred_qscale[i] = q/sum;
1905             }
1906         }
1907
1908         /* find expected bits */
1909         for(i=0; i<rcc->num_entries; i++)
1910         {
1911             ratecontrol_entry_t *rce = &rcc->entry[i];
1912             rce->new_qscale = clip_qscale(h, rce->pict_type, blurred_qscale[i]);
1913             assert(rce->new_qscale >= 0);
1914             expected_bits += qscale2bits(rce, rce->new_qscale);
1915         }
1916
1917         if(expected_bits > all_available_bits) rate_factor -= step;
1918     }
1919
1920     x264_free(qscale);
1921     if(filter_size > 1)
1922         x264_free(blurred_qscale);
1923
1924     if(rcc->b_vbv)
1925         vbv_pass2(h);
1926     expected_bits = count_expected_bits(h);
1927
1928     if(fabs(expected_bits/all_available_bits - 1.0) > 0.01)
1929     {
1930         double avgq = 0;
1931         for(i=0; i<rcc->num_entries; i++)
1932             avgq += rcc->entry[i].new_qscale;
1933         avgq = qscale2qp(avgq / rcc->num_entries);
1934
1935         if ((expected_bits > all_available_bits) || (!rcc->b_vbv))
1936             x264_log(h, X264_LOG_WARNING, "Error: 2pass curve failed to converge\n");
1937         x264_log(h, X264_LOG_WARNING, "target: %.2f kbit/s, expected: %.2f kbit/s, avg QP: %.4f\n",
1938                  (float)h->param.rc.i_bitrate,
1939                  expected_bits * rcc->fps / (rcc->num_entries * 1000.),
1940                  avgq);
1941         if(expected_bits < all_available_bits && avgq < h->param.rc.i_qp_min + 2)
1942         {
1943             if(h->param.rc.i_qp_min > 0)
1944                 x264_log(h, X264_LOG_WARNING, "try reducing target bitrate or reducing qp_min (currently %d)\n", h->param.rc.i_qp_min);
1945             else
1946                 x264_log(h, X264_LOG_WARNING, "try reducing target bitrate\n");
1947         }
1948         else if(expected_bits > all_available_bits && avgq > h->param.rc.i_qp_max - 2)
1949         {
1950             if(h->param.rc.i_qp_max < 51)
1951                 x264_log(h, X264_LOG_WARNING, "try increasing target bitrate or increasing qp_max (currently %d)\n", h->param.rc.i_qp_max);
1952             else
1953                 x264_log(h, X264_LOG_WARNING, "try increasing target bitrate\n");
1954         }
1955         else if(!(rcc->b_2pass && rcc->b_vbv))
1956             x264_log(h, X264_LOG_WARNING, "internal error\n");
1957     }
1958
1959     return 0;
1960 }
1961
1962