ratecontrol.c 38.4 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 108
    /* 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;

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

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

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

133

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

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

153 154 155 156
/* 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. */
157 158
static inline double qscale2bits(ratecontrol_entry_t *rce, double qscale)
{
Loren Merritt's avatar
Loren Merritt committed
159
    if(qscale<0.1)
160
        qscale = 0.1;
161 162
    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 );
163 164 165
}


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

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

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

Loren Merritt's avatar
Loren Merritt committed
176 177 178 179
    rc->b_abr = h->param.rc.b_cbr && !h->param.rc.b_stat_read;
    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
180 181 182 183 184 185
    /* 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;

186
    rc->bitrate = h->param.rc.i_bitrate * 1000;
Loren Merritt's avatar
Loren Merritt committed
187
    rc->rate_tolerance = h->param.rc.f_rate_tolerance;
188
    rc->nmb = h->mb.i_mb_count;
Loren Merritt's avatar
Loren Merritt committed
189 190 191 192 193 194 195 196 197 198 199 200 201
    rc->last_non_b_pict_type = -1;
    rc->cbr_decay = 1.0;

    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 );
202
        }
Loren Merritt's avatar
Loren Merritt committed
203 204 205 206 207 208 209 210
        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");
211 212 213 214
    if(rc->rate_tolerance < 0.01) {
        x264_log(h, X264_LOG_ERROR, "bitrate tolerance too small, using .01\n");
        rc->rate_tolerance = 0.01;
    }
215

Loren Merritt's avatar
Loren Merritt committed
216 217 218 219 220 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 */
#define ABR_INIT_QP 24
        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;
225 226
    }

Loren Merritt's avatar
Loren Merritt committed
227 228 229
    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 );
230

Loren Merritt's avatar
Loren Merritt committed
231
    rc->lstep = exp2f(h->param.rc.i_qp_step / 6.0);
232
    rc->last_qscale = qp2qscale(26);
233 234 235 236 237
    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
238 239 240
        rc->pred[i].coeff= 2.0;
        rc->pred[i].count= 1.0;
        rc->pred[i].decay= 0.5;
241 242
    }

243 244
    if( parse_zones( h ) < 0 )
        return -1;
Loren Merritt's avatar
Loren Merritt committed
245

246 247 248 249 250 251 252
    /* 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
253 254
        stats_in = x264_slurp_file( h->param.rc.psz_stat_in );
        if( !stats_in )
255 256 257 258 259 260 261
        {
            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
262
        for(i=-1; p; i++)
263
            p = strchr(p+1, ';');
Loren Merritt's avatar
Loren Merritt committed
264 265 266 267
        if(i==0)
        {
            x264_log(h, X264_LOG_ERROR, "empty stats file\n");
            return -1;
268 269 270 271
        }
        i += h->param.i_bframe;
        rc->entry = (ratecontrol_entry_t*) x264_malloc(i*sizeof(ratecontrol_entry_t));
        memset(rc->entry, 0, i*sizeof(ratecontrol_entry_t));
Loren Merritt's avatar
Loren Merritt committed
272
        /* FIXME: num_entries is sometimes treated as number of frames in the video */
273 274 275 276 277
        rc->num_entries= i;

        /* init all to skipped p frames */
        for(i=0; i<rc->num_entries; i++){
            ratecontrol_entry_t *rce = &rc->entry[i];
278
            rce->pict_type = SLICE_TYPE_P;
279 280 281 282 283 284 285 286 287
            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;
288 289
            int frame_number;
            char pict_type;
290 291 292 293 294 295 296 297 298
            int e;
            char *next;
            float qp;

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

Loren Merritt's avatar
Loren Merritt committed
301 302 303 304 305
            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;
            }
306
            rce = &rc->entry[frame_number];
307

308 309
            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,
310
                   &rce->mv_bits, &rce->misc_bits, &rce->i_count, &rce->p_count, &rce->s_count);
311 312

            switch(pict_type){
313
                case 'I': rce->kept_as_ref = 1;
314 315
                case 'i': rce->pict_type = SLICE_TYPE_I; break;
                case 'P': rce->pict_type = SLICE_TYPE_P; break;
316 317
                case 'B': rce->kept_as_ref = 1;
                case 'b': rce->pict_type = SLICE_TYPE_B; break;
318 319
                default:  e = -1; break;
            }
320 321 322 323 324 325 326 327 328 329
            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);

330 331 332
        if(h->param.rc.b_cbr)
        {
            if(init_pass2(h) < 0) return -1;
Loren Merritt's avatar
Loren Merritt committed
333
        } /* else we're using constant quant, so no need to run the bitrate allocation */
334 335 336
    }

    /* Open output file */
337 338
    /* 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 */
339 340
    if( h->param.rc.b_stat_write )
    {
341 342 343
        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" );
344 345

        rc->p_stat_file_out = fopen( rc->psz_stat_file_tmpname, "wb" );
346 347 348 349 350 351
        if( rc->p_stat_file_out == NULL )
        {
            x264_log(h, X264_LOG_ERROR, "ratecontrol_init: can't open stats file\n");
            return -1;
        }
    }
352 353

    return 0;
Laurent Aimar's avatar
Laurent Aimar committed
354 355
}

356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 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
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;
}

413
void x264_ratecontrol_delete( x264_t *h )
Laurent Aimar's avatar
Laurent Aimar committed
414
{
415
    x264_ratecontrol_t *rc = h->rc;
416 417

    if( rc->p_stat_file_out )
418
    {
419
        fclose( rc->p_stat_file_out );
420 421 422 423 424 425 426
        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 );
427
    }
Loren Merritt's avatar
Loren Merritt committed
428 429
    x264_free( rc->entry );
    x264_free( rc->zones );
Laurent Aimar's avatar
Laurent Aimar committed
430 431 432
    x264_free( rc );
}

Loren Merritt's avatar
Loren Merritt committed
433
/* Before encoding a frame, choose a QP for it */
Måns Rullgård's avatar
Måns Rullgård committed
434
void x264_ratecontrol_start( x264_t *h, int i_slice_type, int i_force_qp )
Laurent Aimar's avatar
Laurent Aimar committed
435
{
436 437 438 439
    x264_ratecontrol_t *rc = h->rc;

    x264_cpu_restore( h->param.cpu );

Måns Rullgård's avatar
Måns Rullgård committed
440
    rc->qp_force = i_force_qp;
Loren Merritt's avatar
Loren Merritt committed
441
    rc->slice_type = i_slice_type;
Måns Rullgård's avatar
Måns Rullgård committed
442

Loren Merritt's avatar
Loren Merritt committed
443
    if( i_force_qp )
444
    {
Loren Merritt's avatar
Loren Merritt committed
445
        rc->qpa = rc->qp = i_force_qp - 1;
446
    }
Loren Merritt's avatar
Loren Merritt committed
447 448 449 450 451 452
    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 )
453 454
    {
        int frame = h->fenc->i_frame;
455
        ratecontrol_entry_t *rce;
456
        assert( frame >= 0 && frame < rc->num_entries );
Loren Merritt's avatar
Loren Merritt committed
457
        rce = h->rc->rce = &h->rc->entry[frame];
458 459

        rce->new_qscale = rate_estimate_qscale( h, i_slice_type );
Loren Merritt's avatar
Loren Merritt committed
460 461
        rc->qpa = rc->qp = rce->new_qp =
            x264_clip3( (int)(qscale2qp(rce->new_qscale) + 0.5), 0, 51 );
462
    }
Loren Merritt's avatar
Loren Merritt committed
463 464 465 466 467
    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;
468
        else
Loren Merritt's avatar
Loren Merritt committed
469 470
            q = rc->qp_constant[ i_slice_type ];
        rc->qpa = rc->qp = q;
Måns Rullgård's avatar
Måns Rullgård committed
471
    }
Laurent Aimar's avatar
Laurent Aimar committed
472 473
}

474
void x264_ratecontrol_mb( x264_t *h, int bits )
Laurent Aimar's avatar
Laurent Aimar committed
475
{
Loren Merritt's avatar
Loren Merritt committed
476
    /* currently no adaptive quant */
Laurent Aimar's avatar
Laurent Aimar committed
477 478
}

Loren Merritt's avatar
Loren Merritt committed
479
int x264_ratecontrol_qp( x264_t *h )
Laurent Aimar's avatar
Laurent Aimar committed
480
{
Loren Merritt's avatar
Loren Merritt committed
481
    return h->rc->qp;
482
}
Laurent Aimar's avatar
Laurent Aimar committed
483

Loren Merritt's avatar
Loren Merritt committed
484
/* In 2pass, force the same frame types as in the 1st pass */
485 486 487 488
int x264_ratecontrol_slice_type( x264_t *h, int frame_num )
{
    if( h->param.rc.b_stat_read )
    {
489 490 491 492 493
        if( frame_num >= h->rc->num_entries )
        {
            x264_log(h, X264_LOG_ERROR, "More input frames than in the 1st pass\n");
            return X264_TYPE_P;
        }
494
        switch( h->rc->entry[frame_num].pict_type )
495 496
        {
            case SLICE_TYPE_I:
497
                return h->rc->entry[frame_num].kept_as_ref ? X264_TYPE_IDR : X264_TYPE_I;
498 499

            case SLICE_TYPE_B:
500
                return h->rc->entry[frame_num].kept_as_ref ? X264_TYPE_BREF : X264_TYPE_B;
501 502 503 504 505 506 507 508 509 510 511 512

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

Loren Merritt's avatar
Loren Merritt committed
513
/* After encoding one frame, save stats and update ratecontrol state */
514 515 516
void x264_ratecontrol_end( x264_t *h, int bits )
{
    x264_ratecontrol_t *rc = h->rc;
517
    const int *mbs = h->stat.frame.i_mb_count;
Loren Merritt's avatar
Loren Merritt committed
518
    int i;
Laurent Aimar's avatar
Laurent Aimar committed
519

520 521
    x264_cpu_restore( h->param.cpu );

522 523 524
    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
525
    for( i = B_DIRECT; i < B_8x8; i++ )
526
        h->stat.frame.i_mb_count_p += mbs[i];
Loren Merritt's avatar
Loren Merritt committed
527

528 529
    if( h->param.rc.b_stat_write )
    {
530
        char c_type = rc->slice_type==SLICE_TYPE_I ? (h->fenc->i_poc==0 ? 'I' : 'i')
531 532
                    : rc->slice_type==SLICE_TYPE_P ? 'P'
                    : h->fenc->b_kept_as_ref ? 'B' : 'b';
533
        fprintf( rc->p_stat_file_out,
Loren Merritt's avatar
Loren Merritt committed
534
                 "in:%d out:%d type:%c q:%.2f itex:%d ptex:%d mv:%d misc:%d imb:%d pmb:%d smb:%d;\n",
535
                 h->fenc->i_frame, h->i_frame-1,
536
                 c_type, rc->qpa,
537 538
                 h->stat.frame.i_itex_bits, h->stat.frame.i_ptex_bits,
                 h->stat.frame.i_hdr_bits, h->stat.frame.i_misc_bits,
539
                 h->stat.frame.i_mb_count_i,
Loren Merritt's avatar
Loren Merritt committed
540 541
                 h->stat.frame.i_mb_count_p,
                 h->stat.frame.i_mb_count_skip);
542 543
    }

Loren Merritt's avatar
Loren Merritt committed
544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564
    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
565 566
    }

Loren Merritt's avatar
Loren Merritt committed
567 568 569
    if( rc->b_2pass )
    {
        rc->expected_bits_sum += qscale2bits( rc->rce, qp2qscale(rc->rce->new_qp) );
Laurent Aimar's avatar
Laurent Aimar committed
570 571
    }

Loren Merritt's avatar
Loren Merritt committed
572
    update_vbv( h, bits );
573

Loren Merritt's avatar
Loren Merritt committed
574 575
    if( rc->slice_type != SLICE_TYPE_B )
        rc->last_non_b_pict_type = rc->slice_type;
Laurent Aimar's avatar
Laurent Aimar committed
576
}
577 578 579 580

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

582 583 584 585 586 587
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
588
 * modify the bitrate curve from pass1 for one frame
589
 */
Loren Merritt's avatar
Loren Merritt committed
590
static double get_qscale(x264_t *h, ratecontrol_entry_t *rce, double rate_factor, int frame_num)
591 592
{
    x264_ratecontrol_t *rcc= h->rc;
593
    const int pict_type = rce->pict_type;
594
    double q;
Loren Merritt's avatar
Loren Merritt committed
595
    int i;
596 597 598 599 600

    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,
601
        rce->mv_bits * rce->qscale,
602 603 604 605 606 607 608 609 610 611 612 613
        (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
614
        rce->blurred_complexity,
615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633
        0
    };
    static const char *const_names[]={
        "iTex",
        "pTex",
        "tex",
        "mv",
        "iCount",
        "pCount",
        "sCount",
        "isI",
        "isP",
        "isB",
        "qComp",
        "avgIITex",
        "avgPITex",
        "avgPPTex",
        "avgBPTex",
        "avgTex",
634
        "blurCplx",
635 636 637
        NULL
    };
    static double (*func1[])(void *, double)={
638
//      (void *)bits2qscale,
639 640 641 642
        (void *)qscale2bits,
        NULL
    };
    static const char *func1_names[]={
643
//      "bits2qp",
644 645 646 647
        "qp2bits",
        NULL
    };

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

Loren Merritt's avatar
Loren Merritt committed
650
    // avoid NaN's in the rc_eq
651 652
    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
653 654 655
    else {
        rcc->last_rceq = q;
        q /= rate_factor;
656
        rcc->last_qscale = q;
Loren Merritt's avatar
Loren Merritt committed
657 658 659 660 661 662 663 664 665 666 667 668 669 670
    }

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

672
    return q;
673 674 675 676 677
}

static double get_diff_limited_q(x264_t *h, ratecontrol_entry_t *rce, double q)
{
    x264_ratecontrol_t *rcc = h->rc;
678
    const int pict_type = rce->pict_type;
679 680 681 682

    // 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];
683 684
    if( pict_type == SLICE_TYPE_I )
    {
685 686 687 688 689 690 691 692 693 694 695 696
        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;
697 698 699 700 701
    }
    else if( pict_type == SLICE_TYPE_B )
    {
        if( h->param.rc.f_pb_factor > 0 )
            q = last_non_b_q;
702 703
        if( !rce->kept_as_ref )
            q *= fabs( h->param.rc.f_pb_factor );
704 705 706 707 708
    }
    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 )
    {
709
        q = last_p_q;
710
    }
711 712

    /* last qscale / qdiff stuff */
713 714
    if(rcc->last_non_b_pict_type==pict_type
       && (pict_type!=SLICE_TYPE_I || rcc->last_accum_p_norm < 1))
715 716
    {
        double last_q = rcc->last_qscale_for[pict_type];
Loren Merritt's avatar
Loren Merritt committed
717 718
        double max_qscale = last_q * rcc->lstep;
        double min_qscale = last_q / rcc->lstep;
719 720 721 722 723

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

Loren Merritt's avatar
Loren Merritt committed
724
    rcc->last_qscale_for[pict_type] = q;
725 726
    if(pict_type!=SLICE_TYPE_B)
        rcc->last_non_b_pict_type = pict_type;
727 728
    if(pict_type==SLICE_TYPE_I)
    {
729
        rcc->last_accum_p_norm = rcc->accum_p_norm;
730 731 732 733 734 735 736 737 738
        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);
    }
739 740 741
    return q;
}

Loren Merritt's avatar
Loren Merritt committed
742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771
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 )
772
{
Loren Merritt's avatar
Loren Merritt committed
773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802
    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 );
    }
803

Loren Merritt's avatar
Loren Merritt committed
804
    if(lmin==lmax)
Loren Merritt's avatar
Loren Merritt committed
805
        return lmin;
Loren Merritt's avatar
Loren Merritt committed
806 807
    else if(rcc->b_2pass)
    {
808 809
        double min2 = log(lmin);
        double max2 = log(lmax);
Loren Merritt's avatar
Loren Merritt committed
810 811
        q = (log(q) - min2)/(max2-min2) - 0.5;
        q = 1.0/(1.0 + exp(-4*q));
812
        q = q*(max2-min2) + min2;
Loren Merritt's avatar
Loren Merritt committed
813
        return exp(q);
814
    }
Loren Merritt's avatar
Loren Merritt committed
815 816
    else
        return x264_clip3f(q, lmin, lmax);
817 818 819 820 821 822 823
}

// 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
824
    ratecontrol_entry_t rce;
825 826 827 828 829 830
    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
831 832 833 834 835 836 837 838 839
    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]);
        }
    }
840

Loren Merritt's avatar
Loren Merritt committed
841
    if( pict_type == SLICE_TYPE_B )
842
    {
Loren Merritt's avatar
Loren Merritt committed
843
        rcc->last_satd = 0;
Loren Merritt's avatar
Loren Merritt committed
844
        if(h->fenc->b_kept_as_ref)
Loren Merritt's avatar
Loren Merritt committed
845
            q = rcc->last_qscale * sqrtf(h->param.rc.f_pb_factor);
846
        else
Loren Merritt's avatar
Loren Merritt committed
847 848
            q = rcc->last_qscale * h->param.rc.f_pb_factor;
        return x264_clip3f(q, lmin, lmax);
849 850 851
    }
    else
    {
Loren Merritt's avatar
Loren Merritt committed
852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897
        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;
Loren Merritt's avatar
Loren Merritt committed
898
            q = get_qscale(h, &rce, rcc->wanted_bits_window / rcc->cplxr_sum, h->fenc->i_frame);
Loren Merritt's avatar
Loren Merritt committed
899 900 901 902

            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 );
Loren Merritt's avatar
Loren Merritt committed
903
            q *= overflow;
Loren Merritt's avatar
Loren Merritt committed
904 905 906 907 908 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

            if( pict_type == SLICE_TYPE_I
                /* 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
            {
                if( h->stat.i_slice_count[SLICE_TYPE_P] < 5 )
                {
                    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() ?
            }
        }
936

Loren Merritt's avatar
Loren Merritt committed
937
        rcc->last_qscale_for[pict_type] =
938
        rcc->last_qscale = q;
Loren Merritt's avatar
Loren Merritt committed
939

940 941
        return q;
    }
942 943 944 945 946 947 948 949 950
}

static int init_pass2( x264_t *h )
{
    x264_ratecontrol_t *rcc = h->rc;
    uint64_t all_const_bits = 0;
    uint64_t all_available_bits = (uint64_t)(h->param.rc.i_bitrate * 1000 * (double)rcc->num_entries / rcc->fps);
    double rate_factor, step, step_mult;
    double qblur = h->param.rc.f_qblur;
Loren Merritt's avatar
Loren Merritt committed
951
    double cplxblur = h->param.rc.f_complexity_blur;
952 953 954 955 956 957 958 959
    const int filter_size = (int)(qblur*4) | 1;
    double expected_bits;
    double *qscale, *blurred_qscale;
    int i;

    /* find total/average complexity & const_bits */
    for(i=0; i<rcc->num_entries; i++){
        ratecontrol_entry_t *rce = &rcc->entry[i];
960
        all_const_bits += rce->misc_bits;
961 962
        rcc->i_cplx_sum[rce->pict_type] += rce->i_tex_bits * rce->qscale;
        rcc->p_cplx_sum[rce->pict_type] += rce->p_tex_bits * rce->qscale;
963
        rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits * rce->qscale;
964
        rcc->frame_count[rce->pict_type] ++;
965 966 967 968 969 970 971 972 973
    }

    if( all_available_bits < all_const_bits)
    {
        x264_log(h, X264_LOG_ERROR, "requested bitrate is too low. estimated minimum is %d kbps\n",
                 (int)(all_const_bits * rcc->fps / (rcc->num_entries * 1000)));
        return -1;
    }

Loren Merritt's avatar
Loren Merritt committed
974 975 976 977
    /* Blur complexities, to reduce local fluctuation of QP.
     * We don't blur the QPs directly, because then one very simple frame
     * could drag down the QP of a nearby complex frame and give it more
     * bits than intended. */
Loren Merritt's avatar
Loren Merritt committed
978 979
    for(i=0; i<rcc->num_entries; i++){
        ratecontrol_entry_t *rce = &rcc->entry[i];
980
        double weight_sum = 0;
Loren Merritt's avatar
Loren Merritt committed
981
        double cplx_sum = 0;
982
        double weight = 1.0;
Loren Merritt's avatar
Loren Merritt committed
983 984
        int j;
        /* weighted average of cplx of future frames */
985
        for(j=1; j<cplxblur*2 && j<rcc->num_entries-i; j++){
Loren Merritt's avatar
Loren Merritt committed
986
            ratecontrol_entry_t *rcj = &rcc->entry[i+j];
987
            weight *= 1 - pow( (float)rcj->i_count / rcc->nmb, 2 );
Loren Merritt's avatar
Loren Merritt committed
988 989 990
            if(weight < .0001)
                break;
            weight_sum += weight;
991
            cplx_sum += weight * qscale2bits(rcj, 1);
Loren Merritt's avatar
Loren Merritt committed
992 993
        }
        /* weighted average of cplx of past frames */
994
        weight = 1.0;
995
        for(j=0; j<=cplxblur*2 && j<=i; j++){
Loren Merritt's avatar
Loren Merritt committed
996 997
            ratecontrol_entry_t *rcj = &rcc->entry[i-j];
            weight_sum += weight;
998
            cplx_sum += weight * qscale2bits(rcj, 1);
999
            weight *= 1 - pow( (float)rcj->i_count / rcc->nmb, 2 );