ratecontrol.c 44.7 KB
Newer Older
1
/***************************************************-*- coding: iso-8859-1 -*-
Laurent Aimar's avatar
Laurent Aimar committed
2 3
 * ratecontrol.c: h264 encoder library (Rate Control)
 *****************************************************************************
Loren Merritt's avatar
Loren Merritt committed
4
 * Copyright (C) 2005 x264 project
Laurent Aimar's avatar
Laurent Aimar committed
5 6
 * $Id: ratecontrol.c,v 1.1 2004/06/03 19:27:08 fenrir Exp $
 *
Loren Merritt's avatar
Loren Merritt committed
7 8 9
 * Authors: Loren Merritt <lorenm@u.washington.edu>
 *          Michael Niedermayer <michaelni@gmx.at>
 *          Mns Rullgrd <mru@mru.ath.cx>
Laurent Aimar's avatar
Laurent Aimar committed
10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
 *****************************************************************************/

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

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

38
#if defined(SYS_FREEBSD) || defined(SYS_BEOS) || defined(SYS_NETBSD)
39 40
#define exp2f(x) powf( 2, (x) )
#endif
41 42 43 44
#if defined(SYS_MACOSX)
#define exp2f(x) (float)pow( 2, (x) )
#define sqrtf sqrt
#endif
Loren Merritt's avatar
Loren Merritt committed
45 46 47
#if defined(_MSC_VER)
#define isfinite _finite
#endif
48
#if defined(_MSC_VER) || defined(SYS_SunOS)
49
#define exp2f(x) pow( 2, (x) )
50
#define sqrtf sqrt
51
#endif
52 53 54
#ifdef WIN32 // POSIX says that rename() removes the destination, but win32 doesn't.
#define rename(src,dst) (unlink(dst), rename(src,dst))
#endif
55 56 57 58

typedef struct
{
    int pict_type;
59
    int kept_as_ref;
60 61 62 63 64 65 66 67 68 69 70
    float qscale;
    int mv_bits;
    int i_tex_bits;
    int p_tex_bits;
    int misc_bits;
    uint64_t expected_bits;
    float new_qscale;
    int new_qp;
    int i_count;
    int p_count;
    int s_count;
Loren Merritt's avatar
Loren Merritt committed
71
    float blurred_complexity;
Loren Merritt's avatar
Loren Merritt committed
72
    char direct_mode;
73 74
} ratecontrol_entry_t;

Loren Merritt's avatar
Loren Merritt committed
75 76 77 78 79 80 81
typedef struct
{
    double coeff;
    double count;
    double decay;
} predictor_t;

82 83 84
struct x264_ratecontrol_t
{
    /* constants */
Loren Merritt's avatar
Loren Merritt committed
85 86
    int b_abr;
    int b_2pass;
87
    double fps;
Loren Merritt's avatar
Loren Merritt committed
88 89
    double bitrate;
    double rate_tolerance;
90
    int nmb;                    /* number of macroblocks in a frame */
91
    int qp_constant[5];
92

Loren Merritt's avatar
Loren Merritt committed
93 94
    /* current frame */
    ratecontrol_entry_t *rce;
95
    int qp;                     /* qp for current frame */
Loren Merritt's avatar
Loren Merritt committed
96 97
    float qpa;                  /* average of macroblocks' qp (same as qp if no adaptive quant) */
    int slice_type;
Måns Rullgård's avatar
Måns Rullgård committed
98
    int qp_force;
99

Loren Merritt's avatar
Loren Merritt committed
100 101 102 103 104 105 106 107 108 109 110 111 112 113 114
    /* VBV stuff */
    double buffer_size;
    double buffer_fill;
    double buffer_rate;         /* # of bits added to buffer_fill after each frame */
    predictor_t pred[5];        /* predict frame size from satd */

    /* ABR stuff */
    int    last_satd;
    double last_rceq;
    double cplxr_sum;           /* sum of bits*qscale/rceq */
    double expected_bits_sum;   /* sum of qscale2bits after rceq, ratefactor, and overflow */
    double wanted_bits_window;  /* target bitrate * window */
    double cbr_decay;
    double short_term_cplxsum;
    double short_term_cplxcount;
115
    double rate_factor_constant;
Loren Merritt's avatar
Loren Merritt committed
116

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

    int num_entries;            /* number of ratecontrol_entry_ts */
Loren Merritt's avatar
Loren Merritt committed
122
    ratecontrol_entry_t *entry; /* FIXME: copy needed data and free this once init is done */
123 124 125
    double last_qscale;
    double last_qscale_for[5];  /* last qscale for a specific pict type, used for max_diff & ipb factor stuff  */
    int last_non_b_pict_type;
126 127
    double accum_p_qp;          /* for determining I-frame quant */
    double accum_p_norm;
128
    double last_accum_p_norm;
129
    double lmin[5];             /* min qscale by frame type */
130
    double lmax[5];
Loren Merritt's avatar
Loren Merritt committed
131
    double lstep;               /* max change (multiply) in qscale per frame */
132 133 134 135
    double i_cplx_sum[5];       /* estimated total texture bits in intra MBs at qscale=1 */
    double p_cplx_sum[5];
    double mv_bits_sum[5];
    int frame_count[5];         /* number of frames of each type */
Loren Merritt's avatar
Loren Merritt committed
136 137 138

    int i_zones;
    x264_zone_t *zones;
139
};
Laurent Aimar's avatar
Laurent Aimar committed
140

141

142
static int parse_zones( x264_t *h );
143 144
static int init_pass2(x264_t *);
static float rate_estimate_qscale( x264_t *h, int pict_type );
Loren Merritt's avatar
Loren Merritt committed
145 146
static void update_vbv( x264_t *h, int bits );
int  x264_rc_analyse_slice( x264_t *h );
147 148 149

/* Terminology:
 * qp = h.264's quantizer
150
 * qscale = linearized quantizer = Lagrange multiplier
151 152 153 154 155 156 157 158 159 160
 */
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);
}

161 162 163 164
/* 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. */
165 166
static inline double qscale2bits(ratecontrol_entry_t *rce, double qscale)
{
Loren Merritt's avatar
Loren Merritt committed
167
    if(qscale<0.1)
168
        qscale = 0.1;
169
    return (rce->i_tex_bits + rce->p_tex_bits + .1) * pow( rce->qscale / qscale, 1.1 )
170 171
           + rce->mv_bits * pow( X264_MAX(rce->qscale, 12) / X264_MAX(qscale, 12), 0.5 )
           + rce->misc_bits;
172 173 174
}


175
int x264_ratecontrol_new( x264_t *h )
Laurent Aimar's avatar
Laurent Aimar committed
176
{
177 178
    x264_ratecontrol_t *rc;
    int i;
179

180 181 182
    x264_cpu_restore( h->param.cpu );

    h->rc = rc = x264_malloc( sizeof( x264_ratecontrol_t ) );
183 184
    memset(rc, 0, sizeof(*rc));

185
    rc->b_abr = ( h->param.rc.b_cbr || h->param.rc.i_rf_constant ) && !h->param.rc.b_stat_read;
Loren Merritt's avatar
Loren Merritt committed
186 187 188
    rc->b_2pass = h->param.rc.b_cbr && h->param.rc.b_stat_read;
    h->mb.b_variable_qp = 0;
    
Måns Rullgård's avatar
Måns Rullgård committed
189 190 191 192 193 194
    /* 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;

195
    rc->bitrate = h->param.rc.i_bitrate * 1000;
Loren Merritt's avatar
Loren Merritt committed
196
    rc->rate_tolerance = h->param.rc.f_rate_tolerance;
197
    rc->nmb = h->mb.i_mb_count;
Loren Merritt's avatar
Loren Merritt committed
198 199 200
    rc->last_non_b_pict_type = -1;
    rc->cbr_decay = 1.0;

201 202
    if( h->param.rc.i_rf_constant && h->param.rc.b_stat_read )
    {
203
        x264_log(h, X264_LOG_ERROR, "constant rate-factor is incompatible with 2pass.\n");
204 205
        return -1;
    }
206
    if( h->param.rc.i_vbv_buffer_size && !h->param.rc.b_cbr && !h->param.rc.i_rf_constant )
207
        x264_log(h, X264_LOG_ERROR, "VBV is incompatible with constant QP.\n");
208 209 210 211 212 213
    if( h->param.rc.i_vbv_buffer_size && h->param.rc.b_cbr
        && h->param.rc.i_vbv_max_bitrate == 0 )
    {
        x264_log( h, X264_LOG_DEBUG, "VBV maxrate unspecified, assuming CBR\n" );
        h->param.rc.i_vbv_max_bitrate = h->param.rc.i_bitrate;
    }
Loren Merritt's avatar
Loren Merritt committed
214 215 216 217 218 219 220 221 222 223
    if( h->param.rc.i_vbv_max_bitrate < h->param.rc.i_bitrate &&
        h->param.rc.i_vbv_max_bitrate > 0)
        x264_log(h, X264_LOG_ERROR, "max bitrate less than average bitrate, ignored.\n");
    else 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 < 10 * h->param.rc.i_vbv_max_bitrate / rc->fps ) {
            h->param.rc.i_vbv_buffer_size = 10 * h->param.rc.i_vbv_max_bitrate / rc->fps;
            x264_log( h, X264_LOG_ERROR, "VBV buffer size too small, using %d kbit\n",
                      h->param.rc.i_vbv_buffer_size );
224
        }
Loren Merritt's avatar
Loren Merritt committed
225 226 227 228 229 230
        rc->buffer_rate = h->param.rc.i_vbv_max_bitrate * 1000 / rc->fps;
        rc->buffer_size = h->param.rc.i_vbv_buffer_size * 1000;
        rc->buffer_fill = rc->buffer_size * h->param.rc.f_vbv_buffer_init;
        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);
    }
231 232
    else if( h->param.rc.i_vbv_max_bitrate )
        x264_log(h, X264_LOG_ERROR, "VBV maxrate specified, but no bufsize.\n");
233 234 235 236
    if(rc->rate_tolerance < 0.01) {
        x264_log(h, X264_LOG_ERROR, "bitrate tolerance too small, using .01\n");
        rc->rate_tolerance = 0.01;
    }
237

Loren Merritt's avatar
Loren Merritt committed
238 239 240 241
    if( rc->b_abr )
    {
        /* FIXME shouldn't need to arbitrarily specify a QP,
         * but this is more robust than BPP measures */
242
#define ABR_INIT_QP ( h->param.rc.i_rf_constant > 0 ? h->param.rc.i_rf_constant : 24 )
Loren Merritt's avatar
Loren Merritt committed
243 244 245 246
        rc->accum_p_norm = .01;
        rc->accum_p_qp = ABR_INIT_QP * rc->accum_p_norm;
        rc->cplxr_sum = .01;
        rc->wanted_bits_window = .01;
247 248
    }

249 250 251 252 253 254 255 256
    if( h->param.rc.i_rf_constant )
    {
        /* arbitrary rescaling to make CRF somewhat similar to QP */
        double base_cplx = h->mb.i_mb_count * (h->param.i_bframe ? 120 : 80);
        rc->rate_factor_constant = pow( base_cplx, 1 - h->param.rc.f_qcompress )
                                 / qp2qscale( h->param.rc.i_rf_constant );
    }

Loren Merritt's avatar
Loren Merritt committed
257 258 259
    rc->qp_constant[SLICE_TYPE_P] = h->param.rc.i_qp_constant;
    rc->qp_constant[SLICE_TYPE_I] = x264_clip3( (int)( qscale2qp( qp2qscale( h->param.rc.i_qp_constant ) / fabs( h->param.rc.f_ip_factor )) + 0.5 ), 0, 51 );
    rc->qp_constant[SLICE_TYPE_B] = x264_clip3( (int)( qscale2qp( qp2qscale( h->param.rc.i_qp_constant ) * fabs( h->param.rc.f_pb_factor )) + 0.5 ), 0, 51 );
260

Loren Merritt's avatar
Loren Merritt committed
261
    rc->lstep = exp2f(h->param.rc.i_qp_step / 6.0);
262
    rc->last_qscale = qp2qscale(26);
263 264 265 266 267
    for( i = 0; i < 5; i++ )
    {
        rc->last_qscale_for[i] = qp2qscale(26);
        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
268 269 270
        rc->pred[i].coeff= 2.0;
        rc->pred[i].count= 1.0;
        rc->pred[i].decay= 0.5;
271 272
    }

273 274
    if( parse_zones( h ) < 0 )
        return -1;
Loren Merritt's avatar
Loren Merritt committed
275

276 277 278
    /* Load stat file and init 2pass algo */
    if( h->param.rc.b_stat_read )
    {
279
        char *p, *stats_in, *stats_buf;
280 281 282

        /* read 1st pass stats */
        assert( h->param.rc.psz_stat_in );
283 284
        stats_buf = stats_in = x264_slurp_file( h->param.rc.psz_stat_in );
        if( !stats_buf )
285 286 287 288 289
        {
            x264_log(h, X264_LOG_ERROR, "ratecontrol_init: can't open stats file\n");
            return -1;
        }

290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322
        /* check whether 1st pass options were compatible with current options */
        if( !strncmp( stats_buf, "#options:", 9 ) )
        {
            int i;
            char *opts = stats_buf;
            stats_in = strchr( stats_buf, '\n' );
            if( !stats_in )
                return -1;
            *stats_in = '\0';
            stats_in++;

            if( ( p = strstr( opts, "bframes=" ) ) && sscanf( p, "bframes=%d", &i )
                && h->param.i_bframe != i )
            {
                x264_log( h, X264_LOG_ERROR, "different number of B-frames than 1st pass (%d vs %d)\n",
                          h->param.i_bframe, i );
                return -1;
            }

            /* since B-adapt doesn't (yet) take into account B-pyramid,
             * the converse is not a problem */
            if( strstr( opts, "b_pyramid=1" ) && !h->param.b_bframe_pyramid )
                x264_log( h, X264_LOG_WARNING, "1st pass used B-pyramid, 2nd doesn't\n" );

            if( ( p = strstr( opts, "keyint=" ) ) && sscanf( p, "keyint=%d", &i )
                && h->param.i_keyint_max != i )
                x264_log( h, X264_LOG_WARNING, "different keyint than 1st pass (%d vs %d)\n",
                          h->param.i_keyint_max, i );

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

323 324
        /* find number of pics */
        p = stats_in;
Loren Merritt's avatar
Loren Merritt committed
325
        for(i=-1; p; i++)
326
            p = strchr(p+1, ';');
Loren Merritt's avatar
Loren Merritt committed
327 328 329 330
        if(i==0)
        {
            x264_log(h, X264_LOG_ERROR, "empty stats file\n");
            return -1;
331
        }
332 333
        rc->num_entries = i;

334
        if( h->param.i_frame_total < rc->num_entries && h->param.i_frame_total > 0 )
335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350
        {
            x264_log( h, X264_LOG_WARNING, "2nd pass has fewer frames than 1st pass (%d vs %d)\n",
                      h->param.i_frame_total, rc->num_entries );
        }
        if( h->param.i_frame_total > rc->num_entries + h->param.i_bframe )
        {
            x264_log( h, X264_LOG_ERROR, "2nd pass has more frames than 1st pass (%d vs %d)\n",
                      h->param.i_frame_total, rc->num_entries );
            return -1;
        }

        /* FIXME: ugly padding because VfW drops delayed B-frames */
        rc->num_entries += h->param.i_bframe;

        rc->entry = (ratecontrol_entry_t*) x264_malloc(rc->num_entries * sizeof(ratecontrol_entry_t));
        memset(rc->entry, 0, rc->num_entries * sizeof(ratecontrol_entry_t));
351 352 353 354

        /* init all to skipped p frames */
        for(i=0; i<rc->num_entries; i++){
            ratecontrol_entry_t *rce = &rc->entry[i];
355
            rce->pict_type = SLICE_TYPE_P;
356 357 358 359 360 361 362 363 364
            rce->qscale = rce->new_qscale = qp2qscale(20);
            rce->misc_bits = rc->nmb + 10;
            rce->new_qp = 0;
        }

        /* read stats */
        p = stats_in;
        for(i=0; i < rc->num_entries - h->param.i_bframe; i++){
            ratecontrol_entry_t *rce;
365 366
            int frame_number;
            char pict_type;
367 368 369 370 371 372 373 374 375
            int e;
            char *next;
            float qp;

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

Loren Merritt's avatar
Loren Merritt committed
378 379 380 381 382
            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;
            }
383
            rce = &rc->entry[frame_number];
Loren Merritt's avatar
Loren Merritt committed
384
            rce->direct_mode = 0;
385

Loren Merritt's avatar
Loren Merritt committed
386
            e += sscanf(p, " in:%*d out:%*d type:%c q:%f itex:%d ptex:%d mv:%d misc:%d imb:%d pmb:%d smb:%d d:%c",
387
                   &pict_type, &qp, &rce->i_tex_bits, &rce->p_tex_bits,
Loren Merritt's avatar
Loren Merritt committed
388 389
                   &rce->mv_bits, &rce->misc_bits, &rce->i_count, &rce->p_count,
                   &rce->s_count, &rce->direct_mode);
390 391

            switch(pict_type){
392
                case 'I': rce->kept_as_ref = 1;
393 394
                case 'i': rce->pict_type = SLICE_TYPE_I; break;
                case 'P': rce->pict_type = SLICE_TYPE_P; break;
395 396
                case 'B': rce->kept_as_ref = 1;
                case 'b': rce->pict_type = SLICE_TYPE_B; break;
397 398
                default:  e = -1; break;
            }
Loren Merritt's avatar
Loren Merritt committed
399
            if(e < 10){
400 401 402 403 404 405 406
                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;
        }

407
        x264_free(stats_buf);
408

409 410 411
        if(h->param.rc.b_cbr)
        {
            if(init_pass2(h) < 0) return -1;
Loren Merritt's avatar
Loren Merritt committed
412
        } /* else we're using constant quant, so no need to run the bitrate allocation */
413 414 415
    }

    /* Open output file */
416 417
    /* 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 */
418 419
    if( h->param.rc.b_stat_write )
    {
420 421
        char *p;

422 423 424
        rc->psz_stat_file_tmpname = x264_malloc( strlen(h->param.rc.psz_stat_out) + 6 );
        strcpy( rc->psz_stat_file_tmpname, h->param.rc.psz_stat_out );
        strcat( rc->psz_stat_file_tmpname, ".temp" );
425 426

        rc->p_stat_file_out = fopen( rc->psz_stat_file_tmpname, "wb" );
427 428 429 430 431
        if( rc->p_stat_file_out == NULL )
        {
            x264_log(h, X264_LOG_ERROR, "ratecontrol_init: can't open stats file\n");
            return -1;
        }
432 433 434 435

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

    return 0;
Laurent Aimar's avatar
Laurent Aimar committed
439 440
}

441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 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
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 )
    {
        char *p;
        h->param.rc.i_zones = 1;
        for( p = h->param.rc.psz_zones; *p; p++ )
            h->param.rc.i_zones += (*p == '/');
        h->param.rc.zones = x264_malloc( h->param.rc.i_zones * sizeof(x264_zone_t) );
        p = h->param.rc.psz_zones;
        for( i = 0; i < h->param.rc.i_zones; i++)
        {
            x264_zone_t *z = &h->param.rc.zones[i];
            if( 3 == sscanf(p, "%u,%u,q=%u", &z->i_start, &z->i_end, &z->i_qp) )
                z->b_force_qp = 1;
            else if( 3 == sscanf(p, "%u,%u,b=%f", &z->i_start, &z->i_end, &z->f_bitrate_factor) )
                z->b_force_qp = 0;
            else
            {
                char *slash = strchr(p, '/');
                if(slash) *slash = '\0';
                x264_log( h, X264_LOG_ERROR, "invalid zone: \"%s\"\n", p );
                return -1;
            }
            p = strchr(p, '/') + 1;
        }
    }

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

        rc->i_zones = h->param.rc.i_zones;
        rc->zones = x264_malloc( rc->i_zones * sizeof(x264_zone_t) );
        memcpy( rc->zones, h->param.rc.zones, rc->i_zones * sizeof(x264_zone_t) );
    }

    return 0;
}

498 499 500 501 502 503 504 505 506 507 508 509
void x264_ratecontrol_summary( x264_t *h )
{
    x264_ratecontrol_t *rc = h->rc;
    if( rc->b_abr && !h->param.rc.i_rf_constant && !h->param.rc.i_vbv_max_bitrate )
    {
        double base_cplx = h->mb.i_mb_count * (h->param.i_bframe ? 120 : 80);
        x264_log( h, X264_LOG_INFO, "final ratefactor: %.2f\n", 
                  qscale2qp( pow( base_cplx, 1 - h->param.rc.f_qcompress )
                             * rc->cplxr_sum / rc->wanted_bits_window ) );
    }
}

510
void x264_ratecontrol_delete( x264_t *h )
Laurent Aimar's avatar
Laurent Aimar committed
511
{
512
    x264_ratecontrol_t *rc = h->rc;
513 514

    if( rc->p_stat_file_out )
515
    {
516
        fclose( rc->p_stat_file_out );
517 518 519 520 521 522 523
        if( h->i_frame >= rc->num_entries - h->param.i_bframe )
            if( rename( rc->psz_stat_file_tmpname, h->param.rc.psz_stat_out ) != 0 )
            {
                x264_log( h, X264_LOG_ERROR, "failed to rename \"%s\" to \"%s\"\n",
                          rc->psz_stat_file_tmpname, h->param.rc.psz_stat_out );
            }
        x264_free( rc->psz_stat_file_tmpname );
524
    }
Loren Merritt's avatar
Loren Merritt committed
525 526
    x264_free( rc->entry );
    x264_free( rc->zones );
Laurent Aimar's avatar
Laurent Aimar committed
527 528 529
    x264_free( rc );
}

Loren Merritt's avatar
Loren Merritt committed
530
/* Before encoding a frame, choose a QP for it */
Måns Rullgård's avatar
Måns Rullgård committed
531
void x264_ratecontrol_start( x264_t *h, int i_slice_type, int i_force_qp )
Laurent Aimar's avatar
Laurent Aimar committed
532
{
533
    x264_ratecontrol_t *rc = h->rc;
Loren Merritt's avatar
Loren Merritt committed
534
    ratecontrol_entry_t *rce = NULL;
535 536 537

    x264_cpu_restore( h->param.cpu );

Måns Rullgård's avatar
Måns Rullgård committed
538
    rc->qp_force = i_force_qp;
Loren Merritt's avatar
Loren Merritt committed
539
    rc->slice_type = i_slice_type;
Måns Rullgård's avatar
Måns Rullgård committed
540

Loren Merritt's avatar
Loren Merritt committed
541 542 543 544 545 546 547 548 549 550 551 552 553 554
    if( h->param.rc.b_stat_read )
    {
        int frame = h->fenc->i_frame;
        assert( frame >= 0 && frame < rc->num_entries );
        rce = h->rc->rce = &h->rc->entry[frame];

        if( i_slice_type == SLICE_TYPE_B
            && h->param.analyse.i_direct_mv_pred == X264_DIRECT_PRED_AUTO )
        {
            h->sh.b_direct_spatial_mv_pred = ( rce->direct_mode == 's' );
            h->mb.b_direct_auto_read = ( rce->direct_mode == 's' || rce->direct_mode == 't' );
        }
    }

Loren Merritt's avatar
Loren Merritt committed
555
    if( i_force_qp )
556
    {
Loren Merritt's avatar
Loren Merritt committed
557
        rc->qpa = rc->qp = i_force_qp - 1;
558
    }
Loren Merritt's avatar
Loren Merritt committed
559 560 561 562 563 564
    else if( rc->b_abr )
    {
        rc->qpa = rc->qp =
            x264_clip3( (int)(qscale2qp( rate_estimate_qscale( h, i_slice_type ) ) + .5), 0, 51 );
    }
    else if( rc->b_2pass )
565 566
    {
        rce->new_qscale = rate_estimate_qscale( h, i_slice_type );
Loren Merritt's avatar
Loren Merritt committed
567 568
        rc->qpa = rc->qp = rce->new_qp =
            x264_clip3( (int)(qscale2qp(rce->new_qscale) + 0.5), 0, 51 );
569
    }
Loren Merritt's avatar
Loren Merritt committed
570 571 572 573 574
    else /* CQP */
    {
        int q;
        if( i_slice_type == SLICE_TYPE_B && h->fdec->b_kept_as_ref )
            q = ( rc->qp_constant[ SLICE_TYPE_B ] + rc->qp_constant[ SLICE_TYPE_P ] ) / 2;
575
        else
Loren Merritt's avatar
Loren Merritt committed
576 577
            q = rc->qp_constant[ i_slice_type ];
        rc->qpa = rc->qp = q;
Måns Rullgård's avatar
Måns Rullgård committed
578
    }
Laurent Aimar's avatar
Laurent Aimar committed
579 580
}

581
void x264_ratecontrol_mb( x264_t *h, int bits )
Laurent Aimar's avatar
Laurent Aimar committed
582
{
Loren Merritt's avatar
Loren Merritt committed
583
    /* currently no adaptive quant */
Laurent Aimar's avatar
Laurent Aimar committed
584 585
}

Loren Merritt's avatar
Loren Merritt committed
586
int x264_ratecontrol_qp( x264_t *h )
Laurent Aimar's avatar
Laurent Aimar committed
587
{
Loren Merritt's avatar
Loren Merritt committed
588
    return h->rc->qp;
589
}
Laurent Aimar's avatar
Laurent Aimar committed
590

Loren Merritt's avatar
Loren Merritt committed
591
/* In 2pass, force the same frame types as in the 1st pass */
592 593
int x264_ratecontrol_slice_type( x264_t *h, int frame_num )
{
594
    x264_ratecontrol_t *rc = h->rc;
595 596
    if( h->param.rc.b_stat_read )
    {
597
        if( frame_num >= rc->num_entries )
598
        {
599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620
            /* We could try to initialize everything required for ABR and
             * adaptive B-frames, but that would be complicated.
             * So just calculate the average QP used so far. */

            h->param.rc.i_qp_constant = (h->stat.i_slice_count[SLICE_TYPE_P] == 0) ? 24
                                      : 1 + h->stat.i_slice_qp[SLICE_TYPE_P] / h->stat.i_slice_count[SLICE_TYPE_P];
            rc->qp_constant[SLICE_TYPE_P] = x264_clip3( h->param.rc.i_qp_constant, 0, 51 );
            rc->qp_constant[SLICE_TYPE_I] = x264_clip3( (int)( qscale2qp( qp2qscale( h->param.rc.i_qp_constant ) / fabs( h->param.rc.f_ip_factor )) + 0.5 ), 0, 51 );
            rc->qp_constant[SLICE_TYPE_B] = x264_clip3( (int)( qscale2qp( qp2qscale( h->param.rc.i_qp_constant ) * fabs( h->param.rc.f_pb_factor )) + 0.5 ), 0, 51 );

            x264_log(h, X264_LOG_ERROR, "2nd pass has more frames than 1st pass (%d)\n", rc->num_entries);
            x264_log(h, X264_LOG_ERROR, "continuing anyway, at constant QP=%d\n", h->param.rc.i_qp_constant);
            if( h->param.b_bframe_adaptive )
                x264_log(h, X264_LOG_ERROR, "disabling adaptive B-frames\n");

            rc->b_abr = 0;
            rc->b_2pass = 0;
            h->param.rc.b_cbr = 0;
            h->param.rc.b_stat_read = 0;
            h->param.b_bframe_adaptive = 0;
            if( h->param.i_bframe > 1 )
                h->param.i_bframe = 1;
621 622
            return X264_TYPE_P;
        }
623
        switch( rc->entry[frame_num].pict_type )
624 625
        {
            case SLICE_TYPE_I:
626
                return rc->entry[frame_num].kept_as_ref ? X264_TYPE_IDR : X264_TYPE_I;
627 628

            case SLICE_TYPE_B:
629
                return rc->entry[frame_num].kept_as_ref ? X264_TYPE_BREF : X264_TYPE_B;
630 631 632 633 634 635 636 637 638 639 640 641

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

Loren Merritt's avatar
Loren Merritt committed
642
/* After encoding one frame, save stats and update ratecontrol state */
643 644 645
void x264_ratecontrol_end( x264_t *h, int bits )
{
    x264_ratecontrol_t *rc = h->rc;
646
    const int *mbs = h->stat.frame.i_mb_count;
Loren Merritt's avatar
Loren Merritt committed
647
    int i;
Laurent Aimar's avatar
Laurent Aimar committed
648

649 650
    x264_cpu_restore( h->param.cpu );

651 652 653
    h->stat.frame.i_mb_count_skip = mbs[P_SKIP] + mbs[B_SKIP];
    h->stat.frame.i_mb_count_i = mbs[I_16x16] + mbs[I_8x8] + mbs[I_4x4];
    h->stat.frame.i_mb_count_p = mbs[P_L0] + mbs[P_8x8];
Loren Merritt's avatar
Loren Merritt committed
654
    for( i = B_DIRECT; i < B_8x8; i++ )
655
        h->stat.frame.i_mb_count_p += mbs[i];
Loren Merritt's avatar
Loren Merritt committed
656

657 658
    if( h->param.rc.b_stat_write )
    {
659
        char c_type = rc->slice_type==SLICE_TYPE_I ? (h->fenc->i_poc==0 ? 'I' : 'i')
660 661
                    : rc->slice_type==SLICE_TYPE_P ? 'P'
                    : h->fenc->b_kept_as_ref ? 'B' : 'b';
Loren Merritt's avatar
Loren Merritt committed
662 663 664 665 666 667
        int dir_frame = h->stat.frame.i_direct_score[1] - h->stat.frame.i_direct_score[0];
        int dir_avg = h->stat.i_direct_score[1] - h->stat.i_direct_score[0];
        char c_direct = h->mb.b_direct_auto_write ?
                        ( dir_frame>0 ? 's' : dir_frame<0 ? 't' : 
                          dir_avg>0 ? 's' : dir_avg<0 ? 't' : '-' )
                        : '-';
668
        fprintf( rc->p_stat_file_out,
Loren Merritt's avatar
Loren Merritt committed
669
                 "in:%d out:%d type:%c q:%.2f itex:%d ptex:%d mv:%d misc:%d imb:%d pmb:%d smb:%d d:%c;\n",
670
                 h->fenc->i_frame, h->i_frame-1,
671
                 c_type, rc->qpa,
672 673
                 h->stat.frame.i_itex_bits, h->stat.frame.i_ptex_bits,
                 h->stat.frame.i_hdr_bits, h->stat.frame.i_misc_bits,
674
                 h->stat.frame.i_mb_count_i,
Loren Merritt's avatar
Loren Merritt committed
675
                 h->stat.frame.i_mb_count_p,
Loren Merritt's avatar
Loren Merritt committed
676 677
                 h->stat.frame.i_mb_count_skip,
                 c_direct);
678 679
    }

Loren Merritt's avatar
Loren Merritt committed
680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700
    if( rc->b_abr )
    {
        if( rc->slice_type != SLICE_TYPE_B )
            rc->cplxr_sum += bits * qp2qscale(rc->qpa) / rc->last_rceq;
        else
        {
            /* Depends on the fact that B-frame's QP is an offset from the following P-frame's.
             * Not perfectly accurate with B-refs, but good enough. */
            rc->cplxr_sum += bits * qp2qscale(rc->qpa) / (rc->last_rceq * fabs(h->param.rc.f_pb_factor));
        }
        rc->cplxr_sum *= rc->cbr_decay;
        rc->wanted_bits_window += rc->bitrate / rc->fps;
        rc->wanted_bits_window *= rc->cbr_decay;

        rc->accum_p_qp   *= .95;
        rc->accum_p_norm *= .95;
        rc->accum_p_norm += 1;
        if( rc->slice_type == SLICE_TYPE_I )
            rc->accum_p_qp += rc->qpa * fabs(h->param.rc.f_ip_factor);
        else
            rc->accum_p_qp += rc->qpa;
Laurent Aimar's avatar
Laurent Aimar committed
701 702
    }

Loren Merritt's avatar
Loren Merritt committed
703 704 705
    if( rc->b_2pass )
    {
        rc->expected_bits_sum += qscale2bits( rc->rce, qp2qscale(rc->rce->new_qp) );
Laurent Aimar's avatar
Laurent Aimar committed
706 707
    }

Loren Merritt's avatar
Loren Merritt committed
708
    update_vbv( h, bits );
709

Loren Merritt's avatar
Loren Merritt committed
710 711
    if( rc->slice_type != SLICE_TYPE_B )
        rc->last_non_b_pict_type = rc->slice_type;
Laurent Aimar's avatar
Laurent Aimar committed
712
}
713 714 715 716

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

718 719 720 721 722 723
double x264_eval( char *s, double *const_value, const char **const_name,
                  double (**func1)(void *, double), const char **func1_name,
                  double (**func2)(void *, double, double), char **func2_name,
                  void *opaque );

/**
Loren Merritt's avatar
Loren Merritt committed
724
 * modify the bitrate curve from pass1 for one frame
725
 */
Loren Merritt's avatar
Loren Merritt committed
726
static double get_qscale(x264_t *h, ratecontrol_entry_t *rce, double rate_factor, int frame_num)
727 728
{
    x264_ratecontrol_t *rcc= h->rc;
729
    const int pict_type = rce->pict_type;
730
    double q;
Loren Merritt's avatar
Loren Merritt committed
731
    int i;
732 733 734 735 736

    double const_values[]={
        rce->i_tex_bits * rce->qscale,
        rce->p_tex_bits * rce->qscale,
        (rce->i_tex_bits + rce->p_tex_bits) * rce->qscale,
737
        rce->mv_bits * rce->qscale,
738 739 740 741 742 743 744 745 746 747 748 749
        (double)rce->i_count / rcc->nmb,
        (double)rce->p_count / rcc->nmb,
        (double)rce->s_count / rcc->nmb,
        rce->pict_type == SLICE_TYPE_I,
        rce->pict_type == SLICE_TYPE_P,
        rce->pict_type == SLICE_TYPE_B,
        h->param.rc.f_qcompress,
        rcc->i_cplx_sum[SLICE_TYPE_I] / rcc->frame_count[SLICE_TYPE_I],
        rcc->i_cplx_sum[SLICE_TYPE_P] / rcc->frame_count[SLICE_TYPE_P],
        rcc->p_cplx_sum[SLICE_TYPE_P] / rcc->frame_count[SLICE_TYPE_P],
        rcc->p_cplx_sum[SLICE_TYPE_B] / rcc->frame_count[SLICE_TYPE_B],
        (rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / rcc->frame_count[pict_type],
Loren Merritt's avatar
Loren Merritt committed
750
        rce->blurred_complexity,
751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769
        0
    };
    static const char *const_names[]={
        "iTex",
        "pTex",
        "tex",
        "mv",
        "iCount",
        "pCount",
        "sCount",
        "isI",
        "isP",
        "isB",
        "qComp",
        "avgIITex",
        "avgPITex",
        "avgPPTex",
        "avgBPTex",
        "avgTex",
770
        "blurCplx",
771 772 773
        NULL
    };
    static double (*func1[])(void *, double)={
774
//      (void *)bits2qscale,
775 776 777 778
        (void *)qscale2bits,
        NULL
    };
    static const char *func1_names[]={
779
//      "bits2qp",
780 781 782 783
        "qp2bits",
        NULL
    };

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

Loren Merritt's avatar
Loren Merritt committed
786
    // avoid NaN's in the rc_eq
787
    if(!isfinite(q) || rce->i_tex_bits + rce->p_tex_bits + rce->mv_bits == 0)
788
        q = rcc->last_qscale;
Loren Merritt's avatar
Loren Merritt committed
789 790 791
    else {
        rcc->last_rceq = q;
        q /= rate_factor;
792
        rcc->last_qscale = q;
Loren Merritt's avatar
Loren Merritt committed
793 794 795 796 797 798 799 800 801 802 803 804 805 806
    }

    for( i = rcc->i_zones-1; i >= 0; i-- )
    {
        x264_zone_t *z = &rcc->zones[i];
        if( frame_num >= z->i_start && frame_num <= z->i_end )
        {
            if( z->b_force_qp )
                q = qp2qscale(z->i_qp);
            else
                q /= z->f_bitrate_factor;
            break;
        }
    }
807

808
    return q;
809 810 811 812 813
}

static double get_diff_limited_q(x264_t *h, ratecontrol_entry_t *rce, double q)
{
    x264_ratecontrol_t *rcc = h->rc;
814
    const int pict_type = rce->pict_type;
815 816 817 818

    // force I/B quants as a function of P quants
    const double last_p_q    = rcc->last_qscale_for[SLICE_TYPE_P];
    const double last_non_b_q= rcc->last_qscale_for[rcc->last_non_b_pict_type];
819 820
    if( pict_type == SLICE_TYPE_I )
    {
821 822 823 824 825 826 827 828 829 830 831 832
        double iq = q;
        double pq = qp2qscale( rcc->accum_p_qp / rcc->accum_p_norm );
        double ip_factor = fabs( h->param.rc.f_ip_factor );
        /* don't apply ip_factor if the following frame is also I */
        if( rcc->accum_p_norm <= 0 )
            q = iq;
        else if( h->param.rc.f_ip_factor < 0 )
            q = iq / ip_factor;
        else if( rcc->accum_p_norm >= 1 )
            q = pq / ip_factor;
        else
            q = rcc->accum_p_norm * pq / ip_factor + (1 - rcc->accum_p_norm) * iq;
833 834 835 836 837
    }
    else if( pict_type == SLICE_TYPE_B )
    {
        if( h->param.rc.f_pb_factor > 0 )
            q = last_non_b_q;
838 839
        if( !rce->kept_as_ref )
            q *= fabs( h->param.rc.f_pb_factor );
840 841 842 843 844
    }
    else if( pict_type == SLICE_TYPE_P
             && rcc->last_non_b_pict_type == SLICE_TYPE_P
             && rce->i_tex_bits + rce->p_tex_bits == 0 )
    {
845
        q = last_p_q;
846
    }
847 848

    /* last qscale / qdiff stuff */
849 850
    if(rcc->last_non_b_pict_type==pict_type
       && (pict_type!=SLICE_TYPE_I || rcc->last_accum_p_norm < 1))
851 852
    {
        double last_q = rcc->last_qscale_for[pict_type];
Loren Merritt's avatar
Loren Merritt committed
853 854
        double max_qscale = last_q * rcc->lstep;
        double min_qscale = last_q / rcc->lstep;
855 856 857 858 859

        if     (q > max_qscale) q = max_qscale;
        else if(q < min_qscale) q = min_qscale;
    }

Loren Merritt's avatar
Loren Merritt committed
860
    rcc->last_qscale_for[pict_type] = q;
861 862
    if(pict_type!=SLICE_TYPE_B)
        rcc->last_non_b_pict_type = pict_type;
863 864
    if(pict_type==SLICE_TYPE_I)
    {
865
        rcc->last_accum_p_norm = rcc->accum_p_norm;
866 867 868 869 870 871 872 873 874
        rcc->accum_p_norm = 0;
        rcc->accum_p_qp = 0;
    }
    if(pict_type==SLICE_TYPE_P)
    {
        float mask = 1 - pow( (float)rce->i_count / rcc->nmb, 2 );
        rcc->accum_p_qp   = mask * (qscale2qp(q) + rcc->accum_p_qp);
        rcc->accum_p_norm = mask * (1 + rcc->accum_p_norm);
    }
875 876 877
    return q;
}

Loren Merritt's avatar
Loren Merritt committed
878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907
static double predict_size( predictor_t *p, double q, double var )
{
     return p->coeff*var / (q*p->count);
}

static void update_predictor( predictor_t *p, double q, double var, double bits )
{
    p->count *= p->decay;
    p->coeff *= p->decay;
    p->count ++;
    p->coeff += bits*q / var;
}

static void update_vbv( x264_t *h, int bits )
{
    x264_ratecontrol_t *rcc = h->rc;
    if( !rcc->buffer_size )
        return;

    rcc->buffer_fill += rcc->buffer_rate - bits;
    if( rcc->buffer_fill < 0 && !rcc->b_2pass )
        x264_log( h, X264_LOG_WARNING, "VBV underflow (%.0f bits)\n", rcc->buffer_fill );
    rcc->buffer_fill = x264_clip3( rcc->buffer_fill, 0, rcc->buffer_size );

    if(rcc->last_satd > 100)
        update_predictor( &rcc->pred[rcc->slice_type], qp2qscale(rcc->qpa), rcc->last_satd, bits );
}

// apply VBV constraints and clip qscale to between lmin and lmax
static double clip_qscale( x264_t *h, int pict_type, double q )
908
{
Loren Merritt's avatar
Loren Merritt committed
909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938
    x264_ratecontrol_t *rcc = h->rc;
    double lmin = rcc->lmin[pict_type];
    double lmax = rcc->lmax[pict_type];
    double q0 = q;

    /* B-frames are not directly subject to VBV,
     * since they are controlled by the P-frames' QPs.
     * FIXME: in 2pass we could modify previous frames' QP too,
     *        instead of waiting for the buffer to fill */
    if( rcc->buffer_size &&
        ( pict_type == SLICE_TYPE_P ||
          ( pict_type == SLICE_TYPE_I && rcc->last_non_b_pict_type == SLICE_TYPE_I ) ) )
    {
        if( rcc->buffer_fill/rcc->buffer_size < 0.5 )
            q /= x264_clip3f( 2.0*rcc->buffer_fill/rcc->buffer_size, 0.5, 1.0 );
    }
    /* Now a hard threshold to make sure the frame fits in VBV.
     * This one is mostly for I-frames. */
    if( rcc->buffer_size && rcc->last_satd > 0 )
    {
        double bits = predict_size( &rcc->pred[rcc->slice_type], q, rcc->last_satd );
        double qf = 1.0;
        if( bits > rcc->buffer_fill/2 )
            qf = x264_clip3f( rcc->buffer_fill/(2*bits), 0.2, 1.0 );
        q /= qf;
        bits *= qf;
        if( bits < rcc->buffer_rate/2 )
            q *= bits*2/rcc->buffer_rate;
        q = X264_MAX( q0, q );
    }
939

Loren Merritt's avatar
Loren Merritt committed
940
    if(lmin==lmax)
Loren Merritt's avatar
Loren Merritt committed
941
        return lmin;
Loren Merritt's avatar
Loren Merritt committed
942 943
    else if(rcc->b_2pass)
    {
944 945
        double min2 = log(lmin);
        double max2 = log(lmax);
Loren Merritt's avatar
Loren Merritt committed
946 947
        q = (log(q) - min2)/(max2-min2) - 0.5;
        q = 1.0/(1.0 + exp(-4*q));
948
        q = q*(max2-min2) + min2;
Loren Merritt's avatar
Loren Merritt committed
949
        return exp(q);
950
    }
Loren Merritt's avatar
Loren Merritt committed
951 952
    else
        return x264_clip3f(q, lmin, lmax);
953 954 955 956 957 958 959
}

// update qscale for 1 frame based on actual bits used so far
static float rate_estimate_qscale(x264_t *h, int pict_type)
{
    float q;
    x264_ratecontrol_t *rcc = h->rc;
Loren Merritt's avatar
Loren Merritt committed
960
    ratecontrol_entry_t rce;
961 962 963 964 965 966
    double lmin = rcc->lmin[pict_type];
    double lmax = rcc->lmax[pict_type];
    int64_t total_bits = 8*(h->stat.i_slice_size[SLICE_TYPE_I]
                          + h->stat.i_slice_size[SLICE_TYPE_P]
                          + h->stat.i_slice_size[SLICE_TYPE_B]);

Loren Merritt's avatar
Loren Merritt committed
967 968 969 970 971 972 973 974 975
    if( rcc->b_2pass )
    {
        rce = *rcc->rce;
        if(pict_type != rce.pict_type)
        {
            x264_log(h, X264_LOG_ERROR, "slice=%c but 2pass stats say %c\n",
                     slice_type_to_char[pict_type], slice_type_to_char[rce.pict_type]);
        }
    }
976

Loren Merritt's avatar
Loren Merritt committed
977
    if( pict_type == SLICE_TYPE_B )
978
    {
Loren Merritt's avatar
Loren Merritt committed
979
        rcc->last_satd = 0;
Loren Merritt's avatar
Loren Merritt committed
980
        if(h->fenc->b_kept_as_ref)
Loren Merritt's avatar
Loren Merritt committed
981
            q = rcc->last_qscale * sqrtf(h->param.rc.f_pb_factor);
982
        else
Loren Merritt's avatar