Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ratecontrol.c @ 08f7073a

History | View | Annotate | Download (28.7 KB)

1 8b4c7dbc Michael Niedermayer
/*
2 2ef0f2b2 Fabrice Bellard
 * Rate control for video encoders
3
 *
4 8f2ab833 Michael Niedermayer
 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5 2ef0f2b2 Fabrice Bellard
 *
6
 * This library is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU Lesser General Public
8
 * License as published by the Free Software Foundation; either
9
 * version 2 of the License, or (at your option) any later version.
10
 *
11
 * This library is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with this library; if not, write to the Free Software
18
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19
 */
20 983e3246 Michael Niedermayer
21
/**
22
 * @file ratecontrol.c
23
 * Rate control for video encoders.
24
 */ 
25
26 8b4c7dbc Michael Niedermayer
#include "avcodec.h"
27 2ef0f2b2 Fabrice Bellard
#include "dsputil.h"
28 8b4c7dbc Michael Niedermayer
#include "mpegvideo.h"
29
30 3aa102be Michael Niedermayer
#undef NDEBUG // allways check asserts, the speed effect is far too small to disable them
31
#include <assert.h>
32 8b4c7dbc Michael Niedermayer
33 471d7dc3 Michael Niedermayer
#ifndef M_E
34
#define M_E 2.718281828
35
#endif
36
37 8b4c7dbc Michael Niedermayer
static int init_pass2(MpegEncContext *s);
38 3aa102be Michael Niedermayer
static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_factor, int frame_num);
39 8b4c7dbc Michael Niedermayer
40
void ff_write_pass1_stats(MpegEncContext *s){
41 158c7f05 Michael Niedermayer
    sprintf(s->avctx->stats_out, "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;\n",
42 1031fabd Michael Niedermayer
            s->current_picture_ptr->display_picture_number, s->current_picture_ptr->coded_picture_number, s->pict_type, 
43 158c7f05 Michael Niedermayer
            s->current_picture.quality, s->i_tex_bits, s->p_tex_bits, s->mv_bits, s->misc_bits, 
44 1e491e29 Michael Niedermayer
            s->f_code, s->b_code, s->current_picture.mc_mb_var_sum, s->current_picture.mb_var_sum, s->i_count);
45 8b4c7dbc Michael Niedermayer
}
46
47
int ff_rate_control_init(MpegEncContext *s)
48
{
49
    RateControlContext *rcc= &s->rc_context;
50 3aa102be Michael Niedermayer
    int i;
51 8b4c7dbc Michael Niedermayer
    emms_c();
52
53 3aa102be Michael Niedermayer
    for(i=0; i<5; i++){
54 158c7f05 Michael Niedermayer
        rcc->pred[i].coeff= FF_QP2LAMBDA * 7.0;
55 3aa102be Michael Niedermayer
        rcc->pred[i].count= 1.0;
56
    
57
        rcc->pred[i].decay= 0.4;
58
        rcc->i_cplx_sum [i]=
59
        rcc->p_cplx_sum [i]=
60
        rcc->mv_bits_sum[i]=
61
        rcc->qscale_sum [i]=
62
        rcc->frame_count[i]= 1; // 1 is better cuz of 1/0 and such
63 158c7f05 Michael Niedermayer
        rcc->last_qscale_for[i]=FF_QP2LAMBDA * 5;
64 3aa102be Michael Niedermayer
    }
65 fb066639 Michael Niedermayer
    rcc->buffer_index= s->avctx->rc_initial_buffer_occupancy;
66 3aa102be Michael Niedermayer
67
    if(s->flags&CODEC_FLAG_PASS2){
68 8b4c7dbc Michael Niedermayer
        int i;
69 3aa102be Michael Niedermayer
        char *p;
70 8b4c7dbc Michael Niedermayer
71 3aa102be Michael Niedermayer
        /* find number of pics */
72
        p= s->avctx->stats_in;
73
        for(i=-1; p; i++){
74
            p= strchr(p+1, ';');
75 8b4c7dbc Michael Niedermayer
        }
76 3aa102be Michael Niedermayer
        i+= s->max_b_frames;
77
        rcc->entry = (RateControlEntry*)av_mallocz(i*sizeof(RateControlEntry));
78
        rcc->num_entries= i;
79
        
80
        /* init all to skiped p frames (with b frames we might have a not encoded frame at the end FIXME) */
81
        for(i=0; i<rcc->num_entries; i++){
82
            RateControlEntry *rce= &rcc->entry[i];
83
            rce->pict_type= rce->new_pict_type=P_TYPE;
84 158c7f05 Michael Niedermayer
            rce->qscale= rce->new_qscale=FF_QP2LAMBDA * 2;
85 3aa102be Michael Niedermayer
            rce->misc_bits= s->mb_num + 10;
86
            rce->mb_var_sum= s->mb_num*100;
87
        }        
88
        
89
        /* read stats */
90
        p= s->avctx->stats_in;
91
        for(i=0; i<rcc->num_entries - s->max_b_frames; i++){
92 8b4c7dbc Michael Niedermayer
            RateControlEntry *rce;
93
            int picture_number;
94
            int e;
95 3aa102be Michael Niedermayer
            char *next;
96
97
            next= strchr(p, ';');
98
            if(next){
99
                (*next)=0; //sscanf in unbelieavle slow on looong strings //FIXME copy / dont write
100
                next++;
101
            }
102
            e= sscanf(p, " in:%d ", &picture_number);
103
104
            assert(picture_number >= 0);
105
            assert(picture_number < rcc->num_entries);
106 8b4c7dbc Michael Niedermayer
            rce= &rcc->entry[picture_number];
107 3aa102be Michael Niedermayer
108 c5d309f2 Michael Niedermayer
            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",
109 3aa102be Michael Niedermayer
                   &rce->pict_type, &rce->qscale, &rce->i_tex_bits, &rce->p_tex_bits, &rce->mv_bits, &rce->misc_bits, 
110
                   &rce->f_code, &rce->b_code, &rce->mc_mb_var_sum, &rce->mb_var_sum, &rce->i_count);
111
            if(e!=12){
112 9b879566 Michel Bardiaux
                av_log(s->avctx, AV_LOG_ERROR, "statistics are damaged at line %d, parser out=%d\n", i, e);
113 8b4c7dbc Michael Niedermayer
                return -1;
114
            }
115 3aa102be Michael Niedermayer
            p= next;
116 8b4c7dbc Michael Niedermayer
        }
117
        
118
        if(init_pass2(s) < 0) return -1;
119
    }
120
     
121 3aa102be Michael Niedermayer
    if(!(s->flags&CODEC_FLAG_PASS2)){
122
123
        rcc->short_term_qsum=0.001;
124
        rcc->short_term_qcount=0.001;
125 8b4c7dbc Michael Niedermayer
    
126 23e54f69 Michael Niedermayer
        rcc->pass1_rc_eq_output_sum= 0.001;
127 3aa102be Michael Niedermayer
        rcc->pass1_wanted_bits=0.001;
128
        
129
        /* init stuff with the user specified complexity */
130
        if(s->avctx->rc_initial_cplx){
131
            for(i=0; i<60*30; i++){
132
                double bits= s->avctx->rc_initial_cplx * (i/10000.0 + 1.0)*s->mb_num;
133
                RateControlEntry rce;
134
                double q;
135
                
136
                if     (i%((s->gop_size+3)/4)==0) rce.pict_type= I_TYPE;
137
                else if(i%(s->max_b_frames+1))    rce.pict_type= B_TYPE;
138
                else                              rce.pict_type= P_TYPE;
139
140
                rce.new_pict_type= rce.pict_type;
141
                rce.mc_mb_var_sum= bits*s->mb_num/100000;
142
                rce.mb_var_sum   = s->mb_num;
143 158c7f05 Michael Niedermayer
                rce.qscale   = FF_QP2LAMBDA * 2;
144 3aa102be Michael Niedermayer
                rce.f_code   = 2;
145
                rce.b_code   = 1;
146
                rce.misc_bits= 1;
147
148
                if(s->pict_type== I_TYPE){
149
                    rce.i_count   = s->mb_num;
150
                    rce.i_tex_bits= bits;
151
                    rce.p_tex_bits= 0;
152
                    rce.mv_bits= 0;
153
                }else{
154
                    rce.i_count   = 0; //FIXME we do know this approx
155
                    rce.i_tex_bits= 0;
156
                    rce.p_tex_bits= bits*0.9;
157
                    rce.mv_bits= bits*0.1;
158
                }
159
                rcc->i_cplx_sum [rce.pict_type] += rce.i_tex_bits*rce.qscale;
160
                rcc->p_cplx_sum [rce.pict_type] += rce.p_tex_bits*rce.qscale;
161
                rcc->mv_bits_sum[rce.pict_type] += rce.mv_bits;
162
                rcc->frame_count[rce.pict_type] ++;
163 8b4c7dbc Michael Niedermayer
164 3aa102be Michael Niedermayer
                bits= rce.i_tex_bits + rce.p_tex_bits;
165 8b4c7dbc Michael Niedermayer
166 23e54f69 Michael Niedermayer
                q= get_qscale(s, &rce, rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum, i);
167 14bea432 Michael Niedermayer
                rcc->pass1_wanted_bits+= s->bit_rate/(s->avctx->frame_rate / (double)s->avctx->frame_rate_base);
168 3aa102be Michael Niedermayer
            }
169
        }
170
171
    }
172
    
173 8b4c7dbc Michael Niedermayer
    return 0;
174
}
175
176
void ff_rate_control_uninit(MpegEncContext *s)
177
{
178
    RateControlContext *rcc= &s->rc_context;
179
    emms_c();
180
181 6000abfa Fabrice Bellard
    av_freep(&rcc->entry);
182 8b4c7dbc Michael Niedermayer
}
183
184 3aa102be Michael Niedermayer
static inline double qp2bits(RateControlEntry *rce, double qp){
185
    if(qp<=0.0){
186 9b879566 Michel Bardiaux
        av_log(NULL, AV_LOG_ERROR, "qp<=0.0\n");
187 3aa102be Michael Niedermayer
    }
188
    return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits+1)/ qp;
189
}
190
191
static inline double bits2qp(RateControlEntry *rce, double bits){
192
    if(bits<0.9){
193 9b879566 Michel Bardiaux
        av_log(NULL, AV_LOG_ERROR, "bits<0.9\n");
194 3aa102be Michael Niedermayer
    }
195
    return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits+1)/ bits;
196
}
197
    
198 11dffbe1 Michael Niedermayer
int ff_vbv_update(MpegEncContext *s, int frame_size){
199 3aa102be Michael Niedermayer
    RateControlContext *rcc= &s->rc_context;
200 14bea432 Michael Niedermayer
    const double fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base;
201 d60a8f85 Michael Niedermayer
    const int buffer_size= s->avctx->rc_buffer_size;
202 3aa102be Michael Niedermayer
    const double min_rate= s->avctx->rc_min_rate/fps;
203
    const double max_rate= s->avctx->rc_max_rate/fps;
204 d60a8f85 Michael Niedermayer
    
205
//printf("%d %f %d %f %f\n", buffer_size, rcc->buffer_index, frame_size, min_rate, max_rate);
206 3aa102be Michael Niedermayer
    if(buffer_size){
207 fb066639 Michael Niedermayer
        int left;
208
209 3aa102be Michael Niedermayer
        rcc->buffer_index-= frame_size;
210 fb066639 Michael Niedermayer
        if(rcc->buffer_index < 0){
211 9b879566 Michel Bardiaux
            av_log(s->avctx, AV_LOG_ERROR, "rc buffer underflow\n");
212 fb066639 Michael Niedermayer
            rcc->buffer_index= 0;
213
        }
214
215
        left= buffer_size - rcc->buffer_index - 1;
216
        rcc->buffer_index += clip(left, min_rate, max_rate);
217
218 d60a8f85 Michael Niedermayer
        if(rcc->buffer_index > buffer_size){
219
            int stuffing= ceil((rcc->buffer_index - buffer_size)/8);
220 11dffbe1 Michael Niedermayer
            
221
            if(stuffing < 4 && s->codec_id == CODEC_ID_MPEG4)
222
                stuffing=4;
223
            rcc->buffer_index -= 8*stuffing;
224
            
225
            if(s->avctx->debug & FF_DEBUG_RC)
226
                av_log(s->avctx, AV_LOG_DEBUG, "stuffing %d bytes\n", stuffing);
227
228
            return stuffing;
229 fb066639 Michael Niedermayer
        }
230 3aa102be Michael Niedermayer
    }
231 11dffbe1 Michael Niedermayer
    return 0;
232 3aa102be Michael Niedermayer
}
233
234
/**
235
 * modifies the bitrate curve from pass1 for one frame
236
 */
237
static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_factor, int frame_num){
238
    RateControlContext *rcc= &s->rc_context;
239 d55f7b65 Michael Niedermayer
    AVCodecContext *a= s->avctx;
240 3aa102be Michael Niedermayer
    double q, bits;
241
    const int pict_type= rce->new_pict_type;
242
    const double mb_num= s->mb_num;  
243
    int i;
244
245
    double const_values[]={
246
        M_PI,
247
        M_E,
248
        rce->i_tex_bits*rce->qscale,
249
        rce->p_tex_bits*rce->qscale,
250
        (rce->i_tex_bits + rce->p_tex_bits)*(double)rce->qscale,
251
        rce->mv_bits/mb_num,
252
        rce->pict_type == B_TYPE ? (rce->f_code + rce->b_code)*0.5 : rce->f_code,
253
        rce->i_count/mb_num,
254
        rce->mc_mb_var_sum/mb_num,
255
        rce->mb_var_sum/mb_num,
256
        rce->pict_type == I_TYPE,
257
        rce->pict_type == P_TYPE,
258
        rce->pict_type == B_TYPE,
259
        rcc->qscale_sum[pict_type] / (double)rcc->frame_count[pict_type],
260 d55f7b65 Michael Niedermayer
        a->qcompress,
261 3aa102be Michael Niedermayer
/*        rcc->last_qscale_for[I_TYPE],
262
        rcc->last_qscale_for[P_TYPE],
263
        rcc->last_qscale_for[B_TYPE],
264
        rcc->next_non_b_qscale,*/
265
        rcc->i_cplx_sum[I_TYPE] / (double)rcc->frame_count[I_TYPE],
266
        rcc->i_cplx_sum[P_TYPE] / (double)rcc->frame_count[P_TYPE],
267
        rcc->p_cplx_sum[P_TYPE] / (double)rcc->frame_count[P_TYPE],
268
        rcc->p_cplx_sum[B_TYPE] / (double)rcc->frame_count[B_TYPE],
269
        (rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / (double)rcc->frame_count[pict_type],
270
        0
271
    };
272 5c91a675 Zdenek Kabelac
    static const char *const_names[]={
273 3aa102be Michael Niedermayer
        "PI",
274
        "E",
275
        "iTex",
276
        "pTex",
277
        "tex",
278
        "mv",
279
        "fCode",
280
        "iCount",
281
        "mcVar",
282
        "var",
283
        "isI",
284
        "isP",
285
        "isB",
286
        "avgQP",
287
        "qComp",
288
/*        "lastIQP",
289
        "lastPQP",
290
        "lastBQP",
291
        "nextNonBQP",*/
292
        "avgIITex",
293
        "avgPITex",
294
        "avgPPTex",
295
        "avgBPTex",
296
        "avgTex",
297
        NULL
298
    };
299 07787186 Dominik Mierzejewski
    static double (*func1[])(void *, double)={
300 ec6a3752 Fabrice Bellard
        (void *)bits2qp,
301
        (void *)qp2bits,
302 3aa102be Michael Niedermayer
        NULL
303
    };
304 5c91a675 Zdenek Kabelac
    static const char *func1_names[]={
305 3aa102be Michael Niedermayer
        "bits2qp",
306
        "qp2bits",
307
        NULL
308
    };
309
310
    bits= ff_eval(s->avctx->rc_eq, const_values, const_names, func1, func1_names, NULL, NULL, rce);
311
    
312 23e54f69 Michael Niedermayer
    rcc->pass1_rc_eq_output_sum+= bits;
313 3aa102be Michael Niedermayer
    bits*=rate_factor;
314
    if(bits<0.0) bits=0.0;
315
    bits+= 1.0; //avoid 1/0 issues
316
    
317
    /* user override */
318
    for(i=0; i<s->avctx->rc_override_count; i++){
319
        RcOverride *rco= s->avctx->rc_override;
320
        if(rco[i].start_frame > frame_num) continue;
321
        if(rco[i].end_frame   < frame_num) continue;
322
    
323
        if(rco[i].qscale) 
324
            bits= qp2bits(rce, rco[i].qscale); //FIXME move at end to really force it?
325
        else
326
            bits*= rco[i].quality_factor;
327
    }
328
329
    q= bits2qp(rce, bits);
330
    
331
    /* I/B difference */
332
    if     (pict_type==I_TYPE && s->avctx->i_quant_factor<0.0)
333
        q= -q*s->avctx->i_quant_factor + s->avctx->i_quant_offset;
334
    else if(pict_type==B_TYPE && s->avctx->b_quant_factor<0.0)
335
        q= -q*s->avctx->b_quant_factor + s->avctx->b_quant_offset;
336 6a1f7e7b Michael Niedermayer
        
337
    return q;
338
}
339
340
static double get_diff_limited_q(MpegEncContext *s, RateControlEntry *rce, double q){
341
    RateControlContext *rcc= &s->rc_context;
342
    AVCodecContext *a= s->avctx;
343
    const int pict_type= rce->new_pict_type;
344
    const double last_p_q    = rcc->last_qscale_for[P_TYPE];
345
    const double last_non_b_q= rcc->last_qscale_for[rcc->last_non_b_pict_type];
346 59b571c1 Michael Niedermayer
    
347 6a1f7e7b Michael Niedermayer
    if     (pict_type==I_TYPE && (a->i_quant_factor>0.0 || rcc->last_non_b_pict_type==P_TYPE))
348
        q= last_p_q    *ABS(a->i_quant_factor) + a->i_quant_offset;
349
    else if(pict_type==B_TYPE && a->b_quant_factor>0.0)
350
        q= last_non_b_q*    a->b_quant_factor  + a->b_quant_offset;
351
352 3aa102be Michael Niedermayer
    /* last qscale / qdiff stuff */
353 6a1f7e7b Michael Niedermayer
    if(rcc->last_non_b_pict_type==pict_type || pict_type!=I_TYPE){
354
        double last_q= rcc->last_qscale_for[pict_type];
355 158c7f05 Michael Niedermayer
        const int maxdiff= FF_QP2LAMBDA * a->max_qdiff;
356 59b571c1 Michael Niedermayer
357 158c7f05 Michael Niedermayer
        if     (q > last_q + maxdiff) q= last_q + maxdiff;
358
        else if(q < last_q - maxdiff) q= last_q - maxdiff;
359 6a1f7e7b Michael Niedermayer
    }
360 3aa102be Michael Niedermayer
361
    rcc->last_qscale_for[pict_type]= q; //Note we cant do that after blurring
362
    
363 6a1f7e7b Michael Niedermayer
    if(pict_type!=B_TYPE)
364
        rcc->last_non_b_pict_type= pict_type;
365
366 3aa102be Michael Niedermayer
    return q;
367
}
368
369
/**
370
 * gets the qmin & qmax for pict_type
371
 */
372
static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type){
373 158c7f05 Michael Niedermayer
    int qmin= s->avctx->lmin;                                                       
374
    int qmax= s->avctx->lmax;
375 fa12b546 Michael Niedermayer
    
376
    assert(qmin <= qmax);
377 3aa102be Michael Niedermayer
378
    if(pict_type==B_TYPE){
379
        qmin= (int)(qmin*ABS(s->avctx->b_quant_factor)+s->avctx->b_quant_offset + 0.5);
380
        qmax= (int)(qmax*ABS(s->avctx->b_quant_factor)+s->avctx->b_quant_offset + 0.5);
381
    }else if(pict_type==I_TYPE){
382
        qmin= (int)(qmin*ABS(s->avctx->i_quant_factor)+s->avctx->i_quant_offset + 0.5);
383
        qmax= (int)(qmax*ABS(s->avctx->i_quant_factor)+s->avctx->i_quant_offset + 0.5);
384
    }
385
386 158c7f05 Michael Niedermayer
    qmin= clip(qmin, 1, FF_LAMBDA_MAX);
387
    qmax= clip(qmax, 1, FF_LAMBDA_MAX);
388 3aa102be Michael Niedermayer
389 fa12b546 Michael Niedermayer
    if(qmax<qmin) qmax= qmin;
390 3aa102be Michael Niedermayer
    
391
    *qmin_ret= qmin;
392
    *qmax_ret= qmax;
393
}
394
395
static double modify_qscale(MpegEncContext *s, RateControlEntry *rce, double q, int frame_num){
396
    RateControlContext *rcc= &s->rc_context;
397
    int qmin, qmax;
398
    double bits;
399
    const int pict_type= rce->new_pict_type;
400
    const double buffer_size= s->avctx->rc_buffer_size;
401 fb066639 Michael Niedermayer
    const double fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base;
402
    const double min_rate= s->avctx->rc_min_rate / fps;
403
    const double max_rate= s->avctx->rc_max_rate / fps;
404 3aa102be Michael Niedermayer
    
405
    get_qminmax(&qmin, &qmax, s, pict_type);
406
407
    /* modulation */
408
    if(s->avctx->rc_qmod_freq && frame_num%s->avctx->rc_qmod_freq==0 && pict_type==P_TYPE)
409
        q*= s->avctx->rc_qmod_amp;
410
411
    bits= qp2bits(rce, q);
412 946c8a12 Michael Niedermayer
//printf("q:%f\n", q);
413 3aa102be Michael Niedermayer
    /* buffer overflow/underflow protection */
414
    if(buffer_size){
415 6a1f7e7b Michael Niedermayer
        double expected_size= rcc->buffer_index;
416 d60a8f85 Michael Niedermayer
        double q_limit;
417 3aa102be Michael Niedermayer
418
        if(min_rate){
419 6a1f7e7b Michael Niedermayer
            double d= 2*(buffer_size - expected_size)/buffer_size;
420 3aa102be Michael Niedermayer
            if(d>1.0) d=1.0;
421 946c8a12 Michael Niedermayer
            else if(d<0.0001) d=0.0001;
422
            q*= pow(d, 1.0/s->avctx->rc_buffer_aggressivity);
423 6a1f7e7b Michael Niedermayer
424 d60a8f85 Michael Niedermayer
            q_limit= bits2qp(rce, FFMAX((min_rate - buffer_size + rcc->buffer_index)*3, 1));
425
            if(q > q_limit){
426
                if(s->avctx->debug&FF_DEBUG_RC){
427
                    av_log(s->avctx, AV_LOG_DEBUG, "limiting QP %f -> %f\n", q, q_limit);
428
                }
429
                q= q_limit;
430
            }
431 3aa102be Michael Niedermayer
        }
432
433
        if(max_rate){
434
            double d= 2*expected_size/buffer_size;
435
            if(d>1.0) d=1.0;
436 946c8a12 Michael Niedermayer
            else if(d<0.0001) d=0.0001;
437
            q/= pow(d, 1.0/s->avctx->rc_buffer_aggressivity);
438 6a1f7e7b Michael Niedermayer
439 d60a8f85 Michael Niedermayer
            q_limit= bits2qp(rce, FFMAX(rcc->buffer_index/3, 1));
440
            if(q < q_limit){
441
                if(s->avctx->debug&FF_DEBUG_RC){
442
                    av_log(s->avctx, AV_LOG_DEBUG, "limiting QP %f -> %f\n", q, q_limit);
443
                }
444
                q= q_limit;
445
            }
446 3aa102be Michael Niedermayer
        }
447
    }
448 946c8a12 Michael Niedermayer
//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);
449 c695ca3b Michael Niedermayer
    if(s->avctx->rc_qsquish==0.0 || qmin==qmax){
450 3aa102be Michael Niedermayer
        if     (q<qmin) q=qmin;
451
        else if(q>qmax) q=qmax;
452
    }else{
453
        double min2= log(qmin);
454
        double max2= log(qmax);
455
        
456
        q= log(q);
457
        q= (q - min2)/(max2-min2) - 0.5;
458
        q*= -4.0;
459
        q= 1.0/(1.0 + exp(q));
460
        q= q*(max2-min2) + min2;
461
        
462
        q= exp(q);
463
    }
464 c5d309f2 Michael Niedermayer
    
465 3aa102be Michael Niedermayer
    return q;
466
}
467
468 8b4c7dbc Michael Niedermayer
//----------------------------------
469
// 1 Pass Code
470
471 3aa102be Michael Niedermayer
static double predict_size(Predictor *p, double q, double var)
472 8b4c7dbc Michael Niedermayer
{
473
     return p->coeff*var / (q*p->count);
474
}
475
476 ccfddafb bubu
/*
477 3aa102be Michael Niedermayer
static double predict_qp(Predictor *p, double size, double var)
478
{
479
//printf("coeff:%f, count:%f, var:%f, size:%f//\n", p->coeff, p->count, var, size);
480
     return p->coeff*var / (size*p->count);
481
}
482 ccfddafb bubu
*/
483 3aa102be Michael Niedermayer
484 8b4c7dbc Michael Niedermayer
static void update_predictor(Predictor *p, double q, double var, double size)
485
{
486
    double new_coeff= size*q / (var + 1);
487 3aa102be Michael Niedermayer
    if(var<10) return;
488 8b4c7dbc Michael Niedermayer
489
    p->count*= p->decay;
490
    p->coeff*= p->decay;
491
    p->count++;
492
    p->coeff+= new_coeff;
493
}
494
495 c5d309f2 Michael Niedermayer
static void adaptive_quantization(MpegEncContext *s, double q){
496
    int i;
497
    const float lumi_masking= s->avctx->lumi_masking / (128.0*128.0);
498 5e746b99 Michael Niedermayer
    const float dark_masking= s->avctx->dark_masking / (128.0*128.0);
499 c5d309f2 Michael Niedermayer
    const float temp_cplx_masking= s->avctx->temporal_cplx_masking;
500
    const float spatial_cplx_masking = s->avctx->spatial_cplx_masking;
501
    const float p_masking = s->avctx->p_masking;
502
    float bits_sum= 0.0;
503
    float cplx_sum= 0.0;
504
    float cplx_tab[s->mb_num];
505
    float bits_tab[s->mb_num];
506 158c7f05 Michael Niedermayer
    const int qmin= s->avctx->lmin;
507
    const int qmax= s->avctx->lmax;
508 1e491e29 Michael Niedermayer
    Picture * const pic= &s->current_picture;
509 c5d309f2 Michael Niedermayer
    
510
    for(i=0; i<s->mb_num; i++){
511 2f5feea4 Michael Niedermayer
        const int mb_xy= s->mb_index2xy[i];
512 158c7f05 Michael Niedermayer
        float temp_cplx= sqrt(pic->mc_mb_var[mb_xy]); //FIXME merge in pow()
513 2f5feea4 Michael Niedermayer
        float spat_cplx= sqrt(pic->mb_var[mb_xy]);
514
        const int lumi= pic->mb_mean[mb_xy];
515 c5d309f2 Michael Niedermayer
        float bits, cplx, factor;
516 158c7f05 Michael Niedermayer
#if 0        
517 c5d309f2 Michael Niedermayer
        if(spat_cplx < q/3) spat_cplx= q/3; //FIXME finetune
518
        if(temp_cplx < q/3) temp_cplx= q/3; //FIXME finetune
519 158c7f05 Michael Niedermayer
#endif   
520
        if(spat_cplx < 4) spat_cplx= 4; //FIXME finetune
521
        if(temp_cplx < 4) temp_cplx= 4; //FIXME finetune
522
523 bb198e19 Michael Niedermayer
        if((s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTRA)){//FIXME hq mode 
524 c5d309f2 Michael Niedermayer
            cplx= spat_cplx;
525
            factor= 1.0 + p_masking;
526
        }else{
527
            cplx= temp_cplx;
528
            factor= pow(temp_cplx, - temp_cplx_masking);
529
        }
530
        factor*=pow(spat_cplx, - spatial_cplx_masking);
531 5e746b99 Michael Niedermayer
532
        if(lumi>127)
533
            factor*= (1.0 - (lumi-128)*(lumi-128)*lumi_masking);
534
        else
535
            factor*= (1.0 - (lumi-128)*(lumi-128)*dark_masking);
536 c5d309f2 Michael Niedermayer
        
537
        if(factor<0.00001) factor= 0.00001;
538
        
539
        bits= cplx*factor;
540
        cplx_sum+= cplx;
541
        bits_sum+= bits;
542
        cplx_tab[i]= cplx;
543
        bits_tab[i]= bits;
544
    }
545
546
    /* handle qmin/qmax cliping */
547
    if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
548 e9a4834a Michael Niedermayer
        float factor= bits_sum/cplx_sum;
549 c5d309f2 Michael Niedermayer
        for(i=0; i<s->mb_num; i++){
550
            float newq= q*cplx_tab[i]/bits_tab[i];
551 e9a4834a Michael Niedermayer
            newq*= factor;
552 c5d309f2 Michael Niedermayer
553
            if     (newq > qmax){
554
                bits_sum -= bits_tab[i];
555
                cplx_sum -= cplx_tab[i]*q/qmax;
556
            }
557
            else if(newq < qmin){
558
                bits_sum -= bits_tab[i];
559
                cplx_sum -= cplx_tab[i]*q/qmin;
560
            }
561
        }
562 e9a4834a Michael Niedermayer
        if(bits_sum < 0.001) bits_sum= 0.001;
563
        if(cplx_sum < 0.001) cplx_sum= 0.001;
564 c5d309f2 Michael Niedermayer
    }
565
   
566
    for(i=0; i<s->mb_num; i++){
567 2f5feea4 Michael Niedermayer
        const int mb_xy= s->mb_index2xy[i];
568 c5d309f2 Michael Niedermayer
        float newq= q*cplx_tab[i]/bits_tab[i];
569
        int intq;
570
571
        if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
572
            newq*= bits_sum/cplx_sum;
573
        }
574
575 158c7f05 Michael Niedermayer
        intq= (int)(newq + 0.5);
576 c5d309f2 Michael Niedermayer
577
        if     (intq > qmax) intq= qmax;
578
        else if(intq < qmin) intq= qmin;
579
//if(i%s->mb_width==0) printf("\n");
580
//printf("%2d%3d ", intq, ff_sqrt(s->mc_mb_var[i]));
581 158c7f05 Michael Niedermayer
        s->lambda_table[mb_xy]= intq;
582 c5d309f2 Michael Niedermayer
    }
583
}
584 158c7f05 Michael Niedermayer
//FIXME rd or at least approx for dquant
585 c5d309f2 Michael Niedermayer
586
float ff_rate_estimate_qscale(MpegEncContext *s)
587 8b4c7dbc Michael Niedermayer
{
588
    float q;
589 c5d309f2 Michael Niedermayer
    int qmin, qmax;
590 8b4c7dbc Michael Niedermayer
    float br_compensation;
591
    double diff;
592
    double short_term_q;
593
    double fps;
594 3aa102be Michael Niedermayer
    int picture_number= s->picture_number;
595 8b4c7dbc Michael Niedermayer
    int64_t wanted_bits;
596 3aa102be Michael Niedermayer
    RateControlContext *rcc= &s->rc_context;
597 d55f7b65 Michael Niedermayer
    AVCodecContext *a= s->avctx;
598 3aa102be Michael Niedermayer
    RateControlEntry local_rce, *rce;
599
    double bits;
600
    double rate_factor;
601
    int var;
602
    const int pict_type= s->pict_type;
603 1e491e29 Michael Niedermayer
    Picture * const pic= &s->current_picture;
604 8b4c7dbc Michael Niedermayer
    emms_c();
605
606 3aa102be Michael Niedermayer
    get_qminmax(&qmin, &qmax, s, pict_type);
607 8b4c7dbc Michael Niedermayer
608 14bea432 Michael Niedermayer
    fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base;
609 946c8a12 Michael Niedermayer
//printf("input_pic_num:%d pic_num:%d frame_rate:%d\n", s->input_picture_number, s->picture_number, s->frame_rate);
610 8b4c7dbc Michael Niedermayer
        /* update predictors */
611
    if(picture_number>2){
612 3aa102be Michael Niedermayer
        const int last_var= s->last_pict_type == I_TYPE ? rcc->last_mb_var_sum : rcc->last_mc_mb_var_sum;
613
        update_predictor(&rcc->pred[s->last_pict_type], rcc->last_qscale, sqrt(last_var), s->frame_bits);
614 8b4c7dbc Michael Niedermayer
    }
615
616 3aa102be Michael Niedermayer
    if(s->flags&CODEC_FLAG_PASS2){
617
        assert(picture_number>=0);
618
        assert(picture_number<rcc->num_entries);
619
        rce= &rcc->entry[picture_number];
620
        wanted_bits= rce->expected_bits;
621
    }else{
622
        rce= &local_rce;
623
        wanted_bits= (uint64_t)(s->bit_rate*(double)picture_number/fps);
624
    }
625 8b4c7dbc Michael Niedermayer
626 3aa102be Michael Niedermayer
    diff= s->total_bits - wanted_bits;
627 d55f7b65 Michael Niedermayer
    br_compensation= (a->bit_rate_tolerance - diff)/a->bit_rate_tolerance;
628 3aa102be Michael Niedermayer
    if(br_compensation<=0.0) br_compensation=0.001;
629
630 1e491e29 Michael Niedermayer
    var= pict_type == I_TYPE ? pic->mb_var_sum : pic->mc_mb_var_sum;
631 3aa102be Michael Niedermayer
    
632 b1609412 Fabrice Bellard
    short_term_q = 0; /* avoid warning */
633 3aa102be Michael Niedermayer
    if(s->flags&CODEC_FLAG_PASS2){
634
        if(pict_type!=I_TYPE)
635
            assert(pict_type == rce->new_pict_type);
636
637
        q= rce->new_qscale / br_compensation;
638
//printf("%f %f %f last:%d var:%d type:%d//\n", q, rce->new_qscale, br_compensation, s->frame_bits, var, pict_type);
639
    }else{
640
        rce->pict_type= 
641
        rce->new_pict_type= pict_type;
642 1e491e29 Michael Niedermayer
        rce->mc_mb_var_sum= pic->mc_mb_var_sum;
643
        rce->mb_var_sum   = pic->   mb_var_sum;
644 158c7f05 Michael Niedermayer
        rce->qscale   = FF_QP2LAMBDA * 2;
645 3aa102be Michael Niedermayer
        rce->f_code   = s->f_code;
646
        rce->b_code   = s->b_code;
647
        rce->misc_bits= 1;
648
649
        bits= predict_size(&rcc->pred[pict_type], rce->qscale, sqrt(var));
650
        if(pict_type== I_TYPE){
651
            rce->i_count   = s->mb_num;
652
            rce->i_tex_bits= bits;
653
            rce->p_tex_bits= 0;
654
            rce->mv_bits= 0;
655
        }else{
656
            rce->i_count   = 0; //FIXME we do know this approx
657
            rce->i_tex_bits= 0;
658
            rce->p_tex_bits= bits*0.9;
659
            
660
            rce->mv_bits= bits*0.1;
661 8b4c7dbc Michael Niedermayer
        }
662 3aa102be Michael Niedermayer
        rcc->i_cplx_sum [pict_type] += rce->i_tex_bits*rce->qscale;
663
        rcc->p_cplx_sum [pict_type] += rce->p_tex_bits*rce->qscale;
664
        rcc->mv_bits_sum[pict_type] += rce->mv_bits;
665
        rcc->frame_count[pict_type] ++;
666 8b4c7dbc Michael Niedermayer
667 3aa102be Michael Niedermayer
        bits= rce->i_tex_bits + rce->p_tex_bits;
668 23e54f69 Michael Niedermayer
        rate_factor= rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum * br_compensation;
669 8b4c7dbc Michael Niedermayer
    
670 3aa102be Michael Niedermayer
        q= get_qscale(s, rce, rate_factor, picture_number);
671 8b4c7dbc Michael Niedermayer
672 c695ca3b Michael Niedermayer
        assert(q>0.0);
673 3aa102be Michael Niedermayer
//printf("%f ", q);
674 6a1f7e7b Michael Niedermayer
        q= get_diff_limited_q(s, rce, q);
675 3aa102be Michael Niedermayer
//printf("%f ", q);
676
        assert(q>0.0);
677
678
        if(pict_type==P_TYPE || s->intra_only){ //FIXME type dependant blur like in 2-pass
679 d55f7b65 Michael Niedermayer
            rcc->short_term_qsum*=a->qblur;
680
            rcc->short_term_qcount*=a->qblur;
681 3aa102be Michael Niedermayer
682
            rcc->short_term_qsum+= q;
683
            rcc->short_term_qcount++;
684
//printf("%f ", q);
685
            q= short_term_q= rcc->short_term_qsum/rcc->short_term_qcount;
686
//printf("%f ", q);
687
        }
688 946c8a12 Michael Niedermayer
        assert(q>0.0);
689
        
690 3aa102be Michael Niedermayer
        q= modify_qscale(s, rce, q, picture_number);
691
692
        rcc->pass1_wanted_bits+= s->bit_rate/fps;
693
694 c695ca3b Michael Niedermayer
        assert(q>0.0);
695 8b4c7dbc Michael Niedermayer
    }
696 59b571c1 Michael Niedermayer
697
    if(s->avctx->debug&FF_DEBUG_RC){
698 9b879566 Michel Bardiaux
        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",
699 d8085ea7 Michael Niedermayer
        av_get_pict_type_char(pict_type), qmin, q, qmax, picture_number, (int)wanted_bits/1000, (int)s->total_bits/1000,
700 59b571c1 Michael Niedermayer
        br_compensation, short_term_q, s->frame_bits, pic->mb_var_sum, pic->mc_mb_var_sum, s->bit_rate/1000, (int)fps
701
        );
702
    }
703 3aa102be Michael Niedermayer
704
    if     (q<qmin) q=qmin; 
705
    else if(q>qmax) q=qmax;
706
707 c5d309f2 Michael Niedermayer
    if(s->adaptive_quant)
708
        adaptive_quantization(s, q);
709
    else
710
        q= (int)(q + 0.5);
711
    
712
    rcc->last_qscale= q;
713 1e491e29 Michael Niedermayer
    rcc->last_mc_mb_var_sum= pic->mc_mb_var_sum;
714
    rcc->last_mb_var_sum= pic->mb_var_sum;
715
#if 0
716
{
717
    static int mvsum=0, texsum=0;
718
    mvsum += s->mv_bits;
719
    texsum += s->i_tex_bits + s->p_tex_bits;
720
    printf("%d %d//\n\n", mvsum, texsum);
721
}
722
#endif
723 c5d309f2 Michael Niedermayer
    return q;
724 8b4c7dbc Michael Niedermayer
}
725
726
//----------------------------------------------
727
// 2-Pass code
728
729
static int init_pass2(MpegEncContext *s)
730
{
731
    RateControlContext *rcc= &s->rc_context;
732 d55f7b65 Michael Niedermayer
    AVCodecContext *a= s->avctx;
733 8b4c7dbc Michael Niedermayer
    int i;
734 14bea432 Michael Niedermayer
    double fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base;
735 8b4c7dbc Michael Niedermayer
    double complexity[5]={0,0,0,0,0};   // aproximate bits at quant=1
736
    double avg_quantizer[5];
737
    uint64_t const_bits[5]={0,0,0,0,0}; // quantizer idependant bits
738
    uint64_t available_bits[5];
739
    uint64_t all_const_bits;
740
    uint64_t all_available_bits= (uint64_t)(s->bit_rate*(double)rcc->num_entries/fps);
741
    double rate_factor=0;
742
    double step;
743 ccfddafb bubu
    //int last_i_frame=-10000000;
744 d55f7b65 Michael Niedermayer
    const int filter_size= (int)(a->qblur*4) | 1;  
745 3aa102be Michael Niedermayer
    double expected_bits;
746
    double *qscale, *blured_qscale;
747 8b4c7dbc Michael Niedermayer
748
    /* find complexity & const_bits & decide the pict_types */
749
    for(i=0; i<rcc->num_entries; i++){
750
        RateControlEntry *rce= &rcc->entry[i];
751
        
752 0d1e9246 Michael Niedermayer
        rce->new_pict_type= rce->pict_type;
753 3aa102be Michael Niedermayer
        rcc->i_cplx_sum [rce->pict_type] += rce->i_tex_bits*rce->qscale;
754
        rcc->p_cplx_sum [rce->pict_type] += rce->p_tex_bits*rce->qscale;
755
        rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits;
756
        rcc->frame_count[rce->pict_type] ++;
757 8b4c7dbc Michael Niedermayer
758
        complexity[rce->new_pict_type]+= (rce->i_tex_bits+ rce->p_tex_bits)*(double)rce->qscale;
759
        const_bits[rce->new_pict_type]+= rce->mv_bits + rce->misc_bits;
760
    }
761
    all_const_bits= const_bits[I_TYPE] + const_bits[P_TYPE] + const_bits[B_TYPE];
762
    
763
    if(all_available_bits < all_const_bits){
764 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "requested bitrate is to low\n");
765 8b4c7dbc Michael Niedermayer
        return -1;
766
    }
767 3aa102be Michael Niedermayer
    
768
    /* find average quantizers */
769
    avg_quantizer[P_TYPE]=0;
770
    for(step=256*256; step>0.0000001; step*=0.5){
771
        double expected_bits=0;
772
        avg_quantizer[P_TYPE]+= step;
773
        
774
        avg_quantizer[I_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->i_quant_factor) + s->avctx->i_quant_offset;
775
        avg_quantizer[B_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
776
        
777
        expected_bits= 
778
            + all_const_bits 
779
            + complexity[I_TYPE]/avg_quantizer[I_TYPE]
780
            + complexity[P_TYPE]/avg_quantizer[P_TYPE]
781
            + complexity[B_TYPE]/avg_quantizer[B_TYPE];
782
            
783
        if(expected_bits < all_available_bits) avg_quantizer[P_TYPE]-= step;
784
//printf("%f %lld %f\n", expected_bits, all_available_bits, avg_quantizer[P_TYPE]);
785
    }
786 405469ce Michael Niedermayer
//printf("qp_i:%f, qp_p:%f, qp_b:%f\n", avg_quantizer[I_TYPE],avg_quantizer[P_TYPE],avg_quantizer[B_TYPE]);
787 8b4c7dbc Michael Niedermayer
788
    for(i=0; i<5; i++){
789
        available_bits[i]= const_bits[i] + complexity[i]/avg_quantizer[i];
790
    }
791
//printf("%lld %lld %lld %lld\n", available_bits[I_TYPE], available_bits[P_TYPE], available_bits[B_TYPE], all_available_bits);
792 3aa102be Michael Niedermayer
        
793 8e1e6f31 Fabrice Bellard
    qscale= av_malloc(sizeof(double)*rcc->num_entries);
794
    blured_qscale= av_malloc(sizeof(double)*rcc->num_entries);
795 3aa102be Michael Niedermayer
796 8b4c7dbc Michael Niedermayer
    for(step=256*256; step>0.0000001; step*=0.5){
797 3aa102be Michael Niedermayer
        expected_bits=0;
798 8b4c7dbc Michael Niedermayer
        rate_factor+= step;
799 3aa102be Michael Niedermayer
        
800
        rcc->buffer_index= s->avctx->rc_buffer_size/2;
801
802 8b4c7dbc Michael Niedermayer
        /* find qscale */
803
        for(i=0; i<rcc->num_entries; i++){
804 3aa102be Michael Niedermayer
            qscale[i]= get_qscale(s, &rcc->entry[i], rate_factor, i);
805
        }
806
        assert(filter_size%2==1);
807
808
        /* fixed I/B QP relative to P mode */
809
        for(i=rcc->num_entries-1; i>=0; i--){
810 8b4c7dbc Michael Niedermayer
            RateControlEntry *rce= &rcc->entry[i];
811 6a1f7e7b Michael Niedermayer
            
812
            qscale[i]= get_diff_limited_q(s, rce, qscale[i]);
813 3aa102be Michael Niedermayer
        }
814 8b4c7dbc Michael Niedermayer
815 3aa102be Michael Niedermayer
        /* smooth curve */
816
        for(i=0; i<rcc->num_entries; i++){
817
            RateControlEntry *rce= &rcc->entry[i];
818
            const int pict_type= rce->new_pict_type;
819
            int j;
820
            double q=0.0, sum=0.0;
821
        
822
            for(j=0; j<filter_size; j++){
823
                int index= i+j-filter_size/2;
824
                double d= index-i;
825 d55f7b65 Michael Niedermayer
                double coeff= a->qblur==0 ? 1.0 : exp(-d*d/(a->qblur * a->qblur));
826 8b4c7dbc Michael Niedermayer
            
827 3aa102be Michael Niedermayer
                if(index < 0 || index >= rcc->num_entries) continue;
828
                if(pict_type != rcc->entry[index].new_pict_type) continue;
829
                q+= qscale[index] * coeff;
830
                sum+= coeff;
831 8b4c7dbc Michael Niedermayer
            }
832 3aa102be Michael Niedermayer
            blured_qscale[i]= q/sum;
833 8b4c7dbc Michael Niedermayer
        }
834
    
835
        /* find expected bits */
836
        for(i=0; i<rcc->num_entries; i++){
837
            RateControlEntry *rce= &rcc->entry[i];
838 3aa102be Michael Niedermayer
            double bits;
839
            rce->new_qscale= modify_qscale(s, rce, blured_qscale[i], i);
840 405469ce Michael Niedermayer
            bits= qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;
841 3aa102be Michael Niedermayer
//printf("%d %f\n", rce->new_bits, blured_qscale[i]);
842 11dffbe1 Michael Niedermayer
            bits += 8*ff_vbv_update(s, bits);
843 3aa102be Michael Niedermayer
844 8b4c7dbc Michael Niedermayer
            rce->expected_bits= expected_bits;
845 3aa102be Michael Niedermayer
            expected_bits += bits;
846 8b4c7dbc Michael Niedermayer
        }
847
848 3aa102be Michael Niedermayer
//        printf("%f %d %f\n", expected_bits, (int)all_available_bits, rate_factor);
849 8b4c7dbc Michael Niedermayer
        if(expected_bits > all_available_bits) rate_factor-= step;
850
    }
851 8e1e6f31 Fabrice Bellard
    av_free(qscale);
852
    av_free(blured_qscale);
853 8b4c7dbc Michael Niedermayer
854 3aa102be Michael Niedermayer
    if(abs(expected_bits/all_available_bits - 1.0) > 0.01 ){
855 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "Error: 2pass curve failed to converge\n");
856 3aa102be Michael Niedermayer
        return -1;
857 8b4c7dbc Michael Niedermayer
    }
858
859 3aa102be Michael Niedermayer
    return 0;
860 8b4c7dbc Michael Niedermayer
}