3593c68bf6eedf7d2d1398e1ac904e5b416c23c6
[libav.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->current_picture.mc_mb_var_sum, s->current_picture.mb_var_sum, s->i_count);
45 }
46
47 int ff_rate_control_init(MpegEncContext *s)
48 {
49 RateControlContext *rcc= &s->rc_context;
50 int i;
51 emms_c();
52
53 for(i=0; i<5; i++){
54 rcc->pred[i].coeff= 7.0;
55 rcc->pred[i].count= 1.0;
56
57 rcc->pred[i].decay= 0.4;
58 rcc->i_cplx_sum [i]=
59 rcc->p_cplx_sum [i]=
60 rcc->mv_bits_sum[i]=
61 rcc->qscale_sum [i]=
62 rcc->frame_count[i]= 1; // 1 is better cuz of 1/0 and such
63 rcc->last_qscale_for[i]=5;
64 }
65 rcc->buffer_index= s->avctx->rc_buffer_size/2;
66
67 if(s->flags&CODEC_FLAG_PASS2){
68 int i;
69 char *p;
70
71 /* find number of pics */
72 p= s->avctx->stats_in;
73 for(i=-1; p; i++){
74 p= strchr(p+1, ';');
75 }
76 i+= s->max_b_frames;
77 rcc->entry = (RateControlEntry*)av_mallocz(i*sizeof(RateControlEntry));
78 rcc->num_entries= i;
79
80 /* init all to skiped p frames (with b frames we might have a not encoded frame at the end FIXME) */
81 for(i=0; i<rcc->num_entries; i++){
82 RateControlEntry *rce= &rcc->entry[i];
83 rce->pict_type= rce->new_pict_type=P_TYPE;
84 rce->qscale= rce->new_qscale=2;
85 rce->misc_bits= s->mb_num + 10;
86 rce->mb_var_sum= s->mb_num*100;
87 }
88
89 /* read stats */
90 p= s->avctx->stats_in;
91 for(i=0; i<rcc->num_entries - s->max_b_frames; i++){
92 RateControlEntry *rce;
93 int picture_number;
94 int e;
95 char *next;
96
97 next= strchr(p, ';');
98 if(next){
99 (*next)=0; //sscanf in unbelieavle slow on looong strings //FIXME copy / dont write
100 next++;
101 }
102 e= sscanf(p, " in:%d ", &picture_number);
103
104 assert(picture_number >= 0);
105 assert(picture_number < rcc->num_entries);
106 rce= &rcc->entry[picture_number];
107
108 e+=sscanf(p, " in:%*d out:%*d type:%d q:%f itex:%d ptex:%d mv:%d misc:%d fcode:%d bcode:%d mc-var:%d var:%d icount:%d",
109 &rce->pict_type, &rce->qscale, &rce->i_tex_bits, &rce->p_tex_bits, &rce->mv_bits, &rce->misc_bits,
110 &rce->f_code, &rce->b_code, &rce->mc_mb_var_sum, &rce->mb_var_sum, &rce->i_count);
111 if(e!=12){
112 fprintf(stderr, "statistics are damaged at line %d, parser out=%d\n", i, e);
113 return -1;
114 }
115 p= next;
116 }
117
118 if(init_pass2(s) < 0) return -1;
119 }
120
121 if(!(s->flags&CODEC_FLAG_PASS2)){
122
123 rcc->short_term_qsum=0.001;
124 rcc->short_term_qcount=0.001;
125
126 rcc->pass1_rc_eq_output_sum= 0.001;
127 rcc->pass1_wanted_bits=0.001;
128
129 /* init stuff with the user specified complexity */
130 if(s->avctx->rc_initial_cplx){
131 for(i=0; i<60*30; i++){
132 double bits= s->avctx->rc_initial_cplx * (i/10000.0 + 1.0)*s->mb_num;
133 RateControlEntry rce;
134 double q;
135
136 if (i%((s->gop_size+3)/4)==0) rce.pict_type= I_TYPE;
137 else if(i%(s->max_b_frames+1)) rce.pict_type= B_TYPE;
138 else rce.pict_type= P_TYPE;
139
140 rce.new_pict_type= rce.pict_type;
141 rce.mc_mb_var_sum= bits*s->mb_num/100000;
142 rce.mb_var_sum = s->mb_num;
143 rce.qscale = 2;
144 rce.f_code = 2;
145 rce.b_code = 1;
146 rce.misc_bits= 1;
147
148 if(s->pict_type== I_TYPE){
149 rce.i_count = s->mb_num;
150 rce.i_tex_bits= bits;
151 rce.p_tex_bits= 0;
152 rce.mv_bits= 0;
153 }else{
154 rce.i_count = 0; //FIXME we do know this approx
155 rce.i_tex_bits= 0;
156 rce.p_tex_bits= bits*0.9;
157 rce.mv_bits= bits*0.1;
158 }
159 rcc->i_cplx_sum [rce.pict_type] += rce.i_tex_bits*rce.qscale;
160 rcc->p_cplx_sum [rce.pict_type] += rce.p_tex_bits*rce.qscale;
161 rcc->mv_bits_sum[rce.pict_type] += rce.mv_bits;
162 rcc->frame_count[rce.pict_type] ++;
163
164 bits= rce.i_tex_bits + rce.p_tex_bits;
165
166 q= get_qscale(s, &rce, rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum, i);
167 rcc->pass1_wanted_bits+= s->bit_rate/(s->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 (void *)bits2qp,
288 (void *)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_rc_eq_output_sum+= bits;
300 bits*=rate_factor;
301 if(bits<0.0) bits=0.0;
302 bits+= 1.0; //avoid 1/0 issues
303
304 /* user override */
305 for(i=0; i<s->avctx->rc_override_count; i++){
306 RcOverride *rco= s->avctx->rc_override;
307 if(rco[i].start_frame > frame_num) continue;
308 if(rco[i].end_frame < frame_num) continue;
309
310 if(rco[i].qscale)
311 bits= qp2bits(rce, rco[i].qscale); //FIXME move at end to really force it?
312 else
313 bits*= rco[i].quality_factor;
314 }
315
316 q= bits2qp(rce, bits);
317
318 /* I/B difference */
319 if (pict_type==I_TYPE && s->avctx->i_quant_factor<0.0)
320 q= -q*s->avctx->i_quant_factor + s->avctx->i_quant_offset;
321 else if(pict_type==B_TYPE && s->avctx->b_quant_factor<0.0)
322 q= -q*s->avctx->b_quant_factor + s->avctx->b_quant_offset;
323
324 return q;
325 }
326
327 static double get_diff_limited_q(MpegEncContext *s, RateControlEntry *rce, double q){
328 RateControlContext *rcc= &s->rc_context;
329 AVCodecContext *a= s->avctx;
330 const int pict_type= rce->new_pict_type;
331 const double last_p_q = rcc->last_qscale_for[P_TYPE];
332 const double last_non_b_q= rcc->last_qscale_for[rcc->last_non_b_pict_type];
333
334 if (pict_type==I_TYPE && (a->i_quant_factor>0.0 || rcc->last_non_b_pict_type==P_TYPE))
335 q= last_p_q *ABS(a->i_quant_factor) + a->i_quant_offset;
336 else if(pict_type==B_TYPE && a->b_quant_factor>0.0)
337 q= last_non_b_q* a->b_quant_factor + a->b_quant_offset;
338
339 /* last qscale / qdiff stuff */
340 if(rcc->last_non_b_pict_type==pict_type || pict_type!=I_TYPE){
341 double last_q= rcc->last_qscale_for[pict_type];
342
343 if (q > last_q + a->max_qdiff) q= last_q + a->max_qdiff;
344 else if(q < last_q - a->max_qdiff) q= last_q - a->max_qdiff;
345 }
346
347 rcc->last_qscale_for[pict_type]= q; //Note we cant do that after blurring
348
349 if(pict_type!=B_TYPE)
350 rcc->last_non_b_pict_type= pict_type;
351
352 return q;
353 }
354
355 /**
356 * gets the qmin & qmax for pict_type
357 */
358 static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type){
359 int qmin= s->qmin;
360 int qmax= s->qmax;
361
362 if(pict_type==B_TYPE){
363 qmin= (int)(qmin*ABS(s->avctx->b_quant_factor)+s->avctx->b_quant_offset + 0.5);
364 qmax= (int)(qmax*ABS(s->avctx->b_quant_factor)+s->avctx->b_quant_offset + 0.5);
365 }else if(pict_type==I_TYPE){
366 qmin= (int)(qmin*ABS(s->avctx->i_quant_factor)+s->avctx->i_quant_offset + 0.5);
367 qmax= (int)(qmax*ABS(s->avctx->i_quant_factor)+s->avctx->i_quant_offset + 0.5);
368 }
369
370 if(qmin<1) qmin=1;
371 if(qmin==1 && s->qmin>1) qmin=2; //avoid qmin=1 unless the user wants qmin=1
372
373 if(qmin<3 && s->max_qcoeff<=128 && pict_type==I_TYPE) qmin=3; //reduce cliping problems
374
375 if(qmax>31) qmax=31;
376 if(qmax<=qmin) qmax= qmin= (qmax+qmin+1)>>1;
377
378 *qmin_ret= qmin;
379 *qmax_ret= qmax;
380 }
381
382 static double modify_qscale(MpegEncContext *s, RateControlEntry *rce, double q, int frame_num){
383 RateControlContext *rcc= &s->rc_context;
384 int qmin, qmax;
385 double bits;
386 const int pict_type= rce->new_pict_type;
387 const double buffer_size= s->avctx->rc_buffer_size;
388 const double min_rate= s->avctx->rc_min_rate;
389 const double max_rate= s->avctx->rc_max_rate;
390
391 get_qminmax(&qmin, &qmax, s, pict_type);
392
393 /* modulation */
394 if(s->avctx->rc_qmod_freq && frame_num%s->avctx->rc_qmod_freq==0 && pict_type==P_TYPE)
395 q*= s->avctx->rc_qmod_amp;
396
397 bits= qp2bits(rce, q);
398 //printf("q:%f\n", q);
399 /* buffer overflow/underflow protection */
400 if(buffer_size){
401 double expected_size= rcc->buffer_index;
402
403 if(min_rate){
404 double d= 2*(buffer_size - expected_size)/buffer_size;
405 if(d>1.0) d=1.0;
406 else if(d<0.0001) d=0.0001;
407 q*= pow(d, 1.0/s->avctx->rc_buffer_aggressivity);
408
409 q= FFMIN(q, bits2qp(rce, FFMAX((min_rate - buffer_size + rcc->buffer_index)*2, 1)));
410 }
411
412 if(max_rate){
413 double d= 2*expected_size/buffer_size;
414 if(d>1.0) d=1.0;
415 else if(d<0.0001) d=0.0001;
416 q/= pow(d, 1.0/s->avctx->rc_buffer_aggressivity);
417
418 q= FFMAX(q, bits2qp(rce, FFMAX(rcc->buffer_index/2, 1)));
419 }
420 }
421 //printf("q:%f max:%f min:%f size:%f index:%d bits:%f agr:%f\n", q,max_rate, min_rate, buffer_size, rcc->buffer_index, bits, s->avctx->rc_buffer_aggressivity);
422 if(s->avctx->rc_qsquish==0.0 || qmin==qmax){
423 if (q<qmin) q=qmin;
424 else if(q>qmax) q=qmax;
425 }else{
426 double min2= log(qmin);
427 double max2= log(qmax);
428
429 q= log(q);
430 q= (q - min2)/(max2-min2) - 0.5;
431 q*= -4.0;
432 q= 1.0/(1.0 + exp(q));
433 q= q*(max2-min2) + min2;
434
435 q= exp(q);
436 }
437
438 return q;
439 }
440
441 //----------------------------------
442 // 1 Pass Code
443
444 static double predict_size(Predictor *p, double q, double var)
445 {
446 return p->coeff*var / (q*p->count);
447 }
448
449 /*
450 static double predict_qp(Predictor *p, double size, double var)
451 {
452 //printf("coeff:%f, count:%f, var:%f, size:%f//\n", p->coeff, p->count, var, size);
453 return p->coeff*var / (size*p->count);
454 }
455 */
456
457 static void update_predictor(Predictor *p, double q, double var, double size)
458 {
459 double new_coeff= size*q / (var + 1);
460 if(var<10) return;
461
462 p->count*= p->decay;
463 p->coeff*= p->decay;
464 p->count++;
465 p->coeff+= new_coeff;
466 }
467
468 static void adaptive_quantization(MpegEncContext *s, double q){
469 int i;
470 const float lumi_masking= s->avctx->lumi_masking / (128.0*128.0);
471 const float dark_masking= s->avctx->dark_masking / (128.0*128.0);
472 const float temp_cplx_masking= s->avctx->temporal_cplx_masking;
473 const float spatial_cplx_masking = s->avctx->spatial_cplx_masking;
474 const float p_masking = s->avctx->p_masking;
475 float bits_sum= 0.0;
476 float cplx_sum= 0.0;
477 float cplx_tab[s->mb_num];
478 float bits_tab[s->mb_num];
479 const int qmin= s->avctx->mb_qmin;
480 const int qmax= s->avctx->mb_qmax;
481 Picture * const pic= &s->current_picture;
482
483 for(i=0; i<s->mb_num; i++){
484 float temp_cplx= sqrt(pic->mc_mb_var[i]);
485 float spat_cplx= sqrt(pic->mb_var[i]);
486 const int lumi= pic->mb_mean[i];
487 float bits, cplx, factor;
488
489 if(spat_cplx < q/3) spat_cplx= q/3; //FIXME finetune
490 if(temp_cplx < q/3) temp_cplx= q/3; //FIXME finetune
491
492 if((s->mb_type[i]&MB_TYPE_INTRA)){//FIXME hq mode
493 cplx= spat_cplx;
494 factor= 1.0 + p_masking;
495 }else{
496 cplx= temp_cplx;
497 factor= pow(temp_cplx, - temp_cplx_masking);
498 }
499 factor*=pow(spat_cplx, - spatial_cplx_masking);
500
501 if(lumi>127)
502 factor*= (1.0 - (lumi-128)*(lumi-128)*lumi_masking);
503 else
504 factor*= (1.0 - (lumi-128)*(lumi-128)*dark_masking);
505
506 if(factor<0.00001) factor= 0.00001;
507
508 bits= cplx*factor;
509 cplx_sum+= cplx;
510 bits_sum+= bits;
511 cplx_tab[i]= cplx;
512 bits_tab[i]= bits;
513 }
514
515 /* handle qmin/qmax cliping */
516 if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
517 for(i=0; i<s->mb_num; i++){
518 float newq= q*cplx_tab[i]/bits_tab[i];
519 newq*= bits_sum/cplx_sum;
520
521 if (newq > qmax){
522 bits_sum -= bits_tab[i];
523 cplx_sum -= cplx_tab[i]*q/qmax;
524 }
525 else if(newq < qmin){
526 bits_sum -= bits_tab[i];
527 cplx_sum -= cplx_tab[i]*q/qmin;
528 }
529 }
530 }
531
532 for(i=0; i<s->mb_num; i++){
533 float newq= q*cplx_tab[i]/bits_tab[i];
534 int intq;
535
536 if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
537 newq*= bits_sum/cplx_sum;
538 }
539
540 if(i && ABS(pic->qscale_table[i-1] - newq)<0.75)
541 intq= pic->qscale_table[i-1];
542 else
543 intq= (int)(newq + 0.5);
544
545 if (intq > qmax) intq= qmax;
546 else if(intq < qmin) intq= qmin;
547 //if(i%s->mb_width==0) printf("\n");
548 //printf("%2d%3d ", intq, ff_sqrt(s->mc_mb_var[i]));
549 pic->qscale_table[i]= intq;
550 }
551 }
552
553 float ff_rate_estimate_qscale(MpegEncContext *s)
554 {
555 float q;
556 int qmin, qmax;
557 float br_compensation;
558 double diff;
559 double short_term_q;
560 double fps;
561 int picture_number= s->picture_number;
562 int64_t wanted_bits;
563 RateControlContext *rcc= &s->rc_context;
564 RateControlEntry local_rce, *rce;
565 double bits;
566 double rate_factor;
567 int var;
568 const int pict_type= s->pict_type;
569 Picture * const pic= &s->current_picture;
570 emms_c();
571
572 get_qminmax(&qmin, &qmax, s, pict_type);
573
574 fps= (double)s->frame_rate / FRAME_RATE_BASE;
575 //printf("input_pic_num:%d pic_num:%d frame_rate:%d\n", s->input_picture_number, s->picture_number, s->frame_rate);
576 /* update predictors */
577 if(picture_number>2){
578 const int last_var= s->last_pict_type == I_TYPE ? rcc->last_mb_var_sum : rcc->last_mc_mb_var_sum;
579 update_predictor(&rcc->pred[s->last_pict_type], rcc->last_qscale, sqrt(last_var), s->frame_bits);
580 }
581
582 if(s->flags&CODEC_FLAG_PASS2){
583 assert(picture_number>=0);
584 assert(picture_number<rcc->num_entries);
585 rce= &rcc->entry[picture_number];
586 wanted_bits= rce->expected_bits;
587 }else{
588 rce= &local_rce;
589 wanted_bits= (uint64_t)(s->bit_rate*(double)picture_number/fps);
590 }
591
592 diff= s->total_bits - wanted_bits;
593 br_compensation= (s->bit_rate_tolerance - diff)/s->bit_rate_tolerance;
594 if(br_compensation<=0.0) br_compensation=0.001;
595
596 var= pict_type == I_TYPE ? pic->mb_var_sum : pic->mc_mb_var_sum;
597
598 if(s->flags&CODEC_FLAG_PASS2){
599 if(pict_type!=I_TYPE)
600 assert(pict_type == rce->new_pict_type);
601
602 q= rce->new_qscale / br_compensation;
603 //printf("%f %f %f last:%d var:%d type:%d//\n", q, rce->new_qscale, br_compensation, s->frame_bits, var, pict_type);
604 }else{
605 rce->pict_type=
606 rce->new_pict_type= pict_type;
607 rce->mc_mb_var_sum= pic->mc_mb_var_sum;
608 rce->mb_var_sum = pic-> mb_var_sum;
609 rce->qscale = 2;
610 rce->f_code = s->f_code;
611 rce->b_code = s->b_code;
612 rce->misc_bits= 1;
613
614 if(picture_number>0)
615 update_rc_buffer(s, s->frame_bits);
616
617 bits= predict_size(&rcc->pred[pict_type], rce->qscale, sqrt(var));
618 if(pict_type== I_TYPE){
619 rce->i_count = s->mb_num;
620 rce->i_tex_bits= bits;
621 rce->p_tex_bits= 0;
622 rce->mv_bits= 0;
623 }else{
624 rce->i_count = 0; //FIXME we do know this approx
625 rce->i_tex_bits= 0;
626 rce->p_tex_bits= bits*0.9;
627
628 rce->mv_bits= bits*0.1;
629 }
630 rcc->i_cplx_sum [pict_type] += rce->i_tex_bits*rce->qscale;
631 rcc->p_cplx_sum [pict_type] += rce->p_tex_bits*rce->qscale;
632 rcc->mv_bits_sum[pict_type] += rce->mv_bits;
633 rcc->frame_count[pict_type] ++;
634
635 bits= rce->i_tex_bits + rce->p_tex_bits;
636 rate_factor= rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum * br_compensation;
637
638 q= get_qscale(s, rce, rate_factor, picture_number);
639
640 assert(q>0.0);
641 //printf("%f ", q);
642 q= get_diff_limited_q(s, rce, q);
643 //printf("%f ", q);
644 assert(q>0.0);
645
646 if(pict_type==P_TYPE || s->intra_only){ //FIXME type dependant blur like in 2-pass
647 rcc->short_term_qsum*=s->qblur;
648 rcc->short_term_qcount*=s->qblur;
649
650 rcc->short_term_qsum+= q;
651 rcc->short_term_qcount++;
652 //printf("%f ", q);
653 q= short_term_q= rcc->short_term_qsum/rcc->short_term_qcount;
654 //printf("%f ", q);
655 }
656 assert(q>0.0);
657
658 q= modify_qscale(s, rce, q, picture_number);
659
660 rcc->pass1_wanted_bits+= s->bit_rate/fps;
661
662 assert(q>0.0);
663 }
664
665 if(s->avctx->debug&FF_DEBUG_RC){
666 printf("%c qp:%d<%2.1f<%d %d want:%d total:%d comp:%f st_q:%2.2f size:%d var:%d/%d br:%d fps:%d\n",
667 ff_get_pict_type_char(pict_type), qmin, q, qmax, picture_number, (int)wanted_bits/1000, (int)s->total_bits/1000,
668 br_compensation, short_term_q, s->frame_bits, pic->mb_var_sum, pic->mc_mb_var_sum, s->bit_rate/1000, (int)fps
669 );
670 }
671
672 if (q<qmin) q=qmin;
673 else if(q>qmax) q=qmax;
674
675 if(s->adaptive_quant)
676 adaptive_quantization(s, q);
677 else
678 q= (int)(q + 0.5);
679
680 rcc->last_qscale= q;
681 rcc->last_mc_mb_var_sum= pic->mc_mb_var_sum;
682 rcc->last_mb_var_sum= pic->mb_var_sum;
683 #if 0
684 {
685 static int mvsum=0, texsum=0;
686 mvsum += s->mv_bits;
687 texsum += s->i_tex_bits + s->p_tex_bits;
688 printf("%d %d//\n\n", mvsum, texsum);
689 }
690 #endif
691 return q;
692 }
693
694 //----------------------------------------------
695 // 2-Pass code
696
697 static int init_pass2(MpegEncContext *s)
698 {
699 RateControlContext *rcc= &s->rc_context;
700 int i;
701 double fps= (double)s->frame_rate / FRAME_RATE_BASE;
702 double complexity[5]={0,0,0,0,0}; // aproximate bits at quant=1
703 double avg_quantizer[5];
704 uint64_t const_bits[5]={0,0,0,0,0}; // quantizer idependant bits
705 uint64_t available_bits[5];
706 uint64_t all_const_bits;
707 uint64_t all_available_bits= (uint64_t)(s->bit_rate*(double)rcc->num_entries/fps);
708 double rate_factor=0;
709 double step;
710 //int last_i_frame=-10000000;
711 const int filter_size= (int)(s->qblur*4) | 1;
712 double expected_bits;
713 double *qscale, *blured_qscale;
714
715 /* find complexity & const_bits & decide the pict_types */
716 for(i=0; i<rcc->num_entries; i++){
717 RateControlEntry *rce= &rcc->entry[i];
718
719 rce->new_pict_type= rce->pict_type;
720 rcc->i_cplx_sum [rce->pict_type] += rce->i_tex_bits*rce->qscale;
721 rcc->p_cplx_sum [rce->pict_type] += rce->p_tex_bits*rce->qscale;
722 rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits;
723 rcc->frame_count[rce->pict_type] ++;
724
725 complexity[rce->new_pict_type]+= (rce->i_tex_bits+ rce->p_tex_bits)*(double)rce->qscale;
726 const_bits[rce->new_pict_type]+= rce->mv_bits + rce->misc_bits;
727 }
728 all_const_bits= const_bits[I_TYPE] + const_bits[P_TYPE] + const_bits[B_TYPE];
729
730 if(all_available_bits < all_const_bits){
731 fprintf(stderr, "requested bitrate is to low\n");
732 return -1;
733 }
734
735 /* find average quantizers */
736 avg_quantizer[P_TYPE]=0;
737 for(step=256*256; step>0.0000001; step*=0.5){
738 double expected_bits=0;
739 avg_quantizer[P_TYPE]+= step;
740
741 avg_quantizer[I_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->i_quant_factor) + s->avctx->i_quant_offset;
742 avg_quantizer[B_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
743
744 expected_bits=
745 + all_const_bits
746 + complexity[I_TYPE]/avg_quantizer[I_TYPE]
747 + complexity[P_TYPE]/avg_quantizer[P_TYPE]
748 + complexity[B_TYPE]/avg_quantizer[B_TYPE];
749
750 if(expected_bits < all_available_bits) avg_quantizer[P_TYPE]-= step;
751 //printf("%f %lld %f\n", expected_bits, all_available_bits, avg_quantizer[P_TYPE]);
752 }
753 //printf("qp_i:%f, qp_p:%f, qp_b:%f\n", avg_quantizer[I_TYPE],avg_quantizer[P_TYPE],avg_quantizer[B_TYPE]);
754
755 for(i=0; i<5; i++){
756 available_bits[i]= const_bits[i] + complexity[i]/avg_quantizer[i];
757 }
758 //printf("%lld %lld %lld %lld\n", available_bits[I_TYPE], available_bits[P_TYPE], available_bits[B_TYPE], all_available_bits);
759
760 qscale= malloc(sizeof(double)*rcc->num_entries);
761 blured_qscale= malloc(sizeof(double)*rcc->num_entries);
762
763 for(step=256*256; step>0.0000001; step*=0.5){
764 expected_bits=0;
765 rate_factor+= step;
766
767 rcc->buffer_index= s->avctx->rc_buffer_size/2;
768
769 /* find qscale */
770 for(i=0; i<rcc->num_entries; i++){
771 qscale[i]= get_qscale(s, &rcc->entry[i], rate_factor, i);
772 }
773 assert(filter_size%2==1);
774
775 /* fixed I/B QP relative to P mode */
776 for(i=rcc->num_entries-1; i>=0; i--){
777 RateControlEntry *rce= &rcc->entry[i];
778
779 qscale[i]= get_diff_limited_q(s, rce, qscale[i]);
780 }
781
782 /* smooth curve */
783 for(i=0; i<rcc->num_entries; i++){
784 RateControlEntry *rce= &rcc->entry[i];
785 const int pict_type= rce->new_pict_type;
786 int j;
787 double q=0.0, sum=0.0;
788
789 for(j=0; j<filter_size; j++){
790 int index= i+j-filter_size/2;
791 double d= index-i;
792 double coeff= s->qblur==0 ? 1.0 : exp(-d*d/(s->qblur * s->qblur));
793
794 if(index < 0 || index >= rcc->num_entries) continue;
795 if(pict_type != rcc->entry[index].new_pict_type) continue;
796 q+= qscale[index] * coeff;
797 sum+= coeff;
798 }
799 blured_qscale[i]= q/sum;
800 }
801
802 /* find expected bits */
803 for(i=0; i<rcc->num_entries; i++){
804 RateControlEntry *rce= &rcc->entry[i];
805 double bits;
806 rce->new_qscale= modify_qscale(s, rce, blured_qscale[i], i);
807 bits= qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;
808 //printf("%d %f\n", rce->new_bits, blured_qscale[i]);
809 update_rc_buffer(s, bits);
810
811 rce->expected_bits= expected_bits;
812 expected_bits += bits;
813 }
814
815 // printf("%f %d %f\n", expected_bits, (int)all_available_bits, rate_factor);
816 if(expected_bits > all_available_bits) rate_factor-= step;
817 }
818 free(qscale);
819 free(blured_qscale);
820
821 if(abs(expected_bits/all_available_bits - 1.0) > 0.01 ){
822 fprintf(stderr, "Error: 2pass curve failed to converge\n");
823 return -1;
824 }
825
826 return 0;
827 }