Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ratecontrol.c @ 2d5e962b

History | View | Annotate | Download (27.5 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 c5d309f2 Michael Niedermayer
    sprintf(s->avctx->stats_out, "in:%d out:%d type:%d q:%f itex:%d ptex:%d mv:%d misc:%d fcode:%d bcode:%d mc-var:%d var:%d icount:%d;\n",
42 8b4c7dbc Michael Niedermayer
            s->picture_number, s->input_picture_number - s->max_b_frames, s->pict_type, 
43 c5d309f2 Michael Niedermayer
            s->frame_qscale, 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
        rcc->pred[i].coeff= 7.0;
55
        rcc->pred[i].count= 1.0;
56
    
57
        rcc->pred[i].decay= 0.4;
58
        rcc->i_cplx_sum [i]=
59
        rcc->p_cplx_sum [i]=
60
        rcc->mv_bits_sum[i]=
61
        rcc->qscale_sum [i]=
62
        rcc->frame_count[i]= 1; // 1 is better cuz of 1/0 and such
63
        rcc->last_qscale_for[i]=5;
64
    }
65
    rcc->buffer_index= s->avctx->rc_buffer_size/2;
66
67
    if(s->flags&CODEC_FLAG_PASS2){
68 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
            rce->qscale= rce->new_qscale=2;
85
            rce->misc_bits= s->mb_num + 10;
86
            rce->mb_var_sum= s->mb_num*100;
87
        }        
88
        
89
        /* read stats */
90
        p= s->avctx->stats_in;
91
        for(i=0; i<rcc->num_entries - s->max_b_frames; i++){
92 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
                fprintf(stderr, "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
                rce.qscale   = 2;
144
                rce.f_code   = 2;
145
                rce.b_code   = 1;
146
                rce.misc_bits= 1;
147
148
                if(s->pict_type== I_TYPE){
149
                    rce.i_count   = s->mb_num;
150
                    rce.i_tex_bits= bits;
151
                    rce.p_tex_bits= 0;
152
                    rce.mv_bits= 0;
153
                }else{
154
                    rce.i_count   = 0; //FIXME we do know this approx
155
                    rce.i_tex_bits= 0;
156
                    rce.p_tex_bits= bits*0.9;
157
                    rce.mv_bits= bits*0.1;
158
                }
159
                rcc->i_cplx_sum [rce.pict_type] += rce.i_tex_bits*rce.qscale;
160
                rcc->p_cplx_sum [rce.pict_type] += rce.p_tex_bits*rce.qscale;
161
                rcc->mv_bits_sum[rce.pict_type] += rce.mv_bits;
162
                rcc->frame_count[rce.pict_type] ++;
163 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
        fprintf(stderr, "qp<=0.0\n");
187
    }
188
    return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits+1)/ qp;
189
}
190
191
static inline double bits2qp(RateControlEntry *rce, double bits){
192
    if(bits<0.9){
193
        fprintf(stderr, "bits<0.9\n");
194
    }
195
    return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits+1)/ bits;
196
}
197
    
198
static void update_rc_buffer(MpegEncContext *s, int frame_size){
199
    RateControlContext *rcc= &s->rc_context;
200 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
            fprintf(stderr, "rc buffer underflow\n");
217
        if(rcc->buffer_index >= s->avctx->rc_buffer_size)
218
            fprintf(stderr, "rc buffer overflow\n");
219
    }
220
}
221
222
/**
223
 * modifies the bitrate curve from pass1 for one frame
224
 */
225
static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_factor, int frame_num){
226
    RateControlContext *rcc= &s->rc_context;
227
    double q, bits;
228
    const int pict_type= rce->new_pict_type;
229
    const double mb_num= s->mb_num;  
230
    int i;
231
232
    double const_values[]={
233
        M_PI,
234
        M_E,
235
        rce->i_tex_bits*rce->qscale,
236
        rce->p_tex_bits*rce->qscale,
237
        (rce->i_tex_bits + rce->p_tex_bits)*(double)rce->qscale,
238
        rce->mv_bits/mb_num,
239
        rce->pict_type == B_TYPE ? (rce->f_code + rce->b_code)*0.5 : rce->f_code,
240
        rce->i_count/mb_num,
241
        rce->mc_mb_var_sum/mb_num,
242
        rce->mb_var_sum/mb_num,
243
        rce->pict_type == I_TYPE,
244
        rce->pict_type == P_TYPE,
245
        rce->pict_type == B_TYPE,
246
        rcc->qscale_sum[pict_type] / (double)rcc->frame_count[pict_type],
247
        s->qcompress,
248
/*        rcc->last_qscale_for[I_TYPE],
249
        rcc->last_qscale_for[P_TYPE],
250
        rcc->last_qscale_for[B_TYPE],
251
        rcc->next_non_b_qscale,*/
252
        rcc->i_cplx_sum[I_TYPE] / (double)rcc->frame_count[I_TYPE],
253
        rcc->i_cplx_sum[P_TYPE] / (double)rcc->frame_count[P_TYPE],
254
        rcc->p_cplx_sum[P_TYPE] / (double)rcc->frame_count[P_TYPE],
255
        rcc->p_cplx_sum[B_TYPE] / (double)rcc->frame_count[B_TYPE],
256
        (rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / (double)rcc->frame_count[pict_type],
257
        0
258
    };
259 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 59b571c1 Michael Niedermayer
343 6a1f7e7b Michael Niedermayer
        if     (q > last_q + a->max_qdiff) q= last_q + a->max_qdiff;
344
        else if(q < last_q - a->max_qdiff) q= last_q - a->max_qdiff;
345
    }
346 3aa102be Michael Niedermayer
347
    rcc->last_qscale_for[pict_type]= q; //Note we cant do that after blurring
348
    
349 6a1f7e7b Michael Niedermayer
    if(pict_type!=B_TYPE)
350
        rcc->last_non_b_pict_type= pict_type;
351
352 3aa102be Michael Niedermayer
    return q;
353
}
354
355
/**
356
 * gets the qmin & qmax for pict_type
357
 */
358
static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type){
359 c5a9ab69 Michael Niedermayer
    int qmin= s->avctx->qmin;                                                       
360
    int qmax= s->avctx->qmax;
361 fa12b546 Michael Niedermayer
    
362
    assert(qmin <= qmax);
363 3aa102be Michael Niedermayer
364
    if(pict_type==B_TYPE){
365
        qmin= (int)(qmin*ABS(s->avctx->b_quant_factor)+s->avctx->b_quant_offset + 0.5);
366
        qmax= (int)(qmax*ABS(s->avctx->b_quant_factor)+s->avctx->b_quant_offset + 0.5);
367
    }else if(pict_type==I_TYPE){
368
        qmin= (int)(qmin*ABS(s->avctx->i_quant_factor)+s->avctx->i_quant_offset + 0.5);
369
        qmax= (int)(qmax*ABS(s->avctx->i_quant_factor)+s->avctx->i_quant_offset + 0.5);
370
    }
371
372 fa12b546 Michael Niedermayer
    qmin= clip(qmin, 1, 31);
373
    qmax= clip(qmax, 1, 31);
374
375 c5a9ab69 Michael Niedermayer
    if(qmin==1 && s->avctx->qmin>1) qmin=2; //avoid qmin=1 unless the user wants qmin=1
376 3aa102be Michael Niedermayer
377
    if(qmin<3 && s->max_qcoeff<=128 && pict_type==I_TYPE) qmin=3; //reduce cliping problems
378
379 fa12b546 Michael Niedermayer
    if(qmax<qmin) qmax= qmin;
380 3aa102be Michael Niedermayer
    
381
    *qmin_ret= qmin;
382
    *qmax_ret= qmax;
383
}
384
385
static double modify_qscale(MpegEncContext *s, RateControlEntry *rce, double q, int frame_num){
386
    RateControlContext *rcc= &s->rc_context;
387
    int qmin, qmax;
388
    double bits;
389
    const int pict_type= rce->new_pict_type;
390
    const double buffer_size= s->avctx->rc_buffer_size;
391
    const double min_rate= s->avctx->rc_min_rate;
392
    const double max_rate= s->avctx->rc_max_rate;
393
    
394
    get_qminmax(&qmin, &qmax, s, pict_type);
395
396
    /* modulation */
397
    if(s->avctx->rc_qmod_freq && frame_num%s->avctx->rc_qmod_freq==0 && pict_type==P_TYPE)
398
        q*= s->avctx->rc_qmod_amp;
399
400
    bits= qp2bits(rce, q);
401 946c8a12 Michael Niedermayer
//printf("q:%f\n", q);
402 3aa102be Michael Niedermayer
    /* buffer overflow/underflow protection */
403
    if(buffer_size){
404 6a1f7e7b Michael Niedermayer
        double expected_size= rcc->buffer_index;
405 3aa102be Michael Niedermayer
406
        if(min_rate){
407 6a1f7e7b Michael Niedermayer
            double d= 2*(buffer_size - expected_size)/buffer_size;
408 3aa102be Michael Niedermayer
            if(d>1.0) d=1.0;
409 946c8a12 Michael Niedermayer
            else if(d<0.0001) d=0.0001;
410
            q*= pow(d, 1.0/s->avctx->rc_buffer_aggressivity);
411 6a1f7e7b Michael Niedermayer
412 b8a78f41 Michael Niedermayer
            q= FFMIN(q, bits2qp(rce, FFMAX((min_rate - buffer_size + rcc->buffer_index)*2, 1)));
413 3aa102be Michael Niedermayer
        }
414
415
        if(max_rate){
416
            double d= 2*expected_size/buffer_size;
417
            if(d>1.0) d=1.0;
418 946c8a12 Michael Niedermayer
            else if(d<0.0001) d=0.0001;
419
            q/= pow(d, 1.0/s->avctx->rc_buffer_aggressivity);
420 6a1f7e7b Michael Niedermayer
421 b8a78f41 Michael Niedermayer
            q= FFMAX(q, bits2qp(rce, FFMAX(rcc->buffer_index/2, 1)));
422 3aa102be Michael Niedermayer
        }
423
    }
424 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);
425 c695ca3b Michael Niedermayer
    if(s->avctx->rc_qsquish==0.0 || qmin==qmax){
426 3aa102be Michael Niedermayer
        if     (q<qmin) q=qmin;
427
        else if(q>qmax) q=qmax;
428
    }else{
429
        double min2= log(qmin);
430
        double max2= log(qmax);
431
        
432
        q= log(q);
433
        q= (q - min2)/(max2-min2) - 0.5;
434
        q*= -4.0;
435
        q= 1.0/(1.0 + exp(q));
436
        q= q*(max2-min2) + min2;
437
        
438
        q= exp(q);
439
    }
440 c5d309f2 Michael Niedermayer
    
441 3aa102be Michael Niedermayer
    return q;
442
}
443
444 8b4c7dbc Michael Niedermayer
//----------------------------------
445
// 1 Pass Code
446
447 3aa102be Michael Niedermayer
static double predict_size(Predictor *p, double q, double var)
448 8b4c7dbc Michael Niedermayer
{
449
     return p->coeff*var / (q*p->count);
450
}
451
452 ccfddafb bubu
/*
453 3aa102be Michael Niedermayer
static double predict_qp(Predictor *p, double size, double var)
454
{
455
//printf("coeff:%f, count:%f, var:%f, size:%f//\n", p->coeff, p->count, var, size);
456
     return p->coeff*var / (size*p->count);
457
}
458 ccfddafb bubu
*/
459 3aa102be Michael Niedermayer
460 8b4c7dbc Michael Niedermayer
static void update_predictor(Predictor *p, double q, double var, double size)
461
{
462
    double new_coeff= size*q / (var + 1);
463 3aa102be Michael Niedermayer
    if(var<10) return;
464 8b4c7dbc Michael Niedermayer
465
    p->count*= p->decay;
466
    p->coeff*= p->decay;
467
    p->count++;
468
    p->coeff+= new_coeff;
469
}
470
471 c5d309f2 Michael Niedermayer
static void adaptive_quantization(MpegEncContext *s, double q){
472
    int i;
473
    const float lumi_masking= s->avctx->lumi_masking / (128.0*128.0);
474 5e746b99 Michael Niedermayer
    const float dark_masking= s->avctx->dark_masking / (128.0*128.0);
475 c5d309f2 Michael Niedermayer
    const float temp_cplx_masking= s->avctx->temporal_cplx_masking;
476
    const float spatial_cplx_masking = s->avctx->spatial_cplx_masking;
477
    const float p_masking = s->avctx->p_masking;
478
    float bits_sum= 0.0;
479
    float cplx_sum= 0.0;
480
    float cplx_tab[s->mb_num];
481
    float bits_tab[s->mb_num];
482 17a70fde Michael Niedermayer
    const int qmin= s->avctx->mb_qmin;
483
    const int qmax= s->avctx->mb_qmax;
484 1e491e29 Michael Niedermayer
    Picture * const pic= &s->current_picture;
485 2f5feea4 Michael Niedermayer
    int last_qscale=0;
486 c5d309f2 Michael Niedermayer
    
487
    for(i=0; i<s->mb_num; i++){
488 2f5feea4 Michael Niedermayer
        const int mb_xy= s->mb_index2xy[i];
489
        float temp_cplx= sqrt(pic->mc_mb_var[mb_xy]);
490
        float spat_cplx= sqrt(pic->mb_var[mb_xy]);
491
        const int lumi= pic->mb_mean[mb_xy];
492 c5d309f2 Michael Niedermayer
        float bits, cplx, factor;
493
        
494
        if(spat_cplx < q/3) spat_cplx= q/3; //FIXME finetune
495
        if(temp_cplx < q/3) temp_cplx= q/3; //FIXME finetune
496
        
497 2f5feea4 Michael Niedermayer
        if((s->mb_type[mb_xy]&MB_TYPE_INTRA)){//FIXME hq mode 
498 c5d309f2 Michael Niedermayer
            cplx= spat_cplx;
499
            factor= 1.0 + p_masking;
500
        }else{
501
            cplx= temp_cplx;
502
            factor= pow(temp_cplx, - temp_cplx_masking);
503
        }
504
        factor*=pow(spat_cplx, - spatial_cplx_masking);
505 5e746b99 Michael Niedermayer
506
        if(lumi>127)
507
            factor*= (1.0 - (lumi-128)*(lumi-128)*lumi_masking);
508
        else
509
            factor*= (1.0 - (lumi-128)*(lumi-128)*dark_masking);
510 c5d309f2 Michael Niedermayer
        
511
        if(factor<0.00001) factor= 0.00001;
512
        
513
        bits= cplx*factor;
514
        cplx_sum+= cplx;
515
        bits_sum+= bits;
516
        cplx_tab[i]= cplx;
517
        bits_tab[i]= bits;
518
    }
519
520
    /* handle qmin/qmax cliping */
521
    if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
522
        for(i=0; i<s->mb_num; i++){
523
            float newq= q*cplx_tab[i]/bits_tab[i];
524
            newq*= bits_sum/cplx_sum;
525
526
            if     (newq > qmax){
527
                bits_sum -= bits_tab[i];
528
                cplx_sum -= cplx_tab[i]*q/qmax;
529
            }
530
            else if(newq < qmin){
531
                bits_sum -= bits_tab[i];
532
                cplx_sum -= cplx_tab[i]*q/qmin;
533
            }
534
        }
535
    }
536
   
537
    for(i=0; i<s->mb_num; i++){
538 2f5feea4 Michael Niedermayer
        const int mb_xy= s->mb_index2xy[i];
539 c5d309f2 Michael Niedermayer
        float newq= q*cplx_tab[i]/bits_tab[i];
540
        int intq;
541
542
        if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
543
            newq*= bits_sum/cplx_sum;
544
        }
545
546 2f5feea4 Michael Niedermayer
        if(i && ABS(last_qscale - newq)<0.75)
547
            intq= last_qscale;
548 c5d309f2 Michael Niedermayer
        else
549
            intq= (int)(newq + 0.5);
550
551
        if     (intq > qmax) intq= qmax;
552
        else if(intq < qmin) intq= qmin;
553
//if(i%s->mb_width==0) printf("\n");
554
//printf("%2d%3d ", intq, ff_sqrt(s->mc_mb_var[i]));
555 2f5feea4 Michael Niedermayer
        last_qscale=
556
        pic->qscale_table[mb_xy]= intq;
557 c5d309f2 Michael Niedermayer
    }
558
}
559
560
float ff_rate_estimate_qscale(MpegEncContext *s)
561 8b4c7dbc Michael Niedermayer
{
562
    float q;
563 c5d309f2 Michael Niedermayer
    int qmin, qmax;
564 8b4c7dbc Michael Niedermayer
    float br_compensation;
565
    double diff;
566
    double short_term_q;
567
    double fps;
568 3aa102be Michael Niedermayer
    int picture_number= s->picture_number;
569 8b4c7dbc Michael Niedermayer
    int64_t wanted_bits;
570 3aa102be Michael Niedermayer
    RateControlContext *rcc= &s->rc_context;
571
    RateControlEntry local_rce, *rce;
572
    double bits;
573
    double rate_factor;
574
    int var;
575
    const int pict_type= s->pict_type;
576 1e491e29 Michael Niedermayer
    Picture * const pic= &s->current_picture;
577 8b4c7dbc Michael Niedermayer
    emms_c();
578
579 3aa102be Michael Niedermayer
    get_qminmax(&qmin, &qmax, s, pict_type);
580 8b4c7dbc Michael Niedermayer
581 14bea432 Michael Niedermayer
    fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base;
582 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);
583 8b4c7dbc Michael Niedermayer
        /* update predictors */
584
    if(picture_number>2){
585 3aa102be Michael Niedermayer
        const int last_var= s->last_pict_type == I_TYPE ? rcc->last_mb_var_sum : rcc->last_mc_mb_var_sum;
586
        update_predictor(&rcc->pred[s->last_pict_type], rcc->last_qscale, sqrt(last_var), s->frame_bits);
587 8b4c7dbc Michael Niedermayer
    }
588
589 3aa102be Michael Niedermayer
    if(s->flags&CODEC_FLAG_PASS2){
590
        assert(picture_number>=0);
591
        assert(picture_number<rcc->num_entries);
592
        rce= &rcc->entry[picture_number];
593
        wanted_bits= rce->expected_bits;
594
    }else{
595
        rce= &local_rce;
596
        wanted_bits= (uint64_t)(s->bit_rate*(double)picture_number/fps);
597
    }
598 8b4c7dbc Michael Niedermayer
599 3aa102be Michael Niedermayer
    diff= s->total_bits - wanted_bits;
600
    br_compensation= (s->bit_rate_tolerance - diff)/s->bit_rate_tolerance;
601
    if(br_compensation<=0.0) br_compensation=0.001;
602
603 1e491e29 Michael Niedermayer
    var= pict_type == I_TYPE ? pic->mb_var_sum : pic->mc_mb_var_sum;
604 3aa102be Michael Niedermayer
    
605
    if(s->flags&CODEC_FLAG_PASS2){
606
        if(pict_type!=I_TYPE)
607
            assert(pict_type == rce->new_pict_type);
608
609
        q= rce->new_qscale / br_compensation;
610
//printf("%f %f %f last:%d var:%d type:%d//\n", q, rce->new_qscale, br_compensation, s->frame_bits, var, pict_type);
611
    }else{
612
        rce->pict_type= 
613
        rce->new_pict_type= pict_type;
614 1e491e29 Michael Niedermayer
        rce->mc_mb_var_sum= pic->mc_mb_var_sum;
615
        rce->mb_var_sum   = pic->   mb_var_sum;
616 3aa102be Michael Niedermayer
        rce->qscale   = 2;
617
        rce->f_code   = s->f_code;
618
        rce->b_code   = s->b_code;
619
        rce->misc_bits= 1;
620
621
        if(picture_number>0)
622
            update_rc_buffer(s, s->frame_bits);
623
624
        bits= predict_size(&rcc->pred[pict_type], rce->qscale, sqrt(var));
625
        if(pict_type== I_TYPE){
626
            rce->i_count   = s->mb_num;
627
            rce->i_tex_bits= bits;
628
            rce->p_tex_bits= 0;
629
            rce->mv_bits= 0;
630
        }else{
631
            rce->i_count   = 0; //FIXME we do know this approx
632
            rce->i_tex_bits= 0;
633
            rce->p_tex_bits= bits*0.9;
634
            
635
            rce->mv_bits= bits*0.1;
636 8b4c7dbc Michael Niedermayer
        }
637 3aa102be Michael Niedermayer
        rcc->i_cplx_sum [pict_type] += rce->i_tex_bits*rce->qscale;
638
        rcc->p_cplx_sum [pict_type] += rce->p_tex_bits*rce->qscale;
639
        rcc->mv_bits_sum[pict_type] += rce->mv_bits;
640
        rcc->frame_count[pict_type] ++;
641 8b4c7dbc Michael Niedermayer
642 3aa102be Michael Niedermayer
        bits= rce->i_tex_bits + rce->p_tex_bits;
643 23e54f69 Michael Niedermayer
        rate_factor= rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum * br_compensation;
644 8b4c7dbc Michael Niedermayer
    
645 3aa102be Michael Niedermayer
        q= get_qscale(s, rce, rate_factor, picture_number);
646 8b4c7dbc Michael Niedermayer
647 c695ca3b Michael Niedermayer
        assert(q>0.0);
648 3aa102be Michael Niedermayer
//printf("%f ", q);
649 6a1f7e7b Michael Niedermayer
        q= get_diff_limited_q(s, rce, q);
650 3aa102be Michael Niedermayer
//printf("%f ", q);
651
        assert(q>0.0);
652
653
        if(pict_type==P_TYPE || s->intra_only){ //FIXME type dependant blur like in 2-pass
654
            rcc->short_term_qsum*=s->qblur;
655
            rcc->short_term_qcount*=s->qblur;
656
657
            rcc->short_term_qsum+= q;
658
            rcc->short_term_qcount++;
659
//printf("%f ", q);
660
            q= short_term_q= rcc->short_term_qsum/rcc->short_term_qcount;
661
//printf("%f ", q);
662
        }
663 946c8a12 Michael Niedermayer
        assert(q>0.0);
664
        
665 3aa102be Michael Niedermayer
        q= modify_qscale(s, rce, q, picture_number);
666
667
        rcc->pass1_wanted_bits+= s->bit_rate/fps;
668
669 c695ca3b Michael Niedermayer
        assert(q>0.0);
670 8b4c7dbc Michael Niedermayer
    }
671 59b571c1 Michael Niedermayer
672
    if(s->avctx->debug&FF_DEBUG_RC){
673
        printf("%c qp:%d<%2.1f<%d %d want:%d total:%d comp:%f st_q:%2.2f size:%d var:%d/%d br:%d fps:%d\n",
674 d8085ea7 Michael Niedermayer
        av_get_pict_type_char(pict_type), qmin, q, qmax, picture_number, (int)wanted_bits/1000, (int)s->total_bits/1000,
675 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
676
        );
677
    }
678 3aa102be Michael Niedermayer
679
    if     (q<qmin) q=qmin; 
680
    else if(q>qmax) q=qmax;
681
682 c5d309f2 Michael Niedermayer
    if(s->adaptive_quant)
683
        adaptive_quantization(s, q);
684
    else
685
        q= (int)(q + 0.5);
686
    
687
    rcc->last_qscale= q;
688 1e491e29 Michael Niedermayer
    rcc->last_mc_mb_var_sum= pic->mc_mb_var_sum;
689
    rcc->last_mb_var_sum= pic->mb_var_sum;
690
#if 0
691
{
692
    static int mvsum=0, texsum=0;
693
    mvsum += s->mv_bits;
694
    texsum += s->i_tex_bits + s->p_tex_bits;
695
    printf("%d %d//\n\n", mvsum, texsum);
696
}
697
#endif
698 c5d309f2 Michael Niedermayer
    return q;
699 8b4c7dbc Michael Niedermayer
}
700
701
//----------------------------------------------
702
// 2-Pass code
703
704
static int init_pass2(MpegEncContext *s)
705
{
706
    RateControlContext *rcc= &s->rc_context;
707
    int i;
708 14bea432 Michael Niedermayer
    double fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base;
709 8b4c7dbc Michael Niedermayer
    double complexity[5]={0,0,0,0,0};   // aproximate bits at quant=1
710
    double avg_quantizer[5];
711
    uint64_t const_bits[5]={0,0,0,0,0}; // quantizer idependant bits
712
    uint64_t available_bits[5];
713
    uint64_t all_const_bits;
714
    uint64_t all_available_bits= (uint64_t)(s->bit_rate*(double)rcc->num_entries/fps);
715
    double rate_factor=0;
716
    double step;
717 ccfddafb bubu
    //int last_i_frame=-10000000;
718 3aa102be Michael Niedermayer
    const int filter_size= (int)(s->qblur*4) | 1;  
719
    double expected_bits;
720
    double *qscale, *blured_qscale;
721 8b4c7dbc Michael Niedermayer
722
    /* find complexity & const_bits & decide the pict_types */
723
    for(i=0; i<rcc->num_entries; i++){
724
        RateControlEntry *rce= &rcc->entry[i];
725
        
726 0d1e9246 Michael Niedermayer
        rce->new_pict_type= rce->pict_type;
727 3aa102be Michael Niedermayer
        rcc->i_cplx_sum [rce->pict_type] += rce->i_tex_bits*rce->qscale;
728
        rcc->p_cplx_sum [rce->pict_type] += rce->p_tex_bits*rce->qscale;
729
        rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits;
730
        rcc->frame_count[rce->pict_type] ++;
731 8b4c7dbc Michael Niedermayer
732
        complexity[rce->new_pict_type]+= (rce->i_tex_bits+ rce->p_tex_bits)*(double)rce->qscale;
733
        const_bits[rce->new_pict_type]+= rce->mv_bits + rce->misc_bits;
734
    }
735
    all_const_bits= const_bits[I_TYPE] + const_bits[P_TYPE] + const_bits[B_TYPE];
736
    
737
    if(all_available_bits < all_const_bits){
738
        fprintf(stderr, "requested bitrate is to low\n");
739
        return -1;
740
    }
741 3aa102be Michael Niedermayer
    
742
    /* find average quantizers */
743
    avg_quantizer[P_TYPE]=0;
744
    for(step=256*256; step>0.0000001; step*=0.5){
745
        double expected_bits=0;
746
        avg_quantizer[P_TYPE]+= step;
747
        
748
        avg_quantizer[I_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->i_quant_factor) + s->avctx->i_quant_offset;
749
        avg_quantizer[B_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
750
        
751
        expected_bits= 
752
            + all_const_bits 
753
            + complexity[I_TYPE]/avg_quantizer[I_TYPE]
754
            + complexity[P_TYPE]/avg_quantizer[P_TYPE]
755
            + complexity[B_TYPE]/avg_quantizer[B_TYPE];
756
            
757
        if(expected_bits < all_available_bits) avg_quantizer[P_TYPE]-= step;
758
//printf("%f %lld %f\n", expected_bits, all_available_bits, avg_quantizer[P_TYPE]);
759
    }
760 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]);
761 8b4c7dbc Michael Niedermayer
762
    for(i=0; i<5; i++){
763
        available_bits[i]= const_bits[i] + complexity[i]/avg_quantizer[i];
764
    }
765
//printf("%lld %lld %lld %lld\n", available_bits[I_TYPE], available_bits[P_TYPE], available_bits[B_TYPE], all_available_bits);
766 3aa102be Michael Niedermayer
        
767 8e1e6f31 Fabrice Bellard
    qscale= av_malloc(sizeof(double)*rcc->num_entries);
768
    blured_qscale= av_malloc(sizeof(double)*rcc->num_entries);
769 3aa102be Michael Niedermayer
770 8b4c7dbc Michael Niedermayer
    for(step=256*256; step>0.0000001; step*=0.5){
771 3aa102be Michael Niedermayer
        expected_bits=0;
772 8b4c7dbc Michael Niedermayer
        rate_factor+= step;
773 3aa102be Michael Niedermayer
        
774
        rcc->buffer_index= s->avctx->rc_buffer_size/2;
775
776 8b4c7dbc Michael Niedermayer
        /* find qscale */
777
        for(i=0; i<rcc->num_entries; i++){
778 3aa102be Michael Niedermayer
            qscale[i]= get_qscale(s, &rcc->entry[i], rate_factor, i);
779
        }
780
        assert(filter_size%2==1);
781
782
        /* fixed I/B QP relative to P mode */
783
        for(i=rcc->num_entries-1; i>=0; i--){
784 8b4c7dbc Michael Niedermayer
            RateControlEntry *rce= &rcc->entry[i];
785 6a1f7e7b Michael Niedermayer
            
786
            qscale[i]= get_diff_limited_q(s, rce, qscale[i]);
787 3aa102be Michael Niedermayer
        }
788 8b4c7dbc Michael Niedermayer
789 3aa102be Michael Niedermayer
        /* smooth curve */
790
        for(i=0; i<rcc->num_entries; i++){
791
            RateControlEntry *rce= &rcc->entry[i];
792
            const int pict_type= rce->new_pict_type;
793
            int j;
794
            double q=0.0, sum=0.0;
795
        
796
            for(j=0; j<filter_size; j++){
797
                int index= i+j-filter_size/2;
798
                double d= index-i;
799
                double coeff= s->qblur==0 ? 1.0 : exp(-d*d/(s->qblur * s->qblur));
800 8b4c7dbc Michael Niedermayer
            
801 3aa102be Michael Niedermayer
                if(index < 0 || index >= rcc->num_entries) continue;
802
                if(pict_type != rcc->entry[index].new_pict_type) continue;
803
                q+= qscale[index] * coeff;
804
                sum+= coeff;
805 8b4c7dbc Michael Niedermayer
            }
806 3aa102be Michael Niedermayer
            blured_qscale[i]= q/sum;
807 8b4c7dbc Michael Niedermayer
        }
808
    
809
        /* find expected bits */
810
        for(i=0; i<rcc->num_entries; i++){
811
            RateControlEntry *rce= &rcc->entry[i];
812 3aa102be Michael Niedermayer
            double bits;
813
            rce->new_qscale= modify_qscale(s, rce, blured_qscale[i], i);
814 405469ce Michael Niedermayer
            bits= qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;
815 3aa102be Michael Niedermayer
//printf("%d %f\n", rce->new_bits, blured_qscale[i]);
816
            update_rc_buffer(s, bits);
817
818 8b4c7dbc Michael Niedermayer
            rce->expected_bits= expected_bits;
819 3aa102be Michael Niedermayer
            expected_bits += bits;
820 8b4c7dbc Michael Niedermayer
        }
821
822 3aa102be Michael Niedermayer
//        printf("%f %d %f\n", expected_bits, (int)all_available_bits, rate_factor);
823 8b4c7dbc Michael Niedermayer
        if(expected_bits > all_available_bits) rate_factor-= step;
824
    }
825 8e1e6f31 Fabrice Bellard
    av_free(qscale);
826
    av_free(blured_qscale);
827 8b4c7dbc Michael Niedermayer
828 3aa102be Michael Niedermayer
    if(abs(expected_bits/all_available_bits - 1.0) > 0.01 ){
829
        fprintf(stderr, "Error: 2pass curve failed to converge\n");
830
        return -1;
831 8b4c7dbc Michael Niedermayer
    }
832
833 3aa102be Michael Niedermayer
    return 0;
834 8b4c7dbc Michael Niedermayer
}