Mercurial > libavcodec.hg
annotate ratecontrol.c @ 4166:eced83504436 libavcodec
mp3 header (de)compression bitstream filter
this will make mp3 frames 4 bytes smaller, it will not give you binary identical mp3 files, but it will give you mp3 files which decode to binary identical output
this will only work in containers providing at least packet size, sample_rate and number of channels
bugreports about mp3 files for which this fails are welcome
and this is experimental (dont expect compatibility and dont even expect to be able to decompress what you compressed, hell dont even expect this to work without editing the source a little)
author | michael |
---|---|
date | Fri, 10 Nov 2006 01:41:53 +0000 |
parents | 90e848a24c70 |
children | fc155ff94878 |
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 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3789
diff
changeset
|
6 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3789
diff
changeset
|
7 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3789
diff
changeset
|
8 * FFmpeg is free software; you can redistribute it and/or |
428 | 9 * modify it under the terms of the GNU Lesser General Public |
10 * License as published by the Free Software Foundation; either | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3789
diff
changeset
|
11 * version 2.1 of the License, or (at your option) any later version. |
428 | 12 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3789
diff
changeset
|
13 * FFmpeg is distributed in the hope that it will be useful, |
428 | 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
16 * Lesser General Public License for more details. | |
17 * | |
18 * You should have received a copy of the GNU Lesser General Public | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3789
diff
changeset
|
19 * License along with FFmpeg; if not, write to the Free Software |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
2981
diff
changeset
|
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
428 | 21 */ |
1106 | 22 |
23 /** | |
24 * @file ratecontrol.c | |
25 * Rate control for video encoders. | |
2967 | 26 */ |
1106 | 27 |
329 | 28 #include "avcodec.h" |
428 | 29 #include "dsputil.h" |
3789
730ad999e379
Move the ratecontrol related code from mpegvideo.h to a separate header file.
takis
parents:
3786
diff
changeset
|
30 #include "ratecontrol.h" |
329 | 31 #include "mpegvideo.h" |
3786
616a81d04758
Pull out the ff_eval* from the mpegvideo header, as it doesn't belong there and
takis
parents:
3775
diff
changeset
|
32 #include "eval.h" |
329 | 33 |
612 | 34 #undef NDEBUG // allways check asserts, the speed effect is far too small to disable them |
35 #include <assert.h> | |
329 | 36 |
627 | 37 #ifndef M_E |
38 #define M_E 2.718281828 | |
39 #endif | |
40 | |
329 | 41 static int init_pass2(MpegEncContext *s); |
612 | 42 static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_factor, int frame_num); |
329 | 43 |
44 void ff_write_pass1_stats(MpegEncContext *s){ | |
3064 | 45 snprintf(s->avctx->stats_out, 256, "in:%d out:%d type:%d q:%d itex:%d ptex:%d mv:%d misc:%d fcode:%d bcode:%d mc-var:%d var:%d icount:%d skipcount:%d hbits:%d;\n", |
2967 | 46 s->current_picture_ptr->display_picture_number, s->current_picture_ptr->coded_picture_number, s->pict_type, |
47 s->current_picture.quality, s->i_tex_bits, s->p_tex_bits, s->mv_bits, s->misc_bits, | |
3064 | 48 s->f_code, s->b_code, s->current_picture.mc_mb_var_sum, s->current_picture.mb_var_sum, s->i_count, s->skip_count, s->header_bits); |
329 | 49 } |
50 | |
4084 | 51 static inline double qp2bits(RateControlEntry *rce, double qp){ |
52 if(qp<=0.0){ | |
53 av_log(NULL, AV_LOG_ERROR, "qp<=0.0\n"); | |
54 } | |
55 return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits+1)/ qp; | |
56 } | |
57 | |
58 static inline double bits2qp(RateControlEntry *rce, double bits){ | |
59 if(bits<0.9){ | |
60 av_log(NULL, AV_LOG_ERROR, "bits<0.9\n"); | |
61 } | |
62 return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits+1)/ bits; | |
63 } | |
64 | |
329 | 65 int ff_rate_control_init(MpegEncContext *s) |
66 { | |
67 RateControlContext *rcc= &s->rc_context; | |
612 | 68 int i; |
4084 | 69 char *error = NULL; |
70 static const char *const_names[]={ | |
71 "PI", | |
72 "E", | |
73 "iTex", | |
74 "pTex", | |
75 "tex", | |
76 "mv", | |
77 "fCode", | |
78 "iCount", | |
79 "mcVar", | |
80 "var", | |
81 "isI", | |
82 "isP", | |
83 "isB", | |
84 "avgQP", | |
85 "qComp", | |
86 /* "lastIQP", | |
87 "lastPQP", | |
88 "lastBQP", | |
89 "nextNonBQP",*/ | |
90 "avgIITex", | |
91 "avgPITex", | |
92 "avgPPTex", | |
93 "avgBPTex", | |
94 "avgTex", | |
95 NULL | |
96 }; | |
97 static double (*func1[])(void *, double)={ | |
98 (void *)bits2qp, | |
99 (void *)qp2bits, | |
100 NULL | |
101 }; | |
102 static const char *func1_names[]={ | |
103 "bits2qp", | |
104 "qp2bits", | |
105 NULL | |
106 }; | |
329 | 107 emms_c(); |
108 | |
4084 | 109 rcc->rc_eq_eval = ff_parse(s->avctx->rc_eq, const_names, func1, func1_names, NULL, NULL, &error); |
110 if (!rcc->rc_eq_eval) { | |
111 av_log(s->avctx, AV_LOG_ERROR, "Error parsing rc_eq \"%s\": %s\n", s->avctx->rc_eq, error? error : ""); | |
112 return -1; | |
113 } | |
114 | |
612 | 115 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
|
116 rcc->pred[i].coeff= FF_QP2LAMBDA * 7.0; |
612 | 117 rcc->pred[i].count= 1.0; |
2967 | 118 |
612 | 119 rcc->pred[i].decay= 0.4; |
120 rcc->i_cplx_sum [i]= | |
121 rcc->p_cplx_sum [i]= | |
122 rcc->mv_bits_sum[i]= | |
123 rcc->qscale_sum [i]= | |
124 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
|
125 rcc->last_qscale_for[i]=FF_QP2LAMBDA * 5; |
612 | 126 } |
1683 | 127 rcc->buffer_index= s->avctx->rc_initial_buffer_occupancy; |
612 | 128 |
129 if(s->flags&CODEC_FLAG_PASS2){ | |
329 | 130 int i; |
612 | 131 char *p; |
329 | 132 |
612 | 133 /* find number of pics */ |
134 p= s->avctx->stats_in; | |
135 for(i=-1; p; i++){ | |
136 p= strchr(p+1, ';'); | |
329 | 137 } |
612 | 138 i+= s->max_b_frames; |
2422 | 139 if(i<=0 || i>=INT_MAX / sizeof(RateControlEntry)) |
140 return -1; | |
612 | 141 rcc->entry = (RateControlEntry*)av_mallocz(i*sizeof(RateControlEntry)); |
142 rcc->num_entries= i; | |
2967 | 143 |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2494
diff
changeset
|
144 /* init all to skipped p frames (with b frames we might have a not encoded frame at the end FIXME) */ |
612 | 145 for(i=0; i<rcc->num_entries; i++){ |
146 RateControlEntry *rce= &rcc->entry[i]; | |
147 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
|
148 rce->qscale= rce->new_qscale=FF_QP2LAMBDA * 2; |
612 | 149 rce->misc_bits= s->mb_num + 10; |
150 rce->mb_var_sum= s->mb_num*100; | |
2967 | 151 } |
152 | |
612 | 153 /* read stats */ |
154 p= s->avctx->stats_in; | |
155 for(i=0; i<rcc->num_entries - s->max_b_frames; i++){ | |
329 | 156 RateControlEntry *rce; |
157 int picture_number; | |
158 int e; | |
612 | 159 char *next; |
160 | |
161 next= strchr(p, ';'); | |
162 if(next){ | |
163 (*next)=0; //sscanf in unbelieavle slow on looong strings //FIXME copy / dont write | |
164 next++; | |
165 } | |
166 e= sscanf(p, " in:%d ", &picture_number); | |
167 | |
168 assert(picture_number >= 0); | |
169 assert(picture_number < rcc->num_entries); | |
329 | 170 rce= &rcc->entry[picture_number]; |
612 | 171 |
3064 | 172 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 skipcount:%d hbits:%d", |
2967 | 173 &rce->pict_type, &rce->qscale, &rce->i_tex_bits, &rce->p_tex_bits, &rce->mv_bits, &rce->misc_bits, |
3064 | 174 &rce->f_code, &rce->b_code, &rce->mc_mb_var_sum, &rce->mb_var_sum, &rce->i_count, &rce->skip_count, &rce->header_bits); |
175 if(e!=14){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1505
diff
changeset
|
176 av_log(s->avctx, AV_LOG_ERROR, "statistics are damaged at line %d, parser out=%d\n", i, e); |
329 | 177 return -1; |
178 } | |
3064 | 179 |
612 | 180 p= next; |
329 | 181 } |
3203 | 182 |
183 if(init_pass2(s) < 0) return -1; | |
184 | |
3200
646f6344472d
make ff_rate_control_init() bail out if rc_strategy==1 and lavc wasn't
corey
parents:
3065
diff
changeset
|
185 //FIXME maybe move to end |
646f6344472d
make ff_rate_control_init() bail out if rc_strategy==1 and lavc wasn't
corey
parents:
3065
diff
changeset
|
186 if((s->flags&CODEC_FLAG_PASS2) && s->avctx->rc_strategy == FF_RC_STRATEGY_XVID) { |
3065 | 187 #ifdef CONFIG_XVID |
3064 | 188 return ff_xvid_rate_control_init(s); |
3200
646f6344472d
make ff_rate_control_init() bail out if rc_strategy==1 and lavc wasn't
corey
parents:
3065
diff
changeset
|
189 #else |
646f6344472d
make ff_rate_control_init() bail out if rc_strategy==1 and lavc wasn't
corey
parents:
3065
diff
changeset
|
190 av_log(s->avctx, AV_LOG_ERROR, "XviD ratecontrol requires libavcodec compiled with XviD support\n"); |
646f6344472d
make ff_rate_control_init() bail out if rc_strategy==1 and lavc wasn't
corey
parents:
3065
diff
changeset
|
191 return -1; |
3065 | 192 #endif |
3200
646f6344472d
make ff_rate_control_init() bail out if rc_strategy==1 and lavc wasn't
corey
parents:
3065
diff
changeset
|
193 } |
329 | 194 } |
2967 | 195 |
612 | 196 if(!(s->flags&CODEC_FLAG_PASS2)){ |
197 | |
198 rcc->short_term_qsum=0.001; | |
199 rcc->short_term_qcount=0.001; | |
2967 | 200 |
707 | 201 rcc->pass1_rc_eq_output_sum= 0.001; |
612 | 202 rcc->pass1_wanted_bits=0.001; |
2967 | 203 |
612 | 204 /* init stuff with the user specified complexity */ |
205 if(s->avctx->rc_initial_cplx){ | |
206 for(i=0; i<60*30; i++){ | |
207 double bits= s->avctx->rc_initial_cplx * (i/10000.0 + 1.0)*s->mb_num; | |
208 RateControlEntry rce; | |
209 double q; | |
2967 | 210 |
612 | 211 if (i%((s->gop_size+3)/4)==0) rce.pict_type= I_TYPE; |
212 else if(i%(s->max_b_frames+1)) rce.pict_type= B_TYPE; | |
213 else rce.pict_type= P_TYPE; | |
214 | |
215 rce.new_pict_type= rce.pict_type; | |
216 rce.mc_mb_var_sum= bits*s->mb_num/100000; | |
217 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
|
218 rce.qscale = FF_QP2LAMBDA * 2; |
612 | 219 rce.f_code = 2; |
220 rce.b_code = 1; | |
221 rce.misc_bits= 1; | |
329 | 222 |
612 | 223 if(s->pict_type== I_TYPE){ |
224 rce.i_count = s->mb_num; | |
225 rce.i_tex_bits= bits; | |
226 rce.p_tex_bits= 0; | |
227 rce.mv_bits= 0; | |
228 }else{ | |
229 rce.i_count = 0; //FIXME we do know this approx | |
230 rce.i_tex_bits= 0; | |
231 rce.p_tex_bits= bits*0.9; | |
232 rce.mv_bits= bits*0.1; | |
233 } | |
234 rcc->i_cplx_sum [rce.pict_type] += rce.i_tex_bits*rce.qscale; | |
235 rcc->p_cplx_sum [rce.pict_type] += rce.p_tex_bits*rce.qscale; | |
236 rcc->mv_bits_sum[rce.pict_type] += rce.mv_bits; | |
237 rcc->frame_count[rce.pict_type] ++; | |
329 | 238 |
612 | 239 bits= rce.i_tex_bits + rce.p_tex_bits; |
240 | |
707 | 241 q= get_qscale(s, &rce, rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum, i); |
2637 | 242 rcc->pass1_wanted_bits+= s->bit_rate/(1/av_q2d(s->avctx->time_base)); //FIXME missbehaves a little for variable fps |
612 | 243 } |
244 } | |
245 | |
246 } | |
2967 | 247 |
329 | 248 return 0; |
249 } | |
250 | |
251 void ff_rate_control_uninit(MpegEncContext *s) | |
252 { | |
253 RateControlContext *rcc= &s->rc_context; | |
254 emms_c(); | |
255 | |
4084 | 256 ff_eval_free(rcc->rc_eq_eval); |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
388
diff
changeset
|
257 av_freep(&rcc->entry); |
3064 | 258 |
3065 | 259 #ifdef CONFIG_XVID |
3064 | 260 if((s->flags&CODEC_FLAG_PASS2) && s->avctx->rc_strategy == FF_RC_STRATEGY_XVID) |
261 ff_xvid_rate_control_uninit(s); | |
3065 | 262 #endif |
329 | 263 } |
264 | |
1684 | 265 int ff_vbv_update(MpegEncContext *s, int frame_size){ |
612 | 266 RateControlContext *rcc= &s->rc_context; |
2637 | 267 const double fps= 1/av_q2d(s->avctx->time_base); |
1697 | 268 const int buffer_size= s->avctx->rc_buffer_size; |
612 | 269 const double min_rate= s->avctx->rc_min_rate/fps; |
270 const double max_rate= s->avctx->rc_max_rate/fps; | |
2967 | 271 |
1697 | 272 //printf("%d %f %d %f %f\n", buffer_size, rcc->buffer_index, frame_size, min_rate, max_rate); |
612 | 273 if(buffer_size){ |
1683 | 274 int left; |
275 | |
612 | 276 rcc->buffer_index-= frame_size; |
1683 | 277 if(rcc->buffer_index < 0){ |
278 av_log(s->avctx, AV_LOG_ERROR, "rc buffer underflow\n"); | |
279 rcc->buffer_index= 0; | |
612 | 280 } |
1683 | 281 |
282 left= buffer_size - rcc->buffer_index - 1; | |
283 rcc->buffer_index += clip(left, min_rate, max_rate); | |
284 | |
1697 | 285 if(rcc->buffer_index > buffer_size){ |
286 int stuffing= ceil((rcc->buffer_index - buffer_size)/8); | |
2967 | 287 |
1684 | 288 if(stuffing < 4 && s->codec_id == CODEC_ID_MPEG4) |
289 stuffing=4; | |
290 rcc->buffer_index -= 8*stuffing; | |
2967 | 291 |
1684 | 292 if(s->avctx->debug & FF_DEBUG_RC) |
293 av_log(s->avctx, AV_LOG_DEBUG, "stuffing %d bytes\n", stuffing); | |
294 | |
295 return stuffing; | |
1683 | 296 } |
612 | 297 } |
1684 | 298 return 0; |
612 | 299 } |
300 | |
301 /** | |
302 * modifies the bitrate curve from pass1 for one frame | |
303 */ | |
304 static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_factor, int frame_num){ | |
305 RateControlContext *rcc= &s->rc_context; | |
1687 | 306 AVCodecContext *a= s->avctx; |
612 | 307 double q, bits; |
308 const int pict_type= rce->new_pict_type; | |
2967 | 309 const double mb_num= s->mb_num; |
612 | 310 int i; |
311 | |
312 double const_values[]={ | |
313 M_PI, | |
314 M_E, | |
315 rce->i_tex_bits*rce->qscale, | |
316 rce->p_tex_bits*rce->qscale, | |
317 (rce->i_tex_bits + rce->p_tex_bits)*(double)rce->qscale, | |
318 rce->mv_bits/mb_num, | |
319 rce->pict_type == B_TYPE ? (rce->f_code + rce->b_code)*0.5 : rce->f_code, | |
320 rce->i_count/mb_num, | |
321 rce->mc_mb_var_sum/mb_num, | |
322 rce->mb_var_sum/mb_num, | |
323 rce->pict_type == I_TYPE, | |
324 rce->pict_type == P_TYPE, | |
325 rce->pict_type == B_TYPE, | |
326 rcc->qscale_sum[pict_type] / (double)rcc->frame_count[pict_type], | |
1687 | 327 a->qcompress, |
612 | 328 /* rcc->last_qscale_for[I_TYPE], |
329 rcc->last_qscale_for[P_TYPE], | |
330 rcc->last_qscale_for[B_TYPE], | |
331 rcc->next_non_b_qscale,*/ | |
332 rcc->i_cplx_sum[I_TYPE] / (double)rcc->frame_count[I_TYPE], | |
333 rcc->i_cplx_sum[P_TYPE] / (double)rcc->frame_count[P_TYPE], | |
334 rcc->p_cplx_sum[P_TYPE] / (double)rcc->frame_count[P_TYPE], | |
335 rcc->p_cplx_sum[B_TYPE] / (double)rcc->frame_count[B_TYPE], | |
336 (rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / (double)rcc->frame_count[pict_type], | |
337 0 | |
338 }; | |
339 | |
4084 | 340 bits= ff_parse_eval(rcc->rc_eq_eval, const_values, rce); |
3766 | 341 if (isnan(bits)) { |
4084 | 342 av_log(s->avctx, AV_LOG_ERROR, "Error evaluating rc_eq \"%s\"\n", s->avctx->rc_eq); |
3766 | 343 return -1; |
344 } | |
2967 | 345 |
707 | 346 rcc->pass1_rc_eq_output_sum+= bits; |
612 | 347 bits*=rate_factor; |
348 if(bits<0.0) bits=0.0; | |
349 bits+= 1.0; //avoid 1/0 issues | |
2967 | 350 |
612 | 351 /* user override */ |
352 for(i=0; i<s->avctx->rc_override_count; i++){ | |
353 RcOverride *rco= s->avctx->rc_override; | |
354 if(rco[i].start_frame > frame_num) continue; | |
355 if(rco[i].end_frame < frame_num) continue; | |
2967 | 356 |
357 if(rco[i].qscale) | |
612 | 358 bits= qp2bits(rce, rco[i].qscale); //FIXME move at end to really force it? |
359 else | |
360 bits*= rco[i].quality_factor; | |
361 } | |
362 | |
363 q= bits2qp(rce, bits); | |
2967 | 364 |
612 | 365 /* I/B difference */ |
366 if (pict_type==I_TYPE && s->avctx->i_quant_factor<0.0) | |
367 q= -q*s->avctx->i_quant_factor + s->avctx->i_quant_offset; | |
368 else if(pict_type==B_TYPE && s->avctx->b_quant_factor<0.0) | |
369 q= -q*s->avctx->b_quant_factor + s->avctx->b_quant_offset; | |
2967 | 370 |
679 | 371 return q; |
372 } | |
373 | |
374 static double get_diff_limited_q(MpegEncContext *s, RateControlEntry *rce, double q){ | |
375 RateControlContext *rcc= &s->rc_context; | |
376 AVCodecContext *a= s->avctx; | |
377 const int pict_type= rce->new_pict_type; | |
378 const double last_p_q = rcc->last_qscale_for[P_TYPE]; | |
379 const double last_non_b_q= rcc->last_qscale_for[rcc->last_non_b_pict_type]; | |
2967 | 380 |
679 | 381 if (pict_type==I_TYPE && (a->i_quant_factor>0.0 || rcc->last_non_b_pict_type==P_TYPE)) |
4001 | 382 q= last_p_q *FFABS(a->i_quant_factor) + a->i_quant_offset; |
679 | 383 else if(pict_type==B_TYPE && a->b_quant_factor>0.0) |
384 q= last_non_b_q* a->b_quant_factor + a->b_quant_offset; | |
385 | |
612 | 386 /* last qscale / qdiff stuff */ |
679 | 387 if(rcc->last_non_b_pict_type==pict_type || pict_type!=I_TYPE){ |
388 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
|
389 const int maxdiff= FF_QP2LAMBDA * a->max_qdiff; |
930 | 390 |
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
|
391 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
|
392 else if(q < last_q - maxdiff) q= last_q - maxdiff; |
679 | 393 } |
612 | 394 |
395 rcc->last_qscale_for[pict_type]= q; //Note we cant do that after blurring | |
2967 | 396 |
679 | 397 if(pict_type!=B_TYPE) |
398 rcc->last_non_b_pict_type= pict_type; | |
399 | |
612 | 400 return q; |
401 } | |
402 | |
403 /** | |
404 * gets the qmin & qmax for pict_type | |
405 */ | |
406 static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type){ | |
2967 | 407 int qmin= s->avctx->lmin; |
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
|
408 int qmax= s->avctx->lmax; |
2967 | 409 |
1365 | 410 assert(qmin <= qmax); |
612 | 411 |
412 if(pict_type==B_TYPE){ | |
4001 | 413 qmin= (int)(qmin*FFABS(s->avctx->b_quant_factor)+s->avctx->b_quant_offset + 0.5); |
414 qmax= (int)(qmax*FFABS(s->avctx->b_quant_factor)+s->avctx->b_quant_offset + 0.5); | |
612 | 415 }else if(pict_type==I_TYPE){ |
4001 | 416 qmin= (int)(qmin*FFABS(s->avctx->i_quant_factor)+s->avctx->i_quant_offset + 0.5); |
417 qmax= (int)(qmax*FFABS(s->avctx->i_quant_factor)+s->avctx->i_quant_offset + 0.5); | |
612 | 418 } |
419 | |
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
|
420 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
|
421 qmax= clip(qmax, 1, FF_LAMBDA_MAX); |
612 | 422 |
1365 | 423 if(qmax<qmin) qmax= qmin; |
2967 | 424 |
612 | 425 *qmin_ret= qmin; |
426 *qmax_ret= qmax; | |
427 } | |
428 | |
429 static double modify_qscale(MpegEncContext *s, RateControlEntry *rce, double q, int frame_num){ | |
430 RateControlContext *rcc= &s->rc_context; | |
431 int qmin, qmax; | |
432 double bits; | |
433 const int pict_type= rce->new_pict_type; | |
434 const double buffer_size= s->avctx->rc_buffer_size; | |
2637 | 435 const double fps= 1/av_q2d(s->avctx->time_base); |
1683 | 436 const double min_rate= s->avctx->rc_min_rate / fps; |
437 const double max_rate= s->avctx->rc_max_rate / fps; | |
2967 | 438 |
612 | 439 get_qminmax(&qmin, &qmax, s, pict_type); |
440 | |
441 /* modulation */ | |
442 if(s->avctx->rc_qmod_freq && frame_num%s->avctx->rc_qmod_freq==0 && pict_type==P_TYPE) | |
443 q*= s->avctx->rc_qmod_amp; | |
444 | |
445 bits= qp2bits(rce, q); | |
678 | 446 //printf("q:%f\n", q); |
612 | 447 /* buffer overflow/underflow protection */ |
448 if(buffer_size){ | |
679 | 449 double expected_size= rcc->buffer_index; |
1697 | 450 double q_limit; |
612 | 451 |
452 if(min_rate){ | |
679 | 453 double d= 2*(buffer_size - expected_size)/buffer_size; |
612 | 454 if(d>1.0) d=1.0; |
678 | 455 else if(d<0.0001) d=0.0001; |
456 q*= pow(d, 1.0/s->avctx->rc_buffer_aggressivity); | |
679 | 457 |
1697 | 458 q_limit= bits2qp(rce, FFMAX((min_rate - buffer_size + rcc->buffer_index)*3, 1)); |
459 if(q > q_limit){ | |
460 if(s->avctx->debug&FF_DEBUG_RC){ | |
461 av_log(s->avctx, AV_LOG_DEBUG, "limiting QP %f -> %f\n", q, q_limit); | |
462 } | |
463 q= q_limit; | |
464 } | |
612 | 465 } |
466 | |
467 if(max_rate){ | |
468 double d= 2*expected_size/buffer_size; | |
469 if(d>1.0) d=1.0; | |
678 | 470 else if(d<0.0001) d=0.0001; |
471 q/= pow(d, 1.0/s->avctx->rc_buffer_aggressivity); | |
679 | 472 |
1697 | 473 q_limit= bits2qp(rce, FFMAX(rcc->buffer_index/3, 1)); |
474 if(q < q_limit){ | |
475 if(s->avctx->debug&FF_DEBUG_RC){ | |
476 av_log(s->avctx, AV_LOG_DEBUG, "limiting QP %f -> %f\n", q, q_limit); | |
477 } | |
478 q= q_limit; | |
479 } | |
612 | 480 } |
481 } | |
678 | 482 //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 | 483 if(s->avctx->rc_qsquish==0.0 || qmin==qmax){ |
612 | 484 if (q<qmin) q=qmin; |
485 else if(q>qmax) q=qmax; | |
486 }else{ | |
487 double min2= log(qmin); | |
488 double max2= log(qmax); | |
2967 | 489 |
612 | 490 q= log(q); |
491 q= (q - min2)/(max2-min2) - 0.5; | |
492 q*= -4.0; | |
493 q= 1.0/(1.0 + exp(q)); | |
494 q= q*(max2-min2) + min2; | |
2967 | 495 |
612 | 496 q= exp(q); |
497 } | |
2967 | 498 |
612 | 499 return q; |
500 } | |
501 | |
329 | 502 //---------------------------------- |
503 // 1 Pass Code | |
504 | |
612 | 505 static double predict_size(Predictor *p, double q, double var) |
329 | 506 { |
507 return p->coeff*var / (q*p->count); | |
508 } | |
509 | |
949 | 510 /* |
612 | 511 static double predict_qp(Predictor *p, double size, double var) |
512 { | |
513 //printf("coeff:%f, count:%f, var:%f, size:%f//\n", p->coeff, p->count, var, size); | |
514 return p->coeff*var / (size*p->count); | |
515 } | |
949 | 516 */ |
612 | 517 |
329 | 518 static void update_predictor(Predictor *p, double q, double var, double size) |
519 { | |
520 double new_coeff= size*q / (var + 1); | |
612 | 521 if(var<10) return; |
329 | 522 |
523 p->count*= p->decay; | |
524 p->coeff*= p->decay; | |
525 p->count++; | |
526 p->coeff+= new_coeff; | |
527 } | |
528 | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
529 static void adaptive_quantization(MpegEncContext *s, double q){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
530 int i; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
531 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
|
532 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
|
533 const float temp_cplx_masking= s->avctx->temporal_cplx_masking; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
534 const float spatial_cplx_masking = s->avctx->spatial_cplx_masking; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
535 const float p_masking = s->avctx->p_masking; |
2493
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
536 const float border_masking = s->avctx->border_masking; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
537 float bits_sum= 0.0; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
538 float cplx_sum= 0.0; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
539 float cplx_tab[s->mb_num]; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
540 float bits_tab[s->mb_num]; |
2494
36d70fbb31c5
mb_lmin/max to limit the per mb quality for the ratecontrol independant from the frame limits
michael
parents:
2493
diff
changeset
|
541 const int qmin= s->avctx->mb_lmin; |
36d70fbb31c5
mb_lmin/max to limit the per mb quality for the ratecontrol independant from the frame limits
michael
parents:
2493
diff
changeset
|
542 const int qmax= s->avctx->mb_lmax; |
903 | 543 Picture * const pic= &s->current_picture; |
2493
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
544 const int mb_width = s->mb_width; |
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
545 const int mb_height = s->mb_height; |
2967 | 546 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
547 for(i=0; i<s->mb_num; i++){ |
1180 | 548 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
|
549 float temp_cplx= sqrt(pic->mc_mb_var[mb_xy]); //FIXME merge in pow() |
1180 | 550 float spat_cplx= sqrt(pic->mb_var[mb_xy]); |
551 const int lumi= pic->mb_mean[mb_xy]; | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
552 float bits, cplx, factor; |
2493
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
553 int mb_x = mb_xy % s->mb_stride; |
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
554 int mb_y = mb_xy / s->mb_stride; |
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
555 int mb_distance; |
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
556 float mb_factor = 0.0; |
2967 | 557 #if 0 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
558 if(spat_cplx < q/3) spat_cplx= q/3; //FIXME finetune |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
559 if(temp_cplx < q/3) temp_cplx= q/3; //FIXME finetune |
2967 | 560 #endif |
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
|
561 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
|
562 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
|
563 |
2967 | 564 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
|
565 cplx= spat_cplx; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
566 factor= 1.0 + p_masking; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
567 }else{ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
568 cplx= temp_cplx; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
569 factor= pow(temp_cplx, - temp_cplx_masking); |
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 factor*=pow(spat_cplx, - spatial_cplx_masking); |
693
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
572 |
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
573 if(lumi>127) |
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
574 factor*= (1.0 - (lumi-128)*(lumi-128)*lumi_masking); |
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
575 else |
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
576 factor*= (1.0 - (lumi-128)*(lumi-128)*dark_masking); |
2493
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
577 |
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
578 if(mb_x < mb_width/5){ |
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
579 mb_distance = mb_width/5 - mb_x; |
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
580 mb_factor = (float)mb_distance / (float)(mb_width/5); |
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
581 }else if(mb_x > 4*mb_width/5){ |
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
582 mb_distance = mb_x - 4*mb_width/5; |
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
583 mb_factor = (float)mb_distance / (float)(mb_width/5); |
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
584 } |
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
585 if(mb_y < mb_height/5){ |
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
586 mb_distance = mb_height/5 - mb_y; |
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
587 mb_factor = FFMAX(mb_factor, (float)mb_distance / (float)(mb_height/5)); |
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
588 }else if(mb_y > 4*mb_height/5){ |
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
589 mb_distance = mb_y - 4*mb_height/5; |
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
590 mb_factor = FFMAX(mb_factor, (float)mb_distance / (float)(mb_height/5)); |
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
591 } |
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
592 |
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
593 factor*= 1.0 - border_masking*mb_factor; |
2967 | 594 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
595 if(factor<0.00001) factor= 0.00001; |
2967 | 596 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
597 bits= cplx*factor; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
598 cplx_sum+= cplx; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
599 bits_sum+= bits; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
600 cplx_tab[i]= cplx; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
601 bits_tab[i]= bits; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
602 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
603 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
604 /* handle qmin/qmax cliping */ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
605 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
|
606 float factor= bits_sum/cplx_sum; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
607 for(i=0; i<s->mb_num; i++){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
608 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
|
609 newq*= factor; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
610 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
611 if (newq > qmax){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
612 bits_sum -= bits_tab[i]; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
613 cplx_sum -= cplx_tab[i]*q/qmax; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
614 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
615 else if(newq < qmin){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
616 bits_sum -= bits_tab[i]; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
617 cplx_sum -= cplx_tab[i]*q/qmin; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
618 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
619 } |
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
|
620 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
|
621 if(cplx_sum < 0.001) cplx_sum= 0.001; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
622 } |
2967 | 623 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
624 for(i=0; i<s->mb_num; i++){ |
1180 | 625 const int mb_xy= s->mb_index2xy[i]; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
626 float newq= q*cplx_tab[i]/bits_tab[i]; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
627 int intq; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
628 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
629 if(s->flags&CODEC_FLAG_NORMALIZE_AQP){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
630 newq*= bits_sum/cplx_sum; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
631 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
632 |
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
|
633 intq= (int)(newq + 0.5); |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
634 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
635 if (intq > qmax) intq= qmax; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
636 else if(intq < qmin) intq= qmin; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
637 //if(i%s->mb_width==0) printf("\n"); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
638 //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
|
639 s->lambda_table[mb_xy]= intq; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
640 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
641 } |
2981 | 642 |
643 void ff_get_2pass_fcode(MpegEncContext *s){ | |
644 RateControlContext *rcc= &s->rc_context; | |
645 int picture_number= s->picture_number; | |
646 RateControlEntry *rce; | |
647 | |
648 rce= &rcc->entry[picture_number]; | |
649 s->f_code= rce->f_code; | |
650 s->b_code= rce->b_code; | |
651 } | |
652 | |
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
|
653 //FIXME rd or at least approx for dquant |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
654 |
2974 | 655 float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run) |
329 | 656 { |
657 float q; | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
658 int qmin, qmax; |
329 | 659 float br_compensation; |
660 double diff; | |
661 double short_term_q; | |
662 double fps; | |
612 | 663 int picture_number= s->picture_number; |
329 | 664 int64_t wanted_bits; |
612 | 665 RateControlContext *rcc= &s->rc_context; |
1687 | 666 AVCodecContext *a= s->avctx; |
612 | 667 RateControlEntry local_rce, *rce; |
668 double bits; | |
669 double rate_factor; | |
670 int var; | |
671 const int pict_type= s->pict_type; | |
903 | 672 Picture * const pic= &s->current_picture; |
329 | 673 emms_c(); |
674 | |
3065 | 675 #ifdef CONFIG_XVID |
3064 | 676 if((s->flags&CODEC_FLAG_PASS2) && s->avctx->rc_strategy == FF_RC_STRATEGY_XVID) |
677 return ff_xvid_rate_estimate_qscale(s, dry_run); | |
3065 | 678 #endif |
3064 | 679 |
612 | 680 get_qminmax(&qmin, &qmax, s, pict_type); |
681 | |
2637 | 682 fps= 1/av_q2d(s->avctx->time_base); |
678 | 683 //printf("input_pic_num:%d pic_num:%d frame_rate:%d\n", s->input_picture_number, s->picture_number, s->frame_rate); |
329 | 684 /* update predictors */ |
2974 | 685 if(picture_number>2 && !dry_run){ |
612 | 686 const int last_var= s->last_pict_type == I_TYPE ? rcc->last_mb_var_sum : rcc->last_mc_mb_var_sum; |
687 update_predictor(&rcc->pred[s->last_pict_type], rcc->last_qscale, sqrt(last_var), s->frame_bits); | |
329 | 688 } |
689 | |
612 | 690 if(s->flags&CODEC_FLAG_PASS2){ |
691 assert(picture_number>=0); | |
692 assert(picture_number<rcc->num_entries); | |
693 rce= &rcc->entry[picture_number]; | |
694 wanted_bits= rce->expected_bits; | |
695 }else{ | |
696 rce= &local_rce; | |
697 wanted_bits= (uint64_t)(s->bit_rate*(double)picture_number/fps); | |
329 | 698 } |
699 | |
700 diff= s->total_bits - wanted_bits; | |
1687 | 701 br_compensation= (a->bit_rate_tolerance - diff)/a->bit_rate_tolerance; |
329 | 702 if(br_compensation<=0.0) br_compensation=0.001; |
612 | 703 |
903 | 704 var= pict_type == I_TYPE ? pic->mb_var_sum : pic->mc_mb_var_sum; |
2967 | 705 |
1455 | 706 short_term_q = 0; /* avoid warning */ |
612 | 707 if(s->flags&CODEC_FLAG_PASS2){ |
708 if(pict_type!=I_TYPE) | |
709 assert(pict_type == rce->new_pict_type); | |
710 | |
711 q= rce->new_qscale / br_compensation; | |
712 //printf("%f %f %f last:%d var:%d type:%d//\n", q, rce->new_qscale, br_compensation, s->frame_bits, var, pict_type); | |
713 }else{ | |
2967 | 714 rce->pict_type= |
612 | 715 rce->new_pict_type= pict_type; |
903 | 716 rce->mc_mb_var_sum= pic->mc_mb_var_sum; |
717 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
|
718 rce->qscale = FF_QP2LAMBDA * 2; |
612 | 719 rce->f_code = s->f_code; |
720 rce->b_code = s->b_code; | |
721 rce->misc_bits= 1; | |
722 | |
723 bits= predict_size(&rcc->pred[pict_type], rce->qscale, sqrt(var)); | |
724 if(pict_type== I_TYPE){ | |
725 rce->i_count = s->mb_num; | |
726 rce->i_tex_bits= bits; | |
727 rce->p_tex_bits= 0; | |
728 rce->mv_bits= 0; | |
729 }else{ | |
730 rce->i_count = 0; //FIXME we do know this approx | |
731 rce->i_tex_bits= 0; | |
732 rce->p_tex_bits= bits*0.9; | |
2967 | 733 |
612 | 734 rce->mv_bits= bits*0.1; |
735 } | |
736 rcc->i_cplx_sum [pict_type] += rce->i_tex_bits*rce->qscale; | |
737 rcc->p_cplx_sum [pict_type] += rce->p_tex_bits*rce->qscale; | |
738 rcc->mv_bits_sum[pict_type] += rce->mv_bits; | |
739 rcc->frame_count[pict_type] ++; | |
740 | |
741 bits= rce->i_tex_bits + rce->p_tex_bits; | |
707 | 742 rate_factor= rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum * br_compensation; |
2967 | 743 |
612 | 744 q= get_qscale(s, rce, rate_factor, picture_number); |
3766 | 745 if (q < 0) |
746 return -1; | |
612 | 747 |
615 | 748 assert(q>0.0); |
612 | 749 //printf("%f ", q); |
679 | 750 q= get_diff_limited_q(s, rce, q); |
612 | 751 //printf("%f ", q); |
752 assert(q>0.0); | |
753 | |
754 if(pict_type==P_TYPE || s->intra_only){ //FIXME type dependant blur like in 2-pass | |
1687 | 755 rcc->short_term_qsum*=a->qblur; |
756 rcc->short_term_qcount*=a->qblur; | |
612 | 757 |
758 rcc->short_term_qsum+= q; | |
759 rcc->short_term_qcount++; | |
760 //printf("%f ", q); | |
761 q= short_term_q= rcc->short_term_qsum/rcc->short_term_qcount; | |
762 //printf("%f ", q); | |
763 } | |
678 | 764 assert(q>0.0); |
2967 | 765 |
612 | 766 q= modify_qscale(s, rce, q, picture_number); |
767 | |
768 rcc->pass1_wanted_bits+= s->bit_rate/fps; | |
769 | |
615 | 770 assert(q>0.0); |
612 | 771 } |
930 | 772 |
773 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
|
774 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 | 775 av_get_pict_type_char(pict_type), qmin, q, qmax, picture_number, (int)wanted_bits/1000, (int)s->total_bits/1000, |
930 | 776 br_compensation, short_term_q, s->frame_bits, pic->mb_var_sum, pic->mc_mb_var_sum, s->bit_rate/1000, (int)fps |
777 ); | |
778 } | |
612 | 779 |
2967 | 780 if (q<qmin) q=qmin; |
612 | 781 else if(q>qmax) q=qmax; |
782 | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
783 if(s->adaptive_quant) |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
784 adaptive_quantization(s, q); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
785 else |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
786 q= (int)(q + 0.5); |
2967 | 787 |
2974 | 788 if(!dry_run){ |
789 rcc->last_qscale= q; | |
790 rcc->last_mc_mb_var_sum= pic->mc_mb_var_sum; | |
791 rcc->last_mb_var_sum= pic->mb_var_sum; | |
792 } | |
903 | 793 #if 0 |
794 { | |
795 static int mvsum=0, texsum=0; | |
796 mvsum += s->mv_bits; | |
797 texsum += s->i_tex_bits + s->p_tex_bits; | |
798 printf("%d %d//\n\n", mvsum, texsum); | |
799 } | |
800 #endif | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
801 return q; |
329 | 802 } |
803 | |
804 //---------------------------------------------- | |
805 // 2-Pass code | |
806 | |
807 static int init_pass2(MpegEncContext *s) | |
808 { | |
809 RateControlContext *rcc= &s->rc_context; | |
1687 | 810 AVCodecContext *a= s->avctx; |
3681 | 811 int i, toobig; |
2637 | 812 double fps= 1/av_q2d(s->avctx->time_base); |
329 | 813 double complexity[5]={0,0,0,0,0}; // aproximate bits at quant=1 |
814 uint64_t const_bits[5]={0,0,0,0,0}; // quantizer idependant bits | |
815 uint64_t all_const_bits; | |
816 uint64_t all_available_bits= (uint64_t)(s->bit_rate*(double)rcc->num_entries/fps); | |
817 double rate_factor=0; | |
818 double step; | |
949 | 819 //int last_i_frame=-10000000; |
2967 | 820 const int filter_size= (int)(a->qblur*4) | 1; |
612 | 821 double expected_bits; |
3681 | 822 double *qscale, *blured_qscale, qscale_sum; |
329 | 823 |
824 /* find complexity & const_bits & decide the pict_types */ | |
825 for(i=0; i<rcc->num_entries; i++){ | |
826 RateControlEntry *rce= &rcc->entry[i]; | |
2967 | 827 |
915 | 828 rce->new_pict_type= rce->pict_type; |
612 | 829 rcc->i_cplx_sum [rce->pict_type] += rce->i_tex_bits*rce->qscale; |
830 rcc->p_cplx_sum [rce->pict_type] += rce->p_tex_bits*rce->qscale; | |
831 rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits; | |
832 rcc->frame_count[rce->pict_type] ++; | |
329 | 833 |
834 complexity[rce->new_pict_type]+= (rce->i_tex_bits+ rce->p_tex_bits)*(double)rce->qscale; | |
835 const_bits[rce->new_pict_type]+= rce->mv_bits + rce->misc_bits; | |
836 } | |
837 all_const_bits= const_bits[I_TYPE] + const_bits[P_TYPE] + const_bits[B_TYPE]; | |
2967 | 838 |
329 | 839 if(all_available_bits < all_const_bits){ |
3674 | 840 av_log(s->avctx, AV_LOG_ERROR, "requested bitrate is too low\n"); |
329 | 841 return -1; |
842 } | |
2967 | 843 |
1031
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
977
diff
changeset
|
844 qscale= av_malloc(sizeof(double)*rcc->num_entries); |
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
977
diff
changeset
|
845 blured_qscale= av_malloc(sizeof(double)*rcc->num_entries); |
3681 | 846 toobig = 0; |
612 | 847 |
329 | 848 for(step=256*256; step>0.0000001; step*=0.5){ |
612 | 849 expected_bits=0; |
329 | 850 rate_factor+= step; |
2967 | 851 |
612 | 852 rcc->buffer_index= s->avctx->rc_buffer_size/2; |
853 | |
329 | 854 /* find qscale */ |
855 for(i=0; i<rcc->num_entries; i++){ | |
612 | 856 qscale[i]= get_qscale(s, &rcc->entry[i], rate_factor, i); |
857 } | |
858 assert(filter_size%2==1); | |
329 | 859 |
612 | 860 /* fixed I/B QP relative to P mode */ |
861 for(i=rcc->num_entries-1; i>=0; i--){ | |
862 RateControlEntry *rce= &rcc->entry[i]; | |
2967 | 863 |
679 | 864 qscale[i]= get_diff_limited_q(s, rce, qscale[i]); |
329 | 865 } |
866 | |
867 /* smooth curve */ | |
612 | 868 for(i=0; i<rcc->num_entries; i++){ |
869 RateControlEntry *rce= &rcc->entry[i]; | |
870 const int pict_type= rce->new_pict_type; | |
871 int j; | |
872 double q=0.0, sum=0.0; | |
2967 | 873 |
612 | 874 for(j=0; j<filter_size; j++){ |
875 int index= i+j-filter_size/2; | |
876 double d= index-i; | |
1687 | 877 double coeff= a->qblur==0 ? 1.0 : exp(-d*d/(a->qblur * a->qblur)); |
2967 | 878 |
612 | 879 if(index < 0 || index >= rcc->num_entries) continue; |
880 if(pict_type != rcc->entry[index].new_pict_type) continue; | |
881 q+= qscale[index] * coeff; | |
882 sum+= coeff; | |
883 } | |
884 blured_qscale[i]= q/sum; | |
885 } | |
2967 | 886 |
329 | 887 /* find expected bits */ |
888 for(i=0; i<rcc->num_entries; i++){ | |
889 RateControlEntry *rce= &rcc->entry[i]; | |
612 | 890 double bits; |
891 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
|
892 bits= qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits; |
612 | 893 //printf("%d %f\n", rce->new_bits, blured_qscale[i]); |
1684 | 894 bits += 8*ff_vbv_update(s, bits); |
612 | 895 |
329 | 896 rce->expected_bits= expected_bits; |
612 | 897 expected_bits += bits; |
329 | 898 } |
899 | |
3681 | 900 /* |
901 av_log(s->avctx, AV_LOG_INFO, | |
902 "expected_bits: %f all_available_bits: %d rate_factor: %f\n", | |
903 expected_bits, (int)all_available_bits, rate_factor); | |
904 */ | |
905 if(expected_bits > all_available_bits) { | |
906 rate_factor-= step; | |
907 ++toobig; | |
908 } | |
329 | 909 } |
1031
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
977
diff
changeset
|
910 av_free(qscale); |
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
977
diff
changeset
|
911 av_free(blured_qscale); |
612 | 912 |
3681 | 913 /* check bitrate calculations and print info */ |
914 qscale_sum = 0.0; | |
915 for(i=0; i<rcc->num_entries; i++){ | |
916 /* av_log(s->avctx, AV_LOG_DEBUG, "[lavc rc] entry[%d].new_qscale = %.3f qp = %.3f\n", | |
917 i, rcc->entry[i].new_qscale, rcc->entry[i].new_qscale / FF_QP2LAMBDA); */ | |
918 qscale_sum += clip(rcc->entry[i].new_qscale / FF_QP2LAMBDA, s->avctx->qmin, s->avctx->qmax); | |
919 } | |
920 assert(toobig <= 40); | |
921 av_log(s->avctx, AV_LOG_DEBUG, | |
922 "[lavc rc] requested bitrate: %d bps expected bitrate: %d bps\n", | |
923 s->bit_rate, | |
924 (int)(expected_bits / ((double)all_available_bits/s->bit_rate))); | |
925 av_log(s->avctx, AV_LOG_DEBUG, | |
926 "[lavc rc] estimated target average qp: %.3f\n", | |
927 (float)qscale_sum / rcc->num_entries); | |
928 if (toobig == 0) { | |
929 av_log(s->avctx, AV_LOG_INFO, | |
930 "[lavc rc] Using all of requested bitrate is not " | |
931 "necessary for this video with these parameters.\n"); | |
932 } else if (toobig == 40) { | |
933 av_log(s->avctx, AV_LOG_ERROR, | |
934 "[lavc rc] Error: bitrate too low for this video " | |
935 "with these parameters.\n"); | |
936 return -1; | |
937 } else if (fabs(expected_bits/all_available_bits - 1.0) > 0.01) { | |
938 av_log(s->avctx, AV_LOG_ERROR, | |
939 "[lavc rc] Error: 2pass curve failed to converge\n"); | |
612 | 940 return -1; |
941 } | |
329 | 942 |
943 return 0; | |
944 } |