Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ratecontrol.c @ 08f7073a

History | View | Annotate | Download (28.7 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
        float factor= bits_sum/cplx_sum;
549
        for(i=0; i<s->mb_num; i++){
550
            float newq= q*cplx_tab[i]/bits_tab[i];
551
            newq*= factor;
552

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

    
571
        if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
572
            newq*= bits_sum/cplx_sum;
573
        }
574

    
575
        intq= (int)(newq + 0.5);
576

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

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

    
606
    get_qminmax(&qmin, &qmax, s, pict_type);
607

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

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

    
626
    diff= s->total_bits - wanted_bits;
627
    br_compensation= (a->bit_rate_tolerance - diff)/a->bit_rate_tolerance;
628
    if(br_compensation<=0.0) br_compensation=0.001;
629

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

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

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

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

    
672
        assert(q>0.0);
673
//printf("%f ", q);
674
        q= get_diff_limited_q(s, rce, q);
675
//printf("%f ", q);
676
        assert(q>0.0);
677

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

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

    
692
        rcc->pass1_wanted_bits+= s->bit_rate/fps;
693

    
694
        assert(q>0.0);
695
    }
696

    
697
    if(s->avctx->debug&FF_DEBUG_RC){
698
        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",
699
        av_get_pict_type_char(pict_type), qmin, q, qmax, picture_number, (int)wanted_bits/1000, (int)s->total_bits/1000,
700
        br_compensation, short_term_q, s->frame_bits, pic->mb_var_sum, pic->mc_mb_var_sum, s->bit_rate/1000, (int)fps
701
        );
702
    }
703

    
704
    if     (q<qmin) q=qmin; 
705
    else if(q>qmax) q=qmax;
706

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

    
726
//----------------------------------------------
727
// 2-Pass code
728

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

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

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

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

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

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

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

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

    
844
            rce->expected_bits= expected_bits;
845
            expected_bits += bits;
846
        }
847

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

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

    
859
    return 0;
860
}