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