ratecontrol.c 105 KB
Newer Older
1
/*****************************************************************************
Fiona Glaser's avatar
Fiona Glaser committed
2
 * ratecontrol.c: ratecontrol
Laurent Aimar's avatar
Laurent Aimar committed
3
 *****************************************************************************
Fiona Glaser's avatar
Fiona Glaser committed
4
 * Copyright (C) 2005-2010 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.
Fiona Glaser's avatar
Fiona Glaser committed
25 26 27
 *
 * This program is also available under a commercial proprietary license.
 * For more information, contact us at licensing@x264.com.
Laurent Aimar's avatar
Laurent Aimar committed
28 29
 *****************************************************************************/

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

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

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

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

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

Loren Merritt's avatar
Loren Merritt committed
86 87
    /* current frame */
    ratecontrol_entry_t *rce;
88
    int qp;                     /* qp for current frame */
89
    float qpm;                  /* qp for current macroblock: precise float for AQ */
90 91
    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
92
    float qp_novbv;             /* QP for the current frame if 1-pass VBV was disabled. */
93

Loren Merritt's avatar
Loren Merritt committed
94 95
    /* VBV stuff */
    double buffer_size;
Fiona Glaser's avatar
Fiona Glaser committed
96
    int64_t buffer_fill_final;
Loren Merritt's avatar
Loren Merritt committed
97
    double buffer_fill;         /* planned buffer, if all in-progress frames hit their bit budget */
Loren Merritt's avatar
Loren Merritt committed
98
    double buffer_rate;         /* # of bits added to buffer_fill after each frame */
99
    double vbv_max_rate;        /* # of bits added to buffer_fill per second */
Loren Merritt's avatar
Loren Merritt committed
100
    predictor_t *pred;          /* predict frame size from satd */
101
    int single_frame_vbv;
Fiona Glaser's avatar
Fiona Glaser committed
102
    double rate_factor_max_increment; /* Don't allow RF above (CRF + this value). */
Loren Merritt's avatar
Loren Merritt committed
103 104 105 106 107

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

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

    int num_entries;            /* number of ratecontrol_entry_ts */
Loren Merritt's avatar
Loren Merritt committed
127
    ratecontrol_entry_t *entry; /* FIXME: copy needed data and free this once init is done */
128
    double last_qscale;
129
    double last_qscale_for[3];  /* last qscale for a specific pict type, used for max_diff & ipb factor stuff */
130
    int last_non_b_pict_type;
131 132
    double accum_p_qp;          /* for determining I-frame quant */
    double accum_p_norm;
133
    double last_accum_p_norm;
134 135
    double lmin[3];             /* min qscale by frame type */
    double lmax[3];
Loren Merritt's avatar
Loren Merritt committed
136
    double lstep;               /* max change (multiply) in qscale per frame */
137 138 139
    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
140

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

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

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

165

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

Fiona Glaser's avatar
Fiona Glaser committed
174 175 176 177 178 179 180 181 182
#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;\
    }\
}

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

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

209 210 211 212 213 214 215 216 217
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
218 219 220 221 222
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
223 224
        ? 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
225
    stride <<= h->mb.b_interlaced;
226 227 228 229
    if( i )
    {
        ALIGNED_ARRAY_16( pixel, pix,[FENC_STRIDE*8] );
        h->mc.load_deinterleave_8x8x2_fenc( pix, frame->plane[1] + offset, stride );
Fiona Glaser's avatar
Fiona Glaser committed
230 231
        return ac_energy_var( h->pixf.var[PIXEL_8x8]( pix, FENC_STRIDE ), 6, frame, 1 )
             + ac_energy_var( h->pixf.var[PIXEL_8x8]( pix+FENC_STRIDE/2, FENC_STRIDE ), 6, frame, 2 );
232 233
    }
    else
Fiona Glaser's avatar
Fiona Glaser committed
234
        return ac_energy_var( h->pixf.var[PIXEL_16x16]( frame->plane[0] + offset, stride ), 8, frame, 0 );
Fiona Glaser's avatar
Fiona Glaser committed
235 236
}

237
// Find the total AC energy of the block in all planes.
238
static NOINLINE uint32_t x264_ac_energy_mb( x264_t *h, int mb_x, int mb_y, x264_frame_t *frame )
239
{
240 241 242 243
    /* 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
244 245
    uint32_t var = ac_energy_plane( h, mb_x, mb_y, frame, 0 );
    var         += ac_energy_plane( h, mb_x, mb_y, frame, 1 );
246
    x264_emms();
247 248 249
    return var;
}

250
void x264_adaptive_quant_frame( x264_t *h, x264_frame_t *frame, float *quant_offsets )
251
{
252 253
    /* 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
254 255
    float strength;
    float avg_adj = 0.f;
256 257
    /* Initialize frame stats */
    for( int i = 0; i < 3; i++ )
Fiona Glaser's avatar
Fiona Glaser committed
258
    {
259 260
        frame->i_pixel_sum[i] = 0;
        frame->i_pixel_ssd[i] = 0;
Fiona Glaser's avatar
Fiona Glaser committed
261 262
    }

263 264
    /* 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
265
    {
266
        /* Need to init it anyways for MB tree */
Yusuke Nakamura's avatar
Yusuke Nakamura committed
267
        if( h->param.rc.i_aq_mode && h->param.rc.f_aq_strength == 0 )
268
        {
269 270
            if( quant_offsets )
            {
271
                for( int mb_xy = 0; mb_xy < h->mb.i_mb_count; mb_xy++ )
272 273 274 275 276 277 278 279 280 281 282 283 284
                    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;
            }
285 286
        }
        /* Need variance data for weighted prediction */
287
        if( h->param.analyse.i_weighted_pred )
288
        {
289 290
            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++ )
291 292 293 294
                    x264_ac_energy_mb( h, mb_x, mb_y, frame );
        }
        else
            return;
Anton Mitrofanov's avatar
Anton Mitrofanov committed
295
    }
296
    /* Actual adaptive quantization */
Anton Mitrofanov's avatar
Anton Mitrofanov committed
297
    else
298 299
    {
        if( h->param.rc.i_aq_mode == X264_AQ_AUTOVARIANCE )
300
        {
301
            float bit_depth_correction = powf(1 << (BIT_DEPTH-8), 0.5f);
302
            float avg_adj_pow2 = 0.f;
303 304
            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++ )
305 306 307 308 309 310 311 312 313
                {
                    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;
314 315
            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;
316 317 318 319
        }
        else
            strength = h->param.rc.f_aq_strength * 1.0397f;

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

    /* 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];
349 350 351
        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);
352
    }
353 354
}

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

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

369 370 371 372
                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
373

374 375 376 377 378 379
                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
380 381
        }

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

398 399 400 401
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
402 403
    x264_weight_t weights[16][3];
    int refcount[16];
404 405 406 407 408

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

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

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

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

        /* 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;
428
        h->fref0[ref] = frames[bestref];
Dylan Yudaken's avatar
Dylan Yudaken committed
429
        memcpy( h->fenc->weight[ref], weights[bestref], sizeof(weights[bestref]) );
430 431 432 433 434
    }

    return 0;
}

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

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

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 )
Fiona Glaser's avatar
Fiona Glaser committed
458
                                 / qp2qscale( h->param.rc.f_rf_constant + mbtree_offset + QP_BD_OFFSET );
459 460
    }

461 462 463 464 465 466 467 468 469 470 471 472 473
    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;
474 475 476 477 478

        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
479 480
        h->sps->vui.hrd.i_bit_rate_unscaled = vbv_max_bitrate;
        h->sps->vui.hrd.i_cpb_size_unscaled = vbv_buffer_size;
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
        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

507
            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 );
508 509 510 511
            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 );
512 513
            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 );
514 515 516

            #undef MAX_DURATION

Fiona Glaser's avatar
Fiona Glaser committed
517 518
            vbv_buffer_size = h->sps->vui.hrd.i_cpb_size_unscaled;
            vbv_max_bitrate = h->sps->vui.hrd.i_bit_rate_unscaled;
519 520 521 522 523 524 525 526 527 528
        }
        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;
529 530 531
        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
532 533 534 535 536 537 538 539 540
        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;
            }
        }
541 542 543 544
        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
545
            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
546
            rc->buffer_fill_final = rc->buffer_size * h->param.rc.f_vbv_buffer_init * h->sps->vui.i_time_scale;
547 548 549 550 551 552 553 554
            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;
        }
    }
}

555
int x264_ratecontrol_new( x264_t *h )
Laurent Aimar's avatar
Laurent Aimar committed
556
{
557
    x264_ratecontrol_t *rc;
558

559
    x264_emms();
560

561 562
    CHECKED_MALLOCZERO( h->rc, h->param.i_threads * sizeof(x264_ratecontrol_t) );
    rc = h->rc;
563

564 565
    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
566

567
    /* FIXME: use integers */
568
    if( h->param.i_fps_num > 0 && h->param.i_fps_den > 0 )
569 570 571 572
        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
573 574 575 576 577 578 579 580
    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;

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

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

    x264_ratecontrol_init_reconfigurable( h, 1 );

Fiona Glaser's avatar
Fiona Glaser committed
595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611
    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;
        }
    }

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

618
    h->mb.b_variable_qp = rc->b_vbv || h->param.rc.i_aq_mode;
619

Loren Merritt's avatar
Loren Merritt committed
620 621
    if( rc->b_abr )
    {
622
        /* FIXME ABR_INIT_QP is actually used only in CRF */
Fiona Glaser's avatar
Fiona Glaser committed
623
#define ABR_INIT_QP (( h->param.rc.i_rc_method == X264_RC_CRF ? h->param.rc.f_rf_constant : 24 ) + QP_BD_OFFSET)
Loren Merritt's avatar
Loren Merritt committed
624 625
        rc->accum_p_norm = .01;
        rc->accum_p_qp = ABR_INIT_QP * rc->accum_p_norm;
626
        /* estimated ratio that produces a reasonable QP for the first I-frame */
Fiona Glaser's avatar
Fiona Glaser committed
627
        rc->cplxr_sum = .01 * pow( 7.0e5, rc->qcompress ) * pow( h->mb.i_mb_count, 0.5 );
628 629
        rc->wanted_bits_window = 1.0 * rc->bitrate / rc->fps;
        rc->last_non_b_pict_type = SLICE_TYPE_I;
630 631
    }

632 633
    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
634
    rc->qp_constant[SLICE_TYPE_P] = h->param.rc.i_qp_constant;
635 636
    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
637
    h->mb.ip_offset = rc->ip_offset + 0.5;
638

Loren Merritt's avatar
Loren Merritt committed
639
    rc->lstep = pow( 2, h->param.rc.i_qp_step / 6.0 );
640
    rc->last_qscale = qp2qscale( 26 );
Fiona Glaser's avatar
Fiona Glaser committed
641 642
    int num_preds = h->param.b_sliced_threads * h->param.i_threads + 1;
    CHECKED_MALLOC( rc->pred, 5 * sizeof(predictor_t) * num_preds );
643
    CHECKED_MALLOC( rc->pred_b_from_p, sizeof(predictor_t) );
644
    for( int i = 0; i < 3; i++ )
645
    {
646
        rc->last_qscale_for[i] = qp2qscale( ABR_INIT_QP );
647 648
        rc->lmin[i] = qp2qscale( h->param.rc.i_qp_min );
        rc->lmax[i] = qp2qscale( h->param.rc.i_qp_max );
649
        for( int j = 0; j < num_preds; j++ )
Fiona Glaser's avatar
Fiona Glaser committed
650 651 652 653 654 655
        {
            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;
        }
656
        for( int j = 0; j < 2; j++ )
657 658 659 660 661 662
        {
            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;
        }
663
    }
Loren Merritt's avatar
Loren Merritt committed
664
    *rc->pred_b_from_p = rc->pred[0];
665

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

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

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

699 700 701
        /* check whether 1st pass options were compatible with current options */
        if( !strncmp( stats_buf, "#options:", 9 ) )
        {
702
            int i, j;
703
            uint32_t k, l;
704 705 706 707 708 709
            char *opts = stats_buf;
            stats_in = strchr( stats_buf, '\n' );
            if( !stats_in )
                return -1;
            *stats_in = '\0';
            stats_in++;
710 711 712 713 714 715 716 717 718 719 720
            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;
            }
721

722
            if( ( p = strstr( opts, "timebase=" ) ) && sscanf( p, "timebase=%u/%u", &k, &l ) != 2 )
723 724 725 726
            {
                x264_log( h, X264_LOG_ERROR, "timebase specified in stats file not valid\n" );
                return -1;
            }
727
            if( k != h->param.i_timebase_num || l != h->param.i_timebase_den )
728
            {
729 730
                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 );
731 732 733
                return -1;
            }

Fiona Glaser's avatar
Fiona Glaser committed
734
            CMP_OPT_FIRST_PASS( "bitdepth", BIT_DEPTH );
735
            CMP_OPT_FIRST_PASS( "weightp", X264_MAX( 0, h->param.analyse.i_weighted_pred ) );
Fiona Glaser's avatar
Fiona Glaser committed
736 737 738
            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
739
            CMP_OPT_FIRST_PASS( "open_gop", h->param.i_open_gop );
740

741 742 743 744 745 746 747 748 749 750 751 752 753 754
            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;
                }
            }

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

758 759 760 761 762 763
            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;
            }

764 765
            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;
766
            else if( h->param.i_bframe )
767 768 769 770
            {
                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
771

772
            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
773
                h->param.rc.i_lookahead = i;
774 775
        }

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

788
        if( h->param.i_frame_total < rc->num_entries && h->param.i_frame_total > 0 )
789 790 791 792
        {
            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 );
        }
793
        if( h->param.i_frame_total > rc->num_entries )
794 795 796 797 798 799
        {
            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;
        }

800
        CHECKED_MALLOCZERO( rc->entry, rc->num_entries * sizeof(ratecontrol_entry_t) );
801 802

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

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

            next= strchr(p, ';');
825 826 827
            if( next )
                *next++ = 0; //sscanf is unbelievably slow on long strings
            e = sscanf( p, " in:%d ", &frame_number );
828

829
            if( frame_number < 0 || frame_number >= rc->num_entries )
Loren Merritt's avatar
Loren Merritt committed
830
            {
831
                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
832 833
                return -1;
            }
834
            rce = &rc->entry[frame_number];
Loren Merritt's avatar
Loren Merritt committed
835
            rce->direct_mode = 0;
836

837
            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",
838
                   &pict_type, &rce->i_duration, &rce->i_cpb_duration, &qp, &rce->tex_bits,
Loren Merritt's avatar
Loren Merritt committed
839
                   &rce->mv_bits, &rce->misc_bits, &rce->i_count, &rce->p_count,
840
                   &rce->s_count, &rce->direct_mode );
841

842 843 844 845 846 847 848 849 850 851 852 853 854 855
            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
856
            /* find weights */
Fiona Glaser's avatar
Fiona Glaser committed
857
            rce->i_weight_denom[0] = rce->i_weight_denom[1] = -1;
Dylan Yudaken's avatar
Dylan Yudaken committed
858 859
            char *w = strchr( p, 'w' );
            if( w )
Fiona Glaser's avatar
Fiona Glaser committed
860 861 862 863 864 865 866 867 868 869
            {
                int count = sscanf( w, "w:%hd,%hd,%hd,%hd,%hd,%hd,%hd,%hd",
                                    &rce->i_weight_denom[0], &rce->weight[0][0], &rce->weight[0][1],
                                    &rce->i_weight_denom[1], &rce->weight[1][0], &rce->weight[1][1],
                                    &rce->weight[2][0], &rce->weight[2][1] );
                if( count == 3 )
                    rce->i_weight_denom[1] = -1;
                else if ( count != 8 )
                    rce->i_weight_denom[0] = rce->i_weight_denom[1] = -1;
            }
Dylan Yudaken's avatar
Dylan Yudaken committed
870

871 872 873
            if( pict_type != 'b' )
                rce->kept_as_ref = 1;
            switch( pict_type )
Fiona Glaser's avatar
Fiona Glaser committed
874
            {
875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894
                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;
895 896
                default:  e = -1; break;
            }
897
            if( e < 12 )
Fiona Glaser's avatar
Fiona Glaser committed
898
            {
899
parse_error:
900
                x264_log( h, X264_LOG_ERROR, "statistics are damaged at line %d, parser out=%d\n", i, e );
901 902
                return -1;
            }
903
            rce->qscale = qp2qscale( qp );
904 905 906
            p = next;
        }

907
        x264_free( stats_buf );
908

909
        if( h->param.rc.i_rc_method == X264_RC_ABR )
910
        {
911 912
            if( init_pass2( h ) < 0 )
                return -1;
Loren Merritt's avatar
Loren Merritt committed
913
        } /* else we're using constant quant, so no need to run the bitrate allocation */
914 915 916
    }

    /* Open output file */
917 918
    /* 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 */
919 920
    if( h->param.rc.b_stat_write )
    {
921
        char *p;
Fiona Glaser's avatar
Fiona Glaser committed
922
        rc->psz_stat_file_tmpname = x264_strcat_filename( h->param.rc.psz_stat_out, ".temp" );
923 924
        if( !rc->psz_stat_file_tmpname )
            return -1;
925 926

        rc->p_stat_file_out = fopen( rc->psz_stat_file_tmpname, "wb" );
927 928 929 930 931
        if( rc->p_stat_file_out == NULL )
        {
            x264_log(h, X264_LOG_ERROR, "ratecontrol_init: can't open stats file\n");
            return -1;
        }
932 933

        p = x264_param2string( &h->param, 1 );
934 935
        if( p )
            fprintf( rc->p_stat_file_out, "#options: %s\n", p );
936
        x264_free( p );
Fiona Glaser's avatar
Fiona Glaser committed
937 938 939 940
        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" );
941 942
            if( !rc->psz_mbtree_stat_file_tmpname || !rc->psz_mbtree_stat_file_name )
                return -1;
Fiona Glaser's avatar
Fiona Glaser committed
943 944 945 946 947 948 949 950 951 952 953

            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) )
954 955 956 957 958 959
    {
        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;
    }
960

961
    for( int i = 0; i<h->param.i_threads; i++ )
Loren Merritt's avatar
Loren Merritt committed
962 963
    {
        h->thread[i]->rc = rc+i;
964
        if( i )
965
        {
966
            rc[i] = rc[0];
Loren Merritt's avatar
Loren Merritt committed
967
            h->thread[i]->param = h->param;
968
            h->thread[i]->mb.b_variable_qp = h->mb.b_variable_qp;
969
            h->thread[i]->mb.ip_offset = h->mb.ip_offset;
970
        }
Loren Merritt's avatar
Loren Merritt committed
971 972
    }

973
    return 0;
974 975
fail:
    return -1;
Laurent Aimar's avatar
Laurent Aimar committed
976 977
}

978 979