Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ratecontrol.c @ 8dbcc9f2

History | View | Annotate | Download (27.7 KB)

1 8b4c7dbc Michael Niedermayer
/*
2 2ef0f2b2 Fabrice Bellard
 * 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 983e3246 Michael Niedermayer
21
/**
22
 * @file ratecontrol.c
23
 * Rate control for video encoders.
24
 */ 
25
26 8b4c7dbc Michael Niedermayer
#include "avcodec.h"
27 2ef0f2b2 Fabrice Bellard
#include "dsputil.h"
28 8b4c7dbc Michael Niedermayer
#include "mpegvideo.h"
29
30 3aa102be Michael Niedermayer
#undef NDEBUG // allways check asserts, the speed effect is far too small to disable them
31
#include <assert.h>
32 8b4c7dbc Michael Niedermayer
33 471d7dc3 Michael Niedermayer
#ifndef M_E
34
#define M_E 2.718281828
35
#endif
36
37 8b4c7dbc Michael Niedermayer
static int init_pass2(MpegEncContext *s);
38 3aa102be Michael Niedermayer
static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_factor, int frame_num);
39 8b4c7dbc Michael Niedermayer
40
void ff_write_pass1_stats(MpegEncContext *s){
41 158c7f05 Michael Niedermayer
    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 8b4c7dbc Michael Niedermayer
            s->picture_number, s->input_picture_number - s->max_b_frames, s->pict_type, 
43 158c7f05 Michael Niedermayer
            s->current_picture.quality, s->i_tex_bits, s->p_tex_bits, s->mv_bits, s->misc_bits, 
44 1e491e29 Michael Niedermayer
            s->f_code, s->b_code, s->current_picture.mc_mb_var_sum, s->current_picture.mb_var_sum, s->i_count);
45 8b4c7dbc Michael Niedermayer
}
46
47
int ff_rate_control_init(MpegEncContext *s)
48
{
49
    RateControlContext *rcc= &s->rc_context;
50 3aa102be Michael Niedermayer
    int i;
51 8b4c7dbc Michael Niedermayer
    emms_c();
52
53 3aa102be Michael Niedermayer
    for(i=0; i<5; i++){
54 158c7f05 Michael Niedermayer
        rcc->pred[i].coeff= FF_QP2LAMBDA * 7.0;
55 3aa102be Michael Niedermayer
        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 158c7f05 Michael Niedermayer
        rcc->last_qscale_for[i]=FF_QP2LAMBDA * 5;
64 3aa102be Michael Niedermayer
    }
65
    rcc->buffer_index= s->avctx->rc_buffer_size/2;
66
67
    if(s->flags&CODEC_FLAG_PASS2){
68 8b4c7dbc Michael Niedermayer
        int i;
69 3aa102be Michael Niedermayer
        char *p;
70 8b4c7dbc Michael Niedermayer
71 3aa102be Michael Niedermayer
        /* find number of pics */
72
        p= s->avctx->stats_in;
73
        for(i=-1; p; i++){
74
            p= strchr(p+1, ';');
75 8b4c7dbc Michael Niedermayer
        }
76 3aa102be Michael Niedermayer
        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 158c7f05 Michael Niedermayer
            rce->qscale= rce->new_qscale=FF_QP2LAMBDA * 2;
85 3aa102be Michael Niedermayer
            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 8b4c7dbc Michael Niedermayer
            RateControlEntry *rce;
93
            int picture_number;
94
            int e;
95 3aa102be Michael Niedermayer
            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 8b4c7dbc Michael Niedermayer
            rce= &rcc->entry[picture_number];
107 3aa102be Michael Niedermayer
108 c5d309f2 Michael Niedermayer
            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 3aa102be Michael Niedermayer
                   &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 9b879566 Michel Bardiaux
                av_log(s->avctx, AV_LOG_ERROR, "statistics are damaged at line %d, parser out=%d\n", i, e);
113 8b4c7dbc Michael Niedermayer
                return -1;
114
            }
115 3aa102be Michael Niedermayer
            p= next;
116 8b4c7dbc Michael Niedermayer
        }
117
        
118
        if(init_pass2(s) < 0) return -1;
119
    }
120
     
121 3aa102be Michael Niedermayer
    if(!(s->flags&CODEC_FLAG_PASS2)){
122
123
        rcc->short_term_qsum=0.001;
124
        rcc->short_term_qcount=0.001;
125 8b4c7dbc Michael Niedermayer
    
126 23e54f69 Michael Niedermayer
        rcc->pass1_rc_eq_output_sum= 0.001;
127 3aa102be Michael Niedermayer
        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 158c7f05 Michael Niedermayer
                rce.qscale   = FF_QP2LAMBDA * 2;
144 3aa102be Michael Niedermayer
                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 8b4c7dbc Michael Niedermayer
164 3aa102be Michael Niedermayer
                bits= rce.i_tex_bits + rce.p_tex_bits;
165 8b4c7dbc Michael Niedermayer
166 23e54f69 Michael Niedermayer
                q= get_qscale(s, &rce, rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum, i);
167 14bea432 Michael Niedermayer
                rcc->pass1_wanted_bits+= s->bit_rate/(s->avctx->frame_rate / (double)s->avctx->frame_rate_base);
168 3aa102be Michael Niedermayer
            }
169
        }
170
171
    }
172
    
173 8b4c7dbc Michael Niedermayer
    return 0;
174
}
175
176
void ff_rate_control_uninit(MpegEncContext *s)
177
{
178
    RateControlContext *rcc= &s->rc_context;
179
    emms_c();
180
181 6000abfa Fabrice Bellard
    av_freep(&rcc->entry);
182 8b4c7dbc Michael Niedermayer
}
183
184 3aa102be Michael Niedermayer
static inline double qp2bits(RateControlEntry *rce, double qp){
185
    if(qp<=0.0){
186 9b879566 Michel Bardiaux
        av_log(NULL, AV_LOG_ERROR, "qp<=0.0\n");
187 3aa102be Michael Niedermayer
    }
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 9b879566 Michel Bardiaux
        av_log(NULL, AV_LOG_ERROR, "bits<0.9\n");
194 3aa102be Michael Niedermayer
    }
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 14bea432 Michael Niedermayer
    const double fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base;
201 3aa102be Michael Niedermayer
    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 9b879566 Michel Bardiaux
            av_log(s->avctx, AV_LOG_ERROR, "rc buffer underflow\n");
217 3aa102be Michael Niedermayer
        if(rcc->buffer_index >= s->avctx->rc_buffer_size)
218 9b879566 Michel Bardiaux
            av_log(s->avctx, AV_LOG_ERROR, "rc buffer overflow\n");
219 3aa102be Michael Niedermayer
    }
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 5c91a675 Zdenek Kabelac
    static const char *const_names[]={
260 3aa102be Michael Niedermayer
        "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 07787186 Dominik Mierzejewski
    static double (*func1[])(void *, double)={
287 ec6a3752 Fabrice Bellard
        (void *)bits2qp,
288
        (void *)qp2bits,
289 3aa102be Michael Niedermayer
        NULL
290
    };
291 5c91a675 Zdenek Kabelac
    static const char *func1_names[]={
292 3aa102be Michael Niedermayer
        "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 23e54f69 Michael Niedermayer
    rcc->pass1_rc_eq_output_sum+= bits;
300 3aa102be Michael Niedermayer
    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 6a1f7e7b Michael Niedermayer
        
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 59b571c1 Michael Niedermayer
    
334 6a1f7e7b Michael Niedermayer
    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 3aa102be Michael Niedermayer
    /* last qscale / qdiff stuff */
340 6a1f7e7b Michael Niedermayer
    if(rcc->last_non_b_pict_type==pict_type || pict_type!=I_TYPE){
341
        double last_q= rcc->last_qscale_for[pict_type];
342 158c7f05 Michael Niedermayer
        const int maxdiff= FF_QP2LAMBDA * a->max_qdiff;
343 59b571c1 Michael Niedermayer
344 158c7f05 Michael Niedermayer
        if     (q > last_q + maxdiff) q= last_q + maxdiff;
345
        else if(q < last_q - maxdiff) q= last_q - maxdiff;
346 6a1f7e7b Michael Niedermayer
    }
347 3aa102be Michael Niedermayer
348
    rcc->last_qscale_for[pict_type]= q; //Note we cant do that after blurring
349
    
350 6a1f7e7b Michael Niedermayer
    if(pict_type!=B_TYPE)
351
        rcc->last_non_b_pict_type= pict_type;
352
353 3aa102be Michael Niedermayer
    return q;
354
}
355
356
/**
357
 * gets the qmin & qmax for pict_type
358
 */
359
static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type){
360 158c7f05 Michael Niedermayer
    int qmin= s->avctx->lmin;                                                       
361
    int qmax= s->avctx->lmax;
362 fa12b546 Michael Niedermayer
    
363
    assert(qmin <= qmax);
364 3aa102be Michael Niedermayer
365
    if(pict_type==B_TYPE){
366
        qmin= (int)(qmin*ABS(s->avctx->b_quant_factor)+s->avctx->b_quant_offset + 0.5);
367
        qmax= (int)(qmax*ABS(s->avctx->b_quant_factor)+s->avctx->b_quant_offset + 0.5);
368
    }else if(pict_type==I_TYPE){
369
        qmin= (int)(qmin*ABS(s->avctx->i_quant_factor)+s->avctx->i_quant_offset + 0.5);
370
        qmax= (int)(qmax*ABS(s->avctx->i_quant_factor)+s->avctx->i_quant_offset + 0.5);
371
    }
372
373 158c7f05 Michael Niedermayer
    qmin= clip(qmin, 1, FF_LAMBDA_MAX);
374
    qmax= clip(qmax, 1, FF_LAMBDA_MAX);
375 3aa102be Michael Niedermayer
376 fa12b546 Michael Niedermayer
    if(qmax<qmin) qmax= qmin;
377 3aa102be Michael Niedermayer
    
378
    *qmin_ret= qmin;
379
    *qmax_ret= qmax;
380
}
381
382
static double modify_qscale(MpegEncContext *s, RateControlEntry *rce, double q, int frame_num){
383
    RateControlContext *rcc= &s->rc_context;
384
    int qmin, qmax;
385
    double bits;
386
    const int pict_type= rce->new_pict_type;
387
    const double buffer_size= s->avctx->rc_buffer_size;
388
    const double min_rate= s->avctx->rc_min_rate;
389
    const double max_rate= s->avctx->rc_max_rate;
390
    
391
    get_qminmax(&qmin, &qmax, s, pict_type);
392
393
    /* modulation */
394
    if(s->avctx->rc_qmod_freq && frame_num%s->avctx->rc_qmod_freq==0 && pict_type==P_TYPE)
395
        q*= s->avctx->rc_qmod_amp;
396
397
    bits= qp2bits(rce, q);
398 946c8a12 Michael Niedermayer
//printf("q:%f\n", q);
399 3aa102be Michael Niedermayer
    /* buffer overflow/underflow protection */
400
    if(buffer_size){
401 6a1f7e7b Michael Niedermayer
        double expected_size= rcc->buffer_index;
402 3aa102be Michael Niedermayer
403
        if(min_rate){
404 6a1f7e7b Michael Niedermayer
            double d= 2*(buffer_size - expected_size)/buffer_size;
405 3aa102be Michael Niedermayer
            if(d>1.0) d=1.0;
406 946c8a12 Michael Niedermayer
            else if(d<0.0001) d=0.0001;
407
            q*= pow(d, 1.0/s->avctx->rc_buffer_aggressivity);
408 6a1f7e7b Michael Niedermayer
409 b8a78f41 Michael Niedermayer
            q= FFMIN(q, bits2qp(rce, FFMAX((min_rate - buffer_size + rcc->buffer_index)*2, 1)));
410 3aa102be Michael Niedermayer
        }
411
412
        if(max_rate){
413
            double d= 2*expected_size/buffer_size;
414
            if(d>1.0) d=1.0;
415 946c8a12 Michael Niedermayer
            else if(d<0.0001) d=0.0001;
416
            q/= pow(d, 1.0/s->avctx->rc_buffer_aggressivity);
417 6a1f7e7b Michael Niedermayer
418 b8a78f41 Michael Niedermayer
            q= FFMAX(q, bits2qp(rce, FFMAX(rcc->buffer_index/2, 1)));
419 3aa102be Michael Niedermayer
        }
420
    }
421 946c8a12 Michael Niedermayer
//printf("q:%f max:%f min:%f size:%f index:%d bits:%f agr:%f\n", q,max_rate, min_rate, buffer_size, rcc->buffer_index, bits, s->avctx->rc_buffer_aggressivity);
422 c695ca3b Michael Niedermayer
    if(s->avctx->rc_qsquish==0.0 || qmin==qmax){
423 3aa102be Michael Niedermayer
        if     (q<qmin) q=qmin;
424
        else if(q>qmax) q=qmax;
425
    }else{
426
        double min2= log(qmin);
427
        double max2= log(qmax);
428
        
429
        q= log(q);
430
        q= (q - min2)/(max2-min2) - 0.5;
431
        q*= -4.0;
432
        q= 1.0/(1.0 + exp(q));
433
        q= q*(max2-min2) + min2;
434
        
435
        q= exp(q);
436
    }
437 c5d309f2 Michael Niedermayer
    
438 3aa102be Michael Niedermayer
    return q;
439
}
440
441 8b4c7dbc Michael Niedermayer
//----------------------------------
442
// 1 Pass Code
443
444 3aa102be Michael Niedermayer
static double predict_size(Predictor *p, double q, double var)
445 8b4c7dbc Michael Niedermayer
{
446
     return p->coeff*var / (q*p->count);
447
}
448
449 ccfddafb bubu
/*
450 3aa102be Michael Niedermayer
static double predict_qp(Predictor *p, double size, double var)
451
{
452
//printf("coeff:%f, count:%f, var:%f, size:%f//\n", p->coeff, p->count, var, size);
453
     return p->coeff*var / (size*p->count);
454
}
455 ccfddafb bubu
*/
456 3aa102be Michael Niedermayer
457 8b4c7dbc Michael Niedermayer
static void update_predictor(Predictor *p, double q, double var, double size)
458
{
459
    double new_coeff= size*q / (var + 1);
460 3aa102be Michael Niedermayer
    if(var<10) return;
461 8b4c7dbc Michael Niedermayer
462
    p->count*= p->decay;
463
    p->coeff*= p->decay;
464
    p->count++;
465
    p->coeff+= new_coeff;
466
}
467
468 c5d309f2 Michael Niedermayer
static void adaptive_quantization(MpegEncContext *s, double q){
469
    int i;
470
    const float lumi_masking= s->avctx->lumi_masking / (128.0*128.0);
471 5e746b99 Michael Niedermayer
    const float dark_masking= s->avctx->dark_masking / (128.0*128.0);
472 c5d309f2 Michael Niedermayer
    const float temp_cplx_masking= s->avctx->temporal_cplx_masking;
473
    const float spatial_cplx_masking = s->avctx->spatial_cplx_masking;
474
    const float p_masking = s->avctx->p_masking;
475
    float bits_sum= 0.0;
476
    float cplx_sum= 0.0;
477
    float cplx_tab[s->mb_num];
478
    float bits_tab[s->mb_num];
479 158c7f05 Michael Niedermayer
    const int qmin= s->avctx->lmin;
480
    const int qmax= s->avctx->lmax;
481 1e491e29 Michael Niedermayer
    Picture * const pic= &s->current_picture;
482 c5d309f2 Michael Niedermayer
    
483
    for(i=0; i<s->mb_num; i++){
484 2f5feea4 Michael Niedermayer
        const int mb_xy= s->mb_index2xy[i];
485 158c7f05 Michael Niedermayer
        float temp_cplx= sqrt(pic->mc_mb_var[mb_xy]); //FIXME merge in pow()
486 2f5feea4 Michael Niedermayer
        float spat_cplx= sqrt(pic->mb_var[mb_xy]);
487
        const int lumi= pic->mb_mean[mb_xy];
488 c5d309f2 Michael Niedermayer
        float bits, cplx, factor;
489 158c7f05 Michael Niedermayer
#if 0        
490 c5d309f2 Michael Niedermayer
        if(spat_cplx < q/3) spat_cplx= q/3; //FIXME finetune
491
        if(temp_cplx < q/3) temp_cplx= q/3; //FIXME finetune
492 158c7f05 Michael Niedermayer
#endif   
493
        if(spat_cplx < 4) spat_cplx= 4; //FIXME finetune
494
        if(temp_cplx < 4) temp_cplx= 4; //FIXME finetune
495
496 2f5feea4 Michael Niedermayer
        if((s->mb_type[mb_xy]&MB_TYPE_INTRA)){//FIXME hq mode 
497 c5d309f2 Michael Niedermayer
            cplx= spat_cplx;
498
            factor= 1.0 + p_masking;
499
        }else{
500
            cplx= temp_cplx;
501
            factor= pow(temp_cplx, - temp_cplx_masking);
502
        }
503
        factor*=pow(spat_cplx, - spatial_cplx_masking);
504 5e746b99 Michael Niedermayer
505
        if(lumi>127)
506
            factor*= (1.0 - (lumi-128)*(lumi-128)*lumi_masking);
507
        else
508
            factor*= (1.0 - (lumi-128)*(lumi-128)*dark_masking);
509 c5d309f2 Michael Niedermayer
        
510
        if(factor<0.00001) factor= 0.00001;
511
        
512
        bits= cplx*factor;
513
        cplx_sum+= cplx;
514
        bits_sum+= bits;
515
        cplx_tab[i]= cplx;
516
        bits_tab[i]= bits;
517
    }
518
519
    /* handle qmin/qmax cliping */
520
    if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
521
        for(i=0; i<s->mb_num; i++){
522
            float newq= q*cplx_tab[i]/bits_tab[i];
523
            newq*= bits_sum/cplx_sum;
524
525
            if     (newq > qmax){
526
                bits_sum -= bits_tab[i];
527
                cplx_sum -= cplx_tab[i]*q/qmax;
528
            }
529
            else if(newq < qmin){
530
                bits_sum -= bits_tab[i];
531
                cplx_sum -= cplx_tab[i]*q/qmin;
532
            }
533
        }
534
    }
535
   
536
    for(i=0; i<s->mb_num; i++){
537 2f5feea4 Michael Niedermayer
        const int mb_xy= s->mb_index2xy[i];
538 c5d309f2 Michael Niedermayer
        float newq= q*cplx_tab[i]/bits_tab[i];
539
        int intq;
540
541
        if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
542
            newq*= bits_sum/cplx_sum;
543
        }
544
545 158c7f05 Michael Niedermayer
        intq= (int)(newq + 0.5);
546 c5d309f2 Michael Niedermayer
547
        if     (intq > qmax) intq= qmax;
548
        else if(intq < qmin) intq= qmin;
549
//if(i%s->mb_width==0) printf("\n");
550
//printf("%2d%3d ", intq, ff_sqrt(s->mc_mb_var[i]));
551 158c7f05 Michael Niedermayer
        s->lambda_table[mb_xy]= intq;
552 c5d309f2 Michael Niedermayer
    }
553
}
554 158c7f05 Michael Niedermayer
//FIXME rd or at least approx for dquant
555 c5d309f2 Michael Niedermayer
556
float ff_rate_estimate_qscale(MpegEncContext *s)
557 8b4c7dbc Michael Niedermayer
{
558
    float q;
559 c5d309f2 Michael Niedermayer
    int qmin, qmax;
560 8b4c7dbc Michael Niedermayer
    float br_compensation;
561
    double diff;
562
    double short_term_q;
563
    double fps;
564 3aa102be Michael Niedermayer
    int picture_number= s->picture_number;
565 8b4c7dbc Michael Niedermayer
    int64_t wanted_bits;
566 3aa102be Michael Niedermayer
    RateControlContext *rcc= &s->rc_context;
567
    RateControlEntry local_rce, *rce;
568
    double bits;
569
    double rate_factor;
570
    int var;
571
    const int pict_type= s->pict_type;
572 1e491e29 Michael Niedermayer
    Picture * const pic= &s->current_picture;
573 8b4c7dbc Michael Niedermayer
    emms_c();
574
575 3aa102be Michael Niedermayer
    get_qminmax(&qmin, &qmax, s, pict_type);
576 8b4c7dbc Michael Niedermayer
577 14bea432 Michael Niedermayer
    fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base;
578 946c8a12 Michael Niedermayer
//printf("input_pic_num:%d pic_num:%d frame_rate:%d\n", s->input_picture_number, s->picture_number, s->frame_rate);
579 8b4c7dbc Michael Niedermayer
        /* update predictors */
580
    if(picture_number>2){
581 3aa102be Michael Niedermayer
        const int last_var= s->last_pict_type == I_TYPE ? rcc->last_mb_var_sum : rcc->last_mc_mb_var_sum;
582
        update_predictor(&rcc->pred[s->last_pict_type], rcc->last_qscale, sqrt(last_var), s->frame_bits);
583 8b4c7dbc Michael Niedermayer
    }
584
585 3aa102be Michael Niedermayer
    if(s->flags&CODEC_FLAG_PASS2){
586
        assert(picture_number>=0);
587
        assert(picture_number<rcc->num_entries);
588
        rce= &rcc->entry[picture_number];
589
        wanted_bits= rce->expected_bits;
590
    }else{
591
        rce= &local_rce;
592
        wanted_bits= (uint64_t)(s->bit_rate*(double)picture_number/fps);
593
    }
594 8b4c7dbc Michael Niedermayer
595 3aa102be Michael Niedermayer
    diff= s->total_bits - wanted_bits;
596
    br_compensation= (s->bit_rate_tolerance - diff)/s->bit_rate_tolerance;
597
    if(br_compensation<=0.0) br_compensation=0.001;
598
599 1e491e29 Michael Niedermayer
    var= pict_type == I_TYPE ? pic->mb_var_sum : pic->mc_mb_var_sum;
600 3aa102be Michael Niedermayer
    
601 b1609412 Fabrice Bellard
    short_term_q = 0; /* avoid warning */
602 3aa102be Michael Niedermayer
    if(s->flags&CODEC_FLAG_PASS2){
603
        if(pict_type!=I_TYPE)
604
            assert(pict_type == rce->new_pict_type);
605
606
        q= rce->new_qscale / br_compensation;
607
//printf("%f %f %f last:%d var:%d type:%d//\n", q, rce->new_qscale, br_compensation, s->frame_bits, var, pict_type);
608
    }else{
609
        rce->pict_type= 
610
        rce->new_pict_type= pict_type;
611 1e491e29 Michael Niedermayer
        rce->mc_mb_var_sum= pic->mc_mb_var_sum;
612
        rce->mb_var_sum   = pic->   mb_var_sum;
613 158c7f05 Michael Niedermayer
        rce->qscale   = FF_QP2LAMBDA * 2;
614 3aa102be Michael Niedermayer
        rce->f_code   = s->f_code;
615
        rce->b_code   = s->b_code;
616
        rce->misc_bits= 1;
617
618
        if(picture_number>0)
619
            update_rc_buffer(s, s->frame_bits);
620
621
        bits= predict_size(&rcc->pred[pict_type], rce->qscale, sqrt(var));
622
        if(pict_type== I_TYPE){
623
            rce->i_count   = s->mb_num;
624
            rce->i_tex_bits= bits;
625
            rce->p_tex_bits= 0;
626
            rce->mv_bits= 0;
627
        }else{
628
            rce->i_count   = 0; //FIXME we do know this approx
629
            rce->i_tex_bits= 0;
630
            rce->p_tex_bits= bits*0.9;
631
            
632
            rce->mv_bits= bits*0.1;
633 8b4c7dbc Michael Niedermayer
        }
634 3aa102be Michael Niedermayer
        rcc->i_cplx_sum [pict_type] += rce->i_tex_bits*rce->qscale;
635
        rcc->p_cplx_sum [pict_type] += rce->p_tex_bits*rce->qscale;
636
        rcc->mv_bits_sum[pict_type] += rce->mv_bits;
637
        rcc->frame_count[pict_type] ++;
638 8b4c7dbc Michael Niedermayer
639 3aa102be Michael Niedermayer
        bits= rce->i_tex_bits + rce->p_tex_bits;
640 23e54f69 Michael Niedermayer
        rate_factor= rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum * br_compensation;
641 8b4c7dbc Michael Niedermayer
    
642 3aa102be Michael Niedermayer
        q= get_qscale(s, rce, rate_factor, picture_number);
643 8b4c7dbc Michael Niedermayer
644 c695ca3b Michael Niedermayer
        assert(q>0.0);
645 3aa102be Michael Niedermayer
//printf("%f ", q);
646 6a1f7e7b Michael Niedermayer
        q= get_diff_limited_q(s, rce, q);
647 3aa102be Michael Niedermayer
//printf("%f ", q);
648
        assert(q>0.0);
649
650
        if(pict_type==P_TYPE || s->intra_only){ //FIXME type dependant blur like in 2-pass
651
            rcc->short_term_qsum*=s->qblur;
652
            rcc->short_term_qcount*=s->qblur;
653
654
            rcc->short_term_qsum+= q;
655
            rcc->short_term_qcount++;
656
//printf("%f ", q);
657
            q= short_term_q= rcc->short_term_qsum/rcc->short_term_qcount;
658
//printf("%f ", q);
659
        }
660 946c8a12 Michael Niedermayer
        assert(q>0.0);
661
        
662 3aa102be Michael Niedermayer
        q= modify_qscale(s, rce, q, picture_number);
663
664
        rcc->pass1_wanted_bits+= s->bit_rate/fps;
665
666 c695ca3b Michael Niedermayer
        assert(q>0.0);
667 8b4c7dbc Michael Niedermayer
    }
668 59b571c1 Michael Niedermayer
669
    if(s->avctx->debug&FF_DEBUG_RC){
670 9b879566 Michel Bardiaux
        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",
671 d8085ea7 Michael Niedermayer
        av_get_pict_type_char(pict_type), qmin, q, qmax, picture_number, (int)wanted_bits/1000, (int)s->total_bits/1000,
672 59b571c1 Michael Niedermayer
        br_compensation, short_term_q, s->frame_bits, pic->mb_var_sum, pic->mc_mb_var_sum, s->bit_rate/1000, (int)fps
673
        );
674
    }
675 3aa102be Michael Niedermayer
676
    if     (q<qmin) q=qmin; 
677
    else if(q>qmax) q=qmax;
678
679 c5d309f2 Michael Niedermayer
    if(s->adaptive_quant)
680
        adaptive_quantization(s, q);
681
    else
682
        q= (int)(q + 0.5);
683
    
684
    rcc->last_qscale= q;
685 1e491e29 Michael Niedermayer
    rcc->last_mc_mb_var_sum= pic->mc_mb_var_sum;
686
    rcc->last_mb_var_sum= pic->mb_var_sum;
687
#if 0
688
{
689
    static int mvsum=0, texsum=0;
690
    mvsum += s->mv_bits;
691
    texsum += s->i_tex_bits + s->p_tex_bits;
692
    printf("%d %d//\n\n", mvsum, texsum);
693
}
694
#endif
695 c5d309f2 Michael Niedermayer
    return q;
696 8b4c7dbc Michael Niedermayer
}
697
698
//----------------------------------------------
699
// 2-Pass code
700
701
static int init_pass2(MpegEncContext *s)
702
{
703
    RateControlContext *rcc= &s->rc_context;
704
    int i;
705 14bea432 Michael Niedermayer
    double fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base;
706 8b4c7dbc Michael Niedermayer
    double complexity[5]={0,0,0,0,0};   // aproximate bits at quant=1
707
    double avg_quantizer[5];
708
    uint64_t const_bits[5]={0,0,0,0,0}; // quantizer idependant bits
709
    uint64_t available_bits[5];
710
    uint64_t all_const_bits;
711
    uint64_t all_available_bits= (uint64_t)(s->bit_rate*(double)rcc->num_entries/fps);
712
    double rate_factor=0;
713
    double step;
714 ccfddafb bubu
    //int last_i_frame=-10000000;
715 3aa102be Michael Niedermayer
    const int filter_size= (int)(s->qblur*4) | 1;  
716
    double expected_bits;
717
    double *qscale, *blured_qscale;
718 8b4c7dbc Michael Niedermayer
719
    /* find complexity & const_bits & decide the pict_types */
720
    for(i=0; i<rcc->num_entries; i++){
721
        RateControlEntry *rce= &rcc->entry[i];
722
        
723 0d1e9246 Michael Niedermayer
        rce->new_pict_type= rce->pict_type;
724 3aa102be Michael Niedermayer
        rcc->i_cplx_sum [rce->pict_type] += rce->i_tex_bits*rce->qscale;
725
        rcc->p_cplx_sum [rce->pict_type] += rce->p_tex_bits*rce->qscale;
726
        rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits;
727
        rcc->frame_count[rce->pict_type] ++;
728 8b4c7dbc Michael Niedermayer
729
        complexity[rce->new_pict_type]+= (rce->i_tex_bits+ rce->p_tex_bits)*(double)rce->qscale;
730
        const_bits[rce->new_pict_type]+= rce->mv_bits + rce->misc_bits;
731
    }
732
    all_const_bits= const_bits[I_TYPE] + const_bits[P_TYPE] + const_bits[B_TYPE];
733
    
734
    if(all_available_bits < all_const_bits){
735 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "requested bitrate is to low\n");
736 8b4c7dbc Michael Niedermayer
        return -1;
737
    }
738 3aa102be Michael Niedermayer
    
739
    /* find average quantizers */
740
    avg_quantizer[P_TYPE]=0;
741
    for(step=256*256; step>0.0000001; step*=0.5){
742
        double expected_bits=0;
743
        avg_quantizer[P_TYPE]+= step;
744
        
745
        avg_quantizer[I_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->i_quant_factor) + s->avctx->i_quant_offset;
746
        avg_quantizer[B_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
747
        
748
        expected_bits= 
749
            + all_const_bits 
750
            + complexity[I_TYPE]/avg_quantizer[I_TYPE]
751
            + complexity[P_TYPE]/avg_quantizer[P_TYPE]
752
            + complexity[B_TYPE]/avg_quantizer[B_TYPE];
753
            
754
        if(expected_bits < all_available_bits) avg_quantizer[P_TYPE]-= step;
755
//printf("%f %lld %f\n", expected_bits, all_available_bits, avg_quantizer[P_TYPE]);
756
    }
757 405469ce Michael Niedermayer
//printf("qp_i:%f, qp_p:%f, qp_b:%f\n", avg_quantizer[I_TYPE],avg_quantizer[P_TYPE],avg_quantizer[B_TYPE]);
758 8b4c7dbc Michael Niedermayer
759
    for(i=0; i<5; i++){
760
        available_bits[i]= const_bits[i] + complexity[i]/avg_quantizer[i];
761
    }
762
//printf("%lld %lld %lld %lld\n", available_bits[I_TYPE], available_bits[P_TYPE], available_bits[B_TYPE], all_available_bits);
763 3aa102be Michael Niedermayer
        
764 8e1e6f31 Fabrice Bellard
    qscale= av_malloc(sizeof(double)*rcc->num_entries);
765
    blured_qscale= av_malloc(sizeof(double)*rcc->num_entries);
766 3aa102be Michael Niedermayer
767 8b4c7dbc Michael Niedermayer
    for(step=256*256; step>0.0000001; step*=0.5){
768 3aa102be Michael Niedermayer
        expected_bits=0;
769 8b4c7dbc Michael Niedermayer
        rate_factor+= step;
770 3aa102be Michael Niedermayer
        
771
        rcc->buffer_index= s->avctx->rc_buffer_size/2;
772
773 8b4c7dbc Michael Niedermayer
        /* find qscale */
774
        for(i=0; i<rcc->num_entries; i++){
775 3aa102be Michael Niedermayer
            qscale[i]= get_qscale(s, &rcc->entry[i], rate_factor, i);
776
        }
777
        assert(filter_size%2==1);
778
779
        /* fixed I/B QP relative to P mode */
780
        for(i=rcc->num_entries-1; i>=0; i--){
781 8b4c7dbc Michael Niedermayer
            RateControlEntry *rce= &rcc->entry[i];
782 6a1f7e7b Michael Niedermayer
            
783
            qscale[i]= get_diff_limited_q(s, rce, qscale[i]);
784 3aa102be Michael Niedermayer
        }
785 8b4c7dbc Michael Niedermayer
786 3aa102be Michael Niedermayer
        /* smooth curve */
787
        for(i=0; i<rcc->num_entries; i++){
788
            RateControlEntry *rce= &rcc->entry[i];
789
            const int pict_type= rce->new_pict_type;
790
            int j;
791
            double q=0.0, sum=0.0;
792
        
793
            for(j=0; j<filter_size; j++){
794
                int index= i+j-filter_size/2;
795
                double d= index-i;
796
                double coeff= s->qblur==0 ? 1.0 : exp(-d*d/(s->qblur * s->qblur));
797 8b4c7dbc Michael Niedermayer
            
798 3aa102be Michael Niedermayer
                if(index < 0 || index >= rcc->num_entries) continue;
799
                if(pict_type != rcc->entry[index].new_pict_type) continue;
800
                q+= qscale[index] * coeff;
801
                sum+= coeff;
802 8b4c7dbc Michael Niedermayer
            }
803 3aa102be Michael Niedermayer
            blured_qscale[i]= q/sum;
804 8b4c7dbc Michael Niedermayer
        }
805
    
806
        /* find expected bits */
807
        for(i=0; i<rcc->num_entries; i++){
808
            RateControlEntry *rce= &rcc->entry[i];
809 3aa102be Michael Niedermayer
            double bits;
810
            rce->new_qscale= modify_qscale(s, rce, blured_qscale[i], i);
811 405469ce Michael Niedermayer
            bits= qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;
812 3aa102be Michael Niedermayer
//printf("%d %f\n", rce->new_bits, blured_qscale[i]);
813
            update_rc_buffer(s, bits);
814
815 8b4c7dbc Michael Niedermayer
            rce->expected_bits= expected_bits;
816 3aa102be Michael Niedermayer
            expected_bits += bits;
817 8b4c7dbc Michael Niedermayer
        }
818
819 3aa102be Michael Niedermayer
//        printf("%f %d %f\n", expected_bits, (int)all_available_bits, rate_factor);
820 8b4c7dbc Michael Niedermayer
        if(expected_bits > all_available_bits) rate_factor-= step;
821
    }
822 8e1e6f31 Fabrice Bellard
    av_free(qscale);
823
    av_free(blured_qscale);
824 8b4c7dbc Michael Niedermayer
825 3aa102be Michael Niedermayer
    if(abs(expected_bits/all_available_bits - 1.0) > 0.01 ){
826 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "Error: 2pass curve failed to converge\n");
827 3aa102be Michael Niedermayer
        return -1;
828 8b4c7dbc Michael Niedermayer
    }
829
830 3aa102be Michael Niedermayer
    return 0;
831 8b4c7dbc Michael Niedermayer
}