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