ratecontrol.c 41.8 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 30
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
31 32
#include <math.h>
#include <limits.h>
33
#include <assert.h>
Laurent Aimar's avatar
Laurent Aimar committed
34

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

39
#if defined(SYS_FREEBSD) || defined(SYS_BEOS) || defined(SYS_NETBSD)
40 41
#define exp2f(x) powf( 2, (x) )
#endif
42
#if defined(_MSC_VER) || defined(SYS_SunOS)
43
#define exp2f(x) pow( 2, (x) )
44
#define sqrtf sqrt
45
#endif
46 47 48
#ifdef WIN32 // POSIX says that rename() removes the destination, but win32 doesn't.
#define rename(src,dst) (unlink(dst), rename(src,dst))
#endif
49 50 51 52

typedef struct
{
    int pict_type;
53
    int kept_as_ref;
54 55 56 57 58 59 60 61 62 63 64
    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
65
    float blurred_complexity;
66 67
} ratecontrol_entry_t;

Loren Merritt's avatar
Loren Merritt committed
68 69 70 71 72 73 74
typedef struct
{
    double coeff;
    double count;
    double decay;
} predictor_t;

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

Loren Merritt's avatar
Loren Merritt committed
86 87
    /* current frame */
    ratecontrol_entry_t *rce;
88
    int qp;                     /* qp for current frame */
Loren Merritt's avatar
Loren Merritt committed
89 90
    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
91
    int qp_force;
92

Loren Merritt's avatar
Loren Merritt committed
93 94 95 96 97 98 99 100 101 102 103 104 105 106 107
    /* 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;
108
    double rate_factor_constant;
Loren Merritt's avatar
Loren Merritt committed
109

110 111
    /* 2pass stuff */
    FILE *p_stat_file_out;
112
    char *psz_stat_file_tmpname;
113 114

    int num_entries;            /* number of ratecontrol_entry_ts */
Loren Merritt's avatar
Loren Merritt committed
115
    ratecontrol_entry_t *entry; /* FIXME: copy needed data and free this once init is done */
116 117 118
    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;
119 120
    double accum_p_qp;          /* for determining I-frame quant */
    double accum_p_norm;
121
    double last_accum_p_norm;
122
    double lmin[5];             /* min qscale by frame type */
123
    double lmax[5];
Loren Merritt's avatar
Loren Merritt committed
124
    double lstep;               /* max change (multiply) in qscale per frame */
125 126 127 128
    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
129 130 131

    int i_zones;
    x264_zone_t *zones;
132
};
Laurent Aimar's avatar
Laurent Aimar committed
133

134

135
static int parse_zones( x264_t *h );
136 137
static int init_pass2(x264_t *);
static float rate_estimate_qscale( x264_t *h, int pict_type );
Loren Merritt's avatar
Loren Merritt committed
138 139
static void update_vbv( x264_t *h, int bits );
int  x264_rc_analyse_slice( x264_t *h );
140 141 142

/* Terminology:
 * qp = h.264's quantizer
143
 * qscale = linearized quantizer = Lagrange multiplier
144 145 146 147 148 149 150 151 152 153
 */
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);
}

154 155 156 157
/* 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. */
158 159
static inline double qscale2bits(ratecontrol_entry_t *rce, double qscale)
{
Loren Merritt's avatar
Loren Merritt committed
160
    if(qscale<0.1)
161
        qscale = 0.1;
162 163
    return (rce->i_tex_bits + rce->p_tex_bits + .1) * pow( rce->qscale / qscale, 1.1 )
           + rce->mv_bits * pow( X264_MAX(rce->qscale, 12) / X264_MAX(qscale, 12), 0.5 );
164 165 166
}


167
int x264_ratecontrol_new( x264_t *h )
Laurent Aimar's avatar
Laurent Aimar committed
168
{
169 170
    x264_ratecontrol_t *rc;
    int i;
171

172 173 174
    x264_cpu_restore( h->param.cpu );

    h->rc = rc = x264_malloc( sizeof( x264_ratecontrol_t ) );
175 176
    memset(rc, 0, sizeof(*rc));

177
    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
178 179 180
    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
181 182 183 184 185 186
    /* 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;

187
    rc->bitrate = h->param.rc.i_bitrate * 1000;
Loren Merritt's avatar
Loren Merritt committed
188
    rc->rate_tolerance = h->param.rc.f_rate_tolerance;
189
    rc->nmb = h->mb.i_mb_count;
Loren Merritt's avatar
Loren Merritt committed
190 191 192
    rc->last_non_b_pict_type = -1;
    rc->cbr_decay = 1.0;

193 194
    if( rc->b_2pass && h->param.rc.i_rf_constant )
        x264_log(h, X264_LOG_ERROR, "constant rate-factor is incompatible with 2pass.\n");
195 196
    if( h->param.rc.i_vbv_max_bitrate && !h->param.rc.b_cbr && !h->param.rc.i_rf_constant )
        x264_log(h, X264_LOG_ERROR, "VBV is incompatible with constant QP.\n");
Loren Merritt's avatar
Loren Merritt committed
197 198 199 200 201 202 203 204 205 206
    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 );
207
        }
Loren Merritt's avatar
Loren Merritt committed
208 209 210 211 212 213 214 215
        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);
    }
    else if( h->param.rc.i_vbv_max_bitrate || h->param.rc.i_vbv_buffer_size )
        x264_log(h, X264_LOG_ERROR, "VBV maxrate or buffer size specified, but not both.\n");
216 217 218 219
    if(rc->rate_tolerance < 0.01) {
        x264_log(h, X264_LOG_ERROR, "bitrate tolerance too small, using .01\n");
        rc->rate_tolerance = 0.01;
    }
220

Loren Merritt's avatar
Loren Merritt committed
221 222 223 224
    if( rc->b_abr )
    {
        /* FIXME shouldn't need to arbitrarily specify a QP,
         * but this is more robust than BPP measures */
225
#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
226 227 228 229
        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;
230 231
    }

232 233 234 235 236 237 238 239
    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
240 241 242
    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 );
243

Loren Merritt's avatar
Loren Merritt committed
244
    rc->lstep = exp2f(h->param.rc.i_qp_step / 6.0);
245
    rc->last_qscale = qp2qscale(26);
246 247 248 249 250
    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
251 252 253
        rc->pred[i].coeff= 2.0;
        rc->pred[i].count= 1.0;
        rc->pred[i].decay= 0.5;
254 255
    }

256 257
    if( parse_zones( h ) < 0 )
        return -1;
Loren Merritt's avatar
Loren Merritt committed
258

259 260 261 262 263 264 265
    /* Load stat file and init 2pass algo */
    if( h->param.rc.b_stat_read )
    {
        char *p, *stats_in;

        /* read 1st pass stats */
        assert( h->param.rc.psz_stat_in );
Loren Merritt's avatar
Loren Merritt committed
266 267
        stats_in = x264_slurp_file( h->param.rc.psz_stat_in );
        if( !stats_in )
268 269 270 271 272 273 274
        {
            x264_log(h, X264_LOG_ERROR, "ratecontrol_init: can't open stats file\n");
            return -1;
        }

        /* find number of pics */
        p = stats_in;
Loren Merritt's avatar
Loren Merritt committed
275
        for(i=-1; p; i++)
276
            p = strchr(p+1, ';');
Loren Merritt's avatar
Loren Merritt committed
277 278 279 280
        if(i==0)
        {
            x264_log(h, X264_LOG_ERROR, "empty stats file\n");
            return -1;
281
        }
282 283
        rc->num_entries = i;

284
        if( h->param.i_frame_total < rc->num_entries && h->param.i_frame_total > 0 )
285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300
        {
            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));
301 302 303 304

        /* init all to skipped p frames */
        for(i=0; i<rc->num_entries; i++){
            ratecontrol_entry_t *rce = &rc->entry[i];
305
            rce->pict_type = SLICE_TYPE_P;
306 307 308 309 310 311 312 313 314
            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;
315 316
            int frame_number;
            char pict_type;
317 318 319 320 321 322 323 324 325
            int e;
            char *next;
            float qp;

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

Loren Merritt's avatar
Loren Merritt committed
328 329 330 331 332
            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;
            }
333
            rce = &rc->entry[frame_number];
334

335 336
            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",
                   &pict_type, &qp, &rce->i_tex_bits, &rce->p_tex_bits,
337
                   &rce->mv_bits, &rce->misc_bits, &rce->i_count, &rce->p_count, &rce->s_count);
338 339

            switch(pict_type){
340
                case 'I': rce->kept_as_ref = 1;
341 342
                case 'i': rce->pict_type = SLICE_TYPE_I; break;
                case 'P': rce->pict_type = SLICE_TYPE_P; break;
343 344
                case 'B': rce->kept_as_ref = 1;
                case 'b': rce->pict_type = SLICE_TYPE_B; break;
345 346
                default:  e = -1; break;
            }
347 348 349 350 351 352 353 354 355 356
            if(e != 10){
                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;
        }

        x264_free(stats_in);

357 358 359
        if(h->param.rc.b_cbr)
        {
            if(init_pass2(h) < 0) return -1;
Loren Merritt's avatar
Loren Merritt committed
360
        } /* else we're using constant quant, so no need to run the bitrate allocation */
361 362 363
    }

    /* Open output file */
364 365
    /* 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 */
366 367
    if( h->param.rc.b_stat_write )
    {
368 369 370
        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" );
371 372

        rc->p_stat_file_out = fopen( rc->psz_stat_file_tmpname, "wb" );
373 374 375 376 377 378
        if( rc->p_stat_file_out == NULL )
        {
            x264_log(h, X264_LOG_ERROR, "ratecontrol_init: can't open stats file\n");
            return -1;
        }
    }
379 380

    return 0;
Laurent Aimar's avatar
Laurent Aimar committed
381 382
}

383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439
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;
}

440 441 442 443 444 445 446 447 448 449 450 451
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 ) );
    }
}

452
void x264_ratecontrol_delete( x264_t *h )
Laurent Aimar's avatar
Laurent Aimar committed
453
{
454
    x264_ratecontrol_t *rc = h->rc;
455 456

    if( rc->p_stat_file_out )
457
    {
458
        fclose( rc->p_stat_file_out );
459 460 461 462 463 464 465
        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 );
466
    }
Loren Merritt's avatar
Loren Merritt committed
467 468
    x264_free( rc->entry );
    x264_free( rc->zones );
Laurent Aimar's avatar
Laurent Aimar committed
469 470 471
    x264_free( rc );
}

Loren Merritt's avatar
Loren Merritt committed
472
/* Before encoding a frame, choose a QP for it */
Måns Rullgård's avatar
Måns Rullgård committed
473
void x264_ratecontrol_start( x264_t *h, int i_slice_type, int i_force_qp )
Laurent Aimar's avatar
Laurent Aimar committed
474
{
475 476 477 478
    x264_ratecontrol_t *rc = h->rc;

    x264_cpu_restore( h->param.cpu );

Måns Rullgård's avatar
Måns Rullgård committed
479
    rc->qp_force = i_force_qp;
Loren Merritt's avatar
Loren Merritt committed
480
    rc->slice_type = i_slice_type;
Måns Rullgård's avatar
Måns Rullgård committed
481

Loren Merritt's avatar
Loren Merritt committed
482
    if( i_force_qp )
483
    {
Loren Merritt's avatar
Loren Merritt committed
484
        rc->qpa = rc->qp = i_force_qp - 1;
485
    }
Loren Merritt's avatar
Loren Merritt committed
486 487 488 489 490 491
    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 )
492 493
    {
        int frame = h->fenc->i_frame;
494
        ratecontrol_entry_t *rce;
495
        assert( frame >= 0 && frame < rc->num_entries );
Loren Merritt's avatar
Loren Merritt committed
496
        rce = h->rc->rce = &h->rc->entry[frame];
497 498

        rce->new_qscale = rate_estimate_qscale( h, i_slice_type );
Loren Merritt's avatar
Loren Merritt committed
499 500
        rc->qpa = rc->qp = rce->new_qp =
            x264_clip3( (int)(qscale2qp(rce->new_qscale) + 0.5), 0, 51 );
501
    }
Loren Merritt's avatar
Loren Merritt committed
502 503 504 505 506
    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;
507
        else
Loren Merritt's avatar
Loren Merritt committed
508 509
            q = rc->qp_constant[ i_slice_type ];
        rc->qpa = rc->qp = q;
Måns Rullgård's avatar
Måns Rullgård committed
510
    }
Laurent Aimar's avatar
Laurent Aimar committed
511 512
}

513
void x264_ratecontrol_mb( x264_t *h, int bits )
Laurent Aimar's avatar
Laurent Aimar committed
514
{
Loren Merritt's avatar
Loren Merritt committed
515
    /* currently no adaptive quant */
Laurent Aimar's avatar
Laurent Aimar committed
516 517
}

Loren Merritt's avatar
Loren Merritt committed
518
int x264_ratecontrol_qp( x264_t *h )
Laurent Aimar's avatar
Laurent Aimar committed
519
{
Loren Merritt's avatar
Loren Merritt committed
520
    return h->rc->qp;
521
}
Laurent Aimar's avatar
Laurent Aimar committed
522

Loren Merritt's avatar
Loren Merritt committed
523
/* In 2pass, force the same frame types as in the 1st pass */
524 525
int x264_ratecontrol_slice_type( x264_t *h, int frame_num )
{
526
    x264_ratecontrol_t *rc = h->rc;
527 528
    if( h->param.rc.b_stat_read )
    {
529
        if( frame_num >= rc->num_entries )
530
        {
531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552
            /* 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;
553 554
            return X264_TYPE_P;
        }
555
        switch( rc->entry[frame_num].pict_type )
556 557
        {
            case SLICE_TYPE_I:
558
                return rc->entry[frame_num].kept_as_ref ? X264_TYPE_IDR : X264_TYPE_I;
559 560

            case SLICE_TYPE_B:
561
                return rc->entry[frame_num].kept_as_ref ? X264_TYPE_BREF : X264_TYPE_B;
562 563 564 565 566 567 568 569 570 571 572 573

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

Loren Merritt's avatar
Loren Merritt committed
574
/* After encoding one frame, save stats and update ratecontrol state */
575 576 577
void x264_ratecontrol_end( x264_t *h, int bits )
{
    x264_ratecontrol_t *rc = h->rc;
578
    const int *mbs = h->stat.frame.i_mb_count;
Loren Merritt's avatar
Loren Merritt committed
579
    int i;
Laurent Aimar's avatar
Laurent Aimar committed
580

581 582
    x264_cpu_restore( h->param.cpu );

583 584 585
    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
586
    for( i = B_DIRECT; i < B_8x8; i++ )
587
        h->stat.frame.i_mb_count_p += mbs[i];
Loren Merritt's avatar
Loren Merritt committed
588

589 590
    if( h->param.rc.b_stat_write )
    {
591
        char c_type = rc->slice_type==SLICE_TYPE_I ? (h->fenc->i_poc==0 ? 'I' : 'i')
592 593
                    : rc->slice_type==SLICE_TYPE_P ? 'P'
                    : h->fenc->b_kept_as_ref ? 'B' : 'b';
594
        fprintf( rc->p_stat_file_out,
Loren Merritt's avatar
Loren Merritt committed
595
                 "in:%d out:%d type:%c q:%.2f itex:%d ptex:%d mv:%d misc:%d imb:%d pmb:%d smb:%d;\n",
596
                 h->fenc->i_frame, h->i_frame-1,
597
                 c_type, rc->qpa,
598 599
                 h->stat.frame.i_itex_bits, h->stat.frame.i_ptex_bits,
                 h->stat.frame.i_hdr_bits, h->stat.frame.i_misc_bits,
600
                 h->stat.frame.i_mb_count_i,
Loren Merritt's avatar
Loren Merritt committed
601 602
                 h->stat.frame.i_mb_count_p,
                 h->stat.frame.i_mb_count_skip);
603 604
    }

Loren Merritt's avatar
Loren Merritt committed
605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625
    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
626 627
    }

Loren Merritt's avatar
Loren Merritt committed
628 629 630
    if( rc->b_2pass )
    {
        rc->expected_bits_sum += qscale2bits( rc->rce, qp2qscale(rc->rce->new_qp) );
Laurent Aimar's avatar
Laurent Aimar committed
631 632
    }

Loren Merritt's avatar
Loren Merritt committed
633
    update_vbv( h, bits );
634

Loren Merritt's avatar
Loren Merritt committed
635 636
    if( rc->slice_type != SLICE_TYPE_B )
        rc->last_non_b_pict_type = rc->slice_type;
Laurent Aimar's avatar
Laurent Aimar committed
637
}
638 639 640 641

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

643 644 645 646 647 648
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
649
 * modify the bitrate curve from pass1 for one frame
650
 */
Loren Merritt's avatar
Loren Merritt committed
651
static double get_qscale(x264_t *h, ratecontrol_entry_t *rce, double rate_factor, int frame_num)
652 653
{
    x264_ratecontrol_t *rcc= h->rc;
654
    const int pict_type = rce->pict_type;
655
    double q;
Loren Merritt's avatar
Loren Merritt committed
656
    int i;
657 658 659 660 661

    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,
662
        rce->mv_bits * rce->qscale,
663 664 665 666 667 668 669 670 671 672 673 674
        (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
675
        rce->blurred_complexity,
676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694
        0
    };
    static const char *const_names[]={
        "iTex",
        "pTex",
        "tex",
        "mv",
        "iCount",
        "pCount",
        "sCount",
        "isI",
        "isP",
        "isB",
        "qComp",
        "avgIITex",
        "avgPITex",
        "avgPPTex",
        "avgBPTex",
        "avgTex",
695
        "blurCplx",
696 697 698
        NULL
    };
    static double (*func1[])(void *, double)={
699
//      (void *)bits2qscale,
700 701 702 703
        (void *)qscale2bits,
        NULL
    };
    static const char *func1_names[]={
704
//      "bits2qp",
705 706 707 708
        "qp2bits",
        NULL
    };

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

Loren Merritt's avatar
Loren Merritt committed
711
    // avoid NaN's in the rc_eq
712 713
    if(q != q || rce->i_tex_bits + rce->p_tex_bits + rce->mv_bits == 0)
        q = rcc->last_qscale;
Loren Merritt's avatar
Loren Merritt committed
714 715 716
    else {
        rcc->last_rceq = q;
        q /= rate_factor;
717
        rcc->last_qscale = q;
Loren Merritt's avatar
Loren Merritt committed
718 719 720 721 722 723 724 725 726 727 728 729 730 731
    }

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

733
    return q;
734 735 736 737 738
}

static double get_diff_limited_q(x264_t *h, ratecontrol_entry_t *rce, double q)
{
    x264_ratecontrol_t *rcc = h->rc;
739
    const int pict_type = rce->pict_type;
740 741 742 743

    // 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];
744 745
    if( pict_type == SLICE_TYPE_I )
    {
746 747 748 749 750 751 752 753 754 755 756 757
        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;
758 759 760 761 762
    }
    else if( pict_type == SLICE_TYPE_B )
    {
        if( h->param.rc.f_pb_factor > 0 )
            q = last_non_b_q;
763 764
        if( !rce->kept_as_ref )
            q *= fabs( h->param.rc.f_pb_factor );
765 766 767 768 769
    }
    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 )
    {
770
        q = last_p_q;
771
    }
772 773

    /* last qscale / qdiff stuff */
774 775
    if(rcc->last_non_b_pict_type==pict_type
       && (pict_type!=SLICE_TYPE_I || rcc->last_accum_p_norm < 1))
776 777
    {
        double last_q = rcc->last_qscale_for[pict_type];
Loren Merritt's avatar
Loren Merritt committed
778 779
        double max_qscale = last_q * rcc->lstep;
        double min_qscale = last_q / rcc->lstep;
780 781 782 783 784

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

Loren Merritt's avatar
Loren Merritt committed
785
    rcc->last_qscale_for[pict_type] = q;
786 787
    if(pict_type!=SLICE_TYPE_B)
        rcc->last_non_b_pict_type = pict_type;
788 789
    if(pict_type==SLICE_TYPE_I)
    {
790
        rcc->last_accum_p_norm = rcc->accum_p_norm;
791 792 793 794 795 796 797 798 799
        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);
    }
800 801 802
    return q;
}

Loren Merritt's avatar
Loren Merritt committed
803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832
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 )
833
{
Loren Merritt's avatar
Loren Merritt committed
834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863
    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 );
    }
864

Loren Merritt's avatar
Loren Merritt committed
865
    if(lmin==lmax)
Loren Merritt's avatar
Loren Merritt committed
866
        return lmin;
Loren Merritt's avatar
Loren Merritt committed
867 868
    else if(rcc->b_2pass)
    {
869 870
        double min2 = log(lmin);
        double max2 = log(lmax);
Loren Merritt's avatar
Loren Merritt committed
871 872
        q = (log(q) - min2)/(max2-min2) - 0.5;
        q = 1.0/(1.0 + exp(-4*q));
873
        q = q*(max2-min2) + min2;
Loren Merritt's avatar
Loren Merritt committed
874
        return exp(q);
875
    }
Loren Merritt's avatar
Loren Merritt committed
876 877
    else
        return x264_clip3f(q, lmin, lmax);
878 879 880 881 882 883 884
}

// 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
885
    ratecontrol_entry_t rce;
886 887 888 889 890 891
    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
892 893 894 895 896 897 898 899 900
    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]);
        }
    }
901

Loren Merritt's avatar
Loren Merritt committed
902
    if( pict_type == SLICE_TYPE_B )
903
    {
Loren Merritt's avatar
Loren Merritt committed
904
        rcc->last_satd = 0;
Loren Merritt's avatar
Loren Merritt committed
905
        if(h->fenc->b_kept_as_ref)
Loren Merritt's avatar
Loren Merritt committed
906
            q = rcc->last_qscale * sqrtf(h->param.rc.f_pb_factor);
907
        else
Loren Merritt's avatar
Loren Merritt committed
908 909
            q = rcc->last_qscale * h->param.rc.f_pb_factor;
        return x264_clip3f(q, lmin, lmax);
910 911 912
    }
    else
    {
Loren Merritt's avatar
Loren Merritt committed
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 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959
        double abr_buffer = 2 * rcc->rate_tolerance * rcc->bitrate;
        if( rcc->b_2pass )
        {
            //FIXME adjust abr_buffer based on distance to the end of the video
            int64_t diff = total_bits - (int64_t)rce.expected_bits;
            q = rce.new_qscale;
            q /= x264_clip3f((double)(abr_buffer - diff) / abr_buffer, .5, 2);
            if( h->fenc->i_frame > 30 )
            {
                /* Adjust quant based on the difference between
                 * achieved and expected bitrate so far */
                double time = (double)h->fenc->i_frame / rcc->num_entries;
                double w = x264_clip3f( time*100, 0.0, 1.0 );
                q *= pow( (double)total_bits / rcc->expected_bits_sum, w );
            }
            q = x264_clip3f( q, lmin, lmax );
        }
        else /* 1pass ABR */
        {
            /* Calculate the quantizer which would have produced the desired
             * average bitrate if it had been applied to all frames so far.
             * Then modulate that quant based on the current frame's complexity
             * relative to the average complexity so far (using the 2pass RCEQ).
             * Then bias the quant up or down if total size so far was far from
             * the target.
             * Result: Depending on the value of rate_tolerance, there is a
             * tradeoff between quality and bitrate precision. But at large
             * tolerances, the bit distribution approaches that of 2pass. */

            double wanted_bits, overflow, lmin, lmax;

            rcc->last_satd = x264_rc_analyse_slice( h );
            rcc->short_term_cplxsum *= 0.5;
            rcc->short_term_cplxcount *= 0.5;
            rcc->short_term_cplxsum += rcc->last_satd;
            rcc->short_term_cplxcount ++;

            rce.p_tex_bits = rcc->last_satd;
            rce.blurred_complexity = rcc->short_term_cplxsum / rcc->short_term_cplxcount;
            rce.i_tex_bits = 0;
            rce.mv_bits = 0;
            rce.p_count = rcc->nmb;
            rce.i_count = 0;
            rce.s_count = 0;
            rce.qscale = 1;
            rce.pict_type = pict_type;

960 961 962 963 964 965 966 967 968 969 970 971 972 973
            if( h->param.rc.i_rf_constant )
            {
                q = get_qscale( h, &rce, rcc->rate_factor_constant, h->fenc->i_frame );
                overflow = 1;
            }
            else
            {
                q = get_qscale( h, &rce, rcc->wanted_bits_window / rcc->cplxr_sum, h->fenc->i_frame );

                wanted_bits = h->fenc->i_frame * rcc->bitrate / rcc->fps;
                abr_buffer *= X264_MAX( 1, sqrt(h->fenc->i_frame/25) );
                overflow = x264_clip3f( 1.0 + (total_bits - wanted_bits) / abr_buffer, .5, 2 );
                q *= overflow;
            }
Loren Merritt's avatar
Loren Merritt committed
974

975
            if( pict_type == SLICE_TYPE_I && h->param.i_keyint_max > 1
Loren Merritt's avatar
Loren Merritt committed
976 977 978 979 980 981 982 983 984
                /* should test _next_ pict type, but that isn't decided yet */
                && rcc->last_non_b_pict_type != SLICE_TYPE_I )
            {
                q = qp2qscale( rcc->accum_p_qp / rcc->accum_p_norm );
                q /= fabs( h->param.rc.f_ip_factor );
                q = clip_qscale( h, pict_type, q );
            }
            else
            {
985
                if( h->stat.i_slice_count[h->param.i_keyint_max > 1 ? SLICE_TYPE_P : SLICE_TYPE_I] < 5 )
Loren Merritt's avatar
Loren Merritt committed
986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005
                {
                    float w = h->stat.i_slice_count[SLICE_TYPE_P] / 5.;
                    float q2 = qp2qscale(ABR_INIT_QP);
                    q = q*w + q2*(1-w);
                }

                /* Asymmetric clipping, because symmetric would prevent
                 * overflow control in areas of rapidly oscillating complexity */
                lmin = rcc->last_qscale_for[pict_type] / rcc->lstep;
                lmax = rcc->last_qscale_for[pict_type] * rcc->lstep;
                if( overflow > 1.1 )
                    lmax *= rcc->lstep;
                else if( overflow < 0.9 )
                    lmin /= rcc->lstep;

                q = x264_clip3f(q, lmin, lmax);
                q = clip_qscale(h, pict_type, q);
                //FIXME use get_diff_limited_q() ?
            }
        }
1006

Loren Merritt's avatar
Loren Merritt committed
1007
        rcc->last_qscale_for[pict_type] =
1008
        rcc->last_qscale = q;
Loren Merritt's avatar
Loren Merritt committed
1009

1010 1011
        return q;
    }