← Back to branch summary

~ubuntu-branches/debian/wheezy/vlc/wheezy

« back to all changes in this revision

Viewing changes to extras/ffmpeg/libavcodec/ratecontrol.c

Tags: upstream-0.7.2.final
Import upstream version 0.7.2.final

Show diffs side-by-side

added added

removed removed

Lines of Context:
extras/ffmpeg/libavcodec/ratecontrol.c
 
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
}