git.sesse.net Git - ffmpeg/blob - libavcodec/ratecontrol.c

   1 /*
   2  * Rate control for video encoders
   3  *
   4  * Copyright (c) 2002 Michael Niedermayer <michaelni@gmx.at>
   5  *
   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 #include <math.h>
  21 #include "common.h"
  22 #include "avcodec.h"
  23 #include "dsputil.h"
  24 #include "mpegvideo.h"
  25
  26 #undef NDEBUG // allways check asserts, the speed effect is far too small to disable them
  27 #include <assert.h>
  28
  29 #ifndef M_PI
  30 #define M_PI 3.14159265358979323846
  31 #endif
  32
  33 #ifndef M_E
  34 #define M_E 2.718281828
  35 #endif
  36
  37 static int init_pass2(MpegEncContext *s);
  38 static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_factor, int frame_num);
  39
  40 void ff_write_pass1_stats(MpegEncContext *s){
  41     sprintf(s->avctx->stats_out, "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;\n",
  42             s->picture_number, s->input_picture_number - s->max_b_frames, s->pict_type,
  43             s->frame_qscale, s->i_tex_bits, s->p_tex_bits, s->mv_bits, s->misc_bits,
  44             s->f_code, s->b_code, s->mc_mb_var_sum, s->mb_var_sum, s->i_count);
  45 }
  46
  47 int ff_rate_control_init(MpegEncContext *s)
  48 {
  49     RateControlContext *rcc= &s->rc_context;
  50     int i;
  51     emms_c();
  52
  53     for(i=0; i<5; i++){
  54         rcc->pred[i].coeff= 7.0;
  55         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         rcc->last_qscale_for[i]=5;
  64     }
  65     rcc->buffer_index= s->avctx->rc_buffer_size/2;
  66
  67     if(s->flags&CODEC_FLAG_PASS2){
  68         int i;
  69         char *p;
  70
  71         /* find number of pics */
  72         p= s->avctx->stats_in;
  73         for(i=-1; p; i++){
  74             p= strchr(p+1, ';');
  75         }
  76         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             rce->qscale= rce->new_qscale=2;
  85             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             RateControlEntry *rce;
  93             int picture_number;
  94             int e;
  95             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             rce= &rcc->entry[picture_number];
 107
 108             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                    &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                 fprintf(stderr, "statistics are damaged at line %d, parser out=%d\n", i, e);
 113                 return -1;
 114             }
 115             p= next;
 116         }
 117
 118         if(init_pass2(s) < 0) return -1;
 119     }
 120
 121     if(!(s->flags&CODEC_FLAG_PASS2)){
 122
 123         rcc->short_term_qsum=0.001;
 124         rcc->short_term_qcount=0.001;
 125
 126         rcc->pass1_rc_eq_output_sum= 0.001;
 127         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                 rce.qscale   = 2;
 144                 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
 164                 bits= rce.i_tex_bits + rce.p_tex_bits;
 165
 166                 q= get_qscale(s, &rce, rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum, i);
 167                 rcc->pass1_wanted_bits+= s->bit_rate/(s->frame_rate / (double)FRAME_RATE_BASE);
 168             }
 169         }
 170
 171     }
 172
 173     return 0;
 174 }
 175
 176 void ff_rate_control_uninit(MpegEncContext *s)
 177 {
 178     RateControlContext *rcc= &s->rc_context;
 179     emms_c();
 180
 181     av_freep(&rcc->entry);
 182 }
 183
 184 static inline double qp2bits(RateControlEntry *rce, double qp){
 185     if(qp<=0.0){
 186         fprintf(stderr, "qp<=0.0\n");
 187     }
 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         fprintf(stderr, "bits<0.9\n");
 194     }
 195     return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits+1)/ bits;
 196 }
 197
 198 static void update_rc_buffer(MpegEncContext *s, int frame_size){
 199     RateControlContext *rcc= &s->rc_context;
 200     const double fps= (double)s->frame_rate / FRAME_RATE_BASE;
 201     const double buffer_size= s->avctx->rc_buffer_size;
 202     const double min_rate= s->avctx->rc_min_rate/fps;
 203     const double max_rate= s->avctx->rc_max_rate/fps;
 204
 205     if(buffer_size){
 206         rcc->buffer_index-= frame_size;
 207         if(rcc->buffer_index < buffer_size/2 /*FIXME /2 */ || min_rate==0){
 208             rcc->buffer_index+= max_rate;
 209             if(rcc->buffer_index >= buffer_size)
 210                 rcc->buffer_index= buffer_size-1;
 211         }else{
 212             rcc->buffer_index+= min_rate;
 213         }
 214
 215         if(rcc->buffer_index < 0)
 216             fprintf(stderr, "rc buffer underflow\n");
 217         if(rcc->buffer_index >= s->avctx->rc_buffer_size)
 218             fprintf(stderr, "rc buffer overflow\n");
 219     }
 220 }
 221
 222 /**
 223  * modifies the bitrate curve from pass1 for one frame
 224  */
 225 static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_factor, int frame_num){
 226     RateControlContext *rcc= &s->rc_context;
 227     double q, bits;
 228     const int pict_type= rce->new_pict_type;
 229     const double mb_num= s->mb_num;
 230     int i;
 231
 232     double const_values[]={
 233         M_PI,
 234         M_E,
 235         rce->i_tex_bits*rce->qscale,
 236         rce->p_tex_bits*rce->qscale,
 237         (rce->i_tex_bits + rce->p_tex_bits)*(double)rce->qscale,
 238         rce->mv_bits/mb_num,
 239         rce->pict_type == B_TYPE ? (rce->f_code + rce->b_code)*0.5 : rce->f_code,
 240         rce->i_count/mb_num,
 241         rce->mc_mb_var_sum/mb_num,
 242         rce->mb_var_sum/mb_num,
 243         rce->pict_type == I_TYPE,
 244         rce->pict_type == P_TYPE,
 245         rce->pict_type == B_TYPE,
 246         rcc->qscale_sum[pict_type] / (double)rcc->frame_count[pict_type],
 247         s->qcompress,
 248 /*        rcc->last_qscale_for[I_TYPE],
 249         rcc->last_qscale_for[P_TYPE],
 250         rcc->last_qscale_for[B_TYPE],
 251         rcc->next_non_b_qscale,*/
 252         rcc->i_cplx_sum[I_TYPE] / (double)rcc->frame_count[I_TYPE],
 253         rcc->i_cplx_sum[P_TYPE] / (double)rcc->frame_count[P_TYPE],
 254         rcc->p_cplx_sum[P_TYPE] / (double)rcc->frame_count[P_TYPE],
 255         rcc->p_cplx_sum[B_TYPE] / (double)rcc->frame_count[B_TYPE],
 256         (rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / (double)rcc->frame_count[pict_type],
 257         0
 258     };
 259     char *const_names[]={
 260         "PI",
 261         "E",
 262         "iTex",
 263         "pTex",
 264         "tex",
 265         "mv",
 266         "fCode",
 267         "iCount",
 268         "mcVar",
 269         "var",
 270         "isI",
 271         "isP",
 272         "isB",
 273         "avgQP",
 274         "qComp",
 275 /*        "lastIQP",
 276         "lastPQP",
 277         "lastBQP",
 278         "nextNonBQP",*/
 279         "avgIITex",
 280         "avgPITex",
 281         "avgPPTex",
 282         "avgBPTex",
 283         "avgTex",
 284         NULL
 285     };
 286     static double (*func1[])(void *, double)={
 287         (void *)bits2qp,
 288         (void *)qp2bits,
 289         NULL
 290     };
 291     char *func1_names[]={
 292         "bits2qp",
 293         "qp2bits",
 294         NULL
 295     };
 296
 297     bits= ff_eval(s->avctx->rc_eq, const_values, const_names, func1, func1_names, NULL, NULL, rce);
 298
 299     rcc->pass1_rc_eq_output_sum+= bits;
 300     bits*=rate_factor;
 301     if(bits<0.0) bits=0.0;
 302     bits+= 1.0; //avoid 1/0 issues
 303
 304     /* user override */
 305     for(i=0; i<s->avctx->rc_override_count; i++){
 306         RcOverride *rco= s->avctx->rc_override;
 307         if(rco[i].start_frame > frame_num) continue;
 308         if(rco[i].end_frame   < frame_num) continue;
 309
 310         if(rco[i].qscale)
 311             bits= qp2bits(rce, rco[i].qscale); //FIXME move at end to really force it?
 312         else
 313             bits*= rco[i].quality_factor;
 314     }
 315
 316     q= bits2qp(rce, bits);
 317
 318     /* I/B difference */
 319     if     (pict_type==I_TYPE && s->avctx->i_quant_factor<0.0)
 320         q= -q*s->avctx->i_quant_factor + s->avctx->i_quant_offset;
 321     else if(pict_type==B_TYPE && s->avctx->b_quant_factor<0.0)
 322         q= -q*s->avctx->b_quant_factor + s->avctx->b_quant_offset;
 323
 324     return q;
 325 }
 326
 327 static double get_diff_limited_q(MpegEncContext *s, RateControlEntry *rce, double q){
 328     RateControlContext *rcc= &s->rc_context;
 329     AVCodecContext *a= s->avctx;
 330     const int pict_type= rce->new_pict_type;
 331     const double last_p_q    = rcc->last_qscale_for[P_TYPE];
 332     const double last_non_b_q= rcc->last_qscale_for[rcc->last_non_b_pict_type];
 333
 334     if     (pict_type==I_TYPE && (a->i_quant_factor>0.0 || rcc->last_non_b_pict_type==P_TYPE))
 335         q= last_p_q    *ABS(a->i_quant_factor) + a->i_quant_offset;
 336     else if(pict_type==B_TYPE && a->b_quant_factor>0.0)
 337         q= last_non_b_q*    a->b_quant_factor  + a->b_quant_offset;
 338
 339     /* last qscale / qdiff stuff */
 340     if(rcc->last_non_b_pict_type==pict_type || pict_type!=I_TYPE){
 341         double last_q= rcc->last_qscale_for[pict_type];
 342         if     (q > last_q + a->max_qdiff) q= last_q + a->max_qdiff;
 343         else if(q < last_q - a->max_qdiff) q= last_q - a->max_qdiff;
 344     }
 345
 346     rcc->last_qscale_for[pict_type]= q; //Note we cant do that after blurring
 347
 348     if(pict_type!=B_TYPE)
 349         rcc->last_non_b_pict_type= pict_type;
 350
 351     return q;
 352 }
 353
 354 /**
 355  * gets the qmin & qmax for pict_type
 356  */
 357 static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type){
 358     int qmin= s->qmin;
 359     int qmax= s->qmax;
 360
 361     if(pict_type==B_TYPE){
 362         qmin= (int)(qmin*ABS(s->avctx->b_quant_factor)+s->avctx->b_quant_offset + 0.5);
 363         qmax= (int)(qmax*ABS(s->avctx->b_quant_factor)+s->avctx->b_quant_offset + 0.5);
 364     }else if(pict_type==I_TYPE){
 365         qmin= (int)(qmin*ABS(s->avctx->i_quant_factor)+s->avctx->i_quant_offset + 0.5);
 366         qmax= (int)(qmax*ABS(s->avctx->i_quant_factor)+s->avctx->i_quant_offset + 0.5);
 367     }
 368
 369     if(qmin<1) qmin=1;
 370     if(qmin==1 && s->qmin>1) qmin=2; //avoid qmin=1 unless the user wants qmin=1
 371
 372     if(qmin<3 && s->max_qcoeff<=128 && pict_type==I_TYPE) qmin=3; //reduce cliping problems
 373
 374     if(qmax>31) qmax=31;
 375     if(qmax<=qmin) qmax= qmin= (qmax+qmin+1)>>1;
 376
 377     *qmin_ret= qmin;
 378     *qmax_ret= qmax;
 379 }
 380
 381 static double modify_qscale(MpegEncContext *s, RateControlEntry *rce, double q, int frame_num){
 382     RateControlContext *rcc= &s->rc_context;
 383     int qmin, qmax;
 384     double bits;
 385     const int pict_type= rce->new_pict_type;
 386     const double buffer_size= s->avctx->rc_buffer_size;
 387     const double min_rate= s->avctx->rc_min_rate;
 388     const double max_rate= s->avctx->rc_max_rate;
 389
 390     get_qminmax(&qmin, &qmax, s, pict_type);
 391
 392     /* modulation */
 393     if(s->avctx->rc_qmod_freq && frame_num%s->avctx->rc_qmod_freq==0 && pict_type==P_TYPE)
 394         q*= s->avctx->rc_qmod_amp;
 395
 396     bits= qp2bits(rce, q);
 397 //printf("q:%f\n", q);
 398     /* buffer overflow/underflow protection */
 399     if(buffer_size){
 400         double expected_size= rcc->buffer_index;
 401
 402         if(min_rate){
 403             double d= 2*(buffer_size - expected_size)/buffer_size;
 404             if(d>1.0) d=1.0;
 405             else if(d<0.0001) d=0.0001;
 406             q*= pow(d, 1.0/s->avctx->rc_buffer_aggressivity);
 407
 408             q= MIN(q, bits2qp(rce, MAX((min_rate - buffer_size + rcc->buffer_index)*2, 1)));
 409         }
 410
 411         if(max_rate){
 412             double d= 2*expected_size/buffer_size;
 413             if(d>1.0) d=1.0;
 414             else if(d<0.0001) d=0.0001;
 415             q/= pow(d, 1.0/s->avctx->rc_buffer_aggressivity);
 416
 417             q= MAX(q, bits2qp(rce, MAX(rcc->buffer_index/2, 1)));
 418         }
 419     }
 420 //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);
 421     if(s->avctx->rc_qsquish==0.0 || qmin==qmax){
 422         if     (q<qmin) q=qmin;
 423         else if(q>qmax) q=qmax;
 424     }else{
 425         double min2= log(qmin);
 426         double max2= log(qmax);
 427
 428         q= log(q);
 429         q= (q - min2)/(max2-min2) - 0.5;
 430         q*= -4.0;
 431         q= 1.0/(1.0 + exp(q));
 432         q= q*(max2-min2) + min2;
 433
 434         q= exp(q);
 435     }
 436
 437     return q;
 438 }
 439
 440 //----------------------------------
 441 // 1 Pass Code
 442
 443 static double predict_size(Predictor *p, double q, double var)
 444 {
 445      return p->coeff*var / (q*p->count);
 446 }
 447
 448 static double predict_qp(Predictor *p, double size, double var)
 449 {
 450 //printf("coeff:%f, count:%f, var:%f, size:%f//\n", p->coeff, p->count, var, size);
 451      return p->coeff*var / (size*p->count);
 452 }
 453
 454 static void update_predictor(Predictor *p, double q, double var, double size)
 455 {
 456     double new_coeff= size*q / (var + 1);
 457     if(var<10) return;
 458
 459     p->count*= p->decay;
 460     p->coeff*= p->decay;
 461     p->count++;
 462     p->coeff+= new_coeff;
 463 }
 464
 465 static void adaptive_quantization(MpegEncContext *s, double q){
 466     int i;
 467     const float lumi_masking= s->avctx->lumi_masking / (128.0*128.0);
 468     const float dark_masking= s->avctx->dark_masking / (128.0*128.0);
 469     const float temp_cplx_masking= s->avctx->temporal_cplx_masking;
 470     const float spatial_cplx_masking = s->avctx->spatial_cplx_masking;
 471     const float p_masking = s->avctx->p_masking;
 472     float bits_sum= 0.0;
 473     float cplx_sum= 0.0;
 474     float cplx_tab[s->mb_num];
 475     float bits_tab[s->mb_num];
 476     const int qmin= 2; //s->avctx->mb_qmin;
 477     const int qmax= 31; //s->avctx->mb_qmax;
 478
 479     for(i=0; i<s->mb_num; i++){
 480         float temp_cplx= sqrt(s->mc_mb_var[i]);
 481         float spat_cplx= sqrt(s->mb_var[i]);
 482         const int lumi= s->mb_mean[i];
 483         float bits, cplx, factor;
 484
 485         if(spat_cplx < q/3) spat_cplx= q/3; //FIXME finetune
 486         if(temp_cplx < q/3) temp_cplx= q/3; //FIXME finetune
 487
 488         if((s->mb_type[i]&MB_TYPE_INTRA)){//FIXME hq mode
 489             cplx= spat_cplx;
 490             factor= 1.0 + p_masking;
 491         }else{
 492             cplx= temp_cplx;
 493             factor= pow(temp_cplx, - temp_cplx_masking);
 494         }
 495         factor*=pow(spat_cplx, - spatial_cplx_masking);
 496
 497         if(lumi>127)
 498             factor*= (1.0 - (lumi-128)*(lumi-128)*lumi_masking);
 499         else
 500             factor*= (1.0 - (lumi-128)*(lumi-128)*dark_masking);
 501
 502         if(factor<0.00001) factor= 0.00001;
 503
 504         bits= cplx*factor;
 505         cplx_sum+= cplx;
 506         bits_sum+= bits;
 507         cplx_tab[i]= cplx;
 508         bits_tab[i]= bits;
 509     }
 510
 511     /* handle qmin/qmax cliping */
 512     if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
 513         for(i=0; i<s->mb_num; i++){
 514             float newq= q*cplx_tab[i]/bits_tab[i];
 515             newq*= bits_sum/cplx_sum;
 516
 517             if     (newq > qmax){
 518                 bits_sum -= bits_tab[i];
 519                 cplx_sum -= cplx_tab[i]*q/qmax;
 520             }
 521             else if(newq < qmin){
 522                 bits_sum -= bits_tab[i];
 523                 cplx_sum -= cplx_tab[i]*q/qmin;
 524             }
 525         }
 526     }
 527
 528     for(i=0; i<s->mb_num; i++){
 529         float newq= q*cplx_tab[i]/bits_tab[i];
 530         int intq;
 531
 532         if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
 533             newq*= bits_sum/cplx_sum;
 534         }
 535
 536         if(i && ABS(s->qscale_table[i-1] - newq)<0.75)
 537             intq= s->qscale_table[i-1];
 538         else
 539             intq= (int)(newq + 0.5);
 540
 541         if     (intq > qmax) intq= qmax;
 542         else if(intq < qmin) intq= qmin;
 543 //if(i%s->mb_width==0) printf("\n");
 544 //printf("%2d%3d ", intq, ff_sqrt(s->mc_mb_var[i]));
 545         s->qscale_table[i]= intq;
 546     }
 547 }
 548
 549 float ff_rate_estimate_qscale(MpegEncContext *s)
 550 {
 551     float q;
 552     int qmin, qmax;
 553     float br_compensation;
 554     double diff;
 555     double short_term_q;
 556     double fps;
 557     int picture_number= s->picture_number;
 558     int64_t wanted_bits;
 559     RateControlContext *rcc= &s->rc_context;
 560     RateControlEntry local_rce, *rce;
 561     double bits;
 562     double rate_factor;
 563     int var;
 564     const int pict_type= s->pict_type;
 565     emms_c();
 566
 567     get_qminmax(&qmin, &qmax, s, pict_type);
 568
 569     fps= (double)s->frame_rate / FRAME_RATE_BASE;
 570 //printf("input_pic_num:%d pic_num:%d frame_rate:%d\n", s->input_picture_number, s->picture_number, s->frame_rate);
 571         /* update predictors */
 572     if(picture_number>2){
 573         const int last_var= s->last_pict_type == I_TYPE ? rcc->last_mb_var_sum : rcc->last_mc_mb_var_sum;
 574         update_predictor(&rcc->pred[s->last_pict_type], rcc->last_qscale, sqrt(last_var), s->frame_bits);
 575     }
 576
 577     if(s->flags&CODEC_FLAG_PASS2){
 578         assert(picture_number>=0);
 579         assert(picture_number<rcc->num_entries);
 580         rce= &rcc->entry[picture_number];
 581         wanted_bits= rce->expected_bits;
 582     }else{
 583         rce= &local_rce;
 584         wanted_bits= (uint64_t)(s->bit_rate*(double)picture_number/fps);
 585     }
 586
 587     diff= s->total_bits - wanted_bits;
 588     br_compensation= (s->bit_rate_tolerance - diff)/s->bit_rate_tolerance;
 589     if(br_compensation<=0.0) br_compensation=0.001;
 590
 591     var= pict_type == I_TYPE ? s->mb_var_sum : s->mc_mb_var_sum;
 592
 593     if(s->flags&CODEC_FLAG_PASS2){
 594         if(pict_type!=I_TYPE)
 595             assert(pict_type == rce->new_pict_type);
 596
 597         q= rce->new_qscale / br_compensation;
 598 //printf("%f %f %f last:%d var:%d type:%d//\n", q, rce->new_qscale, br_compensation, s->frame_bits, var, pict_type);
 599     }else{
 600         rce->pict_type=
 601         rce->new_pict_type= pict_type;
 602         rce->mc_mb_var_sum= s->mc_mb_var_sum;
 603         rce->mb_var_sum   = s->   mb_var_sum;
 604         rce->qscale   = 2;
 605         rce->f_code   = s->f_code;
 606         rce->b_code   = s->b_code;
 607         rce->misc_bits= 1;
 608
 609         if(picture_number>0)
 610             update_rc_buffer(s, s->frame_bits);
 611
 612         bits= predict_size(&rcc->pred[pict_type], rce->qscale, sqrt(var));
 613         if(pict_type== I_TYPE){
 614             rce->i_count   = s->mb_num;
 615             rce->i_tex_bits= bits;
 616             rce->p_tex_bits= 0;
 617             rce->mv_bits= 0;
 618         }else{
 619             rce->i_count   = 0; //FIXME we do know this approx
 620             rce->i_tex_bits= 0;
 621             rce->p_tex_bits= bits*0.9;
 622
 623             rce->mv_bits= bits*0.1;
 624         }
 625         rcc->i_cplx_sum [pict_type] += rce->i_tex_bits*rce->qscale;
 626         rcc->p_cplx_sum [pict_type] += rce->p_tex_bits*rce->qscale;
 627         rcc->mv_bits_sum[pict_type] += rce->mv_bits;
 628         rcc->frame_count[pict_type] ++;
 629
 630         bits= rce->i_tex_bits + rce->p_tex_bits;
 631         rate_factor= rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum * br_compensation;
 632
 633         q= get_qscale(s, rce, rate_factor, picture_number);
 634
 635         assert(q>0.0);
 636 //printf("%f ", q);
 637         q= get_diff_limited_q(s, rce, q);
 638 //printf("%f ", q);
 639         assert(q>0.0);
 640
 641         if(pict_type==P_TYPE || s->intra_only){ //FIXME type dependant blur like in 2-pass
 642             rcc->short_term_qsum*=s->qblur;
 643             rcc->short_term_qcount*=s->qblur;
 644
 645             rcc->short_term_qsum+= q;
 646             rcc->short_term_qcount++;
 647 //printf("%f ", q);
 648             q= short_term_q= rcc->short_term_qsum/rcc->short_term_qcount;
 649 //printf("%f ", q);
 650         }
 651         assert(q>0.0);
 652
 653         q= modify_qscale(s, rce, q, picture_number);
 654
 655         rcc->pass1_wanted_bits+= s->bit_rate/fps;
 656
 657         assert(q>0.0);
 658     }
 659 //printf("qmin:%d, qmax:%d, q:%f\n", qmin, qmax, q);
 660
 661
 662     if     (q<qmin) q=qmin;
 663     else if(q>qmax) q=qmax;
 664
 665 //    printf("%f %d %d %d\n", q, picture_number, (int)wanted_bits, (int)s->total_bits);
 666
 667 //printf("%f %f %f\n", q, br_compensation, short_term_q);
 668
 669 //printf("q:%d diff:%d comp:%f st_q:%f last_size:%d type:%d\n", qscale, (int)diff, br_compensation,
 670 //       short_term_q, s->frame_bits, pict_type);
 671 //printf("%d %d\n", s->bit_rate, (int)fps);
 672
 673     if(s->adaptive_quant)
 674         adaptive_quantization(s, q);
 675     else
 676         q= (int)(q + 0.5);
 677
 678     rcc->last_qscale= q;
 679     rcc->last_mc_mb_var_sum= s->mc_mb_var_sum;
 680     rcc->last_mb_var_sum= s->mb_var_sum;
 681     return q;
 682 }
 683
 684 //----------------------------------------------
 685 // 2-Pass code
 686
 687 static int init_pass2(MpegEncContext *s)
 688 {
 689     RateControlContext *rcc= &s->rc_context;
 690     int i;
 691     double fps= (double)s->frame_rate / FRAME_RATE_BASE;
 692     double complexity[5]={0,0,0,0,0};   // aproximate bits at quant=1
 693     double avg_quantizer[5];
 694     uint64_t const_bits[5]={0,0,0,0,0}; // quantizer idependant bits
 695     uint64_t available_bits[5];
 696     uint64_t all_const_bits;
 697     uint64_t all_available_bits= (uint64_t)(s->bit_rate*(double)rcc->num_entries/fps);
 698     double rate_factor=0;
 699     double step;
 700     int last_i_frame=-10000000;
 701     const int filter_size= (int)(s->qblur*4) | 1;
 702     double expected_bits;
 703     double *qscale, *blured_qscale;
 704
 705     /* find complexity & const_bits & decide the pict_types */
 706     for(i=0; i<rcc->num_entries; i++){
 707         RateControlEntry *rce= &rcc->entry[i];
 708
 709         if(s->b_frame_strategy==0 || s->max_b_frames==0){
 710             rce->new_pict_type= rce->pict_type;
 711         }else{
 712             int j;
 713             int next_non_b_type=P_TYPE;
 714
 715             switch(rce->pict_type){
 716             case I_TYPE:
 717                 if(i-last_i_frame>s->gop_size/2){ //FIXME this is not optimal
 718                     rce->new_pict_type= I_TYPE;
 719                     last_i_frame= i;
 720                 }else{
 721                     rce->new_pict_type= P_TYPE; // will be caught by the scene detection anyway
 722                 }
 723                 break;
 724             case P_TYPE:
 725                 rce->new_pict_type= P_TYPE;
 726                 break;
 727             case B_TYPE:
 728                 for(j=i+1; j<i+s->max_b_frames+2 && j<rcc->num_entries; j++){
 729                     if(rcc->entry[j].pict_type != B_TYPE){
 730                         next_non_b_type= rcc->entry[j].pict_type;
 731                         break;
 732                     }
 733                 }
 734                 if(next_non_b_type==I_TYPE)
 735                     rce->new_pict_type= P_TYPE;
 736                 else
 737                     rce->new_pict_type= B_TYPE;
 738                 break;
 739             }
 740         }
 741         rcc->i_cplx_sum [rce->pict_type] += rce->i_tex_bits*rce->qscale;
 742         rcc->p_cplx_sum [rce->pict_type] += rce->p_tex_bits*rce->qscale;
 743         rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits;
 744         rcc->frame_count[rce->pict_type] ++;
 745
 746         complexity[rce->new_pict_type]+= (rce->i_tex_bits+ rce->p_tex_bits)*(double)rce->qscale;
 747         const_bits[rce->new_pict_type]+= rce->mv_bits + rce->misc_bits;
 748     }
 749     all_const_bits= const_bits[I_TYPE] + const_bits[P_TYPE] + const_bits[B_TYPE];
 750
 751     if(all_available_bits < all_const_bits){
 752         fprintf(stderr, "requested bitrate is to low\n");
 753         return -1;
 754     }
 755
 756     /* find average quantizers */
 757     avg_quantizer[P_TYPE]=0;
 758     for(step=256*256; step>0.0000001; step*=0.5){
 759         double expected_bits=0;
 760         avg_quantizer[P_TYPE]+= step;
 761
 762         avg_quantizer[I_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->i_quant_factor) + s->avctx->i_quant_offset;
 763         avg_quantizer[B_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
 764
 765         expected_bits=
 766             + all_const_bits
 767             + complexity[I_TYPE]/avg_quantizer[I_TYPE]
 768             + complexity[P_TYPE]/avg_quantizer[P_TYPE]
 769             + complexity[B_TYPE]/avg_quantizer[B_TYPE];
 770
 771         if(expected_bits < all_available_bits) avg_quantizer[P_TYPE]-= step;
 772 //printf("%f %lld %f\n", expected_bits, all_available_bits, avg_quantizer[P_TYPE]);
 773     }
 774 //printf("qp_i:%f, qp_p:%f, qp_b:%f\n", avg_quantizer[I_TYPE],avg_quantizer[P_TYPE],avg_quantizer[B_TYPE]);
 775
 776     for(i=0; i<5; i++){
 777         available_bits[i]= const_bits[i] + complexity[i]/avg_quantizer[i];
 778     }
 779 //printf("%lld %lld %lld %lld\n", available_bits[I_TYPE], available_bits[P_TYPE], available_bits[B_TYPE], all_available_bits);
 780
 781     qscale= malloc(sizeof(double)*rcc->num_entries);
 782     blured_qscale= malloc(sizeof(double)*rcc->num_entries);
 783
 784     for(step=256*256; step>0.0000001; step*=0.5){
 785         expected_bits=0;
 786         rate_factor+= step;
 787
 788         rcc->buffer_index= s->avctx->rc_buffer_size/2;
 789
 790         /* find qscale */
 791         for(i=0; i<rcc->num_entries; i++){
 792             qscale[i]= get_qscale(s, &rcc->entry[i], rate_factor, i);
 793         }
 794         assert(filter_size%2==1);
 795
 796         /* fixed I/B QP relative to P mode */
 797         for(i=rcc->num_entries-1; i>=0; i--){
 798             RateControlEntry *rce= &rcc->entry[i];
 799
 800             qscale[i]= get_diff_limited_q(s, rce, qscale[i]);
 801         }
 802
 803         /* smooth curve */
 804         for(i=0; i<rcc->num_entries; i++){
 805             RateControlEntry *rce= &rcc->entry[i];
 806             const int pict_type= rce->new_pict_type;
 807             int j;
 808             double q=0.0, sum=0.0;
 809
 810             for(j=0; j<filter_size; j++){
 811                 int index= i+j-filter_size/2;
 812                 double d= index-i;
 813                 double coeff= s->qblur==0 ? 1.0 : exp(-d*d/(s->qblur * s->qblur));
 814
 815                 if(index < 0 || index >= rcc->num_entries) continue;
 816                 if(pict_type != rcc->entry[index].new_pict_type) continue;
 817                 q+= qscale[index] * coeff;
 818                 sum+= coeff;
 819             }
 820             blured_qscale[i]= q/sum;
 821         }
 822
 823         /* find expected bits */
 824         for(i=0; i<rcc->num_entries; i++){
 825             RateControlEntry *rce= &rcc->entry[i];
 826             double bits;
 827             rce->new_qscale= modify_qscale(s, rce, blured_qscale[i], i);
 828             bits= qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;
 829 //printf("%d %f\n", rce->new_bits, blured_qscale[i]);
 830             update_rc_buffer(s, bits);
 831
 832             rce->expected_bits= expected_bits;
 833             expected_bits += bits;
 834         }
 835
 836 //        printf("%f %d %f\n", expected_bits, (int)all_available_bits, rate_factor);
 837         if(expected_bits > all_available_bits) rate_factor-= step;
 838     }
 839     free(qscale);
 840     free(blured_qscale);
 841
 842     if(abs(expected_bits/all_available_bits - 1.0) > 0.01 ){
 843         fprintf(stderr, "Error: 2pass curve failed to converge\n");
 844         return -1;
 845     }
 846
 847     return 0;
 848 }