Move ff_sqrt() to libavutil/intmath.h
[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/**
bad5537e 24 * @file libavcodec/ratecontrol.c
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"
4d7b4613 33#include "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;
3aa102be 69 int i;
e3cb2c4a 70 const char *error = NULL;
cf2baeb3 71 static const char * const const_names[]={
bb0f1ea7
OS
72 "PI",
73 "E",
74 "iTex",
75 "pTex",
76 "tex",
77 "mv",
78 "fCode",
79 "iCount",
80 "mcVar",
81 "var",
82 "isI",
83 "isP",
84 "isB",
85 "avgQP",
86 "qComp",
87/* "lastIQP",
88 "lastPQP",
89 "lastBQP",
90 "nextNonBQP",*/
91 "avgIITex",
92 "avgPITex",
93 "avgPPTex",
94 "avgBPTex",
95 "avgTex",
96 NULL
97 };
9b5ede5b 98 static double (* const func1[])(void *, double)={
bb0f1ea7
OS
99 (void *)bits2qp,
100 (void *)qp2bits,
101 NULL
102 };
cf2baeb3 103 static const char * const func1_names[]={
bb0f1ea7
OS
104 "bits2qp",
105 "qp2bits",
106 NULL
107 };
8b4c7dbc
MN
108 emms_c();
109
3cffbe09 110 rcc->rc_eq_eval = ff_parse(s->avctx->rc_eq ? s->avctx->rc_eq : "tex^qComp", const_names, func1, func1_names, NULL, NULL, &error);
bb0f1ea7
OS
111 if (!rcc->rc_eq_eval) {
112 av_log(s->avctx, AV_LOG_ERROR, "Error parsing rc_eq \"%s\": %s\n", s->avctx->rc_eq, error? error : "");
113 return -1;
114 }
115
3aa102be 116 for(i=0; i<5; i++){
158c7f05 117 rcc->pred[i].coeff= FF_QP2LAMBDA * 7.0;
3aa102be 118 rcc->pred[i].count= 1.0;
115329f1 119
3aa102be
MN
120 rcc->pred[i].decay= 0.4;
121 rcc->i_cplx_sum [i]=
122 rcc->p_cplx_sum [i]=
123 rcc->mv_bits_sum[i]=
124 rcc->qscale_sum [i]=
04932b0d 125 rcc->frame_count[i]= 1; // 1 is better because of 1/0 and such
158c7f05 126 rcc->last_qscale_for[i]=FF_QP2LAMBDA * 5;
3aa102be 127 }
fb066639 128 rcc->buffer_index= s->avctx->rc_initial_buffer_occupancy;
3aa102be 129
3aa102be 130 if(s->flags&CODEC_FLAG_PASS2){
8b4c7dbc 131 int i;
3aa102be 132 char *p;
8b4c7dbc 133
3aa102be
MN
134 /* find number of pics */
135 p= s->avctx->stats_in;
136 for(i=-1; p; i++){
137 p= strchr(p+1, ';');
8b4c7dbc 138 }
3aa102be 139 i+= s->max_b_frames;
0ecca7a4
MN
140 if(i<=0 || i>=INT_MAX / sizeof(RateControlEntry))
141 return -1;
90901860 142 rcc->entry = av_mallocz(i*sizeof(RateControlEntry));
3aa102be 143 rcc->num_entries= i;
115329f1 144
160d679c 145 /* init all to skipped p frames (with b frames we might have a not encoded frame at the end FIXME) */
3aa102be
MN
146 for(i=0; i<rcc->num_entries; i++){
147 RateControlEntry *rce= &rcc->entry[i];
9701840b 148 rce->pict_type= rce->new_pict_type=FF_P_TYPE;
158c7f05 149 rce->qscale= rce->new_qscale=FF_QP2LAMBDA * 2;
3aa102be
MN
150 rce->misc_bits= s->mb_num + 10;
151 rce->mb_var_sum= s->mb_num*100;
115329f1
DB
152 }
153
3aa102be
MN
154 /* read stats */
155 p= s->avctx->stats_in;
156 for(i=0; i<rcc->num_entries - s->max_b_frames; i++){
8b4c7dbc
MN
157 RateControlEntry *rce;
158 int picture_number;
159 int e;
3aa102be
MN
160 char *next;
161
162 next= strchr(p, ';');
163 if(next){
755bfeab 164 (*next)=0; //sscanf in unbelievably slow on looong strings //FIXME copy / do not write
3aa102be
MN
165 next++;
166 }
167 e= sscanf(p, " in:%d ", &picture_number);
168
169 assert(picture_number >= 0);
170 assert(picture_number < rcc->num_entries);
8b4c7dbc 171 rce= &rcc->entry[picture_number];
3aa102be 172
64b7c5b6 173 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 174 &rce->pict_type, &rce->qscale, &rce->i_tex_bits, &rce->p_tex_bits, &rce->mv_bits, &rce->misc_bits,
64b7c5b6
MN
175 &rce->f_code, &rce->b_code, &rce->mc_mb_var_sum, &rce->mb_var_sum, &rce->i_count, &rce->skip_count, &rce->header_bits);
176 if(e!=14){
9b879566 177 av_log(s->avctx, AV_LOG_ERROR, "statistics are damaged at line %d, parser out=%d\n", i, e);
8b4c7dbc
MN
178 return -1;
179 }
64b7c5b6 180
3aa102be 181 p= next;
8b4c7dbc 182 }
5fe4cf7b
MN
183
184 if(init_pass2(s) < 0) return -1;
185
64b7c5b6 186 //FIXME maybe move to end
022fad48 187 if((s->flags&CODEC_FLAG_PASS2) && s->avctx->rc_strategy == FF_RC_STRATEGY_XVID) {
b250f9c6 188#if CONFIG_LIBXVID
64b7c5b6 189 return ff_xvid_rate_control_init(s);
022fad48 190#else
842eabc5 191 av_log(s->avctx, AV_LOG_ERROR, "Xvid ratecontrol requires libavcodec compiled with Xvid support.\n");
022fad48 192 return -1;
19531051 193#endif
022fad48 194 }
8b4c7dbc 195 }
115329f1 196
3aa102be
MN
197 if(!(s->flags&CODEC_FLAG_PASS2)){
198
199 rcc->short_term_qsum=0.001;
200 rcc->short_term_qcount=0.001;
115329f1 201
23e54f69 202 rcc->pass1_rc_eq_output_sum= 0.001;
3aa102be 203 rcc->pass1_wanted_bits=0.001;
115329f1 204
0fa9a5dd
MN
205 if(s->avctx->qblur > 1.0){
206 av_log(s->avctx, AV_LOG_ERROR, "qblur too large\n");
207 return -1;
208 }
3aa102be
MN
209 /* init stuff with the user specified complexity */
210 if(s->avctx->rc_initial_cplx){
211 for(i=0; i<60*30; i++){
212 double bits= s->avctx->rc_initial_cplx * (i/10000.0 + 1.0)*s->mb_num;
213 RateControlEntry rce;
115329f1 214
9701840b
AJ
215 if (i%((s->gop_size+3)/4)==0) rce.pict_type= FF_I_TYPE;
216 else if(i%(s->max_b_frames+1)) rce.pict_type= FF_B_TYPE;
217 else rce.pict_type= FF_P_TYPE;
3aa102be
MN
218
219 rce.new_pict_type= rce.pict_type;
220 rce.mc_mb_var_sum= bits*s->mb_num/100000;
221 rce.mb_var_sum = s->mb_num;
158c7f05 222 rce.qscale = FF_QP2LAMBDA * 2;
3aa102be
MN
223 rce.f_code = 2;
224 rce.b_code = 1;
225 rce.misc_bits= 1;
226
9701840b 227 if(s->pict_type== FF_I_TYPE){
3aa102be
MN
228 rce.i_count = s->mb_num;
229 rce.i_tex_bits= bits;
230 rce.p_tex_bits= 0;
231 rce.mv_bits= 0;
232 }else{
233 rce.i_count = 0; //FIXME we do know this approx
234 rce.i_tex_bits= 0;
235 rce.p_tex_bits= bits*0.9;
236 rce.mv_bits= bits*0.1;
237 }
238 rcc->i_cplx_sum [rce.pict_type] += rce.i_tex_bits*rce.qscale;
239 rcc->p_cplx_sum [rce.pict_type] += rce.p_tex_bits*rce.qscale;
240 rcc->mv_bits_sum[rce.pict_type] += rce.mv_bits;
241 rcc->frame_count[rce.pict_type] ++;
8b4c7dbc 242
25ef0072 243 get_qscale(s, &rce, rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum, i);
df3a80b5 244 rcc->pass1_wanted_bits+= s->bit_rate/(1/av_q2d(s->avctx->time_base)); //FIXME misbehaves a little for variable fps
3aa102be
MN
245 }
246 }
247
248 }
115329f1 249
8b4c7dbc
MN
250 return 0;
251}
252
253void ff_rate_control_uninit(MpegEncContext *s)
254{
255 RateControlContext *rcc= &s->rc_context;
256 emms_c();
257
bb0f1ea7 258 ff_eval_free(rcc->rc_eq_eval);
6000abfa 259 av_freep(&rcc->entry);
64b7c5b6 260
b250f9c6 261#if CONFIG_LIBXVID
64b7c5b6
MN
262 if((s->flags&CODEC_FLAG_PASS2) && s->avctx->rc_strategy == FF_RC_STRATEGY_XVID)
263 ff_xvid_rate_control_uninit(s);
19531051 264#endif
8b4c7dbc
MN
265}
266
11dffbe1 267int ff_vbv_update(MpegEncContext *s, int frame_size){
3aa102be 268 RateControlContext *rcc= &s->rc_context;
c0df9d75 269 const double fps= 1/av_q2d(s->avctx->time_base);
d60a8f85 270 const int buffer_size= s->avctx->rc_buffer_size;
3aa102be
MN
271 const double min_rate= s->avctx->rc_min_rate/fps;
272 const double max_rate= s->avctx->rc_max_rate/fps;
115329f1 273
d60a8f85 274//printf("%d %f %d %f %f\n", buffer_size, rcc->buffer_index, frame_size, min_rate, max_rate);
3aa102be 275 if(buffer_size){
fb066639
MN
276 int left;
277
3aa102be 278 rcc->buffer_index-= frame_size;
fb066639 279 if(rcc->buffer_index < 0){
9b879566 280 av_log(s->avctx, AV_LOG_ERROR, "rc buffer underflow\n");
fb066639
MN
281 rcc->buffer_index= 0;
282 }
283
284 left= buffer_size - rcc->buffer_index - 1;
f66e4f5f 285 rcc->buffer_index += av_clip(left, min_rate, max_rate);
fb066639 286
d60a8f85
MN
287 if(rcc->buffer_index > buffer_size){
288 int stuffing= ceil((rcc->buffer_index - buffer_size)/8);
115329f1 289
11dffbe1
MN
290 if(stuffing < 4 && s->codec_id == CODEC_ID_MPEG4)
291 stuffing=4;
292 rcc->buffer_index -= 8*stuffing;
115329f1 293
11dffbe1
MN
294 if(s->avctx->debug & FF_DEBUG_RC)
295 av_log(s->avctx, AV_LOG_DEBUG, "stuffing %d bytes\n", stuffing);
296
297 return stuffing;
fb066639 298 }
3aa102be 299 }
11dffbe1 300 return 0;
3aa102be
MN
301}
302
303/**
304 * modifies the bitrate curve from pass1 for one frame
305 */
306static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_factor, int frame_num){
307 RateControlContext *rcc= &s->rc_context;
d55f7b65 308 AVCodecContext *a= s->avctx;
3aa102be
MN
309 double q, bits;
310 const int pict_type= rce->new_pict_type;
115329f1 311 const double mb_num= s->mb_num;
3aa102be 312 int i;
3aa102be
MN
313
314 double const_values[]={
315 M_PI,
316 M_E,
317 rce->i_tex_bits*rce->qscale,
318 rce->p_tex_bits*rce->qscale,
319 (rce->i_tex_bits + rce->p_tex_bits)*(double)rce->qscale,
320 rce->mv_bits/mb_num,
9701840b 321 rce->pict_type == FF_B_TYPE ? (rce->f_code + rce->b_code)*0.5 : rce->f_code,
3aa102be
MN
322 rce->i_count/mb_num,
323 rce->mc_mb_var_sum/mb_num,
324 rce->mb_var_sum/mb_num,
9701840b
AJ
325 rce->pict_type == FF_I_TYPE,
326 rce->pict_type == FF_P_TYPE,
327 rce->pict_type == FF_B_TYPE,
3aa102be 328 rcc->qscale_sum[pict_type] / (double)rcc->frame_count[pict_type],
d55f7b65 329 a->qcompress,
9701840b
AJ
330/* rcc->last_qscale_for[FF_I_TYPE],
331 rcc->last_qscale_for[FF_P_TYPE],
332 rcc->last_qscale_for[FF_B_TYPE],
3aa102be 333 rcc->next_non_b_qscale,*/
9701840b
AJ
334 rcc->i_cplx_sum[FF_I_TYPE] / (double)rcc->frame_count[FF_I_TYPE],
335 rcc->i_cplx_sum[FF_P_TYPE] / (double)rcc->frame_count[FF_P_TYPE],
336 rcc->p_cplx_sum[FF_P_TYPE] / (double)rcc->frame_count[FF_P_TYPE],
337 rcc->p_cplx_sum[FF_B_TYPE] / (double)rcc->frame_count[FF_B_TYPE],
3aa102be
MN
338 (rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / (double)rcc->frame_count[pict_type],
339 0
340 };
3aa102be 341
bb0f1ea7 342 bits= ff_parse_eval(rcc->rc_eq_eval, const_values, rce);
4156a436 343 if (isnan(bits)) {
bb0f1ea7 344 av_log(s->avctx, AV_LOG_ERROR, "Error evaluating rc_eq \"%s\"\n", s->avctx->rc_eq);
4156a436
PI
345 return -1;
346 }
115329f1 347
23e54f69 348 rcc->pass1_rc_eq_output_sum+= bits;
3aa102be
MN
349 bits*=rate_factor;
350 if(bits<0.0) bits=0.0;
351 bits+= 1.0; //avoid 1/0 issues
115329f1 352
3aa102be
MN
353 /* user override */
354 for(i=0; i<s->avctx->rc_override_count; i++){
355 RcOverride *rco= s->avctx->rc_override;
356 if(rco[i].start_frame > frame_num) continue;
357 if(rco[i].end_frame < frame_num) continue;
115329f1
DB
358
359 if(rco[i].qscale)
3aa102be
MN
360 bits= qp2bits(rce, rco[i].qscale); //FIXME move at end to really force it?
361 else
362 bits*= rco[i].quality_factor;
363 }
364
365 q= bits2qp(rce, bits);
115329f1 366
3aa102be 367 /* I/B difference */
9701840b 368 if (pict_type==FF_I_TYPE && s->avctx->i_quant_factor<0.0)
3aa102be 369 q= -q*s->avctx->i_quant_factor + s->avctx->i_quant_offset;
9701840b 370 else if(pict_type==FF_B_TYPE && s->avctx->b_quant_factor<0.0)
3aa102be 371 q= -q*s->avctx->b_quant_factor + s->avctx->b_quant_offset;
2711cb28 372 if(q<1) q=1;
115329f1 373
6a1f7e7b
MN
374 return q;
375}
376
377static double get_diff_limited_q(MpegEncContext *s, RateControlEntry *rce, double q){
378 RateControlContext *rcc= &s->rc_context;
379 AVCodecContext *a= s->avctx;
380 const int pict_type= rce->new_pict_type;
9701840b 381 const double last_p_q = rcc->last_qscale_for[FF_P_TYPE];
6a1f7e7b 382 const double last_non_b_q= rcc->last_qscale_for[rcc->last_non_b_pict_type];
115329f1 383
9701840b 384 if (pict_type==FF_I_TYPE && (a->i_quant_factor>0.0 || rcc->last_non_b_pict_type==FF_P_TYPE))
c26abfa5 385 q= last_p_q *FFABS(a->i_quant_factor) + a->i_quant_offset;
9701840b 386 else if(pict_type==FF_B_TYPE && a->b_quant_factor>0.0)
6a1f7e7b 387 q= last_non_b_q* a->b_quant_factor + a->b_quant_offset;
2711cb28 388 if(q<1) q=1;
6a1f7e7b 389
3aa102be 390 /* last qscale / qdiff stuff */
9701840b 391 if(rcc->last_non_b_pict_type==pict_type || pict_type!=FF_I_TYPE){
6a1f7e7b 392 double last_q= rcc->last_qscale_for[pict_type];
158c7f05 393 const int maxdiff= FF_QP2LAMBDA * a->max_qdiff;
59b571c1 394
158c7f05
MN
395 if (q > last_q + maxdiff) q= last_q + maxdiff;
396 else if(q < last_q - maxdiff) q= last_q - maxdiff;
6a1f7e7b 397 }
3aa102be 398
755bfeab 399 rcc->last_qscale_for[pict_type]= q; //Note we cannot do that after blurring
115329f1 400
9701840b 401 if(pict_type!=FF_B_TYPE)
6a1f7e7b
MN
402 rcc->last_non_b_pict_type= pict_type;
403
3aa102be
MN
404 return q;
405}
406
407/**
408 * gets the qmin & qmax for pict_type
409 */
410static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type){
115329f1 411 int qmin= s->avctx->lmin;
158c7f05 412 int qmax= s->avctx->lmax;
115329f1 413
fa12b546 414 assert(qmin <= qmax);
3aa102be 415
9701840b 416 if(pict_type==FF_B_TYPE){
c26abfa5
DB
417 qmin= (int)(qmin*FFABS(s->avctx->b_quant_factor)+s->avctx->b_quant_offset + 0.5);
418 qmax= (int)(qmax*FFABS(s->avctx->b_quant_factor)+s->avctx->b_quant_offset + 0.5);
9701840b 419 }else if(pict_type==FF_I_TYPE){
c26abfa5
DB
420 qmin= (int)(qmin*FFABS(s->avctx->i_quant_factor)+s->avctx->i_quant_offset + 0.5);
421 qmax= (int)(qmax*FFABS(s->avctx->i_quant_factor)+s->avctx->i_quant_offset + 0.5);
3aa102be
MN
422 }
423
f66e4f5f
RD
424 qmin= av_clip(qmin, 1, FF_LAMBDA_MAX);
425 qmax= av_clip(qmax, 1, FF_LAMBDA_MAX);
3aa102be 426
fa12b546 427 if(qmax<qmin) qmax= qmin;
115329f1 428
3aa102be
MN
429 *qmin_ret= qmin;
430 *qmax_ret= qmax;
431}
432
433static double modify_qscale(MpegEncContext *s, RateControlEntry *rce, double q, int frame_num){
434 RateControlContext *rcc= &s->rc_context;
435 int qmin, qmax;
3aa102be
MN
436 const int pict_type= rce->new_pict_type;
437 const double buffer_size= s->avctx->rc_buffer_size;
c0df9d75 438 const double fps= 1/av_q2d(s->avctx->time_base);
fb066639
MN
439 const double min_rate= s->avctx->rc_min_rate / fps;
440 const double max_rate= s->avctx->rc_max_rate / fps;
115329f1 441
3aa102be
MN
442 get_qminmax(&qmin, &qmax, s, pict_type);
443
444 /* modulation */
9701840b 445 if(s->avctx->rc_qmod_freq && frame_num%s->avctx->rc_qmod_freq==0 && pict_type==FF_P_TYPE)
3aa102be
MN
446 q*= s->avctx->rc_qmod_amp;
447
946c8a12 448//printf("q:%f\n", q);
3aa102be
MN
449 /* buffer overflow/underflow protection */
450 if(buffer_size){
6a1f7e7b 451 double expected_size= rcc->buffer_index;
d60a8f85 452 double q_limit;
3aa102be
MN
453
454 if(min_rate){
6a1f7e7b 455 double d= 2*(buffer_size - expected_size)/buffer_size;
3aa102be 456 if(d>1.0) d=1.0;
946c8a12
MN
457 else if(d<0.0001) d=0.0001;
458 q*= pow(d, 1.0/s->avctx->rc_buffer_aggressivity);
6a1f7e7b 459
3bff4d8b 460 q_limit= bits2qp(rce, FFMAX((min_rate - buffer_size + rcc->buffer_index) * s->avctx->rc_min_vbv_overflow_use, 1));
d60a8f85
MN
461 if(q > q_limit){
462 if(s->avctx->debug&FF_DEBUG_RC){
463 av_log(s->avctx, AV_LOG_DEBUG, "limiting QP %f -> %f\n", q, q_limit);
464 }
465 q= q_limit;
466 }
3aa102be
MN
467 }
468
469 if(max_rate){
470 double d= 2*expected_size/buffer_size;
471 if(d>1.0) d=1.0;
946c8a12
MN
472 else if(d<0.0001) d=0.0001;
473 q/= pow(d, 1.0/s->avctx->rc_buffer_aggressivity);
6a1f7e7b 474
3bff4d8b 475 q_limit= bits2qp(rce, FFMAX(rcc->buffer_index * s->avctx->rc_max_available_vbv_use, 1));
d60a8f85
MN
476 if(q < q_limit){
477 if(s->avctx->debug&FF_DEBUG_RC){
478 av_log(s->avctx, AV_LOG_DEBUG, "limiting QP %f -> %f\n", q, q_limit);
479 }
480 q= q_limit;
481 }
3aa102be
MN
482 }
483 }
946c8a12 484//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 485 if(s->avctx->rc_qsquish==0.0 || qmin==qmax){
3aa102be
MN
486 if (q<qmin) q=qmin;
487 else if(q>qmax) q=qmax;
488 }else{
489 double min2= log(qmin);
490 double max2= log(qmax);
115329f1 491
3aa102be
MN
492 q= log(q);
493 q= (q - min2)/(max2-min2) - 0.5;
494 q*= -4.0;
495 q= 1.0/(1.0 + exp(q));
496 q= q*(max2-min2) + min2;
115329f1 497
3aa102be
MN
498 q= exp(q);
499 }
115329f1 500
3aa102be
MN
501 return q;
502}
503
8b4c7dbc
MN
504//----------------------------------
505// 1 Pass Code
506
3aa102be 507static double predict_size(Predictor *p, double q, double var)
8b4c7dbc
MN
508{
509 return p->coeff*var / (q*p->count);
510}
511
ccfddafb 512/*
3aa102be
MN
513static double predict_qp(Predictor *p, double size, double var)
514{
515//printf("coeff:%f, count:%f, var:%f, size:%f//\n", p->coeff, p->count, var, size);
516 return p->coeff*var / (size*p->count);
517}
ccfddafb 518*/
3aa102be 519
8b4c7dbc
MN
520static void update_predictor(Predictor *p, double q, double var, double size)
521{
522 double new_coeff= size*q / (var + 1);
3aa102be 523 if(var<10) return;
8b4c7dbc
MN
524
525 p->count*= p->decay;
526 p->coeff*= p->decay;
527 p->count++;
528 p->coeff+= new_coeff;
529}
530
c5d309f2
MN
531static void adaptive_quantization(MpegEncContext *s, double q){
532 int i;
533 const float lumi_masking= s->avctx->lumi_masking / (128.0*128.0);
5e746b99 534 const float dark_masking= s->avctx->dark_masking / (128.0*128.0);
c5d309f2
MN
535 const float temp_cplx_masking= s->avctx->temporal_cplx_masking;
536 const float spatial_cplx_masking = s->avctx->spatial_cplx_masking;
537 const float p_masking = s->avctx->p_masking;
957c743a 538 const float border_masking = s->avctx->border_masking;
c5d309f2
MN
539 float bits_sum= 0.0;
540 float cplx_sum= 0.0;
541 float cplx_tab[s->mb_num];
542 float bits_tab[s->mb_num];
6e0d8c06
MN
543 const int qmin= s->avctx->mb_lmin;
544 const int qmax= s->avctx->mb_lmax;
1e491e29 545 Picture * const pic= &s->current_picture;
957c743a
CM
546 const int mb_width = s->mb_width;
547 const int mb_height = s->mb_height;
115329f1 548
c5d309f2 549 for(i=0; i<s->mb_num; i++){
2f5feea4 550 const int mb_xy= s->mb_index2xy[i];
158c7f05 551 float temp_cplx= sqrt(pic->mc_mb_var[mb_xy]); //FIXME merge in pow()
2f5feea4
MN
552 float spat_cplx= sqrt(pic->mb_var[mb_xy]);
553 const int lumi= pic->mb_mean[mb_xy];
c5d309f2 554 float bits, cplx, factor;
957c743a
CM
555 int mb_x = mb_xy % s->mb_stride;
556 int mb_y = mb_xy / s->mb_stride;
557 int mb_distance;
558 float mb_factor = 0.0;
115329f1 559#if 0
c5d309f2
MN
560 if(spat_cplx < q/3) spat_cplx= q/3; //FIXME finetune
561 if(temp_cplx < q/3) temp_cplx= q/3; //FIXME finetune
115329f1 562#endif
158c7f05
MN
563 if(spat_cplx < 4) spat_cplx= 4; //FIXME finetune
564 if(temp_cplx < 4) temp_cplx= 4; //FIXME finetune
565
115329f1 566 if((s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTRA)){//FIXME hq mode
c5d309f2
MN
567 cplx= spat_cplx;
568 factor= 1.0 + p_masking;
569 }else{
570 cplx= temp_cplx;
571 factor= pow(temp_cplx, - temp_cplx_masking);
572 }
573 factor*=pow(spat_cplx, - spatial_cplx_masking);
5e746b99
MN
574
575 if(lumi>127)
576 factor*= (1.0 - (lumi-128)*(lumi-128)*lumi_masking);
577 else
578 factor*= (1.0 - (lumi-128)*(lumi-128)*dark_masking);
957c743a
CM
579
580 if(mb_x < mb_width/5){
581 mb_distance = mb_width/5 - mb_x;
582 mb_factor = (float)mb_distance / (float)(mb_width/5);
583 }else if(mb_x > 4*mb_width/5){
584 mb_distance = mb_x - 4*mb_width/5;
585 mb_factor = (float)mb_distance / (float)(mb_width/5);
586 }
587 if(mb_y < mb_height/5){
588 mb_distance = mb_height/5 - mb_y;
589 mb_factor = FFMAX(mb_factor, (float)mb_distance / (float)(mb_height/5));
590 }else if(mb_y > 4*mb_height/5){
591 mb_distance = mb_y - 4*mb_height/5;
592 mb_factor = FFMAX(mb_factor, (float)mb_distance / (float)(mb_height/5));
593 }
594
595 factor*= 1.0 - border_masking*mb_factor;
115329f1 596
c5d309f2 597 if(factor<0.00001) factor= 0.00001;
115329f1 598
c5d309f2
MN
599 bits= cplx*factor;
600 cplx_sum+= cplx;
601 bits_sum+= bits;
602 cplx_tab[i]= cplx;
603 bits_tab[i]= bits;
604 }
605
755bfeab 606 /* handle qmin/qmax clipping */
c5d309f2 607 if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
e9a4834a 608 float factor= bits_sum/cplx_sum;
c5d309f2
MN
609 for(i=0; i<s->mb_num; i++){
610 float newq= q*cplx_tab[i]/bits_tab[i];
e9a4834a 611 newq*= factor;
c5d309f2
MN
612
613 if (newq > qmax){
614 bits_sum -= bits_tab[i];
615 cplx_sum -= cplx_tab[i]*q/qmax;
616 }
617 else if(newq < qmin){
618 bits_sum -= bits_tab[i];
619 cplx_sum -= cplx_tab[i]*q/qmin;
620 }
621 }
e9a4834a
MN
622 if(bits_sum < 0.001) bits_sum= 0.001;
623 if(cplx_sum < 0.001) cplx_sum= 0.001;
c5d309f2 624 }
115329f1 625
c5d309f2 626 for(i=0; i<s->mb_num; i++){
2f5feea4 627 const int mb_xy= s->mb_index2xy[i];
c5d309f2
MN
628 float newq= q*cplx_tab[i]/bits_tab[i];
629 int intq;
630
631 if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
632 newq*= bits_sum/cplx_sum;
633 }
634
158c7f05 635 intq= (int)(newq + 0.5);
c5d309f2
MN
636
637 if (intq > qmax) intq= qmax;
638 else if(intq < qmin) intq= qmin;
639//if(i%s->mb_width==0) printf("\n");
640//printf("%2d%3d ", intq, ff_sqrt(s->mc_mb_var[i]));
158c7f05 641 s->lambda_table[mb_xy]= intq;
c5d309f2
MN
642 }
643}
82b019ce
MN
644
645void ff_get_2pass_fcode(MpegEncContext *s){
646 RateControlContext *rcc= &s->rc_context;
647 int picture_number= s->picture_number;
648 RateControlEntry *rce;
649
650 rce= &rcc->entry[picture_number];
651 s->f_code= rce->f_code;
652 s->b_code= rce->b_code;
653}
654
158c7f05 655//FIXME rd or at least approx for dquant
c5d309f2 656
8ed9f9ab 657float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
8b4c7dbc 658{
8b4c7dbc 659 float q;
c5d309f2 660 int qmin, qmax;
8b4c7dbc
MN
661 float br_compensation;
662 double diff;
663 double short_term_q;
8b4c7dbc 664 double fps;
3aa102be 665 int picture_number= s->picture_number;
8b4c7dbc 666 int64_t wanted_bits;
3aa102be 667 RateControlContext *rcc= &s->rc_context;
d55f7b65 668 AVCodecContext *a= s->avctx;
3aa102be
MN
669 RateControlEntry local_rce, *rce;
670 double bits;
671 double rate_factor;
672 int var;
673 const int pict_type= s->pict_type;
1e491e29 674 Picture * const pic= &s->current_picture;
8b4c7dbc
MN
675 emms_c();
676
b250f9c6 677#if CONFIG_LIBXVID
64b7c5b6
MN
678 if((s->flags&CODEC_FLAG_PASS2) && s->avctx->rc_strategy == FF_RC_STRATEGY_XVID)
679 return ff_xvid_rate_estimate_qscale(s, dry_run);
19531051 680#endif
64b7c5b6 681
3aa102be 682 get_qminmax(&qmin, &qmax, s, pict_type);
8b4c7dbc 683
c0df9d75 684 fps= 1/av_q2d(s->avctx->time_base);
946c8a12 685//printf("input_pic_num:%d pic_num:%d frame_rate:%d\n", s->input_picture_number, s->picture_number, s->frame_rate);
8b4c7dbc 686 /* update predictors */
8ed9f9ab 687 if(picture_number>2 && !dry_run){
9701840b 688 const int last_var= s->last_pict_type == FF_I_TYPE ? rcc->last_mb_var_sum : rcc->last_mc_mb_var_sum;
3aa102be 689 update_predictor(&rcc->pred[s->last_pict_type], rcc->last_qscale, sqrt(last_var), s->frame_bits);
8b4c7dbc
MN
690 }
691
3aa102be
MN
692 if(s->flags&CODEC_FLAG_PASS2){
693 assert(picture_number>=0);
694 assert(picture_number<rcc->num_entries);
695 rce= &rcc->entry[picture_number];
696 wanted_bits= rce->expected_bits;
697 }else{
f6128014 698 Picture *dts_pic;
3aa102be 699 rce= &local_rce;
f6128014
MN
700
701 //FIXME add a dts field to AVFrame and ensure its set and use it here instead of reordering
702 //but the reordering is simpler for now until h.264 b pyramid must be handeld
9701840b 703 if(s->pict_type == FF_B_TYPE || s->low_delay)
f6128014
MN
704 dts_pic= s->current_picture_ptr;
705 else
706 dts_pic= s->last_picture_ptr;
707
708//if(dts_pic)
709// 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);
710
711 if(!dts_pic || dts_pic->pts == AV_NOPTS_VALUE)
712 wanted_bits= (uint64_t)(s->bit_rate*(double)picture_number/fps);
713 else
714 wanted_bits= (uint64_t)(s->bit_rate*(double)dts_pic->pts/fps);
3aa102be 715 }
8b4c7dbc 716
3aa102be 717 diff= s->total_bits - wanted_bits;
d55f7b65 718 br_compensation= (a->bit_rate_tolerance - diff)/a->bit_rate_tolerance;
3aa102be
MN
719 if(br_compensation<=0.0) br_compensation=0.001;
720
9701840b 721 var= pict_type == FF_I_TYPE ? pic->mb_var_sum : pic->mc_mb_var_sum;
115329f1 722
b1609412 723 short_term_q = 0; /* avoid warning */
3aa102be 724 if(s->flags&CODEC_FLAG_PASS2){
9701840b 725 if(pict_type!=FF_I_TYPE)
3aa102be
MN
726 assert(pict_type == rce->new_pict_type);
727
728 q= rce->new_qscale / br_compensation;
729//printf("%f %f %f last:%d var:%d type:%d//\n", q, rce->new_qscale, br_compensation, s->frame_bits, var, pict_type);
730 }else{
115329f1 731 rce->pict_type=
3aa102be 732 rce->new_pict_type= pict_type;
1e491e29
MN
733 rce->mc_mb_var_sum= pic->mc_mb_var_sum;
734 rce->mb_var_sum = pic-> mb_var_sum;
158c7f05 735 rce->qscale = FF_QP2LAMBDA * 2;
3aa102be
MN
736 rce->f_code = s->f_code;
737 rce->b_code = s->b_code;
738 rce->misc_bits= 1;
739
3aa102be 740 bits= predict_size(&rcc->pred[pict_type], rce->qscale, sqrt(var));
9701840b 741 if(pict_type== FF_I_TYPE){
3aa102be
MN
742 rce->i_count = s->mb_num;
743 rce->i_tex_bits= bits;
744 rce->p_tex_bits= 0;
745 rce->mv_bits= 0;
746 }else{
747 rce->i_count = 0; //FIXME we do know this approx
748 rce->i_tex_bits= 0;
749 rce->p_tex_bits= bits*0.9;
115329f1 750
3aa102be 751 rce->mv_bits= bits*0.1;
8b4c7dbc 752 }
3aa102be
MN
753 rcc->i_cplx_sum [pict_type] += rce->i_tex_bits*rce->qscale;
754 rcc->p_cplx_sum [pict_type] += rce->p_tex_bits*rce->qscale;
755 rcc->mv_bits_sum[pict_type] += rce->mv_bits;
756 rcc->frame_count[pict_type] ++;
8b4c7dbc 757
3aa102be 758 bits= rce->i_tex_bits + rce->p_tex_bits;
23e54f69 759 rate_factor= rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum * br_compensation;
115329f1 760
3aa102be 761 q= get_qscale(s, rce, rate_factor, picture_number);
4156a436
PI
762 if (q < 0)
763 return -1;
8b4c7dbc 764
c695ca3b 765 assert(q>0.0);
3aa102be 766//printf("%f ", q);
6a1f7e7b 767 q= get_diff_limited_q(s, rce, q);
3aa102be
MN
768//printf("%f ", q);
769 assert(q>0.0);
770
9701840b 771 if(pict_type==FF_P_TYPE || s->intra_only){ //FIXME type dependent blur like in 2-pass
d55f7b65
MN
772 rcc->short_term_qsum*=a->qblur;
773 rcc->short_term_qcount*=a->qblur;
3aa102be
MN
774
775 rcc->short_term_qsum+= q;
776 rcc->short_term_qcount++;
777//printf("%f ", q);
778 q= short_term_q= rcc->short_term_qsum/rcc->short_term_qcount;
779//printf("%f ", q);
780 }
946c8a12 781 assert(q>0.0);
115329f1 782
3aa102be
MN
783 q= modify_qscale(s, rce, q, picture_number);
784
785 rcc->pass1_wanted_bits+= s->bit_rate/fps;
786
c695ca3b 787 assert(q>0.0);
8b4c7dbc 788 }
59b571c1
MN
789
790 if(s->avctx->debug&FF_DEBUG_RC){
9b879566 791 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 792 av_get_pict_type_char(pict_type), qmin, q, qmax, picture_number, (int)wanted_bits/1000, (int)s->total_bits/1000,
59b571c1
MN
793 br_compensation, short_term_q, s->frame_bits, pic->mb_var_sum, pic->mc_mb_var_sum, s->bit_rate/1000, (int)fps
794 );
795 }
3aa102be 796
115329f1 797 if (q<qmin) q=qmin;
3aa102be 798 else if(q>qmax) q=qmax;
3aa102be 799
c5d309f2
MN
800 if(s->adaptive_quant)
801 adaptive_quantization(s, q);
802 else
803 q= (int)(q + 0.5);
115329f1 804
8ed9f9ab
MN
805 if(!dry_run){
806 rcc->last_qscale= q;
807 rcc->last_mc_mb_var_sum= pic->mc_mb_var_sum;
808 rcc->last_mb_var_sum= pic->mb_var_sum;
809 }
1e491e29
MN
810#if 0
811{
812 static int mvsum=0, texsum=0;
813 mvsum += s->mv_bits;
814 texsum += s->i_tex_bits + s->p_tex_bits;
815 printf("%d %d//\n\n", mvsum, texsum);
816}
817#endif
c5d309f2 818 return q;
8b4c7dbc
MN
819}
820
821//----------------------------------------------
822// 2-Pass code
823
824static int init_pass2(MpegEncContext *s)
825{
826 RateControlContext *rcc= &s->rc_context;
d55f7b65 827 AVCodecContext *a= s->avctx;
577cd173 828 int i, toobig;
c0df9d75 829 double fps= 1/av_q2d(s->avctx->time_base);
8b4c7dbc 830 double complexity[5]={0,0,0,0,0}; // aproximate bits at quant=1
eafcac6a 831 uint64_t const_bits[5]={0,0,0,0,0}; // quantizer independent bits
8b4c7dbc
MN
832 uint64_t all_const_bits;
833 uint64_t all_available_bits= (uint64_t)(s->bit_rate*(double)rcc->num_entries/fps);
8b4c7dbc
MN
834 double rate_factor=0;
835 double step;
ccfddafb 836 //int last_i_frame=-10000000;
115329f1 837 const int filter_size= (int)(a->qblur*4) | 1;
3aa102be 838 double expected_bits;
170c0b45 839 double *qscale, *blurred_qscale, qscale_sum;
8b4c7dbc
MN
840
841 /* find complexity & const_bits & decide the pict_types */
842 for(i=0; i<rcc->num_entries; i++){
843 RateControlEntry *rce= &rcc->entry[i];
115329f1 844
0d1e9246 845 rce->new_pict_type= rce->pict_type;
3aa102be
MN
846 rcc->i_cplx_sum [rce->pict_type] += rce->i_tex_bits*rce->qscale;
847 rcc->p_cplx_sum [rce->pict_type] += rce->p_tex_bits*rce->qscale;
848 rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits;
849 rcc->frame_count[rce->pict_type] ++;
8b4c7dbc
MN
850
851 complexity[rce->new_pict_type]+= (rce->i_tex_bits+ rce->p_tex_bits)*(double)rce->qscale;
852 const_bits[rce->new_pict_type]+= rce->mv_bits + rce->misc_bits;
8b4c7dbc 853 }
9701840b 854 all_const_bits= const_bits[FF_I_TYPE] + const_bits[FF_P_TYPE] + const_bits[FF_B_TYPE];
115329f1 855
8b4c7dbc 856 if(all_available_bits < all_const_bits){
29b372b9 857 av_log(s->avctx, AV_LOG_ERROR, "requested bitrate is too low\n");
8b4c7dbc
MN
858 return -1;
859 }
115329f1 860
8e1e6f31 861 qscale= av_malloc(sizeof(double)*rcc->num_entries);
170c0b45 862 blurred_qscale= av_malloc(sizeof(double)*rcc->num_entries);
577cd173 863 toobig = 0;
3aa102be 864
8b4c7dbc 865 for(step=256*256; step>0.0000001; step*=0.5){
3aa102be 866 expected_bits=0;
8b4c7dbc 867 rate_factor+= step;
115329f1 868
3aa102be
MN
869 rcc->buffer_index= s->avctx->rc_buffer_size/2;
870
8b4c7dbc
MN
871 /* find qscale */
872 for(i=0; i<rcc->num_entries; i++){
3aa102be
MN
873 qscale[i]= get_qscale(s, &rcc->entry[i], rate_factor, i);
874 }
875 assert(filter_size%2==1);
876
877 /* fixed I/B QP relative to P mode */
3aa102be 878 for(i=rcc->num_entries-1; i>=0; i--){
8b4c7dbc 879 RateControlEntry *rce= &rcc->entry[i];
115329f1 880
6a1f7e7b 881 qscale[i]= get_diff_limited_q(s, rce, qscale[i]);
3aa102be 882 }
8b4c7dbc 883
3aa102be
MN
884 /* smooth curve */
885 for(i=0; i<rcc->num_entries; i++){
886 RateControlEntry *rce= &rcc->entry[i];
887 const int pict_type= rce->new_pict_type;
888 int j;
889 double q=0.0, sum=0.0;
115329f1 890
3aa102be
MN
891 for(j=0; j<filter_size; j++){
892 int index= i+j-filter_size/2;
893 double d= index-i;
d55f7b65 894 double coeff= a->qblur==0 ? 1.0 : exp(-d*d/(a->qblur * a->qblur));
115329f1 895
3aa102be
MN
896 if(index < 0 || index >= rcc->num_entries) continue;
897 if(pict_type != rcc->entry[index].new_pict_type) continue;
898 q+= qscale[index] * coeff;
899 sum+= coeff;
8b4c7dbc 900 }
170c0b45 901 blurred_qscale[i]= q/sum;
8b4c7dbc 902 }
115329f1 903
8b4c7dbc
MN
904 /* find expected bits */
905 for(i=0; i<rcc->num_entries; i++){
906 RateControlEntry *rce= &rcc->entry[i];
3aa102be 907 double bits;
170c0b45 908 rce->new_qscale= modify_qscale(s, rce, blurred_qscale[i], i);
405469ce 909 bits= qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;
170c0b45 910//printf("%d %f\n", rce->new_bits, blurred_qscale[i]);
11dffbe1 911 bits += 8*ff_vbv_update(s, bits);
3aa102be 912
8b4c7dbc 913 rce->expected_bits= expected_bits;
3aa102be 914 expected_bits += bits;
8b4c7dbc
MN
915 }
916
577cd173
CH
917 /*
918 av_log(s->avctx, AV_LOG_INFO,
919 "expected_bits: %f all_available_bits: %d rate_factor: %f\n",
920 expected_bits, (int)all_available_bits, rate_factor);
921 */
922 if(expected_bits > all_available_bits) {
923 rate_factor-= step;
924 ++toobig;
925 }
8b4c7dbc 926 }
8e1e6f31 927 av_free(qscale);
170c0b45 928 av_free(blurred_qscale);
8b4c7dbc 929
577cd173
CH
930 /* check bitrate calculations and print info */
931 qscale_sum = 0.0;
932 for(i=0; i<rcc->num_entries; i++){
933 /* av_log(s->avctx, AV_LOG_DEBUG, "[lavc rc] entry[%d].new_qscale = %.3f qp = %.3f\n",
934 i, rcc->entry[i].new_qscale, rcc->entry[i].new_qscale / FF_QP2LAMBDA); */
f66e4f5f 935 qscale_sum += av_clip(rcc->entry[i].new_qscale / FF_QP2LAMBDA, s->avctx->qmin, s->avctx->qmax);
577cd173
CH
936 }
937 assert(toobig <= 40);
938 av_log(s->avctx, AV_LOG_DEBUG,
939 "[lavc rc] requested bitrate: %d bps expected bitrate: %d bps\n",
940 s->bit_rate,
941 (int)(expected_bits / ((double)all_available_bits/s->bit_rate)));
942 av_log(s->avctx, AV_LOG_DEBUG,
943 "[lavc rc] estimated target average qp: %.3f\n",
944 (float)qscale_sum / rcc->num_entries);
945 if (toobig == 0) {
946 av_log(s->avctx, AV_LOG_INFO,
947 "[lavc rc] Using all of requested bitrate is not "
948 "necessary for this video with these parameters.\n");
949 } else if (toobig == 40) {
950 av_log(s->avctx, AV_LOG_ERROR,
951 "[lavc rc] Error: bitrate too low for this video "
952 "with these parameters.\n");
953 return -1;
954 } else if (fabs(expected_bits/all_available_bits - 1.0) > 0.01) {
955 av_log(s->avctx, AV_LOG_ERROR,
956 "[lavc rc] Error: 2pass curve failed to converge\n");
3aa102be 957 return -1;
8b4c7dbc 958 }
8b4c7dbc 959
3aa102be 960 return 0;
8b4c7dbc 961}