ratecontrol.c 43.7 KB
Newer Older
1
/***************************************************-*- coding: iso-8859-1 -*-
Laurent Aimar's avatar
Laurent Aimar committed
2 3
 * ratecontrol.c: h264 encoder library (Rate Control)
 *****************************************************************************
Loren Merritt's avatar
Loren Merritt committed
4
 * Copyright (C) 2005 x264 project
Laurent Aimar's avatar
Laurent Aimar committed
5 6
 * $Id: ratecontrol.c,v 1.1 2004/06/03 19:27:08 fenrir Exp $
 *
Loren Merritt's avatar
Loren Merritt committed
7 8 9
 * Authors: Loren Merritt <lorenm@u.washington.edu>
 *          Michael Niedermayer <michaelni@gmx.at>
 *          Mns Rullgrd <mru@mru.ath.cx>
Laurent Aimar's avatar
Laurent Aimar committed
10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
 *****************************************************************************/

26
#define _ISOC99_SOURCE
27
#undef NDEBUG // always check asserts, the speed effect is far too small to disable them
Laurent Aimar's avatar
Laurent Aimar committed
28 29
#include <stdio.h>
#include <string.h>
30 31
#include <math.h>
#include <limits.h>
32
#include <assert.h>
Laurent Aimar's avatar
Laurent Aimar committed
33

34 35
#include "common/common.h"
#include "common/cpu.h"
Laurent Aimar's avatar
Laurent Aimar committed
36 37
#include "ratecontrol.h"

38
#if defined(SYS_FREEBSD) || defined(SYS_BEOS) || defined(SYS_NETBSD)
39 40
#define exp2f(x) powf( 2, (x) )
#endif
Loren Merritt's avatar
Loren Merritt committed
41 42 43
#if defined(_MSC_VER)
#define isfinite _finite
#endif
44
#if defined(_MSC_VER) || defined(SYS_SunOS)
45
#define exp2f(x) pow( 2, (x) )
46
#define sqrtf sqrt
47
#endif
48 49 50
#ifdef WIN32 // POSIX says that rename() removes the destination, but win32 doesn't.
#define rename(src,dst) (unlink(dst), rename(src,dst))
#endif
51 52 53 54

typedef struct
{
    int pict_type;
55
    int kept_as_ref;
56 57 58 59 60 61 62 63 64 65 66
    float qscale;
    int mv_bits;
    int i_tex_bits;
    int p_tex_bits;
    int misc_bits;
    uint64_t expected_bits;
    float new_qscale;
    int new_qp;
    int i_count;
    int p_count;
    int s_count;
Loren Merritt's avatar
Loren Merritt committed
67
    float blurred_complexity;
68 69
} ratecontrol_entry_t;

Loren Merritt's avatar
Loren Merritt committed
70 71 72 73 74 75 76
typedef struct
{
    double coeff;
    double count;
    double decay;
} predictor_t;

77 78 79
struct x264_ratecontrol_t
{
    /* constants */
Loren Merritt's avatar
Loren Merritt committed
80 81
    int b_abr;
    int b_2pass;
82
    double fps;
Loren Merritt's avatar
Loren Merritt committed
83 84
    double bitrate;
    double rate_tolerance;
85
    int nmb;                    /* number of macroblocks in a frame */
86
    int qp_constant[5];
87

Loren Merritt's avatar
Loren Merritt committed
88 89
    /* current frame */
    ratecontrol_entry_t *rce;
90
    int qp;                     /* qp for current frame */
Loren Merritt's avatar
Loren Merritt committed
91 92
    float qpa;                  /* average of macroblocks' qp (same as qp if no adaptive quant) */
    int slice_type;
Måns Rullgård's avatar
Måns Rullgård committed
93
    int qp_force;
94

Loren Merritt's avatar
Loren Merritt committed
95 96 97 98 99 100 101 102 103 104 105 106 107 108 109
    /* VBV stuff */
    double buffer_size;
    double buffer_fill;
    double buffer_rate;         /* # of bits added to buffer_fill after each frame */
    predictor_t pred[5];        /* predict frame size from satd */

    /* ABR stuff */
    int    last_satd;
    double last_rceq;
    double cplxr_sum;           /* sum of bits*qscale/rceq */
    double expected_bits_sum;   /* sum of qscale2bits after rceq, ratefactor, and overflow */
    double wanted_bits_window;  /* target bitrate * window */
    double cbr_decay;
    double short_term_cplxsum;
    double short_term_cplxcount;
110
    double rate_factor_constant;
Loren Merritt's avatar
Loren Merritt committed
111

112 113
    /* 2pass stuff */
    FILE *p_stat_file_out;
114
    char *psz_stat_file_tmpname;
115 116

    int num_entries;            /* number of ratecontrol_entry_ts */
Loren Merritt's avatar
Loren Merritt committed
117
    ratecontrol_entry_t *entry; /* FIXME: copy needed data and free this once init is done */
118 119 120
    double last_qscale;
    double last_qscale_for[5];  /* last qscale for a specific pict type, used for max_diff & ipb factor stuff  */
    int last_non_b_pict_type;
121 122
    double accum_p_qp;          /* for determining I-frame quant */
    double accum_p_norm;
123
    double last_accum_p_norm;
124
    double lmin[5];             /* min qscale by frame type */
125
    double lmax[5];
Loren Merritt's avatar
Loren Merritt committed
126
    double lstep;               /* max change (multiply) in qscale per frame */
127 128 129 130
    double i_cplx_sum[5];       /* estimated total texture bits in intra MBs at qscale=1 */
    double p_cplx_sum[5];
    double mv_bits_sum[5];
    int frame_count[5];         /* number of frames of each type */
Loren Merritt's avatar
Loren Merritt committed
131 132 133

    int i_zones;
    x264_zone_t *zones;
134
};
Laurent Aimar's avatar
Laurent Aimar committed
135

136

137
static int parse_zones( x264_t *h );
138 139
static int init_pass2(x264_t *);
static float rate_estimate_qscale( x264_t *h, int pict_type );
Loren Merritt's avatar
Loren Merritt committed
140 141
static void update_vbv( x264_t *h, int bits );
int  x264_rc_analyse_slice( x264_t *h );
142 143 144

/* Terminology:
 * qp = h.264's quantizer
145
 * qscale = linearized quantizer = Lagrange multiplier
146 147 148 149 150 151 152 153 154 155
 */
static inline double qp2qscale(double qp)
{
    return 0.85 * pow(2.0, ( qp - 12.0 ) / 6.0);
}
static inline double qscale2qp(double qscale)
{
    return 12.0 + 6.0 * log(qscale/0.85) / log(2.0);
}

156 157 158 159
/* Texture bitrate is not quite inversely proportional to qscale,
 * probably due the the changing number of SKIP blocks.
 * MV bits level off at about qp<=12, because the lambda used
 * for motion estimation is constant there. */
160 161
static inline double qscale2bits(ratecontrol_entry_t *rce, double qscale)
{
Loren Merritt's avatar
Loren Merritt committed
162
    if(qscale<0.1)
163
        qscale = 0.1;
164 165
    return (rce->i_tex_bits + rce->p_tex_bits + .1) * pow( rce->qscale / qscale, 1.1 )
           + rce->mv_bits * pow( X264_MAX(rce->qscale, 12) / X264_MAX(qscale, 12), 0.5 );
166 167 168
}


169
int x264_ratecontrol_new( x264_t *h )
Laurent Aimar's avatar
Laurent Aimar committed
170
{
171 172
    x264_ratecontrol_t *rc;
    int i;
173

174 175 176
    x264_cpu_restore( h->param.cpu );

    h->rc = rc = x264_malloc( sizeof( x264_ratecontrol_t ) );
177 178
    memset(rc, 0, sizeof(*rc));

179
    rc->b_abr = ( h->param.rc.b_cbr || h->param.rc.i_rf_constant ) && !h->param.rc.b_stat_read;
Loren Merritt's avatar
Loren Merritt committed
180 181 182
    rc->b_2pass = h->param.rc.b_cbr && h->param.rc.b_stat_read;
    h->mb.b_variable_qp = 0;
    
Måns Rullgård's avatar
Måns Rullgård committed
183 184 185 186 187 188
    /* FIXME: use integers */
    if(h->param.i_fps_num > 0 && h->param.i_fps_den > 0)
        rc->fps = (float) h->param.i_fps_num / h->param.i_fps_den;
    else
        rc->fps = 25.0;

189
    rc->bitrate = h->param.rc.i_bitrate * 1000;
Loren Merritt's avatar
Loren Merritt committed
190
    rc->rate_tolerance = h->param.rc.f_rate_tolerance;
191
    rc->nmb = h->mb.i_mb_count;
Loren Merritt's avatar
Loren Merritt committed
192 193 194
    rc->last_non_b_pict_type = -1;
    rc->cbr_decay = 1.0;

195 196
    if( h->param.rc.i_rf_constant && h->param.rc.b_stat_read )
    {
197
        x264_log(h, X264_LOG_ERROR, "constant rate-factor is incompatible with 2pass.\n");
198 199
        return -1;
    }
200
    if( h->param.rc.i_vbv_buffer_size && !h->param.rc.b_cbr && !h->param.rc.i_rf_constant )
201
        x264_log(h, X264_LOG_ERROR, "VBV is incompatible with constant QP.\n");
202 203 204 205 206 207
    if( h->param.rc.i_vbv_buffer_size && h->param.rc.b_cbr
        && h->param.rc.i_vbv_max_bitrate == 0 )
    {
        x264_log( h, X264_LOG_DEBUG, "VBV maxrate unspecified, assuming CBR\n" );
        h->param.rc.i_vbv_max_bitrate = h->param.rc.i_bitrate;
    }
Loren Merritt's avatar
Loren Merritt committed
208 209 210 211 212 213 214 215 216 217
    if( h->param.rc.i_vbv_max_bitrate < h->param.rc.i_bitrate &&
        h->param.rc.i_vbv_max_bitrate > 0)
        x264_log(h, X264_LOG_ERROR, "max bitrate less than average bitrate, ignored.\n");
    else if( h->param.rc.i_vbv_max_bitrate > 0 &&
             h->param.rc.i_vbv_buffer_size > 0 )
    {
        if( h->param.rc.i_vbv_buffer_size < 10 * h->param.rc.i_vbv_max_bitrate / rc->fps ) {
            h->param.rc.i_vbv_buffer_size = 10 * h->param.rc.i_vbv_max_bitrate / rc->fps;
            x264_log( h, X264_LOG_ERROR, "VBV buffer size too small, using %d kbit\n",
                      h->param.rc.i_vbv_buffer_size );
218
        }
Loren Merritt's avatar
Loren Merritt committed
219 220 221 222 223 224
        rc->buffer_rate = h->param.rc.i_vbv_max_bitrate * 1000 / rc->fps;
        rc->buffer_size = h->param.rc.i_vbv_buffer_size * 1000;
        rc->buffer_fill = rc->buffer_size * h->param.rc.f_vbv_buffer_init;
        rc->cbr_decay = 1.0 - rc->buffer_rate / rc->buffer_size
                      * 0.5 * X264_MAX(0, 1.5 - rc->buffer_rate * rc->fps / rc->bitrate);
    }
225 226
    else if( h->param.rc.i_vbv_max_bitrate )
        x264_log(h, X264_LOG_ERROR, "VBV maxrate specified, but no bufsize.\n");
227 228 229 230
    if(rc->rate_tolerance < 0.01) {
        x264_log(h, X264_LOG_ERROR, "bitrate tolerance too small, using .01\n");
        rc->rate_tolerance = 0.01;
    }
231

Loren Merritt's avatar
Loren Merritt committed
232 233 234 235
    if( rc->b_abr )
    {
        /* FIXME shouldn't need to arbitrarily specify a QP,
         * but this is more robust than BPP measures */
236
#define ABR_INIT_QP ( h->param.rc.i_rf_constant > 0 ? h->param.rc.i_rf_constant : 24 )
Loren Merritt's avatar
Loren Merritt committed
237 238 239 240
        rc->accum_p_norm = .01;
        rc->accum_p_qp = ABR_INIT_QP * rc->accum_p_norm;
        rc->cplxr_sum = .01;
        rc->wanted_bits_window = .01;
241 242
    }

243 244 245 246 247 248 249 250
    if( h->param.rc.i_rf_constant )
    {
        /* arbitrary rescaling to make CRF somewhat similar to QP */
        double base_cplx = h->mb.i_mb_count * (h->param.i_bframe ? 120 : 80);
        rc->rate_factor_constant = pow( base_cplx, 1 - h->param.rc.f_qcompress )
                                 / qp2qscale( h->param.rc.i_rf_constant );
    }

Loren Merritt's avatar
Loren Merritt committed
251 252 253
    rc->qp_constant[SLICE_TYPE_P] = h->param.rc.i_qp_constant;
    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 );
    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 );
254

Loren Merritt's avatar
Loren Merritt committed
255
    rc->lstep = exp2f(h->param.rc.i_qp_step / 6.0);
256
    rc->last_qscale = qp2qscale(26);
257 258 259 260 261
    for( i = 0; i < 5; i++ )
    {
        rc->last_qscale_for[i] = qp2qscale(26);
        rc->lmin[i] = qp2qscale( h->param.rc.i_qp_min );
        rc->lmax[i] = qp2qscale( h->param.rc.i_qp_max );
Loren Merritt's avatar
Loren Merritt committed
262 263 264
        rc->pred[i].coeff= 2.0;
        rc->pred[i].count= 1.0;
        rc->pred[i].decay= 0.5;
265 266
    }

267 268
    if( parse_zones( h ) < 0 )
        return -1;
Loren Merritt's avatar
Loren Merritt committed
269

270 271 272
    /* Load stat file and init 2pass algo */
    if( h->param.rc.b_stat_read )
    {
273
        char *p, *stats_in, *stats_buf;
274 275 276

        /* read 1st pass stats */
        assert( h->param.rc.psz_stat_in );
277 278
        stats_buf = stats_in = x264_slurp_file( h->param.rc.psz_stat_in );
        if( !stats_buf )
279 280 281 282 283
        {
            x264_log(h, X264_LOG_ERROR, "ratecontrol_init: can't open stats file\n");
            return -1;
        }

284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316
        /* check whether 1st pass options were compatible with current options */
        if( !strncmp( stats_buf, "#options:", 9 ) )
        {
            int i;
            char *opts = stats_buf;
            stats_in = strchr( stats_buf, '\n' );
            if( !stats_in )
                return -1;
            *stats_in = '\0';
            stats_in++;

            if( ( p = strstr( opts, "bframes=" ) ) && sscanf( p, "bframes=%d", &i )
                && h->param.i_bframe != i )
            {
                x264_log( h, X264_LOG_ERROR, "different number of B-frames than 1st pass (%d vs %d)\n",
                          h->param.i_bframe, i );
                return -1;
            }

            /* since B-adapt doesn't (yet) take into account B-pyramid,
             * the converse is not a problem */
            if( strstr( opts, "b_pyramid=1" ) && !h->param.b_bframe_pyramid )
                x264_log( h, X264_LOG_WARNING, "1st pass used B-pyramid, 2nd doesn't\n" );

            if( ( p = strstr( opts, "keyint=" ) ) && sscanf( p, "keyint=%d", &i )
                && h->param.i_keyint_max != i )
                x264_log( h, X264_LOG_WARNING, "different keyint than 1st pass (%d vs %d)\n",
                          h->param.i_keyint_max, i );

            if( strstr( opts, "qp=0" ) && h->param.rc.b_cbr )
                x264_log( h, X264_LOG_WARNING, "1st pass was lossless, bitrate prediction will be inaccurate\n" );
        }

317 318
        /* find number of pics */
        p = stats_in;
Loren Merritt's avatar
Loren Merritt committed
319
        for(i=-1; p; i++)
320
            p = strchr(p+1, ';');
Loren Merritt's avatar
Loren Merritt committed
321 322 323 324
        if(i==0)
        {
            x264_log(h, X264_LOG_ERROR, "empty stats file\n");
            return -1;
325
        }
326 327
        rc->num_entries = i;

328
        if( h->param.i_frame_total < rc->num_entries && h->param.i_frame_total > 0 )
329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344
        {
            x264_log( h, X264_LOG_WARNING, "2nd pass has fewer frames than 1st pass (%d vs %d)\n",
                      h->param.i_frame_total, rc->num_entries );
        }
        if( h->param.i_frame_total > rc->num_entries + h->param.i_bframe )
        {
            x264_log( h, X264_LOG_ERROR, "2nd pass has more frames than 1st pass (%d vs %d)\n",
                      h->param.i_frame_total, rc->num_entries );
            return -1;
        }

        /* FIXME: ugly padding because VfW drops delayed B-frames */
        rc->num_entries += h->param.i_bframe;

        rc->entry = (ratecontrol_entry_t*) x264_malloc(rc->num_entries * sizeof(ratecontrol_entry_t));
        memset(rc->entry, 0, rc->num_entries * sizeof(ratecontrol_entry_t));
345 346 347 348

        /* init all to skipped p frames */
        for(i=0; i<rc->num_entries; i++){
            ratecontrol_entry_t *rce = &rc->entry[i];
349
            rce->pict_type = SLICE_TYPE_P;
350 351 352 353 354 355 356 357 358
            rce->qscale = rce->new_qscale = qp2qscale(20);
            rce->misc_bits = rc->nmb + 10;
            rce->new_qp = 0;
        }

        /* read stats */
        p = stats_in;
        for(i=0; i < rc->num_entries - h->param.i_bframe; i++){
            ratecontrol_entry_t *rce;
359 360
            int frame_number;
            char pict_type;
361 362 363 364 365 366 367 368 369
            int e;
            char *next;
            float qp;

            next= strchr(p, ';');
            if(next){
                (*next)=0; //sscanf is unbelievably slow on looong strings
                next++;
            }
370
            e = sscanf(p, " in:%d ", &frame_number);
371

Loren Merritt's avatar
Loren Merritt committed
372 373 374 375 376
            if(frame_number < 0 || frame_number >= rc->num_entries)
            {
                x264_log(h, X264_LOG_ERROR, "bad frame number (%d) at stats line %d\n", frame_number, i);
                return -1;
            }
377
            rce = &rc->entry[frame_number];
378

379 380
            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",
                   &pict_type, &qp, &rce->i_tex_bits, &rce->p_tex_bits,
381
                   &rce->mv_bits, &rce->misc_bits, &rce->i_count, &rce->p_count, &rce->s_count);
382 383

            switch(pict_type){
384
                case 'I': rce->kept_as_ref = 1;
385 386
                case 'i': rce->pict_type = SLICE_TYPE_I; break;
                case 'P': rce->pict_type = SLICE_TYPE_P; break;
387 388
                case 'B': rce->kept_as_ref = 1;
                case 'b': rce->pict_type = SLICE_TYPE_B; break;
389 390
                default:  e = -1; break;
            }
391 392 393 394 395 396 397 398
            if(e != 10){
                x264_log(h, X264_LOG_ERROR, "statistics are damaged at line %d, parser out=%d\n", i, e);
                return -1;
            }
            rce->qscale = qp2qscale(qp);
            p = next;
        }

399
        x264_free(stats_buf);
400

401 402 403
        if(h->param.rc.b_cbr)
        {
            if(init_pass2(h) < 0) return -1;
Loren Merritt's avatar
Loren Merritt committed
404
        } /* else we're using constant quant, so no need to run the bitrate allocation */
405 406 407
    }

    /* Open output file */
408 409
    /* If input and output files are the same, output to a temp file
     * and move it to the real name only when it's complete */
410 411
    if( h->param.rc.b_stat_write )
    {
412 413
        char *p;

414 415 416
        rc->psz_stat_file_tmpname = x264_malloc( strlen(h->param.rc.psz_stat_out) + 6 );
        strcpy( rc->psz_stat_file_tmpname, h->param.rc.psz_stat_out );
        strcat( rc->psz_stat_file_tmpname, ".temp" );
417 418

        rc->p_stat_file_out = fopen( rc->psz_stat_file_tmpname, "wb" );
419 420 421 422 423
        if( rc->p_stat_file_out == NULL )
        {
            x264_log(h, X264_LOG_ERROR, "ratecontrol_init: can't open stats file\n");
            return -1;
        }
424 425 426 427

        p = x264_param2string( &h->param, 1 );
        fprintf( rc->p_stat_file_out, "#options: %s\n", p );
        x264_free( p );
428
    }
429 430

    return 0;
Laurent Aimar's avatar
Laurent Aimar committed
431 432
}

433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489
static int parse_zones( x264_t *h )
{
    x264_ratecontrol_t *rc = h->rc;
    int i;
    if( h->param.rc.psz_zones && !h->param.rc.i_zones )
    {
        char *p;
        h->param.rc.i_zones = 1;
        for( p = h->param.rc.psz_zones; *p; p++ )
            h->param.rc.i_zones += (*p == '/');
        h->param.rc.zones = x264_malloc( h->param.rc.i_zones * sizeof(x264_zone_t) );
        p = h->param.rc.psz_zones;
        for( i = 0; i < h->param.rc.i_zones; i++)
        {
            x264_zone_t *z = &h->param.rc.zones[i];
            if( 3 == sscanf(p, "%u,%u,q=%u", &z->i_start, &z->i_end, &z->i_qp) )
                z->b_force_qp = 1;
            else if( 3 == sscanf(p, "%u,%u,b=%f", &z->i_start, &z->i_end, &z->f_bitrate_factor) )
                z->b_force_qp = 0;
            else
            {
                char *slash = strchr(p, '/');
                if(slash) *slash = '\0';
                x264_log( h, X264_LOG_ERROR, "invalid zone: \"%s\"\n", p );
                return -1;
            }
            p = strchr(p, '/') + 1;
        }
    }

    if( h->param.rc.i_zones > 0 )
    {
        for( i = 0; i < h->param.rc.i_zones; i++ )
        {
            x264_zone_t z = h->param.rc.zones[i];
            if( z.i_start < 0 || z.i_start > z.i_end )
            {
                x264_log( h, X264_LOG_ERROR, "invalid zone: start=%d end=%d\n",
                          z.i_start, z.i_end );
                return -1;
            }
            else if( !z.b_force_qp && z.f_bitrate_factor <= 0 )
            {
                x264_log( h, X264_LOG_ERROR, "invalid zone: bitrate_factor=%f\n",
                          z.f_bitrate_factor );
                return -1;
            }
        }

        rc->i_zones = h->param.rc.i_zones;
        rc->zones = x264_malloc( rc->i_zones * sizeof(x264_zone_t) );
        memcpy( rc->zones, h->param.rc.zones, rc->i_zones * sizeof(x264_zone_t) );
    }

    return 0;
}

490 491 492 493 494 495 496 497 498 499 500 501
void x264_ratecontrol_summary( x264_t *h )
{
    x264_ratecontrol_t *rc = h->rc;
    if( rc->b_abr && !h->param.rc.i_rf_constant && !h->param.rc.i_vbv_max_bitrate )
    {
        double base_cplx = h->mb.i_mb_count * (h->param.i_bframe ? 120 : 80);
        x264_log( h, X264_LOG_INFO, "final ratefactor: %.2f\n", 
                  qscale2qp( pow( base_cplx, 1 - h->param.rc.f_qcompress )
                             * rc->cplxr_sum / rc->wanted_bits_window ) );
    }
}

502
void x264_ratecontrol_delete( x264_t *h )
Laurent Aimar's avatar
Laurent Aimar committed
503
{
504
    x264_ratecontrol_t *rc = h->rc;
505 506

    if( rc->p_stat_file_out )
507
    {
508
        fclose( rc->p_stat_file_out );
509 510 511 512 513 514 515
        if( h->i_frame >= rc->num_entries - h->param.i_bframe )
            if( rename( rc->psz_stat_file_tmpname, h->param.rc.psz_stat_out ) != 0 )
            {
                x264_log( h, X264_LOG_ERROR, "failed to rename \"%s\" to \"%s\"\n",
                          rc->psz_stat_file_tmpname, h->param.rc.psz_stat_out );
            }
        x264_free( rc->psz_stat_file_tmpname );
516
    }
Loren Merritt's avatar
Loren Merritt committed
517 518
    x264_free( rc->entry );
    x264_free( rc->zones );
Laurent Aimar's avatar
Laurent Aimar committed
519 520 521
    x264_free( rc );
}

Loren Merritt's avatar
Loren Merritt committed
522
/* Before encoding a frame, choose a QP for it */
Måns Rullgård's avatar
Måns Rullgård committed
523
void x264_ratecontrol_start( x264_t *h, int i_slice_type, int i_force_qp )
Laurent Aimar's avatar
Laurent Aimar committed
524
{
525 526 527 528
    x264_ratecontrol_t *rc = h->rc;

    x264_cpu_restore( h->param.cpu );

Måns Rullgård's avatar
Måns Rullgård committed
529
    rc->qp_force = i_force_qp;
Loren Merritt's avatar
Loren Merritt committed
530
    rc->slice_type = i_slice_type;
Måns Rullgård's avatar
Måns Rullgård committed
531

Loren Merritt's avatar
Loren Merritt committed
532
    if( i_force_qp )
533
    {
Loren Merritt's avatar
Loren Merritt committed
534
        rc->qpa = rc->qp = i_force_qp - 1;
535
    }
Loren Merritt's avatar
Loren Merritt committed
536 537 538 539 540 541
    else if( rc->b_abr )
    {
        rc->qpa = rc->qp =
            x264_clip3( (int)(qscale2qp( rate_estimate_qscale( h, i_slice_type ) ) + .5), 0, 51 );
    }
    else if( rc->b_2pass )
542 543
    {
        int frame = h->fenc->i_frame;
544
        ratecontrol_entry_t *rce;
545
        assert( frame >= 0 && frame < rc->num_entries );
Loren Merritt's avatar
Loren Merritt committed
546
        rce = h->rc->rce = &h->rc->entry[frame];
547 548

        rce->new_qscale = rate_estimate_qscale( h, i_slice_type );
Loren Merritt's avatar
Loren Merritt committed
549 550
        rc->qpa = rc->qp = rce->new_qp =
            x264_clip3( (int)(qscale2qp(rce->new_qscale) + 0.5), 0, 51 );
551
    }
Loren Merritt's avatar
Loren Merritt committed
552 553 554 555 556
    else /* CQP */
    {
        int q;
        if( i_slice_type == SLICE_TYPE_B && h->fdec->b_kept_as_ref )
            q = ( rc->qp_constant[ SLICE_TYPE_B ] + rc->qp_constant[ SLICE_TYPE_P ] ) / 2;
557
        else
Loren Merritt's avatar
Loren Merritt committed
558 559
            q = rc->qp_constant[ i_slice_type ];
        rc->qpa = rc->qp = q;
Måns Rullgård's avatar
Måns Rullgård committed
560
    }
Laurent Aimar's avatar
Laurent Aimar committed
561 562
}

563
void x264_ratecontrol_mb( x264_t *h, int bits )
Laurent Aimar's avatar
Laurent Aimar committed
564
{
Loren Merritt's avatar
Loren Merritt committed
565
    /* currently no adaptive quant */
Laurent Aimar's avatar
Laurent Aimar committed
566 567
}

Loren Merritt's avatar
Loren Merritt committed
568
int x264_ratecontrol_qp( x264_t *h )
Laurent Aimar's avatar
Laurent Aimar committed
569
{
Loren Merritt's avatar
Loren Merritt committed
570
    return h->rc->qp;
571
}
Laurent Aimar's avatar
Laurent Aimar committed
572

Loren Merritt's avatar
Loren Merritt committed
573
/* In 2pass, force the same frame types as in the 1st pass */
574 575
int x264_ratecontrol_slice_type( x264_t *h, int frame_num )
{
576
    x264_ratecontrol_t *rc = h->rc;
577 578
    if( h->param.rc.b_stat_read )
    {
579
        if( frame_num >= rc->num_entries )
580
        {
581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602
            /* We could try to initialize everything required for ABR and
             * adaptive B-frames, but that would be complicated.
             * So just calculate the average QP used so far. */

            h->param.rc.i_qp_constant = (h->stat.i_slice_count[SLICE_TYPE_P] == 0) ? 24
                                      : 1 + h->stat.i_slice_qp[SLICE_TYPE_P] / h->stat.i_slice_count[SLICE_TYPE_P];
            rc->qp_constant[SLICE_TYPE_P] = x264_clip3( h->param.rc.i_qp_constant, 0, 51 );
            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 );
            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 );

            x264_log(h, X264_LOG_ERROR, "2nd pass has more frames than 1st pass (%d)\n", rc->num_entries);
            x264_log(h, X264_LOG_ERROR, "continuing anyway, at constant QP=%d\n", h->param.rc.i_qp_constant);
            if( h->param.b_bframe_adaptive )
                x264_log(h, X264_LOG_ERROR, "disabling adaptive B-frames\n");

            rc->b_abr = 0;
            rc->b_2pass = 0;
            h->param.rc.b_cbr = 0;
            h->param.rc.b_stat_read = 0;
            h->param.b_bframe_adaptive = 0;
            if( h->param.i_bframe > 1 )
                h->param.i_bframe = 1;
603 604
            return X264_TYPE_P;
        }
605
        switch( rc->entry[frame_num].pict_type )
606 607
        {
            case SLICE_TYPE_I:
608
                return rc->entry[frame_num].kept_as_ref ? X264_TYPE_IDR : X264_TYPE_I;
609 610

            case SLICE_TYPE_B:
611
                return rc->entry[frame_num].kept_as_ref ? X264_TYPE_BREF : X264_TYPE_B;
612 613 614 615 616 617 618 619 620 621 622 623

            case SLICE_TYPE_P:
            default:
                return X264_TYPE_P;
        }
    }
    else
    {
        return X264_TYPE_AUTO;
    }
}

Loren Merritt's avatar
Loren Merritt committed
624
/* After encoding one frame, save stats and update ratecontrol state */
625 626 627
void x264_ratecontrol_end( x264_t *h, int bits )
{
    x264_ratecontrol_t *rc = h->rc;
628
    const int *mbs = h->stat.frame.i_mb_count;
Loren Merritt's avatar
Loren Merritt committed
629
    int i;
Laurent Aimar's avatar
Laurent Aimar committed
630

631 632
    x264_cpu_restore( h->param.cpu );

633 634 635
    h->stat.frame.i_mb_count_skip = mbs[P_SKIP] + mbs[B_SKIP];
    h->stat.frame.i_mb_count_i = mbs[I_16x16] + mbs[I_8x8] + mbs[I_4x4];
    h->stat.frame.i_mb_count_p = mbs[P_L0] + mbs[P_8x8];
Loren Merritt's avatar
Loren Merritt committed
636
    for( i = B_DIRECT; i < B_8x8; i++ )
637
        h->stat.frame.i_mb_count_p += mbs[i];
Loren Merritt's avatar
Loren Merritt committed
638

639 640
    if( h->param.rc.b_stat_write )
    {
641
        char c_type = rc->slice_type==SLICE_TYPE_I ? (h->fenc->i_poc==0 ? 'I' : 'i')
642 643
                    : rc->slice_type==SLICE_TYPE_P ? 'P'
                    : h->fenc->b_kept_as_ref ? 'B' : 'b';
644
        fprintf( rc->p_stat_file_out,
Loren Merritt's avatar
Loren Merritt committed
645
                 "in:%d out:%d type:%c q:%.2f itex:%d ptex:%d mv:%d misc:%d imb:%d pmb:%d smb:%d;\n",
646
                 h->fenc->i_frame, h->i_frame-1,
647
                 c_type, rc->qpa,
648 649
                 h->stat.frame.i_itex_bits, h->stat.frame.i_ptex_bits,
                 h->stat.frame.i_hdr_bits, h->stat.frame.i_misc_bits,
650
                 h->stat.frame.i_mb_count_i,
Loren Merritt's avatar
Loren Merritt committed
651 652
                 h->stat.frame.i_mb_count_p,
                 h->stat.frame.i_mb_count_skip);
653 654
    }

Loren Merritt's avatar
Loren Merritt committed
655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675
    if( rc->b_abr )
    {
        if( rc->slice_type != SLICE_TYPE_B )
            rc->cplxr_sum += bits * qp2qscale(rc->qpa) / rc->last_rceq;
        else
        {
            /* Depends on the fact that B-frame's QP is an offset from the following P-frame's.
             * Not perfectly accurate with B-refs, but good enough. */
            rc->cplxr_sum += bits * qp2qscale(rc->qpa) / (rc->last_rceq * fabs(h->param.rc.f_pb_factor));
        }
        rc->cplxr_sum *= rc->cbr_decay;
        rc->wanted_bits_window += rc->bitrate / rc->fps;
        rc->wanted_bits_window *= rc->cbr_decay;

        rc->accum_p_qp   *= .95;
        rc->accum_p_norm *= .95;
        rc->accum_p_norm += 1;
        if( rc->slice_type == SLICE_TYPE_I )
            rc->accum_p_qp += rc->qpa * fabs(h->param.rc.f_ip_factor);
        else
            rc->accum_p_qp += rc->qpa;
Laurent Aimar's avatar
Laurent Aimar committed
676 677
    }

Loren Merritt's avatar
Loren Merritt committed
678 679 680
    if( rc->b_2pass )
    {
        rc->expected_bits_sum += qscale2bits( rc->rce, qp2qscale(rc->rce->new_qp) );
Laurent Aimar's avatar
Laurent Aimar committed
681 682
    }

Loren Merritt's avatar
Loren Merritt committed
683
    update_vbv( h, bits );
684

Loren Merritt's avatar
Loren Merritt committed
685 686
    if( rc->slice_type != SLICE_TYPE_B )
        rc->last_non_b_pict_type = rc->slice_type;
Laurent Aimar's avatar
Laurent Aimar committed
687
}
688 689 690 691

/****************************************************************************
 * 2 pass functions
 ***************************************************************************/
Loren Merritt's avatar
Loren Merritt committed
692

693 694 695 696 697 698
double x264_eval( char *s, double *const_value, const char **const_name,
                  double (**func1)(void *, double), const char **func1_name,
                  double (**func2)(void *, double, double), char **func2_name,
                  void *opaque );

/**
Loren Merritt's avatar
Loren Merritt committed
699
 * modify the bitrate curve from pass1 for one frame
700
 */
Loren Merritt's avatar
Loren Merritt committed
701
static double get_qscale(x264_t *h, ratecontrol_entry_t *rce, double rate_factor, int frame_num)
702 703
{
    x264_ratecontrol_t *rcc= h->rc;
704
    const int pict_type = rce->pict_type;
705
    double q;
Loren Merritt's avatar
Loren Merritt committed
706
    int i;
707 708 709 710 711

    double const_values[]={
        rce->i_tex_bits * rce->qscale,
        rce->p_tex_bits * rce->qscale,
        (rce->i_tex_bits + rce->p_tex_bits) * rce->qscale,
712
        rce->mv_bits * rce->qscale,
713 714 715 716 717 718 719 720 721 722 723 724
        (double)rce->i_count / rcc->nmb,
        (double)rce->p_count / rcc->nmb,
        (double)rce->s_count / rcc->nmb,
        rce->pict_type == SLICE_TYPE_I,
        rce->pict_type == SLICE_TYPE_P,
        rce->pict_type == SLICE_TYPE_B,
        h->param.rc.f_qcompress,
        rcc->i_cplx_sum[SLICE_TYPE_I] / rcc->frame_count[SLICE_TYPE_I],
        rcc->i_cplx_sum[SLICE_TYPE_P] / rcc->frame_count[SLICE_TYPE_P],
        rcc->p_cplx_sum[SLICE_TYPE_P] / rcc->frame_count[SLICE_TYPE_P],
        rcc->p_cplx_sum[SLICE_TYPE_B] / rcc->frame_count[SLICE_TYPE_B],
        (rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / rcc->frame_count[pict_type],
Loren Merritt's avatar
Loren Merritt committed
725
        rce->blurred_complexity,
726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744
        0
    };
    static const char *const_names[]={
        "iTex",
        "pTex",
        "tex",
        "mv",
        "iCount",
        "pCount",
        "sCount",
        "isI",
        "isP",
        "isB",
        "qComp",
        "avgIITex",
        "avgPITex",
        "avgPPTex",
        "avgBPTex",
        "avgTex",
745
        "blurCplx",
746 747 748
        NULL
    };
    static double (*func1[])(void *, double)={
749
//      (void *)bits2qscale,
750 751 752 753
        (void *)qscale2bits,
        NULL
    };
    static const char *func1_names[]={
754
//      "bits2qp",
755 756 757 758
        "qp2bits",
        NULL
    };

759
    q = x264_eval((char*)h->param.rc.psz_rc_eq, const_values, const_names, func1, func1_names, NULL, NULL, rce);
760

Loren Merritt's avatar
Loren Merritt committed
761
    // avoid NaN's in the rc_eq
762
    if(!isfinite(q) || rce->i_tex_bits + rce->p_tex_bits + rce->mv_bits == 0)
763
        q = rcc->last_qscale;
Loren Merritt's avatar
Loren Merritt committed
764 765 766
    else {
        rcc->last_rceq = q;
        q /= rate_factor;
767
        rcc->last_qscale = q;
Loren Merritt's avatar
Loren Merritt committed
768 769 770 771 772 773 774 775 776 777 778 779 780 781
    }

    for( i = rcc->i_zones-1; i >= 0; i-- )
    {
        x264_zone_t *z = &rcc->zones[i];
        if( frame_num >= z->i_start && frame_num <= z->i_end )
        {
            if( z->b_force_qp )
                q = qp2qscale(z->i_qp);
            else
                q /= z->f_bitrate_factor;
            break;
        }
    }
782

783
    return q;
784 785 786 787 788
}

static double get_diff_limited_q(x264_t *h, ratecontrol_entry_t *rce, double q)
{
    x264_ratecontrol_t *rcc = h->rc;
789
    const int pict_type = rce->pict_type;
790 791 792 793

    // force I/B quants as a function of P quants
    const double last_p_q    = rcc->last_qscale_for[SLICE_TYPE_P];
    const double last_non_b_q= rcc->last_qscale_for[rcc->last_non_b_pict_type];
794 795
    if( pict_type == SLICE_TYPE_I )
    {
796 797 798 799 800 801 802 803 804 805 806 807
        double iq = q;
        double pq = qp2qscale( rcc->accum_p_qp / rcc->accum_p_norm );
        double ip_factor = fabs( h->param.rc.f_ip_factor );
        /* don't apply ip_factor if the following frame is also I */
        if( rcc->accum_p_norm <= 0 )
            q = iq;
        else if( h->param.rc.f_ip_factor < 0 )
            q = iq / ip_factor;
        else if( rcc->accum_p_norm >= 1 )
            q = pq / ip_factor;
        else
            q = rcc->accum_p_norm * pq / ip_factor + (1 - rcc->accum_p_norm) * iq;
808 809 810 811 812
    }
    else if( pict_type == SLICE_TYPE_B )
    {
        if( h->param.rc.f_pb_factor > 0 )
            q = last_non_b_q;
813 814
        if( !rce->kept_as_ref )
            q *= fabs( h->param.rc.f_pb_factor );
815 816 817 818 819
    }
    else if( pict_type == SLICE_TYPE_P
             && rcc->last_non_b_pict_type == SLICE_TYPE_P
             && rce->i_tex_bits + rce->p_tex_bits == 0 )
    {
820
        q = last_p_q;
821
    }
822 823

    /* last qscale / qdiff stuff */
824 825
    if(rcc->last_non_b_pict_type==pict_type
       && (pict_type!=SLICE_TYPE_I || rcc->last_accum_p_norm < 1))
826 827
    {
        double last_q = rcc->last_qscale_for[pict_type];
Loren Merritt's avatar
Loren Merritt committed
828 829
        double max_qscale = last_q * rcc->lstep;
        double min_qscale = last_q / rcc->lstep;
830 831 832 833 834

        if     (q > max_qscale) q = max_qscale;
        else if(q < min_qscale) q = min_qscale;
    }

Loren Merritt's avatar
Loren Merritt committed
835
    rcc->last_qscale_for[pict_type] = q;
836 837
    if(pict_type!=SLICE_TYPE_B)
        rcc->last_non_b_pict_type = pict_type;
838 839
    if(pict_type==SLICE_TYPE_I)
    {
840
        rcc->last_accum_p_norm = rcc->accum_p_norm;
841 842 843 844 845 846 847 848 849
        rcc->accum_p_norm = 0;
        rcc->accum_p_qp = 0;
    }
    if(pict_type==SLICE_TYPE_P)
    {
        float mask = 1 - pow( (float)rce->i_count / rcc->nmb, 2 );
        rcc->accum_p_qp   = mask * (qscale2qp(q) + rcc->accum_p_qp);
        rcc->accum_p_norm = mask * (1 + rcc->accum_p_norm);
    }
850 851 852
    return q;
}

Loren Merritt's avatar
Loren Merritt committed
853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882
static double predict_size( predictor_t *p, double q, double var )
{
     return p->coeff*var / (q*p->count);
}

static void update_predictor( predictor_t *p, double q, double var, double bits )
{
    p->count *= p->decay;
    p->coeff *= p->decay;
    p->count ++;
    p->coeff += bits*q / var;
}

static void update_vbv( x264_t *h, int bits )
{
    x264_ratecontrol_t *rcc = h->rc;
    if( !rcc->buffer_size )
        return;

    rcc->buffer_fill += rcc->buffer_rate - bits;
    if( rcc->buffer_fill < 0 && !rcc->b_2pass )
        x264_log( h, X264_LOG_WARNING, "VBV underflow (%.0f bits)\n", rcc->buffer_fill );
    rcc->buffer_fill = x264_clip3( rcc->buffer_fill, 0, rcc->buffer_size );

    if(rcc->last_satd > 100)
        update_predictor( &rcc->pred[rcc->slice_type], qp2qscale(rcc->qpa), rcc->last_satd, bits );
}

// apply VBV constraints and clip qscale to between lmin and lmax
static double clip_qscale( x264_t *h, int pict_type, double q )
883
{
Loren Merritt's avatar
Loren Merritt committed
884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913
    x264_ratecontrol_t *rcc = h->rc;
    double lmin = rcc->lmin[pict_type];
    double lmax = rcc->lmax[pict_type];
    double q0 = q;

    /* B-frames are not directly subject to VBV,
     * since they are controlled by the P-frames' QPs.
     * FIXME: in 2pass we could modify previous frames' QP too,
     *        instead of waiting for the buffer to fill */
    if( rcc->buffer_size &&
        ( pict_type == SLICE_TYPE_P ||
          ( pict_type == SLICE_TYPE_I && rcc->last_non_b_pict_type == SLICE_TYPE_I ) ) )
    {
        if( rcc->buffer_fill/rcc->buffer_size < 0.5 )
            q /= x264_clip3f( 2.0*rcc->buffer_fill/rcc->buffer_size, 0.5, 1.0 );
    }
    /* Now a hard threshold to make sure the frame fits in VBV.
     * This one is mostly for I-frames. */
    if( rcc->buffer_size && rcc->last_satd > 0 )
    {
        double bits = predict_size( &rcc->pred[rcc->slice_type], q, rcc->last_satd );
        double qf = 1.0;
        if( bits > rcc->buffer_fill/2 )
            qf = x264_clip3f( rcc->buffer_fill/(2*bits), 0.2, 1.0 );
        q /= qf;
        bits *= qf;
        if( bits < rcc->buffer_rate/2 )
            q *= bits*2/rcc->buffer_rate;
        q = X264_MAX( q0, q );
    }
914

Loren Merritt's avatar
Loren Merritt committed
915
    if(lmin==lmax)
Loren Merritt's avatar
Loren Merritt committed
916
        return lmin;
Loren Merritt's avatar
Loren Merritt committed
917 918
    else if(rcc->b_2pass)
    {
919 920
        double min2 = log(lmin);
        double max2 = log(lmax);
Loren Merritt's avatar
Loren Merritt committed
921 922
        q = (log(q) - min2)/(max2-min2) - 0.5;
        q = 1.0/(1.0 + exp(-4*q));
923
        q = q*(max2-min2) + min2;
Loren Merritt's avatar
Loren Merritt committed
924
        return exp(q);
925
    }
Loren Merritt's avatar
Loren Merritt committed
926 927
    else
        return x264_clip3f(q, lmin, lmax);
928 929 930 931 932 933 934
}

// update qscale for 1 frame based on actual bits used so far
static float rate_estimate_qscale(x264_t *h, int pict_type)
{
    float q;
    x264_ratecontrol_t *rcc = h->rc;
Loren Merritt's avatar
Loren Merritt committed
935
    ratecontrol_entry_t rce;
936 937 938 939 940 941
    double lmin = rcc->lmin[pict_type];
    double lmax = rcc->lmax[pict_type];
    int64_t total_bits = 8*(h->stat.i_slice_size[SLICE_TYPE_I]
                          + h->stat.i_slice_size[SLICE_TYPE_P]
                          + h->stat.i_slice_size[SLICE_TYPE_B]);

Loren Merritt's avatar
Loren Merritt committed
942 943 944 945 946 947 948 949 950
    if( rcc->b_2pass )
    {
        rce = *rcc->rce;
        if(pict_type != rce.pict_type)
        {
            x264_log(h, X264_LOG_ERROR, "slice=%c but 2pass stats say %c\n",
                     slice_type_to_char[pict_type], slice_type_to_char[rce.pict_type]);
        }
    }
951

Loren Merritt's avatar
Loren Merritt committed
952
    if( pict_type == SLICE_TYPE_B )
953
    {
Loren Merritt's avatar
Loren Merritt committed
954
        rcc->last_satd = 0;
Loren Merritt's avatar
Loren Merritt committed
955
        if(h->fenc->b_kept_as_ref)
Loren Merritt's avatar
Loren Merritt committed
956
            q = rcc->last_qscale * sqrtf(h->param.rc.f_pb_factor);
957
        else
Loren Merritt's avatar
Loren Merritt committed
958 959
            q = rcc->last_qscale * h->param.rc.f_pb_factor;
        return x264_clip3f(q, lmin, lmax);
960 961 962
    }
    else
    {
Loren Merritt's avatar
Loren Merritt committed
963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009
        double abr_buffer = 2 * rcc->rate_tolerance * rcc->bitrate;
        if( rcc->b_2pass )
        {
            //FIXME adjust abr_buffer based on distance to the end of the video
            int64_t diff = total_bits - (int64_t)rce.expected_bits;
            q = rce.new_qscale;
            q /= x264_clip3f((double)(abr_buffer - diff) / abr_buffer, .5, 2);
            if( h->fenc->i_frame > 30 )
            {
                /* Adjust quant based on the difference between
                 * achieved and expected bitrate so far */
                double time = (double)h->fenc->i_frame / rcc->num_entries;
                double w = x264_clip3f( time*<