Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ratecontrol.c @ 8f2ab833

History | View | Annotate | Download (28.6 KB)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
171
    }
172
    
173
    return 0;
174
}
175

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

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

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

    
191
static inline double bits2qp(RateControlEntry *rce, double bits){
192
    if(bits<0.9){
193
        av_log(NULL, AV_LOG_ERROR, "bits<0.9\n");
194
    }
195
    return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits+1)/ bits;
196
}
197
    
198
int ff_vbv_update(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 int 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
//printf("%d %f %d %f %f\n", buffer_size, rcc->buffer_index, frame_size, min_rate, max_rate);
206
    if(buffer_size){
207
        int left;
208

    
209
        rcc->buffer_index-= frame_size;
210
        if(rcc->buffer_index < 0){
211
            av_log(s->avctx, AV_LOG_ERROR, "rc buffer underflow\n");
212
            rcc->buffer_index= 0;
213
        }
214

    
215
        left= buffer_size - rcc->buffer_index - 1;
216
        rcc->buffer_index += clip(left, min_rate, max_rate);
217

    
218
        if(rcc->buffer_index > buffer_size){
219
            int stuffing= ceil((rcc->buffer_index - buffer_size)/8);
220
            
221
            if(stuffing < 4 && s->codec_id == CODEC_ID_MPEG4)
222
                stuffing=4;
223
            rcc->buffer_index -= 8*stuffing;
224
            
225
            if(s->avctx->debug & FF_DEBUG_RC)
226
                av_log(s->avctx, AV_LOG_DEBUG, "stuffing %d bytes\n", stuffing);
227

    
228
            return stuffing;
229
        }
230
    }
231
    return 0;
232
}
233

    
234
/**
235
 * modifies the bitrate curve from pass1 for one frame
236
 */
237
static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_factor, int frame_num){
238
    RateControlContext *rcc= &s->rc_context;
239
    AVCodecContext *a= s->avctx;
240
    double q, bits;
241
    const int pict_type= rce->new_pict_type;
242
    const double mb_num= s->mb_num;  
243
    int i;
244

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

    
310
    bits= ff_eval(s->avctx->rc_eq, const_values, const_names, func1, func1_names, NULL, NULL, rce);
311
    
312
    rcc->pass1_rc_eq_output_sum+= bits;
313
    bits*=rate_factor;
314
    if(bits<0.0) bits=0.0;
315
    bits+= 1.0; //avoid 1/0 issues
316
    
317
    /* user override */
318
    for(i=0; i<s->avctx->rc_override_count; i++){
319
        RcOverride *rco= s->avctx->rc_override;
320
        if(rco[i].start_frame > frame_num) continue;
321
        if(rco[i].end_frame   < frame_num) continue;
322
    
323
        if(rco[i].qscale) 
324
            bits= qp2bits(rce, rco[i].qscale); //FIXME move at end to really force it?
325
        else
326
            bits*= rco[i].quality_factor;
327
    }
328

    
329
    q= bits2qp(rce, bits);
330
    
331
    /* I/B difference */
332
    if     (pict_type==I_TYPE && s->avctx->i_quant_factor<0.0)
333
        q= -q*s->avctx->i_quant_factor + s->avctx->i_quant_offset;
334
    else if(pict_type==B_TYPE && s->avctx->b_quant_factor<0.0)
335
        q= -q*s->avctx->b_quant_factor + s->avctx->b_quant_offset;
336
        
337
    return q;
338
}
339

    
340
static double get_diff_limited_q(MpegEncContext *s, RateControlEntry *rce, double q){
341
    RateControlContext *rcc= &s->rc_context;
342
    AVCodecContext *a= s->avctx;
343
    const int pict_type= rce->new_pict_type;
344
    const double last_p_q    = rcc->last_qscale_for[P_TYPE];
345
    const double last_non_b_q= rcc->last_qscale_for[rcc->last_non_b_pict_type];
346
    
347
    if     (pict_type==I_TYPE && (a->i_quant_factor>0.0 || rcc->last_non_b_pict_type==P_TYPE))
348
        q= last_p_q    *ABS(a->i_quant_factor) + a->i_quant_offset;
349
    else if(pict_type==B_TYPE && a->b_quant_factor>0.0)
350
        q= last_non_b_q*    a->b_quant_factor  + a->b_quant_offset;
351

    
352
    /* last qscale / qdiff stuff */
353
    if(rcc->last_non_b_pict_type==pict_type || pict_type!=I_TYPE){
354
        double last_q= rcc->last_qscale_for[pict_type];
355
        const int maxdiff= FF_QP2LAMBDA * a->max_qdiff;
356

    
357
        if     (q > last_q + maxdiff) q= last_q + maxdiff;
358
        else if(q < last_q - maxdiff) q= last_q - maxdiff;
359
    }
360

    
361
    rcc->last_qscale_for[pict_type]= q; //Note we cant do that after blurring
362
    
363
    if(pict_type!=B_TYPE)
364
        rcc->last_non_b_pict_type= pict_type;
365

    
366
    return q;
367
}
368

    
369
/**
370
 * gets the qmin & qmax for pict_type
371
 */
372
static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type){
373
    int qmin= s->avctx->lmin;                                                       
374
    int qmax= s->avctx->lmax;
375
    
376
    assert(qmin <= qmax);
377

    
378
    if(pict_type==B_TYPE){
379
        qmin= (int)(qmin*ABS(s->avctx->b_quant_factor)+s->avctx->b_quant_offset + 0.5);
380
        qmax= (int)(qmax*ABS(s->avctx->b_quant_factor)+s->avctx->b_quant_offset + 0.5);
381
    }else if(pict_type==I_TYPE){
382
        qmin= (int)(qmin*ABS(s->avctx->i_quant_factor)+s->avctx->i_quant_offset + 0.5);
383
        qmax= (int)(qmax*ABS(s->avctx->i_quant_factor)+s->avctx->i_quant_offset + 0.5);
384
    }
385

    
386
    qmin= clip(qmin, 1, FF_LAMBDA_MAX);
387
    qmax= clip(qmax, 1, FF_LAMBDA_MAX);
388

    
389
    if(qmax<qmin) qmax= qmin;
390
    
391
    *qmin_ret= qmin;
392
    *qmax_ret= qmax;
393
}
394

    
395
static double modify_qscale(MpegEncContext *s, RateControlEntry *rce, double q, int frame_num){
396
    RateControlContext *rcc= &s->rc_context;
397
    int qmin, qmax;
398
    double bits;
399
    const int pict_type= rce->new_pict_type;
400
    const double buffer_size= s->avctx->rc_buffer_size;
401
    const double fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base;
402
    const double min_rate= s->avctx->rc_min_rate / fps;
403
    const double max_rate= s->avctx->rc_max_rate / fps;
404
    
405
    get_qminmax(&qmin, &qmax, s, pict_type);
406

    
407
    /* modulation */
408
    if(s->avctx->rc_qmod_freq && frame_num%s->avctx->rc_qmod_freq==0 && pict_type==P_TYPE)
409
        q*= s->avctx->rc_qmod_amp;
410

    
411
    bits= qp2bits(rce, q);
412
//printf("q:%f\n", q);
413
    /* buffer overflow/underflow protection */
414
    if(buffer_size){
415
        double expected_size= rcc->buffer_index;
416
        double q_limit;
417

    
418
        if(min_rate){
419
            double d= 2*(buffer_size - expected_size)/buffer_size;
420
            if(d>1.0) d=1.0;
421
            else if(d<0.0001) d=0.0001;
422
            q*= pow(d, 1.0/s->avctx->rc_buffer_aggressivity);
423

    
424
            q_limit= bits2qp(rce, FFMAX((min_rate - buffer_size + rcc->buffer_index)*3, 1));
425
            if(q > q_limit){
426
                if(s->avctx->debug&FF_DEBUG_RC){
427
                    av_log(s->avctx, AV_LOG_DEBUG, "limiting QP %f -> %f\n", q, q_limit);
428
                }
429
                q= q_limit;
430
            }
431
        }
432

    
433
        if(max_rate){
434
            double d= 2*expected_size/buffer_size;
435
            if(d>1.0) d=1.0;
436
            else if(d<0.0001) d=0.0001;
437
            q/= pow(d, 1.0/s->avctx->rc_buffer_aggressivity);
438

    
439
            q_limit= bits2qp(rce, FFMAX(rcc->buffer_index/3, 1));
440
            if(q < q_limit){
441
                if(s->avctx->debug&FF_DEBUG_RC){
442
                    av_log(s->avctx, AV_LOG_DEBUG, "limiting QP %f -> %f\n", q, q_limit);
443
                }
444
                q= q_limit;
445
            }
446
        }
447
    }
448
//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);
449
    if(s->avctx->rc_qsquish==0.0 || qmin==qmax){
450
        if     (q<qmin) q=qmin;
451
        else if(q>qmax) q=qmax;
452
    }else{
453
        double min2= log(qmin);
454
        double max2= log(qmax);
455
        
456
        q= log(q);
457
        q= (q - min2)/(max2-min2) - 0.5;
458
        q*= -4.0;
459
        q= 1.0/(1.0 + exp(q));
460
        q= q*(max2-min2) + min2;
461
        
462
        q= exp(q);
463
    }
464
    
465
    return q;
466
}
467

    
468
//----------------------------------
469
// 1 Pass Code
470

    
471
static double predict_size(Predictor *p, double q, double var)
472
{
473
     return p->coeff*var / (q*p->count);
474
}
475

    
476
/*
477
static double predict_qp(Predictor *p, double size, double var)
478
{
479
//printf("coeff:%f, count:%f, var:%f, size:%f//\n", p->coeff, p->count, var, size);
480
     return p->coeff*var / (size*p->count);
481
}
482
*/
483

    
484
static void update_predictor(Predictor *p, double q, double var, double size)
485
{
486
    double new_coeff= size*q / (var + 1);
487
    if(var<10) return;
488

    
489
    p->count*= p->decay;
490
    p->coeff*= p->decay;
491
    p->count++;
492
    p->coeff+= new_coeff;
493
}
494

    
495
static void adaptive_quantization(MpegEncContext *s, double q){
496
    int i;
497
    const float lumi_masking= s->avctx->lumi_masking / (128.0*128.0);
498
    const float dark_masking= s->avctx->dark_masking / (128.0*128.0);
499
    const float temp_cplx_masking= s->avctx->temporal_cplx_masking;
500
    const float spatial_cplx_masking = s->avctx->spatial_cplx_masking;
501
    const float p_masking = s->avctx->p_masking;
502
    float bits_sum= 0.0;
503
    float cplx_sum= 0.0;
504
    float cplx_tab[s->mb_num];
505
    float bits_tab[s->mb_num];
506
    const int qmin= s->avctx->lmin;
507
    const int qmax= s->avctx->lmax;
508
    Picture * const pic= &s->current_picture;
509
    
510
    for(i=0; i<s->mb_num; i++){
511
        const int mb_xy= s->mb_index2xy[i];
512
        float temp_cplx= sqrt(pic->mc_mb_var[mb_xy]); //FIXME merge in pow()
513
        float spat_cplx= sqrt(pic->mb_var[mb_xy]);
514
        const int lumi= pic->mb_mean[mb_xy];
515
        float bits, cplx, factor;
516
#if 0        
517
        if(spat_cplx < q/3) spat_cplx= q/3; //FIXME finetune
518
        if(temp_cplx < q/3) temp_cplx= q/3; //FIXME finetune
519
#endif   
520
        if(spat_cplx < 4) spat_cplx= 4; //FIXME finetune
521
        if(temp_cplx < 4) temp_cplx= 4; //FIXME finetune
522

    
523
        if((s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTRA)){//FIXME hq mode 
524
            cplx= spat_cplx;
525
            factor= 1.0 + p_masking;
526
        }else{
527
            cplx= temp_cplx;
528
            factor= pow(temp_cplx, - temp_cplx_masking);
529
        }
530
        factor*=pow(spat_cplx, - spatial_cplx_masking);
531

    
532
        if(lumi>127)
533
            factor*= (1.0 - (lumi-128)*(lumi-128)*lumi_masking);
534
        else
535
            factor*= (1.0 - (lumi-128)*(lumi-128)*dark_masking);
536
        
537
        if(factor<0.00001) factor= 0.00001;
538
        
539
        bits= cplx*factor;
540
        cplx_sum+= cplx;
541
        bits_sum+= bits;
542
        cplx_tab[i]= cplx;
543
        bits_tab[i]= bits;
544
    }
545

    
546
    /* handle qmin/qmax cliping */
547
    if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
548
        for(i=0; i<s->mb_num; i++){
549
            float newq= q*cplx_tab[i]/bits_tab[i];
550
            newq*= bits_sum/cplx_sum;
551

    
552
            if     (newq > qmax){
553
                bits_sum -= bits_tab[i];
554
                cplx_sum -= cplx_tab[i]*q/qmax;
555
            }
556
            else if(newq < qmin){
557
                bits_sum -= bits_tab[i];
558
                cplx_sum -= cplx_tab[i]*q/qmin;
559
            }
560
        }
561
    }
562
   
563
    for(i=0; i<s->mb_num; i++){
564
        const int mb_xy= s->mb_index2xy[i];
565
        float newq= q*cplx_tab[i]/bits_tab[i];
566
        int intq;
567

    
568
        if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
569
            newq*= bits_sum/cplx_sum;
570
        }
571

    
572
        intq= (int)(newq + 0.5);
573

    
574
        if     (intq > qmax) intq= qmax;
575
        else if(intq < qmin) intq= qmin;
576
//if(i%s->mb_width==0) printf("\n");
577
//printf("%2d%3d ", intq, ff_sqrt(s->mc_mb_var[i]));
578
        s->lambda_table[mb_xy]= intq;
579
    }
580
}
581
//FIXME rd or at least approx for dquant
582

    
583
float ff_rate_estimate_qscale(MpegEncContext *s)
584
{
585
    float q;
586
    int qmin, qmax;
587
    float br_compensation;
588
    double diff;
589
    double short_term_q;
590
    double fps;
591
    int picture_number= s->picture_number;
592
    int64_t wanted_bits;
593
    RateControlContext *rcc= &s->rc_context;
594
    AVCodecContext *a= s->avctx;
595
    RateControlEntry local_rce, *rce;
596
    double bits;
597
    double rate_factor;
598
    int var;
599
    const int pict_type= s->pict_type;
600
    Picture * const pic= &s->current_picture;
601
    emms_c();
602

    
603
    get_qminmax(&qmin, &qmax, s, pict_type);
604

    
605
    fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base;
606
//printf("input_pic_num:%d pic_num:%d frame_rate:%d\n", s->input_picture_number, s->picture_number, s->frame_rate);
607
        /* update predictors */
608
    if(picture_number>2){
609
        const int last_var= s->last_pict_type == I_TYPE ? rcc->last_mb_var_sum : rcc->last_mc_mb_var_sum;
610
        update_predictor(&rcc->pred[s->last_pict_type], rcc->last_qscale, sqrt(last_var), s->frame_bits);
611
    }
612

    
613
    if(s->flags&CODEC_FLAG_PASS2){
614
        assert(picture_number>=0);
615
        assert(picture_number<rcc->num_entries);
616
        rce= &rcc->entry[picture_number];
617
        wanted_bits= rce->expected_bits;
618
    }else{
619
        rce= &local_rce;
620
        wanted_bits= (uint64_t)(s->bit_rate*(double)picture_number/fps);
621
    }
622

    
623
    diff= s->total_bits - wanted_bits;
624
    br_compensation= (a->bit_rate_tolerance - diff)/a->bit_rate_tolerance;
625
    if(br_compensation<=0.0) br_compensation=0.001;
626

    
627
    var= pict_type == I_TYPE ? pic->mb_var_sum : pic->mc_mb_var_sum;
628
    
629
    short_term_q = 0; /* avoid warning */
630
    if(s->flags&CODEC_FLAG_PASS2){
631
        if(pict_type!=I_TYPE)
632
            assert(pict_type == rce->new_pict_type);
633

    
634
        q= rce->new_qscale / br_compensation;
635
//printf("%f %f %f last:%d var:%d type:%d//\n", q, rce->new_qscale, br_compensation, s->frame_bits, var, pict_type);
636
    }else{
637
        rce->pict_type= 
638
        rce->new_pict_type= pict_type;
639
        rce->mc_mb_var_sum= pic->mc_mb_var_sum;
640
        rce->mb_var_sum   = pic->   mb_var_sum;
641
        rce->qscale   = FF_QP2LAMBDA * 2;
642
        rce->f_code   = s->f_code;
643
        rce->b_code   = s->b_code;
644
        rce->misc_bits= 1;
645

    
646
        bits= predict_size(&rcc->pred[pict_type], rce->qscale, sqrt(var));
647
        if(pict_type== I_TYPE){
648
            rce->i_count   = s->mb_num;
649
            rce->i_tex_bits= bits;
650
            rce->p_tex_bits= 0;
651
            rce->mv_bits= 0;
652
        }else{
653
            rce->i_count   = 0; //FIXME we do know this approx
654
            rce->i_tex_bits= 0;
655
            rce->p_tex_bits= bits*0.9;
656
            
657
            rce->mv_bits= bits*0.1;
658
        }
659
        rcc->i_cplx_sum [pict_type] += rce->i_tex_bits*rce->qscale;
660
        rcc->p_cplx_sum [pict_type] += rce->p_tex_bits*rce->qscale;
661
        rcc->mv_bits_sum[pict_type] += rce->mv_bits;
662
        rcc->frame_count[pict_type] ++;
663

    
664
        bits= rce->i_tex_bits + rce->p_tex_bits;
665
        rate_factor= rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum * br_compensation;
666
    
667
        q= get_qscale(s, rce, rate_factor, picture_number);
668

    
669
        assert(q>0.0);
670
//printf("%f ", q);
671
        q= get_diff_limited_q(s, rce, q);
672
//printf("%f ", q);
673
        assert(q>0.0);
674

    
675
        if(pict_type==P_TYPE || s->intra_only){ //FIXME type dependant blur like in 2-pass
676
            rcc->short_term_qsum*=a->qblur;
677
            rcc->short_term_qcount*=a->qblur;
678

    
679
            rcc->short_term_qsum+= q;
680
            rcc->short_term_qcount++;
681
//printf("%f ", q);
682
            q= short_term_q= rcc->short_term_qsum/rcc->short_term_qcount;
683
//printf("%f ", q);
684
        }
685
        assert(q>0.0);
686
        
687
        q= modify_qscale(s, rce, q, picture_number);
688

    
689
        rcc->pass1_wanted_bits+= s->bit_rate/fps;
690

    
691
        assert(q>0.0);
692
    }
693

    
694
    if(s->avctx->debug&FF_DEBUG_RC){
695
        av_log(s->avctx, AV_LOG_DEBUG, "%c qp:%d<%2.1f<%d %d want:%d total:%d comp:%f st_q:%2.2f size:%d var:%d/%d br:%d fps:%d\n",
696
        av_get_pict_type_char(pict_type), qmin, q, qmax, picture_number, (int)wanted_bits/1000, (int)s->total_bits/1000,
697
        br_compensation, short_term_q, s->frame_bits, pic->mb_var_sum, pic->mc_mb_var_sum, s->bit_rate/1000, (int)fps
698
        );
699
    }
700

    
701
    if     (q<qmin) q=qmin; 
702
    else if(q>qmax) q=qmax;
703

    
704
    if(s->adaptive_quant)
705
        adaptive_quantization(s, q);
706
    else
707
        q= (int)(q + 0.5);
708
    
709
    rcc->last_qscale= q;
710
    rcc->last_mc_mb_var_sum= pic->mc_mb_var_sum;
711
    rcc->last_mb_var_sum= pic->mb_var_sum;
712
#if 0
713
{
714
    static int mvsum=0, texsum=0;
715
    mvsum += s->mv_bits;
716
    texsum += s->i_tex_bits + s->p_tex_bits;
717
    printf("%d %d//\n\n", mvsum, texsum);
718
}
719
#endif
720
    return q;
721
}
722

    
723
//----------------------------------------------
724
// 2-Pass code
725

    
726
static int init_pass2(MpegEncContext *s)
727
{
728
    RateControlContext *rcc= &s->rc_context;
729
    AVCodecContext *a= s->avctx;
730
    int i;
731
    double fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base;
732
    double complexity[5]={0,0,0,0,0};   // aproximate bits at quant=1
733
    double avg_quantizer[5];
734
    uint64_t const_bits[5]={0,0,0,0,0}; // quantizer idependant bits
735
    uint64_t available_bits[5];
736
    uint64_t all_const_bits;
737
    uint64_t all_available_bits= (uint64_t)(s->bit_rate*(double)rcc->num_entries/fps);
738
    double rate_factor=0;
739
    double step;
740
    //int last_i_frame=-10000000;
741
    const int filter_size= (int)(a->qblur*4) | 1;  
742
    double expected_bits;
743
    double *qscale, *blured_qscale;
744

    
745
    /* find complexity & const_bits & decide the pict_types */
746
    for(i=0; i<rcc->num_entries; i++){
747
        RateControlEntry *rce= &rcc->entry[i];
748
        
749
        rce->new_pict_type= rce->pict_type;
750
        rcc->i_cplx_sum [rce->pict_type] += rce->i_tex_bits*rce->qscale;
751
        rcc->p_cplx_sum [rce->pict_type] += rce->p_tex_bits*rce->qscale;
752
        rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits;
753
        rcc->frame_count[rce->pict_type] ++;
754

    
755
        complexity[rce->new_pict_type]+= (rce->i_tex_bits+ rce->p_tex_bits)*(double)rce->qscale;
756
        const_bits[rce->new_pict_type]+= rce->mv_bits + rce->misc_bits;
757
    }
758
    all_const_bits= const_bits[I_TYPE] + const_bits[P_TYPE] + const_bits[B_TYPE];
759
    
760
    if(all_available_bits < all_const_bits){
761
        av_log(s->avctx, AV_LOG_ERROR, "requested bitrate is to low\n");
762
        return -1;
763
    }
764
    
765
    /* find average quantizers */
766
    avg_quantizer[P_TYPE]=0;
767
    for(step=256*256; step>0.0000001; step*=0.5){
768
        double expected_bits=0;
769
        avg_quantizer[P_TYPE]+= step;
770
        
771
        avg_quantizer[I_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->i_quant_factor) + s->avctx->i_quant_offset;
772
        avg_quantizer[B_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
773
        
774
        expected_bits= 
775
            + all_const_bits 
776
            + complexity[I_TYPE]/avg_quantizer[I_TYPE]
777
            + complexity[P_TYPE]/avg_quantizer[P_TYPE]
778
            + complexity[B_TYPE]/avg_quantizer[B_TYPE];
779
            
780
        if(expected_bits < all_available_bits) avg_quantizer[P_TYPE]-= step;
781
//printf("%f %lld %f\n", expected_bits, all_available_bits, avg_quantizer[P_TYPE]);
782
    }
783
//printf("qp_i:%f, qp_p:%f, qp_b:%f\n", avg_quantizer[I_TYPE],avg_quantizer[P_TYPE],avg_quantizer[B_TYPE]);
784

    
785
    for(i=0; i<5; i++){
786
        available_bits[i]= const_bits[i] + complexity[i]/avg_quantizer[i];
787
    }
788
//printf("%lld %lld %lld %lld\n", available_bits[I_TYPE], available_bits[P_TYPE], available_bits[B_TYPE], all_available_bits);
789
        
790
    qscale= av_malloc(sizeof(double)*rcc->num_entries);
791
    blured_qscale= av_malloc(sizeof(double)*rcc->num_entries);
792

    
793
    for(step=256*256; step>0.0000001; step*=0.5){
794
        expected_bits=0;
795
        rate_factor+= step;
796
        
797
        rcc->buffer_index= s->avctx->rc_buffer_size/2;
798

    
799
        /* find qscale */
800
        for(i=0; i<rcc->num_entries; i++){
801
            qscale[i]= get_qscale(s, &rcc->entry[i], rate_factor, i);
802
        }
803
        assert(filter_size%2==1);
804

    
805
        /* fixed I/B QP relative to P mode */
806
        for(i=rcc->num_entries-1; i>=0; i--){
807
            RateControlEntry *rce= &rcc->entry[i];
808
            
809
            qscale[i]= get_diff_limited_q(s, rce, qscale[i]);
810
        }
811

    
812
        /* smooth curve */
813
        for(i=0; i<rcc->num_entries; i++){
814
            RateControlEntry *rce= &rcc->entry[i];
815
            const int pict_type= rce->new_pict_type;
816
            int j;
817
            double q=0.0, sum=0.0;
818
        
819
            for(j=0; j<filter_size; j++){
820
                int index= i+j-filter_size/2;
821
                double d= index-i;
822
                double coeff= a->qblur==0 ? 1.0 : exp(-d*d/(a->qblur * a->qblur));
823
            
824
                if(index < 0 || index >= rcc->num_entries) continue;
825
                if(pict_type != rcc->entry[index].new_pict_type) continue;
826
                q+= qscale[index] * coeff;
827
                sum+= coeff;
828
            }
829
            blured_qscale[i]= q/sum;
830
        }
831
    
832
        /* find expected bits */
833
        for(i=0; i<rcc->num_entries; i++){
834
            RateControlEntry *rce= &rcc->entry[i];
835
            double bits;
836
            rce->new_qscale= modify_qscale(s, rce, blured_qscale[i], i);
837
            bits= qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;
838
//printf("%d %f\n", rce->new_bits, blured_qscale[i]);
839
            bits += 8*ff_vbv_update(s, bits);
840

    
841
            rce->expected_bits= expected_bits;
842
            expected_bits += bits;
843
        }
844

    
845
//        printf("%f %d %f\n", expected_bits, (int)all_available_bits, rate_factor);
846
        if(expected_bits > all_available_bits) rate_factor-= step;
847
    }
848
    av_free(qscale);
849
    av_free(blured_qscale);
850

    
851
    if(abs(expected_bits/all_available_bits - 1.0) > 0.01 ){
852
        av_log(s->avctx, AV_LOG_ERROR, "Error: 2pass curve failed to converge\n");
853
        return -1;
854
    }
855

    
856
    return 0;
857
}