Mercurial > libavcodec.hg
comparison ratecontrol.c @ 4084:90e848a24c70 libavcodec
update ratecontrol to new ff_eval API
author | ods15 |
---|---|
date | Fri, 27 Oct 2006 20:16:26 +0000 |
parents | 34fdffe98bd0 |
children | fc155ff94878 |
comparison
equal
deleted
inserted
replaced
4083:065ee7dd69ca | 4084:90e848a24c70 |
---|---|
46 s->current_picture_ptr->display_picture_number, s->current_picture_ptr->coded_picture_number, s->pict_type, | 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, | 47 s->current_picture.quality, s->i_tex_bits, s->p_tex_bits, s->mv_bits, s->misc_bits, |
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); | 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); |
49 } | 49 } |
50 | 50 |
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 | |
51 int ff_rate_control_init(MpegEncContext *s) | 65 int ff_rate_control_init(MpegEncContext *s) |
52 { | 66 { |
53 RateControlContext *rcc= &s->rc_context; | 67 RateControlContext *rcc= &s->rc_context; |
54 int i; | 68 int i; |
55 emms_c(); | |
56 | |
57 for(i=0; i<5; i++){ | |
58 rcc->pred[i].coeff= FF_QP2LAMBDA * 7.0; | |
59 rcc->pred[i].count= 1.0; | |
60 | |
61 rcc->pred[i].decay= 0.4; | |
62 rcc->i_cplx_sum [i]= | |
63 rcc->p_cplx_sum [i]= | |
64 rcc->mv_bits_sum[i]= | |
65 rcc->qscale_sum [i]= | |
66 rcc->frame_count[i]= 1; // 1 is better cuz of 1/0 and such | |
67 rcc->last_qscale_for[i]=FF_QP2LAMBDA * 5; | |
68 } | |
69 rcc->buffer_index= s->avctx->rc_initial_buffer_occupancy; | |
70 | |
71 if(s->flags&CODEC_FLAG_PASS2){ | |
72 int i; | |
73 char *p; | |
74 | |
75 /* find number of pics */ | |
76 p= s->avctx->stats_in; | |
77 for(i=-1; p; i++){ | |
78 p= strchr(p+1, ';'); | |
79 } | |
80 i+= s->max_b_frames; | |
81 if(i<=0 || i>=INT_MAX / sizeof(RateControlEntry)) | |
82 return -1; | |
83 rcc->entry = (RateControlEntry*)av_mallocz(i*sizeof(RateControlEntry)); | |
84 rcc->num_entries= i; | |
85 | |
86 /* init all to skipped p frames (with b frames we might have a not encoded frame at the end FIXME) */ | |
87 for(i=0; i<rcc->num_entries; i++){ | |
88 RateControlEntry *rce= &rcc->entry[i]; | |
89 rce->pict_type= rce->new_pict_type=P_TYPE; | |
90 rce->qscale= rce->new_qscale=FF_QP2LAMBDA * 2; | |
91 rce->misc_bits= s->mb_num + 10; | |
92 rce->mb_var_sum= s->mb_num*100; | |
93 } | |
94 | |
95 /* read stats */ | |
96 p= s->avctx->stats_in; | |
97 for(i=0; i<rcc->num_entries - s->max_b_frames; i++){ | |
98 RateControlEntry *rce; | |
99 int picture_number; | |
100 int e; | |
101 char *next; | |
102 | |
103 next= strchr(p, ';'); | |
104 if(next){ | |
105 (*next)=0; //sscanf in unbelieavle slow on looong strings //FIXME copy / dont write | |
106 next++; | |
107 } | |
108 e= sscanf(p, " in:%d ", &picture_number); | |
109 | |
110 assert(picture_number >= 0); | |
111 assert(picture_number < rcc->num_entries); | |
112 rce= &rcc->entry[picture_number]; | |
113 | |
114 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", | |
115 &rce->pict_type, &rce->qscale, &rce->i_tex_bits, &rce->p_tex_bits, &rce->mv_bits, &rce->misc_bits, | |
116 &rce->f_code, &rce->b_code, &rce->mc_mb_var_sum, &rce->mb_var_sum, &rce->i_count, &rce->skip_count, &rce->header_bits); | |
117 if(e!=14){ | |
118 av_log(s->avctx, AV_LOG_ERROR, "statistics are damaged at line %d, parser out=%d\n", i, e); | |
119 return -1; | |
120 } | |
121 | |
122 p= next; | |
123 } | |
124 | |
125 if(init_pass2(s) < 0) return -1; | |
126 | |
127 //FIXME maybe move to end | |
128 if((s->flags&CODEC_FLAG_PASS2) && s->avctx->rc_strategy == FF_RC_STRATEGY_XVID) { | |
129 #ifdef CONFIG_XVID | |
130 return ff_xvid_rate_control_init(s); | |
131 #else | |
132 av_log(s->avctx, AV_LOG_ERROR, "XviD ratecontrol requires libavcodec compiled with XviD support\n"); | |
133 return -1; | |
134 #endif | |
135 } | |
136 } | |
137 | |
138 if(!(s->flags&CODEC_FLAG_PASS2)){ | |
139 | |
140 rcc->short_term_qsum=0.001; | |
141 rcc->short_term_qcount=0.001; | |
142 | |
143 rcc->pass1_rc_eq_output_sum= 0.001; | |
144 rcc->pass1_wanted_bits=0.001; | |
145 | |
146 /* init stuff with the user specified complexity */ | |
147 if(s->avctx->rc_initial_cplx){ | |
148 for(i=0; i<60*30; i++){ | |
149 double bits= s->avctx->rc_initial_cplx * (i/10000.0 + 1.0)*s->mb_num; | |
150 RateControlEntry rce; | |
151 double q; | |
152 | |
153 if (i%((s->gop_size+3)/4)==0) rce.pict_type= I_TYPE; | |
154 else if(i%(s->max_b_frames+1)) rce.pict_type= B_TYPE; | |
155 else rce.pict_type= P_TYPE; | |
156 | |
157 rce.new_pict_type= rce.pict_type; | |
158 rce.mc_mb_var_sum= bits*s->mb_num/100000; | |
159 rce.mb_var_sum = s->mb_num; | |
160 rce.qscale = FF_QP2LAMBDA * 2; | |
161 rce.f_code = 2; | |
162 rce.b_code = 1; | |
163 rce.misc_bits= 1; | |
164 | |
165 if(s->pict_type== I_TYPE){ | |
166 rce.i_count = s->mb_num; | |
167 rce.i_tex_bits= bits; | |
168 rce.p_tex_bits= 0; | |
169 rce.mv_bits= 0; | |
170 }else{ | |
171 rce.i_count = 0; //FIXME we do know this approx | |
172 rce.i_tex_bits= 0; | |
173 rce.p_tex_bits= bits*0.9; | |
174 rce.mv_bits= bits*0.1; | |
175 } | |
176 rcc->i_cplx_sum [rce.pict_type] += rce.i_tex_bits*rce.qscale; | |
177 rcc->p_cplx_sum [rce.pict_type] += rce.p_tex_bits*rce.qscale; | |
178 rcc->mv_bits_sum[rce.pict_type] += rce.mv_bits; | |
179 rcc->frame_count[rce.pict_type] ++; | |
180 | |
181 bits= rce.i_tex_bits + rce.p_tex_bits; | |
182 | |
183 q= get_qscale(s, &rce, rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum, i); | |
184 rcc->pass1_wanted_bits+= s->bit_rate/(1/av_q2d(s->avctx->time_base)); //FIXME missbehaves a little for variable fps | |
185 } | |
186 } | |
187 | |
188 } | |
189 | |
190 return 0; | |
191 } | |
192 | |
193 void ff_rate_control_uninit(MpegEncContext *s) | |
194 { | |
195 RateControlContext *rcc= &s->rc_context; | |
196 emms_c(); | |
197 | |
198 av_freep(&rcc->entry); | |
199 | |
200 #ifdef CONFIG_XVID | |
201 if((s->flags&CODEC_FLAG_PASS2) && s->avctx->rc_strategy == FF_RC_STRATEGY_XVID) | |
202 ff_xvid_rate_control_uninit(s); | |
203 #endif | |
204 } | |
205 | |
206 static inline double qp2bits(RateControlEntry *rce, double qp){ | |
207 if(qp<=0.0){ | |
208 av_log(NULL, AV_LOG_ERROR, "qp<=0.0\n"); | |
209 } | |
210 return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits+1)/ qp; | |
211 } | |
212 | |
213 static inline double bits2qp(RateControlEntry *rce, double bits){ | |
214 if(bits<0.9){ | |
215 av_log(NULL, AV_LOG_ERROR, "bits<0.9\n"); | |
216 } | |
217 return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits+1)/ bits; | |
218 } | |
219 | |
220 int ff_vbv_update(MpegEncContext *s, int frame_size){ | |
221 RateControlContext *rcc= &s->rc_context; | |
222 const double fps= 1/av_q2d(s->avctx->time_base); | |
223 const int buffer_size= s->avctx->rc_buffer_size; | |
224 const double min_rate= s->avctx->rc_min_rate/fps; | |
225 const double max_rate= s->avctx->rc_max_rate/fps; | |
226 | |
227 //printf("%d %f %d %f %f\n", buffer_size, rcc->buffer_index, frame_size, min_rate, max_rate); | |
228 if(buffer_size){ | |
229 int left; | |
230 | |
231 rcc->buffer_index-= frame_size; | |
232 if(rcc->buffer_index < 0){ | |
233 av_log(s->avctx, AV_LOG_ERROR, "rc buffer underflow\n"); | |
234 rcc->buffer_index= 0; | |
235 } | |
236 | |
237 left= buffer_size - rcc->buffer_index - 1; | |
238 rcc->buffer_index += clip(left, min_rate, max_rate); | |
239 | |
240 if(rcc->buffer_index > buffer_size){ | |
241 int stuffing= ceil((rcc->buffer_index - buffer_size)/8); | |
242 | |
243 if(stuffing < 4 && s->codec_id == CODEC_ID_MPEG4) | |
244 stuffing=4; | |
245 rcc->buffer_index -= 8*stuffing; | |
246 | |
247 if(s->avctx->debug & FF_DEBUG_RC) | |
248 av_log(s->avctx, AV_LOG_DEBUG, "stuffing %d bytes\n", stuffing); | |
249 | |
250 return stuffing; | |
251 } | |
252 } | |
253 return 0; | |
254 } | |
255 | |
256 /** | |
257 * modifies the bitrate curve from pass1 for one frame | |
258 */ | |
259 static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_factor, int frame_num){ | |
260 RateControlContext *rcc= &s->rc_context; | |
261 AVCodecContext *a= s->avctx; | |
262 double q, bits; | |
263 const int pict_type= rce->new_pict_type; | |
264 const double mb_num= s->mb_num; | |
265 int i; | |
266 char *error = NULL; | 69 char *error = NULL; |
267 | |
268 double const_values[]={ | |
269 M_PI, | |
270 M_E, | |
271 rce->i_tex_bits*rce->qscale, | |
272 rce->p_tex_bits*rce->qscale, | |
273 (rce->i_tex_bits + rce->p_tex_bits)*(double)rce->qscale, | |
274 rce->mv_bits/mb_num, | |
275 rce->pict_type == B_TYPE ? (rce->f_code + rce->b_code)*0.5 : rce->f_code, | |
276 rce->i_count/mb_num, | |
277 rce->mc_mb_var_sum/mb_num, | |
278 rce->mb_var_sum/mb_num, | |
279 rce->pict_type == I_TYPE, | |
280 rce->pict_type == P_TYPE, | |
281 rce->pict_type == B_TYPE, | |
282 rcc->qscale_sum[pict_type] / (double)rcc->frame_count[pict_type], | |
283 a->qcompress, | |
284 /* rcc->last_qscale_for[I_TYPE], | |
285 rcc->last_qscale_for[P_TYPE], | |
286 rcc->last_qscale_for[B_TYPE], | |
287 rcc->next_non_b_qscale,*/ | |
288 rcc->i_cplx_sum[I_TYPE] / (double)rcc->frame_count[I_TYPE], | |
289 rcc->i_cplx_sum[P_TYPE] / (double)rcc->frame_count[P_TYPE], | |
290 rcc->p_cplx_sum[P_TYPE] / (double)rcc->frame_count[P_TYPE], | |
291 rcc->p_cplx_sum[B_TYPE] / (double)rcc->frame_count[B_TYPE], | |
292 (rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / (double)rcc->frame_count[pict_type], | |
293 0 | |
294 }; | |
295 static const char *const_names[]={ | 70 static const char *const_names[]={ |
296 "PI", | 71 "PI", |
297 "E", | 72 "E", |
298 "iTex", | 73 "iTex", |
299 "pTex", | 74 "pTex", |
327 static const char *func1_names[]={ | 102 static const char *func1_names[]={ |
328 "bits2qp", | 103 "bits2qp", |
329 "qp2bits", | 104 "qp2bits", |
330 NULL | 105 NULL |
331 }; | 106 }; |
332 | 107 emms_c(); |
333 bits= ff_eval2(s->avctx->rc_eq, const_values, const_names, func1, func1_names, NULL, NULL, rce, &error); | 108 |
109 rcc->rc_eq_eval = ff_parse(s->avctx->rc_eq, const_names, func1, func1_names, NULL, NULL, &error); | |
110 if (!rcc->rc_eq_eval) { | |
111 av_log(s->avctx, AV_LOG_ERROR, "Error parsing rc_eq \"%s\": %s\n", s->avctx->rc_eq, error? error : ""); | |
112 return -1; | |
113 } | |
114 | |
115 for(i=0; i<5; i++){ | |
116 rcc->pred[i].coeff= FF_QP2LAMBDA * 7.0; | |
117 rcc->pred[i].count= 1.0; | |
118 | |
119 rcc->pred[i].decay= 0.4; | |
120 rcc->i_cplx_sum [i]= | |
121 rcc->p_cplx_sum [i]= | |
122 rcc->mv_bits_sum[i]= | |
123 rcc->qscale_sum [i]= | |
124 rcc->frame_count[i]= 1; // 1 is better cuz of 1/0 and such | |
125 rcc->last_qscale_for[i]=FF_QP2LAMBDA * 5; | |
126 } | |
127 rcc->buffer_index= s->avctx->rc_initial_buffer_occupancy; | |
128 | |
129 if(s->flags&CODEC_FLAG_PASS2){ | |
130 int i; | |
131 char *p; | |
132 | |
133 /* find number of pics */ | |
134 p= s->avctx->stats_in; | |
135 for(i=-1; p; i++){ | |
136 p= strchr(p+1, ';'); | |
137 } | |
138 i+= s->max_b_frames; | |
139 if(i<=0 || i>=INT_MAX / sizeof(RateControlEntry)) | |
140 return -1; | |
141 rcc->entry = (RateControlEntry*)av_mallocz(i*sizeof(RateControlEntry)); | |
142 rcc->num_entries= i; | |
143 | |
144 /* init all to skipped p frames (with b frames we might have a not encoded frame at the end FIXME) */ | |
145 for(i=0; i<rcc->num_entries; i++){ | |
146 RateControlEntry *rce= &rcc->entry[i]; | |
147 rce->pict_type= rce->new_pict_type=P_TYPE; | |
148 rce->qscale= rce->new_qscale=FF_QP2LAMBDA * 2; | |
149 rce->misc_bits= s->mb_num + 10; | |
150 rce->mb_var_sum= s->mb_num*100; | |
151 } | |
152 | |
153 /* read stats */ | |
154 p= s->avctx->stats_in; | |
155 for(i=0; i<rcc->num_entries - s->max_b_frames; i++){ | |
156 RateControlEntry *rce; | |
157 int picture_number; | |
158 int e; | |
159 char *next; | |
160 | |
161 next= strchr(p, ';'); | |
162 if(next){ | |
163 (*next)=0; //sscanf in unbelieavle slow on looong strings //FIXME copy / dont write | |
164 next++; | |
165 } | |
166 e= sscanf(p, " in:%d ", &picture_number); | |
167 | |
168 assert(picture_number >= 0); | |
169 assert(picture_number < rcc->num_entries); | |
170 rce= &rcc->entry[picture_number]; | |
171 | |
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", | |
173 &rce->pict_type, &rce->qscale, &rce->i_tex_bits, &rce->p_tex_bits, &rce->mv_bits, &rce->misc_bits, | |
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){ | |
176 av_log(s->avctx, AV_LOG_ERROR, "statistics are damaged at line %d, parser out=%d\n", i, e); | |
177 return -1; | |
178 } | |
179 | |
180 p= next; | |
181 } | |
182 | |
183 if(init_pass2(s) < 0) return -1; | |
184 | |
185 //FIXME maybe move to end | |
186 if((s->flags&CODEC_FLAG_PASS2) && s->avctx->rc_strategy == FF_RC_STRATEGY_XVID) { | |
187 #ifdef CONFIG_XVID | |
188 return ff_xvid_rate_control_init(s); | |
189 #else | |
190 av_log(s->avctx, AV_LOG_ERROR, "XviD ratecontrol requires libavcodec compiled with XviD support\n"); | |
191 return -1; | |
192 #endif | |
193 } | |
194 } | |
195 | |
196 if(!(s->flags&CODEC_FLAG_PASS2)){ | |
197 | |
198 rcc->short_term_qsum=0.001; | |
199 rcc->short_term_qcount=0.001; | |
200 | |
201 rcc->pass1_rc_eq_output_sum= 0.001; | |
202 rcc->pass1_wanted_bits=0.001; | |
203 | |
204 /* init stuff with the user specified complexity */ | |
205 if(s->avctx->rc_initial_cplx){ | |
206 for(i=0; i<60*30; i++){ | |
207 double bits= s->avctx->rc_initial_cplx * (i/10000.0 + 1.0)*s->mb_num; | |
208 RateControlEntry rce; | |
209 double q; | |
210 | |
211 if (i%((s->gop_size+3)/4)==0) rce.pict_type= I_TYPE; | |
212 else if(i%(s->max_b_frames+1)) rce.pict_type= B_TYPE; | |
213 else rce.pict_type= P_TYPE; | |
214 | |
215 rce.new_pict_type= rce.pict_type; | |
216 rce.mc_mb_var_sum= bits*s->mb_num/100000; | |
217 rce.mb_var_sum = s->mb_num; | |
218 rce.qscale = FF_QP2LAMBDA * 2; | |
219 rce.f_code = 2; | |
220 rce.b_code = 1; | |
221 rce.misc_bits= 1; | |
222 | |
223 if(s->pict_type== I_TYPE){ | |
224 rce.i_count = s->mb_num; | |
225 rce.i_tex_bits= bits; | |
226 rce.p_tex_bits= 0; | |
227 rce.mv_bits= 0; | |
228 }else{ | |
229 rce.i_count = 0; //FIXME we do know this approx | |
230 rce.i_tex_bits= 0; | |
231 rce.p_tex_bits= bits*0.9; | |
232 rce.mv_bits= bits*0.1; | |
233 } | |
234 rcc->i_cplx_sum [rce.pict_type] += rce.i_tex_bits*rce.qscale; | |
235 rcc->p_cplx_sum [rce.pict_type] += rce.p_tex_bits*rce.qscale; | |
236 rcc->mv_bits_sum[rce.pict_type] += rce.mv_bits; | |
237 rcc->frame_count[rce.pict_type] ++; | |
238 | |
239 bits= rce.i_tex_bits + rce.p_tex_bits; | |
240 | |
241 q= get_qscale(s, &rce, rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum, i); | |
242 rcc->pass1_wanted_bits+= s->bit_rate/(1/av_q2d(s->avctx->time_base)); //FIXME missbehaves a little for variable fps | |
243 } | |
244 } | |
245 | |
246 } | |
247 | |
248 return 0; | |
249 } | |
250 | |
251 void ff_rate_control_uninit(MpegEncContext *s) | |
252 { | |
253 RateControlContext *rcc= &s->rc_context; | |
254 emms_c(); | |
255 | |
256 ff_eval_free(rcc->rc_eq_eval); | |
257 av_freep(&rcc->entry); | |
258 | |
259 #ifdef CONFIG_XVID | |
260 if((s->flags&CODEC_FLAG_PASS2) && s->avctx->rc_strategy == FF_RC_STRATEGY_XVID) | |
261 ff_xvid_rate_control_uninit(s); | |
262 #endif | |
263 } | |
264 | |
265 int ff_vbv_update(MpegEncContext *s, int frame_size){ | |
266 RateControlContext *rcc= &s->rc_context; | |
267 const double fps= 1/av_q2d(s->avctx->time_base); | |
268 const int buffer_size= s->avctx->rc_buffer_size; | |
269 const double min_rate= s->avctx->rc_min_rate/fps; | |
270 const double max_rate= s->avctx->rc_max_rate/fps; | |
271 | |
272 //printf("%d %f %d %f %f\n", buffer_size, rcc->buffer_index, frame_size, min_rate, max_rate); | |
273 if(buffer_size){ | |
274 int left; | |
275 | |
276 rcc->buffer_index-= frame_size; | |
277 if(rcc->buffer_index < 0){ | |
278 av_log(s->avctx, AV_LOG_ERROR, "rc buffer underflow\n"); | |
279 rcc->buffer_index= 0; | |
280 } | |
281 | |
282 left= buffer_size - rcc->buffer_index - 1; | |
283 rcc->buffer_index += clip(left, min_rate, max_rate); | |
284 | |
285 if(rcc->buffer_index > buffer_size){ | |
286 int stuffing= ceil((rcc->buffer_index - buffer_size)/8); | |
287 | |
288 if(stuffing < 4 && s->codec_id == CODEC_ID_MPEG4) | |
289 stuffing=4; | |
290 rcc->buffer_index -= 8*stuffing; | |
291 | |
292 if(s->avctx->debug & FF_DEBUG_RC) | |
293 av_log(s->avctx, AV_LOG_DEBUG, "stuffing %d bytes\n", stuffing); | |
294 | |
295 return stuffing; | |
296 } | |
297 } | |
298 return 0; | |
299 } | |
300 | |
301 /** | |
302 * modifies the bitrate curve from pass1 for one frame | |
303 */ | |
304 static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_factor, int frame_num){ | |
305 RateControlContext *rcc= &s->rc_context; | |
306 AVCodecContext *a= s->avctx; | |
307 double q, bits; | |
308 const int pict_type= rce->new_pict_type; | |
309 const double mb_num= s->mb_num; | |
310 int i; | |
311 | |
312 double const_values[]={ | |
313 M_PI, | |
314 M_E, | |
315 rce->i_tex_bits*rce->qscale, | |
316 rce->p_tex_bits*rce->qscale, | |
317 (rce->i_tex_bits + rce->p_tex_bits)*(double)rce->qscale, | |
318 rce->mv_bits/mb_num, | |
319 rce->pict_type == B_TYPE ? (rce->f_code + rce->b_code)*0.5 : rce->f_code, | |
320 rce->i_count/mb_num, | |
321 rce->mc_mb_var_sum/mb_num, | |
322 rce->mb_var_sum/mb_num, | |
323 rce->pict_type == I_TYPE, | |
324 rce->pict_type == P_TYPE, | |
325 rce->pict_type == B_TYPE, | |
326 rcc->qscale_sum[pict_type] / (double)rcc->frame_count[pict_type], | |
327 a->qcompress, | |
328 /* rcc->last_qscale_for[I_TYPE], | |
329 rcc->last_qscale_for[P_TYPE], | |
330 rcc->last_qscale_for[B_TYPE], | |
331 rcc->next_non_b_qscale,*/ | |
332 rcc->i_cplx_sum[I_TYPE] / (double)rcc->frame_count[I_TYPE], | |
333 rcc->i_cplx_sum[P_TYPE] / (double)rcc->frame_count[P_TYPE], | |
334 rcc->p_cplx_sum[P_TYPE] / (double)rcc->frame_count[P_TYPE], | |
335 rcc->p_cplx_sum[B_TYPE] / (double)rcc->frame_count[B_TYPE], | |
336 (rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / (double)rcc->frame_count[pict_type], | |
337 0 | |
338 }; | |
339 | |
340 bits= ff_parse_eval(rcc->rc_eq_eval, const_values, rce); | |
334 if (isnan(bits)) { | 341 if (isnan(bits)) { |
335 av_log(s->avctx, AV_LOG_ERROR, "Error evaluating rc_eq \"%s\": %s\n", s->avctx->rc_eq, error? error : ""); | 342 av_log(s->avctx, AV_LOG_ERROR, "Error evaluating rc_eq \"%s\"\n", s->avctx->rc_eq); |
336 return -1; | 343 return -1; |
337 } | 344 } |
338 | 345 |
339 rcc->pass1_rc_eq_output_sum+= bits; | 346 rcc->pass1_rc_eq_output_sum+= bits; |
340 bits*=rate_factor; | 347 bits*=rate_factor; |