Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ratecontrol.c @ 983e3246

History | View | Annotate | Download (27.3 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->frame_rate / (double)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->frame_rate / 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->qmin;                                                       
360
    int qmax= s->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->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
    
483
    for(i=0; i<s->mb_num; i++){
484
        float temp_cplx= sqrt(pic->mc_mb_var[i]);
485
        float spat_cplx= sqrt(pic->mb_var[i]);
486
        const int lumi= pic->mb_mean[i];
487
        float bits, cplx, factor;
488
        
489
        if(spat_cplx < q/3) spat_cplx= q/3; //FIXME finetune
490
        if(temp_cplx < q/3) temp_cplx= q/3; //FIXME finetune
491
        
492
        if((s->mb_type[i]&MB_TYPE_INTRA)){//FIXME hq mode 
493
            cplx= spat_cplx;
494
            factor= 1.0 + p_masking;
495
        }else{
496
            cplx= temp_cplx;
497
            factor= pow(temp_cplx, - temp_cplx_masking);
498
        }
499
        factor*=pow(spat_cplx, - spatial_cplx_masking);
500

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

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

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

    
536
        if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
537
            newq*= bits_sum/cplx_sum;
538
        }
539

    
540
        if(i && ABS(pic->qscale_table[i-1] - newq)<0.75)
541
            intq= pic->qscale_table[i-1];
542
        else
543
            intq= (int)(newq + 0.5);
544

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

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

    
572
    get_qminmax(&qmin, &qmax, s, pict_type);
573

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

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

    
592
    diff= s->total_bits - wanted_bits;
593
    br_compensation= (s->bit_rate_tolerance - diff)/s->bit_rate_tolerance;
594
    if(br_compensation<=0.0) br_compensation=0.001;
595

    
596
    var= pict_type == I_TYPE ? pic->mb_var_sum : pic->mc_mb_var_sum;
597
    
598
    if(s->flags&CODEC_FLAG_PASS2){
599
        if(pict_type!=I_TYPE)
600
            assert(pict_type == rce->new_pict_type);
601

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

    
614
        if(picture_number>0)
615
            update_rc_buffer(s, s->frame_bits);
616

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

    
635
        bits= rce->i_tex_bits + rce->p_tex_bits;
636
        rate_factor= rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum * br_compensation;
637
    
638
        q= get_qscale(s, rce, rate_factor, picture_number);
639

    
640
        assert(q>0.0);
641
//printf("%f ", q);
642
        q= get_diff_limited_q(s, rce, q);
643
//printf("%f ", q);
644
        assert(q>0.0);
645

    
646
        if(pict_type==P_TYPE || s->intra_only){ //FIXME type dependant blur like in 2-pass
647
            rcc->short_term_qsum*=s->qblur;
648
            rcc->short_term_qcount*=s->qblur;
649

    
650
            rcc->short_term_qsum+= q;
651
            rcc->short_term_qcount++;
652
//printf("%f ", q);
653
            q= short_term_q= rcc->short_term_qsum/rcc->short_term_qcount;
654
//printf("%f ", q);
655
        }
656
        assert(q>0.0);
657
        
658
        q= modify_qscale(s, rce, q, picture_number);
659

    
660
        rcc->pass1_wanted_bits+= s->bit_rate/fps;
661

    
662
        assert(q>0.0);
663
    }
664

    
665
    if(s->avctx->debug&FF_DEBUG_RC){
666
        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",
667
        ff_get_pict_type_char(pict_type), qmin, q, qmax, picture_number, (int)wanted_bits/1000, (int)s->total_bits/1000,
668
        br_compensation, short_term_q, s->frame_bits, pic->mb_var_sum, pic->mc_mb_var_sum, s->bit_rate/1000, (int)fps
669
        );
670
    }
671

    
672
    if     (q<qmin) q=qmin; 
673
    else if(q>qmax) q=qmax;
674

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

    
694
//----------------------------------------------
695
// 2-Pass code
696

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

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

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

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

    
763
    for(step=256*256; step>0.0000001; step*=0.5){
764
        expected_bits=0;
765
        rate_factor+= step;
766
        
767
        rcc->buffer_index= s->avctx->rc_buffer_size/2;
768

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

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

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

    
811
            rce->expected_bits= expected_bits;
812
            expected_bits += bits;
813
        }
814

    
815
//        printf("%f %d %f\n", expected_bits, (int)all_available_bits, rate_factor);
816
        if(expected_bits > all_available_bits) rate_factor-= step;
817
    }
818
    av_free(qscale);
819
    av_free(blured_qscale);
820

    
821
    if(abs(expected_bits/all_available_bits - 1.0) > 0.01 ){
822
        fprintf(stderr, "Error: 2pass curve failed to converge\n");
823
        return -1;
824
    }
825

    
826
    return 0;
827
}