ps2 idct patch by (Leon van Stuivenberg <leonvs at iae dot nl>)
[libav.git] / libavcodec / ratecontrol.c
CommitLineData
8b4c7dbc 1/*
2ef0f2b2
FB
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 */
3aa102be
MN
20#include <math.h>
21#include "common.h"
8b4c7dbc 22#include "avcodec.h"
2ef0f2b2 23#include "dsputil.h"
8b4c7dbc
MN
24#include "mpegvideo.h"
25
3aa102be
MN
26#undef NDEBUG // allways check asserts, the speed effect is far too small to disable them
27#include <assert.h>
8b4c7dbc 28
471d7dc3
MN
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
8b4c7dbc 37static int init_pass2(MpegEncContext *s);
3aa102be 38static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_factor, int frame_num);
8b4c7dbc
MN
39
40void ff_write_pass1_stats(MpegEncContext *s){
3aa102be 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",
8b4c7dbc 42 s->picture_number, s->input_picture_number - s->max_b_frames, s->pict_type,
3aa102be
MN
43 s->qscale, s->i_tex_bits, s->p_tex_bits, s->mv_bits, s->misc_bits,
44 s->f_code, s->b_code, s->mc_mb_var_sum, s->mb_var_sum, s->i_count);
8b4c7dbc
MN
45}
46
47int ff_rate_control_init(MpegEncContext *s)
48{
49 RateControlContext *rcc= &s->rc_context;
3aa102be 50 int i;
8b4c7dbc
MN
51 emms_c();
52
3aa102be
MN
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
3aa102be 67 if(s->flags&CODEC_FLAG_PASS2){
8b4c7dbc 68 int i;
3aa102be 69 char *p;
8b4c7dbc 70
3aa102be
MN
71 /* find number of pics */
72 p= s->avctx->stats_in;
73 for(i=-1; p; i++){
74 p= strchr(p+1, ';');
8b4c7dbc 75 }
3aa102be
MN
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++){
8b4c7dbc
MN
92 RateControlEntry *rce;
93 int picture_number;
94 int e;
3aa102be
MN
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);
8b4c7dbc 106 rce= &rcc->entry[picture_number];
3aa102be
MN
107
108 e+=sscanf(p, " 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",
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);
8b4c7dbc
MN
113 return -1;
114 }
3aa102be 115 p= next;
8b4c7dbc 116 }
8b4c7dbc
MN
117
118 if(init_pass2(s) < 0) return -1;
119 }
120
3aa102be
MN
121 if(!(s->flags&CODEC_FLAG_PASS2)){
122
123 rcc->short_term_qsum=0.001;
124 rcc->short_term_qcount=0.001;
8b4c7dbc 125
3aa102be
MN
126 rcc->pass1_bits =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] ++;
8b4c7dbc 163
3aa102be 164 bits= rce.i_tex_bits + rce.p_tex_bits;
8b4c7dbc 165
3aa102be
MN
166 q= get_qscale(s, &rce, rcc->pass1_wanted_bits/rcc->pass1_bits, i);
167 rcc->pass1_wanted_bits+= s->bit_rate/(s->frame_rate / (double)FRAME_RATE_BASE);
168 }
169 }
170
171 }
172
8b4c7dbc
MN
173 return 0;
174}
175
176void ff_rate_control_uninit(MpegEncContext *s)
177{
178 RateControlContext *rcc= &s->rc_context;
179 emms_c();
180
6000abfa 181 av_freep(&rcc->entry);
8b4c7dbc
MN
182}
183
3aa102be
MN
184static 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
191static 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
198static 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 */
225static 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;
3aa102be
MN
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 };
07787186 286 static double (*func1[])(void *, double)={
3aa102be
MN
287 bits2qp,
288 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_bits+= 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;
6a1f7e7b
MN
323
324 return q;
325}
326
327static 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
3aa102be 339 /* last qscale / qdiff stuff */
6a1f7e7b
MN
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 if (q > last_q + a->max_qdiff) q= last_q + a->max_qdiff;
343 else if(q < last_q - a->max_qdiff) q= last_q - a->max_qdiff;
344 }
3aa102be
MN
345
346 rcc->last_qscale_for[pict_type]= q; //Note we cant do that after blurring
347
6a1f7e7b
MN
348 if(pict_type!=B_TYPE)
349 rcc->last_non_b_pict_type= pict_type;
350
3aa102be
MN
351 return q;
352}
353
354/**
355 * gets the qmin & qmax for pict_type
356 */
357static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type){
358 int qmin= s->qmin;
359 int qmax= s->qmax;
360
361 if(pict_type==B_TYPE){
362 qmin= (int)(qmin*ABS(s->avctx->b_quant_factor)+s->avctx->b_quant_offset + 0.5);
363 qmax= (int)(qmax*ABS(s->avctx->b_quant_factor)+s->avctx->b_quant_offset + 0.5);
364 }else if(pict_type==I_TYPE){
365 qmin= (int)(qmin*ABS(s->avctx->i_quant_factor)+s->avctx->i_quant_offset + 0.5);
366 qmax= (int)(qmax*ABS(s->avctx->i_quant_factor)+s->avctx->i_quant_offset + 0.5);
367 }
368
369 if(qmin<1) qmin=1;
370 if(qmin==1 && s->qmin>1) qmin=2; //avoid qmin=1 unless the user wants qmin=1
371
372 if(qmin<3 && s->max_qcoeff<=128 && pict_type==I_TYPE) qmin=3; //reduce cliping problems
373
374 if(qmax>31) qmax=31;
375 if(qmax<=qmin) qmax= qmin= (qmax+qmin+1)>>1;
376
377 *qmin_ret= qmin;
378 *qmax_ret= qmax;
379}
380
381static double modify_qscale(MpegEncContext *s, RateControlEntry *rce, double q, int frame_num){
382 RateControlContext *rcc= &s->rc_context;
383 int qmin, qmax;
384 double bits;
385 const int pict_type= rce->new_pict_type;
386 const double buffer_size= s->avctx->rc_buffer_size;
387 const double min_rate= s->avctx->rc_min_rate;
388 const double max_rate= s->avctx->rc_max_rate;
389
390 get_qminmax(&qmin, &qmax, s, pict_type);
391
392 /* modulation */
393 if(s->avctx->rc_qmod_freq && frame_num%s->avctx->rc_qmod_freq==0 && pict_type==P_TYPE)
394 q*= s->avctx->rc_qmod_amp;
395
396 bits= qp2bits(rce, q);
946c8a12 397//printf("q:%f\n", q);
3aa102be
MN
398 /* buffer overflow/underflow protection */
399 if(buffer_size){
6a1f7e7b 400 double expected_size= rcc->buffer_index;
3aa102be
MN
401
402 if(min_rate){
6a1f7e7b 403 double d= 2*(buffer_size - expected_size)/buffer_size;
3aa102be 404 if(d>1.0) d=1.0;
946c8a12
MN
405 else if(d<0.0001) d=0.0001;
406 q*= pow(d, 1.0/s->avctx->rc_buffer_aggressivity);
6a1f7e7b
MN
407
408 q= MIN(q, bits2qp(rce, MAX((min_rate - buffer_size + rcc->buffer_index)*2, 1)));
3aa102be
MN
409 }
410
411 if(max_rate){
412 double d= 2*expected_size/buffer_size;
413 if(d>1.0) d=1.0;
946c8a12
MN
414 else if(d<0.0001) d=0.0001;
415 q/= pow(d, 1.0/s->avctx->rc_buffer_aggressivity);
6a1f7e7b
MN
416
417 q= MAX(q, bits2qp(rce, MAX(rcc->buffer_index/2, 1)));
3aa102be
MN
418 }
419 }
946c8a12 420//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);
c695ca3b 421 if(s->avctx->rc_qsquish==0.0 || qmin==qmax){
3aa102be
MN
422 if (q<qmin) q=qmin;
423 else if(q>qmax) q=qmax;
424 }else{
425 double min2= log(qmin);
426 double max2= log(qmax);
427
428 q= log(q);
429 q= (q - min2)/(max2-min2) - 0.5;
430 q*= -4.0;
431 q= 1.0/(1.0 + exp(q));
432 q= q*(max2-min2) + min2;
433
434 q= exp(q);
435 }
436
437 return q;
438}
439
8b4c7dbc
MN
440//----------------------------------
441// 1 Pass Code
442
3aa102be 443static double predict_size(Predictor *p, double q, double var)
8b4c7dbc
MN
444{
445 return p->coeff*var / (q*p->count);
446}
447
3aa102be
MN
448static double predict_qp(Predictor *p, double size, double var)
449{
450//printf("coeff:%f, count:%f, var:%f, size:%f//\n", p->coeff, p->count, var, size);
451 return p->coeff*var / (size*p->count);
452}
453
8b4c7dbc
MN
454static void update_predictor(Predictor *p, double q, double var, double size)
455{
456 double new_coeff= size*q / (var + 1);
3aa102be 457 if(var<10) return;
8b4c7dbc
MN
458
459 p->count*= p->decay;
460 p->coeff*= p->decay;
461 p->count++;
462 p->coeff+= new_coeff;
463}
464
465int ff_rate_estimate_qscale(MpegEncContext *s)
466{
8b4c7dbc 467 float q;
3aa102be 468 int qscale, qmin, qmax;
8b4c7dbc
MN
469 float br_compensation;
470 double diff;
471 double short_term_q;
8b4c7dbc 472 double fps;
3aa102be 473 int picture_number= s->picture_number;
8b4c7dbc 474 int64_t wanted_bits;
3aa102be
MN
475 RateControlContext *rcc= &s->rc_context;
476 RateControlEntry local_rce, *rce;
477 double bits;
478 double rate_factor;
479 int var;
480 const int pict_type= s->pict_type;
8b4c7dbc
MN
481 emms_c();
482
3aa102be 483 get_qminmax(&qmin, &qmax, s, pict_type);
8b4c7dbc 484
3aa102be 485 fps= (double)s->frame_rate / FRAME_RATE_BASE;
946c8a12 486//printf("input_pic_num:%d pic_num:%d frame_rate:%d\n", s->input_picture_number, s->picture_number, s->frame_rate);
8b4c7dbc
MN
487 /* update predictors */
488 if(picture_number>2){
3aa102be
MN
489 const int last_var= s->last_pict_type == I_TYPE ? rcc->last_mb_var_sum : rcc->last_mc_mb_var_sum;
490 update_predictor(&rcc->pred[s->last_pict_type], rcc->last_qscale, sqrt(last_var), s->frame_bits);
8b4c7dbc
MN
491 }
492
3aa102be
MN
493 if(s->flags&CODEC_FLAG_PASS2){
494 assert(picture_number>=0);
495 assert(picture_number<rcc->num_entries);
496 rce= &rcc->entry[picture_number];
497 wanted_bits= rce->expected_bits;
498 }else{
499 rce= &local_rce;
500 wanted_bits= (uint64_t)(s->bit_rate*(double)picture_number/fps);
501 }
8b4c7dbc 502
3aa102be
MN
503 diff= s->total_bits - wanted_bits;
504 br_compensation= (s->bit_rate_tolerance - diff)/s->bit_rate_tolerance;
505 if(br_compensation<=0.0) br_compensation=0.001;
506
507 var= pict_type == I_TYPE ? s->mb_var_sum : s->mc_mb_var_sum;
508
509 if(s->flags&CODEC_FLAG_PASS2){
510 if(pict_type!=I_TYPE)
511 assert(pict_type == rce->new_pict_type);
512
513 q= rce->new_qscale / br_compensation;
514//printf("%f %f %f last:%d var:%d type:%d//\n", q, rce->new_qscale, br_compensation, s->frame_bits, var, pict_type);
515 }else{
516 rce->pict_type=
517 rce->new_pict_type= pict_type;
518 rce->mc_mb_var_sum= s->mc_mb_var_sum;
519 rce->mb_var_sum = s-> mb_var_sum;
520 rce->qscale = 2;
521 rce->f_code = s->f_code;
522 rce->b_code = s->b_code;
523 rce->misc_bits= 1;
524
525 if(picture_number>0)
526 update_rc_buffer(s, s->frame_bits);
527
528 bits= predict_size(&rcc->pred[pict_type], rce->qscale, sqrt(var));
529 if(pict_type== I_TYPE){
530 rce->i_count = s->mb_num;
531 rce->i_tex_bits= bits;
532 rce->p_tex_bits= 0;
533 rce->mv_bits= 0;
534 }else{
535 rce->i_count = 0; //FIXME we do know this approx
536 rce->i_tex_bits= 0;
537 rce->p_tex_bits= bits*0.9;
538
539 rce->mv_bits= bits*0.1;
8b4c7dbc 540 }
3aa102be
MN
541 rcc->i_cplx_sum [pict_type] += rce->i_tex_bits*rce->qscale;
542 rcc->p_cplx_sum [pict_type] += rce->p_tex_bits*rce->qscale;
543 rcc->mv_bits_sum[pict_type] += rce->mv_bits;
544 rcc->frame_count[pict_type] ++;
8b4c7dbc 545
3aa102be
MN
546 bits= rce->i_tex_bits + rce->p_tex_bits;
547 rate_factor= rcc->pass1_wanted_bits/rcc->pass1_bits * br_compensation;
8b4c7dbc 548
3aa102be 549 q= get_qscale(s, rce, rate_factor, picture_number);
8b4c7dbc 550
c695ca3b 551 assert(q>0.0);
3aa102be 552//printf("%f ", q);
6a1f7e7b 553 q= get_diff_limited_q(s, rce, q);
3aa102be
MN
554//printf("%f ", q);
555 assert(q>0.0);
556
557 if(pict_type==P_TYPE || s->intra_only){ //FIXME type dependant blur like in 2-pass
558 rcc->short_term_qsum*=s->qblur;
559 rcc->short_term_qcount*=s->qblur;
560
561 rcc->short_term_qsum+= q;
562 rcc->short_term_qcount++;
563//printf("%f ", q);
564 q= short_term_q= rcc->short_term_qsum/rcc->short_term_qcount;
565//printf("%f ", q);
566 }
946c8a12
MN
567 assert(q>0.0);
568
3aa102be
MN
569 q= modify_qscale(s, rce, q, picture_number);
570
571 rcc->pass1_wanted_bits+= s->bit_rate/fps;
572
c695ca3b 573 assert(q>0.0);
8b4c7dbc 574 }
3aa102be
MN
575//printf("qmin:%d, qmax:%d, q:%f\n", qmin, qmax, q);
576
577
578 if (q<qmin) q=qmin;
579 else if(q>qmax) q=qmax;
580
581// printf("%f %d %d %d\n", q, picture_number, (int)wanted_bits, (int)s->total_bits);
582
8b4c7dbc
MN
583//printf("%f %f %f\n", q, br_compensation, short_term_q);
584 qscale= (int)(q + 0.5);
8b4c7dbc 585
6a1f7e7b
MN
586//printf("q:%d diff:%d comp:%f st_q:%f last_size:%d type:%d\n", qscale, (int)diff, br_compensation,
587// short_term_q, s->frame_bits, pict_type);
8b4c7dbc 588//printf("%d %d\n", s->bit_rate, (int)fps);
3aa102be
MN
589
590 rcc->last_qscale= qscale;
591 rcc->last_mc_mb_var_sum= s->mc_mb_var_sum;
592 rcc->last_mb_var_sum= s->mb_var_sum;
8b4c7dbc
MN
593 return qscale;
594}
595
596//----------------------------------------------
597// 2-Pass code
598
599static int init_pass2(MpegEncContext *s)
600{
601 RateControlContext *rcc= &s->rc_context;
602 int i;
603 double fps= (double)s->frame_rate / FRAME_RATE_BASE;
604 double complexity[5]={0,0,0,0,0}; // aproximate bits at quant=1
605 double avg_quantizer[5];
606 uint64_t const_bits[5]={0,0,0,0,0}; // quantizer idependant bits
607 uint64_t available_bits[5];
608 uint64_t all_const_bits;
609 uint64_t all_available_bits= (uint64_t)(s->bit_rate*(double)rcc->num_entries/fps);
8b4c7dbc
MN
610 double rate_factor=0;
611 double step;
612 int last_i_frame=-10000000;
3aa102be
MN
613 const int filter_size= (int)(s->qblur*4) | 1;
614 double expected_bits;
615 double *qscale, *blured_qscale;
8b4c7dbc
MN
616
617 /* find complexity & const_bits & decide the pict_types */
618 for(i=0; i<rcc->num_entries; i++){
619 RateControlEntry *rce= &rcc->entry[i];
620
621 if(s->b_frame_strategy==0 || s->max_b_frames==0){
622 rce->new_pict_type= rce->pict_type;
623 }else{
624 int j;
625 int next_non_b_type=P_TYPE;
626
627 switch(rce->pict_type){
628 case I_TYPE:
629 if(i-last_i_frame>s->gop_size/2){ //FIXME this is not optimal
630 rce->new_pict_type= I_TYPE;
631 last_i_frame= i;
632 }else{
633 rce->new_pict_type= P_TYPE; // will be caught by the scene detection anyway
634 }
635 break;
636 case P_TYPE:
637 rce->new_pict_type= P_TYPE;
638 break;
639 case B_TYPE:
640 for(j=i+1; j<i+s->max_b_frames+2 && j<rcc->num_entries; j++){
641 if(rcc->entry[j].pict_type != B_TYPE){
642 next_non_b_type= rcc->entry[j].pict_type;
643 break;
644 }
645 }
646 if(next_non_b_type==I_TYPE)
647 rce->new_pict_type= P_TYPE;
648 else
649 rce->new_pict_type= B_TYPE;
650 break;
651 }
652 }
3aa102be
MN
653 rcc->i_cplx_sum [rce->pict_type] += rce->i_tex_bits*rce->qscale;
654 rcc->p_cplx_sum [rce->pict_type] += rce->p_tex_bits*rce->qscale;
655 rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits;
656 rcc->frame_count[rce->pict_type] ++;
8b4c7dbc
MN
657
658 complexity[rce->new_pict_type]+= (rce->i_tex_bits+ rce->p_tex_bits)*(double)rce->qscale;
659 const_bits[rce->new_pict_type]+= rce->mv_bits + rce->misc_bits;
8b4c7dbc
MN
660 }
661 all_const_bits= const_bits[I_TYPE] + const_bits[P_TYPE] + const_bits[B_TYPE];
662
663 if(all_available_bits < all_const_bits){
664 fprintf(stderr, "requested bitrate is to low\n");
665 return -1;
666 }
3aa102be
MN
667
668 /* find average quantizers */
669 avg_quantizer[P_TYPE]=0;
670 for(step=256*256; step>0.0000001; step*=0.5){
671 double expected_bits=0;
672 avg_quantizer[P_TYPE]+= step;
673
674 avg_quantizer[I_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->i_quant_factor) + s->avctx->i_quant_offset;
675 avg_quantizer[B_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
676
677 expected_bits=
678 + all_const_bits
679 + complexity[I_TYPE]/avg_quantizer[I_TYPE]
680 + complexity[P_TYPE]/avg_quantizer[P_TYPE]
681 + complexity[B_TYPE]/avg_quantizer[B_TYPE];
682
683 if(expected_bits < all_available_bits) avg_quantizer[P_TYPE]-= step;
684//printf("%f %lld %f\n", expected_bits, all_available_bits, avg_quantizer[P_TYPE]);
685 }
405469ce 686//printf("qp_i:%f, qp_p:%f, qp_b:%f\n", avg_quantizer[I_TYPE],avg_quantizer[P_TYPE],avg_quantizer[B_TYPE]);
8b4c7dbc
MN
687
688 for(i=0; i<5; i++){
689 available_bits[i]= const_bits[i] + complexity[i]/avg_quantizer[i];
690 }
691//printf("%lld %lld %lld %lld\n", available_bits[I_TYPE], available_bits[P_TYPE], available_bits[B_TYPE], all_available_bits);
3aa102be
MN
692
693 qscale= malloc(sizeof(double)*rcc->num_entries);
694 blured_qscale= malloc(sizeof(double)*rcc->num_entries);
695
8b4c7dbc 696 for(step=256*256; step>0.0000001; step*=0.5){
3aa102be 697 expected_bits=0;
8b4c7dbc 698 rate_factor+= step;
3aa102be
MN
699
700 rcc->buffer_index= s->avctx->rc_buffer_size/2;
701
8b4c7dbc
MN
702 /* find qscale */
703 for(i=0; i<rcc->num_entries; i++){
3aa102be
MN
704 qscale[i]= get_qscale(s, &rcc->entry[i], rate_factor, i);
705 }
706 assert(filter_size%2==1);
707
708 /* fixed I/B QP relative to P mode */
3aa102be 709 for(i=rcc->num_entries-1; i>=0; i--){
8b4c7dbc 710 RateControlEntry *rce= &rcc->entry[i];
6a1f7e7b
MN
711
712 qscale[i]= get_diff_limited_q(s, rce, qscale[i]);
3aa102be 713 }
8b4c7dbc 714
3aa102be
MN
715 /* smooth curve */
716 for(i=0; i<rcc->num_entries; i++){
717 RateControlEntry *rce= &rcc->entry[i];
718 const int pict_type= rce->new_pict_type;
719 int j;
720 double q=0.0, sum=0.0;
721
722 for(j=0; j<filter_size; j++){
723 int index= i+j-filter_size/2;
724 double d= index-i;
725 double coeff= s->qblur==0 ? 1.0 : exp(-d*d/(s->qblur * s->qblur));
8b4c7dbc 726
3aa102be
MN
727 if(index < 0 || index >= rcc->num_entries) continue;
728 if(pict_type != rcc->entry[index].new_pict_type) continue;
729 q+= qscale[index] * coeff;
730 sum+= coeff;
8b4c7dbc 731 }
3aa102be 732 blured_qscale[i]= q/sum;
8b4c7dbc 733 }
8b4c7dbc
MN
734
735 /* find expected bits */
736 for(i=0; i<rcc->num_entries; i++){
737 RateControlEntry *rce= &rcc->entry[i];
3aa102be
MN
738 double bits;
739 rce->new_qscale= modify_qscale(s, rce, blured_qscale[i], i);
405469ce 740 bits= qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;
3aa102be
MN
741//printf("%d %f\n", rce->new_bits, blured_qscale[i]);
742 update_rc_buffer(s, bits);
743
8b4c7dbc 744 rce->expected_bits= expected_bits;
3aa102be 745 expected_bits += bits;
8b4c7dbc
MN
746 }
747
3aa102be 748// printf("%f %d %f\n", expected_bits, (int)all_available_bits, rate_factor);
8b4c7dbc
MN
749 if(expected_bits > all_available_bits) rate_factor-= step;
750 }
3aa102be
MN
751 free(qscale);
752 free(blured_qscale);
8b4c7dbc 753
3aa102be
MN
754 if(abs(expected_bits/all_available_bits - 1.0) > 0.01 ){
755 fprintf(stderr, "Error: 2pass curve failed to converge\n");
756 return -1;
8b4c7dbc 757 }
8b4c7dbc 758
3aa102be 759 return 0;
8b4c7dbc 760}