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