Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ratecontrol.c @ 0d1e9246

History | View | Annotate | Download (27.2 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
#include <math.h>
21
#include "common.h"
22
#include "avcodec.h"
23
#include "dsputil.h"
24
#include "mpegvideo.h"
25

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

    
29
#ifndef M_PI
30
#define M_PI 3.14159265358979323846
31
#endif
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
    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
    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
        if     (q > last_q + a->max_qdiff) q= last_q + a->max_qdiff;
343
        else if(q < last_q - a->max_qdiff) q= last_q - a->max_qdiff;
344
    }
345

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

    
351
    return q;
352
}
353

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

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

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

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

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

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

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

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

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

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

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

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

    
440
//----------------------------------
441
// 1 Pass Code
442

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

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

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

    
459
    p->count*= p->decay;
460
    p->coeff*= p->decay;
461
    p->count++;
462
    p->coeff+= new_coeff;
463
}
464

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

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

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

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

    
533
        if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
534
            newq*= bits_sum/cplx_sum;
535
        }
536

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

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

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

    
569
    get_qminmax(&qmin, &qmax, s, pict_type);
570

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

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

    
589
    diff= s->total_bits - wanted_bits;
590
    br_compensation= (s->bit_rate_tolerance - diff)/s->bit_rate_tolerance;
591
    if(br_compensation<=0.0) br_compensation=0.001;
592

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

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

    
611
        if(picture_number>0)
612
            update_rc_buffer(s, s->frame_bits);
613

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

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

    
637
        assert(q>0.0);
638
//printf("%f ", q);
639
        q= get_diff_limited_q(s, rce, q);
640
//printf("%f ", q);
641
        assert(q>0.0);
642

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

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

    
657
        rcc->pass1_wanted_bits+= s->bit_rate/fps;
658

    
659
        assert(q>0.0);
660
    }
661
//printf("qmin:%d, qmax:%d, q:%f\n", qmin, qmax, q);
662
    
663

    
664
    if     (q<qmin) q=qmin; 
665
    else if(q>qmax) q=qmax;
666
        
667
//    printf("%f %d %d %d\n", q, picture_number, (int)wanted_bits, (int)s->total_bits);
668
       
669
//printf("diff:%d comp:%f st_q:%f last_size:%d type:%d\n", (int)diff, br_compensation, 
670
//       short_term_q, s->frame_bits, pict_type);
671
//printf("%d %d\n", s->bit_rate, (int)fps);
672

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

    
692
//----------------------------------------------
693
// 2-Pass code
694

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

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

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

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

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

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

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

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

    
809
            rce->expected_bits= expected_bits;
810
            expected_bits += bits;
811
        }
812

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

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

    
824
    return 0;
825
}