Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ratecontrol.c @ 8dbcc9f2

History | View | Annotate | Download (27.7 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:%d 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->current_picture.quality, 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= FF_QP2LAMBDA * 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]=FF_QP2LAMBDA * 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=FF_QP2LAMBDA * 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
                av_log(s->avctx, AV_LOG_ERROR, "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   = FF_QP2LAMBDA * 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
        av_log(NULL, AV_LOG_ERROR, "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
        av_log(NULL, AV_LOG_ERROR, "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
            av_log(s->avctx, AV_LOG_ERROR, "rc buffer underflow\n");
217
        if(rcc->buffer_index >= s->avctx->rc_buffer_size)
218
            av_log(s->avctx, AV_LOG_ERROR, "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
        const int maxdiff= FF_QP2LAMBDA * a->max_qdiff;
343

    
344
        if     (q > last_q + maxdiff) q= last_q + maxdiff;
345
        else if(q < last_q - maxdiff) q= last_q - maxdiff;
346
    }
347

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

    
353
    return q;
354
}
355

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

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

    
373
    qmin= clip(qmin, 1, FF_LAMBDA_MAX);
374
    qmax= clip(qmax, 1, FF_LAMBDA_MAX);
375

    
376
    if(qmax<qmin) qmax= qmin;
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->lmin;
480
    const int qmax= s->avctx->lmax;
481
    Picture * const pic= &s->current_picture;
482
    
483
    for(i=0; i<s->mb_num; i++){
484
        const int mb_xy= s->mb_index2xy[i];
485
        float temp_cplx= sqrt(pic->mc_mb_var[mb_xy]); //FIXME merge in pow()
486
        float spat_cplx= sqrt(pic->mb_var[mb_xy]);
487
        const int lumi= pic->mb_mean[mb_xy];
488
        float bits, cplx, factor;
489
#if 0        
490
        if(spat_cplx < q/3) spat_cplx= q/3; //FIXME finetune
491
        if(temp_cplx < q/3) temp_cplx= q/3; //FIXME finetune
492
#endif   
493
        if(spat_cplx < 4) spat_cplx= 4; //FIXME finetune
494
        if(temp_cplx < 4) temp_cplx= 4; //FIXME finetune
495

    
496
        if((s->mb_type[mb_xy]&MB_TYPE_INTRA)){//FIXME hq mode 
497
            cplx= spat_cplx;
498
            factor= 1.0 + p_masking;
499
        }else{
500
            cplx= temp_cplx;
501
            factor= pow(temp_cplx, - temp_cplx_masking);
502
        }
503
        factor*=pow(spat_cplx, - spatial_cplx_masking);
504

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

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

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

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

    
545
        intq= (int)(newq + 0.5);
546

    
547
        if     (intq > qmax) intq= qmax;
548
        else if(intq < qmin) intq= qmin;
549
//if(i%s->mb_width==0) printf("\n");
550
//printf("%2d%3d ", intq, ff_sqrt(s->mc_mb_var[i]));
551
        s->lambda_table[mb_xy]= intq;
552
    }
553
}
554
//FIXME rd or at least approx for dquant
555

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

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

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

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

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

    
599
    var= pict_type == I_TYPE ? pic->mb_var_sum : pic->mc_mb_var_sum;
600
    
601
    short_term_q = 0; /* avoid warning */
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   = FF_QP2LAMBDA * 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
        av_log(s->avctx, AV_LOG_DEBUG, "%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
        av_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
        av_log(s->avctx, AV_LOG_ERROR, "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
        av_log(s->avctx, AV_LOG_ERROR, "Error: 2pass curve failed to converge\n");
827
        return -1;
828
    }
829

    
830
    return 0;
831
}