Mercurial > libavcodec.hg
annotate ratecontrol.c @ 2150:8aff375a986b libavcodec
optimize quantizaton (about 3x faster)
further opt is easily possible but could lead to overflows depening upon coefficient range, so this wont be done yet as it would make the code somewhat less flexible
author | michael |
---|---|
date | Tue, 27 Jul 2004 17:38:53 +0000 |
parents | 2721e1859e19 |
children | 18b8b2dcc037 |
rev | line source |
---|---|
329 | 1 /* |
428 | 2 * Rate control for video encoders |
3 * | |
1739
07a484280a82
copyright year update of the files i touched and remembered, things look annoyingly unmaintained otherwise
michael
parents:
1708
diff
changeset
|
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at> |
428 | 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 */ | |
1106 | 20 |
21 /** | |
22 * @file ratecontrol.c | |
23 * Rate control for video encoders. | |
24 */ | |
25 | |
329 | 26 #include "avcodec.h" |
428 | 27 #include "dsputil.h" |
329 | 28 #include "mpegvideo.h" |
29 | |
612 | 30 #undef NDEBUG // allways check asserts, the speed effect is far too small to disable them |
31 #include <assert.h> | |
329 | 32 |
627 | 33 #ifndef M_E |
34 #define M_E 2.718281828 | |
35 #endif | |
36 | |
329 | 37 static int init_pass2(MpegEncContext *s); |
612 | 38 static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_factor, int frame_num); |
329 | 39 |
40 void ff_write_pass1_stats(MpegEncContext *s){ | |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1455
diff
changeset
|
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", |
1705 | 42 s->current_picture_ptr->display_picture_number, s->current_picture_ptr->coded_picture_number, s->pict_type, |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1455
diff
changeset
|
43 s->current_picture.quality, s->i_tex_bits, s->p_tex_bits, s->mv_bits, s->misc_bits, |
903 | 44 s->f_code, s->b_code, s->current_picture.mc_mb_var_sum, s->current_picture.mb_var_sum, s->i_count); |
329 | 45 } |
46 | |
47 int ff_rate_control_init(MpegEncContext *s) | |
48 { | |
49 RateControlContext *rcc= &s->rc_context; | |
612 | 50 int i; |
329 | 51 emms_c(); |
52 | |
612 | 53 for(i=0; i<5; i++){ |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1455
diff
changeset
|
54 rcc->pred[i].coeff= FF_QP2LAMBDA * 7.0; |
612 | 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 | |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1455
diff
changeset
|
63 rcc->last_qscale_for[i]=FF_QP2LAMBDA * 5; |
612 | 64 } |
1683 | 65 rcc->buffer_index= s->avctx->rc_initial_buffer_occupancy; |
612 | 66 |
67 if(s->flags&CODEC_FLAG_PASS2){ | |
329 | 68 int i; |
612 | 69 char *p; |
329 | 70 |
612 | 71 /* find number of pics */ |
72 p= s->avctx->stats_in; | |
73 for(i=-1; p; i++){ | |
74 p= strchr(p+1, ';'); | |
329 | 75 } |
612 | 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; | |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1455
diff
changeset
|
84 rce->qscale= rce->new_qscale=FF_QP2LAMBDA * 2; |
612 | 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++){ | |
329 | 92 RateControlEntry *rce; |
93 int picture_number; | |
94 int e; | |
612 | 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); | |
329 | 106 rce= &rcc->entry[picture_number]; |
612 | 107 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
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", |
612 | 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){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1505
diff
changeset
|
112 av_log(s->avctx, AV_LOG_ERROR, "statistics are damaged at line %d, parser out=%d\n", i, e); |
329 | 113 return -1; |
114 } | |
612 | 115 p= next; |
329 | 116 } |
117 | |
118 if(init_pass2(s) < 0) return -1; | |
119 } | |
120 | |
612 | 121 if(!(s->flags&CODEC_FLAG_PASS2)){ |
122 | |
123 rcc->short_term_qsum=0.001; | |
124 rcc->short_term_qcount=0.001; | |
329 | 125 |
707 | 126 rcc->pass1_rc_eq_output_sum= 0.001; |
612 | 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; | |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1455
diff
changeset
|
143 rce.qscale = FF_QP2LAMBDA * 2; |
612 | 144 rce.f_code = 2; |
145 rce.b_code = 1; | |
146 rce.misc_bits= 1; | |
329 | 147 |
612 | 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] ++; | |
329 | 163 |
612 | 164 bits= rce.i_tex_bits + rce.p_tex_bits; |
165 | |
707 | 166 q= get_qscale(s, &rce, rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum, i); |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
167 rcc->pass1_wanted_bits+= s->bit_rate/(s->avctx->frame_rate / (double)s->avctx->frame_rate_base); |
612 | 168 } |
169 } | |
170 | |
171 } | |
172 | |
329 | 173 return 0; |
174 } | |
175 | |
176 void ff_rate_control_uninit(MpegEncContext *s) | |
177 { | |
178 RateControlContext *rcc= &s->rc_context; | |
179 emms_c(); | |
180 | |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
388
diff
changeset
|
181 av_freep(&rcc->entry); |
329 | 182 } |
183 | |
612 | 184 static inline double qp2bits(RateControlEntry *rce, double qp){ |
185 if(qp<=0.0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1505
diff
changeset
|
186 av_log(NULL, AV_LOG_ERROR, "qp<=0.0\n"); |
612 | 187 } |
188 return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits+1)/ qp; | |
189 } | |
190 | |
191 static inline double bits2qp(RateControlEntry *rce, double bits){ | |
192 if(bits<0.9){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1505
diff
changeset
|
193 av_log(NULL, AV_LOG_ERROR, "bits<0.9\n"); |
612 | 194 } |
195 return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits+1)/ bits; | |
196 } | |
197 | |
1684 | 198 int ff_vbv_update(MpegEncContext *s, int frame_size){ |
612 | 199 RateControlContext *rcc= &s->rc_context; |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
200 const double fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base; |
1697 | 201 const int buffer_size= s->avctx->rc_buffer_size; |
612 | 202 const double min_rate= s->avctx->rc_min_rate/fps; |
203 const double max_rate= s->avctx->rc_max_rate/fps; | |
1697 | 204 |
205 //printf("%d %f %d %f %f\n", buffer_size, rcc->buffer_index, frame_size, min_rate, max_rate); | |
612 | 206 if(buffer_size){ |
1683 | 207 int left; |
208 | |
612 | 209 rcc->buffer_index-= frame_size; |
1683 | 210 if(rcc->buffer_index < 0){ |
211 av_log(s->avctx, AV_LOG_ERROR, "rc buffer underflow\n"); | |
212 rcc->buffer_index= 0; | |
612 | 213 } |
1683 | 214 |
215 left= buffer_size - rcc->buffer_index - 1; | |
216 rcc->buffer_index += clip(left, min_rate, max_rate); | |
217 | |
1697 | 218 if(rcc->buffer_index > buffer_size){ |
219 int stuffing= ceil((rcc->buffer_index - buffer_size)/8); | |
1684 | 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; | |
1683 | 229 } |
612 | 230 } |
1684 | 231 return 0; |
612 | 232 } |
233 | |
234 /** | |
235 * modifies the bitrate curve from pass1 for one frame | |
236 */ | |
237 static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_factor, int frame_num){ | |
238 RateControlContext *rcc= &s->rc_context; | |
1687 | 239 AVCodecContext *a= s->avctx; |
612 | 240 double q, bits; |
241 const int pict_type= rce->new_pict_type; | |
242 const double mb_num= s->mb_num; | |
243 int i; | |
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], | |
1687 | 260 a->qcompress, |
612 | 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 }; | |
1057 | 272 static const char *const_names[]={ |
612 | 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 }; | |
620
a5aa53b6e648
warning patch by (Dominik Mierzejewski <dominik at rangers dot eu dot org>)
michaelni
parents:
616
diff
changeset
|
299 static double (*func1[])(void *, double)={ |
749 | 300 (void *)bits2qp, |
301 (void *)qp2bits, | |
612 | 302 NULL |
303 }; | |
1057 | 304 static const char *func1_names[]={ |
612 | 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 | |
707 | 312 rcc->pass1_rc_eq_output_sum+= bits; |
612 | 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; | |
679 | 336 |
337 return q; | |
338 } | |
339 | |
340 static 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]; | |
930 | 346 |
679 | 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 | |
612 | 352 /* last qscale / qdiff stuff */ |
679 | 353 if(rcc->last_non_b_pict_type==pict_type || pict_type!=I_TYPE){ |
354 double last_q= rcc->last_qscale_for[pict_type]; | |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1455
diff
changeset
|
355 const int maxdiff= FF_QP2LAMBDA * a->max_qdiff; |
930 | 356 |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1455
diff
changeset
|
357 if (q > last_q + maxdiff) q= last_q + maxdiff; |
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1455
diff
changeset
|
358 else if(q < last_q - maxdiff) q= last_q - maxdiff; |
679 | 359 } |
612 | 360 |
361 rcc->last_qscale_for[pict_type]= q; //Note we cant do that after blurring | |
362 | |
679 | 363 if(pict_type!=B_TYPE) |
364 rcc->last_non_b_pict_type= pict_type; | |
365 | |
612 | 366 return q; |
367 } | |
368 | |
369 /** | |
370 * gets the qmin & qmax for pict_type | |
371 */ | |
372 static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type){ | |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1455
diff
changeset
|
373 int qmin= s->avctx->lmin; |
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1455
diff
changeset
|
374 int qmax= s->avctx->lmax; |
1365 | 375 |
376 assert(qmin <= qmax); | |
612 | 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 | |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1455
diff
changeset
|
386 qmin= clip(qmin, 1, FF_LAMBDA_MAX); |
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1455
diff
changeset
|
387 qmax= clip(qmax, 1, FF_LAMBDA_MAX); |
612 | 388 |
1365 | 389 if(qmax<qmin) qmax= qmin; |
612 | 390 |
391 *qmin_ret= qmin; | |
392 *qmax_ret= qmax; | |
393 } | |
394 | |
395 static 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; | |
1683 | 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; | |
612 | 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); | |
678 | 412 //printf("q:%f\n", q); |
612 | 413 /* buffer overflow/underflow protection */ |
414 if(buffer_size){ | |
679 | 415 double expected_size= rcc->buffer_index; |
1697 | 416 double q_limit; |
612 | 417 |
418 if(min_rate){ | |
679 | 419 double d= 2*(buffer_size - expected_size)/buffer_size; |
612 | 420 if(d>1.0) d=1.0; |
678 | 421 else if(d<0.0001) d=0.0001; |
422 q*= pow(d, 1.0/s->avctx->rc_buffer_aggressivity); | |
679 | 423 |
1697 | 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 } | |
612 | 431 } |
432 | |
433 if(max_rate){ | |
434 double d= 2*expected_size/buffer_size; | |
435 if(d>1.0) d=1.0; | |
678 | 436 else if(d<0.0001) d=0.0001; |
437 q/= pow(d, 1.0/s->avctx->rc_buffer_aggressivity); | |
679 | 438 |
1697 | 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 } | |
612 | 446 } |
447 } | |
678 | 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); |
615 | 449 if(s->avctx->rc_qsquish==0.0 || qmin==qmax){ |
612 | 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 } | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
464 |
612 | 465 return q; |
466 } | |
467 | |
329 | 468 //---------------------------------- |
469 // 1 Pass Code | |
470 | |
612 | 471 static double predict_size(Predictor *p, double q, double var) |
329 | 472 { |
473 return p->coeff*var / (q*p->count); | |
474 } | |
475 | |
949 | 476 /* |
612 | 477 static 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 } | |
949 | 482 */ |
612 | 483 |
329 | 484 static void update_predictor(Predictor *p, double q, double var, double size) |
485 { | |
486 double new_coeff= size*q / (var + 1); | |
612 | 487 if(var<10) return; |
329 | 488 |
489 p->count*= p->decay; | |
490 p->coeff*= p->decay; | |
491 p->count++; | |
492 p->coeff+= new_coeff; | |
493 } | |
494 | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
495 static void adaptive_quantization(MpegEncContext *s, double q){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
496 int i; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
497 const float lumi_masking= s->avctx->lumi_masking / (128.0*128.0); |
693
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
498 const float dark_masking= s->avctx->dark_masking / (128.0*128.0); |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
499 const float temp_cplx_masking= s->avctx->temporal_cplx_masking; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
500 const float spatial_cplx_masking = s->avctx->spatial_cplx_masking; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
501 const float p_masking = s->avctx->p_masking; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
502 float bits_sum= 0.0; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
503 float cplx_sum= 0.0; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
504 float cplx_tab[s->mb_num]; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
505 float bits_tab[s->mb_num]; |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1455
diff
changeset
|
506 const int qmin= s->avctx->lmin; |
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1455
diff
changeset
|
507 const int qmax= s->avctx->lmax; |
903 | 508 Picture * const pic= &s->current_picture; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
509 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
510 for(i=0; i<s->mb_num; i++){ |
1180 | 511 const int mb_xy= s->mb_index2xy[i]; |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1455
diff
changeset
|
512 float temp_cplx= sqrt(pic->mc_mb_var[mb_xy]); //FIXME merge in pow() |
1180 | 513 float spat_cplx= sqrt(pic->mb_var[mb_xy]); |
514 const int lumi= pic->mb_mean[mb_xy]; | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
515 float bits, cplx, factor; |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1455
diff
changeset
|
516 #if 0 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
517 if(spat_cplx < q/3) spat_cplx= q/3; //FIXME finetune |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
518 if(temp_cplx < q/3) temp_cplx= q/3; //FIXME finetune |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1455
diff
changeset
|
519 #endif |
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1455
diff
changeset
|
520 if(spat_cplx < 4) spat_cplx= 4; //FIXME finetune |
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1455
diff
changeset
|
521 if(temp_cplx < 4) temp_cplx= 4; //FIXME finetune |
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1455
diff
changeset
|
522 |
1708 | 523 if((s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTRA)){//FIXME hq mode |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
524 cplx= spat_cplx; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
525 factor= 1.0 + p_masking; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
526 }else{ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
527 cplx= temp_cplx; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
528 factor= pow(temp_cplx, - temp_cplx_masking); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
529 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
530 factor*=pow(spat_cplx, - spatial_cplx_masking); |
693
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
531 |
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
532 if(lumi>127) |
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
533 factor*= (1.0 - (lumi-128)*(lumi-128)*lumi_masking); |
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
534 else |
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
535 factor*= (1.0 - (lumi-128)*(lumi-128)*dark_masking); |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
536 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
537 if(factor<0.00001) factor= 0.00001; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
538 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
539 bits= cplx*factor; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
540 cplx_sum+= cplx; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
541 bits_sum+= bits; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
542 cplx_tab[i]= cplx; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
543 bits_tab[i]= bits; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
544 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
545 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
546 /* handle qmin/qmax cliping */ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
547 if(s->flags&CODEC_FLAG_NORMALIZE_AQP){ |
1806
2721e1859e19
normalize adaptive quantizatiuon fix (based upon a patch by (Jindrich Makovicka <makovick at kmlinux dot fjfi dot cvut dot cz>))
michael
parents:
1739
diff
changeset
|
548 float factor= bits_sum/cplx_sum; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
549 for(i=0; i<s->mb_num; i++){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
550 float newq= q*cplx_tab[i]/bits_tab[i]; |
1806
2721e1859e19
normalize adaptive quantizatiuon fix (based upon a patch by (Jindrich Makovicka <makovick at kmlinux dot fjfi dot cvut dot cz>))
michael
parents:
1739
diff
changeset
|
551 newq*= factor; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
552 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
553 if (newq > qmax){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
554 bits_sum -= bits_tab[i]; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
555 cplx_sum -= cplx_tab[i]*q/qmax; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
556 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
557 else if(newq < qmin){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
558 bits_sum -= bits_tab[i]; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
559 cplx_sum -= cplx_tab[i]*q/qmin; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
560 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
561 } |
1806
2721e1859e19
normalize adaptive quantizatiuon fix (based upon a patch by (Jindrich Makovicka <makovick at kmlinux dot fjfi dot cvut dot cz>))
michael
parents:
1739
diff
changeset
|
562 if(bits_sum < 0.001) bits_sum= 0.001; |
2721e1859e19
normalize adaptive quantizatiuon fix (based upon a patch by (Jindrich Makovicka <makovick at kmlinux dot fjfi dot cvut dot cz>))
michael
parents:
1739
diff
changeset
|
563 if(cplx_sum < 0.001) cplx_sum= 0.001; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
564 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
565 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
566 for(i=0; i<s->mb_num; i++){ |
1180 | 567 const int mb_xy= s->mb_index2xy[i]; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
568 float newq= q*cplx_tab[i]/bits_tab[i]; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
569 int intq; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
570 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
571 if(s->flags&CODEC_FLAG_NORMALIZE_AQP){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
572 newq*= bits_sum/cplx_sum; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
573 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
574 |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1455
diff
changeset
|
575 intq= (int)(newq + 0.5); |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
576 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
577 if (intq > qmax) intq= qmax; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
578 else if(intq < qmin) intq= qmin; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
579 //if(i%s->mb_width==0) printf("\n"); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
580 //printf("%2d%3d ", intq, ff_sqrt(s->mc_mb_var[i])); |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1455
diff
changeset
|
581 s->lambda_table[mb_xy]= intq; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
582 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
583 } |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1455
diff
changeset
|
584 //FIXME rd or at least approx for dquant |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
585 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
586 float ff_rate_estimate_qscale(MpegEncContext *s) |
329 | 587 { |
588 float q; | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
589 int qmin, qmax; |
329 | 590 float br_compensation; |
591 double diff; | |
592 double short_term_q; | |
593 double fps; | |
612 | 594 int picture_number= s->picture_number; |
329 | 595 int64_t wanted_bits; |
612 | 596 RateControlContext *rcc= &s->rc_context; |
1687 | 597 AVCodecContext *a= s->avctx; |
612 | 598 RateControlEntry local_rce, *rce; |
599 double bits; | |
600 double rate_factor; | |
601 int var; | |
602 const int pict_type= s->pict_type; | |
903 | 603 Picture * const pic= &s->current_picture; |
329 | 604 emms_c(); |
605 | |
612 | 606 get_qminmax(&qmin, &qmax, s, pict_type); |
607 | |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
608 fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base; |
678 | 609 //printf("input_pic_num:%d pic_num:%d frame_rate:%d\n", s->input_picture_number, s->picture_number, s->frame_rate); |
329 | 610 /* update predictors */ |
611 if(picture_number>2){ | |
612 | 612 const int last_var= s->last_pict_type == I_TYPE ? rcc->last_mb_var_sum : rcc->last_mc_mb_var_sum; |
613 update_predictor(&rcc->pred[s->last_pict_type], rcc->last_qscale, sqrt(last_var), s->frame_bits); | |
329 | 614 } |
615 | |
612 | 616 if(s->flags&CODEC_FLAG_PASS2){ |
617 assert(picture_number>=0); | |
618 assert(picture_number<rcc->num_entries); | |
619 rce= &rcc->entry[picture_number]; | |
620 wanted_bits= rce->expected_bits; | |
621 }else{ | |
622 rce= &local_rce; | |
623 wanted_bits= (uint64_t)(s->bit_rate*(double)picture_number/fps); | |
329 | 624 } |
625 | |
626 diff= s->total_bits - wanted_bits; | |
1687 | 627 br_compensation= (a->bit_rate_tolerance - diff)/a->bit_rate_tolerance; |
329 | 628 if(br_compensation<=0.0) br_compensation=0.001; |
612 | 629 |
903 | 630 var= pict_type == I_TYPE ? pic->mb_var_sum : pic->mc_mb_var_sum; |
612 | 631 |
1455 | 632 short_term_q = 0; /* avoid warning */ |
612 | 633 if(s->flags&CODEC_FLAG_PASS2){ |
634 if(pict_type!=I_TYPE) | |
635 assert(pict_type == rce->new_pict_type); | |
636 | |
637 q= rce->new_qscale / br_compensation; | |
638 //printf("%f %f %f last:%d var:%d type:%d//\n", q, rce->new_qscale, br_compensation, s->frame_bits, var, pict_type); | |
639 }else{ | |
640 rce->pict_type= | |
641 rce->new_pict_type= pict_type; | |
903 | 642 rce->mc_mb_var_sum= pic->mc_mb_var_sum; |
643 rce->mb_var_sum = pic-> mb_var_sum; | |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1455
diff
changeset
|
644 rce->qscale = FF_QP2LAMBDA * 2; |
612 | 645 rce->f_code = s->f_code; |
646 rce->b_code = s->b_code; | |
647 rce->misc_bits= 1; | |
648 | |
649 bits= predict_size(&rcc->pred[pict_type], rce->qscale, sqrt(var)); | |
650 if(pict_type== I_TYPE){ | |
651 rce->i_count = s->mb_num; | |
652 rce->i_tex_bits= bits; | |
653 rce->p_tex_bits= 0; | |
654 rce->mv_bits= 0; | |
655 }else{ | |
656 rce->i_count = 0; //FIXME we do know this approx | |
657 rce->i_tex_bits= 0; | |
658 rce->p_tex_bits= bits*0.9; | |
659 | |
660 rce->mv_bits= bits*0.1; | |
661 } | |
662 rcc->i_cplx_sum [pict_type] += rce->i_tex_bits*rce->qscale; | |
663 rcc->p_cplx_sum [pict_type] += rce->p_tex_bits*rce->qscale; | |
664 rcc->mv_bits_sum[pict_type] += rce->mv_bits; | |
665 rcc->frame_count[pict_type] ++; | |
666 | |
667 bits= rce->i_tex_bits + rce->p_tex_bits; | |
707 | 668 rate_factor= rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum * br_compensation; |
612 | 669 |
670 q= get_qscale(s, rce, rate_factor, picture_number); | |
671 | |
615 | 672 assert(q>0.0); |
612 | 673 //printf("%f ", q); |
679 | 674 q= get_diff_limited_q(s, rce, q); |
612 | 675 //printf("%f ", q); |
676 assert(q>0.0); | |
677 | |
678 if(pict_type==P_TYPE || s->intra_only){ //FIXME type dependant blur like in 2-pass | |
1687 | 679 rcc->short_term_qsum*=a->qblur; |
680 rcc->short_term_qcount*=a->qblur; | |
612 | 681 |
682 rcc->short_term_qsum+= q; | |
683 rcc->short_term_qcount++; | |
684 //printf("%f ", q); | |
685 q= short_term_q= rcc->short_term_qsum/rcc->short_term_qcount; | |
686 //printf("%f ", q); | |
687 } | |
678 | 688 assert(q>0.0); |
689 | |
612 | 690 q= modify_qscale(s, rce, q, picture_number); |
691 | |
692 rcc->pass1_wanted_bits+= s->bit_rate/fps; | |
693 | |
615 | 694 assert(q>0.0); |
612 | 695 } |
930 | 696 |
697 if(s->avctx->debug&FF_DEBUG_RC){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1505
diff
changeset
|
698 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", |
1264 | 699 av_get_pict_type_char(pict_type), qmin, q, qmax, picture_number, (int)wanted_bits/1000, (int)s->total_bits/1000, |
930 | 700 br_compensation, short_term_q, s->frame_bits, pic->mb_var_sum, pic->mc_mb_var_sum, s->bit_rate/1000, (int)fps |
701 ); | |
702 } | |
612 | 703 |
704 if (q<qmin) q=qmin; | |
705 else if(q>qmax) q=qmax; | |
706 | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
707 if(s->adaptive_quant) |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
708 adaptive_quantization(s, q); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
709 else |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
710 q= (int)(q + 0.5); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
711 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
712 rcc->last_qscale= q; |
903 | 713 rcc->last_mc_mb_var_sum= pic->mc_mb_var_sum; |
714 rcc->last_mb_var_sum= pic->mb_var_sum; | |
715 #if 0 | |
716 { | |
717 static int mvsum=0, texsum=0; | |
718 mvsum += s->mv_bits; | |
719 texsum += s->i_tex_bits + s->p_tex_bits; | |
720 printf("%d %d//\n\n", mvsum, texsum); | |
721 } | |
722 #endif | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
723 return q; |
329 | 724 } |
725 | |
726 //---------------------------------------------- | |
727 // 2-Pass code | |
728 | |
729 static int init_pass2(MpegEncContext *s) | |
730 { | |
731 RateControlContext *rcc= &s->rc_context; | |
1687 | 732 AVCodecContext *a= s->avctx; |
329 | 733 int i; |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
734 double fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base; |
329 | 735 double complexity[5]={0,0,0,0,0}; // aproximate bits at quant=1 |
736 double avg_quantizer[5]; | |
737 uint64_t const_bits[5]={0,0,0,0,0}; // quantizer idependant bits | |
738 uint64_t available_bits[5]; | |
739 uint64_t all_const_bits; | |
740 uint64_t all_available_bits= (uint64_t)(s->bit_rate*(double)rcc->num_entries/fps); | |
741 double rate_factor=0; | |
742 double step; | |
949 | 743 //int last_i_frame=-10000000; |
1687 | 744 const int filter_size= (int)(a->qblur*4) | 1; |
612 | 745 double expected_bits; |
746 double *qscale, *blured_qscale; | |
329 | 747 |
748 /* find complexity & const_bits & decide the pict_types */ | |
749 for(i=0; i<rcc->num_entries; i++){ | |
750 RateControlEntry *rce= &rcc->entry[i]; | |
751 | |
915 | 752 rce->new_pict_type= rce->pict_type; |
612 | 753 rcc->i_cplx_sum [rce->pict_type] += rce->i_tex_bits*rce->qscale; |
754 rcc->p_cplx_sum [rce->pict_type] += rce->p_tex_bits*rce->qscale; | |
755 rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits; | |
756 rcc->frame_count[rce->pict_type] ++; | |
329 | 757 |
758 complexity[rce->new_pict_type]+= (rce->i_tex_bits+ rce->p_tex_bits)*(double)rce->qscale; | |
759 const_bits[rce->new_pict_type]+= rce->mv_bits + rce->misc_bits; | |
760 } | |
761 all_const_bits= const_bits[I_TYPE] + const_bits[P_TYPE] + const_bits[B_TYPE]; | |
762 | |
763 if(all_available_bits < all_const_bits){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1505
diff
changeset
|
764 av_log(s->avctx, AV_LOG_ERROR, "requested bitrate is to low\n"); |
329 | 765 return -1; |
766 } | |
612 | 767 |
768 /* find average quantizers */ | |
769 avg_quantizer[P_TYPE]=0; | |
770 for(step=256*256; step>0.0000001; step*=0.5){ | |
771 double expected_bits=0; | |
772 avg_quantizer[P_TYPE]+= step; | |
773 | |
774 avg_quantizer[I_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->i_quant_factor) + s->avctx->i_quant_offset; | |
775 avg_quantizer[B_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset; | |
776 | |
777 expected_bits= | |
778 + all_const_bits | |
779 + complexity[I_TYPE]/avg_quantizer[I_TYPE] | |
780 + complexity[P_TYPE]/avg_quantizer[P_TYPE] | |
781 + complexity[B_TYPE]/avg_quantizer[B_TYPE]; | |
782 | |
783 if(expected_bits < all_available_bits) avg_quantizer[P_TYPE]-= step; | |
784 //printf("%f %lld %f\n", expected_bits, all_available_bits, avg_quantizer[P_TYPE]); | |
785 } | |
616
0fe52ab8042c
forgot the const bits in 2pass curve matching (patch (with rounding removed) by Rmi Guyomarch <rguyom at pobox dot com>)
michaelni
parents:
615
diff
changeset
|
786 //printf("qp_i:%f, qp_p:%f, qp_b:%f\n", avg_quantizer[I_TYPE],avg_quantizer[P_TYPE],avg_quantizer[B_TYPE]); |
329 | 787 |
788 for(i=0; i<5; i++){ | |
789 available_bits[i]= const_bits[i] + complexity[i]/avg_quantizer[i]; | |
790 } | |
791 //printf("%lld %lld %lld %lld\n", available_bits[I_TYPE], available_bits[P_TYPE], available_bits[B_TYPE], all_available_bits); | |
612 | 792 |
1031
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
977
diff
changeset
|
793 qscale= av_malloc(sizeof(double)*rcc->num_entries); |
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
977
diff
changeset
|
794 blured_qscale= av_malloc(sizeof(double)*rcc->num_entries); |
612 | 795 |
329 | 796 for(step=256*256; step>0.0000001; step*=0.5){ |
612 | 797 expected_bits=0; |
329 | 798 rate_factor+= step; |
612 | 799 |
800 rcc->buffer_index= s->avctx->rc_buffer_size/2; | |
801 | |
329 | 802 /* find qscale */ |
803 for(i=0; i<rcc->num_entries; i++){ | |
612 | 804 qscale[i]= get_qscale(s, &rcc->entry[i], rate_factor, i); |
805 } | |
806 assert(filter_size%2==1); | |
329 | 807 |
612 | 808 /* fixed I/B QP relative to P mode */ |
809 for(i=rcc->num_entries-1; i>=0; i--){ | |
810 RateControlEntry *rce= &rcc->entry[i]; | |
679 | 811 |
812 qscale[i]= get_diff_limited_q(s, rce, qscale[i]); | |
329 | 813 } |
814 | |
815 /* smooth curve */ | |
612 | 816 for(i=0; i<rcc->num_entries; i++){ |
817 RateControlEntry *rce= &rcc->entry[i]; | |
818 const int pict_type= rce->new_pict_type; | |
819 int j; | |
820 double q=0.0, sum=0.0; | |
821 | |
822 for(j=0; j<filter_size; j++){ | |
823 int index= i+j-filter_size/2; | |
824 double d= index-i; | |
1687 | 825 double coeff= a->qblur==0 ? 1.0 : exp(-d*d/(a->qblur * a->qblur)); |
612 | 826 |
827 if(index < 0 || index >= rcc->num_entries) continue; | |
828 if(pict_type != rcc->entry[index].new_pict_type) continue; | |
829 q+= qscale[index] * coeff; | |
830 sum+= coeff; | |
831 } | |
832 blured_qscale[i]= q/sum; | |
833 } | |
329 | 834 |
835 /* find expected bits */ | |
836 for(i=0; i<rcc->num_entries; i++){ | |
837 RateControlEntry *rce= &rcc->entry[i]; | |
612 | 838 double bits; |
839 rce->new_qscale= modify_qscale(s, rce, blured_qscale[i], i); | |
616
0fe52ab8042c
forgot the const bits in 2pass curve matching (patch (with rounding removed) by Rmi Guyomarch <rguyom at pobox dot com>)
michaelni
parents:
615
diff
changeset
|
840 bits= qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits; |
612 | 841 //printf("%d %f\n", rce->new_bits, blured_qscale[i]); |
1684 | 842 bits += 8*ff_vbv_update(s, bits); |
612 | 843 |
329 | 844 rce->expected_bits= expected_bits; |
612 | 845 expected_bits += bits; |
329 | 846 } |
847 | |
612 | 848 // printf("%f %d %f\n", expected_bits, (int)all_available_bits, rate_factor); |
329 | 849 if(expected_bits > all_available_bits) rate_factor-= step; |
850 } | |
1031
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
977
diff
changeset
|
851 av_free(qscale); |
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
977
diff
changeset
|
852 av_free(blured_qscale); |
612 | 853 |
854 if(abs(expected_bits/all_available_bits - 1.0) > 0.01 ){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1505
diff
changeset
|
855 av_log(s->avctx, AV_LOG_ERROR, "Error: 2pass curve failed to converge\n"); |
612 | 856 return -1; |
857 } | |
329 | 858 |
859 return 0; | |
860 } |