Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ratecontrol.c @ 2f5feea4

History | View | Annotate | Download (27.5 KB)

1
/*
2
 * Rate control for video encoders
3
 *
4
 * Copyright (c) 2002 Michael Niedermayer <michaelni@gmx.at>
5
 *
6
 * This library is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU Lesser General Public
8
 * License as published by the Free Software Foundation; either
9
 * version 2 of the License, or (at your option) any later version.
10
 *
11
 * This library is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with this library; if not, write to the Free Software
18
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19
 */
20

    
21
/**
22
 * @file ratecontrol.c
23
 * Rate control for video encoders.
24
 */ 
25

    
26
#include "avcodec.h"
27
#include "dsputil.h"
28
#include "mpegvideo.h"
29

    
30
#undef NDEBUG // allways check asserts, the speed effect is far too small to disable them
31
#include <assert.h>
32

    
33
#ifndef M_E
34
#define M_E 2.718281828
35
#endif
36

    
37
static int init_pass2(MpegEncContext *s);
38
static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_factor, int frame_num);
39

    
40
void ff_write_pass1_stats(MpegEncContext *s){
41
    sprintf(s->avctx->stats_out, "in:%d out:%d type:%d q:%f itex:%d ptex:%d mv:%d misc:%d fcode:%d bcode:%d mc-var:%d var:%d icount:%d;\n",
42
            s->picture_number, s->input_picture_number - s->max_b_frames, s->pict_type, 
43
            s->frame_qscale, s->i_tex_bits, s->p_tex_bits, s->mv_bits, s->misc_bits, 
44
            s->f_code, s->b_code, s->current_picture.mc_mb_var_sum, s->current_picture.mb_var_sum, s->i_count);
45
}
46

    
47
int ff_rate_control_init(MpegEncContext *s)
48
{
49
    RateControlContext *rcc= &s->rc_context;
50
    int i;
51
    emms_c();
52

    
53
    for(i=0; i<5; i++){
54
        rcc->pred[i].coeff= 7.0;
55
        rcc->pred[i].count= 1.0;
56
    
57
        rcc->pred[i].decay= 0.4;
58
        rcc->i_cplx_sum [i]=
59
        rcc->p_cplx_sum [i]=
60
        rcc->mv_bits_sum[i]=
61
        rcc->qscale_sum [i]=
62
        rcc->frame_count[i]= 1; // 1 is better cuz of 1/0 and such
63
        rcc->last_qscale_for[i]=5;
64
    }
65
    rcc->buffer_index= s->avctx->rc_buffer_size/2;
66

    
67
    if(s->flags&CODEC_FLAG_PASS2){
68
        int i;
69
        char *p;
70

    
71
        /* find number of pics */
72
        p= s->avctx->stats_in;
73
        for(i=-1; p; i++){
74
            p= strchr(p+1, ';');
75
        }
76
        i+= s->max_b_frames;
77
        rcc->entry = (RateControlEntry*)av_mallocz(i*sizeof(RateControlEntry));
78
        rcc->num_entries= i;
79
        
80
        /* init all to skiped p frames (with b frames we might have a not encoded frame at the end FIXME) */
81
        for(i=0; i<rcc->num_entries; i++){
82
            RateControlEntry *rce= &rcc->entry[i];
83
            rce->pict_type= rce->new_pict_type=P_TYPE;
84
            rce->qscale= rce->new_qscale=2;
85
            rce->misc_bits= s->mb_num + 10;
86
            rce->mb_var_sum= s->mb_num*100;
87
        }        
88
        
89
        /* read stats */
90
        p= s->avctx->stats_in;
91
        for(i=0; i<rcc->num_entries - s->max_b_frames; i++){
92
            RateControlEntry *rce;
93
            int picture_number;
94
            int e;
95
            char *next;
96

    
97
            next= strchr(p, ';');
98
            if(next){
99
                (*next)=0; //sscanf in unbelieavle slow on looong strings //FIXME copy / dont write
100
                next++;
101
            }
102
            e= sscanf(p, " in:%d ", &picture_number);
103

    
104
            assert(picture_number >= 0);
105
            assert(picture_number < rcc->num_entries);
106
            rce= &rcc->entry[picture_number];
107

    
108
            e+=sscanf(p, " in:%*d out:%*d type:%d q:%f itex:%d ptex:%d mv:%d misc:%d fcode:%d bcode:%d mc-var:%d var:%d icount:%d",
109
                   &rce->pict_type, &rce->qscale, &rce->i_tex_bits, &rce->p_tex_bits, &rce->mv_bits, &rce->misc_bits, 
110
                   &rce->f_code, &rce->b_code, &rce->mc_mb_var_sum, &rce->mb_var_sum, &rce->i_count);
111
            if(e!=12){
112
                fprintf(stderr, "statistics are damaged at line %d, parser out=%d\n", i, e);
113
                return -1;
114
            }
115
            p= next;
116
        }
117
        
118
        if(init_pass2(s) < 0) return -1;
119
    }
120
     
121
    if(!(s->flags&CODEC_FLAG_PASS2)){
122

    
123
        rcc->short_term_qsum=0.001;
124
        rcc->short_term_qcount=0.001;
125
    
126
        rcc->pass1_rc_eq_output_sum= 0.001;
127
        rcc->pass1_wanted_bits=0.001;
128
        
129
        /* init stuff with the user specified complexity */
130
        if(s->avctx->rc_initial_cplx){
131
            for(i=0; i<60*30; i++){
132
                double bits= s->avctx->rc_initial_cplx * (i/10000.0 + 1.0)*s->mb_num;
133
                RateControlEntry rce;
134
                double q;
135
                
136
                if     (i%((s->gop_size+3)/4)==0) rce.pict_type= I_TYPE;
137
                else if(i%(s->max_b_frames+1))    rce.pict_type= B_TYPE;
138
                else                              rce.pict_type= P_TYPE;
139

    
140
                rce.new_pict_type= rce.pict_type;
141
                rce.mc_mb_var_sum= bits*s->mb_num/100000;
142
                rce.mb_var_sum   = s->mb_num;
143
                rce.qscale   = 2;
144
                rce.f_code   = 2;
145
                rce.b_code   = 1;
146
                rce.misc_bits= 1;
147

    
148
                if(s->pict_type== I_TYPE){
149
                    rce.i_count   = s->mb_num;
150
                    rce.i_tex_bits= bits;
151
                    rce.p_tex_bits= 0;
152
                    rce.mv_bits= 0;
153
                }else{
154
                    rce.i_count   = 0; //FIXME we do know this approx
155
                    rce.i_tex_bits= 0;
156
                    rce.p_tex_bits= bits*0.9;
157
                    rce.mv_bits= bits*0.1;
158
                }
159
                rcc->i_cplx_sum [rce.pict_type] += rce.i_tex_bits*rce.qscale;
160
                rcc->p_cplx_sum [rce.pict_type] += rce.p_tex_bits*rce.qscale;
161
                rcc->mv_bits_sum[rce.pict_type] += rce.mv_bits;
162
                rcc->frame_count[rce.pict_type] ++;
163

    
164
                bits= rce.i_tex_bits + rce.p_tex_bits;
165

    
166
                q= get_qscale(s, &rce, rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum, i);
167
                rcc->pass1_wanted_bits+= s->bit_rate/(s->avctx->frame_rate / (double)s->avctx->frame_rate_base);
168
            }
169
        }
170

    
171
    }
172
    
173
    return 0;
174
}
175

    
176
void ff_rate_control_uninit(MpegEncContext *s)
177
{
178
    RateControlContext *rcc= &s->rc_context;
179
    emms_c();
180

    
181
    av_freep(&rcc->entry);
182
}
183

    
184
static inline double qp2bits(RateControlEntry *rce, double qp){
185
    if(qp<=0.0){
186
        fprintf(stderr, "qp<=0.0\n");
187
    }
188
    return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits+1)/ qp;
189
}
190

    
191
static inline double bits2qp(RateControlEntry *rce, double bits){
192
    if(bits<0.9){
193
        fprintf(stderr, "bits<0.9\n");
194
    }
195
    return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits+1)/ bits;
196
}
197
    
198
static void update_rc_buffer(MpegEncContext *s, int frame_size){
199
    RateControlContext *rcc= &s->rc_context;
200
    const double fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base;
201
    const double buffer_size= s->avctx->rc_buffer_size;
202
    const double min_rate= s->avctx->rc_min_rate/fps;
203
    const double max_rate= s->avctx->rc_max_rate/fps;
204

    
205
    if(buffer_size){
206
        rcc->buffer_index-= frame_size;
207
        if(rcc->buffer_index < buffer_size/2 /*FIXME /2 */ || min_rate==0){
208
            rcc->buffer_index+= max_rate;
209
            if(rcc->buffer_index >= buffer_size)
210
                rcc->buffer_index= buffer_size-1;
211
        }else{
212
            rcc->buffer_index+= min_rate;
213
        }
214
        
215
        if(rcc->buffer_index < 0)
216
            fprintf(stderr, "rc buffer underflow\n");
217
        if(rcc->buffer_index >= s->avctx->rc_buffer_size)
218
            fprintf(stderr, "rc buffer overflow\n");
219
    }
220
}
221

    
222
/**
223
 * modifies the bitrate curve from pass1 for one frame
224
 */
225
static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_factor, int frame_num){
226
    RateControlContext *rcc= &s->rc_context;
227
    double q, bits;
228
    const int pict_type= rce->new_pict_type;
229
    const double mb_num= s->mb_num;  
230
    int i;
231

    
232
    double const_values[]={
233
        M_PI,
234
        M_E,
235
        rce->i_tex_bits*rce->qscale,
236
        rce->p_tex_bits*rce->qscale,
237
        (rce->i_tex_bits + rce->p_tex_bits)*(double)rce->qscale,
238
        rce->mv_bits/mb_num,
239
        rce->pict_type == B_TYPE ? (rce->f_code + rce->b_code)*0.5 : rce->f_code,
240
        rce->i_count/mb_num,
241
        rce->mc_mb_var_sum/mb_num,
242
        rce->mb_var_sum/mb_num,
243
        rce->pict_type == I_TYPE,
244
        rce->pict_type == P_TYPE,
245
        rce->pict_type == B_TYPE,
246
        rcc->qscale_sum[pict_type] / (double)rcc->frame_count[pict_type],
247
        s->qcompress,
248
/*        rcc->last_qscale_for[I_TYPE],
249
        rcc->last_qscale_for[P_TYPE],
250
        rcc->last_qscale_for[B_TYPE],
251
        rcc->next_non_b_qscale,*/
252
        rcc->i_cplx_sum[I_TYPE] / (double)rcc->frame_count[I_TYPE],
253
        rcc->i_cplx_sum[P_TYPE] / (double)rcc->frame_count[P_TYPE],
254
        rcc->p_cplx_sum[P_TYPE] / (double)rcc->frame_count[P_TYPE],
255
        rcc->p_cplx_sum[B_TYPE] / (double)rcc->frame_count[B_TYPE],
256
        (rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / (double)rcc->frame_count[pict_type],
257
        0
258
    };
259
    static const char *const_names[]={
260
        "PI",
261
        "E",
262
        "iTex",
263
        "pTex",
264
        "tex",
265
        "mv",
266
        "fCode",
267
        "iCount",
268
        "mcVar",
269
        "var",
270
        "isI",
271
        "isP",
272
        "isB",
273
        "avgQP",
274
        "qComp",
275
/*        "lastIQP",
276
        "lastPQP",
277
        "lastBQP",
278
        "nextNonBQP",*/
279
        "avgIITex",
280
        "avgPITex",
281
        "avgPPTex",
282
        "avgBPTex",
283
        "avgTex",
284
        NULL
285
    };
286
    static double (*func1[])(void *, double)={
287
        (void *)bits2qp,
288
        (void *)qp2bits,
289
        NULL
290
    };
291
    static const char *func1_names[]={
292
        "bits2qp",
293
        "qp2bits",
294
        NULL
295
    };
296

    
297
    bits= ff_eval(s->avctx->rc_eq, const_values, const_names, func1, func1_names, NULL, NULL, rce);
298
    
299
    rcc->pass1_rc_eq_output_sum+= bits;
300
    bits*=rate_factor;
301
    if(bits<0.0) bits=0.0;
302
    bits+= 1.0; //avoid 1/0 issues
303
    
304
    /* user override */
305
    for(i=0; i<s->avctx->rc_override_count; i++){
306
        RcOverride *rco= s->avctx->rc_override;
307
        if(rco[i].start_frame > frame_num) continue;
308
        if(rco[i].end_frame   < frame_num) continue;
309
    
310
        if(rco[i].qscale) 
311
            bits= qp2bits(rce, rco[i].qscale); //FIXME move at end to really force it?
312
        else
313
            bits*= rco[i].quality_factor;
314
    }
315

    
316
    q= bits2qp(rce, bits);
317
    
318
    /* I/B difference */
319
    if     (pict_type==I_TYPE && s->avctx->i_quant_factor<0.0)
320
        q= -q*s->avctx->i_quant_factor + s->avctx->i_quant_offset;
321
    else if(pict_type==B_TYPE && s->avctx->b_quant_factor<0.0)
322
        q= -q*s->avctx->b_quant_factor + s->avctx->b_quant_offset;
323
        
324
    return q;
325
}
326

    
327
static double get_diff_limited_q(MpegEncContext *s, RateControlEntry *rce, double q){
328
    RateControlContext *rcc= &s->rc_context;
329
    AVCodecContext *a= s->avctx;
330
    const int pict_type= rce->new_pict_type;
331
    const double last_p_q    = rcc->last_qscale_for[P_TYPE];
332
    const double last_non_b_q= rcc->last_qscale_for[rcc->last_non_b_pict_type];
333
    
334
    if     (pict_type==I_TYPE && (a->i_quant_factor>0.0 || rcc->last_non_b_pict_type==P_TYPE))
335
        q= last_p_q    *ABS(a->i_quant_factor) + a->i_quant_offset;
336
    else if(pict_type==B_TYPE && a->b_quant_factor>0.0)
337
        q= last_non_b_q*    a->b_quant_factor  + a->b_quant_offset;
338

    
339
    /* last qscale / qdiff stuff */
340
    if(rcc->last_non_b_pict_type==pict_type || pict_type!=I_TYPE){
341
        double last_q= rcc->last_qscale_for[pict_type];
342

    
343
        if     (q > last_q + a->max_qdiff) q= last_q + a->max_qdiff;
344
        else if(q < last_q - a->max_qdiff) q= last_q - a->max_qdiff;
345
    }
346

    
347
    rcc->last_qscale_for[pict_type]= q; //Note we cant do that after blurring
348
    
349
    if(pict_type!=B_TYPE)
350
        rcc->last_non_b_pict_type= pict_type;
351

    
352
    return q;
353
}
354

    
355
/**
356
 * gets the qmin & qmax for pict_type
357
 */
358
static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type){
359
    int qmin= s->avctx->qmin;                                                       
360
    int qmax= s->avctx->qmax;
361

    
362
    if(pict_type==B_TYPE){
363
        qmin= (int)(qmin*ABS(s->avctx->b_quant_factor)+s->avctx->b_quant_offset + 0.5);
364
        qmax= (int)(qmax*ABS(s->avctx->b_quant_factor)+s->avctx->b_quant_offset + 0.5);
365
    }else if(pict_type==I_TYPE){
366
        qmin= (int)(qmin*ABS(s->avctx->i_quant_factor)+s->avctx->i_quant_offset + 0.5);
367
        qmax= (int)(qmax*ABS(s->avctx->i_quant_factor)+s->avctx->i_quant_offset + 0.5);
368
    }
369

    
370
    if(qmin<1) qmin=1;
371
    if(qmin==1 && s->avctx->qmin>1) qmin=2; //avoid qmin=1 unless the user wants qmin=1
372

    
373
    if(qmin<3 && s->max_qcoeff<=128 && pict_type==I_TYPE) qmin=3; //reduce cliping problems
374

    
375
    if(qmax>31) qmax=31;
376
    if(qmax<=qmin) qmax= qmin= (qmax+qmin+1)>>1;
377
    
378
    *qmin_ret= qmin;
379
    *qmax_ret= qmax;
380
}
381

    
382
static double modify_qscale(MpegEncContext *s, RateControlEntry *rce, double q, int frame_num){
383
    RateControlContext *rcc= &s->rc_context;
384
    int qmin, qmax;
385
    double bits;
386
    const int pict_type= rce->new_pict_type;
387
    const double buffer_size= s->avctx->rc_buffer_size;
388
    const double min_rate= s->avctx->rc_min_rate;
389
    const double max_rate= s->avctx->rc_max_rate;
390
    
391
    get_qminmax(&qmin, &qmax, s, pict_type);
392

    
393
    /* modulation */
394
    if(s->avctx->rc_qmod_freq && frame_num%s->avctx->rc_qmod_freq==0 && pict_type==P_TYPE)
395
        q*= s->avctx->rc_qmod_amp;
396

    
397
    bits= qp2bits(rce, q);
398
//printf("q:%f\n", q);
399
    /* buffer overflow/underflow protection */
400
    if(buffer_size){
401
        double expected_size= rcc->buffer_index;
402

    
403
        if(min_rate){
404
            double d= 2*(buffer_size - expected_size)/buffer_size;
405
            if(d>1.0) d=1.0;
406
            else if(d<0.0001) d=0.0001;
407
            q*= pow(d, 1.0/s->avctx->rc_buffer_aggressivity);
408

    
409
            q= FFMIN(q, bits2qp(rce, FFMAX((min_rate - buffer_size + rcc->buffer_index)*2, 1)));
410
        }
411

    
412
        if(max_rate){
413
            double d= 2*expected_size/buffer_size;
414
            if(d>1.0) d=1.0;
415
            else if(d<0.0001) d=0.0001;
416
            q/= pow(d, 1.0/s->avctx->rc_buffer_aggressivity);
417

    
418
            q= FFMAX(q, bits2qp(rce, FFMAX(rcc->buffer_index/2, 1)));
419
        }
420
    }
421
//printf("q:%f max:%f min:%f size:%f index:%d bits:%f agr:%f\n", q,max_rate, min_rate, buffer_size, rcc->buffer_index, bits, s->avctx->rc_buffer_aggressivity);
422
    if(s->avctx->rc_qsquish==0.0 || qmin==qmax){
423
        if     (q<qmin) q=qmin;
424
        else if(q>qmax) q=qmax;
425
    }else{
426
        double min2= log(qmin);
427
        double max2= log(qmax);
428
        
429
        q= log(q);
430
        q= (q - min2)/(max2-min2) - 0.5;
431
        q*= -4.0;
432
        q= 1.0/(1.0 + exp(q));
433
        q= q*(max2-min2) + min2;
434
        
435
        q= exp(q);
436
    }
437
    
438
    return q;
439
}
440

    
441
//----------------------------------
442
// 1 Pass Code
443

    
444
static double predict_size(Predictor *p, double q, double var)
445
{
446
     return p->coeff*var / (q*p->count);
447
}
448

    
449
/*
450
static double predict_qp(Predictor *p, double size, double var)
451
{
452
//printf("coeff:%f, count:%f, var:%f, size:%f//\n", p->coeff, p->count, var, size);
453
     return p->coeff*var / (size*p->count);
454
}
455
*/
456

    
457
static void update_predictor(Predictor *p, double q, double var, double size)
458
{
459
    double new_coeff= size*q / (var + 1);
460
    if(var<10) return;
461

    
462
    p->count*= p->decay;
463
    p->coeff*= p->decay;
464
    p->count++;
465
    p->coeff+= new_coeff;
466
}
467

    
468
static void adaptive_quantization(MpegEncContext *s, double q){
469
    int i;
470
    const float lumi_masking= s->avctx->lumi_masking / (128.0*128.0);
471
    const float dark_masking= s->avctx->dark_masking / (128.0*128.0);
472
    const float temp_cplx_masking= s->avctx->temporal_cplx_masking;
473
    const float spatial_cplx_masking = s->avctx->spatial_cplx_masking;
474
    const float p_masking = s->avctx->p_masking;
475
    float bits_sum= 0.0;
476
    float cplx_sum= 0.0;
477
    float cplx_tab[s->mb_num];
478
    float bits_tab[s->mb_num];
479
    const int qmin= s->avctx->mb_qmin;
480
    const int qmax= s->avctx->mb_qmax;
481
    Picture * const pic= &s->current_picture;
482
    int last_qscale=0;
483
    
484
    for(i=0; i<s->mb_num; i++){
485
        const int mb_xy= s->mb_index2xy[i];
486
        float temp_cplx= sqrt(pic->mc_mb_var[mb_xy]);
487
        float spat_cplx= sqrt(pic->mb_var[mb_xy]);
488
        const int lumi= pic->mb_mean[mb_xy];
489
        float bits, cplx, factor;
490
        
491
        if(spat_cplx < q/3) spat_cplx= q/3; //FIXME finetune
492
        if(temp_cplx < q/3) temp_cplx= q/3; //FIXME finetune
493
        
494
        if((s->mb_type[mb_xy]&MB_TYPE_INTRA)){//FIXME hq mode 
495
            cplx= spat_cplx;
496
            factor= 1.0 + p_masking;
497
        }else{
498
            cplx= temp_cplx;
499
            factor= pow(temp_cplx, - temp_cplx_masking);
500
        }
501
        factor*=pow(spat_cplx, - spatial_cplx_masking);
502

    
503
        if(lumi>127)
504
            factor*= (1.0 - (lumi-128)*(lumi-128)*lumi_masking);
505
        else
506
            factor*= (1.0 - (lumi-128)*(lumi-128)*dark_masking);
507
        
508
        if(factor<0.00001) factor= 0.00001;
509
        
510
        bits= cplx*factor;
511
        cplx_sum+= cplx;
512
        bits_sum+= bits;
513
        cplx_tab[i]= cplx;
514
        bits_tab[i]= bits;
515
    }
516

    
517
    /* handle qmin/qmax cliping */
518
    if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
519
        for(i=0; i<s->mb_num; i++){
520
            float newq= q*cplx_tab[i]/bits_tab[i];
521
            newq*= bits_sum/cplx_sum;
522

    
523
            if     (newq > qmax){
524
                bits_sum -= bits_tab[i];
525
                cplx_sum -= cplx_tab[i]*q/qmax;
526
            }
527
            else if(newq < qmin){
528
                bits_sum -= bits_tab[i];
529
                cplx_sum -= cplx_tab[i]*q/qmin;
530
            }
531
        }
532
    }
533
   
534
    for(i=0; i<s->mb_num; i++){
535
        const int mb_xy= s->mb_index2xy[i];
536
        float newq= q*cplx_tab[i]/bits_tab[i];
537
        int intq;
538

    
539
        if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
540
            newq*= bits_sum/cplx_sum;
541
        }
542

    
543
        if(i && ABS(last_qscale - newq)<0.75)
544
            intq= last_qscale;
545
        else
546
            intq= (int)(newq + 0.5);
547

    
548
        if     (intq > qmax) intq= qmax;
549
        else if(intq < qmin) intq= qmin;
550
//if(i%s->mb_width==0) printf("\n");
551
//printf("%2d%3d ", intq, ff_sqrt(s->mc_mb_var[i]));
552
        last_qscale=
553
        pic->qscale_table[mb_xy]= intq;
554
    }
555
}
556

    
557
float ff_rate_estimate_qscale(MpegEncContext *s)
558
{
559
    float q;
560
    int qmin, qmax;
561
    float br_compensation;
562
    double diff;
563
    double short_term_q;
564
    double fps;
565
    int picture_number= s->picture_number;
566
    int64_t wanted_bits;
567
    RateControlContext *rcc= &s->rc_context;
568
    RateControlEntry local_rce, *rce;
569
    double bits;
570
    double rate_factor;
571
    int var;
572
    const int pict_type= s->pict_type;
573
    Picture * const pic= &s->current_picture;
574
    emms_c();
575

    
576
    get_qminmax(&qmin, &qmax, s, pict_type);
577

    
578
    fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base;
579
//printf("input_pic_num:%d pic_num:%d frame_rate:%d\n", s->input_picture_number, s->picture_number, s->frame_rate);
580
        /* update predictors */
581
    if(picture_number>2){
582
        const int last_var= s->last_pict_type == I_TYPE ? rcc->last_mb_var_sum : rcc->last_mc_mb_var_sum;
583
        update_predictor(&rcc->pred[s->last_pict_type], rcc->last_qscale, sqrt(last_var), s->frame_bits);
584
    }
585

    
586
    if(s->flags&CODEC_FLAG_PASS2){
587
        assert(picture_number>=0);
588
        assert(picture_number<rcc->num_entries);
589
        rce= &rcc->entry[picture_number];
590
        wanted_bits= rce->expected_bits;
591
    }else{
592
        rce= &local_rce;
593
        wanted_bits= (uint64_t)(s->bit_rate*(double)picture_number/fps);
594
    }
595

    
596
    diff= s->total_bits - wanted_bits;
597
    br_compensation= (s->bit_rate_tolerance - diff)/s->bit_rate_tolerance;
598
    if(br_compensation<=0.0) br_compensation=0.001;
599

    
600
    var= pict_type == I_TYPE ? pic->mb_var_sum : pic->mc_mb_var_sum;
601
    
602
    if(s->flags&CODEC_FLAG_PASS2){
603
        if(pict_type!=I_TYPE)
604
            assert(pict_type == rce->new_pict_type);
605

    
606
        q= rce->new_qscale / br_compensation;
607
//printf("%f %f %f last:%d var:%d type:%d//\n", q, rce->new_qscale, br_compensation, s->frame_bits, var, pict_type);
608
    }else{
609
        rce->pict_type= 
610
        rce->new_pict_type= pict_type;
611
        rce->mc_mb_var_sum= pic->mc_mb_var_sum;
612
        rce->mb_var_sum   = pic->   mb_var_sum;
613
        rce->qscale   = 2;
614
        rce->f_code   = s->f_code;
615
        rce->b_code   = s->b_code;
616
        rce->misc_bits= 1;
617

    
618
        if(picture_number>0)
619
            update_rc_buffer(s, s->frame_bits);
620

    
621
        bits= predict_size(&rcc->pred[pict_type], rce->qscale, sqrt(var));
622
        if(pict_type== I_TYPE){
623
            rce->i_count   = s->mb_num;
624
            rce->i_tex_bits= bits;
625
            rce->p_tex_bits= 0;
626
            rce->mv_bits= 0;
627
        }else{
628
            rce->i_count   = 0; //FIXME we do know this approx
629
            rce->i_tex_bits= 0;
630
            rce->p_tex_bits= bits*0.9;
631
            
632
            rce->mv_bits= bits*0.1;
633
        }
634
        rcc->i_cplx_sum [pict_type] += rce->i_tex_bits*rce->qscale;
635
        rcc->p_cplx_sum [pict_type] += rce->p_tex_bits*rce->qscale;
636
        rcc->mv_bits_sum[pict_type] += rce->mv_bits;
637
        rcc->frame_count[pict_type] ++;
638

    
639
        bits= rce->i_tex_bits + rce->p_tex_bits;
640
        rate_factor= rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum * br_compensation;
641
    
642
        q= get_qscale(s, rce, rate_factor, picture_number);
643

    
644
        assert(q>0.0);
645
//printf("%f ", q);
646
        q= get_diff_limited_q(s, rce, q);
647
//printf("%f ", q);
648
        assert(q>0.0);
649

    
650
        if(pict_type==P_TYPE || s->intra_only){ //FIXME type dependant blur like in 2-pass
651
            rcc->short_term_qsum*=s->qblur;
652
            rcc->short_term_qcount*=s->qblur;
653

    
654
            rcc->short_term_qsum+= q;
655
            rcc->short_term_qcount++;
656
//printf("%f ", q);
657
            q= short_term_q= rcc->short_term_qsum/rcc->short_term_qcount;
658
//printf("%f ", q);
659
        }
660
        assert(q>0.0);
661
        
662
        q= modify_qscale(s, rce, q, picture_number);
663

    
664
        rcc->pass1_wanted_bits+= s->bit_rate/fps;
665

    
666
        assert(q>0.0);
667
    }
668

    
669
    if(s->avctx->debug&FF_DEBUG_RC){
670
        printf("%c qp:%d<%2.1f<%d %d want:%d total:%d comp:%f st_q:%2.2f size:%d var:%d/%d br:%d fps:%d\n",
671
        ff_get_pict_type_char(pict_type), qmin, q, qmax, picture_number, (int)wanted_bits/1000, (int)s->total_bits/1000,
672
        br_compensation, short_term_q, s->frame_bits, pic->mb_var_sum, pic->mc_mb_var_sum, s->bit_rate/1000, (int)fps
673
        );
674
    }
675

    
676
    if     (q<qmin) q=qmin; 
677
    else if(q>qmax) q=qmax;
678

    
679
    if(s->adaptive_quant)
680
        adaptive_quantization(s, q);
681
    else
682
        q= (int)(q + 0.5);
683
    
684
    rcc->last_qscale= q;
685
    rcc->last_mc_mb_var_sum= pic->mc_mb_var_sum;
686
    rcc->last_mb_var_sum= pic->mb_var_sum;
687
#if 0
688
{
689
    static int mvsum=0, texsum=0;
690
    mvsum += s->mv_bits;
691
    texsum += s->i_tex_bits + s->p_tex_bits;
692
    printf("%d %d//\n\n", mvsum, texsum);
693
}
694
#endif
695
    return q;
696
}
697

    
698
//----------------------------------------------
699
// 2-Pass code
700

    
701
static int init_pass2(MpegEncContext *s)
702
{
703
    RateControlContext *rcc= &s->rc_context;
704
    int i;
705
    double fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base;
706
    double complexity[5]={0,0,0,0,0};   // aproximate bits at quant=1
707
    double avg_quantizer[5];
708
    uint64_t const_bits[5]={0,0,0,0,0}; // quantizer idependant bits
709
    uint64_t available_bits[5];
710
    uint64_t all_const_bits;
711
    uint64_t all_available_bits= (uint64_t)(s->bit_rate*(double)rcc->num_entries/fps);
712
    double rate_factor=0;
713
    double step;
714
    //int last_i_frame=-10000000;
715
    const int filter_size= (int)(s->qblur*4) | 1;  
716
    double expected_bits;
717
    double *qscale, *blured_qscale;
718

    
719
    /* find complexity & const_bits & decide the pict_types */
720
    for(i=0; i<rcc->num_entries; i++){
721
        RateControlEntry *rce= &rcc->entry[i];
722
        
723
        rce->new_pict_type= rce->pict_type;
724
        rcc->i_cplx_sum [rce->pict_type] += rce->i_tex_bits*rce->qscale;
725
        rcc->p_cplx_sum [rce->pict_type] += rce->p_tex_bits*rce->qscale;
726
        rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits;
727
        rcc->frame_count[rce->pict_type] ++;
728

    
729
        complexity[rce->new_pict_type]+= (rce->i_tex_bits+ rce->p_tex_bits)*(double)rce->qscale;
730
        const_bits[rce->new_pict_type]+= rce->mv_bits + rce->misc_bits;
731
    }
732
    all_const_bits= const_bits[I_TYPE] + const_bits[P_TYPE] + const_bits[B_TYPE];
733
    
734
    if(all_available_bits < all_const_bits){
735
        fprintf(stderr, "requested bitrate is to low\n");
736
        return -1;
737
    }
738
    
739
    /* find average quantizers */
740
    avg_quantizer[P_TYPE]=0;
741
    for(step=256*256; step>0.0000001; step*=0.5){
742
        double expected_bits=0;
743
        avg_quantizer[P_TYPE]+= step;
744
        
745
        avg_quantizer[I_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->i_quant_factor) + s->avctx->i_quant_offset;
746
        avg_quantizer[B_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
747
        
748
        expected_bits= 
749
            + all_const_bits 
750
            + complexity[I_TYPE]/avg_quantizer[I_TYPE]
751
            + complexity[P_TYPE]/avg_quantizer[P_TYPE]
752
            + complexity[B_TYPE]/avg_quantizer[B_TYPE];
753
            
754
        if(expected_bits < all_available_bits) avg_quantizer[P_TYPE]-= step;
755
//printf("%f %lld %f\n", expected_bits, all_available_bits, avg_quantizer[P_TYPE]);
756
    }
757
//printf("qp_i:%f, qp_p:%f, qp_b:%f\n", avg_quantizer[I_TYPE],avg_quantizer[P_TYPE],avg_quantizer[B_TYPE]);
758

    
759
    for(i=0; i<5; i++){
760
        available_bits[i]= const_bits[i] + complexity[i]/avg_quantizer[i];
761
    }
762
//printf("%lld %lld %lld %lld\n", available_bits[I_TYPE], available_bits[P_TYPE], available_bits[B_TYPE], all_available_bits);
763
        
764
    qscale= av_malloc(sizeof(double)*rcc->num_entries);
765
    blured_qscale= av_malloc(sizeof(double)*rcc->num_entries);
766

    
767
    for(step=256*256; step>0.0000001; step*=0.5){
768
        expected_bits=0;
769
        rate_factor+= step;
770
        
771
        rcc->buffer_index= s->avctx->rc_buffer_size/2;
772

    
773
        /* find qscale */
774
        for(i=0; i<rcc->num_entries; i++){
775
            qscale[i]= get_qscale(s, &rcc->entry[i], rate_factor, i);
776
        }
777
        assert(filter_size%2==1);
778

    
779
        /* fixed I/B QP relative to P mode */
780
        for(i=rcc->num_entries-1; i>=0; i--){
781
            RateControlEntry *rce= &rcc->entry[i];
782
            
783
            qscale[i]= get_diff_limited_q(s, rce, qscale[i]);
784
        }
785

    
786
        /* smooth curve */
787
        for(i=0; i<rcc->num_entries; i++){
788
            RateControlEntry *rce= &rcc->entry[i];
789
            const int pict_type= rce->new_pict_type;
790
            int j;
791
            double q=0.0, sum=0.0;
792
        
793
            for(j=0; j<filter_size; j++){
794
                int index= i+j-filter_size/2;
795
                double d= index-i;
796
                double coeff= s->qblur==0 ? 1.0 : exp(-d*d/(s->qblur * s->qblur));
797
            
798
                if(index < 0 || index >= rcc->num_entries) continue;
799
                if(pict_type != rcc->entry[index].new_pict_type) continue;
800
                q+= qscale[index] * coeff;
801
                sum+= coeff;
802
            }
803
            blured_qscale[i]= q/sum;
804
        }
805
    
806
        /* find expected bits */
807
        for(i=0; i<rcc->num_entries; i++){
808
            RateControlEntry *rce= &rcc->entry[i];
809
            double bits;
810
            rce->new_qscale= modify_qscale(s, rce, blured_qscale[i], i);
811
            bits= qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;
812
//printf("%d %f\n", rce->new_bits, blured_qscale[i]);
813
            update_rc_buffer(s, bits);
814

    
815
            rce->expected_bits= expected_bits;
816
            expected_bits += bits;
817
        }
818

    
819
//        printf("%f %d %f\n", expected_bits, (int)all_available_bits, rate_factor);
820
        if(expected_bits > all_available_bits) rate_factor-= step;
821
    }
822
    av_free(qscale);
823
    av_free(blured_qscale);
824

    
825
    if(abs(expected_bits/all_available_bits - 1.0) > 0.01 ){
826
        fprintf(stderr, "Error: 2pass curve failed to converge\n");
827
        return -1;
828
    }
829

    
830
    return 0;
831
}