?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed initialisation of tf in file_open(). Without setting the memory to 0,
[cinelerra_cv/mob.git] / quicktime / ffmpeg / libavcodec / ratecontrol.c
blob0fc9caa3174fba37f34595c248016f0f2f5dca7a
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 snprintf(s->avctx->stats_out, 256, "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 skipped 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/(1/av_q2d(s->avctx->time_base)); //FIXME missbehaves a little for variable fps
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= 1/av_q2d(s->avctx->time_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= 1/av_q2d(s->avctx->time_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 const float border_masking = s->avctx->border_masking;
505 float bits_sum= 0.0;
506 float cplx_sum= 0.0;
507 float cplx_tab[s->mb_num];
508 float bits_tab[s->mb_num];
509 const int qmin= s->avctx->mb_lmin;
510 const int qmax= s->avctx->mb_lmax;
511 Picture * const pic= &s->current_picture;
512 const int mb_width = s->mb_width;
513 const int mb_height = s->mb_height;
514
515 for(i=0; i<s->mb_num; i++){
516 const int mb_xy= s->mb_index2xy[i];
517 float temp_cplx= sqrt(pic->mc_mb_var[mb_xy]); //FIXME merge in pow()
518 float spat_cplx= sqrt(pic->mb_var[mb_xy]);
519 const int lumi= pic->mb_mean[mb_xy];
520 float bits, cplx, factor;
521 int mb_x = mb_xy % s->mb_stride;
522 int mb_y = mb_xy / s->mb_stride;
523 int mb_distance;
524 float mb_factor = 0.0;
525 #if 0
526 if(spat_cplx < q/3) spat_cplx= q/3; //FIXME finetune
527 if(temp_cplx < q/3) temp_cplx= q/3; //FIXME finetune
528 #endif
529 if(spat_cplx < 4) spat_cplx= 4; //FIXME finetune
530 if(temp_cplx < 4) temp_cplx= 4; //FIXME finetune
531
532 if((s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTRA)){//FIXME hq mode
533 cplx= spat_cplx;
534 factor= 1.0 + p_masking;
535 }else{
536 cplx= temp_cplx;
537 factor= pow(temp_cplx, - temp_cplx_masking);
538 }
539 factor*=pow(spat_cplx, - spatial_cplx_masking);
540
541 if(lumi>127)
542 factor*= (1.0 - (lumi-128)*(lumi-128)*lumi_masking);
543 else
544 factor*= (1.0 - (lumi-128)*(lumi-128)*dark_masking);
545
546 if(mb_x < mb_width/5){
547 mb_distance = mb_width/5 - mb_x;
548 mb_factor = (float)mb_distance / (float)(mb_width/5);
549 }else if(mb_x > 4*mb_width/5){
550 mb_distance = mb_x - 4*mb_width/5;
551 mb_factor = (float)mb_distance / (float)(mb_width/5);
552 }
553 if(mb_y < mb_height/5){
554 mb_distance = mb_height/5 - mb_y;
555 mb_factor = FFMAX(mb_factor, (float)mb_distance / (float)(mb_height/5));
556 }else if(mb_y > 4*mb_height/5){
557 mb_distance = mb_y - 4*mb_height/5;
558 mb_factor = FFMAX(mb_factor, (float)mb_distance / (float)(mb_height/5));
559 }
560
561 factor*= 1.0 - border_masking*mb_factor;
562
563 if(factor<0.00001) factor= 0.00001;
564
565 bits= cplx*factor;
566 cplx_sum+= cplx;
567 bits_sum+= bits;
568 cplx_tab[i]= cplx;
569 bits_tab[i]= bits;
570 }
571
572 /* handle qmin/qmax cliping */
573 if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
574 float factor= bits_sum/cplx_sum;
575 for(i=0; i<s->mb_num; i++){
576 float newq= q*cplx_tab[i]/bits_tab[i];
577 newq*= factor;
578
579 if (newq > qmax){
580 bits_sum -= bits_tab[i];
581 cplx_sum -= cplx_tab[i]*q/qmax;
582 }
583 else if(newq < qmin){
584 bits_sum -= bits_tab[i];
585 cplx_sum -= cplx_tab[i]*q/qmin;
586 }
587 }
588 if(bits_sum < 0.001) bits_sum= 0.001;
589 if(cplx_sum < 0.001) cplx_sum= 0.001;
590 }
591
592 for(i=0; i<s->mb_num; i++){
593 const int mb_xy= s->mb_index2xy[i];
594 float newq= q*cplx_tab[i]/bits_tab[i];
595 int intq;
596
597 if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
598 newq*= bits_sum/cplx_sum;
599 }
600
601 intq= (int)(newq + 0.5);
602
603 if (intq > qmax) intq= qmax;
604 else if(intq < qmin) intq= qmin;
605 //if(i%s->mb_width==0) printf("\n");
606 //printf("%2d%3d ", intq, ff_sqrt(s->mc_mb_var[i]));
607 s->lambda_table[mb_xy]= intq;
608 }
609 }
610 //FIXME rd or at least approx for dquant
611
612 float ff_rate_estimate_qscale(MpegEncContext *s)
613 {
614 float q;
615 int qmin, qmax;
616 float br_compensation;
617 double diff;
618 double short_term_q;
619 double fps;
620 int picture_number= s->picture_number;
621 int64_t wanted_bits;
622 RateControlContext *rcc= &s->rc_context;
623 AVCodecContext *a= s->avctx;
624 RateControlEntry local_rce, *rce;
625 double bits;
626 double rate_factor;
627 int var;
628 const int pict_type= s->pict_type;
629 Picture * const pic= &s->current_picture;
630 emms_c();
631
632 get_qminmax(&qmin, &qmax, s, pict_type);
633
634 fps= 1/av_q2d(s->avctx->time_base);
635 //printf("input_pic_num:%d pic_num:%d frame_rate:%d\n", s->input_picture_number, s->picture_number, s->frame_rate);
636 /* update predictors */
637 if(picture_number>2){
638 const int last_var= s->last_pict_type == I_TYPE ? rcc->last_mb_var_sum : rcc->last_mc_mb_var_sum;
639 update_predictor(&rcc->pred[s->last_pict_type], rcc->last_qscale, sqrt(last_var), s->frame_bits);
640 }
641
642 if(s->flags&CODEC_FLAG_PASS2){
643 assert(picture_number>=0);
644 assert(picture_number<rcc->num_entries);
645 rce= &rcc->entry[picture_number];
646 wanted_bits= rce->expected_bits;
647 }else{
648 rce= &local_rce;
649 wanted_bits= (uint64_t)(s->bit_rate*(double)picture_number/fps);
650 }
651
652 diff= s->total_bits - wanted_bits;
653 br_compensation= (a->bit_rate_tolerance - diff)/a->bit_rate_tolerance;
654 if(br_compensation<=0.0) br_compensation=0.001;
655
656 var= pict_type == I_TYPE ? pic->mb_var_sum : pic->mc_mb_var_sum;
657
658 short_term_q = 0; /* avoid warning */
659 if(s->flags&CODEC_FLAG_PASS2){
660 if(pict_type!=I_TYPE)
661 assert(pict_type == rce->new_pict_type);
662
663 q= rce->new_qscale / br_compensation;
664 //printf("%f %f %f last:%d var:%d type:%d//\n", q, rce->new_qscale, br_compensation, s->frame_bits, var, pict_type);
665 }else{
666 rce->pict_type=
667 rce->new_pict_type= pict_type;
668 rce->mc_mb_var_sum= pic->mc_mb_var_sum;
669 rce->mb_var_sum = pic-> mb_var_sum;
670 rce->qscale = FF_QP2LAMBDA * 2;
671 rce->f_code = s->f_code;
672 rce->b_code = s->b_code;
673 rce->misc_bits= 1;
674
675 bits= predict_size(&rcc->pred[pict_type], rce->qscale, sqrt(var));
676 if(pict_type== I_TYPE){
677 rce->i_count = s->mb_num;
678 rce->i_tex_bits= bits;
679 rce->p_tex_bits= 0;
680 rce->mv_bits= 0;
681 }else{
682 rce->i_count = 0; //FIXME we do know this approx
683 rce->i_tex_bits= 0;
684 rce->p_tex_bits= bits*0.9;
685
686 rce->mv_bits= bits*0.1;
687 }
688 rcc->i_cplx_sum [pict_type] += rce->i_tex_bits*rce->qscale;
689 rcc->p_cplx_sum [pict_type] += rce->p_tex_bits*rce->qscale;
690 rcc->mv_bits_sum[pict_type] += rce->mv_bits;
691 rcc->frame_count[pict_type] ++;
692
693 bits= rce->i_tex_bits + rce->p_tex_bits;
694 rate_factor= rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum * br_compensation;
695
696 q= get_qscale(s, rce, rate_factor, picture_number);
697
698 assert(q>0.0);
699 //printf("%f ", q);
700 q= get_diff_limited_q(s, rce, q);
701 //printf("%f ", q);
702 assert(q>0.0);
703
704 if(pict_type==P_TYPE || s->intra_only){ //FIXME type dependant blur like in 2-pass
705 rcc->short_term_qsum*=a->qblur;
706 rcc->short_term_qcount*=a->qblur;
707
708 rcc->short_term_qsum+= q;
709 rcc->short_term_qcount++;
710 //printf("%f ", q);
711 q= short_term_q= rcc->short_term_qsum/rcc->short_term_qcount;
712 //printf("%f ", q);
713 }
714 assert(q>0.0);
715
716 q= modify_qscale(s, rce, q, picture_number);
717
718 rcc->pass1_wanted_bits+= s->bit_rate/fps;
719
720 assert(q>0.0);
721 }
722
723 if(s->avctx->debug&FF_DEBUG_RC){
724 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",
725 av_get_pict_type_char(pict_type), qmin, q, qmax, picture_number, (int)wanted_bits/1000, (int)s->total_bits/1000,
726 br_compensation, short_term_q, s->frame_bits, pic->mb_var_sum, pic->mc_mb_var_sum, s->bit_rate/1000, (int)fps
727 );
728 }
729
730 if (q<qmin) q=qmin;
731 else if(q>qmax) q=qmax;
732
733 if(s->adaptive_quant)
734 adaptive_quantization(s, q);
735 else
736 q= (int)(q + 0.5);
737
738 rcc->last_qscale= q;
739 rcc->last_mc_mb_var_sum= pic->mc_mb_var_sum;
740 rcc->last_mb_var_sum= pic->mb_var_sum;
741 #if 0
742 {
743 static int mvsum=0, texsum=0;
744 mvsum += s->mv_bits;
745 texsum += s->i_tex_bits + s->p_tex_bits;
746 printf("%d %d//\n\n", mvsum, texsum);
747 }
748 #endif
749 return q;
750 }
751
752 //----------------------------------------------
753 // 2-Pass code
754
755 static int init_pass2(MpegEncContext *s)
756 {
757 RateControlContext *rcc= &s->rc_context;
758 AVCodecContext *a= s->avctx;
759 int i;
760 double fps= 1/av_q2d(s->avctx->time_base);
761 double complexity[5]={0,0,0,0,0}; // aproximate bits at quant=1
762 double avg_quantizer[5];
763 uint64_t const_bits[5]={0,0,0,0,0}; // quantizer idependant bits
764 uint64_t available_bits[5];
765 uint64_t all_const_bits;
766 uint64_t all_available_bits= (uint64_t)(s->bit_rate*(double)rcc->num_entries/fps);
767 double rate_factor=0;
768 double step;
769 //int last_i_frame=-10000000;
770 const int filter_size= (int)(a->qblur*4) | 1;
771 double expected_bits;
772 double *qscale, *blured_qscale;
773
774 /* find complexity & const_bits & decide the pict_types */
775 for(i=0; i<rcc->num_entries; i++){
776 RateControlEntry *rce= &rcc->entry[i];
777
778 rce->new_pict_type= rce->pict_type;
779 rcc->i_cplx_sum [rce->pict_type] += rce->i_tex_bits*rce->qscale;
780 rcc->p_cplx_sum [rce->pict_type] += rce->p_tex_bits*rce->qscale;
781 rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits;
782 rcc->frame_count[rce->pict_type] ++;
783
784 complexity[rce->new_pict_type]+= (rce->i_tex_bits+ rce->p_tex_bits)*(double)rce->qscale;
785 const_bits[rce->new_pict_type]+= rce->mv_bits + rce->misc_bits;
786 }
787 all_const_bits= const_bits[I_TYPE] + const_bits[P_TYPE] + const_bits[B_TYPE];
788
789 if(all_available_bits < all_const_bits){
790 av_log(s->avctx, AV_LOG_ERROR, "requested bitrate is to low\n");
791 return -1;
792 }
793
794 /* find average quantizers */
795 avg_quantizer[P_TYPE]=0;
796 for(step=256*256; step>0.0000001; step*=0.5){
797 double expected_bits=0;
798 avg_quantizer[P_TYPE]+= step;
799
800 avg_quantizer[I_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->i_quant_factor) + s->avctx->i_quant_offset;
801 avg_quantizer[B_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
802
803 expected_bits=
804 + all_const_bits
805 + complexity[I_TYPE]/avg_quantizer[I_TYPE]
806 + complexity[P_TYPE]/avg_quantizer[P_TYPE]
807 + complexity[B_TYPE]/avg_quantizer[B_TYPE];
808
809 if(expected_bits < all_available_bits) avg_quantizer[P_TYPE]-= step;
810 //printf("%f %lld %f\n", expected_bits, all_available_bits, avg_quantizer[P_TYPE]);
811 }
812 //printf("qp_i:%f, qp_p:%f, qp_b:%f\n", avg_quantizer[I_TYPE],avg_quantizer[P_TYPE],avg_quantizer[B_TYPE]);
813
814 for(i=0; i<5; i++){
815 available_bits[i]= const_bits[i] + complexity[i]/avg_quantizer[i];
816 }
817 //printf("%lld %lld %lld %lld\n", available_bits[I_TYPE], available_bits[P_TYPE], available_bits[B_TYPE], all_available_bits);
818
819 qscale= av_malloc(sizeof(double)*rcc->num_entries);
820 blured_qscale= av_malloc(sizeof(double)*rcc->num_entries);
821
822 for(step=256*256; step>0.0000001; step*=0.5){
823 expected_bits=0;
824 rate_factor+= step;
825
826 rcc->buffer_index= s->avctx->rc_buffer_size/2;
827
828 /* find qscale */
829 for(i=0; i<rcc->num_entries; i++){
830 qscale[i]= get_qscale(s, &rcc->entry[i], rate_factor, i);
831 }
832 assert(filter_size%2==1);
833
834 /* fixed I/B QP relative to P mode */
835 for(i=rcc->num_entries-1; i>=0; i--){
836 RateControlEntry *rce= &rcc->entry[i];
837
838 qscale[i]= get_diff_limited_q(s, rce, qscale[i]);
839 }
840
841 /* smooth curve */
842 for(i=0; i<rcc->num_entries; i++){
843 RateControlEntry *rce= &rcc->entry[i];
844 const int pict_type= rce->new_pict_type;
845 int j;
846 double q=0.0, sum=0.0;
847
848 for(j=0; j<filter_size; j++){
849 int index= i+j-filter_size/2;
850 double d= index-i;
851 double coeff= a->qblur==0 ? 1.0 : exp(-d*d/(a->qblur * a->qblur));
852
853 if(index < 0 || index >= rcc->num_entries) continue;
854 if(pict_type != rcc->entry[index].new_pict_type) continue;
855 q+= qscale[index] * coeff;
856 sum+= coeff;
857 }
858 blured_qscale[i]= q/sum;
859 }
860
861 /* find expected bits */
862 for(i=0; i<rcc->num_entries; i++){
863 RateControlEntry *rce= &rcc->entry[i];
864 double bits;
865 rce->new_qscale= modify_qscale(s, rce, blured_qscale[i], i);
866 bits= qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;
867 //printf("%d %f\n", rce->new_bits, blured_qscale[i]);
868 bits += 8*ff_vbv_update(s, bits);
869
870 rce->expected_bits= expected_bits;
871 expected_bits += bits;
872 }
873
874 // printf("%f %d %f\n", expected_bits, (int)all_available_bits, rate_factor);
875 if(expected_bits > all_available_bits) rate_factor-= step;
876 }
877 av_free(qscale);
878 av_free(blured_qscale);
879
880 if(abs(expected_bits/all_available_bits - 1.0) > 0.01 ){
881 av_log(s->avctx, AV_LOG_ERROR, "Error: 2pass curve failed to converge\n");
882 return -1;
883 }
884
885 return 0;
886 }
mob repository