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