Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ratecontrol.c @ 2d5e962b

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
    assert(qmin <= qmax);
363

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

    
372
    qmin= clip(qmin, 1, 31);
373
    qmax= clip(qmax, 1, 31);
374

    
375
    if(qmin==1 && s->avctx->qmin>1) qmin=2; //avoid qmin=1 unless the user wants qmin=1
376

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

    
379
    if(qmax<qmin) qmax= qmin;
380
    
381
    *qmin_ret= qmin;
382
    *qmax_ret= qmax;
383
}
384

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

    
396
    /* modulation */
397
    if(s->avctx->rc_qmod_freq && frame_num%s->avctx->rc_qmod_freq==0 && pict_type==P_TYPE)
398
        q*= s->avctx->rc_qmod_amp;
399

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

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

    
412
            q= FFMIN(q, bits2qp(rce, FFMAX((min_rate - buffer_size + rcc->buffer_index)*2, 1)));
413
        }
414

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

    
421
            q= FFMAX(q, bits2qp(rce, FFMAX(rcc->buffer_index/2, 1)));
422
        }
423
    }
424
//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);
425
    if(s->avctx->rc_qsquish==0.0 || qmin==qmax){
426
        if     (q<qmin) q=qmin;
427
        else if(q>qmax) q=qmax;
428
    }else{
429
        double min2= log(qmin);
430
        double max2= log(qmax);
431
        
432
        q= log(q);
433
        q= (q - min2)/(max2-min2) - 0.5;
434
        q*= -4.0;
435
        q= 1.0/(1.0 + exp(q));
436
        q= q*(max2-min2) + min2;
437
        
438
        q= exp(q);
439
    }
440
    
441
    return q;
442
}
443

    
444
//----------------------------------
445
// 1 Pass Code
446

    
447
static double predict_size(Predictor *p, double q, double var)
448
{
449
     return p->coeff*var / (q*p->count);
450
}
451

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

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

    
465
    p->count*= p->decay;
466
    p->coeff*= p->decay;
467
    p->count++;
468
    p->coeff+= new_coeff;
469
}
470

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

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

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

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

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

    
546
        if(i && ABS(last_qscale - newq)<0.75)
547
            intq= last_qscale;
548
        else
549
            intq= (int)(newq + 0.5);
550

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

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

    
579
    get_qminmax(&qmin, &qmax, s, pict_type);
580

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

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

    
599
    diff= s->total_bits - wanted_bits;
600
    br_compensation= (s->bit_rate_tolerance - diff)/s->bit_rate_tolerance;
601
    if(br_compensation<=0.0) br_compensation=0.001;
602

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

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

    
621
        if(picture_number>0)
622
            update_rc_buffer(s, s->frame_bits);
623

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

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

    
647
        assert(q>0.0);
648
//printf("%f ", q);
649
        q= get_diff_limited_q(s, rce, q);
650
//printf("%f ", q);
651
        assert(q>0.0);
652

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

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

    
667
        rcc->pass1_wanted_bits+= s->bit_rate/fps;
668

    
669
        assert(q>0.0);
670
    }
671

    
672
    if(s->avctx->debug&FF_DEBUG_RC){
673
        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",
674
        av_get_pict_type_char(pict_type), qmin, q, qmax, picture_number, (int)wanted_bits/1000, (int)s->total_bits/1000,
675
        br_compensation, short_term_q, s->frame_bits, pic->mb_var_sum, pic->mc_mb_var_sum, s->bit_rate/1000, (int)fps
676
        );
677
    }
678

    
679
    if     (q<qmin) q=qmin; 
680
    else if(q>qmax) q=qmax;
681

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

    
701
//----------------------------------------------
702
// 2-Pass code
703

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

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

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

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

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

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

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

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

    
818
            rce->expected_bits= expected_bits;
819
            expected_bits += bits;
820
        }
821

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

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

    
833
    return 0;
834
}