ratecontrol.c 103 KB
Newer Older
1
/*****************************************************************************
Laurent Aimar's avatar
Laurent Aimar committed
2 3
 * ratecontrol.c: h264 encoder library (Rate Control)
 *****************************************************************************
4
 * Copyright (C) 2005-2008 x264 project
Laurent Aimar's avatar
Laurent Aimar committed
5
 *
Loren Merritt's avatar
Loren Merritt committed
6 7
 * Authors: Loren Merritt <lorenm@u.washington.edu>
 *          Michael Niedermayer <michaelni@gmx.at>
8 9
 *          Gabriel Bouvigne <gabriel.bouvigne@joost.com>
 *          Fiona Glaser <fiona@x264.com>
Loren Merritt's avatar
Loren Merritt committed
10
 *          Mns Rullgrd <mru@mru.ath.cx>
Laurent Aimar's avatar
Laurent Aimar committed
11 12 13 14 15 16 17 18 19 20 21 22 23
 *
 * 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
24
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
Laurent Aimar's avatar
Laurent Aimar committed
25 26
 *****************************************************************************/

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

31
#include "common/common.h"
Laurent Aimar's avatar
Laurent Aimar committed
32
#include "ratecontrol.h"
33
#include "me.h"
Laurent Aimar's avatar
Laurent Aimar committed
34

35 36 37
typedef struct
{
    int pict_type;
38
    int frame_type;
39
    int kept_as_ref;
40
    double qscale;
41
    int mv_bits;
42
    int tex_bits;
43
    int misc_bits;
44
    uint64_t expected_bits; /*total expected bits up to the current frame (current one excluded)*/
45
    double expected_vbv;
46
    double new_qscale;
47 48 49 50
    int new_qp;
    int i_count;
    int p_count;
    int s_count;
Loren Merritt's avatar
Loren Merritt committed
51
    float blurred_complexity;
Loren Merritt's avatar
Loren Merritt committed
52
    char direct_mode;
53 54
    int16_t weight[2];
    int16_t i_weight_denom;
55 56
    int refcount[16];
    int refs;
57 58
    int i_duration;
    int i_cpb_duration;
59 60
} ratecontrol_entry_t;

Loren Merritt's avatar
Loren Merritt committed
61 62 63 64 65
typedef struct
{
    double coeff;
    double count;
    double decay;
Fiona Glaser's avatar
Fiona Glaser committed
66
    double offset;
Loren Merritt's avatar
Loren Merritt committed
67 68
} predictor_t;

69 70 71
struct x264_ratecontrol_t
{
    /* constants */
Loren Merritt's avatar
Loren Merritt committed
72 73
    int b_abr;
    int b_2pass;
74
    int b_vbv;
75
    int b_vbv_min_rate;
76
    double fps;
Loren Merritt's avatar
Loren Merritt committed
77 78
    double bitrate;
    double rate_tolerance;
Fiona Glaser's avatar
Fiona Glaser committed
79
    double qcompress;
80
    int nmb;                    /* number of macroblocks in a frame */
81
    int qp_constant[3];
82

Loren Merritt's avatar
Loren Merritt committed
83 84
    /* current frame */
    ratecontrol_entry_t *rce;
85
    int qp;                     /* qp for current frame */
86
    float qpm;                  /* qp for current macroblock: precise float for AQ */
87 88
    float qpa_rc;               /* average of macroblocks' qp before aq */
    float qpa_aq;               /* average of macroblocks' qp after aq */
Fiona Glaser's avatar
Fiona Glaser committed
89
    float qp_novbv;             /* QP for the current frame if 1-pass VBV was disabled. */
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
    /* VBV stuff */
    double buffer_size;
Fiona Glaser's avatar
Fiona Glaser committed
94
    int64_t buffer_fill_final;
Loren Merritt's avatar
Loren Merritt committed
95
    double buffer_fill;         /* planned buffer, if all in-progress frames hit their bit budget */
Loren Merritt's avatar
Loren Merritt committed
96
    double buffer_rate;         /* # of bits added to buffer_fill after each frame */
97
    double vbv_max_rate;        /* # of bits added to buffer_fill per second */
Loren Merritt's avatar
Loren Merritt committed
98
    predictor_t *pred;          /* predict frame size from satd */
99
    int single_frame_vbv;
Fiona Glaser's avatar
Fiona Glaser committed
100
    double rate_factor_max_increment; /* Don't allow RF above (CRF + this value). */
Loren Merritt's avatar
Loren Merritt committed
101 102 103 104 105

    /* ABR stuff */
    int    last_satd;
    double last_rceq;
    double cplxr_sum;           /* sum of bits*qscale/rceq */
106
    double expected_bits_sum;   /* sum of qscale2bits after rceq, ratefactor, and overflow, only includes finished frames */
Loren Merritt's avatar
Loren Merritt committed
107 108 109 110
    double wanted_bits_window;  /* target bitrate * window */
    double cbr_decay;
    double short_term_cplxsum;
    double short_term_cplxcount;
111
    double rate_factor_constant;
112 113
    double ip_offset;
    double pb_offset;
Loren Merritt's avatar
Loren Merritt committed
114

115 116
    /* 2pass stuff */
    FILE *p_stat_file_out;
117
    char *psz_stat_file_tmpname;
Fiona Glaser's avatar
Fiona Glaser committed
118 119 120 121
    FILE *p_mbtree_stat_file_out;
    char *psz_mbtree_stat_file_tmpname;
    char *psz_mbtree_stat_file_name;
    FILE *p_mbtree_stat_file_in;
122 123

    int num_entries;            /* number of ratecontrol_entry_ts */
Loren Merritt's avatar
Loren Merritt committed
124
    ratecontrol_entry_t *entry; /* FIXME: copy needed data and free this once init is done */
125
    double last_qscale;
126
    double last_qscale_for[3];  /* last qscale for a specific pict type, used for max_diff & ipb factor stuff */
127
    int last_non_b_pict_type;
128 129
    double accum_p_qp;          /* for determining I-frame quant */
    double accum_p_norm;
130
    double last_accum_p_norm;
131 132
    double lmin[3];             /* min qscale by frame type */
    double lmax[3];
Loren Merritt's avatar
Loren Merritt committed
133
    double lstep;               /* max change (multiply) in qscale per frame */
134 135 136
    uint16_t *qp_buffer[2];     /* Global buffers for converting MB-tree quantizer data. */
    int qpbuf_pos;              /* In order to handle pyramid reordering, QP buffer acts as a stack.
                                 * This value is the current position (0 or 1). */
Loren Merritt's avatar
Loren Merritt committed
137

138
    /* MBRC stuff */
Fiona Glaser's avatar
Fiona Glaser committed
139 140
    float frame_size_estimated; /* Access to this variable must be atomic: double is
                                 * not atomic on all arches we care about */
141
    double frame_size_maximum;  /* Maximum frame size due to MinCR */
142
    double frame_size_planned;
143
    double slice_size_planned;
144
    predictor_t (*row_pred)[2];
145
    predictor_t row_preds[3][2];
Loren Merritt's avatar
Loren Merritt committed
146
    predictor_t *pred_b_from_p; /* predict B-frame size from P-frame satd */
147 148 149
    int bframes;                /* # consecutive B-frames before this P-frame */
    int bframe_bits;            /* total cost of those frames */

Loren Merritt's avatar
Loren Merritt committed
150 151
    int i_zones;
    x264_zone_t *zones;
152
    x264_zone_t *prev_zone;
153 154 155

    /* hrd stuff */
    int initial_cpb_removal_delay;
Kieran Kunhya's avatar
Kieran Kunhya committed
156
    int initial_cpb_removal_delay_offset;
157 158
    double nrt_first_access_unit; /* nominal removal time */
    double previous_cpb_final_arrival_time;
Fiona Glaser's avatar
Fiona Glaser committed
159
    uint64_t hrd_multiply_denom;
160
};
Laurent Aimar's avatar
Laurent Aimar committed
161

162

163
static int parse_zones( x264_t *h );
164
static int init_pass2(x264_t *);
165
static float rate_estimate_qscale( x264_t *h );
166
static int update_vbv( x264_t *h, int bits );
167
static void update_vbv_plan( x264_t *h, int overhead );
168 169
static double predict_size( predictor_t *p, double q, double var );
static void update_predictor( predictor_t *p, double q, double var, double bits );
170

Fiona Glaser's avatar
Fiona Glaser committed
171 172 173 174 175 176 177 178 179
#define CMP_OPT_FIRST_PASS( opt, param_val )\
{\
    if( ( p = strstr( opts, opt "=" ) ) && sscanf( p, opt "=%d" , &i ) && param_val != i )\
    {\
        x264_log( h, X264_LOG_ERROR, "different " opt " setting than first pass (%d vs %d)\n", param_val, i );\
        return -1;\
    }\
}

180 181
/* Terminology:
 * qp = h.264's quantizer
182
 * qscale = linearized quantizer = Lagrange multiplier
183
 */
184
static inline double qp2qscale( double qp )
185
{
186
    return 0.85 * pow( 2.0, ( qp - 12.0 ) / 6.0 );
187
}
188
static inline double qscale2qp( double qscale )
189
{
190
    return 12.0 + 6.0 * log2( qscale/0.85 );
191 192
}

193 194 195 196
/* 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. */
197
static inline double qscale2bits( ratecontrol_entry_t *rce, double qscale )
198
{
199
    if( qscale<0.1 )
200
        qscale = 0.1;
201
    return (rce->tex_bits + .1) * pow( rce->qscale / qscale, 1.1 )
202
           + rce->mv_bits * pow( X264_MAX(rce->qscale, 1) / X264_MAX(qscale, 1), 0.5 )
203
           + rce->misc_bits;
204 205
}

206 207 208 209 210 211 212 213 214
static ALWAYS_INLINE uint32_t ac_energy_var( uint64_t sum_ssd, int shift, x264_frame_t *frame, int i )
{
    uint32_t sum = sum_ssd;
    uint32_t ssd = sum_ssd >> 32;
    frame->i_pixel_sum[i] += sum;
    frame->i_pixel_ssd[i] += ssd;
    return ssd - ((uint64_t)sum * sum >> shift);
}

Fiona Glaser's avatar
Fiona Glaser committed
215 216 217 218 219
static ALWAYS_INLINE uint32_t ac_energy_plane( x264_t *h, int mb_x, int mb_y, x264_frame_t *frame, int i )
{
    int w = i ? 8 : 16;
    int stride = frame->i_stride[i];
    int offset = h->mb.b_interlaced
220 221
        ? 16 * mb_x + w * (mb_y&~1) * stride + (mb_y&1) * stride
        : 16 * mb_x + w * mb_y * stride;
Fiona Glaser's avatar
Fiona Glaser committed
222
    stride <<= h->mb.b_interlaced;
223 224 225 226 227 228 229 230 231
    if( i )
    {
        ALIGNED_ARRAY_16( pixel, pix,[FENC_STRIDE*8] );
        h->mc.load_deinterleave_8x8x2_fenc( pix, frame->plane[1] + offset, stride );
        return ac_energy_var( h->pixf.var[PIXEL_8x8]( pix, FENC_STRIDE ), 6, frame, i )
             + ac_energy_var( h->pixf.var[PIXEL_8x8]( pix+FENC_STRIDE/2, FENC_STRIDE ), 6, frame, i );
    }
    else
        return ac_energy_var( h->pixf.var[PIXEL_16x16]( frame->plane[0] + offset, stride ), 8, frame, i );
Fiona Glaser's avatar
Fiona Glaser committed
232 233
}

234
// Find the total AC energy of the block in all planes.
235
static NOINLINE uint32_t x264_ac_energy_mb( x264_t *h, int mb_x, int mb_y, x264_frame_t *frame )
236
{
237 238 239 240
    /* This function contains annoying hacks because GCC has a habit of reordering emms
     * and putting it after floating point ops.  As a result, we put the emms at the end of the
     * function and make sure that its always called before the float math.  Noinline makes
     * sure no reordering goes on. */
Fiona Glaser's avatar
Fiona Glaser committed
241 242
    uint32_t var = ac_energy_plane( h, mb_x, mb_y, frame, 0 );
    var         += ac_energy_plane( h, mb_x, mb_y, frame, 1 );
243
    x264_emms();
244 245 246
    return var;
}

247
void x264_adaptive_quant_frame( x264_t *h, x264_frame_t *frame, float *quant_offsets )
248
{
249 250
    /* constants chosen to result in approximately the same overall bitrate as without AQ.
     * FIXME: while they're written in 5 significant digits, they're only tuned to 2. */
Anton Mitrofanov's avatar
Anton Mitrofanov committed
251 252
    float strength;
    float avg_adj = 0.f;
253 254
    /* Initialize frame stats */
    for( int i = 0; i < 3; i++ )
Fiona Glaser's avatar
Fiona Glaser committed
255
    {
256 257
        frame->i_pixel_sum[i] = 0;
        frame->i_pixel_ssd[i] = 0;
Fiona Glaser's avatar
Fiona Glaser committed
258 259
    }

260 261
    /* Degenerate cases */
    if( h->param.rc.i_aq_mode == X264_AQ_NONE || h->param.rc.f_aq_strength == 0 )
Anton Mitrofanov's avatar
Anton Mitrofanov committed
262
    {
263
        /* Need to init it anyways for MB tree */
Yusuke Nakamura's avatar
Yusuke Nakamura committed
264
        if( h->param.rc.i_aq_mode && h->param.rc.f_aq_strength == 0 )
265
        {
266 267
            if( quant_offsets )
            {
268
                for( int mb_xy = 0; mb_xy < h->mb.i_mb_count; mb_xy++ )
269 270 271 272 273 274 275 276 277 278 279 280 281
                    frame->f_qp_offset[mb_xy] = frame->f_qp_offset_aq[mb_xy] = quant_offsets[mb_xy];
                if( h->frames.b_have_lowres )
                    for( int mb_xy = 0; mb_xy < h->mb.i_mb_count; mb_xy++ )
                        frame->i_inv_qscale_factor[mb_xy] = x264_exp2fix8( frame->f_qp_offset[mb_xy] );
            }
            else
            {
                memset( frame->f_qp_offset, 0, h->mb.i_mb_count * sizeof(float) );
                memset( frame->f_qp_offset_aq, 0, h->mb.i_mb_count * sizeof(float) );
                if( h->frames.b_have_lowres )
                    for( int mb_xy = 0; mb_xy < h->mb.i_mb_count; mb_xy++ )
                        frame->i_inv_qscale_factor[mb_xy] = 256;
            }
282 283 284 285
        }
        /* Need variance data for weighted prediction */
        if( h->param.analyse.i_weighted_pred == X264_WEIGHTP_FAKE || h->param.analyse.i_weighted_pred == X264_WEIGHTP_SMART )
        {
286 287
            for( int mb_y = 0; mb_y < h->mb.i_mb_height; mb_y++ )
                for( int mb_x = 0; mb_x < h->mb.i_mb_width; mb_x++ )
288 289 290 291
                    x264_ac_energy_mb( h, mb_x, mb_y, frame );
        }
        else
            return;
Anton Mitrofanov's avatar
Anton Mitrofanov committed
292
    }
293
    /* Actual adaptive quantization */
Anton Mitrofanov's avatar
Anton Mitrofanov committed
294
    else
295 296
    {
        if( h->param.rc.i_aq_mode == X264_AQ_AUTOVARIANCE )
297
        {
298
            float bit_depth_correction = powf(1 << (BIT_DEPTH-8), 0.5f);
299
            float avg_adj_pow2 = 0.f;
300 301
            for( int mb_y = 0; mb_y < h->mb.i_mb_height; mb_y++ )
                for( int mb_x = 0; mb_x < h->mb.i_mb_width; mb_x++ )
302 303 304 305 306 307 308 309 310
                {
                    uint32_t energy = x264_ac_energy_mb( h, mb_x, mb_y, frame );
                    float qp_adj = powf( energy + 1, 0.125f );
                    frame->f_qp_offset[mb_x + mb_y*h->mb.i_mb_stride] = qp_adj;
                    avg_adj += qp_adj;
                    avg_adj_pow2 += qp_adj * qp_adj;
                }
            avg_adj /= h->mb.i_mb_count;
            avg_adj_pow2 /= h->mb.i_mb_count;
311 312
            strength = h->param.rc.f_aq_strength * avg_adj / bit_depth_correction;
            avg_adj = avg_adj - 0.5f * (avg_adj_pow2 - (14.f * bit_depth_correction)) / avg_adj;
313 314 315 316
        }
        else
            strength = h->param.rc.f_aq_strength * 1.0397f;

317 318
        for( int mb_y = 0; mb_y < h->mb.i_mb_height; mb_y++ )
            for( int mb_x = 0; mb_x < h->mb.i_mb_width; mb_x++ )
Anton Mitrofanov's avatar
Anton Mitrofanov committed
319
            {
320
                float qp_adj;
321
                int mb_xy = mb_x + mb_y*h->mb.i_mb_stride;
322 323
                if( h->param.rc.i_aq_mode == X264_AQ_AUTOVARIANCE )
                {
324
                    qp_adj = frame->f_qp_offset[mb_xy];
325 326 327 328 329
                    qp_adj = strength * (qp_adj - avg_adj);
                }
                else
                {
                    uint32_t energy = x264_ac_energy_mb( h, mb_x, mb_y, frame );
330
                    qp_adj = strength * (x264_log2( X264_MAX(energy, 1) ) - (14.427f + 2*(BIT_DEPTH-8)));
331
                }
332 333 334 335
                if( quant_offsets )
                    qp_adj += quant_offsets[mb_xy];
                frame->f_qp_offset[mb_xy] =
                frame->f_qp_offset_aq[mb_xy] = qp_adj;
336
                if( h->frames.b_have_lowres )
337
                    frame->i_inv_qscale_factor[mb_xy] = x264_exp2fix8(qp_adj);
Anton Mitrofanov's avatar
Anton Mitrofanov committed
338
            }
339 340 341 342 343 344 345
    }

    /* Remove mean from SSD calculation */
    for( int i = 0; i < 3; i++ )
    {
        uint64_t ssd = frame->i_pixel_ssd[i];
        uint64_t sum = frame->i_pixel_sum[i];
346 347 348
        int width = h->mb.i_mb_width*16>>!!i;
        int height = h->mb.i_mb_height*16>>!!i;
        frame->i_pixel_ssd[i] = ssd - (sum * sum + width * height / 2) / (width * height);
349
    }
350 351
}

352
int x264_macroblock_tree_read( x264_t *h, x264_frame_t *frame, float *quant_offsets )
Fiona Glaser's avatar
Fiona Glaser committed
353 354 355 356
{
    x264_ratecontrol_t *rc = h->rc;
    uint8_t i_type_actual = rc->entry[frame->i_frame].pict_type;

357
    if( rc->entry[frame->i_frame].kept_as_ref )
Fiona Glaser's avatar
Fiona Glaser committed
358 359
    {
        uint8_t i_type;
360 361 362 363 364
        if( rc->qpbuf_pos < 0 )
        {
            do
            {
                rc->qpbuf_pos++;
Fiona Glaser's avatar
Fiona Glaser committed
365

366 367 368 369
                if( !fread( &i_type, 1, 1, rc->p_mbtree_stat_file_in ) )
                    goto fail;
                if( fread( rc->qp_buffer[rc->qpbuf_pos], sizeof(uint16_t), h->mb.i_mb_count, rc->p_mbtree_stat_file_in ) != h->mb.i_mb_count )
                    goto fail;
Fiona Glaser's avatar
Fiona Glaser committed
370

371 372 373 374 375 376
                if( i_type != i_type_actual && rc->qpbuf_pos == 1 )
                {
                    x264_log(h, X264_LOG_ERROR, "MB-tree frametype %d doesn't match actual frametype %d.\n", i_type, i_type_actual);
                    return -1;
                }
            } while( i_type != i_type_actual );
Fiona Glaser's avatar
Fiona Glaser committed
377 378
        }

379
        for( int i = 0; i < h->mb.i_mb_count; i++ )
380
        {
381
            frame->f_qp_offset[i] = ((float)(int16_t)endian_fix16( rc->qp_buffer[rc->qpbuf_pos][i] )) * (1/256.0);
382 383 384
            if( h->frames.b_have_lowres )
                frame->i_inv_qscale_factor[i] = x264_exp2fix8(frame->f_qp_offset[i]);
        }
385
        rc->qpbuf_pos--;
Fiona Glaser's avatar
Fiona Glaser committed
386 387
    }
    else
388
        x264_stack_align( x264_adaptive_quant_frame, h, frame, quant_offsets );
Fiona Glaser's avatar
Fiona Glaser committed
389 390 391 392 393 394
    return 0;
fail:
    x264_log(h, X264_LOG_ERROR, "Incomplete MB-tree stats file.\n");
    return -1;
}

395 396 397 398
int x264_reference_build_list_optimal( x264_t *h )
{
    ratecontrol_entry_t *rce = h->rc->rce;
    x264_frame_t *frames[16];
Dylan Yudaken's avatar
Dylan Yudaken committed
399 400
    x264_weight_t weights[16][3];
    int refcount[16];
401 402 403 404 405

    if( rce->refs != h->i_ref0 )
        return -1;

    memcpy( frames, h->fref0, sizeof(frames) );
Dylan Yudaken's avatar
Dylan Yudaken committed
406 407
    memcpy( refcount, rce->refcount, sizeof(refcount) );
    memcpy( weights, h->fenc->weight, sizeof(weights) );
Dylan Yudaken's avatar
Dylan Yudaken committed
408
    memset( &h->fenc->weight[1][0], 0, sizeof(x264_weight_t[15][3]) );
409 410 411

    /* For now don't reorder ref 0; it seems to lower quality
       in most cases due to skips. */
412
    for( int ref = 1; ref < h->i_ref0; ref++ )
413 414 415
    {
        int max = -1;
        int bestref = 1;
Dylan Yudaken's avatar
Dylan Yudaken committed
416

417
        for( int i = 1; i < h->i_ref0; i++ )
418 419
            /* Favor lower POC as a tiebreaker. */
            COPY2_IF_GT( max, refcount[i], bestref, i );
Dylan Yudaken's avatar
Dylan Yudaken committed
420 421 422 423 424

        /* FIXME: If there are duplicates from frames other than ref0 then it is possible
         * that the optimal ordering doesnt place every duplicate. */

        refcount[bestref] = -1;
425
        h->fref0[ref] = frames[bestref];
Dylan Yudaken's avatar
Dylan Yudaken committed
426
        memcpy( h->fenc->weight[ref], weights[bestref], sizeof(weights[bestref]) );
427 428 429 430 431
    }

    return 0;
}

Fiona Glaser's avatar
Fiona Glaser committed
432 433 434
static char *x264_strcat_filename( char *input, char *suffix )
{
    char *output = x264_malloc( strlen( input ) + strlen( suffix ) + 1 );
435 436
    if( !output )
        return NULL;
Fiona Glaser's avatar
Fiona Glaser committed
437 438 439 440 441
    strcpy( output, input );
    strcat( output, suffix );
    return output;
}

442 443 444 445 446 447
void x264_ratecontrol_init_reconfigurable( x264_t *h, int b_init )
{
    x264_ratecontrol_t *rc = h->rc;
    if( !b_init && rc->b_2pass )
        return;

448 449 450 451 452 453 454 455 456 457
    if( h->param.rc.i_rc_method == X264_RC_CRF )
    {
        /* Arbitrary rescaling to make CRF somewhat similar to QP.
         * Try to compensate for MB-tree's effects as well. */
        double base_cplx = h->mb.i_mb_count * (h->param.i_bframe ? 120 : 80);
        double mbtree_offset = h->param.rc.b_mb_tree ? (1.0-h->param.rc.f_qcompress)*13.5 : 0;
        rc->rate_factor_constant = pow( base_cplx, 1 - rc->qcompress )
                                 / qp2qscale( h->param.rc.f_rf_constant + mbtree_offset );
    }

458 459 460 461 462 463 464 465 466 467 468 469 470
    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 < (int)(h->param.rc.i_vbv_max_bitrate / rc->fps) )
        {
            h->param.rc.i_vbv_buffer_size = h->param.rc.i_vbv_max_bitrate / rc->fps;
            x264_log( h, X264_LOG_WARNING, "VBV buffer size cannot be smaller than one frame, using %d kbit\n",
                      h->param.rc.i_vbv_buffer_size );
        }

        /* We don't support changing the ABR bitrate right now,
           so if the stream starts as CBR, keep it CBR. */
        if( rc->b_vbv_min_rate )
            h->param.rc.i_vbv_max_bitrate = h->param.rc.i_bitrate;
471 472 473 474 475

        int vbv_buffer_size = h->param.rc.i_vbv_buffer_size * 1000;
        int vbv_max_bitrate = h->param.rc.i_vbv_max_bitrate * 1000;

        /* Init HRD */
Fiona Glaser's avatar
Fiona Glaser committed
476 477
        h->sps->vui.hrd.i_bit_rate_unscaled = vbv_max_bitrate;
        h->sps->vui.hrd.i_cpb_size_unscaled = vbv_buffer_size;
478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503
        if( h->param.i_nal_hrd && b_init )
        {
            h->sps->vui.hrd.i_cpb_cnt = 1;
            h->sps->vui.hrd.b_cbr_hrd = h->param.i_nal_hrd == X264_NAL_HRD_CBR;
            h->sps->vui.hrd.i_time_offset_length = 0;

            #define BR_SHIFT  6
            #define CPB_SHIFT 4

            int bitrate = 1000*h->param.rc.i_vbv_max_bitrate;
            int bufsize = 1000*h->param.rc.i_vbv_buffer_size;

            // normalize HRD size and rate to the value / scale notation
            h->sps->vui.hrd.i_bit_rate_scale = x264_clip3( x264_ctz( bitrate ) - BR_SHIFT, 0, 15 );
            h->sps->vui.hrd.i_bit_rate_value = bitrate >> ( h->sps->vui.hrd.i_bit_rate_scale + BR_SHIFT );
            h->sps->vui.hrd.i_bit_rate_unscaled = h->sps->vui.hrd.i_bit_rate_value << ( h->sps->vui.hrd.i_bit_rate_scale + BR_SHIFT );
            h->sps->vui.hrd.i_cpb_size_scale = x264_clip3( x264_ctz( bufsize ) - CPB_SHIFT, 0, 15 );
            h->sps->vui.hrd.i_cpb_size_value = bufsize >> ( h->sps->vui.hrd.i_cpb_size_scale + CPB_SHIFT );
            h->sps->vui.hrd.i_cpb_size_unscaled = h->sps->vui.hrd.i_cpb_size_value << ( h->sps->vui.hrd.i_cpb_size_scale + CPB_SHIFT );

            #undef CPB_SHIFT
            #undef BR_SHIFT

            // arbitrary
            #define MAX_DURATION 0.5

504
            int max_cpb_output_delay = X264_MIN( h->param.i_keyint_max * MAX_DURATION * h->sps->vui.i_time_scale / h->sps->vui.i_num_units_in_tick, INT_MAX );
505 506 507 508
            int max_dpb_output_delay = h->sps->vui.i_max_dec_frame_buffering * MAX_DURATION * h->sps->vui.i_time_scale / h->sps->vui.i_num_units_in_tick;
            int max_delay = (int)(90000.0 * (double)h->sps->vui.hrd.i_cpb_size_unscaled / h->sps->vui.hrd.i_bit_rate_unscaled + 0.5);

            h->sps->vui.hrd.i_initial_cpb_removal_delay_length = 2 + x264_clip3( 32 - x264_clz( max_delay ), 4, 22 );
509 510
            h->sps->vui.hrd.i_cpb_removal_delay_length = x264_clip3( 32 - x264_clz( max_cpb_output_delay ), 4, 31 );
            h->sps->vui.hrd.i_dpb_output_delay_length  = x264_clip3( 32 - x264_clz( max_dpb_output_delay ), 4, 31 );
511 512 513

            #undef MAX_DURATION

Fiona Glaser's avatar
Fiona Glaser committed
514 515
            vbv_buffer_size = h->sps->vui.hrd.i_cpb_size_unscaled;
            vbv_max_bitrate = h->sps->vui.hrd.i_bit_rate_unscaled;
516 517 518 519 520 521 522 523 524 525
        }
        else if( h->param.i_nal_hrd && !b_init )
        {
            x264_log( h, X264_LOG_WARNING, "VBV parameters cannot be changed when NAL HRD is in use\n" );
            return;
        }

        rc->buffer_rate = vbv_max_bitrate / rc->fps;
        rc->vbv_max_rate = vbv_max_bitrate;
        rc->buffer_size = vbv_buffer_size;
526 527 528
        rc->single_frame_vbv = rc->buffer_rate * 1.1 > rc->buffer_size;
        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);
Fiona Glaser's avatar
Fiona Glaser committed
529 530 531 532 533 534 535 536 537
        if( h->param.rc.i_rc_method == X264_RC_CRF && h->param.rc.f_rf_constant_max )
        {
            rc->rate_factor_max_increment = h->param.rc.f_rf_constant_max - h->param.rc.f_rf_constant;
            if( rc->rate_factor_max_increment <= 0 )
            {
                x264_log( h, X264_LOG_WARNING, "CRF max must be greater than CRF\n" );
                rc->rate_factor_max_increment = 0;
            }
        }
538 539 540 541
        if( b_init )
        {
            if( h->param.rc.f_vbv_buffer_init > 1. )
                h->param.rc.f_vbv_buffer_init = x264_clip3f( h->param.rc.f_vbv_buffer_init / h->param.rc.i_vbv_buffer_size, 0, 1 );
Kieran Kunhya's avatar
Kieran Kunhya committed
542
            h->param.rc.f_vbv_buffer_init = x264_clip3f( X264_MAX( h->param.rc.f_vbv_buffer_init, rc->buffer_rate / rc->buffer_size ), 0, 1);
Fiona Glaser's avatar
Fiona Glaser committed
543
            rc->buffer_fill_final = rc->buffer_size * h->param.rc.f_vbv_buffer_init * h->sps->vui.i_time_scale;
544 545 546 547 548 549 550 551
            rc->b_vbv = 1;
            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;
        }
    }
}

552
int x264_ratecontrol_new( x264_t *h )
Laurent Aimar's avatar
Laurent Aimar committed
553
{
554
    x264_ratecontrol_t *rc;
555

556
    x264_emms();
557

558 559
    CHECKED_MALLOCZERO( h->rc, h->param.i_threads * sizeof(x264_ratecontrol_t) );
    rc = h->rc;
560

561 562
    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
563

564
    /* FIXME: use integers */
565
    if( h->param.i_fps_num > 0 && h->param.i_fps_den > 0 )
566 567 568 569
        rc->fps = (float) h->param.i_fps_num / h->param.i_fps_den;
    else
        rc->fps = 25.0;

Fiona Glaser's avatar
Fiona Glaser committed
570 571 572 573 574 575 576 577
    if( h->param.rc.b_mb_tree )
    {
        h->param.rc.f_pb_factor = 1;
        rc->qcompress = 1;
    }
    else
        rc->qcompress = h->param.rc.f_qcompress;

578
    rc->bitrate = h->param.rc.i_bitrate * 1000.;
Loren Merritt's avatar
Loren Merritt committed
579
    rc->rate_tolerance = h->param.rc.f_rate_tolerance;
580
    rc->nmb = h->mb.i_mb_count;
Loren Merritt's avatar
Loren Merritt committed
581 582 583
    rc->last_non_b_pict_type = -1;
    rc->cbr_decay = 1.0;

584
    if( h->param.rc.i_rc_method == X264_RC_CRF && h->param.rc.b_stat_read )
585
    {
586
        x264_log(h, X264_LOG_ERROR, "constant rate-factor is incompatible with 2pass.\n");
587 588
        return -1;
    }
589 590 591

    x264_ratecontrol_init_reconfigurable( h, 1 );

Fiona Glaser's avatar
Fiona Glaser committed
592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608
    if( h->param.i_nal_hrd )
    {
        uint64_t denom = (uint64_t)h->sps->vui.hrd.i_bit_rate_unscaled * h->sps->vui.i_time_scale;
        uint64_t num = 180000;
        x264_reduce_fraction64( &num, &denom );
        rc->hrd_multiply_denom = 180000 / num;

        double bits_required = log2( 180000 / rc->hrd_multiply_denom )
                             + log2( h->sps->vui.i_time_scale )
                             + log2( h->sps->vui.hrd.i_cpb_size_unscaled );
        if( bits_required >= 63 )
        {
            x264_log( h, X264_LOG_ERROR, "HRD with very large timescale and bufsize not supported\n" );
            return -1;
        }
    }

609
    if( rc->rate_tolerance < 0.01 )
Fiona Glaser's avatar
Fiona Glaser committed
610
    {
611
        x264_log(h, X264_LOG_WARNING, "bitrate tolerance too small, using .01\n");
612 613
        rc->rate_tolerance = 0.01;
    }
614

615
    h->mb.b_variable_qp = rc->b_vbv || h->param.rc.i_aq_mode;
616

Loren Merritt's avatar
Loren Merritt committed
617 618
    if( rc->b_abr )
    {
619
        /* FIXME ABR_INIT_QP is actually used only in CRF */
620
#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
621 622
        rc->accum_p_norm = .01;
        rc->accum_p_qp = ABR_INIT_QP * rc->accum_p_norm;
623
        /* estimated ratio that produces a reasonable QP for the first I-frame */
Fiona Glaser's avatar
Fiona Glaser committed
624
        rc->cplxr_sum = .01 * pow( 7.0e5, rc->qcompress ) * pow( h->mb.i_mb_count, 0.5 );
625 626
        rc->wanted_bits_window = 1.0 * rc->bitrate / rc->fps;
        rc->last_non_b_pict_type = SLICE_TYPE_I;
627 628
    }

629 630
    rc->ip_offset = 6.0 * log2f( h->param.rc.f_ip_factor );
    rc->pb_offset = 6.0 * log2f( h->param.rc.f_pb_factor );
Loren Merritt's avatar
Loren Merritt committed
631
    rc->qp_constant[SLICE_TYPE_P] = h->param.rc.i_qp_constant;
632 633
    rc->qp_constant[SLICE_TYPE_I] = x264_clip3( h->param.rc.i_qp_constant - rc->ip_offset + 0.5, 0, QP_MAX );
    rc->qp_constant[SLICE_TYPE_B] = x264_clip3( h->param.rc.i_qp_constant + rc->pb_offset + 0.5, 0, QP_MAX );
Fiona Glaser's avatar
Fiona Glaser committed
634
    h->mb.ip_offset = rc->ip_offset + 0.5;
635

Loren Merritt's avatar
Loren Merritt committed
636
    rc->lstep = pow( 2, h->param.rc.i_qp_step / 6.0 );
637
    rc->last_qscale = qp2qscale( 26 );
Fiona Glaser's avatar
Fiona Glaser committed
638 639
    int num_preds = h->param.b_sliced_threads * h->param.i_threads + 1;
    CHECKED_MALLOC( rc->pred, 5 * sizeof(predictor_t) * num_preds );
640
    CHECKED_MALLOC( rc->pred_b_from_p, sizeof(predictor_t) );
641
    for( int i = 0; i < 3; i++ )
642
    {
643
        rc->last_qscale_for[i] = qp2qscale( ABR_INIT_QP );
644 645
        rc->lmin[i] = qp2qscale( h->param.rc.i_qp_min );
        rc->lmax[i] = qp2qscale( h->param.rc.i_qp_max );
646
        for( int j = 0; j < num_preds; j++ )
Fiona Glaser's avatar
Fiona Glaser committed
647 648 649 650 651 652
        {
            rc->pred[i+j*5].coeff= 2.0;
            rc->pred[i+j*5].count= 1.0;
            rc->pred[i+j*5].decay= 0.5;
            rc->pred[i+j*5].offset= 0.0;
        }
653
        for( int j = 0; j < 2; j++ )
654 655 656 657 658 659
        {
            rc->row_preds[i][j].coeff= .25;
            rc->row_preds[i][j].count= 1.0;
            rc->row_preds[i][j].decay= 0.5;
            rc->row_preds[i][j].offset= 0.0;
        }
660
    }
Loren Merritt's avatar
Loren Merritt committed
661
    *rc->pred_b_from_p = rc->pred[0];
662

663
    if( parse_zones( h ) < 0 )
664 665
    {
        x264_log( h, X264_LOG_ERROR, "failed to parse zones\n" );
666
        return -1;
667
    }
Loren Merritt's avatar
Loren Merritt committed
668

669 670 671
    /* Load stat file and init 2pass algo */
    if( h->param.rc.b_stat_read )
    {
672
        char *p, *stats_in, *stats_buf;
673 674 675

        /* read 1st pass stats */
        assert( h->param.rc.psz_stat_in );
676 677
        stats_buf = stats_in = x264_slurp_file( h->param.rc.psz_stat_in );
        if( !stats_buf )
678 679 680 681
        {
            x264_log(h, X264_LOG_ERROR, "ratecontrol_init: can't open stats file\n");
            return -1;
        }
Fiona Glaser's avatar
Fiona Glaser committed
682 683 684
        if( h->param.rc.b_mb_tree )
        {
            char *mbtree_stats_in = x264_strcat_filename( h->param.rc.psz_stat_in, ".mbtree" );
685 686
            if( !mbtree_stats_in )
                return -1;
Fiona Glaser's avatar
Fiona Glaser committed
687 688 689 690 691 692 693 694
            rc->p_mbtree_stat_file_in = fopen( mbtree_stats_in, "rb" );
            x264_free( mbtree_stats_in );
            if( !rc->p_mbtree_stat_file_in )
            {
                x264_log(h, X264_LOG_ERROR, "ratecontrol_init: can't open mbtree stats file\n");
                return -1;
            }
        }
695

696 697 698
        /* check whether 1st pass options were compatible with current options */
        if( !strncmp( stats_buf, "#options:", 9 ) )
        {
699
            int i, j;
700
            uint32_t k, l;
701 702 703 704 705 706
            char *opts = stats_buf;
            stats_in = strchr( stats_buf, '\n' );
            if( !stats_in )
                return -1;
            *stats_in = '\0';
            stats_in++;
707 708 709 710 711 712 713 714 715 716 717
            if( sscanf( opts, "#options: %dx%d", &i, &j ) != 2 )
            {
                x264_log( h, X264_LOG_ERROR, "resolution specified in stats file not valid\n" );
                return -1;
            }
            else if( h->param.rc.b_mb_tree && (i != h->param.i_width || j != h->param.i_height)  )
            {
                x264_log( h, X264_LOG_ERROR, "MB-tree doesn't support different resolution than 1st pass (%dx%d vs %dx%d)\n",
                          h->param.i_width, h->param.i_height, i, j );
                return -1;
            }
718

719
            if( ( p = strstr( opts, "timebase=" ) ) && sscanf( p, "timebase=%u/%u", &k, &l ) != 2 )
720 721 722 723
            {
                x264_log( h, X264_LOG_ERROR, "timebase specified in stats file not valid\n" );
                return -1;
            }
724
            if( k != h->param.i_timebase_num || l != h->param.i_timebase_den )
725
            {
726 727
                x264_log( h, X264_LOG_ERROR, "timebase mismatch with 1st pass (%u/%u vs %u/%u)\n",
                          h->param.i_timebase_num, h->param.i_timebase_den, k, l );
728 729 730
                return -1;
            }

731
            CMP_OPT_FIRST_PASS( "weightp", X264_MAX( 0, h->param.analyse.i_weighted_pred ) );
Fiona Glaser's avatar
Fiona Glaser committed
732 733 734
            CMP_OPT_FIRST_PASS( "bframes", h->param.i_bframe );
            CMP_OPT_FIRST_PASS( "b_pyramid", h->param.i_bframe_pyramid );
            CMP_OPT_FIRST_PASS( "intra_refresh", h->param.b_intra_refresh );
Lamont Alston's avatar
Lamont Alston committed
735
            CMP_OPT_FIRST_PASS( "open_gop", h->param.i_open_gop );
736

737 738 739 740 741 742 743 744 745 746 747 748 749 750
            if( (p = strstr( opts, "keyint=" )) )
            {
                p += 7;
                char buf[13] = "infinite ";
                if( h->param.i_keyint_max != X264_KEYINT_MAX_INFINITE )
                    sprintf( buf, "%d ", h->param.i_keyint_max );
                if( strncmp( p, buf, strlen(buf) ) )
                {
                    x264_log( h, X264_LOG_ERROR, "different keyint setting than first pass (%.*s vs %.*s)\n",
                              strlen(buf)-1, buf, strcspn(p, " "), p );
                    return -1;
                }
            }

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

754 755 756 757 758 759
            if( !strstr( opts, "direct=3" ) && h->param.analyse.i_direct_mv_pred == X264_DIRECT_PRED_AUTO )
            {
                x264_log( h, X264_LOG_WARNING, "direct=auto not used on the first pass\n" );
                h->mb.b_direct_auto_write = 1;
            }

760 761
            if( ( p = strstr( opts, "b_adapt=" ) ) && sscanf( p, "b_adapt=%d", &i ) && i >= X264_B_ADAPT_NONE && i <= X264_B_ADAPT_TRELLIS )
                h->param.i_bframe_adaptive = i;
762
            else if( h->param.i_bframe )
763 764 765 766
            {
                x264_log( h, X264_LOG_ERROR, "b_adapt method specified in stats file not valid\n" );
                return -1;
            }
Fiona Glaser's avatar
Fiona Glaser committed
767

768
            if( (h->param.rc.b_mb_tree || h->param.rc.i_vbv_buffer_size) && ( p = strstr( opts, "rc_lookahead=" ) ) && sscanf( p, "rc_lookahead=%d", &i ) )
Fiona Glaser's avatar
Fiona Glaser committed
769
                h->param.rc.i_lookahead = i;
770 771
        }

772 773
        /* find number of pics */
        p = stats_in;
774 775 776 777
        int num_entries;
        for( num_entries = -1; p; num_entries++ )
            p = strchr( p + 1, ';' );
        if( !num_entries )
Loren Merritt's avatar
Loren Merritt committed
778 779 780
        {
            x264_log(h, X264_LOG_ERROR, "empty stats file\n");
            return -1;
781
        }
782
        rc->num_entries = num_entries;
783

784
        if( h->param.i_frame_total < rc->num_entries && h->param.i_frame_total > 0 )
785 786 787 788
        {
            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 );
        }
789
        if( h->param.i_frame_total > rc->num_entries )
790 791 792 793 794 795
        {
            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;
        }

796
        CHECKED_MALLOCZERO( rc->entry, rc->num_entries * sizeof(ratecontrol_entry_t) );
797 798

        /* init all to skipped p frames */
799
        for( int i = 0; i < rc->num_entries; i++ )
Fiona Glaser's avatar
Fiona Glaser committed
800
        {
801
            ratecontrol_entry_t *rce = &rc->entry[i];
802
            rce->pict_type = SLICE_TYPE_P;
803
            rce->qscale = rce->new_qscale = qp2qscale( 20 );
804 805 806 807 808 809
            rce->misc_bits = rc->nmb + 10;
            rce->new_qp = 0;
        }

        /* read stats */
        p = stats_in;
810
        for( int i = 0; i < rc->num_entries; i++ )
Fiona Glaser's avatar
Fiona Glaser committed
811
        {
812
            ratecontrol_entry_t *rce;
813 814
            int frame_number;
            char pict_type;
815 816 817
            int e;
            char *next;
            float qp;
818
            int ref;
819 820

            next= strchr(p, ';');
821 822 823
            if( next )
                *next++ = 0; //sscanf is unbelievably slow on long strings
            e = sscanf( p, " in:%d ", &frame_number );
824

825
            if( frame_number < 0 || frame_number >= rc->num_entries )
Loren Merritt's avatar
Loren Merritt committed
826
            {
827
                x264_log( h, X264_LOG_ERROR, "bad frame number (%d) at stats line %d\n", frame_number, i );
Loren Merritt's avatar
Loren Merritt committed
828 829
                return -1;
            }
830
            rce = &rc->entry[frame_number];
Loren Merritt's avatar
Loren Merritt committed
831
            rce->direct_mode = 0;
832

833
            e += sscanf( p, " in:%*d out:%*d type:%c dur:%d cpbdur:%d q:%f tex:%d mv:%d misc:%d imb:%d pmb:%d smb:%d d:%c",
834
                   &pict_type, &rce->i_duration, &rce->i_cpb_duration, &qp, &rce->tex_bits,
Loren Merritt's avatar
Loren Merritt committed
835
                   &rce->mv_bits, &rce->misc_bits, &rce->i_count, &rce->p_count,
836
                   &rce->s_count, &rce->direct_mode );
837

838 839 840 841 842 843 844 845 846 847 848 849 850 851
            p = strstr( p, "ref:" );
            if( !p )
                goto parse_error;
            p += 4;
            for( ref = 0; ref < 16; ref++ )
            {
                if( sscanf( p, " %d", &rce->refcount[ref] ) != 1 )
                    break;
                p = strchr( p+1, ' ' );
                if( !p )
                    goto parse_error;
            }
            rce->refs = ref;

Dylan Yudaken's avatar
Dylan Yudaken committed
852 853 854 855
            /* find weights */
            rce->i_weight_denom = -1;
            char *w = strchr( p, 'w' );
            if( w )
856
                if( sscanf( w, "w:%hd,%hd,%hd", &rce->i_weight_denom, &rce->weight[0], &rce->weight[1] ) != 3 )
Dylan Yudaken's avatar
Dylan Yudaken committed
857 858
                    rce->i_weight_denom = -1;

859 860 861
            if( pict_type != 'b' )
                rce->kept_as_ref = 1;
            switch( pict_type )
Fiona Glaser's avatar
Fiona Glaser committed
862
            {
863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882
                case 'I':
                    rce->frame_type = X264_TYPE_IDR;
                    rce->pict_type  = SLICE_TYPE_I;
                    break;
                case 'i':
                    rce->frame_type = X264_TYPE_I;
                    rce->pict_type  = SLICE_TYPE_I;
                    break;
                case 'P':
                    rce->frame_type = X264_TYPE_P;
                    rce->pict_type  = SLICE_TYPE_P;
                    break;
                case 'B':
                    rce->frame_type = X264_TYPE_BREF;
                    rce->pict_type  = SLICE_TYPE_B;
                    break;
                case 'b':
                    rce->frame_type = X264_TYPE_B;
                    rce->pict_type  = SLICE_TYPE_B;
                    break;
883 884
                default:  e = -1; break;
            }
885
            if( e < 12 )
Fiona Glaser's avatar
Fiona Glaser committed
886
            {
887
parse_error:
888
                x264_log( h, X264_LOG_ERROR, "statistics are damaged at line %d, parser out=%d\n", i, e );
889 890
                return -1;
            }
891
            rce->qscale = qp2qscale( qp );
892 893 894
            p = next;
        }

895
        x264_free( stats_buf );
896

897
        if( h->param.rc.i_rc_method == X264_RC_ABR )
898
        {
899 900
            if( init_pass2( h ) < 0 )
                return -1;
Loren Merritt's avatar
Loren Merritt committed
901
        } /* else we're using constant quant, so no need to run the bitrate allocation */
902 903 904
    }

    /* Open output file */
905 906
    /* 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 */
907 908
    if( h->param.rc.b_stat_write )
    {
909
        char *p;
Fiona Glaser's avatar
Fiona Glaser committed
910
        rc->psz_stat_file_tmpname = x264_strcat_filename( h->param.rc.psz_stat_out, ".temp" );
911 912
        if( !rc->psz_stat_file_tmpname )
            return -1;
913 914

        rc->p_stat_file_out = fopen( rc->psz_stat_file_tmpname, "wb" );
915 916 917 918 919
        if( rc->p_stat_file_out == NULL )
        {
            x264_log(h, X264_LOG_ERROR, "ratecontrol_init: can't open stats file\n");
            return -1;
        }
920 921

        p = x264_param2string( &h->param, 1 );
922 923
        if( p )
            fprintf( rc->p_stat_file_out, "#options: %s\n", p );
924
        x264_free( p );
Fiona Glaser's avatar
Fiona Glaser committed
925 926 927 928
        if( h->param.rc.b_mb_tree && !h->param.rc.b_stat_read )
        {
            rc->psz_mbtree_stat_file_tmpname = x264_strcat_filename( h->param.rc.psz_stat_out, ".mbtree.temp" );
            rc->psz_mbtree_stat_file_name = x264_strcat_filename( h->param.rc.psz_stat_out, ".mbtree" );
929 930
            if( !rc->psz_mbtree_stat_file_tmpname || !rc->psz_mbtree_stat_file_name )
                return -1;
Fiona Glaser's avatar
Fiona Glaser committed
931 932 933 934 935 936 937 938 939 940 941

            rc->p_mbtree_stat_file_out = fopen( rc->psz_mbtree_stat_file_tmpname, "wb" );
            if( rc->p_mbtree_stat_file_out == NULL )
            {
                x264_log(h, X264_LOG_ERROR, "ratecontrol_init: can't open mbtree stats file\n");
                return -1;
            }
        }
    }

    if( h->param.rc.b_mb_tree && (h->param.rc.b_stat_read || h->param.rc.b_stat_write) )
942 943 944 945 946 947
    {
        CHECKED_MALLOC( rc->qp_buffer[0], h->mb.i_mb_count * sizeof(uint16_t) );
        if( h->param.i_bframe_pyramid && h->param.rc.b_stat_read )
            CHECKED_MALLOC( rc->qp_buffer[1], h->mb.i_mb_count * sizeof(uint16_t) );
        rc->qpbuf_pos = -1;
    }
948

949
    for( int i = 0; i<h->param.i_threads; i++ )
Loren Merritt's avatar
Loren Merritt committed
950 951
    {
        h->thread[i]->rc = rc+i;
952
        if( i )
953
        {
954
            rc[i] = rc[0];
Loren Merritt's avatar
Loren Merritt committed
955
            h->thread[i]->param = h->param;
956
            h->thread[i]->mb.b_variable_qp = h->mb.b_variable_qp;
957
        }
Loren Merritt's avatar
Loren Merritt committed
958 959
    }

960
    return 0;
961 962
fail:
    return -1;
Laurent Aimar's avatar
Laurent Aimar committed
963 964
}

965 966 967
static int parse_zone( x264_t *h, x264_zone_t *z, char *p )
{
    int len = 0;
968
    char *tok, UNUSED *saveptr=NULL;
969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984
    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;
985
    CHECKED_MALLOC( z->param, sizeof(x264_param_t) );
986
    memcpy( z->param, &h->param, sizeof(x264_param_t) );
987
    z->param->param_free = x264_free;
988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003
    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<