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