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
41
#if defined(_MSC_VER) || defined(SYS_SunOS)
42
#define exp2f(x) pow( 2, (x) )
43
#define sqrtf sqrt
44
#endif
45 46 47
#ifdef WIN32 // POSIX says that rename() removes the destination, but win32 doesn't.
#define rename(src,dst) (unlink(dst), rename(src,dst))
#endif
48 49 50 51

typedef struct
{
    int pict_type;
52
    int kept_as_ref;
53 54 55 56 57 58 59 60 61 62 63
    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
64
    float blurred_complexity;
65 66
} ratecontrol_entry_t;

Loren Merritt's avatar
Loren Merritt committed
67 68 69 70 71 72 73
typedef struct
{
    double coeff;
    double count;
    double decay;
} predictor_t;

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

Loren Merritt's avatar
Loren Merritt committed
85 86
    /* current frame */
    ratecontrol_entry_t *rce;
87
    int qp;                     /* qp for current frame */
Loren Merritt's avatar
Loren Merritt committed
88 89
    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
90
    int qp_force;
91

Loren Merritt's avatar
Loren Merritt committed
92 93 94 95 96 97 98 99 100 101 102 103 104 105 106
    /* 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;
107
    double rate_factor_constant;
Loren Merritt's avatar
Loren Merritt committed
108

109 110
    /* 2pass stuff */
    FILE *p_stat_file_out;
111
    char *psz_stat_file_tmpname;
112 113

    int num_entries;            /* number of ratecontrol_entry_ts */
Loren Merritt's avatar
Loren Merritt committed
114
    ratecontrol_entry_t *entry; /* FIXME: copy needed data and free this once init is done */
115 116 117
    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;
118 119
    double accum_p_qp;          /* for determining I-frame quant */
    double accum_p_norm;
120
    double last_accum_p_norm;
121
    double lmin[5];             /* min qscale by frame type */
122
    double lmax[5];
Loren Merritt's avatar
Loren Merritt committed
123
    double lstep;               /* max change (multiply) in qscale per frame */
124 125 126 127
    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
128 129 130

    int i_zones;
    x264_zone_t *zones;
131
};
Laurent Aimar's avatar
Laurent Aimar committed
132

133

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

/* Terminology:
 * qp = h.264's quantizer
142
 * qscale = linearized quantizer = Lagrange multiplier
143 144 145 146 147 148 149 150 151 152
 */
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);
}

153 154 155 156
/* 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. */
157 158
static inline double qscale2bits(ratecontrol_entry_t *rce, double qscale)
{
Loren Merritt's avatar
Loren Merritt committed
159
    if(qscale<0.1)
160
        qscale = 0.1;
161 162
    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 );
163 164 165
}


166
int x264_ratecontrol_new( x264_t *h )
Laurent Aimar's avatar
Laurent Aimar committed
167
{
168 169
    x264_ratecontrol_t *rc;
    int i;
170

171 172 173
    x264_cpu_restore( h->param.cpu );

    h->rc = rc = x264_malloc( sizeof( x264_ratecontrol_t ) );
174 175
    memset(rc, 0, sizeof(*rc));

176
    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
177 178 179
    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
180 181 182 183 184 185
    /* 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;

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

192 193
    if( h->param.rc.i_rf_constant && h->param.rc.b_stat_read )
    {
194
        x264_log(h, X264_LOG_ERROR, "constant rate-factor is incompatible with 2pass.\n");
195 196
        return -1;
    }
197
    if( h->param.rc.i_vbv_buffer_size && !h->param.rc.b_cbr && !h->param.rc.i_rf_constant )
198
        x264_log(h, X264_LOG_ERROR, "VBV is incompatible with constant QP.\n");
199 200 201 202 203 204
    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
205 206 207 208 209 210 211 212 213 214
    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 );
215
        }
Loren Merritt's avatar
Loren Merritt committed
216 217 218 219 220 221
        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);
    }
222 223
    else if( h->param.rc.i_vbv_max_bitrate )
        x264_log(h, X264_LOG_ERROR, "VBV maxrate specified, but no bufsize.\n");
224 225 226 227
    if(rc->rate_tolerance < 0.01) {
        x264_log(h, X264_LOG_ERROR, "bitrate tolerance too small, using .01\n");
        rc->rate_tolerance = 0.01;
    }
228

Loren Merritt's avatar
Loren Merritt committed
229 230 231 232
    if( rc->b_abr )
    {
        /* FIXME shouldn't need to arbitrarily specify a QP,
         * but this is more robust than BPP measures */
233
#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
234 235 236 237
        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;
238 239
    }

240 241 242 243 244 245 246 247
    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
248 249 250
    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 );
251

Loren Merritt's avatar
Loren Merritt committed
252
    rc->lstep = exp2f(h->param.rc.i_qp_step / 6.0);
253
    rc->last_qscale = qp2qscale(26);
254 255 256 257 258
    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
259 260 261
        rc->pred[i].coeff= 2.0;
        rc->pred[i].count= 1.0;
        rc->pred[i].decay= 0.5;
262 263
    }

264 265
    if( parse_zones( h ) < 0 )
        return -1;
Loren Merritt's avatar
Loren Merritt committed
266

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

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

281 282 283 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
        /* 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" );
        }

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

325
        if( h->param.i_frame_total < rc->num_entries && h->param.i_frame_total > 0 )
326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341
        {
            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));
342 343 344 345

        /* init all to skipped p frames */
        for(i=0; i<rc->num_entries; i++){
            ratecontrol_entry_t *rce = &rc->entry[i];
346
            rce->pict_type = SLICE_TYPE_P;
347 348 349 350 351 352 353 354 355
            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;
356 357
            int frame_number;
            char pict_type;
358 359 360 361 362 363 364 365 366
            int e;
            char *next;
            float qp;

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

Loren Merritt's avatar
Loren Merritt committed
369 370 371 372 373
            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;
            }
374
            rce = &rc->entry[frame_number];
375

376 377
            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,
378
                   &rce->mv_bits, &rce->misc_bits, &rce->i_count, &rce->p_count, &rce->s_count);
379 380

            switch(pict_type){
381
                case 'I': rce->kept_as_ref = 1;
382 383
                case 'i': rce->pict_type = SLICE_TYPE_I; break;
                case 'P': rce->pict_type = SLICE_TYPE_P; break;
384 385
                case 'B': rce->kept_as_ref = 1;
                case 'b': rce->pict_type = SLICE_TYPE_B; break;
386 387
                default:  e = -1; break;
            }
388 389 390 391 392 393 394 395
            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;
        }

396
        x264_free(stats_buf);
397

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

    /* Open output file */
405 406
    /* 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 */
407 408
    if( h->param.rc.b_stat_write )
    {
409 410
        char *p;

411 412 413
        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" );
414 415

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

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

    return 0;
Laurent Aimar's avatar
Laurent Aimar committed
428 429
}

430 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
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;
}

487 488 489 490 491 492 493 494 495 496 497 498
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 ) );
    }
}

499
void x264_ratecontrol_delete( x264_t *h )
Laurent Aimar's avatar
Laurent Aimar committed
500
{
501
    x264_ratecontrol_t *rc = h->rc;
502 503

    if( rc->p_stat_file_out )
504
    {
505
        fclose( rc->p_stat_file_out );
506 507 508 509 510 511 512
        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 );
513
    }
Loren Merritt's avatar
Loren Merritt committed
514 515
    x264_free( rc->entry );
    x264_free( rc->zones );
Laurent Aimar's avatar
Laurent Aimar committed
516 517 518
    x264_free( rc );
}

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

    x264_cpu_restore( h->param.cpu );

Måns Rullgård's avatar
Måns Rullgård committed
526
    rc->qp_force = i_force_qp;
Loren Merritt's avatar
Loren Merritt committed
527
    rc->slice_type = i_slice_type;
Måns Rullgård's avatar
Måns Rullgård committed
528

Loren Merritt's avatar
Loren Merritt committed
529
    if( i_force_qp )
530
    {
Loren Merritt's avatar
Loren Merritt committed
531
        rc->qpa = rc->qp = i_force_qp - 1;
532
    }
Loren Merritt's avatar
Loren Merritt committed
533 534 535 536 537 538
    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 )
539 540
    {
        int frame = h->fenc->i_frame;
541
        ratecontrol_entry_t *rce;
542
        assert( frame >= 0 && frame < rc->num_entries );
Loren Merritt's avatar
Loren Merritt committed
543
        rce = h->rc->rce = &h->rc->entry[frame];
544 545

        rce->new_qscale = rate_estimate_qscale( h, i_slice_type );
Loren Merritt's avatar
Loren Merritt committed
546 547
        rc->qpa = rc->qp = rce->new_qp =
            x264_clip3( (int)(qscale2qp(rce->new_qscale) + 0.5), 0, 51 );
548
    }
Loren Merritt's avatar
Loren Merritt committed
549 550 551 552 553
    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;
554
        else
Loren Merritt's avatar
Loren Merritt committed
555 556
            q = rc->qp_constant[ i_slice_type ];
        rc->qpa = rc->qp = q;
Måns Rullgård's avatar
Måns Rullgård committed
557
    }
Laurent Aimar's avatar
Laurent Aimar committed
558 559
}

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

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

Loren Merritt's avatar
Loren Merritt committed
570
/* In 2pass, force the same frame types as in the 1st pass */
571 572
int x264_ratecontrol_slice_type( x264_t *h, int frame_num )
{
573
    x264_ratecontrol_t *rc = h->rc;
574 575
    if( h->param.rc.b_stat_read )
    {
576
        if( frame_num >= rc->num_entries )
577
        {
578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599
            /* 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;
600 601
            return X264_TYPE_P;
        }
602
        switch( rc->entry[frame_num].pict_type )
603 604
        {
            case SLICE_TYPE_I:
605
                return rc->entry[frame_num].kept_as_ref ? X264_TYPE_IDR : X264_TYPE_I;
606 607

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

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

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

628 629
    x264_cpu_restore( h->param.cpu );

630 631 632
    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
633
    for( i = B_DIRECT; i < B_8x8; i++ )
634
        h->stat.frame.i_mb_count_p += mbs[i];
Loren Merritt's avatar
Loren Merritt committed
635

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

Loren Merritt's avatar
Loren Merritt committed
652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672
    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
673 674
    }

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

Loren Merritt's avatar
Loren Merritt committed
680
    update_vbv( h, bits );
681

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

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

690 691 692 693 694 695
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
696
 * modify the bitrate curve from pass1 for one frame
697
 */
Loren Merritt's avatar
Loren Merritt committed
698
static double get_qscale(x264_t *h, ratecontrol_entry_t *rce, double rate_factor, int frame_num)
699 700
{
    x264_ratecontrol_t *rcc= h->rc;
701
    const int pict_type = rce->pict_type;
702
    double q;
Loren Merritt's avatar
Loren Merritt committed
703
    int i;
704 705 706 707 708

    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,
709
        rce->mv_bits * rce->qscale,
710 711 712 713 714 715 716 717 718 719 720 721
        (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
722
        rce->blurred_complexity,
723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741
        0
    };
    static const char *const_names[]={
        "iTex",
        "pTex",
        "tex",
        "mv",
        "iCount",
        "pCount",
        "sCount",
        "isI",
        "isP",
        "isB",
        "qComp",
        "avgIITex",
        "avgPITex",
        "avgPPTex",
        "avgBPTex",
        "avgTex",
742
        "blurCplx",
743 744 745
        NULL
    };
    static double (*func1[])(void *, double)={
746
//      (void *)bits2qscale,
747 748 749 750
        (void *)qscale2bits,
        NULL
    };
    static const char *func1_names[]={
751
//      "bits2qp",
752 753 754 755
        "qp2bits",
        NULL
    };

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

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

    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;
        }
    }
779

780
    return q;
781 782 783 784 785
}

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

    // 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];
791 792
    if( pict_type == SLICE_TYPE_I )
    {
793 794 795 796 797 798 799 800 801 802 803 804
        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;
805 806 807 808 809
    }
    else if( pict_type == SLICE_TYPE_B )
    {
        if( h->param.rc.f_pb_factor > 0 )
            q = last_non_b_q;
810 811
        if( !rce->kept_as_ref )
            q *= fabs( h->param.rc.f_pb_factor );
812 813 814 815 816
    }
    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 )
    {
817
        q = last_p_q;
818
    }
819 820

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

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

Loren Merritt's avatar
Loren Merritt committed
832
    rcc->last_qscale_for[pict_type] = q;
833 834
    if(pict_type!=SLICE_TYPE_B)
        rcc->last_non_b_pict_type = pict_type;
835 836
    if(pict_type==SLICE_TYPE_I)
    {
837
        rcc->last_accum_p_norm = rcc->accum_p_norm;
838 839 840 841 842 843 844 845 846
        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);
    }
847 848 849
    return q;
}

Loren Merritt's avatar
Loren Merritt committed
850 851 852 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
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 )
880
{
Loren Merritt's avatar
Loren Merritt committed
881 882 883 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
    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 );
    }
911

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

// 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
932
    ratecontrol_entry_t rce;
933 934 935 936 937 938
    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
939 940 941 942 943 944 945 946 947
    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]);
        }
    }
948

Loren Merritt's avatar
Loren Merritt committed
949
    if( pict_type == SLICE_TYPE_B )
950
    {
Loren Merritt's avatar
Loren Merritt committed
951
        rcc->last_satd = 0;
Loren Merritt's avatar
Loren Merritt committed
952
        if(h->fenc->b_kept_as_ref)
Loren Merritt's avatar
Loren Merritt committed
953
            q = rcc->last_qscale * sqrtf(h->param.rc.f_pb_factor);
954
        else
Loren Merritt's avatar
Loren Merritt committed
955 956
            q = rcc->last_qscale * h->param.rc.f_pb_factor;
        return x264_clip3f(q, lmin, lmax);
957 958 959
    }
    else
    {
Loren Merritt's avatar
Loren Merritt committed
960 961 962 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
        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*100, 0.0, 1.0 );
                q *= pow( (double)total_bits / rcc->expected_bits_sum, w );
            }
            q = x264_clip3f( q, lmin, lmax );
        }
        else /* 1pass ABR */
        {
            /* Calculate the quantizer which would have produced the desired
             * average bitrate if it had been applied to all frames so far.
             * Then modulate that quant based on the current frame's complexity
             * relative to the average complexity so far (using the 2pass RCEQ).
             * Then bias the quant up or down if total size so far was far from
             * the target.
             * Result: Depending on the value of rate_tolerance, there is a
             * tradeoff between quality and bitrate precision. But at large
             * tolerances, the bit distribution approaches that of 2pass. */

            double wanted_bits, overflow, lmin, lmax;

            rcc->last_satd = x264_rc_analyse_slice( h );
            rcc->short_term_cplxsum *= 0.5;
            rcc->short_term_cplxcount *= 0.5;
            rcc->short_term_cplxsum