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