cleanup
[ffmpeg.git] / libavcodec / ratecontrol.c
1 /*
2  * Rate control for video encoders
3  *
4  * Copyright (c) 2002-2003 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->picture_number, s->input_picture_number - s->max_b_frames, 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 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 //printf("%f %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 > s->avctx->rc_buffer_size){
219             int stuffing= ceil((rcc->buffer_index - s->avctx->rc_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
417         if(min_rate){
418             double d= 2*(buffer_size - expected_size)/buffer_size;
419             if(d>1.0) d=1.0;
420             else if(d<0.0001) d=0.0001;
421             q*= pow(d, 1.0/s->avctx->rc_buffer_aggressivity);
422
423             q= FFMIN(q, bits2qp(rce, FFMAX((min_rate - buffer_size + rcc->buffer_index)*3, 1)));
424         }
425
426         if(max_rate){
427             double d= 2*expected_size/buffer_size;
428             if(d>1.0) d=1.0;
429             else if(d<0.0001) d=0.0001;
430             q/= pow(d, 1.0/s->avctx->rc_buffer_aggressivity);
431
432             q= FFMAX(q, bits2qp(rce, FFMAX(rcc->buffer_index/3, 1)));
433         }
434     }
435 //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);
436     if(s->avctx->rc_qsquish==0.0 || qmin==qmax){
437         if     (q<qmin) q=qmin;
438         else if(q>qmax) q=qmax;
439     }else{
440         double min2= log(qmin);
441         double max2= log(qmax);
442         
443         q= log(q);
444         q= (q - min2)/(max2-min2) - 0.5;
445         q*= -4.0;
446         q= 1.0/(1.0 + exp(q));
447         q= q*(max2-min2) + min2;
448         
449         q= exp(q);
450     }
451     
452     return q;
453 }
454
455 //----------------------------------
456 // 1 Pass Code
457
458 static double predict_size(Predictor *p, double q, double var)
459 {
460      return p->coeff*var / (q*p->count);
461 }
462
463 /*
464 static double predict_qp(Predictor *p, double size, double var)
465 {
466 //printf("coeff:%f, count:%f, var:%f, size:%f//\n", p->coeff, p->count, var, size);
467      return p->coeff*var / (size*p->count);
468 }
469 */
470
471 static void update_predictor(Predictor *p, double q, double var, double size)
472 {
473     double new_coeff= size*q / (var + 1);
474     if(var<10) return;
475
476     p->count*= p->decay;
477     p->coeff*= p->decay;
478     p->count++;
479     p->coeff+= new_coeff;
480 }
481
482 static void adaptive_quantization(MpegEncContext *s, double q){
483     int i;
484     const float lumi_masking= s->avctx->lumi_masking / (128.0*128.0);
485     const float dark_masking= s->avctx->dark_masking / (128.0*128.0);
486     const float temp_cplx_masking= s->avctx->temporal_cplx_masking;
487     const float spatial_cplx_masking = s->avctx->spatial_cplx_masking;
488     const float p_masking = s->avctx->p_masking;
489     float bits_sum= 0.0;
490     float cplx_sum= 0.0;
491     float cplx_tab[s->mb_num];
492     float bits_tab[s->mb_num];
493     const int qmin= s->avctx->lmin;
494     const int qmax= s->avctx->lmax;
495     Picture * const pic= &s->current_picture;
496     
497     for(i=0; i<s->mb_num; i++){
498         const int mb_xy= s->mb_index2xy[i];
499         float temp_cplx= sqrt(pic->mc_mb_var[mb_xy]); //FIXME merge in pow()
500         float spat_cplx= sqrt(pic->mb_var[mb_xy]);
501         const int lumi= pic->mb_mean[mb_xy];
502         float bits, cplx, factor;
503 #if 0        
504         if(spat_cplx < q/3) spat_cplx= q/3; //FIXME finetune
505         if(temp_cplx < q/3) temp_cplx= q/3; //FIXME finetune
506 #endif   
507         if(spat_cplx < 4) spat_cplx= 4; //FIXME finetune
508         if(temp_cplx < 4) temp_cplx= 4; //FIXME finetune
509
510         if((s->mb_type[mb_xy]&MB_TYPE_INTRA)){//FIXME hq mode 
511             cplx= spat_cplx;
512             factor= 1.0 + p_masking;
513         }else{
514             cplx= temp_cplx;
515             factor= pow(temp_cplx, - temp_cplx_masking);
516         }
517         factor*=pow(spat_cplx, - spatial_cplx_masking);
518
519         if(lumi>127)
520             factor*= (1.0 - (lumi-128)*(lumi-128)*lumi_masking);
521         else
522             factor*= (1.0 - (lumi-128)*(lumi-128)*dark_masking);
523         
524         if(factor<0.00001) factor= 0.00001;
525         
526         bits= cplx*factor;
527         cplx_sum+= cplx;
528         bits_sum+= bits;
529         cplx_tab[i]= cplx;
530         bits_tab[i]= bits;
531     }
532
533     /* handle qmin/qmax cliping */
534     if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
535         for(i=0; i<s->mb_num; i++){
536             float newq= q*cplx_tab[i]/bits_tab[i];
537             newq*= bits_sum/cplx_sum;
538
539             if     (newq > qmax){
540                 bits_sum -= bits_tab[i];
541                 cplx_sum -= cplx_tab[i]*q/qmax;
542             }
543             else if(newq < qmin){
544                 bits_sum -= bits_tab[i];
545                 cplx_sum -= cplx_tab[i]*q/qmin;
546             }
547         }
548     }
549    
550     for(i=0; i<s->mb_num; i++){
551         const int mb_xy= s->mb_index2xy[i];
552         float newq= q*cplx_tab[i]/bits_tab[i];
553         int intq;
554
555         if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
556             newq*= bits_sum/cplx_sum;
557         }
558
559         intq= (int)(newq + 0.5);
560
561         if     (intq > qmax) intq= qmax;
562         else if(intq < qmin) intq= qmin;
563 //if(i%s->mb_width==0) printf("\n");
564 //printf("%2d%3d ", intq, ff_sqrt(s->mc_mb_var[i]));
565         s->lambda_table[mb_xy]= intq;
566     }
567 }
568 //FIXME rd or at least approx for dquant
569
570 float ff_rate_estimate_qscale(MpegEncContext *s)
571 {
572     float q;
573     int qmin, qmax;
574     float br_compensation;
575     double diff;
576     double short_term_q;
577     double fps;
578     int picture_number= s->picture_number;
579     int64_t wanted_bits;
580     RateControlContext *rcc= &s->rc_context;
581     AVCodecContext *a= s->avctx;
582     RateControlEntry local_rce, *rce;
583     double bits;
584     double rate_factor;
585     int var;
586     const int pict_type= s->pict_type;
587     Picture * const pic= &s->current_picture;
588     emms_c();
589
590     get_qminmax(&qmin, &qmax, s, pict_type);
591
592     fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base;
593 //printf("input_pic_num:%d pic_num:%d frame_rate:%d\n", s->input_picture_number, s->picture_number, s->frame_rate);
594         /* update predictors */
595     if(picture_number>2){
596         const int last_var= s->last_pict_type == I_TYPE ? rcc->last_mb_var_sum : rcc->last_mc_mb_var_sum;
597         update_predictor(&rcc->pred[s->last_pict_type], rcc->last_qscale, sqrt(last_var), s->frame_bits);
598     }
599
600     if(s->flags&CODEC_FLAG_PASS2){
601         assert(picture_number>=0);
602         assert(picture_number<rcc->num_entries);
603         rce= &rcc->entry[picture_number];
604         wanted_bits= rce->expected_bits;
605     }else{
606         rce= &local_rce;
607         wanted_bits= (uint64_t)(s->bit_rate*(double)picture_number/fps);
608     }
609
610     diff= s->total_bits - wanted_bits;
611     br_compensation= (a->bit_rate_tolerance - diff)/a->bit_rate_tolerance;
612     if(br_compensation<=0.0) br_compensation=0.001;
613
614     var= pict_type == I_TYPE ? pic->mb_var_sum : pic->mc_mb_var_sum;
615     
616     short_term_q = 0; /* avoid warning */
617     if(s->flags&CODEC_FLAG_PASS2){
618         if(pict_type!=I_TYPE)
619             assert(pict_type == rce->new_pict_type);
620
621         q= rce->new_qscale / br_compensation;
622 //printf("%f %f %f last:%d var:%d type:%d//\n", q, rce->new_qscale, br_compensation, s->frame_bits, var, pict_type);
623     }else{
624         rce->pict_type= 
625         rce->new_pict_type= pict_type;
626         rce->mc_mb_var_sum= pic->mc_mb_var_sum;
627         rce->mb_var_sum   = pic->   mb_var_sum;
628         rce->qscale   = FF_QP2LAMBDA * 2;
629         rce->f_code   = s->f_code;
630         rce->b_code   = s->b_code;
631         rce->misc_bits= 1;
632
633         bits= predict_size(&rcc->pred[pict_type], rce->qscale, sqrt(var));
634         if(pict_type== I_TYPE){
635             rce->i_count   = s->mb_num;
636             rce->i_tex_bits= bits;
637             rce->p_tex_bits= 0;
638             rce->mv_bits= 0;
639         }else{
640             rce->i_count   = 0; //FIXME we do know this approx
641             rce->i_tex_bits= 0;
642             rce->p_tex_bits= bits*0.9;
643             
644             rce->mv_bits= bits*0.1;
645         }
646         rcc->i_cplx_sum [pict_type] += rce->i_tex_bits*rce->qscale;
647         rcc->p_cplx_sum [pict_type] += rce->p_tex_bits*rce->qscale;
648         rcc->mv_bits_sum[pict_type] += rce->mv_bits;
649         rcc->frame_count[pict_type] ++;
650
651         bits= rce->i_tex_bits + rce->p_tex_bits;
652         rate_factor= rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum * br_compensation;
653     
654         q= get_qscale(s, rce, rate_factor, picture_number);
655
656         assert(q>0.0);
657 //printf("%f ", q);
658         q= get_diff_limited_q(s, rce, q);
659 //printf("%f ", q);
660         assert(q>0.0);
661
662         if(pict_type==P_TYPE || s->intra_only){ //FIXME type dependant blur like in 2-pass
663             rcc->short_term_qsum*=a->qblur;
664             rcc->short_term_qcount*=a->qblur;
665
666             rcc->short_term_qsum+= q;
667             rcc->short_term_qcount++;
668 //printf("%f ", q);
669             q= short_term_q= rcc->short_term_qsum/rcc->short_term_qcount;
670 //printf("%f ", q);
671         }
672         assert(q>0.0);
673         
674         q= modify_qscale(s, rce, q, picture_number);
675
676         rcc->pass1_wanted_bits+= s->bit_rate/fps;
677
678         assert(q>0.0);
679     }
680
681     if(s->avctx->debug&FF_DEBUG_RC){
682         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",
683         av_get_pict_type_char(pict_type), qmin, q, qmax, picture_number, (int)wanted_bits/1000, (int)s->total_bits/1000,
684         br_compensation, short_term_q, s->frame_bits, pic->mb_var_sum, pic->mc_mb_var_sum, s->bit_rate/1000, (int)fps
685         );
686     }
687
688     if     (q<qmin) q=qmin; 
689     else if(q>qmax) q=qmax;
690
691     if(s->adaptive_quant)
692         adaptive_quantization(s, q);
693     else
694         q= (int)(q + 0.5);
695     
696     rcc->last_qscale= q;
697     rcc->last_mc_mb_var_sum= pic->mc_mb_var_sum;
698     rcc->last_mb_var_sum= pic->mb_var_sum;
699 #if 0
700 {
701     static int mvsum=0, texsum=0;
702     mvsum += s->mv_bits;
703     texsum += s->i_tex_bits + s->p_tex_bits;
704     printf("%d %d//\n\n", mvsum, texsum);
705 }
706 #endif
707     return q;
708 }
709
710 //----------------------------------------------
711 // 2-Pass code
712
713 static int init_pass2(MpegEncContext *s)
714 {
715     RateControlContext *rcc= &s->rc_context;
716     AVCodecContext *a= s->avctx;
717     int i;
718     double fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base;
719     double complexity[5]={0,0,0,0,0};   // aproximate bits at quant=1
720     double avg_quantizer[5];
721     uint64_t const_bits[5]={0,0,0,0,0}; // quantizer idependant bits
722     uint64_t available_bits[5];
723     uint64_t all_const_bits;
724     uint64_t all_available_bits= (uint64_t)(s->bit_rate*(double)rcc->num_entries/fps);
725     double rate_factor=0;
726     double step;
727     //int last_i_frame=-10000000;
728     const int filter_size= (int)(a->qblur*4) | 1;  
729     double expected_bits;
730     double *qscale, *blured_qscale;
731
732     /* find complexity & const_bits & decide the pict_types */
733     for(i=0; i<rcc->num_entries; i++){
734         RateControlEntry *rce= &rcc->entry[i];
735         
736         rce->new_pict_type= rce->pict_type;
737         rcc->i_cplx_sum [rce->pict_type] += rce->i_tex_bits*rce->qscale;
738         rcc->p_cplx_sum [rce->pict_type] += rce->p_tex_bits*rce->qscale;
739         rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits;
740         rcc->frame_count[rce->pict_type] ++;
741
742         complexity[rce->new_pict_type]+= (rce->i_tex_bits+ rce->p_tex_bits)*(double)rce->qscale;
743         const_bits[rce->new_pict_type]+= rce->mv_bits + rce->misc_bits;
744     }
745     all_const_bits= const_bits[I_TYPE] + const_bits[P_TYPE] + const_bits[B_TYPE];
746     
747     if(all_available_bits < all_const_bits){
748         av_log(s->avctx, AV_LOG_ERROR, "requested bitrate is to low\n");
749         return -1;
750     }
751     
752     /* find average quantizers */
753     avg_quantizer[P_TYPE]=0;
754     for(step=256*256; step>0.0000001; step*=0.5){
755         double expected_bits=0;
756         avg_quantizer[P_TYPE]+= step;
757         
758         avg_quantizer[I_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->i_quant_factor) + s->avctx->i_quant_offset;
759         avg_quantizer[B_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
760         
761         expected_bits= 
762             + all_const_bits 
763             + complexity[I_TYPE]/avg_quantizer[I_TYPE]
764             + complexity[P_TYPE]/avg_quantizer[P_TYPE]
765             + complexity[B_TYPE]/avg_quantizer[B_TYPE];
766             
767         if(expected_bits < all_available_bits) avg_quantizer[P_TYPE]-= step;
768 //printf("%f %lld %f\n", expected_bits, all_available_bits, avg_quantizer[P_TYPE]);
769     }
770 //printf("qp_i:%f, qp_p:%f, qp_b:%f\n", avg_quantizer[I_TYPE],avg_quantizer[P_TYPE],avg_quantizer[B_TYPE]);
771
772     for(i=0; i<5; i++){
773         available_bits[i]= const_bits[i] + complexity[i]/avg_quantizer[i];
774     }
775 //printf("%lld %lld %lld %lld\n", available_bits[I_TYPE], available_bits[P_TYPE], available_bits[B_TYPE], all_available_bits);
776         
777     qscale= av_malloc(sizeof(double)*rcc->num_entries);
778     blured_qscale= av_malloc(sizeof(double)*rcc->num_entries);
779
780     for(step=256*256; step>0.0000001; step*=0.5){
781         expected_bits=0;
782         rate_factor+= step;
783         
784         rcc->buffer_index= s->avctx->rc_buffer_size/2;
785
786         /* find qscale */
787         for(i=0; i<rcc->num_entries; i++){
788             qscale[i]= get_qscale(s, &rcc->entry[i], rate_factor, i);
789         }
790         assert(filter_size%2==1);
791
792         /* fixed I/B QP relative to P mode */
793         for(i=rcc->num_entries-1; i>=0; i--){
794             RateControlEntry *rce= &rcc->entry[i];
795             
796             qscale[i]= get_diff_limited_q(s, rce, qscale[i]);
797         }
798
799         /* smooth curve */
800         for(i=0; i<rcc->num_entries; i++){
801             RateControlEntry *rce= &rcc->entry[i];
802             const int pict_type= rce->new_pict_type;
803             int j;
804             double q=0.0, sum=0.0;
805         
806             for(j=0; j<filter_size; j++){
807                 int index= i+j-filter_size/2;
808                 double d= index-i;
809                 double coeff= a->qblur==0 ? 1.0 : exp(-d*d/(a->qblur * a->qblur));
810             
811                 if(index < 0 || index >= rcc->num_entries) continue;
812                 if(pict_type != rcc->entry[index].new_pict_type) continue;
813                 q+= qscale[index] * coeff;
814                 sum+= coeff;
815             }
816             blured_qscale[i]= q/sum;
817         }
818     
819         /* find expected bits */
820         for(i=0; i<rcc->num_entries; i++){
821             RateControlEntry *rce= &rcc->entry[i];
822             double bits;
823             rce->new_qscale= modify_qscale(s, rce, blured_qscale[i], i);
824             bits= qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;
825 //printf("%d %f\n", rce->new_bits, blured_qscale[i]);
826             bits += 8*ff_vbv_update(s, bits);
827
828             rce->expected_bits= expected_bits;
829             expected_bits += bits;
830         }
831
832 //        printf("%f %d %f\n", expected_bits, (int)all_available_bits, rate_factor);
833         if(expected_bits > all_available_bits) rate_factor-= step;
834     }
835     av_free(qscale);
836     av_free(blured_qscale);
837
838     if(abs(expected_bits/all_available_bits - 1.0) > 0.01 ){
839         av_log(s->avctx, AV_LOG_ERROR, "Error: 2pass curve failed to converge\n");
840         return -1;
841     }
842
843     return 0;
844 }