ratecontrol.c 99.8 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[5];
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;
Loren Merritt's avatar
Loren Merritt committed
94 95
    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
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 126 127
    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;
128 129
    double accum_p_qp;          /* for determining I-frame quant */
    double accum_p_norm;
130
    double last_accum_p_norm;
131
    double lmin[5];             /* min qscale by frame type */
132
    double lmax[5];
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;
Fiona Glaser's avatar
Fiona Glaser committed
144
    double max_frame_error;
145 146
    predictor_t (*row_pred)[2];
    predictor_t row_preds[5][2];
Loren Merritt's avatar
Loren Merritt committed
147
    predictor_t *pred_b_from_p; /* predict B-frame size from P-frame satd */
148 149 150
    int bframes;                /* # consecutive B-frames before this P-frame */
    int bframe_bits;            /* total cost of those frames */

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

    /* hrd stuff */
    int initial_cpb_removal_delay;
Kieran Kunhya's avatar
Kieran Kunhya committed
157
    int initial_cpb_removal_delay_offset;
158 159
    double nrt_first_access_unit; /* nominal removal time */
    double previous_cpb_final_arrival_time;
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
}

Fiona Glaser's avatar
Fiona Glaser committed
206 207 208 209 210 211 212 213 214 215 216 217
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 shift = i ? 6 : 8;
    int stride = frame->i_stride[i];
    int offset = h->mb.b_interlaced
        ? w * (mb_x + (mb_y&~1) * stride) + (mb_y&1) * stride
        : w * (mb_x + mb_y * stride);
    int pix = i ? PIXEL_8x8 : PIXEL_16x16;
    stride <<= h->mb.b_interlaced;
    uint64_t res = h->pixf.var[pix]( frame->plane[i] + offset, stride );
    uint32_t sum = (uint32_t)res;
218 219 220 221
    uint32_t ssd = res >> 32;
    frame->i_pixel_sum[i] += sum;
    frame->i_pixel_ssd[i] += ssd;
    return ssd - (sum * sum >> shift);
Fiona Glaser's avatar
Fiona Glaser committed
222 223
}

224
// Find the total AC energy of the block in all planes.
225
static NOINLINE uint32_t x264_ac_energy_mb( x264_t *h, int mb_x, int mb_y, x264_frame_t *frame )
226
{
227 228 229 230
    /* 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
231 232 233
    uint32_t var = ac_energy_plane( h, mb_x, mb_y, frame, 0 );
    var         += ac_energy_plane( h, mb_x, mb_y, frame, 1 );
    var         += ac_energy_plane( h, mb_x, mb_y, frame, 2 );
234
    x264_emms();
235 236 237
    return var;
}

238
void x264_adaptive_quant_frame( x264_t *h, x264_frame_t *frame, float *quant_offsets )
239
{
240 241
    /* 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
242 243
    float strength;
    float avg_adj = 0.f;
244 245
    /* Initialize frame stats */
    for( int i = 0; i < 3; i++ )
Fiona Glaser's avatar
Fiona Glaser committed
246
    {
247 248
        frame->i_pixel_sum[i] = 0;
        frame->i_pixel_ssd[i] = 0;
Fiona Glaser's avatar
Fiona Glaser committed
249 250
    }

251 252
    /* 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
253
    {
254
        /* Need to init it anyways for MB tree */
Yusuke Nakamura's avatar
Yusuke Nakamura committed
255
        if( h->param.rc.i_aq_mode && h->param.rc.f_aq_strength == 0 )
256
        {
257 258
            if( quant_offsets )
            {
259
                for( int mb_xy = 0; mb_xy < h->mb.i_mb_count; mb_xy++ )
260 261 262 263 264 265 266 267 268 269 270 271 272
                    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;
            }
273 274 275 276
        }
        /* 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 )
        {
277 278
            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++ )
279 280 281 282
                    x264_ac_energy_mb( h, mb_x, mb_y, frame );
        }
        else
            return;
Anton Mitrofanov's avatar
Anton Mitrofanov committed
283
    }
284
    /* Actual adaptive quantization */
Anton Mitrofanov's avatar
Anton Mitrofanov committed
285
    else
286 287
    {
        if( h->param.rc.i_aq_mode == X264_AQ_AUTOVARIANCE )
288
        {
289
            float avg_adj_pow2 = 0.f;
290 291
            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++ )
292 293 294 295 296 297 298 299 300 301 302 303 304 305 306
                {
                    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;
            strength = h->param.rc.f_aq_strength * avg_adj;
            avg_adj = avg_adj - 0.5f * (avg_adj_pow2 - 14.f) / avg_adj;
        }
        else
            strength = h->param.rc.f_aq_strength * 1.0397f;

307 308
        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
309
            {
310
                float qp_adj;
311
                int mb_xy = mb_x + mb_y*h->mb.i_mb_stride;
312 313
                if( h->param.rc.i_aq_mode == X264_AQ_AUTOVARIANCE )
                {
314
                    qp_adj = frame->f_qp_offset[mb_xy];
315 316 317 318 319 320 321
                    qp_adj = strength * (qp_adj - avg_adj);
                }
                else
                {
                    uint32_t energy = x264_ac_energy_mb( h, mb_x, mb_y, frame );
                    qp_adj = strength * (x264_log2( X264_MAX(energy, 1) ) - 14.427f);
                }
322 323 324 325
                if( quant_offsets )
                    qp_adj += quant_offsets[mb_xy];
                frame->f_qp_offset[mb_xy] =
                frame->f_qp_offset_aq[mb_xy] = qp_adj;
326
                if( h->frames.b_have_lowres )
327
                    frame->i_inv_qscale_factor[mb_xy] = x264_exp2fix8(qp_adj);
Anton Mitrofanov's avatar
Anton Mitrofanov committed
328
            }
329 330 331 332 333 334 335
    }

    /* 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];
336 337 338
        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);
339
    }
340 341
}

342
int x264_macroblock_tree_read( x264_t *h, x264_frame_t *frame, float *quant_offsets )
Fiona Glaser's avatar
Fiona Glaser committed
343 344 345 346
{
    x264_ratecontrol_t *rc = h->rc;
    uint8_t i_type_actual = rc->entry[frame->i_frame].pict_type;

347
    if( rc->entry[frame->i_frame].kept_as_ref )
Fiona Glaser's avatar
Fiona Glaser committed
348 349
    {
        uint8_t i_type;
350 351 352 353 354
        if( rc->qpbuf_pos < 0 )
        {
            do
            {
                rc->qpbuf_pos++;
Fiona Glaser's avatar
Fiona Glaser committed
355

356 357 358 359
                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
360

361 362 363 364 365 366
                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
367 368
        }

369
        for( int i = 0; i < h->mb.i_mb_count; i++ )
370
        {
371
            frame->f_qp_offset[i] = ((float)(int16_t)endian_fix16( rc->qp_buffer[rc->qpbuf_pos][i] )) * (1/256.0);
372 373 374
            if( h->frames.b_have_lowres )
                frame->i_inv_qscale_factor[i] = x264_exp2fix8(frame->f_qp_offset[i]);
        }
375
        rc->qpbuf_pos--;
Fiona Glaser's avatar
Fiona Glaser committed
376 377
    }
    else
378
        x264_adaptive_quant_frame( h, frame, quant_offsets );
Fiona Glaser's avatar
Fiona Glaser committed
379 380 381 382 383 384
    return 0;
fail:
    x264_log(h, X264_LOG_ERROR, "Incomplete MB-tree stats file.\n");
    return -1;
}

385 386 387 388
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
389 390
    x264_weight_t weights[16][3];
    int refcount[16];
391 392 393 394 395

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

    memcpy( frames, h->fref0, sizeof(frames) );
Dylan Yudaken's avatar
Dylan Yudaken committed
396 397
    memcpy( refcount, rce->refcount, sizeof(refcount) );
    memcpy( weights, h->fenc->weight, sizeof(weights) );
Dylan Yudaken's avatar
Dylan Yudaken committed
398
    memset( &h->fenc->weight[1][0], 0, sizeof(x264_weight_t[15][3]) );
399 400 401

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

407
        for( int i = 1; i < h->i_ref0; i++ )
408 409
            /* Favor lower POC as a tiebreaker. */
            COPY2_IF_GT( max, refcount[i], bestref, i );
Dylan Yudaken's avatar
Dylan Yudaken committed
410 411 412 413 414

        /* 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;
415
        h->fref0[ref] = frames[bestref];
Dylan Yudaken's avatar
Dylan Yudaken committed
416
        memcpy( h->fenc->weight[ref], weights[bestref], sizeof(weights[bestref]) );
417 418 419 420 421
    }

    return 0;
}

Fiona Glaser's avatar
Fiona Glaser committed
422 423 424
static char *x264_strcat_filename( char *input, char *suffix )
{
    char *output = x264_malloc( strlen( input ) + strlen( suffix ) + 1 );
425 426
    if( !output )
        return NULL;
Fiona Glaser's avatar
Fiona Glaser committed
427 428 429 430 431
    strcpy( output, input );
    strcat( output, suffix );
    return output;
}

432 433 434 435 436 437
void x264_ratecontrol_init_reconfigurable( x264_t *h, int b_init )
{
    x264_ratecontrol_t *rc = h->rc;
    if( !b_init && rc->b_2pass )
        return;

438 439 440 441 442 443 444 445 446 447
    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 );
    }

448 449 450 451 452 453 454 455 456 457 458 459 460
    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;
461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513

        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 */
        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

            int max_cpb_output_delay = h->param.i_keyint_max * MAX_DURATION * h->sps->vui.i_time_scale / h->sps->vui.i_num_units_in_tick;
            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 );
            h->sps->vui.hrd.i_cpb_removal_delay_length = x264_clip3( 32 - x264_clz( max_cpb_output_delay ), 4, 32 );
            h->sps->vui.hrd.i_dpb_output_delay_length  = x264_clip3( 32 - x264_clz( max_dpb_output_delay ), 4, 32 );

            #undef MAX_DURATION

            vbv_buffer_size = X264_MIN( vbv_buffer_size, h->sps->vui.hrd.i_cpb_size_unscaled );
            vbv_max_bitrate = X264_MIN( vbv_max_bitrate, h->sps->vui.hrd.i_bit_rate_unscaled );
        }
        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;
514 515 516
        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
517 518 519 520 521 522 523 524 525
        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;
            }
        }
526 527 528 529
        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
530
            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);
531 532 533 534 535 536 537 538 539
            rc->buffer_fill_final = rc->buffer_size * h->param.rc.f_vbv_buffer_init;
            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;
        }
    }
}

540
int x264_ratecontrol_new( x264_t *h )
Laurent Aimar's avatar
Laurent Aimar committed
541
{
542
    x264_ratecontrol_t *rc;
543

544
    x264_emms();
545

546 547
    CHECKED_MALLOCZERO( h->rc, h->param.i_threads * sizeof(x264_ratecontrol_t) );
    rc = h->rc;
548

549 550
    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
551

552
    /* FIXME: use integers */
553
    if( h->param.i_fps_num > 0 && h->param.i_fps_den > 0 )
554 555 556 557
        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
558 559 560 561 562 563 564 565
    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;

566
    rc->bitrate = h->param.rc.i_bitrate * 1000.;
Loren Merritt's avatar
Loren Merritt committed
567
    rc->rate_tolerance = h->param.rc.f_rate_tolerance;
568
    rc->nmb = h->mb.i_mb_count;
Loren Merritt's avatar
Loren Merritt committed
569 570 571
    rc->last_non_b_pict_type = -1;
    rc->cbr_decay = 1.0;

572
    if( h->param.rc.i_rc_method == X264_RC_CRF && h->param.rc.b_stat_read )
573
    {
574
        x264_log(h, X264_LOG_ERROR, "constant rate-factor is incompatible with 2pass.\n");
575 576
        return -1;
    }
577 578 579 580

    x264_ratecontrol_init_reconfigurable( h, 1 );

    if( rc->rate_tolerance < 0.01 )
Fiona Glaser's avatar
Fiona Glaser committed
581
    {
582
        x264_log(h, X264_LOG_WARNING, "bitrate tolerance too small, using .01\n");
583 584
        rc->rate_tolerance = 0.01;
    }
585

586
    h->mb.b_variable_qp = rc->b_vbv || h->param.rc.i_aq_mode;
587

Loren Merritt's avatar
Loren Merritt committed
588 589
    if( rc->b_abr )
    {
590
        /* FIXME ABR_INIT_QP is actually used only in CRF */
591
#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
592 593
        rc->accum_p_norm = .01;
        rc->accum_p_qp = ABR_INIT_QP * rc->accum_p_norm;
594
        /* estimated ratio that produces a reasonable QP for the first I-frame */
Fiona Glaser's avatar
Fiona Glaser committed
595
        rc->cplxr_sum = .01 * pow( 7.0e5, rc->qcompress ) * pow( h->mb.i_mb_count, 0.5 );
596 597
        rc->wanted_bits_window = 1.0 * rc->bitrate / rc->fps;
        rc->last_non_b_pict_type = SLICE_TYPE_I;
598 599
    }

600 601
    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
602
    rc->qp_constant[SLICE_TYPE_P] = h->param.rc.i_qp_constant;
603 604
    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 );
Fiona Glaser's avatar
Fiona Glaser committed
605
    h->mb.ip_offset = rc->ip_offset + 0.5;
606

Loren Merritt's avatar
Loren Merritt committed
607
    rc->lstep = pow( 2, h->param.rc.i_qp_step / 6.0 );
608
    rc->last_qscale = qp2qscale( 26 );
Fiona Glaser's avatar
Fiona Glaser committed
609 610
    int num_preds = h->param.b_sliced_threads * h->param.i_threads + 1;
    CHECKED_MALLOC( rc->pred, 5 * sizeof(predictor_t) * num_preds );
611
    CHECKED_MALLOC( rc->pred_b_from_p, sizeof(predictor_t) );
612
    for( int i = 0; i < 5; i++ )
613
    {
614
        rc->last_qscale_for[i] = qp2qscale( ABR_INIT_QP );
615 616
        rc->lmin[i] = qp2qscale( h->param.rc.i_qp_min );
        rc->lmax[i] = qp2qscale( h->param.rc.i_qp_max );
617
        for( int j = 0; j < num_preds; j++ )
Fiona Glaser's avatar
Fiona Glaser committed
618 619 620 621 622 623
        {
            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;
        }
624
        for( int j = 0; j < 2; j++ )
625 626 627 628 629 630
        {
            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;
        }
631
    }
Loren Merritt's avatar
Loren Merritt committed
632
    *rc->pred_b_from_p = rc->pred[0];
633

634
    if( parse_zones( h ) < 0 )
635 636
    {
        x264_log( h, X264_LOG_ERROR, "failed to parse zones\n" );
637
        return -1;
638
    }
Loren Merritt's avatar
Loren Merritt committed
639

640 641 642
    /* Load stat file and init 2pass algo */
    if( h->param.rc.b_stat_read )
    {
643
        char *p, *stats_in, *stats_buf;
644 645 646

        /* read 1st pass stats */
        assert( h->param.rc.psz_stat_in );
647 648
        stats_buf = stats_in = x264_slurp_file( h->param.rc.psz_stat_in );
        if( !stats_buf )
649 650 651 652
        {
            x264_log(h, X264_LOG_ERROR, "ratecontrol_init: can't open stats file\n");
            return -1;
        }
Fiona Glaser's avatar
Fiona Glaser committed
653 654 655
        if( h->param.rc.b_mb_tree )
        {
            char *mbtree_stats_in = x264_strcat_filename( h->param.rc.psz_stat_in, ".mbtree" );
656 657
            if( !mbtree_stats_in )
                return -1;
Fiona Glaser's avatar
Fiona Glaser committed
658 659 660 661 662 663 664 665
            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;
            }
        }
666

667 668 669
        /* check whether 1st pass options were compatible with current options */
        if( !strncmp( stats_buf, "#options:", 9 ) )
        {
670
            int i, j;
671
            uint32_t k, l;
672 673 674 675 676 677
            char *opts = stats_buf;
            stats_in = strchr( stats_buf, '\n' );
            if( !stats_in )
                return -1;
            *stats_in = '\0';
            stats_in++;
678 679 680 681 682 683 684 685 686 687 688
            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;
            }
689

690
            if( ( p = strstr( opts, "timebase=" ) ) && sscanf( p, "timebase=%u/%u", &k, &l ) != 2 )
691 692 693 694
            {
                x264_log( h, X264_LOG_ERROR, "timebase specified in stats file not valid\n" );
                return -1;
            }
695
            if( k != h->param.i_timebase_num || l != h->param.i_timebase_den )
696
            {
697 698
                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 );
699 700 701
                return -1;
            }

702
            CMP_OPT_FIRST_PASS( "weightp", X264_MAX( 0, h->param.analyse.i_weighted_pred ) );
Fiona Glaser's avatar
Fiona Glaser committed
703 704 705 706
            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 );
            CMP_OPT_FIRST_PASS( "keyint", h->param.i_keyint_max );
707

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

711 712 713 714 715 716
            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;
            }

717 718
            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;
719
            else if( h->param.i_bframe )
720 721 722 723
            {
                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
724

725
            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
726
                h->param.rc.i_lookahead = i;
727 728
        }

729 730
        /* find number of pics */
        p = stats_in;
731 732 733 734
        int num_entries;
        for( num_entries = -1; p; num_entries++ )
            p = strchr( p + 1, ';' );
        if( !num_entries )
Loren Merritt's avatar
Loren Merritt committed
735 736 737
        {
            x264_log(h, X264_LOG_ERROR, "empty stats file\n");
            return -1;
738
        }
739
        rc->num_entries = num_entries;
740

741
        if( h->param.i_frame_total < rc->num_entries && h->param.i_frame_total > 0 )
742 743 744 745
        {
            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 );
        }
746
        if( h->param.i_frame_total > rc->num_entries )
747 748 749 750 751 752
        {
            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;
        }

753
        CHECKED_MALLOCZERO( rc->entry, rc->num_entries * sizeof(ratecontrol_entry_t) );
754 755

        /* init all to skipped p frames */
756
        for( int i = 0; i < rc->num_entries; i++ )
Fiona Glaser's avatar
Fiona Glaser committed
757
        {
758
            ratecontrol_entry_t *rce = &rc->entry[i];
759
            rce->pict_type = SLICE_TYPE_P;
760
            rce->qscale = rce->new_qscale = qp2qscale( 20 );
761 762 763 764 765 766
            rce->misc_bits = rc->nmb + 10;
            rce->new_qp = 0;
        }

        /* read stats */
        p = stats_in;
767
        for( int i = 0; i < rc->num_entries; i++ )
Fiona Glaser's avatar
Fiona Glaser committed
768
        {
769
            ratecontrol_entry_t *rce;
770 771
            int frame_number;
            char pict_type;
772 773 774
            int e;
            char *next;
            float qp;
775
            int ref;
776 777

            next= strchr(p, ';');
778 779 780
            if( next )
                *next++ = 0; //sscanf is unbelievably slow on long strings
            e = sscanf( p, " in:%d ", &frame_number );
781

782
            if( frame_number < 0 || frame_number >= rc->num_entries )
Loren Merritt's avatar
Loren Merritt committed
783
            {
784
                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
785 786
                return -1;
            }
787
            rce = &rc->entry[frame_number];
Loren Merritt's avatar
Loren Merritt committed
788
            rce->direct_mode = 0;
789

790
            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",
791
                   &pict_type, &rce->i_duration, &rce->i_cpb_duration, &qp, &rce->tex_bits,
Loren Merritt's avatar
Loren Merritt committed
792
                   &rce->mv_bits, &rce->misc_bits, &rce->i_count, &rce->p_count,
793
                   &rce->s_count, &rce->direct_mode );
794

795 796 797 798 799 800 801 802 803 804 805 806 807 808
            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
809 810 811 812
            /* find weights */
            rce->i_weight_denom = -1;
            char *w = strchr( p, 'w' );
            if( w )
813
                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
814 815
                    rce->i_weight_denom = -1;

816 817 818
            if( pict_type != 'b' )
                rce->kept_as_ref = 1;
            switch( pict_type )
Fiona Glaser's avatar
Fiona Glaser committed
819
            {
820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839
                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;
840 841
                default:  e = -1; break;
            }
842
            if( e < 12 )
Fiona Glaser's avatar
Fiona Glaser committed
843
            {
844
parse_error:
845
                x264_log( h, X264_LOG_ERROR, "statistics are damaged at line %d, parser out=%d\n", i, e );
846 847
                return -1;
            }
848
            rce->qscale = qp2qscale( qp );
849 850 851
            p = next;
        }

852
        x264_free( stats_buf );
853

854
        if( h->param.rc.i_rc_method == X264_RC_ABR )
855
        {
856 857
            if( init_pass2( h ) < 0 )
                return -1;
Loren Merritt's avatar
Loren Merritt committed
858
        } /* else we're using constant quant, so no need to run the bitrate allocation */
859 860 861
    }

    /* Open output file */
862 863
    /* 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 */
864 865
    if( h->param.rc.b_stat_write )
    {
866
        char *p;
Fiona Glaser's avatar
Fiona Glaser committed
867
        rc->psz_stat_file_tmpname = x264_strcat_filename( h->param.rc.psz_stat_out, ".temp" );
868 869
        if( !rc->psz_stat_file_tmpname )
            return -1;
870 871

        rc->p_stat_file_out = fopen( rc->psz_stat_file_tmpname, "wb" );
872 873 874 875 876
        if( rc->p_stat_file_out == NULL )
        {
            x264_log(h, X264_LOG_ERROR, "ratecontrol_init: can't open stats file\n");
            return -1;
        }
877 878

        p = x264_param2string( &h->param, 1 );
879 880
        if( p )
            fprintf( rc->p_stat_file_out, "#options: %s\n", p );
881
        x264_free( p );
Fiona Glaser's avatar
Fiona Glaser committed
882 883 884 885
        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" );
886 887
            if( !rc->psz_mbtree_stat_file_tmpname || !rc->psz_mbtree_stat_file_name )
                return -1;
Fiona Glaser's avatar
Fiona Glaser committed
888 889 890 891 892 893 894 895 896 897 898

            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) )
899 900 901 902 903 904
    {
        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;
    }
905

906
    for( int i = 0; i<h->param.i_threads; i++ )
Loren Merritt's avatar
Loren Merritt committed
907 908
    {
        h->thread[i]->rc = rc+i;
909
        if( i )
910
        {
911
            rc[i] = rc[0];
Loren Merritt's avatar
Loren Merritt committed
912
            h->thread[i]->param = h->param;
913
            h->thread[i]->mb.b_variable_qp = h->mb.b_variable_qp;
914
        }
Loren Merritt's avatar
Loren Merritt committed
915 916
    }

917
    return 0;
918 919
fail:
    return -1;
Laurent Aimar's avatar
Laurent Aimar committed
920 921
}

922 923 924
static int parse_zone( x264_t *h, x264_zone_t *z, char *p )
{
    int len = 0;
925
    char *tok, UNUSED *saveptr=NULL;
926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941
    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;
942
    CHECKED_MALLOC( z->param, sizeof(x264_param_t) );
943
    memcpy( z->param, &h->param, sizeof(x264_param_t) );
944
    z->param->param_free = x264_free;
945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960
    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;
961 962
fail:
    return -1;
963 964
}

965 966 967 968 969
static int parse_zones( x264_t *h )
{
    x264_ratecontrol_t *rc = h->rc;
    if( h->param.rc.psz_zones && !h->param.rc.i_zones )
    {
Steven Walters's avatar
Steven Walters committed
970
        char *psz_zones, *p;
971
        CHECKED_MALLOC( psz_zones, strlen( h->param.rc.psz_zones )+1 );
972
        strcpy( psz_zones, h->param.rc.psz_zones );
973
        h->param.rc.i_zones = 1;
974
        for( p = psz_zones; *p; p++ )
975
            h->param.rc.i_zones += (*p == '/');
976
        CHECKED_MALLOC( h->param.rc.zones, h->param.rc.i_zones * sizeof(x264_zone_t) );
977
        p = psz_zones;
978
        for( int i = 0; i < h->param.rc.i_zones; i++ )
979
        {
Steven Walters's avatar
Steven Walters committed
980 981 982
            int i_tok = strcspn( p, "/" );
            p[i_tok] = 0;
            if( parse_zone( h, &h->param.rc.zones[i], p ) )
983
                return -1;
Steven Walters's avatar
Steven Walters committed
984
            p += i_tok + 1;
985
        }
986
        x264_free( psz_zones );
987 988 989 990
    }

    if( h->param.rc.i_zones > 0 )
    {
991
        for( int i = 0; i < h->param.rc.i_zones; i++ )
992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007
        {
            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;
            }
        }

1008
        rc->i_zones = h->param.rc.i_zones + 1;