ratecontrol.c 86.3 KB
Newer Older
1
/***************************************************-*- coding: iso-8859-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 32
#include "common/common.h"
#include "common/cpu.h"
Laurent Aimar's avatar
Laurent Aimar committed
33
#include "ratecontrol.h"
34
#include "me.h"
Laurent Aimar's avatar
Laurent Aimar committed
35

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

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

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

Loren Merritt's avatar
Loren Merritt committed
82 83
    /* current frame */
    ratecontrol_entry_t *rce;
84
    int qp;                     /* qp for current frame */
85
    int qpm;                    /* qp for current macroblock */
86
    float f_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 */
Loren Merritt's avatar
Loren Merritt committed
97
    predictor_t *pred;          /* predict frame size from satd */
98
    int single_frame_vbv;
Loren Merritt's avatar
Loren Merritt committed
99 100 101 102 103

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

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

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

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

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

151

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

Fiona Glaser's avatar
Fiona Glaser committed
160 161 162 163 164 165 166 167 168
#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;\
    }\
}

169 170
/* Terminology:
 * qp = h.264's quantizer
171
 * qscale = linearized quantizer = Lagrange multiplier
172 173 174 175 176 177 178 179 180 181
 */
static inline double qp2qscale(double qp)
{
    return 0.85 * pow(2.0, ( qp - 12.0 ) / 6.0);
}
static inline double qscale2qp(double qscale)
{
    return 12.0 + 6.0 * log(qscale/0.85) / log(2.0);
}

182 183 184 185
/* 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. */
186 187
static inline double qscale2bits(ratecontrol_entry_t *rce, double qscale)
{
Loren Merritt's avatar
Loren Merritt committed
188
    if(qscale<0.1)
189
        qscale = 0.1;
190
    return (rce->tex_bits + .1) * pow( rce->qscale / qscale, 1.1 )
191
           + rce->mv_bits * pow( X264_MAX(rce->qscale, 1) / X264_MAX(qscale, 1), 0.5 )
192
           + rce->misc_bits;
193 194
}

Fiona Glaser's avatar
Fiona Glaser committed
195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210
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;
    uint32_t sqr = res >> 32;
    return sqr - (sum * sum >> shift);
}

211
// Find the total AC energy of the block in all planes.
Anton Mitrofanov's avatar
Anton Mitrofanov committed
212
static NOINLINE uint32_t ac_energy_mb( x264_t *h, int mb_x, int mb_y, x264_frame_t *frame )
213
{
214 215 216 217
    /* 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
218 219 220
    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 );
Loren Merritt's avatar
Loren Merritt committed
221
    x264_emms();
222 223 224
    return var;
}

225
void x264_adaptive_quant_frame( x264_t *h, x264_frame_t *frame )
226
{
227 228
    /* 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. */
229
    int mb_x, mb_y;
Anton Mitrofanov's avatar
Anton Mitrofanov committed
230 231
    float strength;
    float avg_adj = 0.f;
Fiona Glaser's avatar
Fiona Glaser committed
232 233 234 235 236
    /* Need to init it anyways for MB tree. */
    if( h->param.rc.f_aq_strength == 0 )
    {
        int mb_xy;
        memset( frame->f_qp_offset, 0, h->mb.i_mb_count * sizeof(float) );
Fiona Glaser's avatar
Fiona Glaser committed
237
        memset( frame->f_qp_offset_aq, 0, h->mb.i_mb_count * sizeof(float) );
Fiona Glaser's avatar
Fiona Glaser committed
238 239 240 241 242 243
        if( h->frames.b_have_lowres )
            for( mb_xy = 0; mb_xy < h->mb.i_mb_count; mb_xy++ )
                frame->i_inv_qscale_factor[mb_xy] = 256;
        return;
    }

Anton Mitrofanov's avatar
Anton Mitrofanov committed
244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259
    if( h->param.rc.i_aq_mode == X264_AQ_AUTOVARIANCE )
    {
        for( mb_y = 0; mb_y < h->sps->i_mb_height; mb_y++ )
            for( mb_x = 0; mb_x < h->sps->i_mb_width; mb_x++ )
            {
                uint32_t energy = ac_energy_mb( h, mb_x, mb_y, frame );
                float qp_adj = x264_log2( energy + 2 );
                qp_adj *= qp_adj;
                frame->f_qp_offset[mb_x + mb_y*h->mb.i_mb_stride] = qp_adj;
                avg_adj += qp_adj;
            }
        avg_adj /= h->mb.i_mb_count;
        strength = h->param.rc.f_aq_strength * avg_adj * (1.f / 6000.f);
    }
    else
        strength = h->param.rc.f_aq_strength * 1.0397f;
Fiona Glaser's avatar
Fiona Glaser committed
260

261 262
    for( mb_y = 0; mb_y < h->sps->i_mb_height; mb_y++ )
        for( mb_x = 0; mb_x < h->sps->i_mb_width; mb_x++ )
263
        {
Anton Mitrofanov's avatar
Anton Mitrofanov committed
264 265 266 267 268 269 270 271 272 273 274
            float qp_adj;
            if( h->param.rc.i_aq_mode == X264_AQ_AUTOVARIANCE )
            {
                qp_adj = frame->f_qp_offset[mb_x + mb_y*h->mb.i_mb_stride];
                qp_adj = strength * (qp_adj - avg_adj);
            }
            else
            {
                uint32_t energy = ac_energy_mb( h, mb_x, mb_y, frame );
                qp_adj = strength * (x264_log2( X264_MAX(energy, 1) ) - 14.427f);
            }
Fiona Glaser's avatar
Fiona Glaser committed
275 276
            frame->f_qp_offset[mb_x + mb_y*h->mb.i_mb_stride] =
            frame->f_qp_offset_aq[mb_x + mb_y*h->mb.i_mb_stride] = qp_adj;
277
            if( h->frames.b_have_lowres )
Fiona Glaser's avatar
Fiona Glaser committed
278
                frame->i_inv_qscale_factor[mb_x + mb_y*h->mb.i_mb_stride] = x264_exp2fix8(qp_adj);
279 280 281
        }
}

282

283 284 285 286 287 288 289 290 291
/*****************************************************************************
* x264_adaptive_quant:
 * adjust macroblock QP based on variance (AC energy) of the MB.
 * high variance  = higher QP
 * low variance = lower QP
 * This generally increases SSIM and lowers PSNR.
*****************************************************************************/
void x264_adaptive_quant( x264_t *h )
{
292
    x264_emms();
293 294
    /* MB-tree currently doesn't adjust quantizers in unreferenced frames. */
    float qp_offset = h->fdec->b_kept_as_ref ? h->fenc->f_qp_offset[h->mb.i_mb_xy] : h->fenc->f_qp_offset_aq[h->mb.i_mb_xy];
295
    h->mb.i_qp = x264_clip3( h->rc->f_qpm + qp_offset + .5, h->param.rc.i_qp_min, h->param.rc.i_qp_max );
296
}
297

Fiona Glaser's avatar
Fiona Glaser committed
298 299 300 301 302 303
int x264_macroblock_tree_read( x264_t *h, x264_frame_t *frame )
{
    x264_ratecontrol_t *rc = h->rc;
    uint8_t i_type_actual = rc->entry[frame->i_frame].pict_type;
    int i;

304
    if( rc->entry[frame->i_frame].kept_as_ref )
Fiona Glaser's avatar
Fiona Glaser committed
305 306
    {
        uint8_t i_type;
307 308 309 310 311
        if( rc->qpbuf_pos < 0 )
        {
            do
            {
                rc->qpbuf_pos++;
Fiona Glaser's avatar
Fiona Glaser committed
312

313 314 315 316
                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
317

318 319 320 321 322 323
                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
324 325 326
        }

        for( i = 0; i < h->mb.i_mb_count; i++ )
327
        {
328
            frame->f_qp_offset[i] = ((float)(int16_t)endian_fix16( rc->qp_buffer[rc->qpbuf_pos][i] )) * (1/256.0);
329 330 331
            if( h->frames.b_have_lowres )
                frame->i_inv_qscale_factor[i] = x264_exp2fix8(frame->f_qp_offset[i]);
        }
332
        rc->qpbuf_pos--;
Fiona Glaser's avatar
Fiona Glaser committed
333 334 335 336 337 338 339 340 341
    }
    else
        x264_adaptive_quant_frame( h, frame );
    return 0;
fail:
    x264_log(h, X264_LOG_ERROR, "Incomplete MB-tree stats file.\n");
    return -1;
}

342 343 344 345
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
346 347
    x264_weight_t weights[16][3];
    int refcount[16];
348 349 350 351 352 353
    int ref, i;

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

    memcpy( frames, h->fref0, sizeof(frames) );
Dylan Yudaken's avatar
Dylan Yudaken committed
354 355
    memcpy( refcount, rce->refcount, sizeof(refcount) );
    memcpy( weights, h->fenc->weight, sizeof(weights) );
Dylan Yudaken's avatar
Dylan Yudaken committed
356
    memset( &h->fenc->weight[1][0], 0, sizeof(x264_weight_t[15][3]) );
357 358 359 360 361 362 363

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

365
        for( i = 1; i < h->i_ref0; i++ )
Dylan Yudaken's avatar
Dylan Yudaken committed
366 367 368 369 370 371 372 373
            if( !frames[i]->b_duplicate || frames[i]->i_frame != h->fref0[ref-1]->i_frame )
                /* Favor lower POC as a tiebreaker. */
                COPY2_IF_GT( max, refcount[i], bestref, i );

        /* 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;
374
        h->fref0[ref] = frames[bestref];
Dylan Yudaken's avatar
Dylan Yudaken committed
375
        memcpy( h->fenc->weight[ref], weights[bestref], sizeof(weights[bestref]) );
376 377 378 379 380
    }

    return 0;
}

Fiona Glaser's avatar
Fiona Glaser committed
381 382 383
static char *x264_strcat_filename( char *input, char *suffix )
{
    char *output = x264_malloc( strlen( input ) + strlen( suffix ) + 1 );
384 385
    if( !output )
        return NULL;
Fiona Glaser's avatar
Fiona Glaser committed
386 387 388 389 390
    strcpy( output, input );
    strcat( output, suffix );
    return output;
}

391
int x264_ratecontrol_new( x264_t *h )
Laurent Aimar's avatar
Laurent Aimar committed
392
{
393
    x264_ratecontrol_t *rc;
394
    int i, j;
395

Loren Merritt's avatar
Loren Merritt committed
396
    x264_emms();
397

398 399
    CHECKED_MALLOCZERO( h->rc, h->param.i_threads * sizeof(x264_ratecontrol_t) );
    rc = h->rc;
400

401 402
    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
403

Måns Rullgård's avatar
Måns Rullgård committed
404 405 406 407 408 409
    /* FIXME: use integers */
    if(h->param.i_fps_num > 0 && h->param.i_fps_den > 0)
        rc->fps = (float) h->param.i_fps_num / h->param.i_fps_den;
    else
        rc->fps = 25.0;

Fiona Glaser's avatar
Fiona Glaser committed
410 411 412 413 414 415 416 417
    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;

418
    rc->bitrate = h->param.rc.i_bitrate * 1000.;
Loren Merritt's avatar
Loren Merritt committed
419
    rc->rate_tolerance = h->param.rc.f_rate_tolerance;
420
    rc->nmb = h->mb.i_mb_count;
Loren Merritt's avatar
Loren Merritt committed
421 422 423
    rc->last_non_b_pict_type = -1;
    rc->cbr_decay = 1.0;

424
    if( h->param.rc.i_rc_method == X264_RC_CRF && h->param.rc.b_stat_read )
425
    {
426
        x264_log(h, X264_LOG_ERROR, "constant rate-factor is incompatible with 2pass.\n");
427 428
        return -1;
    }
429
    if( h->param.rc.i_vbv_buffer_size )
430
    {
431
        if( h->param.rc.i_rc_method == X264_RC_CQP )
432
        {
433
            x264_log(h, X264_LOG_WARNING, "VBV is incompatible with constant QP, ignored.\n");
434 435 436
            h->param.rc.i_vbv_max_bitrate = 0;
            h->param.rc.i_vbv_buffer_size = 0;
        }
437 438
        else if( h->param.rc.i_vbv_max_bitrate == 0 )
        {
439 440 441 442 443 444 445 446 447 448
            if( h->param.rc.i_rc_method == X264_RC_ABR )
            {
                x264_log( h, X264_LOG_INFO, "VBV maxrate unspecified, assuming CBR\n" );
                h->param.rc.i_vbv_max_bitrate = h->param.rc.i_bitrate;
            }
            else
            {
                x264_log( h, X264_LOG_INFO, "VBV bufsize set but maxrate unspecified, ignored\n" );
                h->param.rc.i_vbv_buffer_size = 0;
            }
449
        }
450
    }
Loren Merritt's avatar
Loren Merritt committed
451 452
    if( h->param.rc.i_vbv_max_bitrate < h->param.rc.i_bitrate &&
        h->param.rc.i_vbv_max_bitrate > 0)
453
        x264_log(h, X264_LOG_WARNING, "max bitrate less than average bitrate, ignored.\n");
Loren Merritt's avatar
Loren Merritt committed
454 455 456
    else if( h->param.rc.i_vbv_max_bitrate > 0 &&
             h->param.rc.i_vbv_buffer_size > 0 )
    {
457
        if( h->param.rc.i_vbv_buffer_size < (int)(h->param.rc.i_vbv_max_bitrate / rc->fps) )
458
        {
459 460
            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",
Loren Merritt's avatar
Loren Merritt committed
461
                      h->param.rc.i_vbv_buffer_size );
462
        }
463 464
        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 );
465 466
        rc->buffer_rate = h->param.rc.i_vbv_max_bitrate * 1000. / rc->fps;
        rc->buffer_size = h->param.rc.i_vbv_buffer_size * 1000.;
467 468
        rc->single_frame_vbv = rc->buffer_rate * 1.1 > rc->buffer_size;
        h->param.rc.f_vbv_buffer_init = X264_MAX( h->param.rc.f_vbv_buffer_init, rc->buffer_rate / rc->buffer_size );
Loren Merritt's avatar
Loren Merritt committed
469
        rc->buffer_fill_final = rc->buffer_size * h->param.rc.f_vbv_buffer_init;
Loren Merritt's avatar
Loren Merritt committed
470 471
        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);
472
        rc->b_vbv = 1;
473 474 475
        rc->b_vbv_min_rate = !rc->b_2pass
                          && h->param.rc.i_rc_method == X264_RC_ABR
                          && h->param.rc.i_vbv_max_bitrate <= h->param.rc.i_bitrate;
Loren Merritt's avatar
Loren Merritt committed
476
    }
477
    else if( h->param.rc.i_vbv_max_bitrate )
478
    {
479
        x264_log(h, X264_LOG_WARNING, "VBV maxrate specified, but no bufsize.\n");
480 481
        h->param.rc.i_vbv_max_bitrate = 0;
    }
Fiona Glaser's avatar
Fiona Glaser committed
482 483
    if(rc->rate_tolerance < 0.01)
    {
484
        x264_log(h, X264_LOG_WARNING, "bitrate tolerance too small, using .01\n");
485 486
        rc->rate_tolerance = 0.01;
    }
487

488
    h->mb.b_variable_qp = rc->b_vbv || h->param.rc.i_aq_mode;
489

Loren Merritt's avatar
Loren Merritt committed
490 491
    if( rc->b_abr )
    {
492
        /* FIXME ABR_INIT_QP is actually used only in CRF */
Loren Merritt's avatar
Loren Merritt committed
493
#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
494 495
        rc->accum_p_norm = .01;
        rc->accum_p_qp = ABR_INIT_QP * rc->accum_p_norm;
496
        /* estimated ratio that produces a reasonable QP for the first I-frame */
Fiona Glaser's avatar
Fiona Glaser committed
497
        rc->cplxr_sum = .01 * pow( 7.0e5, rc->qcompress ) * pow( h->mb.i_mb_count, 0.5 );
498 499
        rc->wanted_bits_window = 1.0 * rc->bitrate / rc->fps;
        rc->last_non_b_pict_type = SLICE_TYPE_I;
500 501
    }

502
    if( h->param.rc.i_rc_method == X264_RC_CRF )
503
    {
Fiona Glaser's avatar
Fiona Glaser committed
504 505
        /* Arbitrary rescaling to make CRF somewhat similar to QP.
         * Try to compensate for MB-tree's effects as well. */
506
        double base_cplx = h->mb.i_mb_count * (h->param.i_bframe ? 120 : 80);
Fiona Glaser's avatar
Fiona Glaser committed
507 508 509
        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 );
510 511
    }

512 513
    rc->ip_offset = 6.0 * log(h->param.rc.f_ip_factor) / log(2.0);
    rc->pb_offset = 6.0 * log(h->param.rc.f_pb_factor) / log(2.0);
Loren Merritt's avatar
Loren Merritt committed
514
    rc->qp_constant[SLICE_TYPE_P] = h->param.rc.i_qp_constant;
515 516
    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
517
    h->mb.ip_offset = rc->ip_offset + 0.5;
518

Loren Merritt's avatar
Loren Merritt committed
519
    rc->lstep = pow( 2, h->param.rc.i_qp_step / 6.0 );
520
    rc->last_qscale = qp2qscale(26);
521 522
    CHECKED_MALLOC( rc->pred, 5*sizeof(predictor_t) );
    CHECKED_MALLOC( rc->pred_b_from_p, sizeof(predictor_t) );
523 524
    for( i = 0; i < 5; i++ )
    {
525
        rc->last_qscale_for[i] = qp2qscale( ABR_INIT_QP );
526 527
        rc->lmin[i] = qp2qscale( h->param.rc.i_qp_min );
        rc->lmax[i] = qp2qscale( h->param.rc.i_qp_max );
Loren Merritt's avatar
Loren Merritt committed
528 529 530
        rc->pred[i].coeff= 2.0;
        rc->pred[i].count= 1.0;
        rc->pred[i].decay= 0.5;
Fiona Glaser's avatar
Fiona Glaser committed
531
        rc->pred[i].offset= 0.0;
532 533 534 535 536 537 538
        for( j = 0; j < 2; j++ )
        {
            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;
        }
539
    }
Loren Merritt's avatar
Loren Merritt committed
540
    *rc->pred_b_from_p = rc->pred[0];
541

542
    if( parse_zones( h ) < 0 )
543 544
    {
        x264_log( h, X264_LOG_ERROR, "failed to parse zones\n" );
545
        return -1;
546
    }
Loren Merritt's avatar
Loren Merritt committed
547

548 549 550
    /* Load stat file and init 2pass algo */
    if( h->param.rc.b_stat_read )
    {
551
        char *p, *stats_in, *stats_buf;
552 553 554

        /* read 1st pass stats */
        assert( h->param.rc.psz_stat_in );
555 556
        stats_buf = stats_in = x264_slurp_file( h->param.rc.psz_stat_in );
        if( !stats_buf )
557 558 559 560
        {
            x264_log(h, X264_LOG_ERROR, "ratecontrol_init: can't open stats file\n");
            return -1;
        }
Fiona Glaser's avatar
Fiona Glaser committed
561 562 563
        if( h->param.rc.b_mb_tree )
        {
            char *mbtree_stats_in = x264_strcat_filename( h->param.rc.psz_stat_in, ".mbtree" );
564 565
            if( !mbtree_stats_in )
                return -1;
Fiona Glaser's avatar
Fiona Glaser committed
566 567 568 569 570 571 572 573
            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;
            }
        }
574

575 576 577
        /* check whether 1st pass options were compatible with current options */
        if( !strncmp( stats_buf, "#options:", 9 ) )
        {
578
            int i, j;
579 580 581 582 583 584
            char *opts = stats_buf;
            stats_in = strchr( stats_buf, '\n' );
            if( !stats_in )
                return -1;
            *stats_in = '\0';
            stats_in++;
585 586 587 588 589 590 591 592 593 594 595
            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;
            }
596

Fiona Glaser's avatar
Fiona Glaser committed
597 598 599 600 601
            CMP_OPT_FIRST_PASS( "wpredp", X264_MAX( 0, h->param.analyse.i_weighted_pred ) );
            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 );
602

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

606 607 608 609 610 611
            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;
            }

612 613
            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;
614
            else if( h->param.i_bframe )
615 616 617 618
            {
                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
619 620 621

            if( h->param.rc.b_mb_tree && ( p = strstr( opts, "rc_lookahead=" ) ) && sscanf( p, "rc_lookahead=%d", &i ) )
                h->param.rc.i_lookahead = i;
622 623
        }

624 625
        /* find number of pics */
        p = stats_in;
Loren Merritt's avatar
Loren Merritt committed
626
        for(i=-1; p; i++)
627
            p = strchr(p+1, ';');
Loren Merritt's avatar
Loren Merritt committed
628 629 630 631
        if(i==0)
        {
            x264_log(h, X264_LOG_ERROR, "empty stats file\n");
            return -1;
632
        }
633 634
        rc->num_entries = i;

635
        if( h->param.i_frame_total < rc->num_entries && h->param.i_frame_total > 0 )
636 637 638 639
        {
            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 );
        }
640
        if( h->param.i_frame_total > rc->num_entries )
641 642 643 644 645 646
        {
            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;
        }

647
        CHECKED_MALLOCZERO( rc->entry, rc->num_entries * sizeof(ratecontrol_entry_t) );
648 649

        /* init all to skipped p frames */
Fiona Glaser's avatar
Fiona Glaser committed
650 651
        for(i=0; i<rc->num_entries; i++)
        {
652
            ratecontrol_entry_t *rce = &rc->entry[i];
653
            rce->pict_type = SLICE_TYPE_P;
654 655 656 657 658 659 660
            rce->qscale = rce->new_qscale = qp2qscale(20);
            rce->misc_bits = rc->nmb + 10;
            rce->new_qp = 0;
        }

        /* read stats */
        p = stats_in;
661
        for(i=0; i < rc->num_entries; i++)
Fiona Glaser's avatar
Fiona Glaser committed
662
        {
663
            ratecontrol_entry_t *rce;
664 665
            int frame_number;
            char pict_type;
666 667 668
            int e;
            char *next;
            float qp;
669
            int ref;
670 671

            next= strchr(p, ';');
Fiona Glaser's avatar
Fiona Glaser committed
672 673 674
            if(next)
            {
                (*next)=0; //sscanf is unbelievably slow on long strings
675 676
                next++;
            }
677
            e = sscanf(p, " in:%d ", &frame_number);
678

Loren Merritt's avatar
Loren Merritt committed
679 680 681 682 683
            if(frame_number < 0 || frame_number >= rc->num_entries)
            {
                x264_log(h, X264_LOG_ERROR, "bad frame number (%d) at stats line %d\n", frame_number, i);
                return -1;
            }
684
            rce = &rc->entry[frame_number];
Loren Merritt's avatar
Loren Merritt committed
685
            rce->direct_mode = 0;
686

687 688
            e += sscanf(p, " in:%*d out:%*d type:%c q:%f tex:%d mv:%d misc:%d imb:%d pmb:%d smb:%d d:%c",
                   &pict_type, &qp, &rce->tex_bits,
Loren Merritt's avatar
Loren Merritt committed
689 690
                   &rce->mv_bits, &rce->misc_bits, &rce->i_count, &rce->p_count,
                   &rce->s_count, &rce->direct_mode);
691

692 693 694 695 696 697 698 699 700 701 702 703 704 705
            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
706 707 708 709
            /* find weights */
            rce->i_weight_denom = -1;
            char *w = strchr( p, 'w' );
            if( w )
710
                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
711 712
                    rce->i_weight_denom = -1;

713 714 715
            if( pict_type != 'b' )
                rce->kept_as_ref = 1;
            switch( pict_type )
Fiona Glaser's avatar
Fiona Glaser committed
716
            {
717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736
                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;
737 738
                default:  e = -1; break;
            }
Fiona Glaser's avatar
Fiona Glaser committed
739 740
            if(e < 10)
            {
741
parse_error:
742 743 744 745 746 747 748
                x264_log(h, X264_LOG_ERROR, "statistics are damaged at line %d, parser out=%d\n", i, e);
                return -1;
            }
            rce->qscale = qp2qscale(qp);
            p = next;
        }

749
        x264_free(stats_buf);
750

751
        if(h->param.rc.i_rc_method == X264_RC_ABR)
752 753
        {
            if(init_pass2(h) < 0) return -1;
Loren Merritt's avatar
Loren Merritt committed
754
        } /* else we're using constant quant, so no need to run the bitrate allocation */
755 756 757
    }

    /* Open output file */
758 759
    /* 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 */
760 761
    if( h->param.rc.b_stat_write )
    {
762
        char *p;
Fiona Glaser's avatar
Fiona Glaser committed
763
        rc->psz_stat_file_tmpname = x264_strcat_filename( h->param.rc.psz_stat_out, ".temp" );
764 765
        if( !rc->psz_stat_file_tmpname )
            return -1;
766 767

        rc->p_stat_file_out = fopen( rc->psz_stat_file_tmpname, "wb" );
768 769 770 771 772
        if( rc->p_stat_file_out == NULL )
        {
            x264_log(h, X264_LOG_ERROR, "ratecontrol_init: can't open stats file\n");
            return -1;
        }
773 774

        p = x264_param2string( &h->param, 1 );
775 776
        if( p )
            fprintf( rc->p_stat_file_out, "#options: %s\n", p );
777
        x264_free( p );
Fiona Glaser's avatar
Fiona Glaser committed
778 779 780 781
        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" );
782 783
            if( !rc->psz_mbtree_stat_file_tmpname || !rc->psz_mbtree_stat_file_name )
                return -1;
Fiona Glaser's avatar
Fiona Glaser committed
784 785 786 787 788 789 790 791 792 793 794

            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) )
795 796 797 798 799 800
    {
        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;
    }
801

802
    for( i=0; i<h->param.i_threads; i++ )
Loren Merritt's avatar
Loren Merritt committed
803 804
    {
        h->thread[i]->rc = rc+i;
805
        if( i )
806
        {
807
            rc[i] = rc[0];
Loren Merritt's avatar
Loren Merritt committed
808
            h->thread[i]->param = h->param;
809
            h->thread[i]->mb.b_variable_qp = h->mb.b_variable_qp;
810
        }
Loren Merritt's avatar
Loren Merritt committed
811 812
    }

813
    return 0;
814 815
fail:
    return -1;
Laurent Aimar's avatar
Laurent Aimar committed
816 817
}

818 819 820
static int parse_zone( x264_t *h, x264_zone_t *z, char *p )
{
    int len = 0;
821
    char *tok, UNUSED *saveptr=NULL;
822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837
    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;
838
    CHECKED_MALLOC( z->param, sizeof(x264_param_t) );
839
    memcpy( z->param, &h->param, sizeof(x264_param_t) );
840
    z->param->param_free = x264_free;
841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856
    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;
857 858
fail:
    return -1;
859 860
}

861 862 863 864 865 866
static int parse_zones( x264_t *h )
{
    x264_ratecontrol_t *rc = h->rc;
    int i;
    if( h->param.rc.psz_zones && !h->param.rc.i_zones )
    {
Steven Walters's avatar
Steven Walters committed
867
        char *psz_zones, *p;
868
        CHECKED_MALLOC( psz_zones, strlen( h->param.rc.psz_zones )+1 );
869
        strcpy( psz_zones, h->param.rc.psz_zones );
870
        h->param.rc.i_zones = 1;
871
        for( p = psz_zones; *p; p++ )
872
            h->param.rc.i_zones += (*p == '/');
873
        CHECKED_MALLOC( h->param.rc.zones, h->param.rc.i_zones * sizeof(x264_zone_t) );
874 875
        p = psz_zones;
        for( i = 0; i < h->param.rc.i_zones; i++ )
876
        {
Steven Walters's avatar
Steven Walters committed
877 878 879
            int i_tok = strcspn( p, "/" );
            p[i_tok] = 0;
            if( parse_zone( h, &h->param.rc.zones[i], p ) )
880
                return -1;
Steven Walters's avatar
Steven Walters committed
881
            p += i_tok + 1;
882
        }
883
        x264_free( psz_zones );
884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904
    }

    if( h->param.rc.i_zones > 0 )
    {
        for( i = 0; i < h->param.rc.i_zones; i++ )
        {
            x264_zone_t z = h->param.rc.zones[i];
            if( z.i_start < 0 || z.i_start > z.i_end )
            {
                x264_log( h, X264_LOG_ERROR, "invalid zone: start=%d end=%d\n",
                          z.i_start, z.i_end );
                return -1;
            }
            else if( !z.b_force_qp && z.f_bitrate_factor <= 0 )
            {
                x264_log( h, X264_LOG_ERROR, "invalid zone: bitrate_factor=%f\n",
                          z.f_bitrate_factor );
                return -1;
            }
        }

905
        rc->i_zones = h->param.rc.i_zones + 1;
906
        CHECKED_MALLOC( rc->zones, rc->i_zones * sizeof(x264_zone_t) );
907 908 909 910 911 912 913
        memcpy( rc->zones+1, h->param.rc.zones, (rc->i_zones-1