ratecontrol.c 38 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 37
#include "common/common.h"
#include "common/cpu.h"
#include "common/macroblock.h"
Laurent Aimar's avatar
Laurent Aimar committed
38 39
#include "ratecontrol.h"

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

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

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

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

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

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

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 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
/* There is no analytical inverse to the above formula. */
166
#if 0
167 168
static inline double bits2qscale(ratecontrol_entry_t *rce, double bits)
{
169
    if(bits<1.0)
170
        bits = 1.0;
171
    return (rce->i_tex_bits + rce->p_tex_bits + rce->mv_bits + .1) * rce->qscale / bits;
172
}
173
#endif
174 175


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

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

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

Loren Merritt's avatar
Loren Merritt committed
186 187 188 189
    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
190 191 192 193 194 195
    /* 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;

196
    rc->bitrate = h->param.rc.i_bitrate * 1000;
Loren Merritt's avatar
Loren Merritt committed
197
    rc->rate_tolerance = h->param.rc.f_rate_tolerance;
198
    rc->nmb = h->mb.i_mb_count;
Loren Merritt's avatar
Loren Merritt committed
199 200 201 202 203 204 205 206 207 208 209 210 211
    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 );
212
        }
Loren Merritt's avatar
Loren Merritt committed
213 214 215 216 217 218 219 220
        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");
221

Loren Merritt's avatar
Loren Merritt committed
222 223 224 225 226 227 228 229 230
    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;
231 232
    }

Loren Merritt's avatar
Loren Merritt committed
233 234 235
    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 );
236

Loren Merritt's avatar
Loren Merritt committed
237
    rc->lstep = exp2f(h->param.rc.i_qp_step / 6.0);
238
    rc->last_qscale = qp2qscale(26);
239 240 241 242 243
    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
244 245 246
        rc->pred[i].coeff= 2.0;
        rc->pred[i].count= 1.0;
        rc->pred[i].decay= 0.5;
247 248 249 250 251 252 253 254
    }
#if 0 // FIXME: do we want to assign lmin/lmax based on ip_factor, or leave them all the same?
    rc->lmin[SLICE_TYPE_I] /= fabs(h->param.f_ip_factor);
    rc->lmax[SLICE_TYPE_I] /= fabs(h->param.f_ip_factor);
    rc->lmin[SLICE_TYPE_B] *= fabs(h->param.f_pb_factor);
    rc->lmax[SLICE_TYPE_B] *= fabs(h->param.f_pb_factor);
#endif

Loren Merritt's avatar
Loren Merritt committed
255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278
    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) );
    }

279 280 281 282 283 284 285 286 287
    /* Load stat file and init 2pass algo */
    if( h->param.rc.b_stat_read )
    {
        int stats_size;
        char *p, *stats_in;
        FILE *stats_file;

        /* read 1st pass stats */
        assert( h->param.rc.psz_stat_in );
288
        stats_file = fopen( h->param.rc.psz_stat_in, "rb");
289 290 291 292 293 294 295 296 297 298 299 300 301 302 303
        if(!stats_file)
        {
            x264_log(h, X264_LOG_ERROR, "ratecontrol_init: can't open stats file\n");
            return -1;
        }
        // FIXME: error checking
        fseek(stats_file, 0, SEEK_END);
        stats_size = ftell(stats_file);
        fseek(stats_file, 0, SEEK_SET);
        stats_in = x264_malloc(stats_size+10);
        fread(stats_in, 1, stats_size, stats_file);
        fclose(stats_file);

        /* find number of pics */
        p = stats_in;
Loren Merritt's avatar
Loren Merritt committed
304
        for(i=-1; p; i++)
305
            p = strchr(p+1, ';');
Loren Merritt's avatar
Loren Merritt committed
306 307 308 309
        if(i==0)
        {
            x264_log(h, X264_LOG_ERROR, "empty stats file\n");
            return -1;
310 311 312 313
        }
        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
314
        /* FIXME: num_entries is sometimes treated as number of frames in the video */
315 316 317 318 319
        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];
320
            rce->pict_type = SLICE_TYPE_P;
321 322 323 324 325 326 327 328 329
            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;
330 331
            int frame_number;
            char pict_type;
332 333 334 335 336 337 338 339 340
            int e;
            char *next;
            float qp;

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

Loren Merritt's avatar
Loren Merritt committed
343 344 345 346 347
            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;
            }
348
            rce = &rc->entry[frame_number];
349

350 351
            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,
352
                   &rce->mv_bits, &rce->misc_bits, &rce->i_count, &rce->p_count, &rce->s_count);
353 354

            switch(pict_type){
355
                case 'I': rce->kept_as_ref = 1;
356 357
                case 'i': rce->pict_type = SLICE_TYPE_I; break;
                case 'P': rce->pict_type = SLICE_TYPE_P; break;
358 359
                case 'B': rce->kept_as_ref = 1;
                case 'b': rce->pict_type = SLICE_TYPE_B; break;
360 361
                default:  e = -1; break;
            }
362 363 364 365 366 367 368 369 370 371
            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);

372 373 374
        if(h->param.rc.b_cbr)
        {
            if(init_pass2(h) < 0) return -1;
Loren Merritt's avatar
Loren Merritt committed
375
        } /* else we're using constant quant, so no need to run the bitrate allocation */
376 377 378
    }

    /* Open output file */
379 380
    /* 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 */
381 382
    if( h->param.rc.b_stat_write )
    {
383 384 385
        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" );
386 387

        rc->p_stat_file_out = fopen( rc->psz_stat_file_tmpname, "wb" );
388 389 390 391 392 393
        if( rc->p_stat_file_out == NULL )
        {
            x264_log(h, X264_LOG_ERROR, "ratecontrol_init: can't open stats file\n");
            return -1;
        }
    }
394 395

    return 0;
Laurent Aimar's avatar
Laurent Aimar committed
396 397
}

398
void x264_ratecontrol_delete( x264_t *h )
Laurent Aimar's avatar
Laurent Aimar committed
399
{
400
    x264_ratecontrol_t *rc = h->rc;
401 402

    if( rc->p_stat_file_out )
403
    {
404
        fclose( rc->p_stat_file_out );
405 406 407 408 409 410 411
        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 );
412
    }
Loren Merritt's avatar
Loren Merritt committed
413 414
    x264_free( rc->entry );
    x264_free( rc->zones );
Laurent Aimar's avatar
Laurent Aimar committed
415 416 417
    x264_free( rc );
}

Loren Merritt's avatar
Loren Merritt committed
418
/* Before encoding a frame, choose a QP for it */
Måns Rullgård's avatar
Måns Rullgård committed
419
void x264_ratecontrol_start( x264_t *h, int i_slice_type, int i_force_qp )
Laurent Aimar's avatar
Laurent Aimar committed
420
{
421 422 423 424
    x264_ratecontrol_t *rc = h->rc;

    x264_cpu_restore( h->param.cpu );

Måns Rullgård's avatar
Måns Rullgård committed
425
    rc->qp_force = i_force_qp;
Loren Merritt's avatar
Loren Merritt committed
426
    rc->slice_type = i_slice_type;
Måns Rullgård's avatar
Måns Rullgård committed
427

Loren Merritt's avatar
Loren Merritt committed
428
    if( i_force_qp )
429
    {
Loren Merritt's avatar
Loren Merritt committed
430
        rc->qpa = rc->qp = i_force_qp - 1;
431
    }
Loren Merritt's avatar
Loren Merritt committed
432 433 434 435 436 437
    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 )
438 439
    {
        int frame = h->fenc->i_frame;
440
        ratecontrol_entry_t *rce;
441
        assert( frame >= 0 && frame < rc->num_entries );
Loren Merritt's avatar
Loren Merritt committed
442
        rce = h->rc->rce = &h->rc->entry[frame];
443 444

        rce->new_qscale = rate_estimate_qscale( h, i_slice_type );
Loren Merritt's avatar
Loren Merritt committed
445 446
        rc->qpa = rc->qp = rce->new_qp =
            x264_clip3( (int)(qscale2qp(rce->new_qscale) + 0.5), 0, 51 );
447
    }
Loren Merritt's avatar
Loren Merritt committed
448 449 450 451 452
    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;
453
        else
Loren Merritt's avatar
Loren Merritt committed
454 455
            q = rc->qp_constant[ i_slice_type ];
        rc->qpa = rc->qp = q;
Måns Rullgård's avatar
Måns Rullgård committed
456
    }
Laurent Aimar's avatar
Laurent Aimar committed
457 458
}

459
void x264_ratecontrol_mb( x264_t *h, int bits )
Laurent Aimar's avatar
Laurent Aimar committed
460
{
Loren Merritt's avatar
Loren Merritt committed
461
    /* currently no adaptive quant */
Laurent Aimar's avatar
Laurent Aimar committed
462 463
}

Loren Merritt's avatar
Loren Merritt committed
464
int x264_ratecontrol_qp( x264_t *h )
Laurent Aimar's avatar
Laurent Aimar committed
465
{
Loren Merritt's avatar
Loren Merritt committed
466
    return h->rc->qp;
467
}
Laurent Aimar's avatar
Laurent Aimar committed
468

Loren Merritt's avatar
Loren Merritt committed
469
/* In 2pass, force the same frame types as in the 1st pass */
470 471 472 473
int x264_ratecontrol_slice_type( x264_t *h, int frame_num )
{
    if( h->param.rc.b_stat_read )
    {
474 475 476 477 478
        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;
        }
479
        switch( h->rc->entry[frame_num].pict_type )
480 481
        {
            case SLICE_TYPE_I:
482
                return h->rc->entry[frame_num].kept_as_ref ? X264_TYPE_IDR : X264_TYPE_I;
483 484

            case SLICE_TYPE_B:
485
                return h->rc->entry[frame_num].kept_as_ref ? X264_TYPE_BREF : X264_TYPE_B;
486 487 488 489 490 491 492 493 494 495 496 497

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

Loren Merritt's avatar
Loren Merritt committed
498
/* After encoding one frame, save stats and update ratecontrol state */
499 500 501
void x264_ratecontrol_end( x264_t *h, int bits )
{
    x264_ratecontrol_t *rc = h->rc;
Loren Merritt's avatar
Loren Merritt committed
502
    int i;
Laurent Aimar's avatar
Laurent Aimar committed
503

504 505
    x264_cpu_restore( h->param.cpu );

Loren Merritt's avatar
Loren Merritt committed
506 507 508 509 510
    h->stat.frame.i_mb_count_skip = h->stat.frame.i_mb_count[P_SKIP] + h->stat.frame.i_mb_count[B_SKIP];
    h->stat.frame.i_mb_count_p = h->stat.frame.i_mb_count[P_L0] + h->stat.frame.i_mb_count[P_8x8];
    for( i = B_DIRECT; i < B_8x8; i++ )
        h->stat.frame.i_mb_count_p += h->stat.frame.i_mb_count[i];

511 512
    if( h->param.rc.b_stat_write )
    {
513
        char c_type = rc->slice_type==SLICE_TYPE_I ? (h->fenc->i_poc==0 ? 'I' : 'i')
514 515
                    : rc->slice_type==SLICE_TYPE_P ? 'P'
                    : h->fenc->b_kept_as_ref ? 'B' : 'b';
516
        fprintf( rc->p_stat_file_out,
Loren Merritt's avatar
Loren Merritt committed
517
                 "in:%d out:%d type:%c q:%.2f itex:%d ptex:%d mv:%d misc:%d imb:%d pmb:%d smb:%d;\n",
518
                 h->fenc->i_frame, h->i_frame-1,
519
                 c_type, rc->qpa,
520 521 522
                 h->stat.frame.i_itex_bits, h->stat.frame.i_ptex_bits,
                 h->stat.frame.i_hdr_bits, h->stat.frame.i_misc_bits,
                 h->stat.frame.i_mb_count[I_4x4] + h->stat.frame.i_mb_count[I_16x16],
Loren Merritt's avatar
Loren Merritt committed
523 524
                 h->stat.frame.i_mb_count_p,
                 h->stat.frame.i_mb_count_skip);
525 526
    }

Loren Merritt's avatar
Loren Merritt committed
527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547
    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
548 549
    }

Loren Merritt's avatar
Loren Merritt committed
550 551 552
    if( rc->b_2pass )
    {
        rc->expected_bits_sum += qscale2bits( rc->rce, qp2qscale(rc->rce->new_qp) );
Laurent Aimar's avatar
Laurent Aimar committed
553 554
    }

Loren Merritt's avatar
Loren Merritt committed
555
    update_vbv( h, bits );
556

Loren Merritt's avatar
Loren Merritt committed
557 558
    if( rc->slice_type != SLICE_TYPE_B )
        rc->last_non_b_pict_type = rc->slice_type;
Laurent Aimar's avatar
Laurent Aimar committed
559
}
560 561 562 563

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

565 566 567 568 569 570
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
571
 * modify the bitrate curve from pass1 for one frame
572
 */
Loren Merritt's avatar
Loren Merritt committed
573
static double get_qscale(x264_t *h, ratecontrol_entry_t *rce, double rate_factor, int frame_num)
574 575
{
    x264_ratecontrol_t *rcc= h->rc;
576
    const int pict_type = rce->pict_type;
577
    double q;
Loren Merritt's avatar
Loren Merritt committed
578
    int i;
579 580 581 582 583

    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,
584
        rce->mv_bits * rce->qscale,
585 586 587 588 589 590 591 592 593 594 595 596
        (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
597
        rce->blurred_complexity,
598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616
        0
    };
    static const char *const_names[]={
        "iTex",
        "pTex",
        "tex",
        "mv",
        "iCount",
        "pCount",
        "sCount",
        "isI",
        "isP",
        "isB",
        "qComp",
        "avgIITex",
        "avgPITex",
        "avgPPTex",
        "avgBPTex",
        "avgTex",
617
        "blurCplx",
618 619 620
        NULL
    };
    static double (*func1[])(void *, double)={
621
//      (void *)bits2qscale,
622 623 624 625
        (void *)qscale2bits,
        NULL
    };
    static const char *func1_names[]={
626
//      "bits2qp",
627 628 629 630
        "qp2bits",
        NULL
    };

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

Loren Merritt's avatar
Loren Merritt committed
633
    // avoid NaN's in the rc_eq
634 635
    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
636 637 638
    else {
        rcc->last_rceq = q;
        q /= rate_factor;
639
        rcc->last_qscale = q;
Loren Merritt's avatar
Loren Merritt committed
640 641 642 643 644 645 646 647 648 649 650 651 652 653
    }

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

655
    return q;
656 657 658 659 660
}

static double get_diff_limited_q(x264_t *h, ratecontrol_entry_t *rce, double q)
{
    x264_ratecontrol_t *rcc = h->rc;
661
    const int pict_type = rce->pict_type;
662 663 664 665

    // 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];
666 667
    if( pict_type == SLICE_TYPE_I )
    {
668 669 670 671 672 673 674 675 676 677 678 679
        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;
680 681 682 683 684
    }
    else if( pict_type == SLICE_TYPE_B )
    {
        if( h->param.rc.f_pb_factor > 0 )
            q = last_non_b_q;
685 686
        if( !rce->kept_as_ref )
            q *= fabs( h->param.rc.f_pb_factor );
687 688 689 690 691
    }
    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 )
    {
692
        q = last_p_q;
693
    }
694 695

    /* last qscale / qdiff stuff */
696 697
    if(rcc->last_non_b_pict_type==pict_type
       && (pict_type!=SLICE_TYPE_I || rcc->last_accum_p_norm < 1))
698 699
    {
        double last_q = rcc->last_qscale_for[pict_type];
Loren Merritt's avatar
Loren Merritt committed
700 701
        double max_qscale = last_q * rcc->lstep;
        double min_qscale = last_q / rcc->lstep;
702 703 704 705 706

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

Loren Merritt's avatar
Loren Merritt committed
707
    rcc->last_qscale_for[pict_type] = q;
708 709
    if(pict_type!=SLICE_TYPE_B)
        rcc->last_non_b_pict_type = pict_type;
710 711
    if(pict_type==SLICE_TYPE_I)
    {
712
        rcc->last_accum_p_norm = rcc->accum_p_norm;
713 714 715 716 717 718 719 720 721
        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);
    }
722 723 724
    return q;
}

Loren Merritt's avatar
Loren Merritt committed
725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754
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 )
755
{
Loren Merritt's avatar
Loren Merritt committed
756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785
    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 );
    }
786

Loren Merritt's avatar
Loren Merritt committed
787
    if(lmin==lmax)
Loren Merritt's avatar
Loren Merritt committed
788
        return lmin;
Loren Merritt's avatar
Loren Merritt committed
789 790
    else if(rcc->b_2pass)
    {
791 792
        double min2 = log(lmin);
        double max2 = log(lmax);
Loren Merritt's avatar
Loren Merritt committed
793 794
        q = (log(q) - min2)/(max2-min2) - 0.5;
        q = 1.0/(1.0 + exp(-4*q));
795
        q = q*(max2-min2) + min2;
Loren Merritt's avatar
Loren Merritt committed
796
        return exp(q);
797
    }
Loren Merritt's avatar
Loren Merritt committed
798 799
    else
        return x264_clip3f(q, lmin, lmax);
800 801 802 803 804 805 806
}

// 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
807
    ratecontrol_entry_t rce;
808 809 810 811 812 813
    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
814 815 816 817 818 819 820 821 822
    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]);
        }
    }
823

Loren Merritt's avatar
Loren Merritt committed
824
    if( pict_type == SLICE_TYPE_B )
825
    {
Loren Merritt's avatar
Loren Merritt committed
826
        rcc->last_satd = 0;
Loren Merritt's avatar
Loren Merritt committed
827
        if(h->fenc->b_kept_as_ref)
Loren Merritt's avatar
Loren Merritt committed
828
            q = rcc->last_qscale * sqrtf(h->param.rc.f_pb_factor);
829
        else
Loren Merritt's avatar
Loren Merritt committed
830 831
            q = rcc->last_qscale * h->param.rc.f_pb_factor;
        return x264_clip3f(q, lmin, lmax);
832 833 834
    }
    else
    {
Loren Merritt's avatar
Loren Merritt committed
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 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880
        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
881
            q = get_qscale(h, &rce, rcc->wanted_bits_window / rcc->cplxr_sum, h->fenc->i_frame);
Loren Merritt's avatar
Loren Merritt committed
882 883 884 885

            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
886
            q *= overflow;
Loren Merritt's avatar
Loren Merritt committed
887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918

            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() ?
            }
        }
919

Loren Merritt's avatar
Loren Merritt committed
920
        rcc->last_qscale_for[pict_type] =
921
        rcc->last_qscale = q;
Loren Merritt's avatar
Loren Merritt committed
922

923 924
        return q;
    }
925 926 927 928 929 930 931 932 933
}

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
934
    double cplxblur = h->param.rc.f_complexity_blur;
935 936 937 938 939 940 941 942
    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];
943
        all_const_bits += rce->misc_bits;
944 945
        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;
946
        rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits * rce->qscale;
947
        rcc->frame_count[rce->pict_type] ++;
948 949 950 951 952 953 954 955 956
    }

    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
957 958 959 960
    /* 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
961 962
    for(i=0; i<rcc->num_entries; i++){
        ratecontrol_entry_t *rce = &rcc->entry[i];
963
        double weight_sum = 0;
Loren Merritt's avatar
Loren Merritt committed
964
        double cplx_sum = 0;
965
        double weight = 1.0;
Loren Merritt's avatar
Loren Merritt committed
966 967
        int j;
        /* weighted average of cplx of future frames */
968
        for(j=1; j<cplxblur*2 && j<rcc->num_entries-i; j++){
Loren Merritt's avatar
Loren Merritt committed
969
            ratecontrol_entry_t *rcj = &rcc->entry[i+j];
970
            weight *= 1 - pow( (float)rcj->i_count / rcc->nmb, 2 );
Loren Merritt's avatar
Loren Merritt committed
971 972 973
            if(weight < .0001)
                break;
            weight_sum += weight;
974
            cplx_sum += weight * qscale2bits(rcj, 1);
Loren Merritt's avatar
Loren Merritt committed
975 976
        }
        /* weighted average of cplx of past frames */
977
        weight = 1.0;
978
        for(j=0; j<=cplxblur*2 && j<=i; j++){
Loren Merritt's avatar
Loren Merritt committed
979 980
            ratecontrol_entry_t *rcj = &rcc->entry[i-j];
            weight_sum += weight;
981
            cplx_sum += weight * qscale2bits(rcj, 1);
982
            weight *= 1 - pow( (float)rcj->i_count / rcc->nmb, 2 );
Loren Merritt's avatar
Loren Merritt committed
983 984 985 986 987 988
            if(weight < .0001)
                break;
        }
        rce->blurred_complexity = cplx_sum / weight_sum;
    }

989 990 991 992 993 994
    qscale = x264_malloc(sizeof(double)*rcc->num_entries);
    if(filter_size > 1)
        blurred_qscale = x264_malloc(sizeof(double)*rcc->num_entries);
    else
        blurred_qscale = qscale;

Loren Merritt's avatar
Loren Merritt committed
995 996 997 998 999 1000 1001
    /* Search for a factor which, when multiplied by the RCEQ values from
     * each frame, adds up to the desired total size.
     * There is no exact closed-form solution because of VBV constraints and
     * because qscale2bits is not invertible, but we can start with the simple
     * approximation of scaling the 1st pass by the ratio of bitrates.
     * The search range is probably overkill, but speed doesn't matter here. */

Loren Merritt's avatar
Loren Merritt committed
1002
    expected_bits = 1;