Mercurial > libavcodec.hg
annotate ratecontrol.c @ 8228:416ffc3907bf libavcodec
Remove ineffectual hack that attempts to build ppc/check_altivec.o without
AltiVec flags. The flags are set by configure and used to compile all files
anyway. Setting extra AltiVec options here just duplicates them for the files
for which they are set.
author | diego |
---|---|
date | Sun, 30 Nov 2008 16:57:28 +0000 |
parents | 596677256482 |
children | 7a463923ecd1 |
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 |
4795 | 34 #undef NDEBUG // Always check asserts, the speed effect is far too small to disable them. |
612 | 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; |
6373 | 69 const char *error = NULL; |
7129 | 70 static const char * const const_names[]={ |
4084 | 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 }; | |
7978 | 97 static double (* const func1[])(void *, double)={ |
4084 | 98 (void *)bits2qp, |
99 (void *)qp2bits, | |
100 NULL | |
101 }; | |
7129 | 102 static const char * const func1_names[]={ |
4084 | 103 "bits2qp", |
104 "qp2bits", | |
105 NULL | |
106 }; | |
329 | 107 emms_c(); |
108 | |
7587 | 109 rcc->rc_eq_eval = ff_parse(s->avctx->rc_eq ? s->avctx->rc_eq : "tex^qComp", const_names, func1, func1_names, NULL, NULL, &error); |
4084 | 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]= | |
6525 | 124 rcc->frame_count[i]= 1; // 1 is better because 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; | |
5958
ed05a3d964fa
stupid code (casting of void*) found by checktree.sh
michael
parents:
5672
diff
changeset
|
141 rcc->entry = av_mallocz(i*sizeof(RateControlEntry)); |
612 | 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]; | |
6481 | 147 rce->pict_type= rce->new_pict_type=FF_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){ | |
5127 | 163 (*next)=0; //sscanf in unbelievably slow on looong strings //FIXME copy / do not write |
612 | 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) { |
5203 | 187 #ifdef CONFIG_LIBXVID |
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 |
6908 | 190 av_log(s->avctx, AV_LOG_ERROR, "Xvid ratecontrol requires libavcodec compiled with Xvid support.\n"); |
3200
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 |
5087
6c7f4ece59ed
check qblur > 1 (prevent assert failure / segfault)
michael
parents:
4795
diff
changeset
|
204 if(s->avctx->qblur > 1.0){ |
6c7f4ece59ed
check qblur > 1 (prevent assert failure / segfault)
michael
parents:
4795
diff
changeset
|
205 av_log(s->avctx, AV_LOG_ERROR, "qblur too large\n"); |
6c7f4ece59ed
check qblur > 1 (prevent assert failure / segfault)
michael
parents:
4795
diff
changeset
|
206 return -1; |
6c7f4ece59ed
check qblur > 1 (prevent assert failure / segfault)
michael
parents:
4795
diff
changeset
|
207 } |
612 | 208 /* init stuff with the user specified complexity */ |
209 if(s->avctx->rc_initial_cplx){ | |
210 for(i=0; i<60*30; i++){ | |
211 double bits= s->avctx->rc_initial_cplx * (i/10000.0 + 1.0)*s->mb_num; | |
212 RateControlEntry rce; | |
213 double q; | |
2967 | 214 |
6481 | 215 if (i%((s->gop_size+3)/4)==0) rce.pict_type= FF_I_TYPE; |
216 else if(i%(s->max_b_frames+1)) rce.pict_type= FF_B_TYPE; | |
217 else rce.pict_type= FF_P_TYPE; | |
612 | 218 |
219 rce.new_pict_type= rce.pict_type; | |
220 rce.mc_mb_var_sum= bits*s->mb_num/100000; | |
221 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
|
222 rce.qscale = FF_QP2LAMBDA * 2; |
612 | 223 rce.f_code = 2; |
224 rce.b_code = 1; | |
225 rce.misc_bits= 1; | |
329 | 226 |
6481 | 227 if(s->pict_type== FF_I_TYPE){ |
612 | 228 rce.i_count = s->mb_num; |
229 rce.i_tex_bits= bits; | |
230 rce.p_tex_bits= 0; | |
231 rce.mv_bits= 0; | |
232 }else{ | |
233 rce.i_count = 0; //FIXME we do know this approx | |
234 rce.i_tex_bits= 0; | |
235 rce.p_tex_bits= bits*0.9; | |
236 rce.mv_bits= bits*0.1; | |
237 } | |
238 rcc->i_cplx_sum [rce.pict_type] += rce.i_tex_bits*rce.qscale; | |
239 rcc->p_cplx_sum [rce.pict_type] += rce.p_tex_bits*rce.qscale; | |
240 rcc->mv_bits_sum[rce.pict_type] += rce.mv_bits; | |
241 rcc->frame_count[rce.pict_type] ++; | |
329 | 242 |
612 | 243 bits= rce.i_tex_bits + rce.p_tex_bits; |
244 | |
707 | 245 q= get_qscale(s, &rce, rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum, i); |
5408 | 246 rcc->pass1_wanted_bits+= s->bit_rate/(1/av_q2d(s->avctx->time_base)); //FIXME misbehaves a little for variable fps |
612 | 247 } |
248 } | |
249 | |
250 } | |
2967 | 251 |
329 | 252 return 0; |
253 } | |
254 | |
255 void ff_rate_control_uninit(MpegEncContext *s) | |
256 { | |
257 RateControlContext *rcc= &s->rc_context; | |
258 emms_c(); | |
259 | |
4084 | 260 ff_eval_free(rcc->rc_eq_eval); |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
388
diff
changeset
|
261 av_freep(&rcc->entry); |
3064 | 262 |
5203 | 263 #ifdef CONFIG_LIBXVID |
3064 | 264 if((s->flags&CODEC_FLAG_PASS2) && s->avctx->rc_strategy == FF_RC_STRATEGY_XVID) |
265 ff_xvid_rate_control_uninit(s); | |
3065 | 266 #endif |
329 | 267 } |
268 | |
1684 | 269 int ff_vbv_update(MpegEncContext *s, int frame_size){ |
612 | 270 RateControlContext *rcc= &s->rc_context; |
2637 | 271 const double fps= 1/av_q2d(s->avctx->time_base); |
1697 | 272 const int buffer_size= s->avctx->rc_buffer_size; |
612 | 273 const double min_rate= s->avctx->rc_min_rate/fps; |
274 const double max_rate= s->avctx->rc_max_rate/fps; | |
2967 | 275 |
1697 | 276 //printf("%d %f %d %f %f\n", buffer_size, rcc->buffer_index, frame_size, min_rate, max_rate); |
612 | 277 if(buffer_size){ |
1683 | 278 int left; |
279 | |
612 | 280 rcc->buffer_index-= frame_size; |
1683 | 281 if(rcc->buffer_index < 0){ |
282 av_log(s->avctx, AV_LOG_ERROR, "rc buffer underflow\n"); | |
283 rcc->buffer_index= 0; | |
612 | 284 } |
1683 | 285 |
286 left= buffer_size - rcc->buffer_index - 1; | |
4594 | 287 rcc->buffer_index += av_clip(left, min_rate, max_rate); |
1683 | 288 |
1697 | 289 if(rcc->buffer_index > buffer_size){ |
290 int stuffing= ceil((rcc->buffer_index - buffer_size)/8); | |
2967 | 291 |
1684 | 292 if(stuffing < 4 && s->codec_id == CODEC_ID_MPEG4) |
293 stuffing=4; | |
294 rcc->buffer_index -= 8*stuffing; | |
2967 | 295 |
1684 | 296 if(s->avctx->debug & FF_DEBUG_RC) |
297 av_log(s->avctx, AV_LOG_DEBUG, "stuffing %d bytes\n", stuffing); | |
298 | |
299 return stuffing; | |
1683 | 300 } |
612 | 301 } |
1684 | 302 return 0; |
612 | 303 } |
304 | |
305 /** | |
306 * modifies the bitrate curve from pass1 for one frame | |
307 */ | |
308 static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_factor, int frame_num){ | |
309 RateControlContext *rcc= &s->rc_context; | |
1687 | 310 AVCodecContext *a= s->avctx; |
612 | 311 double q, bits; |
312 const int pict_type= rce->new_pict_type; | |
2967 | 313 const double mb_num= s->mb_num; |
612 | 314 int i; |
315 | |
316 double const_values[]={ | |
317 M_PI, | |
318 M_E, | |
319 rce->i_tex_bits*rce->qscale, | |
320 rce->p_tex_bits*rce->qscale, | |
321 (rce->i_tex_bits + rce->p_tex_bits)*(double)rce->qscale, | |
322 rce->mv_bits/mb_num, | |
6481 | 323 rce->pict_type == FF_B_TYPE ? (rce->f_code + rce->b_code)*0.5 : rce->f_code, |
612 | 324 rce->i_count/mb_num, |
325 rce->mc_mb_var_sum/mb_num, | |
326 rce->mb_var_sum/mb_num, | |
6481 | 327 rce->pict_type == FF_I_TYPE, |
328 rce->pict_type == FF_P_TYPE, | |
329 rce->pict_type == FF_B_TYPE, | |
612 | 330 rcc->qscale_sum[pict_type] / (double)rcc->frame_count[pict_type], |
1687 | 331 a->qcompress, |
6481 | 332 /* rcc->last_qscale_for[FF_I_TYPE], |
333 rcc->last_qscale_for[FF_P_TYPE], | |
334 rcc->last_qscale_for[FF_B_TYPE], | |
612 | 335 rcc->next_non_b_qscale,*/ |
6481 | 336 rcc->i_cplx_sum[FF_I_TYPE] / (double)rcc->frame_count[FF_I_TYPE], |
337 rcc->i_cplx_sum[FF_P_TYPE] / (double)rcc->frame_count[FF_P_TYPE], | |
338 rcc->p_cplx_sum[FF_P_TYPE] / (double)rcc->frame_count[FF_P_TYPE], | |
339 rcc->p_cplx_sum[FF_B_TYPE] / (double)rcc->frame_count[FF_B_TYPE], | |
612 | 340 (rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / (double)rcc->frame_count[pict_type], |
341 0 | |
342 }; | |
343 | |
4084 | 344 bits= ff_parse_eval(rcc->rc_eq_eval, const_values, rce); |
3766 | 345 if (isnan(bits)) { |
4084 | 346 av_log(s->avctx, AV_LOG_ERROR, "Error evaluating rc_eq \"%s\"\n", s->avctx->rc_eq); |
3766 | 347 return -1; |
348 } | |
2967 | 349 |
707 | 350 rcc->pass1_rc_eq_output_sum+= bits; |
612 | 351 bits*=rate_factor; |
352 if(bits<0.0) bits=0.0; | |
353 bits+= 1.0; //avoid 1/0 issues | |
2967 | 354 |
612 | 355 /* user override */ |
356 for(i=0; i<s->avctx->rc_override_count; i++){ | |
357 RcOverride *rco= s->avctx->rc_override; | |
358 if(rco[i].start_frame > frame_num) continue; | |
359 if(rco[i].end_frame < frame_num) continue; | |
2967 | 360 |
361 if(rco[i].qscale) | |
612 | 362 bits= qp2bits(rce, rco[i].qscale); //FIXME move at end to really force it? |
363 else | |
364 bits*= rco[i].quality_factor; | |
365 } | |
366 | |
367 q= bits2qp(rce, bits); | |
2967 | 368 |
612 | 369 /* I/B difference */ |
6481 | 370 if (pict_type==FF_I_TYPE && s->avctx->i_quant_factor<0.0) |
612 | 371 q= -q*s->avctx->i_quant_factor + s->avctx->i_quant_offset; |
6481 | 372 else if(pict_type==FF_B_TYPE && s->avctx->b_quant_factor<0.0) |
612 | 373 q= -q*s->avctx->b_quant_factor + s->avctx->b_quant_offset; |
5421 | 374 if(q<1) q=1; |
2967 | 375 |
679 | 376 return q; |
377 } | |
378 | |
379 static double get_diff_limited_q(MpegEncContext *s, RateControlEntry *rce, double q){ | |
380 RateControlContext *rcc= &s->rc_context; | |
381 AVCodecContext *a= s->avctx; | |
382 const int pict_type= rce->new_pict_type; | |
6481 | 383 const double last_p_q = rcc->last_qscale_for[FF_P_TYPE]; |
679 | 384 const double last_non_b_q= rcc->last_qscale_for[rcc->last_non_b_pict_type]; |
2967 | 385 |
6481 | 386 if (pict_type==FF_I_TYPE && (a->i_quant_factor>0.0 || rcc->last_non_b_pict_type==FF_P_TYPE)) |
4001 | 387 q= last_p_q *FFABS(a->i_quant_factor) + a->i_quant_offset; |
6481 | 388 else if(pict_type==FF_B_TYPE && a->b_quant_factor>0.0) |
679 | 389 q= last_non_b_q* a->b_quant_factor + a->b_quant_offset; |
5421 | 390 if(q<1) q=1; |
679 | 391 |
612 | 392 /* last qscale / qdiff stuff */ |
6481 | 393 if(rcc->last_non_b_pict_type==pict_type || pict_type!=FF_I_TYPE){ |
679 | 394 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
|
395 const int maxdiff= FF_QP2LAMBDA * a->max_qdiff; |
930 | 396 |
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
|
397 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
|
398 else if(q < last_q - maxdiff) q= last_q - maxdiff; |
679 | 399 } |
612 | 400 |
5127 | 401 rcc->last_qscale_for[pict_type]= q; //Note we cannot do that after blurring |
2967 | 402 |
6481 | 403 if(pict_type!=FF_B_TYPE) |
679 | 404 rcc->last_non_b_pict_type= pict_type; |
405 | |
612 | 406 return q; |
407 } | |
408 | |
409 /** | |
410 * gets the qmin & qmax for pict_type | |
411 */ | |
412 static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type){ | |
2967 | 413 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
|
414 int qmax= s->avctx->lmax; |
2967 | 415 |
1365 | 416 assert(qmin <= qmax); |
612 | 417 |
6481 | 418 if(pict_type==FF_B_TYPE){ |
4001 | 419 qmin= (int)(qmin*FFABS(s->avctx->b_quant_factor)+s->avctx->b_quant_offset + 0.5); |
420 qmax= (int)(qmax*FFABS(s->avctx->b_quant_factor)+s->avctx->b_quant_offset + 0.5); | |
6481 | 421 }else if(pict_type==FF_I_TYPE){ |
4001 | 422 qmin= (int)(qmin*FFABS(s->avctx->i_quant_factor)+s->avctx->i_quant_offset + 0.5); |
423 qmax= (int)(qmax*FFABS(s->avctx->i_quant_factor)+s->avctx->i_quant_offset + 0.5); | |
612 | 424 } |
425 | |
4594 | 426 qmin= av_clip(qmin, 1, FF_LAMBDA_MAX); |
427 qmax= av_clip(qmax, 1, FF_LAMBDA_MAX); | |
612 | 428 |
1365 | 429 if(qmax<qmin) qmax= qmin; |
2967 | 430 |
612 | 431 *qmin_ret= qmin; |
432 *qmax_ret= qmax; | |
433 } | |
434 | |
435 static double modify_qscale(MpegEncContext *s, RateControlEntry *rce, double q, int frame_num){ | |
436 RateControlContext *rcc= &s->rc_context; | |
437 int qmin, qmax; | |
438 double bits; | |
439 const int pict_type= rce->new_pict_type; | |
440 const double buffer_size= s->avctx->rc_buffer_size; | |
2637 | 441 const double fps= 1/av_q2d(s->avctx->time_base); |
1683 | 442 const double min_rate= s->avctx->rc_min_rate / fps; |
443 const double max_rate= s->avctx->rc_max_rate / fps; | |
2967 | 444 |
612 | 445 get_qminmax(&qmin, &qmax, s, pict_type); |
446 | |
447 /* modulation */ | |
6481 | 448 if(s->avctx->rc_qmod_freq && frame_num%s->avctx->rc_qmod_freq==0 && pict_type==FF_P_TYPE) |
612 | 449 q*= s->avctx->rc_qmod_amp; |
450 | |
451 bits= qp2bits(rce, q); | |
678 | 452 //printf("q:%f\n", q); |
612 | 453 /* buffer overflow/underflow protection */ |
454 if(buffer_size){ | |
679 | 455 double expected_size= rcc->buffer_index; |
1697 | 456 double q_limit; |
612 | 457 |
458 if(min_rate){ | |
679 | 459 double d= 2*(buffer_size - expected_size)/buffer_size; |
612 | 460 if(d>1.0) d=1.0; |
678 | 461 else if(d<0.0001) d=0.0001; |
462 q*= pow(d, 1.0/s->avctx->rc_buffer_aggressivity); | |
679 | 463 |
8227 | 464 q_limit= bits2qp(rce, FFMAX((min_rate - buffer_size + rcc->buffer_index) * s->avctx->rc_min_vbv_overflow_use, 1)); |
1697 | 465 if(q > q_limit){ |
466 if(s->avctx->debug&FF_DEBUG_RC){ | |
467 av_log(s->avctx, AV_LOG_DEBUG, "limiting QP %f -> %f\n", q, q_limit); | |
468 } | |
469 q= q_limit; | |
470 } | |
612 | 471 } |
472 | |
473 if(max_rate){ | |
474 double d= 2*expected_size/buffer_size; | |
475 if(d>1.0) d=1.0; | |
678 | 476 else if(d<0.0001) d=0.0001; |
477 q/= pow(d, 1.0/s->avctx->rc_buffer_aggressivity); | |
679 | 478 |
8227 | 479 q_limit= bits2qp(rce, FFMAX(rcc->buffer_index * s->avctx->rc_max_available_vbv_use, 1)); |
1697 | 480 if(q < q_limit){ |
481 if(s->avctx->debug&FF_DEBUG_RC){ | |
482 av_log(s->avctx, AV_LOG_DEBUG, "limiting QP %f -> %f\n", q, q_limit); | |
483 } | |
484 q= q_limit; | |
485 } | |
612 | 486 } |
487 } | |
678 | 488 //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 | 489 if(s->avctx->rc_qsquish==0.0 || qmin==qmax){ |
612 | 490 if (q<qmin) q=qmin; |
491 else if(q>qmax) q=qmax; | |
492 }else{ | |
493 double min2= log(qmin); | |
494 double max2= log(qmax); | |
2967 | 495 |
612 | 496 q= log(q); |
497 q= (q - min2)/(max2-min2) - 0.5; | |
498 q*= -4.0; | |
499 q= 1.0/(1.0 + exp(q)); | |
500 q= q*(max2-min2) + min2; | |
2967 | 501 |
612 | 502 q= exp(q); |
503 } | |
2967 | 504 |
612 | 505 return q; |
506 } | |
507 | |
329 | 508 //---------------------------------- |
509 // 1 Pass Code | |
510 | |
612 | 511 static double predict_size(Predictor *p, double q, double var) |
329 | 512 { |
513 return p->coeff*var / (q*p->count); | |
514 } | |
515 | |
949 | 516 /* |
612 | 517 static double predict_qp(Predictor *p, double size, double var) |
518 { | |
519 //printf("coeff:%f, count:%f, var:%f, size:%f//\n", p->coeff, p->count, var, size); | |
520 return p->coeff*var / (size*p->count); | |
521 } | |
949 | 522 */ |
612 | 523 |
329 | 524 static void update_predictor(Predictor *p, double q, double var, double size) |
525 { | |
526 double new_coeff= size*q / (var + 1); | |
612 | 527 if(var<10) return; |
329 | 528 |
529 p->count*= p->decay; | |
530 p->coeff*= p->decay; | |
531 p->count++; | |
532 p->coeff+= new_coeff; | |
533 } | |
534 | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
535 static void adaptive_quantization(MpegEncContext *s, double q){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
536 int i; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
537 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
|
538 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
|
539 const float temp_cplx_masking= s->avctx->temporal_cplx_masking; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
540 const float spatial_cplx_masking = s->avctx->spatial_cplx_masking; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
541 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
|
542 const float border_masking = s->avctx->border_masking; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
543 float bits_sum= 0.0; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
544 float cplx_sum= 0.0; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
545 float cplx_tab[s->mb_num]; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
546 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
|
547 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
|
548 const int qmax= s->avctx->mb_lmax; |
903 | 549 Picture * const pic= &s->current_picture; |
2493
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
550 const int mb_width = s->mb_width; |
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
551 const int mb_height = s->mb_height; |
2967 | 552 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
553 for(i=0; i<s->mb_num; i++){ |
1180 | 554 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
|
555 float temp_cplx= sqrt(pic->mc_mb_var[mb_xy]); //FIXME merge in pow() |
1180 | 556 float spat_cplx= sqrt(pic->mb_var[mb_xy]); |
557 const int lumi= pic->mb_mean[mb_xy]; | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
558 float bits, cplx, factor; |
2493
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
559 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
|
560 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
|
561 int mb_distance; |
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
562 float mb_factor = 0.0; |
2967 | 563 #if 0 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
564 if(spat_cplx < q/3) spat_cplx= q/3; //FIXME finetune |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
565 if(temp_cplx < q/3) temp_cplx= q/3; //FIXME finetune |
2967 | 566 #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
|
567 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
|
568 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
|
569 |
2967 | 570 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
|
571 cplx= spat_cplx; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
572 factor= 1.0 + p_masking; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
573 }else{ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
574 cplx= temp_cplx; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
575 factor= pow(temp_cplx, - temp_cplx_masking); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
576 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
577 factor*=pow(spat_cplx, - spatial_cplx_masking); |
693
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
578 |
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
579 if(lumi>127) |
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
580 factor*= (1.0 - (lumi-128)*(lumi-128)*lumi_masking); |
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
581 else |
b6a7ff92df57
darkness masking (lumi masking does only bright stuff now)
michaelni
parents:
690
diff
changeset
|
582 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
|
583 |
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
584 if(mb_x < mb_width/5){ |
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
585 mb_distance = mb_width/5 - mb_x; |
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
586 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
|
587 }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
|
588 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
|
589 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
|
590 } |
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
591 if(mb_y < mb_height/5){ |
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
592 mb_distance = mb_height/5 - mb_y; |
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
593 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
|
594 }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
|
595 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
|
596 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
|
597 } |
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
598 |
258120c61eea
Border processing adaptive quant patch by (Christophe Massiot |cmassiot freebox fr)
michael
parents:
2423
diff
changeset
|
599 factor*= 1.0 - border_masking*mb_factor; |
2967 | 600 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
601 if(factor<0.00001) factor= 0.00001; |
2967 | 602 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
603 bits= cplx*factor; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
604 cplx_sum+= cplx; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
605 bits_sum+= bits; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
606 cplx_tab[i]= cplx; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
607 bits_tab[i]= bits; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
608 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
609 |
5127 | 610 /* handle qmin/qmax clipping */ |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
611 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
|
612 float factor= bits_sum/cplx_sum; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
613 for(i=0; i<s->mb_num; i++){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
614 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
|
615 newq*= factor; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
616 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
617 if (newq > qmax){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
618 bits_sum -= bits_tab[i]; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
619 cplx_sum -= cplx_tab[i]*q/qmax; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
620 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
621 else if(newq < qmin){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
622 bits_sum -= bits_tab[i]; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
623 cplx_sum -= cplx_tab[i]*q/qmin; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
624 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
625 } |
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
|
626 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
|
627 if(cplx_sum < 0.001) cplx_sum= 0.001; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
628 } |
2967 | 629 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
630 for(i=0; i<s->mb_num; i++){ |
1180 | 631 const int mb_xy= s->mb_index2xy[i]; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
632 float newq= q*cplx_tab[i]/bits_tab[i]; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
633 int intq; |
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(s->flags&CODEC_FLAG_NORMALIZE_AQP){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
636 newq*= bits_sum/cplx_sum; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
637 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
638 |
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 intq= (int)(newq + 0.5); |
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 if (intq > qmax) intq= qmax; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
642 else if(intq < qmin) intq= qmin; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
643 //if(i%s->mb_width==0) printf("\n"); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
644 //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
|
645 s->lambda_table[mb_xy]= intq; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
646 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
647 } |
2981 | 648 |
649 void ff_get_2pass_fcode(MpegEncContext *s){ | |
650 RateControlContext *rcc= &s->rc_context; | |
651 int picture_number= s->picture_number; | |
652 RateControlEntry *rce; | |
653 | |
654 rce= &rcc->entry[picture_number]; | |
655 s->f_code= rce->f_code; | |
656 s->b_code= rce->b_code; | |
657 } | |
658 | |
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
|
659 //FIXME rd or at least approx for dquant |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
660 |
2974 | 661 float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run) |
329 | 662 { |
663 float q; | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
664 int qmin, qmax; |
329 | 665 float br_compensation; |
666 double diff; | |
667 double short_term_q; | |
668 double fps; | |
612 | 669 int picture_number= s->picture_number; |
329 | 670 int64_t wanted_bits; |
612 | 671 RateControlContext *rcc= &s->rc_context; |
1687 | 672 AVCodecContext *a= s->avctx; |
612 | 673 RateControlEntry local_rce, *rce; |
674 double bits; | |
675 double rate_factor; | |
676 int var; | |
677 const int pict_type= s->pict_type; | |
903 | 678 Picture * const pic= &s->current_picture; |
329 | 679 emms_c(); |
680 | |
5203 | 681 #ifdef CONFIG_LIBXVID |
3064 | 682 if((s->flags&CODEC_FLAG_PASS2) && s->avctx->rc_strategy == FF_RC_STRATEGY_XVID) |
683 return ff_xvid_rate_estimate_qscale(s, dry_run); | |
3065 | 684 #endif |
3064 | 685 |
612 | 686 get_qminmax(&qmin, &qmax, s, pict_type); |
687 | |
2637 | 688 fps= 1/av_q2d(s->avctx->time_base); |
678 | 689 //printf("input_pic_num:%d pic_num:%d frame_rate:%d\n", s->input_picture_number, s->picture_number, s->frame_rate); |
329 | 690 /* update predictors */ |
2974 | 691 if(picture_number>2 && !dry_run){ |
6481 | 692 const int last_var= s->last_pict_type == FF_I_TYPE ? rcc->last_mb_var_sum : rcc->last_mc_mb_var_sum; |
612 | 693 update_predictor(&rcc->pred[s->last_pict_type], rcc->last_qscale, sqrt(last_var), s->frame_bits); |
329 | 694 } |
695 | |
612 | 696 if(s->flags&CODEC_FLAG_PASS2){ |
697 assert(picture_number>=0); | |
698 assert(picture_number<rcc->num_entries); | |
699 rce= &rcc->entry[picture_number]; | |
700 wanted_bits= rce->expected_bits; | |
701 }else{ | |
5672 | 702 Picture *dts_pic; |
612 | 703 rce= &local_rce; |
5672 | 704 |
705 //FIXME add a dts field to AVFrame and ensure its set and use it here instead of reordering | |
706 //but the reordering is simpler for now until h.264 b pyramid must be handeld | |
6481 | 707 if(s->pict_type == FF_B_TYPE || s->low_delay) |
5672 | 708 dts_pic= s->current_picture_ptr; |
709 else | |
710 dts_pic= s->last_picture_ptr; | |
711 | |
712 //if(dts_pic) | |
713 // av_log(NULL, AV_LOG_ERROR, "%Ld %Ld %Ld %d\n", s->current_picture_ptr->pts, s->user_specified_pts, dts_pic->pts, picture_number); | |
714 | |
715 if(!dts_pic || dts_pic->pts == AV_NOPTS_VALUE) | |
716 wanted_bits= (uint64_t)(s->bit_rate*(double)picture_number/fps); | |
717 else | |
718 wanted_bits= (uint64_t)(s->bit_rate*(double)dts_pic->pts/fps); | |
329 | 719 } |
720 | |
721 diff= s->total_bits - wanted_bits; | |
1687 | 722 br_compensation= (a->bit_rate_tolerance - diff)/a->bit_rate_tolerance; |
329 | 723 if(br_compensation<=0.0) br_compensation=0.001; |
612 | 724 |
6481 | 725 var= pict_type == FF_I_TYPE ? pic->mb_var_sum : pic->mc_mb_var_sum; |
2967 | 726 |
1455 | 727 short_term_q = 0; /* avoid warning */ |
612 | 728 if(s->flags&CODEC_FLAG_PASS2){ |
6481 | 729 if(pict_type!=FF_I_TYPE) |
612 | 730 assert(pict_type == rce->new_pict_type); |
731 | |
732 q= rce->new_qscale / br_compensation; | |
733 //printf("%f %f %f last:%d var:%d type:%d//\n", q, rce->new_qscale, br_compensation, s->frame_bits, var, pict_type); | |
734 }else{ | |
2967 | 735 rce->pict_type= |
612 | 736 rce->new_pict_type= pict_type; |
903 | 737 rce->mc_mb_var_sum= pic->mc_mb_var_sum; |
738 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
|
739 rce->qscale = FF_QP2LAMBDA * 2; |
612 | 740 rce->f_code = s->f_code; |
741 rce->b_code = s->b_code; | |
742 rce->misc_bits= 1; | |
743 | |
744 bits= predict_size(&rcc->pred[pict_type], rce->qscale, sqrt(var)); | |
6481 | 745 if(pict_type== FF_I_TYPE){ |
612 | 746 rce->i_count = s->mb_num; |
747 rce->i_tex_bits= bits; | |
748 rce->p_tex_bits= 0; | |
749 rce->mv_bits= 0; | |
750 }else{ | |
751 rce->i_count = 0; //FIXME we do know this approx | |
752 rce->i_tex_bits= 0; | |
753 rce->p_tex_bits= bits*0.9; | |
2967 | 754 |
612 | 755 rce->mv_bits= bits*0.1; |
756 } | |
757 rcc->i_cplx_sum [pict_type] += rce->i_tex_bits*rce->qscale; | |
758 rcc->p_cplx_sum [pict_type] += rce->p_tex_bits*rce->qscale; | |
759 rcc->mv_bits_sum[pict_type] += rce->mv_bits; | |
760 rcc->frame_count[pict_type] ++; | |
761 | |
762 bits= rce->i_tex_bits + rce->p_tex_bits; | |
707 | 763 rate_factor= rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum * br_compensation; |
2967 | 764 |
612 | 765 q= get_qscale(s, rce, rate_factor, picture_number); |
3766 | 766 if (q < 0) |
767 return -1; | |
612 | 768 |
615 | 769 assert(q>0.0); |
612 | 770 //printf("%f ", q); |
679 | 771 q= get_diff_limited_q(s, rce, q); |
612 | 772 //printf("%f ", q); |
773 assert(q>0.0); | |
774 | |
6481 | 775 if(pict_type==FF_P_TYPE || s->intra_only){ //FIXME type dependent blur like in 2-pass |
1687 | 776 rcc->short_term_qsum*=a->qblur; |
777 rcc->short_term_qcount*=a->qblur; | |
612 | 778 |
779 rcc->short_term_qsum+= q; | |
780 rcc->short_term_qcount++; | |
781 //printf("%f ", q); | |
782 q= short_term_q= rcc->short_term_qsum/rcc->short_term_qcount; | |
783 //printf("%f ", q); | |
784 } | |
678 | 785 assert(q>0.0); |
2967 | 786 |
612 | 787 q= modify_qscale(s, rce, q, picture_number); |
788 | |
789 rcc->pass1_wanted_bits+= s->bit_rate/fps; | |
790 | |
615 | 791 assert(q>0.0); |
612 | 792 } |
930 | 793 |
794 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
|
795 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 | 796 av_get_pict_type_char(pict_type), qmin, q, qmax, picture_number, (int)wanted_bits/1000, (int)s->total_bits/1000, |
930 | 797 br_compensation, short_term_q, s->frame_bits, pic->mb_var_sum, pic->mc_mb_var_sum, s->bit_rate/1000, (int)fps |
798 ); | |
799 } | |
612 | 800 |
2967 | 801 if (q<qmin) q=qmin; |
612 | 802 else if(q>qmax) q=qmax; |
803 | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
804 if(s->adaptive_quant) |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
805 adaptive_quantization(s, q); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
806 else |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
807 q= (int)(q + 0.5); |
2967 | 808 |
2974 | 809 if(!dry_run){ |
810 rcc->last_qscale= q; | |
811 rcc->last_mc_mb_var_sum= pic->mc_mb_var_sum; | |
812 rcc->last_mb_var_sum= pic->mb_var_sum; | |
813 } | |
903 | 814 #if 0 |
815 { | |
816 static int mvsum=0, texsum=0; | |
817 mvsum += s->mv_bits; | |
818 texsum += s->i_tex_bits + s->p_tex_bits; | |
819 printf("%d %d//\n\n", mvsum, texsum); | |
820 } | |
821 #endif | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
679
diff
changeset
|
822 return q; |
329 | 823 } |
824 | |
825 //---------------------------------------------- | |
826 // 2-Pass code | |
827 | |
828 static int init_pass2(MpegEncContext *s) | |
829 { | |
830 RateControlContext *rcc= &s->rc_context; | |
1687 | 831 AVCodecContext *a= s->avctx; |
3681 | 832 int i, toobig; |
2637 | 833 double fps= 1/av_q2d(s->avctx->time_base); |
329 | 834 double complexity[5]={0,0,0,0,0}; // aproximate bits at quant=1 |
4588
fc155ff94878
cosmetics: Fix another common typo, dependAnt --> dependEnt.
diego
parents:
4084
diff
changeset
|
835 uint64_t const_bits[5]={0,0,0,0,0}; // quantizer independent bits |
329 | 836 uint64_t all_const_bits; |
837 uint64_t all_available_bits= (uint64_t)(s->bit_rate*(double)rcc->num_entries/fps); | |
838 double rate_factor=0; | |
839 double step; | |
949 | 840 //int last_i_frame=-10000000; |
2967 | 841 const int filter_size= (int)(a->qblur*4) | 1; |
612 | 842 double expected_bits; |
6526 | 843 double *qscale, *blurred_qscale, qscale_sum; |
329 | 844 |
845 /* find complexity & const_bits & decide the pict_types */ | |
846 for(i=0; i<rcc->num_entries; i++){ | |
847 RateControlEntry *rce= &rcc->entry[i]; | |
2967 | 848 |
915 | 849 rce->new_pict_type= rce->pict_type; |
612 | 850 rcc->i_cplx_sum [rce->pict_type] += rce->i_tex_bits*rce->qscale; |
851 rcc->p_cplx_sum [rce->pict_type] += rce->p_tex_bits*rce->qscale; | |
852 rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits; | |
853 rcc->frame_count[rce->pict_type] ++; | |
329 | 854 |
855 complexity[rce->new_pict_type]+= (rce->i_tex_bits+ rce->p_tex_bits)*(double)rce->qscale; | |
856 const_bits[rce->new_pict_type]+= rce->mv_bits + rce->misc_bits; | |
857 } | |
6481 | 858 all_const_bits= const_bits[FF_I_TYPE] + const_bits[FF_P_TYPE] + const_bits[FF_B_TYPE]; |
2967 | 859 |
329 | 860 if(all_available_bits < all_const_bits){ |
3674 | 861 av_log(s->avctx, AV_LOG_ERROR, "requested bitrate is too low\n"); |
329 | 862 return -1; |
863 } | |
2967 | 864 |
1031
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
977
diff
changeset
|
865 qscale= av_malloc(sizeof(double)*rcc->num_entries); |
6526 | 866 blurred_qscale= av_malloc(sizeof(double)*rcc->num_entries); |
3681 | 867 toobig = 0; |
612 | 868 |
329 | 869 for(step=256*256; step>0.0000001; step*=0.5){ |
612 | 870 expected_bits=0; |
329 | 871 rate_factor+= step; |
2967 | 872 |
612 | 873 rcc->buffer_index= s->avctx->rc_buffer_size/2; |
874 | |
329 | 875 /* find qscale */ |
876 for(i=0; i<rcc->num_entries; i++){ | |
612 | 877 qscale[i]= get_qscale(s, &rcc->entry[i], rate_factor, i); |
878 } | |
879 assert(filter_size%2==1); | |
329 | 880 |
612 | 881 /* fixed I/B QP relative to P mode */ |
882 for(i=rcc->num_entries-1; i>=0; i--){ | |
883 RateControlEntry *rce= &rcc->entry[i]; | |
2967 | 884 |
679 | 885 qscale[i]= get_diff_limited_q(s, rce, qscale[i]); |
329 | 886 } |
887 | |
888 /* smooth curve */ | |
612 | 889 for(i=0; i<rcc->num_entries; i++){ |
890 RateControlEntry *rce= &rcc->entry[i]; | |
891 const int pict_type= rce->new_pict_type; | |
892 int j; | |
893 double q=0.0, sum=0.0; | |
2967 | 894 |
612 | 895 for(j=0; j<filter_size; j++){ |
896 int index= i+j-filter_size/2; | |
897 double d= index-i; | |
1687 | 898 double coeff= a->qblur==0 ? 1.0 : exp(-d*d/(a->qblur * a->qblur)); |
2967 | 899 |
612 | 900 if(index < 0 || index >= rcc->num_entries) continue; |
901 if(pict_type != rcc->entry[index].new_pict_type) continue; | |
902 q+= qscale[index] * coeff; | |
903 sum+= coeff; | |
904 } | |
6526 | 905 blurred_qscale[i]= q/sum; |
612 | 906 } |
2967 | 907 |
329 | 908 /* find expected bits */ |
909 for(i=0; i<rcc->num_entries; i++){ | |
910 RateControlEntry *rce= &rcc->entry[i]; | |
612 | 911 double bits; |
6526 | 912 rce->new_qscale= modify_qscale(s, rce, blurred_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
|
913 bits= qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits; |
6526 | 914 //printf("%d %f\n", rce->new_bits, blurred_qscale[i]); |
1684 | 915 bits += 8*ff_vbv_update(s, bits); |
612 | 916 |
329 | 917 rce->expected_bits= expected_bits; |
612 | 918 expected_bits += bits; |
329 | 919 } |
920 | |
3681 | 921 /* |
922 av_log(s->avctx, AV_LOG_INFO, | |
923 "expected_bits: %f all_available_bits: %d rate_factor: %f\n", | |
924 expected_bits, (int)all_available_bits, rate_factor); | |
925 */ | |
926 if(expected_bits > all_available_bits) { | |
927 rate_factor-= step; | |
928 ++toobig; | |
929 } | |
329 | 930 } |
1031
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
977
diff
changeset
|
931 av_free(qscale); |
6526 | 932 av_free(blurred_qscale); |
612 | 933 |
3681 | 934 /* check bitrate calculations and print info */ |
935 qscale_sum = 0.0; | |
936 for(i=0; i<rcc->num_entries; i++){ | |
937 /* av_log(s->avctx, AV_LOG_DEBUG, "[lavc rc] entry[%d].new_qscale = %.3f qp = %.3f\n", | |
938 i, rcc->entry[i].new_qscale, rcc->entry[i].new_qscale / FF_QP2LAMBDA); */ | |
4594 | 939 qscale_sum += av_clip(rcc->entry[i].new_qscale / FF_QP2LAMBDA, s->avctx->qmin, s->avctx->qmax); |
3681 | 940 } |
941 assert(toobig <= 40); | |
942 av_log(s->avctx, AV_LOG_DEBUG, | |
943 "[lavc rc] requested bitrate: %d bps expected bitrate: %d bps\n", | |
944 s->bit_rate, | |
945 (int)(expected_bits / ((double)all_available_bits/s->bit_rate))); | |
946 av_log(s->avctx, AV_LOG_DEBUG, | |
947 "[lavc rc] estimated target average qp: %.3f\n", | |
948 (float)qscale_sum / rcc->num_entries); | |
949 if (toobig == 0) { | |
950 av_log(s->avctx, AV_LOG_INFO, | |
951 "[lavc rc] Using all of requested bitrate is not " | |
952 "necessary for this video with these parameters.\n"); | |
953 } else if (toobig == 40) { | |
954 av_log(s->avctx, AV_LOG_ERROR, | |
955 "[lavc rc] Error: bitrate too low for this video " | |
956 "with these parameters.\n"); | |
957 return -1; | |
958 } else if (fabs(expected_bits/all_available_bits - 1.0) > 0.01) { | |
959 av_log(s->avctx, AV_LOG_ERROR, | |
960 "[lavc rc] Error: 2pass curve failed to converge\n"); | |
612 | 961 return -1; |
962 } | |
329 | 963 |
964 return 0; | |
965 } |