Move eval.c and eval.h from libavcodec to libavutil, and make the eval
[libav.git] / libavcodec / ratecontrol.c
CommitLineData
8b4c7dbc 1/*
2ef0f2b2
FB
2 * Rate control for video encoders
3 *
8f2ab833 4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
2ef0f2b2 5 *
b78e7197
DB
6 * This file is part of FFmpeg.
7 *
8 * FFmpeg is free software; you can redistribute it and/or
2ef0f2b2
FB
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
b78e7197 11 * version 2.1 of the License, or (at your option) any later version.
2ef0f2b2 12 *
b78e7197 13 * FFmpeg is distributed in the hope that it will be useful,
2ef0f2b2
FB
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
b78e7197 19 * License along with FFmpeg; if not, write to the Free Software
5509bffa 20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
2ef0f2b2 21 */
983e3246
MN
22
23/**
ba87f080 24 * @file
983e3246 25 * Rate control for video encoders.
115329f1 26 */
983e3246 27
94ca624f 28#include "libavutil/intmath.h"
8b4c7dbc 29#include "avcodec.h"
2ef0f2b2 30#include "dsputil.h"
0de9926f 31#include "ratecontrol.h"
8b4c7dbc 32#include "mpegvideo.h"
0b99215c 33#include "libavutil/eval.h"
8b4c7dbc 34
e42dba48 35#undef NDEBUG // Always check asserts, the speed effect is far too small to disable them.
3aa102be 36#include <assert.h>
8b4c7dbc 37
471d7dc3
MN
38#ifndef M_E
39#define M_E 2.718281828
40#endif
41
8b4c7dbc 42static int init_pass2(MpegEncContext *s);
3aa102be 43static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_factor, int frame_num);
8b4c7dbc
MN
44
45void ff_write_pass1_stats(MpegEncContext *s){
64b7c5b6 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",
115329f1
DB
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,
64b7c5b6 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);
8b4c7dbc
MN
50}
51
bb0f1ea7
OS
52static 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
59static 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
8b4c7dbc
MN
66int ff_rate_control_init(MpegEncContext *s)
67{
68 RateControlContext *rcc= &s->rc_context;
9ace13b4 69 int i, res;
cf2baeb3 70 static const char * const const_names[]={
bb0f1ea7
OS
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 };
9b5ede5b 97 static double (* const func1[])(void *, double)={
bb0f1ea7
OS
98 (void *)bits2qp,
99 (void *)qp2bits,
100 NULL
101 };
cf2baeb3 102 static const char * const func1_names[]={
bb0f1ea7
OS
103 "bits2qp",
104 "qp2bits",
105 NULL
106 };
8b4c7dbc
MN
107 emms_c();
108
0b99215c 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);
9ace13b4 110 if (res < 0) {
2b65bb45 111 av_log(s->avctx, AV_LOG_ERROR, "Error parsing rc_eq \"%s\"\n", s->avctx->rc_eq);
9ace13b4 112 return res;
bb0f1ea7
OS
113 }
114
3aa102be 115 for(i=0; i<5; i++){
158c7f05 116 rcc->pred[i].coeff= FF_QP2LAMBDA * 7.0;
3aa102be 117 rcc->pred[i].count= 1.0;
115329f1 118
3aa102be
MN
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]=
04932b0d 124 rcc->frame_count[i]= 1; // 1 is better because of 1/0 and such
158c7f05 125 rcc->last_qscale_for[i]=FF_QP2LAMBDA * 5;
3aa102be 126 }
fb066639 127 rcc->buffer_index= s->avctx->rc_initial_buffer_occupancy;
3aa102be 128
3aa102be 129 if(s->flags&CODEC_FLAG_PASS2){
8b4c7dbc 130 int i;
3aa102be 131 char *p;
8b4c7dbc 132
3aa102be
MN
133 /* find number of pics */
134 p= s->avctx->stats_in;
135 for(i=-1; p; i++){
136 p= strchr(p+1, ';');
8b4c7dbc 137 }
3aa102be 138 i+= s->max_b_frames;
0ecca7a4
MN
139 if(i<=0 || i>=INT_MAX / sizeof(RateControlEntry))
140 return -1;
90901860 141 rcc->entry = av_mallocz(i*sizeof(RateControlEntry));
3aa102be 142 rcc->num_entries= i;
115329f1 143
160d679c 144 /* init all to skipped p frames (with b frames we might have a not encoded frame at the end FIXME) */
3aa102be
MN
145 for(i=0; i<rcc->num_entries; i++){
146 RateControlEntry *rce= &rcc->entry[i];
9701840b 147 rce->pict_type= rce->new_pict_type=FF_P_TYPE;
158c7f05 148 rce->qscale= rce->new_qscale=FF_QP2LAMBDA * 2;
3aa102be
MN
149 rce->misc_bits= s->mb_num + 10;
150 rce->mb_var_sum= s->mb_num*100;
115329f1
DB
151 }
152
3aa102be
MN
153 /* read stats */
154 p= s->avctx->stats_in;
155 for(i=0; i<rcc->num_entries - s->max_b_frames; i++){
8b4c7dbc
MN
156 RateControlEntry *rce;
157 int picture_number;
158 int e;
3aa102be
MN
159 char *next;
160
161 next= strchr(p, ';');
162 if(next){
755bfeab 163 (*next)=0; //sscanf in unbelievably slow on looong strings //FIXME copy / do not write
3aa102be
MN
164 next++;
165 }
166 e= sscanf(p, " in:%d ", &picture_number);
167
168 assert(picture_number >= 0);
169 assert(picture_number < rcc->num_entries);
8b4c7dbc 170 rce= &rcc->entry[picture_number];
3aa102be 171
64b7c5b6 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",
115329f1 173 &rce->pict_type, &rce->qscale, &rce->i_tex_bits, &rce->p_tex_bits, &rce->mv_bits, &rce->misc_bits,
64b7c5b6
MN
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){
9b879566 176 av_log(s->avctx, AV_LOG_ERROR, "statistics are damaged at line %d, parser out=%d\n", i, e);
8b4c7dbc
MN
177 return -1;
178 }
64b7c5b6 179
3aa102be 180 p= next;
8b4c7dbc 181 }
5fe4cf7b
MN
182
183 if(init_pass2(s) < 0) return -1;
184
64b7c5b6 185 //FIXME maybe move to end
022fad48 186 if((s->flags&CODEC_FLAG_PASS2) && s->avctx->rc_strategy == FF_RC_STRATEGY_XVID) {
b250f9c6 187#if CONFIG_LIBXVID
64b7c5b6 188 return ff_xvid_rate_control_init(s);
022fad48 189#else
842eabc5 190 av_log(s->avctx, AV_LOG_ERROR, "Xvid ratecontrol requires libavcodec compiled with Xvid support.\n");
022fad48 191 return -1;
19531051 192#endif
022fad48 193 }
8b4c7dbc 194 }
115329f1 195
3aa102be
MN
196 if(!(s->flags&CODEC_FLAG_PASS2)){
197
198 rcc->short_term_qsum=0.001;
199 rcc->short_term_qcount=0.001;
115329f1 200
23e54f69 201 rcc->pass1_rc_eq_output_sum= 0.001;
3aa102be 202 rcc->pass1_wanted_bits=0.001;
115329f1 203
0fa9a5dd
MN
204 if(s->avctx->qblur > 1.0){
205 av_log(s->avctx, AV_LOG_ERROR, "qblur too large\n");
206 return -1;
207 }
3aa102be
MN
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;
115329f1 213
9701840b
AJ
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;
3aa102be
MN
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;
158c7f05 221 rce.qscale = FF_QP2LAMBDA * 2;
3aa102be
MN
222 rce.f_code = 2;
223 rce.b_code = 1;
224 rce.misc_bits= 1;
225
9701840b 226 if(s->pict_type== FF_I_TYPE){
3aa102be
MN
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] ++;
8b4c7dbc 241
25ef0072 242 get_qscale(s, &rce, rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum, i);
df3a80b5 243 rcc->pass1_wanted_bits+= s->bit_rate/(1/av_q2d(s->avctx->time_base)); //FIXME misbehaves a little for variable fps
3aa102be
MN
244 }
245 }
246
247 }
115329f1 248
8b4c7dbc
MN
249 return 0;
250}
251
252void ff_rate_control_uninit(MpegEncContext *s)
253{
254 RateControlContext *rcc= &s->rc_context;
255 emms_c();
256
0b99215c 257 av_free_expr(rcc->rc_eq_eval);
6000abfa 258 av_freep(&rcc->entry);
64b7c5b6 259
b250f9c6 260#if CONFIG_LIBXVID
64b7c5b6
MN
261 if((s->flags&CODEC_FLAG_PASS2) && s->avctx->rc_strategy == FF_RC_STRATEGY_XVID)
262 ff_xvid_rate_control_uninit(s);
19531051 263#endif
8b4c7dbc
MN
264}
265
11dffbe1 266int ff_vbv_update(MpegEncContext *s, int frame_size){
3aa102be 267 RateControlContext *rcc= &s->rc_context;
c0df9d75 268 const double fps= 1/av_q2d(s->avctx->time_base);
d60a8f85 269 const int buffer_size= s->avctx->rc_buffer_size;
3aa102be
MN
270 const double min_rate= s->avctx->rc_min_rate/fps;
271 const double max_rate= s->avctx->rc_max_rate/fps;
115329f1 272
d60a8f85 273//printf("%d %f %d %f %f\n", buffer_size, rcc->buffer_index, frame_size, min_rate, max_rate);
3aa102be 274 if(buffer_size){
fb066639
MN
275 int left;
276
3aa102be 277 rcc->buffer_index-= frame_size;
fb066639 278 if(rcc->buffer_index < 0){
9b879566 279 av_log(s->avctx, AV_LOG_ERROR, "rc buffer underflow\n");
fb066639
MN
280 rcc->buffer_index= 0;
281 }
282
283 left= buffer_size - rcc->buffer_index - 1;
f66e4f5f 284 rcc->buffer_index += av_clip(left, min_rate, max_rate);
fb066639 285
d60a8f85
MN
286 if(rcc->buffer_index > buffer_size){
287 int stuffing= ceil((rcc->buffer_index - buffer_size)/8);
115329f1 288
11dffbe1
MN
289 if(stuffing < 4 && s->codec_id == CODEC_ID_MPEG4)
290 stuffing=4;
291 rcc->buffer_index -= 8*stuffing;
115329f1 292
11dffbe1
MN
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;
fb066639 297 }
3aa102be 298 }
11dffbe1 299 return 0;
3aa102be
MN
300}
301
302/**
303 * modifies the bitrate curve from pass1 for one frame
304 */
305static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_factor, int frame_num){
306 RateControlContext *rcc= &s->rc_context;
d55f7b65 307 AVCodecContext *a= s->avctx;
3aa102be
MN
308 double q, bits;
309 const int pict_type= rce->new_pict_type;
115329f1 310 const double mb_num= s->mb_num;
3aa102be 311 int i;
3aa102be
MN
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,
9701840b 320 rce->pict_type == FF_B_TYPE ? (rce->f_code + rce->b_code)*0.5 : rce->f_code,
3aa102be
MN
321 rce->i_count/mb_num,
322 rce->mc_mb_var_sum/mb_num,
323 rce->mb_var_sum/mb_num,
9701840b
AJ
324 rce->pict_type == FF_I_TYPE,
325 rce->pict_type == FF_P_TYPE,
326 rce->pict_type == FF_B_TYPE,
3aa102be 327 rcc->qscale_sum[pict_type] / (double)rcc->frame_count[pict_type],
d55f7b65 328 a->qcompress,
9701840b
AJ
329/* rcc->last_qscale_for[FF_I_TYPE],
330 rcc->last_qscale_for[FF_P_TYPE],
331 rcc->last_qscale_for[FF_B_TYPE],
3aa102be 332 rcc->next_non_b_qscale,*/
9701840b
AJ
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],
3aa102be
MN
337 (rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / (double)rcc->frame_count[pict_type],
338 0
339 };
3aa102be 340
0b99215c 341 bits = av_eval_expr(rcc->rc_eq_eval, const_values, rce);
4156a436 342 if (isnan(bits)) {
bb0f1ea7 343 av_log(s->avctx, AV_LOG_ERROR, "Error evaluating rc_eq \"%s\"\n", s->avctx->rc_eq);
4156a436
PI
344 return -1;
345 }
115329f1 346
23e54f69 347 rcc->pass1_rc_eq_output_sum+= bits;
3aa102be
MN
348 bits*=rate_factor;
349 if(bits<0.0) bits=0.0;
350 bits+= 1.0; //avoid 1/0 issues
115329f1 351
3aa102be
MN
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;
115329f1
DB
357
358 if(rco[i].qscale)
3aa102be
MN
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);
115329f1 365
3aa102be 366 /* I/B difference */
9701840b 367 if (pict_type==FF_I_TYPE && s->avctx->i_quant_factor<0.0)
3aa102be 368 q= -q*s->avctx->i_quant_factor + s->avctx->i_quant_offset;
9701840b 369 else if(pict_type==FF_B_TYPE && s->avctx->b_quant_factor<0.0)
3aa102be 370 q= -q*s->avctx->b_quant_factor + s->avctx->b_quant_offset;
2711cb28 371 if(q<1) q=1;
115329f1 372
6a1f7e7b
MN
373 return q;
374}
375
376static 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;
9701840b 380 const double last_p_q = rcc->last_qscale_for[FF_P_TYPE];
6a1f7e7b 381 const double last_non_b_q= rcc->last_qscale_for[rcc->last_non_b_pict_type];
115329f1 382
9701840b 383 if (pict_type==FF_I_TYPE && (a->i_quant_factor>0.0 || rcc->last_non_b_pict_type==FF_P_TYPE))
c26abfa5 384 q= last_p_q *FFABS(a->i_quant_factor) + a->i_quant_offset;
9701840b 385 else if(pict_type==FF_B_TYPE && a->b_quant_factor>0.0)
6a1f7e7b 386 q= last_non_b_q* a->b_quant_factor + a->b_quant_offset;
2711cb28 387 if(q<1) q=1;
6a1f7e7b 388
3aa102be 389 /* last qscale / qdiff stuff */
9701840b 390 if(rcc->last_non_b_pict_type==pict_type || pict_type!=FF_I_TYPE){
6a1f7e7b 391 double last_q= rcc->last_qscale_for[pict_type];
158c7f05 392 const int maxdiff= FF_QP2LAMBDA * a->max_qdiff;
59b571c1 393
158c7f05
MN
394 if (q > last_q + maxdiff) q= last_q + maxdiff;
395 else if(q < last_q - maxdiff) q= last_q - maxdiff;
6a1f7e7b 396 }
3aa102be 397
755bfeab 398 rcc->last_qscale_for[pict_type]= q; //Note we cannot do that after blurring
115329f1 399
9701840b 400 if(pict_type!=FF_B_TYPE)
6a1f7e7b
MN
401 rcc->last_non_b_pict_type= pict_type;
402
3aa102be
MN
403 return q;
404}
405
406/**
407 * gets the qmin & qmax for pict_type
408 */
409static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type){
115329f1 410 int qmin= s->avctx->lmin;
158c7f05 411 int qmax= s->avctx->lmax;
115329f1 412
fa12b546 413 assert(qmin <= qmax);
3aa102be 414
9701840b 415 if(pict_type==FF_B_TYPE){
c26abfa5
DB
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);
9701840b 418 }else if(pict_type==FF_I_TYPE){
c26abfa5
DB
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);
3aa102be
MN
421 }
422
f66e4f5f
RD
423 qmin= av_clip(qmin, 1, FF_LAMBDA_MAX);
424 qmax= av_clip(qmax, 1, FF_LAMBDA_MAX);
3aa102be 425
fa12b546 426 if(qmax<qmin) qmax= qmin;
115329f1 427
3aa102be
MN
428 *qmin_ret= qmin;
429 *qmax_ret= qmax;
430}
431
432static double modify_qscale(MpegEncContext *s, RateControlEntry *rce, double q, int frame_num){
433 RateControlContext *rcc= &s->rc_context;
434 int qmin, qmax;
3aa102be
MN
435 const int pict_type= rce->new_pict_type;
436 const double buffer_size= s->avctx->rc_buffer_size;
c0df9d75 437 const double fps= 1/av_q2d(s->avctx->time_base);
fb066639
MN
438 const double min_rate= s->avctx->rc_min_rate / fps;
439 const double max_rate= s->avctx->rc_max_rate / fps;
115329f1 440
3aa102be
MN
441 get_qminmax(&qmin, &qmax, s, pict_type);
442
443 /* modulation */
9701840b 444 if(s->avctx->rc_qmod_freq && frame_num%s->avctx->rc_qmod_freq==0 && pict_type==FF_P_TYPE)
3aa102be
MN
445 q*= s->avctx->rc_qmod_amp;
446
946c8a12 447//printf("q:%f\n", q);
3aa102be
MN
448 /* buffer overflow/underflow protection */
449 if(buffer_size){
6a1f7e7b 450 double expected_size= rcc->buffer_index;
d60a8f85 451 double q_limit;
3aa102be
MN
452
453 if(min_rate){
6a1f7e7b 454 double d= 2*(buffer_size - expected_size)/buffer_size;
3aa102be 455 if(d>1.0) d=1.0;
946c8a12
MN
456 else if(d<0.0001) d=0.0001;
457 q*= pow(d, 1.0/s->avctx->rc_buffer_aggressivity);
6a1f7e7b 458
3bff4d8b 459 q_limit= bits2qp(rce, FFMAX((min_rate - buffer_size + rcc->buffer_index) * s->avctx->rc_min_vbv_overflow_use, 1));
d60a8f85
MN
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 }
3aa102be
MN
466 }
467
468 if(max_rate){
469 double d= 2*expected_size/buffer_size;
470 if(d>1.0) d=1.0;
946c8a12
MN
471 else if(d<0.0001) d=0.0001;
472 q/= pow(d, 1.0/s->avctx->rc_buffer_aggressivity);
6a1f7e7b 473
3bff4d8b 474 q_limit= bits2qp(rce, FFMAX(rcc->buffer_index * s->avctx->rc_max_available_vbv_use, 1));
d60a8f85
MN
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 }
3aa102be
MN
481 }
482 }
946c8a12 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);
c695ca3b 484 if(s->avctx->rc_qsquish==0.0 || qmin==qmax){
3aa102be
MN
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);
115329f1 490
3aa102be
MN
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;
115329f1 496
3aa102be
MN
497 q= exp(q);
498 }
115329f1 499
3aa102be
MN
500 return q;
501}
502
8b4c7dbc
MN
503//----------------------------------
504// 1 Pass Code
505
3aa102be 506static double predict_size(Predictor *p, double q, double var)
8b4c7dbc
MN
507{
508 return p->coeff*var / (q*p->count);
509}
510
ccfddafb 511/*
3aa102be
MN
512static 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}
ccfddafb 517*/
3aa102be 518
8b4c7dbc
MN
519static void update_predictor(Predictor *p, double q, double var, double size)
520{
521 double new_coeff= size*q / (var + 1);
3aa102be 522 if(var<10) return;
8b4c7dbc
MN
523
524 p->count*= p->decay;
525 p->coeff*= p->decay;
526 p->count++;
527 p->coeff+= new_coeff;
528}
529
c5d309f2
MN
530static void adaptive_quantization(MpegEncContext *s, double q){
531 int i;
532 const float lumi_masking= s->avctx->lumi_masking / (128.0*128.0);
5e746b99 533 const float dark_masking= s->avctx->dark_masking / (128.0*128.0);
c5d309f2
MN
534 const float temp_cplx_masking= s->avctx->temporal_cplx_masking;
535 const float spatial_cplx_masking = s->avctx->spatial_cplx_masking;
536 const float p_masking = s->avctx->p_masking;
957c743a 537 const float border_masking = s->avctx->border_masking;
c5d309f2
MN
538 float bits_sum= 0.0;
539 float cplx_sum= 0.0;
540 float cplx_tab[s->mb_num];
541 float bits_tab[s->mb_num];
6e0d8c06
MN
542 const int qmin= s->avctx->mb_lmin;
543 const int qmax= s->avctx->mb_lmax;
1e491e29 544 Picture * const pic= &s->current_picture;
957c743a
CM
545 const int mb_width = s->mb_width;
546 const int mb_height = s->mb_height;
115329f1 547
c5d309f2 548 for(i=0; i<s->mb_num; i++){
2f5feea4 549 const int mb_xy= s->mb_index2xy[i];
158c7f05 550 float temp_cplx= sqrt(pic->mc_mb_var[mb_xy]); //FIXME merge in pow()
2f5feea4
MN
551 float spat_cplx= sqrt(pic->mb_var[mb_xy]);
552 const int lumi= pic->mb_mean[mb_xy];
c5d309f2 553 float bits, cplx, factor;
957c743a
CM
554 int mb_x = mb_xy % s->mb_stride;
555 int mb_y = mb_xy / s->mb_stride;
556 int mb_distance;
557 float mb_factor = 0.0;
115329f1 558#if 0
c5d309f2
MN
559 if(spat_cplx < q/3) spat_cplx= q/3; //FIXME finetune
560 if(temp_cplx < q/3) temp_cplx= q/3; //FIXME finetune
115329f1 561#endif
158c7f05
MN
562 if(spat_cplx < 4) spat_cplx= 4; //FIXME finetune
563 if(temp_cplx < 4) temp_cplx= 4; //FIXME finetune
564
115329f1 565 if((s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTRA)){//FIXME hq mode
c5d309f2
MN
566 cplx= spat_cplx;
567 factor= 1.0 + p_masking;
568 }else{
569 cplx= temp_cplx;
570 factor= pow(temp_cplx, - temp_cplx_masking);
571 }
572 factor*=pow(spat_cplx, - spatial_cplx_masking);
5e746b99
MN
573
574 if(lumi>127)
575 factor*= (1.0 - (lumi-128)*(lumi-128)*lumi_masking);
576 else
577 factor*= (1.0 - (lumi-128)*(lumi-128)*dark_masking);
957c743a
CM
578
579 if(mb_x < mb_width/5){
580 mb_distance = mb_width/5 - mb_x;
581 mb_factor = (float)mb_distance / (float)(mb_width/5);
582 }else if(mb_x > 4*mb_width/5){
583 mb_distance = mb_x - 4*mb_width/5;
584 mb_factor = (float)mb_distance / (float)(mb_width/5);
585 }
586 if(mb_y < mb_height/5){
587 mb_distance = mb_height/5 - mb_y;
588 mb_factor = FFMAX(mb_factor, (float)mb_distance / (float)(mb_height/5));
589 }else if(mb_y > 4*mb_height/5){
590 mb_distance = mb_y - 4*mb_height/5;
591 mb_factor = FFMAX(mb_factor, (float)mb_distance / (float)(mb_height/5));
592 }
593
594 factor*= 1.0 - border_masking*mb_factor;
115329f1 595
c5d309f2 596 if(factor<0.00001) factor= 0.00001;
115329f1 597
c5d309f2
MN
598 bits= cplx*factor;
599 cplx_sum+= cplx;
600 bits_sum+= bits;
601 cplx_tab[i]= cplx;
602 bits_tab[i]= bits;
603 }
604
755bfeab 605 /* handle qmin/qmax clipping */
c5d309f2 606 if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
e9a4834a 607 float factor= bits_sum/cplx_sum;
c5d309f2
MN
608 for(i=0; i<s->mb_num; i++){
609 float newq= q*cplx_tab[i]/bits_tab[i];
e9a4834a 610 newq*= factor;
c5d309f2
MN
611
612 if (newq > qmax){
613 bits_sum -= bits_tab[i];
614 cplx_sum -= cplx_tab[i]*q/qmax;
615 }
616 else if(newq < qmin){
617 bits_sum -= bits_tab[i];
618 cplx_sum -= cplx_tab[i]*q/qmin;
619 }
620 }
e9a4834a
MN
621 if(bits_sum < 0.001) bits_sum= 0.001;
622 if(cplx_sum < 0.001) cplx_sum= 0.001;
c5d309f2 623 }
115329f1 624
c5d309f2 625 for(i=0; i<s->mb_num; i++){
2f5feea4 626 const int mb_xy= s->mb_index2xy[i];
c5d309f2
MN
627 float newq= q*cplx_tab[i]/bits_tab[i];
628 int intq;
629
630 if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
631 newq*= bits_sum/cplx_sum;
632 }
633
158c7f05 634 intq= (int)(newq + 0.5);
c5d309f2
MN
635
636 if (intq > qmax) intq= qmax;
637 else if(intq < qmin) intq= qmin;
638//if(i%s->mb_width==0) printf("\n");
639//printf("%2d%3d ", intq, ff_sqrt(s->mc_mb_var[i]));
158c7f05 640 s->lambda_table[mb_xy]= intq;
c5d309f2
MN
641 }
642}
82b019ce
MN
643
644void 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
158c7f05 654//FIXME rd or at least approx for dquant
c5d309f2 655
8ed9f9ab 656float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
8b4c7dbc 657{
8b4c7dbc 658 float q;
c5d309f2 659 int qmin, qmax;
8b4c7dbc
MN
660 float br_compensation;
661 double diff;
662 double short_term_q;
8b4c7dbc 663 double fps;
3aa102be 664 int picture_number= s->picture_number;
8b4c7dbc 665 int64_t wanted_bits;
3aa102be 666 RateControlContext *rcc= &s->rc_context;
d55f7b65 667 AVCodecContext *a= s->avctx;
3aa102be
MN
668 RateControlEntry local_rce, *rce;
669 double bits;
670 double rate_factor;
671 int var;
672 const int pict_type= s->pict_type;
1e491e29 673 Picture * const pic= &s->current_picture;
8b4c7dbc
MN
674 emms_c();
675
b250f9c6 676#if CONFIG_LIBXVID
64b7c5b6
MN
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);
19531051 679#endif
64b7c5b6 680
3aa102be 681 get_qminmax(&qmin, &qmax, s, pict_type);
8b4c7dbc 682
c0df9d75 683 fps= 1/av_q2d(s->avctx->time_base);
946c8a12 684//printf("input_pic_num:%d pic_num:%d frame_rate:%d\n", s->input_picture_number, s->picture_number, s->frame_rate);
8b4c7dbc 685 /* update predictors */
8ed9f9ab 686 if(picture_number>2 && !dry_run){
9701840b 687 const int last_var= s->last_pict_type == FF_I_TYPE ? rcc->last_mb_var_sum : rcc->last_mc_mb_var_sum;
3aa102be 688 update_predictor(&rcc->pred[s->last_pict_type], rcc->last_qscale, sqrt(last_var), s->frame_bits);
8b4c7dbc
MN
689 }
690
3aa102be
MN
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{
f6128014 697 Picture *dts_pic;
3aa102be 698 rce= &local_rce;
f6128014
MN
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
9701840b 702 if(s->pict_type == FF_B_TYPE || s->low_delay)
f6128014
MN
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);
3aa102be 714 }
8b4c7dbc 715
3aa102be 716 diff= s->total_bits - wanted_bits;
d55f7b65 717 br_compensation= (a->bit_rate_tolerance - diff)/a->bit_rate_tolerance;
3aa102be
MN
718 if(br_compensation<=0.0) br_compensation=0.001;
719
9701840b 720 var= pict_type == FF_I_TYPE ? pic->mb_var_sum : pic->mc_mb_var_sum;
115329f1 721
b1609412 722 short_term_q = 0; /* avoid warning */
3aa102be 723 if(s->flags&CODEC_FLAG_PASS2){
9701840b 724 if(pict_type!=FF_I_TYPE)
3aa102be
MN
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{
115329f1 730 rce->pict_type=
3aa102be 731 rce->new_pict_type= pict_type;
1e491e29
MN
732 rce->mc_mb_var_sum= pic->mc_mb_var_sum;
733 rce->mb_var_sum = pic-> mb_var_sum;
158c7f05 734 rce->qscale = FF_QP2LAMBDA * 2;
3aa102be
MN
735 rce->f_code = s->f_code;
736 rce->b_code = s->b_code;
737 rce->misc_bits= 1;
738
3aa102be 739 bits= predict_size(&rcc->pred[pict_type], rce->qscale, sqrt(var));
9701840b 740 if(pict_type== FF_I_TYPE){
3aa102be
MN
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;
115329f1 749
3aa102be 750 rce->mv_bits= bits*0.1;
8b4c7dbc 751 }
3aa102be
MN
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] ++;
8b4c7dbc 756
3aa102be 757 bits= rce->i_tex_bits + rce->p_tex_bits;
23e54f69 758 rate_factor= rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum * br_compensation;
115329f1 759
3aa102be 760 q= get_qscale(s, rce, rate_factor, picture_number);
4156a436
PI
761 if (q < 0)
762 return -1;
8b4c7dbc 763
c695ca3b 764 assert(q>0.0);
3aa102be 765//printf("%f ", q);
6a1f7e7b 766 q= get_diff_limited_q(s, rce, q);
3aa102be
MN
767//printf("%f ", q);
768 assert(q>0.0);
769
9701840b 770 if(pict_type==FF_P_TYPE || s->intra_only){ //FIXME type dependent blur like in 2-pass
d55f7b65
MN
771 rcc->short_term_qsum*=a->qblur;
772 rcc->short_term_qcount*=a->qblur;
3aa102be
MN
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 }
946c8a12 780 assert(q>0.0);
115329f1 781
3aa102be
MN
782 q= modify_qscale(s, rce, q, picture_number);
783
784 rcc->pass1_wanted_bits+= s->bit_rate/fps;
785
c695ca3b 786 assert(q>0.0);
8b4c7dbc 787 }
59b571c1
MN
788
789 if(s->avctx->debug&FF_DEBUG_RC){
9b879566 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",
d8085ea7 791 av_get_pict_type_char(pict_type), qmin, q, qmax, picture_number, (int)wanted_bits/1000, (int)s->total_bits/1000,
59b571c1
MN
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 }
3aa102be 795
115329f1 796 if (q<qmin) q=qmin;
3aa102be 797 else if(q>qmax) q=qmax;
3aa102be 798
c5d309f2
MN
799 if(s->adaptive_quant)
800 adaptive_quantization(s, q);
801 else
802 q= (int)(q + 0.5);
115329f1 803
8ed9f9ab
MN
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 }
1e491e29
MN
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
c5d309f2 817 return q;
8b4c7dbc
MN
818}
819
820//----------------------------------------------
821// 2-Pass code
822
823static int init_pass2(MpegEncContext *s)
824{
825 RateControlContext *rcc= &s->rc_context;
d55f7b65 826 AVCodecContext *a= s->avctx;
577cd173 827 int i, toobig;
c0df9d75 828 double fps= 1/av_q2d(s->avctx->time_base);
8b4c7dbc 829 double complexity[5]={0,0,0,0,0}; // aproximate bits at quant=1
eafcac6a 830 uint64_t const_bits[5]={0,0,0,0,0}; // quantizer independent bits
8b4c7dbc
MN
831 uint64_t all_const_bits;
832 uint64_t all_available_bits= (uint64_t)(s->bit_rate*(double)rcc->num_entries/fps);
8b4c7dbc
MN
833 double rate_factor=0;
834 double step;
ccfddafb 835 //int last_i_frame=-10000000;
115329f1 836 const int filter_size= (int)(a->qblur*4) | 1;
3aa102be 837 double expected_bits;
170c0b45 838 double *qscale, *blurred_qscale, qscale_sum;
8b4c7dbc
MN
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];
115329f1 843
0d1e9246 844 rce->new_pict_type= rce->pict_type;
3aa102be
MN
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] ++;
8b4c7dbc
MN
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;
8b4c7dbc 852 }
9701840b 853 all_const_bits= const_bits[FF_I_TYPE] + const_bits[FF_P_TYPE] + const_bits[FF_B_TYPE];
115329f1 854
8b4c7dbc 855 if(all_available_bits < all_const_bits){
29b372b9 856 av_log(s->avctx, AV_LOG_ERROR, "requested bitrate is too low\n");
8b4c7dbc
MN
857 return -1;
858 }
115329f1 859
8e1e6f31 860 qscale= av_malloc(sizeof(double)*rcc->num_entries);
170c0b45 861 blurred_qscale= av_malloc(sizeof(double)*rcc->num_entries);
577cd173 862 toobig = 0;
3aa102be 863
8b4c7dbc 864 for(step=256*256; step>0.0000001; step*=0.5){
3aa102be 865 expected_bits=0;
8b4c7dbc 866 rate_factor+= step;
115329f1 867
3aa102be
MN
868 rcc->buffer_index= s->avctx->rc_buffer_size/2;
869
8b4c7dbc
MN
870 /* find qscale */
871 for(i=0; i<rcc->num_entries; i++){
3aa102be
MN
872 qscale[i]= get_qscale(s, &rcc->entry[i], rate_factor, i);
873 }
874 assert(filter_size%2==1);
875
876 /* fixed I/B QP relative to P mode */
3aa102be 877 for(i=rcc->num_entries-1; i>=0; i--){
8b4c7dbc 878 RateControlEntry *rce= &rcc->entry[i];
115329f1 879
6a1f7e7b 880 qscale[i]= get_diff_limited_q(s, rce, qscale[i]);
3aa102be 881 }
8b4c7dbc 882
3aa102be
MN
883 /* smooth curve */
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;
115329f1 889
3aa102be
MN
890 for(j=0; j<filter_size; j++){
891 int index= i+j-filter_size/2;
892 double d= index-i;
d55f7b65 893 double coeff= a->qblur==0 ? 1.0 : exp(-d*d/(a->qblur * a->qblur));
115329f1 894
3aa102be
MN
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;
8b4c7dbc 899 }
170c0b45 900 blurred_qscale[i]= q/sum;
8b4c7dbc 901 }
115329f1 902
8b4c7dbc
MN
903 /* find expected bits */
904 for(i=0; i<rcc->num_entries; i++){
905 RateControlEntry *rce= &rcc->entry[i];
3aa102be 906 double bits;
170c0b45 907 rce->new_qscale= modify_qscale(s, rce, blurred_qscale[i], i);
405469ce 908 bits= qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;
170c0b45 909//printf("%d %f\n", rce->new_bits, blurred_qscale[i]);
11dffbe1 910 bits += 8*ff_vbv_update(s, bits);
3aa102be 911
8b4c7dbc 912 rce->expected_bits= expected_bits;
3aa102be 913 expected_bits += bits;
8b4c7dbc
MN
914 }
915
577cd173
CH
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 }
8b4c7dbc 925 }
8e1e6f31 926 av_free(qscale);
170c0b45 927 av_free(blurred_qscale);
8b4c7dbc 928
577cd173
CH
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); */
f66e4f5f 934 qscale_sum += av_clip(rcc->entry[i].new_qscale / FF_QP2LAMBDA, s->avctx->qmin, s->avctx->qmax);
577cd173
CH
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");
3aa102be 956 return -1;
8b4c7dbc 957 }
8b4c7dbc 958
3aa102be 959 return 0;
8b4c7dbc 960}