Mercurial > libavcodec.hg
annotate ratecontrol.c @ 1708:dea5b2946999 libavcodec
interlaced motion estimation
interlaced mpeg2 encoding
P & B frames
rate distored interlaced mb decission
alternate scantable support
4mv encoding fixes (thats also why the regression tests change)
passing height to most dsp functions
interlaced mpeg4 encoding (no direct mode MBs yet)
various related cleanups
disabled old motion estimaton algorithms (log, full, ...) they will either be fixed or removed
author | michael |
---|---|
date | Tue, 30 Dec 2003 16:07:57 +0000 |
parents | 954593137d37 |
children | 07a484280a82 |
rev | line source |
---|---|
329 | 1 /* |
428 | 2 * Rate control for video encoders |
3 * | |
1683 | 4 * Copyright (c) 2002-2003 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){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
548 for(i=0; i<s->mb_num; i++){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
549 float newq= q*cplx_tab[i]/bits_tab[i]; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
550 newq*= bits_sum/cplx_sum; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
551 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
552 if (newq > qmax){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
553 bits_sum -= bits_tab[i]; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
554 cplx_sum -= cplx_tab[i]*q/qmax; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
555 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
556 else if(newq < qmin){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
557 bits_sum -= bits_tab[i]; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
558 cplx_sum -= cplx_tab[i]*q/qmin; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
559 } |
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 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
562 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
563 for(i=0; i<s->mb_num; i++){ |
1180 | 564 const int mb_xy= s->mb_index2xy[i]; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
565 float newq= q*cplx_tab[i]/bits_tab[i]; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
566 int intq; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
567 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
568 if(s->flags&CODEC_FLAG_NORMALIZE_AQP){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
569 newq*= bits_sum/cplx_sum; |
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 |
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
|
572 intq= (int)(newq + 0.5); |
690
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 if (intq > qmax) intq= qmax; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
575 else if(intq < qmin) intq= qmin; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
576 //if(i%s->mb_width==0) printf("\n"); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
577 //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
|
578 s->lambda_table[mb_xy]= intq; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
579 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
580 } |
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 //FIXME rd or at least approx for dquant |
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 float ff_rate_estimate_qscale(MpegEncContext *s) |
329 | 584 { |
585 float q; | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
586 int qmin, qmax; |
329 | 587 float br_compensation; |
588 double diff; | |
589 double short_term_q; | |
590 double fps; | |
612 | 591 int picture_number= s->picture_number; |
329 | 592 int64_t wanted_bits; |
612 | 593 RateControlContext *rcc= &s->rc_context; |
1687 | 594 AVCodecContext *a= s->avctx; |
612 | 595 RateControlEntry local_rce, *rce; |
596 double bits; | |
597 double rate_factor; | |
598 int var; | |
599 const int pict_type= s->pict_type; | |
903 | 600 Picture * const pic= &s->current_picture; |
329 | 601 emms_c(); |
602 | |
612 | 603 get_qminmax(&qmin, &qmax, s, pict_type); |
604 | |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
605 fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base; |
678 | 606 //printf("input_pic_num:%d pic_num:%d frame_rate:%d\n", s->input_picture_number, s->picture_number, s->frame_rate); |
329 | 607 /* update predictors */ |
608 if(picture_number>2){ | |
612 | 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); | |
329 | 611 } |
612 | |
612 | 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); | |
329 | 621 } |
622 | |
623 diff= s->total_bits - wanted_bits; | |
1687 | 624 br_compensation= (a->bit_rate_tolerance - diff)/a->bit_rate_tolerance; |
329 | 625 if(br_compensation<=0.0) br_compensation=0.001; |
612 | 626 |
903 | 627 var= pict_type == I_TYPE ? pic->mb_var_sum : pic->mc_mb_var_sum; |
612 | 628 |
1455 | 629 short_term_q = 0; /* avoid warning */ |
612 | 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; | |
903 | 639 rce->mc_mb_var_sum= pic->mc_mb_var_sum; |
640 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
|
641 rce->qscale = FF_QP2LAMBDA * 2; |
612 | 642 rce->f_code = s->f_code; |
643 rce->b_code = s->b_code; | |
644 rce->misc_bits= 1; | |
645 | |
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; | |
658 } | |
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] ++; | |
663 | |
664 bits= rce->i_tex_bits + rce->p_tex_bits; | |
707 | 665 rate_factor= rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum * br_compensation; |
612 | 666 |
667 q= get_qscale(s, rce, rate_factor, picture_number); | |
668 | |
615 | 669 assert(q>0.0); |
612 | 670 //printf("%f ", q); |
679 | 671 q= get_diff_limited_q(s, rce, q); |
612 | 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 | |
1687 | 676 rcc->short_term_qsum*=a->qblur; |
677 rcc->short_term_qcount*=a->qblur; | |
612 | 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 } | |
678 | 685 assert(q>0.0); |
686 | |
612 | 687 q= modify_qscale(s, rce, q, picture_number); |
688 | |
689 rcc->pass1_wanted_bits+= s->bit_rate/fps; | |
690 | |
615 | 691 assert(q>0.0); |
612 | 692 } |
930 | 693 |
694 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
|
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", |
1264 | 696 av_get_pict_type_char(pict_type), qmin, q, qmax, picture_number, (int)wanted_bits/1000, (int)s->total_bits/1000, |
930 | 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 } | |
612 | 700 |
701 if (q<qmin) q=qmin; | |
702 else if(q>qmax) q=qmax; | |
703 | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
704 if(s->adaptive_quant) |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
705 adaptive_quantization(s, q); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
706 else |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
707 q= (int)(q + 0.5); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
708 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
709 rcc->last_qscale= q; |
903 | 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 | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
720 return q; |
329 | 721 } |
722 | |
723 //---------------------------------------------- | |
724 // 2-Pass code | |
725 | |
726 static int init_pass2(MpegEncContext *s) | |
727 { | |
728 RateControlContext *rcc= &s->rc_context; | |
1687 | 729 AVCodecContext *a= s->avctx; |
329 | 730 int i; |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
731 double fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base; |
329 | 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); | |
738 double rate_factor=0; | |
739 double step; | |
949 | 740 //int last_i_frame=-10000000; |
1687 | 741 const int filter_size= (int)(a->qblur*4) | 1; |
612 | 742 double expected_bits; |
743 double *qscale, *blured_qscale; | |
329 | 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 | |
915 | 749 rce->new_pict_type= rce->pict_type; |
612 | 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] ++; | |
329 | 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; | |
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){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1505
diff
changeset
|
761 av_log(s->avctx, AV_LOG_ERROR, "requested bitrate is to low\n"); |
329 | 762 return -1; |
763 } | |
612 | 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 } | |
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
|
783 //printf("qp_i:%f, qp_p:%f, qp_b:%f\n", avg_quantizer[I_TYPE],avg_quantizer[P_TYPE],avg_quantizer[B_TYPE]); |
329 | 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); | |
612 | 789 |
1031
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
977
diff
changeset
|
790 qscale= av_malloc(sizeof(double)*rcc->num_entries); |
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
977
diff
changeset
|
791 blured_qscale= av_malloc(sizeof(double)*rcc->num_entries); |
612 | 792 |
329 | 793 for(step=256*256; step>0.0000001; step*=0.5){ |
612 | 794 expected_bits=0; |
329 | 795 rate_factor+= step; |
612 | 796 |
797 rcc->buffer_index= s->avctx->rc_buffer_size/2; | |
798 | |
329 | 799 /* find qscale */ |
800 for(i=0; i<rcc->num_entries; i++){ | |
612 | 801 qscale[i]= get_qscale(s, &rcc->entry[i], rate_factor, i); |
802 } | |
803 assert(filter_size%2==1); | |
329 | 804 |
612 | 805 /* fixed I/B QP relative to P mode */ |
806 for(i=rcc->num_entries-1; i>=0; i--){ | |
807 RateControlEntry *rce= &rcc->entry[i]; | |
679 | 808 |
809 qscale[i]= get_diff_limited_q(s, rce, qscale[i]); | |
329 | 810 } |
811 | |
812 /* smooth curve */ | |
612 | 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; | |
1687 | 822 double coeff= a->qblur==0 ? 1.0 : exp(-d*d/(a->qblur * a->qblur)); |
612 | 823 |
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; | |
828 } | |
829 blured_qscale[i]= q/sum; | |
830 } | |
329 | 831 |
832 /* find expected bits */ | |
833 for(i=0; i<rcc->num_entries; i++){ | |
834 RateControlEntry *rce= &rcc->entry[i]; | |
612 | 835 double bits; |
836 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
|
837 bits= qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits; |
612 | 838 //printf("%d %f\n", rce->new_bits, blured_qscale[i]); |
1684 | 839 bits += 8*ff_vbv_update(s, bits); |
612 | 840 |
329 | 841 rce->expected_bits= expected_bits; |
612 | 842 expected_bits += bits; |
329 | 843 } |
844 | |
612 | 845 // printf("%f %d %f\n", expected_bits, (int)all_available_bits, rate_factor); |
329 | 846 if(expected_bits > all_available_bits) rate_factor-= step; |
847 } | |
1031
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
977
diff
changeset
|
848 av_free(qscale); |
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
977
diff
changeset
|
849 av_free(blured_qscale); |
612 | 850 |
851 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
|
852 av_log(s->avctx, AV_LOG_ERROR, "Error: 2pass curve failed to converge\n"); |
612 | 853 return -1; |
854 } | |
329 | 855 |
856 return 0; | |
857 } |