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