ratecontrol.c 57.2 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"

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

typedef struct
{
    int pict_type;
54
    int kept_as_ref;
55 56 57 58 59 60 61 62 63 64 65
    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
66
    float blurred_complexity;
Loren Merritt's avatar
Loren Merritt committed
67
    char direct_mode;
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
    int b_vbv;
83
    int b_vbv_min_rate;
84
    double fps;
Loren Merritt's avatar
Loren Merritt committed
85 86
    double bitrate;
    double rate_tolerance;
87
    int nmb;                    /* number of macroblocks in a frame */
88
    int qp_constant[5];
89

Loren Merritt's avatar
Loren Merritt committed
90 91
    /* current frame */
    ratecontrol_entry_t *rce;
92
    int qp;                     /* qp for current frame */
93 94
    int qpm;                    /* qp for current macroblock */
    float qpa;                  /* average of macroblocks' qp */
Måns Rullgård's avatar
Måns Rullgård committed
95
    int qp_force;
96

Loren Merritt's avatar
Loren Merritt committed
97 98
    /* VBV stuff */
    double buffer_size;
Loren Merritt's avatar
Loren Merritt committed
99 100
    double buffer_fill_final;   /* real buffer as of the last finished frame */
    double buffer_fill;         /* planned buffer, if all in-progress frames hit their bit budget */
Loren Merritt's avatar
Loren Merritt committed
101
    double buffer_rate;         /* # of bits added to buffer_fill after each frame */
Loren Merritt's avatar
Loren Merritt committed
102
    predictor_t *pred;          /* predict frame size from satd */
Loren Merritt's avatar
Loren Merritt committed
103 104 105 106 107 108 109 110 111 112

    /* 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;
113
    double rate_factor_constant;
114 115
    double ip_offset;
    double pb_offset;
Loren Merritt's avatar
Loren Merritt committed
116

117 118
    /* 2pass stuff */
    FILE *p_stat_file_out;
119
    char *psz_stat_file_tmpname;
120 121

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

137 138 139 140
    /* MBRC stuff */
    double frame_size_planned;
    predictor_t *row_pred;
    predictor_t row_preds[5];
Loren Merritt's avatar
Loren Merritt committed
141
    predictor_t *pred_b_from_p; /* predict B-frame size from P-frame satd */
142 143 144
    int bframes;                /* # consecutive B-frames before this P-frame */
    int bframe_bits;            /* total cost of those frames */

Loren Merritt's avatar
Loren Merritt committed
145 146
    int i_zones;
    x264_zone_t *zones;
147
    x264_zone_t *prev_zone;
148
};
Laurent Aimar's avatar
Laurent Aimar committed
149

150

151
static int parse_zones( x264_t *h );
152
static int init_pass2(x264_t *);
Loren Merritt's avatar
Loren Merritt committed
153
static float rate_estimate_qscale( x264_t *h );
Loren Merritt's avatar
Loren Merritt committed
154
static void update_vbv( x264_t *h, int bits );
Loren Merritt's avatar
Loren Merritt committed
155
static void update_vbv_plan( x264_t *h );
156 157
static double predict_size( predictor_t *p, double q, double var );
static void update_predictor( predictor_t *p, double q, double var, double bits );
Loren Merritt's avatar
Loren Merritt committed
158
int  x264_rc_analyse_slice( x264_t *h );
159 160 161

/* Terminology:
 * qp = h.264's quantizer
162
 * qscale = linearized quantizer = Lagrange multiplier
163 164 165 166 167 168 169 170 171 172
 */
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);
}

173 174 175 176
/* 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. */
177 178
static inline double qscale2bits(ratecontrol_entry_t *rce, double qscale)
{
Loren Merritt's avatar
Loren Merritt committed
179
    if(qscale<0.1)
180
        qscale = 0.1;
181
    return (rce->i_tex_bits + rce->p_tex_bits + .1) * pow( rce->qscale / qscale, 1.1 )
182
           + rce->mv_bits * pow( X264_MAX(rce->qscale, 1) / X264_MAX(qscale, 1), 0.5 )
183
           + rce->misc_bits;
184 185 186
}


187
int x264_ratecontrol_new( x264_t *h )
Laurent Aimar's avatar
Laurent Aimar committed
188
{
189 190
    x264_ratecontrol_t *rc;
    int i;
191

192 193
    x264_cpu_restore( h->param.cpu );

Loren Merritt's avatar
Loren Merritt committed
194
    rc = h->rc = x264_malloc( h->param.i_threads * sizeof(x264_ratecontrol_t) );
195
    memset( rc, 0, h->param.i_threads * sizeof(x264_ratecontrol_t) );
196

197 198
    rc->b_abr = h->param.rc.i_rc_method != X264_RC_CQP && !h->param.rc.b_stat_read;
    rc->b_2pass = h->param.rc.i_rc_method == X264_RC_ABR && h->param.rc.b_stat_read;
Loren Merritt's avatar
Loren Merritt committed
199
    
200 201 202 203 204 205
    /* 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;

206
    rc->bitrate = h->param.rc.i_bitrate * 1000;
Loren Merritt's avatar
Loren Merritt committed
207
    rc->rate_tolerance = h->param.rc.f_rate_tolerance;
208
    rc->nmb = h->mb.i_mb_count;
Loren Merritt's avatar
Loren Merritt committed
209 210 211
    rc->last_non_b_pict_type = -1;
    rc->cbr_decay = 1.0;

212
    if( h->param.rc.i_rc_method == X264_RC_CRF && h->param.rc.b_stat_read )
213
    {
214
        x264_log(h, X264_LOG_ERROR, "constant rate-factor is incompatible with 2pass.\n");
215 216
        return -1;
    }
217
    if( h->param.rc.i_vbv_buffer_size )
218
    {
219 220 221 222 223 224 225
        if( h->param.rc.i_rc_method == X264_RC_CQP )
            x264_log(h, X264_LOG_WARNING, "VBV is incompatible with constant QP, ignored.\n");
        else if( 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;
        }
226
    }
Loren Merritt's avatar
Loren Merritt committed
227 228
    if( h->param.rc.i_vbv_max_bitrate < h->param.rc.i_bitrate &&
        h->param.rc.i_vbv_max_bitrate > 0)
229
        x264_log(h, X264_LOG_WARNING, "max bitrate less than average bitrate, ignored.\n");
Loren Merritt's avatar
Loren Merritt committed
230 231 232
    else if( h->param.rc.i_vbv_max_bitrate > 0 &&
             h->param.rc.i_vbv_buffer_size > 0 )
    {
233 234
        if( h->param.rc.i_vbv_buffer_size < 3 * h->param.rc.i_vbv_max_bitrate / rc->fps )
        {
235
            h->param.rc.i_vbv_buffer_size = 3 * h->param.rc.i_vbv_max_bitrate / rc->fps;
236
            x264_log( h, X264_LOG_WARNING, "VBV buffer size too small, using %d kbit\n",
Loren Merritt's avatar
Loren Merritt committed
237
                      h->param.rc.i_vbv_buffer_size );
238
        }
Loren Merritt's avatar
Loren Merritt committed
239 240
        rc->buffer_rate = h->param.rc.i_vbv_max_bitrate * 1000 / rc->fps;
        rc->buffer_size = h->param.rc.i_vbv_buffer_size * 1000;
Loren Merritt's avatar
Loren Merritt committed
241
        rc->buffer_fill_final = rc->buffer_size * h->param.rc.f_vbv_buffer_init;
Loren Merritt's avatar
Loren Merritt committed
242 243
        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);
244
        rc->b_vbv = 1;
245 246 247
        rc->b_vbv_min_rate = !rc->b_2pass
                          && h->param.rc.i_rc_method == X264_RC_ABR
                          && h->param.rc.i_vbv_max_bitrate <= h->param.rc.i_bitrate;
Loren Merritt's avatar
Loren Merritt committed
248
    }
249
    else if( h->param.rc.i_vbv_max_bitrate )
250
    {
251
        x264_log(h, X264_LOG_WARNING, "VBV maxrate specified, but no bufsize.\n");
252 253
        h->param.rc.i_vbv_max_bitrate = 0;
    }
254
    if(rc->rate_tolerance < 0.01) {
255
        x264_log(h, X264_LOG_WARNING, "bitrate tolerance too small, using .01\n");
256 257
        rc->rate_tolerance = 0.01;
    }
258

Loren Merritt's avatar
Loren Merritt committed
259
    h->mb.b_variable_qp = rc->b_vbv && !rc->b_2pass;
260

Loren Merritt's avatar
Loren Merritt committed
261 262
    if( rc->b_abr )
    {
263
        /* FIXME ABR_INIT_QP is actually used only in CRF */
264
#define ABR_INIT_QP ( h->param.rc.i_rc_method == X264_RC_CRF ? h->param.rc.f_rf_constant : 24 )
Loren Merritt's avatar
Loren Merritt committed
265 266
        rc->accum_p_norm = .01;
        rc->accum_p_qp = ABR_INIT_QP * rc->accum_p_norm;
267 268 269 270
        /* estimated ratio that produces a reasonable QP for the first I-frame */
        rc->cplxr_sum = .01 * pow( 7.0e5, h->param.rc.f_qcompress ) * pow( h->mb.i_mb_count, 0.5 );
        rc->wanted_bits_window = 1.0 * rc->bitrate / rc->fps;
        rc->last_non_b_pict_type = SLICE_TYPE_I;
271 272
    }

273
    if( h->param.rc.i_rc_method == X264_RC_CRF )
274 275 276 277
    {
        /* 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 )
278
                                 / qp2qscale( h->param.rc.f_rf_constant );
279 280
    }

281 282
    rc->ip_offset = 6.0 * log(h->param.rc.f_ip_factor) / log(2.0);
    rc->pb_offset = 6.0 * log(h->param.rc.f_pb_factor) / log(2.0);
Loren Merritt's avatar
Loren Merritt committed
283
    rc->qp_constant[SLICE_TYPE_P] = h->param.rc.i_qp_constant;
284 285
    rc->qp_constant[SLICE_TYPE_I] = x264_clip3( h->param.rc.i_qp_constant - rc->ip_offset + 0.5, 0, 51 );
    rc->qp_constant[SLICE_TYPE_B] = x264_clip3( h->param.rc.i_qp_constant + rc->pb_offset + 0.5, 0, 51 );
286

Loren Merritt's avatar
Loren Merritt committed
287
    rc->lstep = pow( 2, h->param.rc.i_qp_step / 6.0 );
288
    rc->last_qscale = qp2qscale(26);
Loren Merritt's avatar
Loren Merritt committed
289 290
    rc->pred = x264_malloc( 5*sizeof(predictor_t) );
    rc->pred_b_from_p = x264_malloc( sizeof(predictor_t) );
291 292
    for( i = 0; i < 5; i++ )
    {
293
        rc->last_qscale_for[i] = qp2qscale( ABR_INIT_QP );
294 295
        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
296 297 298
        rc->pred[i].coeff= 2.0;
        rc->pred[i].count= 1.0;
        rc->pred[i].decay= 0.5;
299 300 301
        rc->row_preds[i].coeff= .25;
        rc->row_preds[i].count= 1.0;
        rc->row_preds[i].decay= 0.5;
302
    }
Loren Merritt's avatar
Loren Merritt committed
303
    *rc->pred_b_from_p = rc->pred[0];
304

305
    if( parse_zones( h ) < 0 )
306 307
    {
        x264_log( h, X264_LOG_ERROR, "failed to parse zones\n" );
308
        return -1;
309
    }
Loren Merritt's avatar
Loren Merritt committed
310

311 312 313
    /* Load stat file and init 2pass algo */
    if( h->param.rc.b_stat_read )
    {
314
        char *p, *stats_in, *stats_buf;
315 316 317

        /* read 1st pass stats */
        assert( h->param.rc.psz_stat_in );
318 319
        stats_buf = stats_in = x264_slurp_file( h->param.rc.psz_stat_in );
        if( !stats_buf )
320 321 322 323 324
        {
            x264_log(h, X264_LOG_ERROR, "ratecontrol_init: can't open stats file\n");
            return -1;
        }

325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353
        /* 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 );

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

358 359
        /* find number of pics */
        p = stats_in;
Loren Merritt's avatar
Loren Merritt committed
360
        for(i=-1; p; i++)
361
            p = strchr(p+1, ';');
Loren Merritt's avatar
Loren Merritt committed
362 363 364 365
        if(i==0)
        {
            x264_log(h, X264_LOG_ERROR, "empty stats file\n");
            return -1;
366
        }
367 368
        rc->num_entries = i;

369
        if( h->param.i_frame_total < rc->num_entries && h->param.i_frame_total > 0 )
370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385
        {
            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));
386 387 388 389

        /* init all to skipped p frames */
        for(i=0; i<rc->num_entries; i++){
            ratecontrol_entry_t *rce = &rc->entry[i];
390
            rce->pict_type = SLICE_TYPE_P;
391 392 393 394 395 396 397 398 399
            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;
400 401
            int frame_number;
            char pict_type;
402 403 404 405 406 407 408 409 410
            int e;
            char *next;
            float qp;

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

Loren Merritt's avatar
Loren Merritt committed
413 414 415 416 417
            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;
            }
418
            rce = &rc->entry[frame_number];
Loren Merritt's avatar
Loren Merritt committed
419
            rce->direct_mode = 0;
420

Loren Merritt's avatar
Loren Merritt committed
421
            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",
422
                   &pict_type, &qp, &rce->i_tex_bits, &rce->p_tex_bits,
Loren Merritt's avatar
Loren Merritt committed
423 424
                   &rce->mv_bits, &rce->misc_bits, &rce->i_count, &rce->p_count,
                   &rce->s_count, &rce->direct_mode);
425 426

            switch(pict_type){
427
                case 'I': rce->kept_as_ref = 1;
428 429
                case 'i': rce->pict_type = SLICE_TYPE_I; break;
                case 'P': rce->pict_type = SLICE_TYPE_P; break;
430 431
                case 'B': rce->kept_as_ref = 1;
                case 'b': rce->pict_type = SLICE_TYPE_B; break;
432 433
                default:  e = -1; break;
            }
Loren Merritt's avatar
Loren Merritt committed
434
            if(e < 10){
435 436 437 438 439 440 441
                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;
        }

442
        x264_free(stats_buf);
443

444
        if(h->param.rc.i_rc_method == X264_RC_ABR)
445 446
        {
            if(init_pass2(h) < 0) return -1;
Loren Merritt's avatar
Loren Merritt committed
447
        } /* else we're using constant quant, so no need to run the bitrate allocation */
448 449 450
    }

    /* Open output file */
451 452
    /* 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 */
453 454
    if( h->param.rc.b_stat_write )
    {
455 456
        char *p;

457 458 459
        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" );
460 461

        rc->p_stat_file_out = fopen( rc->psz_stat_file_tmpname, "wb" );
462 463 464 465 466
        if( rc->p_stat_file_out == NULL )
        {
            x264_log(h, X264_LOG_ERROR, "ratecontrol_init: can't open stats file\n");
            return -1;
        }
467 468 469 470

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

Loren Merritt's avatar
Loren Merritt committed
473 474 475 476 477 478
    for( i=1; i<h->param.i_threads; i++ )
    {
        h->thread[i]->rc = rc+i;
        rc[i] = rc[0];
    }

479
    return 0;
Laurent Aimar's avatar
Laurent Aimar committed
480 481
}

482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521
static int parse_zone( x264_t *h, x264_zone_t *z, char *p )
{
    int len = 0;
    char *tok, *saveptr;
    z->param = NULL;
    z->f_bitrate_factor = 1;
    if( 3 <= sscanf(p, "%u,%u,q=%u%n", &z->i_start, &z->i_end, &z->i_qp, &len) )
        z->b_force_qp = 1;
    else if( 3 <= sscanf(p, "%u,%u,b=%f%n", &z->i_start, &z->i_end, &z->f_bitrate_factor, &len) )
        z->b_force_qp = 0;
    else if( 2 <= sscanf(p, "%u,%u%n", &z->i_start, &z->i_end, &len) )
        z->b_force_qp = 0;
    else
    {
        x264_log( h, X264_LOG_ERROR, "invalid zone: \"%s\"\n", p );
        return -1;
    }
    p += len;
    if( !*p )
        return 0;
    z->param = malloc( sizeof(x264_param_t) );
    memcpy( z->param, &h->param, sizeof(x264_param_t) );
    while( (tok = strtok_r( p, ",", &saveptr )) )
    {
        char *val = strchr( tok, '=' );
        if( val )
        {
            *val = '\0';
            val++;
        }
        if( x264_param_parse( z->param, tok, val ) )
        {
            x264_log( h, X264_LOG_ERROR, "invalid zone param: %s = %s\n", tok, val );
            return -1;
        }
        p = NULL;
    }
    return 0;
}

522 523 524 525 526 527
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 )
    {
528 529 530
        char *p, *tok, *saveptr;
        char *psz_zones = x264_malloc( strlen(h->param.rc.psz_zones)+1 );
        strcpy( psz_zones, h->param.rc.psz_zones );
531
        h->param.rc.i_zones = 1;
532
        for( p = psz_zones; *p; p++ )
533 534
            h->param.rc.i_zones += (*p == '/');
        h->param.rc.zones = x264_malloc( h->param.rc.i_zones * sizeof(x264_zone_t) );
535 536
        p = psz_zones;
        for( i = 0; i < h->param.rc.i_zones; i++ )
537
        {
538 539
            tok = strtok_r( p, "/", &saveptr );
            if( !tok || parse_zone( h, &h->param.rc.zones[i], tok ) )
540
                return -1;
541
            p = NULL;
542
        }
543
        x264_free( psz_zones );
544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564
    }

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

565
        rc->i_zones = h->param.rc.i_zones + 1;
566
        rc->zones = x264_malloc( rc->i_zones * sizeof(x264_zone_t) );
567 568 569 570 571 572 573 574 575 576 577 578 579 580
        memcpy( rc->zones+1, h->param.rc.zones, (rc->i_zones-1) * sizeof(x264_zone_t) );

        // default zone to fall back to if none of the others match
        rc->zones[0].i_start = 0;
        rc->zones[0].i_end = INT_MAX;
        rc->zones[0].b_force_qp = 0;
        rc->zones[0].f_bitrate_factor = 1;
        rc->zones[0].param = x264_malloc( sizeof(x264_param_t) );
        memcpy( rc->zones[0].param, &h->param, sizeof(x264_param_t) );
        for( i = 1; i < rc->i_zones; i++ )
        {
            if( !rc->zones[i].param )
                rc->zones[i].param = rc->zones[0].param;
        }
581 582 583 584 585
    }

    return 0;
}

Loren Merritt's avatar
Loren Merritt committed
586 587 588 589 590 591 592 593 594 595 596 597
x264_zone_t *get_zone( x264_t *h, int frame_num )
{
    int i;
    for( i = h->rc->i_zones-1; i >= 0; i-- )
    {
        x264_zone_t *z = &h->rc->zones[i];
        if( frame_num >= z->i_start && frame_num <= z->i_end )
            return z;
    }
    return NULL;
}

598 599 600
void x264_ratecontrol_summary( x264_t *h )
{
    x264_ratecontrol_t *rc = h->rc;
601
    if( rc->b_abr && h->param.rc.i_rc_method == X264_RC_ABR && rc->cbr_decay > .9999 )
602 603 604 605 606 607 608 609
    {
        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 ) );
    }
}

610
void x264_ratecontrol_delete( x264_t *h )
Laurent Aimar's avatar
Laurent Aimar committed
611
{
612
    x264_ratecontrol_t *rc = h->rc;
613
    int i;
614 615

    if( rc->p_stat_file_out )
616
    {
617
        fclose( rc->p_stat_file_out );
618 619 620 621 622 623 624
        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 );
625
    }
Loren Merritt's avatar
Loren Merritt committed
626 627
    x264_free( rc->pred );
    x264_free( rc->pred_b_from_p );
Loren Merritt's avatar
Loren Merritt committed
628
    x264_free( rc->entry );
629 630 631 632 633 634 635 636 637
    if( rc->zones )
    {
        x264_free( rc->zones[0].param );
        if( h->param.rc.psz_zones )
            for( i=1; i<rc->i_zones; i++ )
                if( rc->zones[i].param != rc->zones[0].param )
                    x264_free( rc->zones[i].param );
        x264_free( rc->zones );
    }
Laurent Aimar's avatar
Laurent Aimar committed
638 639 640
    x264_free( rc );
}

Loren Merritt's avatar
Loren Merritt committed
641 642 643 644 645 646 647 648 649 650 651 652
static void accum_p_qp_update( x264_t *h, float qp )
{
    x264_ratecontrol_t *rc = h->rc;
    rc->accum_p_qp   *= .95;
    rc->accum_p_norm *= .95;
    rc->accum_p_norm += 1;
    if( h->sh.i_type == SLICE_TYPE_I )
        rc->accum_p_qp += qp + rc->ip_offset;
    else
        rc->accum_p_qp += qp;
}

Loren Merritt's avatar
Loren Merritt committed
653
/* Before encoding a frame, choose a QP for it */
Loren Merritt's avatar
Loren Merritt committed
654
void x264_ratecontrol_start( x264_t *h, int i_force_qp )
Laurent Aimar's avatar
Laurent Aimar committed
655
{
656
    x264_ratecontrol_t *rc = h->rc;
Loren Merritt's avatar
Loren Merritt committed
657
    ratecontrol_entry_t *rce = NULL;
658
    x264_zone_t *zone = get_zone( h, h->fenc->i_frame );
Loren Merritt's avatar
Loren Merritt committed
659
    float q;
660 661 662

    x264_cpu_restore( h->param.cpu );

663 664 665 666
    if( zone && (!rc->prev_zone || zone->param != rc->prev_zone->param) )
        x264_encoder_reconfig( h, zone->param );
    rc->prev_zone = zone;

Måns Rullgård's avatar
Måns Rullgård committed
667 668
    rc->qp_force = i_force_qp;

Loren Merritt's avatar
Loren Merritt committed
669 670 671 672 673 674
    if( h->param.rc.b_stat_read )
    {
        int frame = h->fenc->i_frame;
        assert( frame >= 0 && frame < rc->num_entries );
        rce = h->rc->rce = &h->rc->entry[frame];

Loren Merritt's avatar
Loren Merritt committed
675
        if( h->sh.i_type == SLICE_TYPE_B
Loren Merritt's avatar
Loren Merritt committed
676 677 678 679 680 681 682
            && h->param.analyse.i_direct_mv_pred == X264_DIRECT_PRED_AUTO )
        {
            h->sh.b_direct_spatial_mv_pred = ( rce->direct_mode == 's' );
            h->mb.b_direct_auto_read = ( rce->direct_mode == 's' || rce->direct_mode == 't' );
        }
    }

Loren Merritt's avatar
Loren Merritt committed
683
    if( rc->b_vbv )
684 685
    {
        memset( h->fdec->i_row_bits, 0, h->sps->i_mb_height * sizeof(int) );
Loren Merritt's avatar
Loren Merritt committed
686 687
        rc->row_pred = &rc->row_preds[h->sh.i_type];
        update_vbv_plan( h );
688 689
    }

Loren Merritt's avatar
Loren Merritt committed
690
    if( h->sh.i_type != SLICE_TYPE_B )
691 692 693 694 695 696 697 698
    {
        rc->bframes = 0;
        while( h->frames.current[rc->bframes] && IS_X264_TYPE_B(h->frames.current[rc->bframes]->i_type) )
            rc->bframes++;
    }

    rc->qpa = 0;

Loren Merritt's avatar
Loren Merritt committed
699
    if( i_force_qp )
700
    {
Loren Merritt's avatar
Loren Merritt committed
701
        q = i_force_qp - 1;
702
    }
Loren Merritt's avatar
Loren Merritt committed
703 704
    else if( rc->b_abr )
    {
Loren Merritt's avatar
Loren Merritt committed
705
        q = qscale2qp( rate_estimate_qscale( h ) );
Loren Merritt's avatar
Loren Merritt committed
706 707
    }
    else if( rc->b_2pass )
708
    {
Loren Merritt's avatar
Loren Merritt committed
709 710
        rce->new_qscale = rate_estimate_qscale( h );
        q = qscale2qp( rce->new_qscale );
711
    }
Loren Merritt's avatar
Loren Merritt committed
712 713
    else /* CQP */
    {
Loren Merritt's avatar
Loren Merritt committed
714
        if( h->sh.i_type == SLICE_TYPE_B && h->fdec->b_kept_as_ref )
Loren Merritt's avatar
Loren Merritt committed
715
            q = ( rc->qp_constant[ SLICE_TYPE_B ] + rc->qp_constant[ SLICE_TYPE_P ] ) / 2;
716
        else
Loren Merritt's avatar
Loren Merritt committed
717
            q = rc->qp_constant[ h->sh.i_type ];
Loren Merritt's avatar
Loren Merritt committed
718 719 720 721 722 723 724 725

        if( zone )
        {
            if( zone->b_force_qp )
                q += zone->i_qp - rc->qp_constant[SLICE_TYPE_P];
            else
                q -= 6*log(zone->f_bitrate_factor)/log(2);
        }
Måns Rullgård's avatar
Måns Rullgård committed
726
    }
Loren Merritt's avatar
Loren Merritt committed
727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742

    h->fdec->f_qp_avg =
    rc->qpm =
    rc->qp = x264_clip3( (int)(q + 0.5), 0, 51 );
    if( rce )
        rce->new_qp = rc->qp;

    /* accum_p_qp needs to be here so that future frames can benefit from the
     * data before this frame is done. but this only works because threading
     * guarantees to not re-encode any frames. so the non-threaded case does
     * accum_p_qp later. */
    if( h->param.i_threads > 1 )
        accum_p_qp_update( h, rc->qp );

    if( h->sh.i_type != SLICE_TYPE_B )
        rc->last_non_b_pict_type = h->sh.i_type;
Laurent Aimar's avatar
Laurent Aimar committed
743 744
}

745 746 747 748 749 750 751
double predict_row_size( x264_t *h, int y, int qp )
{
    /* average between two predictors:
     * absolute SATD, and scaled bit cost of the colocated row in the previous frame */
    x264_ratecontrol_t *rc = h->rc;
    double pred_s = predict_size( rc->row_pred, qp2qscale(qp), h->fdec->i_row_satd[y] );
    double pred_t = 0;
Loren Merritt's avatar
Loren Merritt committed
752
    if( h->sh.i_type != SLICE_TYPE_I 
753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768
        && h->fref0[0]->i_type == h->fdec->i_type
        && h->fref0[0]->i_row_satd[y] > 0 )
    {
        pred_t = h->fref0[0]->i_row_bits[y] * h->fdec->i_row_satd[y] / h->fref0[0]->i_row_satd[y]
                 * qp2qscale(h->fref0[0]->i_row_qp[y]) / qp2qscale(qp);
    }
    if( pred_t == 0 )
        pred_t = pred_s;

    return (pred_s + pred_t) / 2;
}

double predict_row_size_sum( x264_t *h, int y, int qp )
{
    int i;
    double bits = 0;
Loren Merritt's avatar
Loren Merritt committed
769
    for( i = 0; i <= y; i++ )
770
        bits += h->fdec->i_row_bits[i];
Loren Merritt's avatar
Loren Merritt committed
771
    for( i = y+1; i < h->sps->i_mb_height; i++ )
772 773 774 775
        bits += predict_row_size( h, i, qp );
    return bits;
}

776
void x264_ratecontrol_mb( x264_t *h, int bits )
Laurent Aimar's avatar
Laurent Aimar committed
777
{
778 779 780 781 782 783 784 785
    x264_ratecontrol_t *rc = h->rc;
    const int y = h->mb.i_mb_y;

    x264_cpu_restore( h->param.cpu );

    h->fdec->i_row_bits[y] += bits;
    rc->qpa += rc->qpm;

Loren Merritt's avatar
Loren Merritt committed
786
    if( h->mb.i_mb_x != h->sps->i_mb_width - 1 || !h->mb.b_variable_qp )
787 788 789 790
        return;

    h->fdec->i_row_qp[y] = rc->qpm;

Loren Merritt's avatar
Loren Merritt committed
791
    if( h->sh.i_type == SLICE_TYPE_B )
792 793
    {
        /* B-frames shouldn't use lower QP than their reference frames */
Loren Merritt's avatar
Loren Merritt committed
794
        if( y < h->sps->i_mb_height-1 )
795 796 797 798 799 800 801 802 803 804 805
        {
            rc->qpm = X264_MAX( rc->qp,
                      X264_MIN( h->fref0[0]->i_row_qp[y+1],
                                h->fref1[0]->i_row_qp[y+1] ));
        }
    }
    else
    {
        update_predictor( rc->row_pred, qp2qscale(rc->qpm), h->fdec->i_row_satd[y], h->fdec->i_row_bits[y] );

        /* tweak quality based on difference from predicted size */
Loren Merritt's avatar
Loren Merritt committed
806
        if( y < h->sps->i_mb_height-1 && h->stat.i_slice_count[h->sh.i_type] > 0 )
807 808 809 810 811 812 813 814
        {
            int prev_row_qp = h->fdec->i_row_qp[y];
            int b0 = predict_row_size_sum( h, y, rc->qpm );
            int b1 = b0;
            int i_qp_max = X264_MIN( prev_row_qp + h->param.rc.i_qp_step, h->param.rc.i_qp_max );
            int i_qp_min = X264_MAX( prev_row_qp - h->param.rc.i_qp_step, h->param.rc.i_qp_min );
            float buffer_left_planned = rc->buffer_fill - rc->frame_size_planned;

815 816 817
            if( !rc->b_vbv_min_rate )
                i_qp_min = X264_MAX( i_qp_min, h->sh.i_qp );

818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835
            while( rc->qpm < i_qp_max
                   && (b1 > rc->frame_size_planned * 1.15
                    || (rc->buffer_fill - b1 < buffer_left_planned * 0.5)))
            {
                rc->qpm ++;
                b1 = predict_row_size_sum( h, y, rc->qpm );
            }

            while( rc->qpm > i_qp_min
                   && buffer_left_planned > rc->buffer_size * 0.4
                   && ((b1 < rc->frame_size_planned * 0.8 && rc->qpm <= prev_row_qp)
                     || b1 < (rc->buffer_fill - rc->buffer_size + rc->buffer_rate) * 1.1) )
            {
                rc->qpm --;
                b1 = predict_row_size_sum( h, y, rc->qpm );
            }
        }
    }
Laurent Aimar's avatar
Laurent Aimar committed
836 837
}

Loren Merritt's avatar
Loren Merritt committed
838
int x264_ratecontrol_qp( x264_t *h )
Laurent Aimar's avatar
Laurent Aimar committed
839
{
840
    return h->rc->qpm;
841
}
Laurent Aimar's avatar
Laurent Aimar committed
842

Loren Merritt's avatar
Loren Merritt committed
843
/* In 2pass, force the same frame types as in the 1st pass */
844 845
int x264_ratecontrol_slice_type( x264_t *h, int frame_num )
{
846
    x264_ratecontrol_t *rc = h->rc;
847 848
    if( h->param.rc.b_stat_read )
    {
849
        if( frame_num >= rc->num_entries )
850
        {
851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867
            /* 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;
868
            h->param.rc.i_rc_method = X264_RC_CQP;
869 870 871 872
            h->param.rc.b_stat_read = 0;
            h->param.b_bframe_adaptive = 0;
            if( h->param.i_bframe > 1 )
                h->param.i_bframe = 1;
873 874
            return X264_TYPE_P;
        }
875
        switch( rc->entry[frame_num].pict_type )
876 877
        {
            case SLICE_TYPE_I:
878
                return rc->entry[frame_num].kept_as_ref ? X264_TYPE_IDR : X264_TYPE_I;
879 880

            case SLICE_TYPE_B:
881
                return rc->entry[frame_num].kept_as_ref ? X264_TYPE_BREF : X264_TYPE_B;
882 883 884 885 886 887 888 889 890 891 892 893

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

Loren Merritt's avatar
Loren Merritt committed
894
/* After encoding one frame, save stats and update ratecontrol state */
895 896 897
void x264_ratecontrol_end( x264_t *h, int bits )
{
    x264_ratecontrol_t *rc = h->rc;
898
    const int *mbs = h->stat.frame.i_mb_count;
Loren Merritt's avatar
Loren Merritt committed
899
    int i;
Laurent Aimar's avatar
Laurent Aimar committed
900

901 902
    x264_cpu_restore( h->param.cpu );

903 904 905
    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
906
    for( i = B_DIRECT; i < B_8x8; i++ )
907
        h->stat.frame.i_mb_count_p += mbs[i];
Loren Merritt's avatar
Loren Merritt committed
908

Loren Merritt's avatar
Loren Merritt committed
909
    if( h->mb.b_variable_qp )
910 911 912 913 914
        rc->qpa /= h->mb.i_mb_count;
    else
        rc->qpa = rc->qp;
    h->fdec->f_qp_avg = rc->qpa;

915 916
    if( h->param.rc.b_stat_write )
    {
Loren Merritt's avatar
Loren Merritt committed
917 918
        char c_type = h->sh.i_type==SLICE_TYPE_I ? (h->fenc->i_poc==0 ? 'I' : 'i')
                    : h->sh.i_type==SLICE_TYPE_P ? 'P'
919
                    : h->fenc->b_kept_as_ref ? 'B' : 'b';
Loren Merritt's avatar
Loren Merritt committed
920 921 922 923 924 925
        int dir_frame = h->stat.frame.i_direct_score[1] - h->stat.frame.i_direct_score[0];
        int dir_avg = h->stat.i_direct_score[1] - h->stat.i_direct_score[0];
        char c_direct = h->mb.b_direct_auto_write ?
                        ( dir_frame>0 ? 's' : dir_frame<0 ? 't' : 
                          dir_avg>0 ? 's' : dir_avg<0 ? 't' : '-' )
                        : '-';
926
        fprintf( rc->p_stat_file_out,
Loren Merritt's avatar
Loren Merritt committed
927
                 "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",
928
                 h->fenc->i_frame, h->i_frame,
929
                 c_type, rc->qpa,
930 931
                 h->stat.frame.i_itex_bits, h->stat.frame.i_ptex_bits,
                 h->stat.frame.i_hdr_bits, h->stat.frame.i_misc_bits,
932
                 h->stat.frame.i_mb_count_i,
Loren Merritt's avatar
Loren Merritt committed
933
                 h->stat.frame.i_mb_count_p,
Loren Merritt's avatar
Loren Merritt committed
934 935
                 h->stat.frame.i_mb_count_skip,
                 c_direct);
936 937
    }

Loren Merritt's avatar
Loren Merritt committed
938 939
    if( rc->b_abr )
    {
Loren Merritt's avatar
Loren Merritt committed
940
        if( h->sh.i_type != SLICE_TYPE_B )
Loren Merritt's avatar
Loren Merritt committed
941 942 943 944 945 946 947 948 949 950 951
            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;

Loren Merritt's avatar
Loren Merritt committed
952 953
        if( h->param.i_threads == 1 )
            accum_p_qp_update( h, rc->qpa );
Laurent Aimar's avatar
Laurent Aimar committed
954 955
    }

Loren Merritt's avatar
Loren Merritt committed
956 957 958
    if( rc->b_2pass )
    {
        rc->expected_bits_sum += qscale2bits( rc->rce, qp2qscale(rc->rce->new_qp) );
Laurent Aimar's avatar
Laurent Aimar committed
959 960
    }

Loren Merritt's avatar
Loren Merritt committed
961
    if( h->mb.b_variable_qp )
962
    {
Loren Merritt's avatar
Loren Merritt committed
963
        if( h->sh.i_type == SLICE_TYPE_B )
964 965 966
        {
            rc->bframe_bits += bits;
            if( !h->frames.current[0] || !IS_X264_TYPE_B(h->frames.current[0]->i_type) )
Loren Merritt's avatar
Loren Merritt committed
967 968 969 970 971
            {
                update_predictor( rc->pred_b_from_p, qp2qscale(rc->qpa),
                                  h->fref1[h->i_ref1-1]->i_satd, rc->bframe_bits / rc->bframes );
                rc->bframe_bits = 0;
            }
972 973 974
        }
    }

Loren Merritt's avatar
Loren Merritt committed
975
    update_vbv( h, bits );
Laurent Aimar's avatar
Laurent Aimar committed
976
}
977 978 979 980

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

982 983 984 985 986 987
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
988
 * modify the bitrate curve from pass1 for one frame
989
 */
Loren Merritt's avatar
Loren Merritt committed
990
static double get_qscale(x264_t *h, ratecontrol_entry_t *rce, double rate_factor, int frame_num)
991 992
{
    x264_ratecontrol_t *rcc= h->rc;
993
    const int pict_type = rce->pict_type;
994
    double q;
Loren Merritt's avatar
Loren Merritt committed
995
    x264_zone_t *zone = get_zone( h, frame_num );
996 997 998 999 1000

    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,
1001
        rce->mv_bits * rce->qscale,
1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013
        (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
1014
        rce->blurred_complexity,
1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033
        0
    };
    static const char *const_names[]={
        "iTex",
        "pTex",
        "tex",
        "mv",
        "iCount",
        "pCount",
        "sCount",
        "isI",
        "isP",
        "isB",
        "qComp",
        "avgIITex",
        "avgPITex",
        "avgPPTex",
        "avgBPTex",
        "avgTex",
1034
        "blurCplx",
1035 1036 1037
        NULL
    };
    static double (*func1[])(void *, double)={
1038
//      (void *)bits2qscale,
1039 1040 1041 1042
        (void *)qscale2bits,
        NULL
    };
    static const char *func1_names[]={
1043
//      "bits2qp",
1044 1045 1046 1047
        "qp2bits",
        NULL
    };

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

Loren Merritt's avatar
Loren Merritt committed
1050
    // avoid NaN's in the rc_eq
1051
    if(!isfinite(q) || rce->i_tex_bits + rce->p_tex_bits + rce->mv_bits == 0)
1052
        q = rcc->last_qscale;
Loren Merritt's avatar
Loren Merritt committed
1053 1054 1055
    else {
        rcc->last_rceq = q;
        q /= rate_factor;
1056
        rcc->last_qscale = q;
Loren Merritt's avatar
Loren Merritt committed
1057 1058
    }

Loren Merritt's avatar
Loren Merritt committed
1059
    if( zone )
Loren Merritt's avatar
Loren Merritt committed
1060
    {
Loren Merritt's avatar
Loren Merritt committed
1061 1062 1063 1064
        if( zone->b_force_qp )
            q = qp2qscale(zone->i_qp);
        else
            q /= zone->f_bitrate_factor;
Loren Merritt's avatar
Loren Merritt committed
1065
    }
1066

1067
    return q;
1068 1069 1070 1071 1072
}

static double get_diff_limited_q(x264_t *h, ratecontrol_entry_t *rce, double q)
{
    x264_ratecontrol_t *rcc = h->rc;
1073
    const int pict_type = rce->pict_type;
1074 1075 1076 1077

    // 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];
1078 1079
    if( pict_type == SLICE_TYPE_I )
    {
1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091
        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;
1092 1093 1094 1095 1096
    }
    else if( pict_type == SLICE_TYPE_B )
    {
        if( h->param.rc.f_pb_factor > 0 )
            q = last_non_b_q;
1097 1098
        if( !rce->kept_as_ref )
            q *= fabs( h->param.rc.f_pb_factor );