picture number fixes
[ffmpeg.git] / libavcodec / ratecontrol.c
1 /*
2  * Rate control for video encoders
3  *
4  * Copyright (c) 2002-2003 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  */
20
21 /**
22  * @file ratecontrol.c
23  * Rate control for video encoders.
24  */ 
25
26 #include "avcodec.h"
27 #include "dsputil.h"
28 #include "mpegvideo.h"
29
30 #undef NDEBUG // allways check asserts, the speed effect is far too small to disable them
31 #include <assert.h>
32
33 #ifndef M_E
34 #define M_E 2.718281828
35 #endif
36
37 static int init_pass2(MpegEncContext *s);
38 static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_factor, int frame_num);
39
40 void ff_write_pass1_stats(MpegEncContext *s){
41     sprintf(s->avctx->stats_out, "in:%d out:%d type:%d q:%d itex:%d ptex:%d mv:%d misc:%d fcode:%d bcode:%d mc-var:%d var:%d icount:%d;\n",
42             s->current_picture_ptr->display_picture_number, s->current_picture_ptr->coded_picture_number, s->pict_type, 
43             s->current_picture.quality, s->i_tex_bits, s->p_tex_bits, s->mv_bits, s->misc_bits, 
44             s->f_code, s->b_code, s->current_picture.mc_mb_var_sum, s->current_picture.mb_var_sum, s->i_count);
45 }
46
47 int ff_rate_control_init(MpegEncContext *s)
48 {
49     RateControlContext *rcc= &s->rc_context;
50     int i;
51     emms_c();
52
53     for(i=0; i<5; i++){
54         rcc->pred[i].coeff= FF_QP2LAMBDA * 7.0;
55         rcc->pred[i].count= 1.0;
56     
57         rcc->pred[i].decay= 0.4;
58         rcc->i_cplx_sum [i]=
59         rcc->p_cplx_sum [i]=
60         rcc->mv_bits_sum[i]=
61         rcc->qscale_sum [i]=
62         rcc->frame_count[i]= 1; // 1 is better cuz of 1/0 and such
63         rcc->last_qscale_for[i]=FF_QP2LAMBDA * 5;
64     }
65     rcc->buffer_index= s->avctx->rc_initial_buffer_occupancy;
66
67     if(s->flags&CODEC_FLAG_PASS2){
68         int i;
69         char *p;
70
71         /* find number of pics */
72         p= s->avctx->stats_in;
73         for(i=-1; p; i++){
74             p= strchr(p+1, ';');
75         }
76         i+= s->max_b_frames;
77         rcc->entry = (RateControlEntry*)av_mallocz(i*sizeof(RateControlEntry));
78         rcc->num_entries= i;
79         
80         /* init all to skiped p frames (with b frames we might have a not encoded frame at the end FIXME) */
81         for(i=0; i<rcc->num_entries; i++){
82             RateControlEntry *rce= &rcc->entry[i];
83             rce->pict_type= rce->new_pict_type=P_TYPE;
84             rce->qscale= rce->new_qscale=FF_QP2LAMBDA * 2;
85             rce->misc_bits= s->mb_num + 10;
86             rce->mb_var_sum= s->mb_num*100;
87         }        
88         
89         /* read stats */
90         p= s->avctx->stats_in;
91         for(i=0; i<rcc->num_entries - s->max_b_frames; i++){
92             RateControlEntry *rce;
93             int picture_number;
94             int e;
95             char *next;
96
97             next= strchr(p, ';');
98             if(next){
99                 (*next)=0; //sscanf in unbelieavle slow on looong strings //FIXME copy / dont write
100                 next++;
101             }
102             e= sscanf(p, " in:%d ", &picture_number);
103
104             assert(picture_number >= 0);
105             assert(picture_number < rcc->num_entries);
106             rce= &rcc->entry[picture_number];
107
108             e+=sscanf(p, " in:%*d out:%*d type:%d q:%f itex:%d ptex:%d mv:%d misc:%d fcode:%d bcode:%d mc-var:%d var:%d icount:%d",
109                    &rce->pict_type, &rce->qscale, &rce->i_tex_bits, &rce->p_tex_bits, &rce->mv_bits, &rce->misc_bits, 
110                    &rce->f_code, &rce->b_code, &rce->mc_mb_var_sum, &rce->mb_var_sum, &rce->i_count);
111             if(e!=12){
112                 av_log(s->avctx, AV_LOG_ERROR, "statistics are damaged at line %d, parser out=%d\n", i, e);
113                 return -1;
114             }
115             p= next;
116         }
117         
118         if(init_pass2(s) < 0) return -1;
119     }
120      
121     if(!(s->flags&CODEC_FLAG_PASS2)){
122
123         rcc->short_term_qsum=0.001;
124         rcc->short_term_qcount=0.001;
125     
126         rcc->pass1_rc_eq_output_sum= 0.001;
127         rcc->pass1_wanted_bits=0.001;
128         
129         /* init stuff with the user specified complexity */
130         if(s->avctx->rc_initial_cplx){
131             for(i=0; i<60*30; i++){
132                 double bits= s->avctx->rc_initial_cplx * (i/10000.0 + 1.0)*s->mb_num;
133                 RateControlEntry rce;
134                 double q;
135                 
136                 if     (i%((s->gop_size+3)/4)==0) rce.pict_type= I_TYPE;
137                 else if(i%(s->max_b_frames+1))    rce.pict_type= B_TYPE;
138                 else                              rce.pict_type= P_TYPE;
139
140                 rce.new_pict_type= rce.pict_type;
141                 rce.mc_mb_var_sum= bits*s->mb_num/100000;
142                 rce.mb_var_sum   = s->mb_num;
143                 rce.qscale   = FF_QP2LAMBDA * 2;
144                 rce.f_code   = 2;
145                 rce.b_code   = 1;
146                 rce.misc_bits= 1;
147
148                 if(s->pict_type== I_TYPE){
149                     rce.i_count   = s->mb_num;
150                     rce.i_tex_bits= bits;
151                     rce.p_tex_bits= 0;
152                     rce.mv_bits= 0;
153                 }else{
154                     rce.i_count   = 0; //FIXME we do know this approx
155                     rce.i_tex_bits= 0;
156                     rce.p_tex_bits= bits*0.9;
157                     rce.mv_bits= bits*0.1;
158                 }
159                 rcc->i_cplx_sum [rce.pict_type] += rce.i_tex_bits*rce.qscale;
160                 rcc->p_cplx_sum [rce.pict_type] += rce.p_tex_bits*rce.qscale;
161                 rcc->mv_bits_sum[rce.pict_type] += rce.mv_bits;
162                 rcc->frame_count[rce.pict_type] ++;
163
164                 bits= rce.i_tex_bits + rce.p_tex_bits;
165
166                 q= get_qscale(s, &rce, rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum, i);
167                 rcc->pass1_wanted_bits+= s->bit_rate/(s->avctx->frame_rate / (double)s->avctx->frame_rate_base);
168             }
169         }
170
171     }
172     
173     return 0;
174 }
175
176 void ff_rate_control_uninit(MpegEncContext *s)
177 {
178     RateControlContext *rcc= &s->rc_context;
179     emms_c();
180
181     av_freep(&rcc->entry);
182 }
183
184 static inline double qp2bits(RateControlEntry *rce, double qp){
185     if(qp<=0.0){
186         av_log(NULL, AV_LOG_ERROR, "qp<=0.0\n");
187     }
188     return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits+1)/ qp;
189 }
190
191 static inline double bits2qp(RateControlEntry *rce, double bits){
192     if(bits<0.9){
193         av_log(NULL, AV_LOG_ERROR, "bits<0.9\n");
194     }
195     return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits+1)/ bits;
196 }
197     
198 int ff_vbv_update(MpegEncContext *s, int frame_size){
199     RateControlContext *rcc= &s->rc_context;
200     const double fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base;
201     const int buffer_size= s->avctx->rc_buffer_size;
202     const double min_rate= s->avctx->rc_min_rate/fps;
203     const double max_rate= s->avctx->rc_max_rate/fps;
204     
205 //printf("%d %f %d %f %f\n", buffer_size, rcc->buffer_index, frame_size, min_rate, max_rate);
206     if(buffer_size){
207         int left;
208
209         rcc->buffer_index-= frame_size;
210         if(rcc->buffer_index < 0){
211             av_log(s->avctx, AV_LOG_ERROR, "rc buffer underflow\n");
212             rcc->buffer_index= 0;
213         }
214
215         left= buffer_size - rcc->buffer_index - 1;
216         rcc->buffer_index += clip(left, min_rate, max_rate);
217
218         if(rcc->buffer_index > buffer_size){
219             int stuffing= ceil((rcc->buffer_index - buffer_size)/8);
220             
221             if(stuffing < 4 && s->codec_id == CODEC_ID_MPEG4)
222                 stuffing=4;
223             rcc->buffer_index -= 8*stuffing;
224             
225             if(s->avctx->debug & FF_DEBUG_RC)
226                 av_log(s->avctx, AV_LOG_DEBUG, "stuffing %d bytes\n", stuffing);
227
228             return stuffing;
229         }
230     }
231     return 0;
232 }
233
234 /**
235  * modifies the bitrate curve from pass1 for one frame
236  */
237 static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_factor, int frame_num){
238     RateControlContext *rcc= &s->rc_context;
239     AVCodecContext *a= s->avctx;
240     double q, bits;
241     const int pict_type= rce->new_pict_type;
242     const double mb_num= s->mb_num;  
243     int i;
244
245     double const_values[]={
246         M_PI,
247         M_E,
248         rce->i_tex_bits*rce->qscale,
249         rce->p_tex_bits*rce->qscale,
250         (rce->i_tex_bits + rce->p_tex_bits)*(double)rce->qscale,
251         rce->mv_bits/mb_num,
252         rce->pict_type == B_TYPE ? (rce->f_code + rce->b_code)*0.5 : rce->f_code,
253         rce->i_count/mb_num,
254         rce->mc_mb_var_sum/mb_num,
255         rce->mb_var_sum/mb_num,
256         rce->pict_type == I_TYPE,
257         rce->pict_type == P_TYPE,
258         rce->pict_type == B_TYPE,
259         rcc->qscale_sum[pict_type] / (double)rcc->frame_count[pict_type],
260         a->qcompress,
261 /*        rcc->last_qscale_for[I_TYPE],
262         rcc->last_qscale_for[P_TYPE],
263         rcc->last_qscale_for[B_TYPE],
264         rcc->next_non_b_qscale,*/
265         rcc->i_cplx_sum[I_TYPE] / (double)rcc->frame_count[I_TYPE],
266         rcc->i_cplx_sum[P_TYPE] / (double)rcc->frame_count[P_TYPE],
267         rcc->p_cplx_sum[P_TYPE] / (double)rcc->frame_count[P_TYPE],
268         rcc->p_cplx_sum[B_TYPE] / (double)rcc->frame_count[B_TYPE],
269         (rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / (double)rcc->frame_count[pict_type],
270         0
271     };
272     static const char *const_names[]={
273         "PI",
274         "E",
275         "iTex",
276         "pTex",
277         "tex",
278         "mv",
279         "fCode",
280         "iCount",
281         "mcVar",
282         "var",
283         "isI",
284         "isP",
285         "isB",
286         "avgQP",
287         "qComp",
288 /*        "lastIQP",
289         "lastPQP",
290         "lastBQP",
291         "nextNonBQP",*/
292         "avgIITex",
293         "avgPITex",
294         "avgPPTex",
295         "avgBPTex",
296         "avgTex",
297         NULL
298     };
299     static double (*func1[])(void *, double)={
300         (void *)bits2qp,
301         (void *)qp2bits,
302         NULL
303     };
304     static const char *func1_names[]={
305         "bits2qp",
306         "qp2bits",
307         NULL
308     };
309
310     bits= ff_eval(s->avctx->rc_eq, const_values, const_names, func1, func1_names, NULL, NULL, rce);
311     
312     rcc->pass1_rc_eq_output_sum+= bits;
313     bits*=rate_factor;
314     if(bits<0.0) bits=0.0;
315     bits+= 1.0; //avoid 1/0 issues
316     
317     /* user override */
318     for(i=0; i<s->avctx->rc_override_count; i++){
319         RcOverride *rco= s->avctx->rc_override;
320         if(rco[i].start_frame > frame_num) continue;
321         if(rco[i].end_frame   < frame_num) continue;
322     
323         if(rco[i].qscale) 
324             bits= qp2bits(rce, rco[i].qscale); //FIXME move at end to really force it?
325         else
326             bits*= rco[i].quality_factor;
327     }
328
329     q= bits2qp(rce, bits);
330     
331     /* I/B difference */
332     if     (pict_type==I_TYPE && s->avctx->i_quant_factor<0.0)
333         q= -q*s->avctx->i_quant_factor + s->avctx->i_quant_offset;
334     else if(pict_type==B_TYPE && s->avctx->b_quant_factor<0.0)
335         q= -q*s->avctx->b_quant_factor + s->avctx->b_quant_offset;
336         
337     return q;
338 }
339
340 static double get_diff_limited_q(MpegEncContext *s, RateControlEntry *rce, double q){
341     RateControlContext *rcc= &s->rc_context;
342     AVCodecContext *a= s->avctx;
343     const int pict_type= rce->new_pict_type;
344     const double last_p_q    = rcc->last_qscale_for[P_TYPE];
345     const double last_non_b_q= rcc->last_qscale_for[rcc->last_non_b_pict_type];
346     
347     if     (pict_type==I_TYPE && (a->i_quant_factor>0.0 || rcc->last_non_b_pict_type==P_TYPE))
348         q= last_p_q    *ABS(a->i_quant_factor) + a->i_quant_offset;
349     else if(pict_type==B_TYPE && a->b_quant_factor>0.0)
350         q= last_non_b_q*    a->b_quant_factor  + a->b_quant_offset;
351
352     /* last qscale / qdiff stuff */
353     if(rcc->last_non_b_pict_type==pict_type || pict_type!=I_TYPE){
354         double last_q= rcc->last_qscale_for[pict_type];
355         const int maxdiff= FF_QP2LAMBDA * a->max_qdiff;
356
357         if     (q > last_q + maxdiff) q= last_q + maxdiff;
358         else if(q < last_q - maxdiff) q= last_q - maxdiff;
359     }
360
361     rcc->last_qscale_for[pict_type]= q; //Note we cant do that after blurring
362     
363     if(pict_type!=B_TYPE)
364         rcc->last_non_b_pict_type= pict_type;
365
366     return q;
367 }
368
369 /**
370  * gets the qmin & qmax for pict_type
371  */
372 static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type){
373     int qmin= s->avctx->lmin;                                                       
374     int qmax= s->avctx->lmax;
375     
376     assert(qmin <= qmax);
377
378     if(pict_type==B_TYPE){
379         qmin= (int)(qmin*ABS(s->avctx->b_quant_factor)+s->avctx->b_quant_offset + 0.5);
380         qmax= (int)(qmax*ABS(s->avctx->b_quant_factor)+s->avctx->b_quant_offset + 0.5);
381     }else if(pict_type==I_TYPE){
382         qmin= (int)(qmin*ABS(s->avctx->i_quant_factor)+s->avctx->i_quant_offset + 0.5);
383         qmax= (int)(qmax*ABS(s->avctx->i_quant_factor)+s->avctx->i_quant_offset + 0.5);
384     }
385
386     qmin= clip(qmin, 1, FF_LAMBDA_MAX);
387     qmax= clip(qmax, 1, FF_LAMBDA_MAX);
388
389     if(qmax<qmin) qmax= qmin;
390     
391     *qmin_ret= qmin;
392     *qmax_ret= qmax;
393 }
394
395 static double modify_qscale(MpegEncContext *s, RateControlEntry *rce, double q, int frame_num){
396     RateControlContext *rcc= &s->rc_context;
397     int qmin, qmax;
398     double bits;
399     const int pict_type= rce->new_pict_type;
400     const double buffer_size= s->avctx->rc_buffer_size;
401     const double fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base;
402     const double min_rate= s->avctx->rc_min_rate / fps;
403     const double max_rate= s->avctx->rc_max_rate / fps;
404     
405     get_qminmax(&qmin, &qmax, s, pict_type);
406
407     /* modulation */
408     if(s->avctx->rc_qmod_freq && frame_num%s->avctx->rc_qmod_freq==0 && pict_type==P_TYPE)
409         q*= s->avctx->rc_qmod_amp;
410
411     bits= qp2bits(rce, q);
412 //printf("q:%f\n", q);
413     /* buffer overflow/underflow protection */
414     if(buffer_size){
415         double expected_size= rcc->buffer_index;
416         double q_limit;
417
418         if(min_rate){
419             double d= 2*(buffer_size - expected_size)/buffer_size;
420             if(d>1.0) d=1.0;
421             else if(d<0.0001) d=0.0001;
422             q*= pow(d, 1.0/s->avctx->rc_buffer_aggressivity);
423
424             q_limit= bits2qp(rce, FFMAX((min_rate - buffer_size + rcc->buffer_index)*3, 1));
425             if(q > q_limit){
426                 if(s->avctx->debug&FF_DEBUG_RC){
427                     av_log(s->avctx, AV_LOG_DEBUG, "limiting QP %f -> %f\n", q, q_limit);
428                 }
429                 q= q_limit;
430             }
431         }
432
433         if(max_rate){
434             double d= 2*expected_size/buffer_size;
435             if(d>1.0) d=1.0;
436             else if(d<0.0001) d=0.0001;
437             q/= pow(d, 1.0/s->avctx->rc_buffer_aggressivity);
438
439             q_limit= bits2qp(rce, FFMAX(rcc->buffer_index/3, 1));
440             if(q < q_limit){
441                 if(s->avctx->debug&FF_DEBUG_RC){
442                     av_log(s->avctx, AV_LOG_DEBUG, "limiting QP %f -> %f\n", q, q_limit);
443                 }
444                 q= q_limit;
445             }
446         }
447     }
448 //printf("q:%f max:%f min:%f size:%f index:%d bits:%f agr:%f\n", q,max_rate, min_rate, buffer_size, rcc->buffer_index, bits, s->avctx->rc_buffer_aggressivity);
449     if(s->avctx->rc_qsquish==0.0 || qmin==qmax){
450         if     (q<qmin) q=qmin;
451         else if(q>qmax) q=qmax;
452     }else{
453         double min2= log(qmin);
454         double max2= log(qmax);
455         
456         q= log(q);
457         q= (q - min2)/(max2-min2) - 0.5;
458         q*= -4.0;
459         q= 1.0/(1.0 + exp(q));
460         q= q*(max2-min2) + min2;
461         
462         q= exp(q);
463     }
464     
465     return q;
466 }
467
468 //----------------------------------
469 // 1 Pass Code
470
471 static double predict_size(Predictor *p, double q, double var)
472 {
473      return p->coeff*var / (q*p->count);
474 }
475
476 /*
477 static double predict_qp(Predictor *p, double size, double var)
478 {
479 //printf("coeff:%f, count:%f, var:%f, size:%f//\n", p->coeff, p->count, var, size);
480      return p->coeff*var / (size*p->count);
481 }
482 */
483
484 static void update_predictor(Predictor *p, double q, double var, double size)
485 {
486     double new_coeff= size*q / (var + 1);
487     if(var<10) return;
488
489     p->count*= p->decay;
490     p->coeff*= p->decay;
491     p->count++;
492     p->coeff+= new_coeff;
493 }
494
495 static void adaptive_quantization(MpegEncContext *s, double q){
496     int i;
497     const float lumi_masking= s->avctx->lumi_masking / (128.0*128.0);
498     const float dark_masking= s->avctx->dark_masking / (128.0*128.0);
499     const float temp_cplx_masking= s->avctx->temporal_cplx_masking;
500     const float spatial_cplx_masking = s->avctx->spatial_cplx_masking;
501     const float p_masking = s->avctx->p_masking;
502     float bits_sum= 0.0;
503     float cplx_sum= 0.0;
504     float cplx_tab[s->mb_num];
505     float bits_tab[s->mb_num];
506     const int qmin= s->avctx->lmin;
507     const int qmax= s->avctx->lmax;
508     Picture * const pic= &s->current_picture;
509     
510     for(i=0; i<s->mb_num; i++){
511         const int mb_xy= s->mb_index2xy[i];
512         float temp_cplx= sqrt(pic->mc_mb_var[mb_xy]); //FIXME merge in pow()
513         float spat_cplx= sqrt(pic->mb_var[mb_xy]);
514         const int lumi= pic->mb_mean[mb_xy];
515         float bits, cplx, factor;
516 #if 0        
517         if(spat_cplx < q/3) spat_cplx= q/3; //FIXME finetune
518         if(temp_cplx < q/3) temp_cplx= q/3; //FIXME finetune
519 #endif   
520         if(spat_cplx < 4) spat_cplx= 4; //FIXME finetune
521         if(temp_cplx < 4) temp_cplx= 4; //FIXME finetune
522
523         if((s->mb_type[mb_xy]&MB_TYPE_INTRA)){//FIXME hq mode 
524             cplx= spat_cplx;
525             factor= 1.0 + p_masking;
526         }else{
527             cplx= temp_cplx;
528             factor= pow(temp_cplx, - temp_cplx_masking);
529         }
530         factor*=pow(spat_cplx, - spatial_cplx_masking);
531
532         if(lumi>127)
533             factor*= (1.0 - (lumi-128)*(lumi-128)*lumi_masking);
534         else
535             factor*= (1.0 - (lumi-128)*(lumi-128)*dark_masking);
536         
537         if(factor<0.00001) factor= 0.00001;
538         
539         bits= cplx*factor;
540         cplx_sum+= cplx;
541         bits_sum+= bits;
542         cplx_tab[i]= cplx;
543         bits_tab[i]= bits;
544     }
545
546     /* handle qmin/qmax cliping */
547     if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
548         for(i=0; i<s->mb_num; i++){
549             float newq= q*cplx_tab[i]/bits_tab[i];
550             newq*= bits_sum/cplx_sum;
551
552             if     (newq > qmax){
553                 bits_sum -= bits_tab[i];
554                 cplx_sum -= cplx_tab[i]*q/qmax;
555             }
556             else if(newq < qmin){
557                 bits_sum -= bits_tab[i];
558                 cplx_sum -= cplx_tab[i]*q/qmin;
559             }
560         }
561     }
562    
563     for(i=0; i<s->mb_num; i++){
564         const int mb_xy= s->mb_index2xy[i];
565         float newq= q*cplx_tab[i]/bits_tab[i];
566         int intq;
567
568         if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
569             newq*= bits_sum/cplx_sum;
570         }
571
572         intq= (int)(newq + 0.5);
573
574         if     (intq > qmax) intq= qmax;
575         else if(intq < qmin) intq= qmin;
576 //if(i%s->mb_width==0) printf("\n");
577 //printf("%2d%3d ", intq, ff_sqrt(s->mc_mb_var[i]));
578         s->lambda_table[mb_xy]= intq;
579     }
580 }
581 //FIXME rd or at least approx for dquant
582
583 float ff_rate_estimate_qscale(MpegEncContext *s)
584 {
585     float q;
586     int qmin, qmax;
587     float br_compensation;
588     double diff;
589     double short_term_q;
590     double fps;
591     int picture_number= s->picture_number;
592     int64_t wanted_bits;
593     RateControlContext *rcc= &s->rc_context;
594     AVCodecContext *a= s->avctx;
595     RateControlEntry local_rce, *rce;
596     double bits;
597     double rate_factor;
598     int var;
599     const int pict_type= s->pict_type;
600     Picture * const pic= &s->current_picture;
601     emms_c();
602
603     get_qminmax(&qmin, &qmax, s, pict_type);
604
605     fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base;
606 //printf("input_pic_num:%d pic_num:%d frame_rate:%d\n", s->input_picture_number, s->picture_number, s->frame_rate);
607         /* update predictors */
608     if(picture_number>2){
609         const int last_var= s->last_pict_type == I_TYPE ? rcc->last_mb_var_sum : rcc->last_mc_mb_var_sum;
610         update_predictor(&rcc->pred[s->last_pict_type], rcc->last_qscale, sqrt(last_var), s->frame_bits);
611     }
612
613     if(s->flags&CODEC_FLAG_PASS2){
614         assert(picture_number>=0);
615         assert(picture_number<rcc->num_entries);
616         rce= &rcc->entry[picture_number];
617         wanted_bits= rce->expected_bits;
618     }else{
619         rce= &local_rce;
620         wanted_bits= (uint64_t)(s->bit_rate*(double)picture_number/fps);
621     }
622
623     diff= s->total_bits - wanted_bits;
624     br_compensation= (a->bit_rate_tolerance - diff)/a->bit_rate_tolerance;
625     if(br_compensation<=0.0) br_compensation=0.001;
626
627     var= pict_type == I_TYPE ? pic->mb_var_sum : pic->mc_mb_var_sum;
628     
629     short_term_q = 0; /* avoid warning */
630     if(s->flags&CODEC_FLAG_PASS2){
631         if(pict_type!=I_TYPE)
632             assert(pict_type == rce->new_pict_type);
633
634         q= rce->new_qscale / br_compensation;
635 //printf("%f %f %f last:%d var:%d type:%d//\n", q, rce->new_qscale, br_compensation, s->frame_bits, var, pict_type);
636     }else{
637         rce->pict_type= 
638         rce->new_pict_type= pict_type;
639         rce->mc_mb_var_sum= pic->mc_mb_var_sum;
640         rce->mb_var_sum   = pic->   mb_var_sum;
641         rce->qscale   = FF_QP2LAMBDA * 2;
642         rce->f_code   = s->f_code;
643         rce->b_code   = s->b_code;
644         rce->misc_bits= 1;
645
646         bits= predict_size(&rcc->pred[pict_type], rce->qscale, sqrt(var));
647         if(pict_type== I_TYPE){
648             rce->i_count   = s->mb_num;
649             rce->i_tex_bits= bits;
650             rce->p_tex_bits= 0;
651             rce->mv_bits= 0;
652         }else{
653             rce->i_count   = 0; //FIXME we do know this approx
654             rce->i_tex_bits= 0;
655             rce->p_tex_bits= bits*0.9;
656             
657             rce->mv_bits= bits*0.1;
658         }
659         rcc->i_cplx_sum [pict_type] += rce->i_tex_bits*rce->qscale;
660         rcc->p_cplx_sum [pict_type] += rce->p_tex_bits*rce->qscale;
661         rcc->mv_bits_sum[pict_type] += rce->mv_bits;
662         rcc->frame_count[pict_type] ++;
663
664         bits= rce->i_tex_bits + rce->p_tex_bits;
665         rate_factor= rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum * br_compensation;
666     
667         q= get_qscale(s, rce, rate_factor, picture_number);
668
669         assert(q>0.0);
670 //printf("%f ", q);
671         q= get_diff_limited_q(s, rce, q);
672 //printf("%f ", q);
673         assert(q>0.0);
674
675         if(pict_type==P_TYPE || s->intra_only){ //FIXME type dependant blur like in 2-pass
676             rcc->short_term_qsum*=a->qblur;
677             rcc->short_term_qcount*=a->qblur;
678
679             rcc->short_term_qsum+= q;
680             rcc->short_term_qcount++;
681 //printf("%f ", q);
682             q= short_term_q= rcc->short_term_qsum/rcc->short_term_qcount;
683 //printf("%f ", q);
684         }
685         assert(q>0.0);
686         
687         q= modify_qscale(s, rce, q, picture_number);
688
689         rcc->pass1_wanted_bits+= s->bit_rate/fps;
690
691         assert(q>0.0);
692     }
693
694     if(s->avctx->debug&FF_DEBUG_RC){
695         av_log(s->avctx, AV_LOG_DEBUG, "%c qp:%d<%2.1f<%d %d want:%d total:%d comp:%f st_q:%2.2f size:%d var:%d/%d br:%d fps:%d\n",
696         av_get_pict_type_char(pict_type), qmin, q, qmax, picture_number, (int)wanted_bits/1000, (int)s->total_bits/1000,
697         br_compensation, short_term_q, s->frame_bits, pic->mb_var_sum, pic->mc_mb_var_sum, s->bit_rate/1000, (int)fps
698         );
699     }
700
701     if     (q<qmin) q=qmin; 
702     else if(q>qmax) q=qmax;
703
704     if(s->adaptive_quant)
705         adaptive_quantization(s, q);
706     else
707         q= (int)(q + 0.5);
708     
709     rcc->last_qscale= q;
710     rcc->last_mc_mb_var_sum= pic->mc_mb_var_sum;
711     rcc->last_mb_var_sum= pic->mb_var_sum;
712 #if 0
713 {
714     static int mvsum=0, texsum=0;
715     mvsum += s->mv_bits;
716     texsum += s->i_tex_bits + s->p_tex_bits;
717     printf("%d %d//\n\n", mvsum, texsum);
718 }
719 #endif
720     return q;
721 }
722
723 //----------------------------------------------
724 // 2-Pass code
725
726 static int init_pass2(MpegEncContext *s)
727 {
728     RateControlContext *rcc= &s->rc_context;
729     AVCodecContext *a= s->avctx;
730     int i;
731     double fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base;
732     double complexity[5]={0,0,0,0,0};   // aproximate bits at quant=1
733     double avg_quantizer[5];
734     uint64_t const_bits[5]={0,0,0,0,0}; // quantizer idependant bits
735     uint64_t available_bits[5];
736     uint64_t all_const_bits;
737     uint64_t all_available_bits= (uint64_t)(s->bit_rate*(double)rcc->num_entries/fps);
738     double rate_factor=0;
739     double step;
740     //int last_i_frame=-10000000;
741     const int filter_size= (int)(a->qblur*4) | 1;  
742     double expected_bits;
743     double *qscale, *blured_qscale;
744
745     /* find complexity & const_bits & decide the pict_types */
746     for(i=0; i<rcc->num_entries; i++){
747         RateControlEntry *rce= &rcc->entry[i];
748         
749         rce->new_pict_type= rce->pict_type;
750         rcc->i_cplx_sum [rce->pict_type] += rce->i_tex_bits*rce->qscale;
751         rcc->p_cplx_sum [rce->pict_type] += rce->p_tex_bits*rce->qscale;
752         rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits;
753         rcc->frame_count[rce->pict_type] ++;
754
755         complexity[rce->new_pict_type]+= (rce->i_tex_bits+ rce->p_tex_bits)*(double)rce->qscale;
756         const_bits[rce->new_pict_type]+= rce->mv_bits + rce->misc_bits;
757     }
758     all_const_bits= const_bits[I_TYPE] + const_bits[P_TYPE] + const_bits[B_TYPE];
759     
760     if(all_available_bits < all_const_bits){
761         av_log(s->avctx, AV_LOG_ERROR, "requested bitrate is to low\n");
762         return -1;
763     }
764     
765     /* find average quantizers */
766     avg_quantizer[P_TYPE]=0;
767     for(step=256*256; step>0.0000001; step*=0.5){
768         double expected_bits=0;
769         avg_quantizer[P_TYPE]+= step;
770         
771         avg_quantizer[I_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->i_quant_factor) + s->avctx->i_quant_offset;
772         avg_quantizer[B_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
773         
774         expected_bits= 
775             + all_const_bits 
776             + complexity[I_TYPE]/avg_quantizer[I_TYPE]
777             + complexity[P_TYPE]/avg_quantizer[P_TYPE]
778             + complexity[B_TYPE]/avg_quantizer[B_TYPE];
779             
780         if(expected_bits < all_available_bits) avg_quantizer[P_TYPE]-= step;
781 //printf("%f %lld %f\n", expected_bits, all_available_bits, avg_quantizer[P_TYPE]);
782     }
783 //printf("qp_i:%f, qp_p:%f, qp_b:%f\n", avg_quantizer[I_TYPE],avg_quantizer[P_TYPE],avg_quantizer[B_TYPE]);
784
785     for(i=0; i<5; i++){
786         available_bits[i]= const_bits[i] + complexity[i]/avg_quantizer[i];
787     }
788 //printf("%lld %lld %lld %lld\n", available_bits[I_TYPE], available_bits[P_TYPE], available_bits[B_TYPE], all_available_bits);
789         
790     qscale= av_malloc(sizeof(double)*rcc->num_entries);
791     blured_qscale= av_malloc(sizeof(double)*rcc->num_entries);
792
793     for(step=256*256; step>0.0000001; step*=0.5){
794         expected_bits=0;
795         rate_factor+= step;
796         
797         rcc->buffer_index= s->avctx->rc_buffer_size/2;
798
799         /* find qscale */
800         for(i=0; i<rcc->num_entries; i++){
801             qscale[i]= get_qscale(s, &rcc->entry[i], rate_factor, i);
802         }
803         assert(filter_size%2==1);
804
805         /* fixed I/B QP relative to P mode */
806         for(i=rcc->num_entries-1; i>=0; i--){
807             RateControlEntry *rce= &rcc->entry[i];
808             
809             qscale[i]= get_diff_limited_q(s, rce, qscale[i]);
810         }
811
812         /* smooth curve */
813         for(i=0; i<rcc->num_entries; i++){
814             RateControlEntry *rce= &rcc->entry[i];
815             const int pict_type= rce->new_pict_type;
816             int j;
817             double q=0.0, sum=0.0;
818         
819             for(j=0; j<filter_size; j++){
820                 int index= i+j-filter_size/2;
821                 double d= index-i;
822                 double coeff= a->qblur==0 ? 1.0 : exp(-d*d/(a->qblur * a->qblur));
823             
824                 if(index < 0 || index >= rcc->num_entries) continue;
825                 if(pict_type != rcc->entry[index].new_pict_type) continue;
826                 q+= qscale[index] * coeff;
827                 sum+= coeff;
828             }
829             blured_qscale[i]= q/sum;
830         }
831     
832         /* find expected bits */
833         for(i=0; i<rcc->num_entries; i++){
834             RateControlEntry *rce= &rcc->entry[i];
835             double bits;
836             rce->new_qscale= modify_qscale(s, rce, blured_qscale[i], i);
837             bits= qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;
838 //printf("%d %f\n", rce->new_bits, blured_qscale[i]);
839             bits += 8*ff_vbv_update(s, bits);
840
841             rce->expected_bits= expected_bits;
842             expected_bits += bits;
843         }
844
845 //        printf("%f %d %f\n", expected_bits, (int)all_available_bits, rate_factor);
846         if(expected_bits > all_available_bits) rate_factor-= step;
847     }
848     av_free(qscale);
849     av_free(blured_qscale);
850
851     if(abs(expected_bits/all_available_bits - 1.0) > 0.01 ){
852         av_log(s->avctx, AV_LOG_ERROR, "Error: 2pass curve failed to converge\n");
853         return -1;
854     }
855
856     return 0;
857 }