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
  21 /**
  22  * @file ratecontrol.c
  23  * Rate control for video encoders.
  24  */
  25
  26 #include "avcodec.h"
  27 #include "dsputil.h"
  28 #include "mpegvideo.h"
  29
  30 #undef NDEBUG // allways check asserts, the speed effect is far too small to disable them
  31 #include <assert.h>
  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->current_picture.mc_mb_var_sum, s->current_picture.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->avctx->frame_rate / (double)s->avctx->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->avctx->frame_rate / (double)s->avctx->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     static const 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     static const 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
 343         if     (q > last_q + a->max_qdiff) q= last_q + a->max_qdiff;
 344         else if(q < last_q - a->max_qdiff) q= last_q - a->max_qdiff;
 345     }
 346
 347     rcc->last_qscale_for[pict_type]= q; //Note we cant do that after blurring
 348
 349     if(pict_type!=B_TYPE)
 350         rcc->last_non_b_pict_type= pict_type;
 351
 352     return q;
 353 }
 354
 355 /**
 356  * gets the qmin & qmax for pict_type
 357  */
 358 static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type){
 359     int qmin= s->avctx->qmin;
 360     int qmax= s->avctx->qmax;
 361
 362     if(pict_type==B_TYPE){
 363         qmin= (int)(qmin*ABS(s->avctx->b_quant_factor)+s->avctx->b_quant_offset + 0.5);
 364         qmax= (int)(qmax*ABS(s->avctx->b_quant_factor)+s->avctx->b_quant_offset + 0.5);
 365     }else if(pict_type==I_TYPE){
 366         qmin= (int)(qmin*ABS(s->avctx->i_quant_factor)+s->avctx->i_quant_offset + 0.5);
 367         qmax= (int)(qmax*ABS(s->avctx->i_quant_factor)+s->avctx->i_quant_offset + 0.5);
 368     }
 369
 370     if(qmin<1) qmin=1;
 371     if(qmin==1 && s->avctx->qmin>1) qmin=2; //avoid qmin=1 unless the user wants qmin=1
 372
 373     if(qmin<3 && s->max_qcoeff<=128 && pict_type==I_TYPE) qmin=3; //reduce cliping problems
 374
 375     if(qmax>31) qmax=31;
 376     if(qmax<=qmin) qmax= qmin= (qmax+qmin+1)>>1;
 377
 378     *qmin_ret= qmin;
 379     *qmax_ret= qmax;
 380 }
 381
 382 static double modify_qscale(MpegEncContext *s, RateControlEntry *rce, double q, int frame_num){
 383     RateControlContext *rcc= &s->rc_context;
 384     int qmin, qmax;
 385     double bits;
 386     const int pict_type= rce->new_pict_type;
 387     const double buffer_size= s->avctx->rc_buffer_size;
 388     const double min_rate= s->avctx->rc_min_rate;
 389     const double max_rate= s->avctx->rc_max_rate;
 390
 391     get_qminmax(&qmin, &qmax, s, pict_type);
 392
 393     /* modulation */
 394     if(s->avctx->rc_qmod_freq && frame_num%s->avctx->rc_qmod_freq==0 && pict_type==P_TYPE)
 395         q*= s->avctx->rc_qmod_amp;
 396
 397     bits= qp2bits(rce, q);
 398 //printf("q:%f\n", q);
 399     /* buffer overflow/underflow protection */
 400     if(buffer_size){
 401         double expected_size= rcc->buffer_index;
 402
 403         if(min_rate){
 404             double d= 2*(buffer_size - expected_size)/buffer_size;
 405             if(d>1.0) d=1.0;
 406             else if(d<0.0001) d=0.0001;
 407             q*= pow(d, 1.0/s->avctx->rc_buffer_aggressivity);
 408
 409             q= FFMIN(q, bits2qp(rce, FFMAX((min_rate - buffer_size + rcc->buffer_index)*2, 1)));
 410         }
 411
 412         if(max_rate){
 413             double d= 2*expected_size/buffer_size;
 414             if(d>1.0) d=1.0;
 415             else if(d<0.0001) d=0.0001;
 416             q/= pow(d, 1.0/s->avctx->rc_buffer_aggressivity);
 417
 418             q= FFMAX(q, bits2qp(rce, FFMAX(rcc->buffer_index/2, 1)));
 419         }
 420     }
 421 //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);
 422     if(s->avctx->rc_qsquish==0.0 || qmin==qmax){
 423         if     (q<qmin) q=qmin;
 424         else if(q>qmax) q=qmax;
 425     }else{
 426         double min2= log(qmin);
 427         double max2= log(qmax);
 428
 429         q= log(q);
 430         q= (q - min2)/(max2-min2) - 0.5;
 431         q*= -4.0;
 432         q= 1.0/(1.0 + exp(q));
 433         q= q*(max2-min2) + min2;
 434
 435         q= exp(q);
 436     }
 437
 438     return q;
 439 }
 440
 441 //----------------------------------
 442 // 1 Pass Code
 443
 444 static double predict_size(Predictor *p, double q, double var)
 445 {
 446      return p->coeff*var / (q*p->count);
 447 }
 448
 449 /*
 450 static double predict_qp(Predictor *p, double size, double var)
 451 {
 452 //printf("coeff:%f, count:%f, var:%f, size:%f//\n", p->coeff, p->count, var, size);
 453      return p->coeff*var / (size*p->count);
 454 }
 455 */
 456
 457 static void update_predictor(Predictor *p, double q, double var, double size)
 458 {
 459     double new_coeff= size*q / (var + 1);
 460     if(var<10) return;
 461
 462     p->count*= p->decay;
 463     p->coeff*= p->decay;
 464     p->count++;
 465     p->coeff+= new_coeff;
 466 }
 467
 468 static void adaptive_quantization(MpegEncContext *s, double q){
 469     int i;
 470     const float lumi_masking= s->avctx->lumi_masking / (128.0*128.0);
 471     const float dark_masking= s->avctx->dark_masking / (128.0*128.0);
 472     const float temp_cplx_masking= s->avctx->temporal_cplx_masking;
 473     const float spatial_cplx_masking = s->avctx->spatial_cplx_masking;
 474     const float p_masking = s->avctx->p_masking;
 475     float bits_sum= 0.0;
 476     float cplx_sum= 0.0;
 477     float cplx_tab[s->mb_num];
 478     float bits_tab[s->mb_num];
 479     const int qmin= s->avctx->mb_qmin;
 480     const int qmax= s->avctx->mb_qmax;
 481     Picture * const pic= &s->current_picture;
 482     int last_qscale=0;
 483
 484     for(i=0; i<s->mb_num; i++){
 485         const int mb_xy= s->mb_index2xy[i];
 486         float temp_cplx= sqrt(pic->mc_mb_var[mb_xy]);
 487         float spat_cplx= sqrt(pic->mb_var[mb_xy]);
 488         const int lumi= pic->mb_mean[mb_xy];
 489         float bits, cplx, factor;
 490
 491         if(spat_cplx < q/3) spat_cplx= q/3; //FIXME finetune
 492         if(temp_cplx < q/3) temp_cplx= q/3; //FIXME finetune
 493
 494         if((s->mb_type[mb_xy]&MB_TYPE_INTRA)){//FIXME hq mode
 495             cplx= spat_cplx;
 496             factor= 1.0 + p_masking;
 497         }else{
 498             cplx= temp_cplx;
 499             factor= pow(temp_cplx, - temp_cplx_masking);
 500         }
 501         factor*=pow(spat_cplx, - spatial_cplx_masking);
 502
 503         if(lumi>127)
 504             factor*= (1.0 - (lumi-128)*(lumi-128)*lumi_masking);
 505         else
 506             factor*= (1.0 - (lumi-128)*(lumi-128)*dark_masking);
 507
 508         if(factor<0.00001) factor= 0.00001;
 509
 510         bits= cplx*factor;
 511         cplx_sum+= cplx;
 512         bits_sum+= bits;
 513         cplx_tab[i]= cplx;
 514         bits_tab[i]= bits;
 515     }
 516
 517     /* handle qmin/qmax cliping */
 518     if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
 519         for(i=0; i<s->mb_num; i++){
 520             float newq= q*cplx_tab[i]/bits_tab[i];
 521             newq*= bits_sum/cplx_sum;
 522
 523             if     (newq > qmax){
 524                 bits_sum -= bits_tab[i];
 525                 cplx_sum -= cplx_tab[i]*q/qmax;
 526             }
 527             else if(newq < qmin){
 528                 bits_sum -= bits_tab[i];
 529                 cplx_sum -= cplx_tab[i]*q/qmin;
 530             }
 531         }
 532     }
 533
 534     for(i=0; i<s->mb_num; i++){
 535         const int mb_xy= s->mb_index2xy[i];
 536         float newq= q*cplx_tab[i]/bits_tab[i];
 537         int intq;
 538
 539         if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
 540             newq*= bits_sum/cplx_sum;
 541         }
 542
 543         if(i && ABS(last_qscale - newq)<0.75)
 544             intq= last_qscale;
 545         else
 546             intq= (int)(newq + 0.5);
 547
 548         if     (intq > qmax) intq= qmax;
 549         else if(intq < qmin) intq= qmin;
 550 //if(i%s->mb_width==0) printf("\n");
 551 //printf("%2d%3d ", intq, ff_sqrt(s->mc_mb_var[i]));
 552         last_qscale=
 553         pic->qscale_table[mb_xy]= intq;
 554     }
 555 }
 556
 557 float ff_rate_estimate_qscale(MpegEncContext *s)
 558 {
 559     float q;
 560     int qmin, qmax;
 561     float br_compensation;
 562     double diff;
 563     double short_term_q;
 564     double fps;
 565     int picture_number= s->picture_number;
 566     int64_t wanted_bits;
 567     RateControlContext *rcc= &s->rc_context;
 568     RateControlEntry local_rce, *rce;
 569     double bits;
 570     double rate_factor;
 571     int var;
 572     const int pict_type= s->pict_type;
 573     Picture * const pic= &s->current_picture;
 574     emms_c();
 575
 576     get_qminmax(&qmin, &qmax, s, pict_type);
 577
 578     fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base;
 579 //printf("input_pic_num:%d pic_num:%d frame_rate:%d\n", s->input_picture_number, s->picture_number, s->frame_rate);
 580         /* update predictors */
 581     if(picture_number>2){
 582         const int last_var= s->last_pict_type == I_TYPE ? rcc->last_mb_var_sum : rcc->last_mc_mb_var_sum;
 583         update_predictor(&rcc->pred[s->last_pict_type], rcc->last_qscale, sqrt(last_var), s->frame_bits);
 584     }
 585
 586     if(s->flags&CODEC_FLAG_PASS2){
 587         assert(picture_number>=0);
 588         assert(picture_number<rcc->num_entries);
 589         rce= &rcc->entry[picture_number];
 590         wanted_bits= rce->expected_bits;
 591     }else{
 592         rce= &local_rce;
 593         wanted_bits= (uint64_t)(s->bit_rate*(double)picture_number/fps);
 594     }
 595
 596     diff= s->total_bits - wanted_bits;
 597     br_compensation= (s->bit_rate_tolerance - diff)/s->bit_rate_tolerance;
 598     if(br_compensation<=0.0) br_compensation=0.001;
 599
 600     var= pict_type == I_TYPE ? pic->mb_var_sum : pic->mc_mb_var_sum;
 601
 602     if(s->flags&CODEC_FLAG_PASS2){
 603         if(pict_type!=I_TYPE)
 604             assert(pict_type == rce->new_pict_type);
 605
 606         q= rce->new_qscale / br_compensation;
 607 //printf("%f %f %f last:%d var:%d type:%d//\n", q, rce->new_qscale, br_compensation, s->frame_bits, var, pict_type);
 608     }else{
 609         rce->pict_type=
 610         rce->new_pict_type= pict_type;
 611         rce->mc_mb_var_sum= pic->mc_mb_var_sum;
 612         rce->mb_var_sum   = pic->   mb_var_sum;
 613         rce->qscale   = 2;
 614         rce->f_code   = s->f_code;
 615         rce->b_code   = s->b_code;
 616         rce->misc_bits= 1;
 617
 618         if(picture_number>0)
 619             update_rc_buffer(s, s->frame_bits);
 620
 621         bits= predict_size(&rcc->pred[pict_type], rce->qscale, sqrt(var));
 622         if(pict_type== I_TYPE){
 623             rce->i_count   = s->mb_num;
 624             rce->i_tex_bits= bits;
 625             rce->p_tex_bits= 0;
 626             rce->mv_bits= 0;
 627         }else{
 628             rce->i_count   = 0; //FIXME we do know this approx
 629             rce->i_tex_bits= 0;
 630             rce->p_tex_bits= bits*0.9;
 631
 632             rce->mv_bits= bits*0.1;
 633         }
 634         rcc->i_cplx_sum [pict_type] += rce->i_tex_bits*rce->qscale;
 635         rcc->p_cplx_sum [pict_type] += rce->p_tex_bits*rce->qscale;
 636         rcc->mv_bits_sum[pict_type] += rce->mv_bits;
 637         rcc->frame_count[pict_type] ++;
 638
 639         bits= rce->i_tex_bits + rce->p_tex_bits;
 640         rate_factor= rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum * br_compensation;
 641
 642         q= get_qscale(s, rce, rate_factor, picture_number);
 643
 644         assert(q>0.0);
 645 //printf("%f ", q);
 646         q= get_diff_limited_q(s, rce, q);
 647 //printf("%f ", q);
 648         assert(q>0.0);
 649
 650         if(pict_type==P_TYPE || s->intra_only){ //FIXME type dependant blur like in 2-pass
 651             rcc->short_term_qsum*=s->qblur;
 652             rcc->short_term_qcount*=s->qblur;
 653
 654             rcc->short_term_qsum+= q;
 655             rcc->short_term_qcount++;
 656 //printf("%f ", q);
 657             q= short_term_q= rcc->short_term_qsum/rcc->short_term_qcount;
 658 //printf("%f ", q);
 659         }
 660         assert(q>0.0);
 661
 662         q= modify_qscale(s, rce, q, picture_number);
 663
 664         rcc->pass1_wanted_bits+= s->bit_rate/fps;
 665
 666         assert(q>0.0);
 667     }
 668
 669     if(s->avctx->debug&FF_DEBUG_RC){
 670         printf("%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",
 671         ff_get_pict_type_char(pict_type), qmin, q, qmax, picture_number, (int)wanted_bits/1000, (int)s->total_bits/1000,
 672         br_compensation, short_term_q, s->frame_bits, pic->mb_var_sum, pic->mc_mb_var_sum, s->bit_rate/1000, (int)fps
 673         );
 674     }
 675
 676     if     (q<qmin) q=qmin;
 677     else if(q>qmax) q=qmax;
 678
 679     if(s->adaptive_quant)
 680         adaptive_quantization(s, q);
 681     else
 682         q= (int)(q + 0.5);
 683
 684     rcc->last_qscale= q;
 685     rcc->last_mc_mb_var_sum= pic->mc_mb_var_sum;
 686     rcc->last_mb_var_sum= pic->mb_var_sum;
 687 #if 0
 688 {
 689     static int mvsum=0, texsum=0;
 690     mvsum += s->mv_bits;
 691     texsum += s->i_tex_bits + s->p_tex_bits;
 692     printf("%d %d//\n\n", mvsum, texsum);
 693 }
 694 #endif
 695     return q;
 696 }
 697
 698 //----------------------------------------------
 699 // 2-Pass code
 700
 701 static int init_pass2(MpegEncContext *s)
 702 {
 703     RateControlContext *rcc= &s->rc_context;
 704     int i;
 705     double fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base;
 706     double complexity[5]={0,0,0,0,0};   // aproximate bits at quant=1
 707     double avg_quantizer[5];
 708     uint64_t const_bits[5]={0,0,0,0,0}; // quantizer idependant bits
 709     uint64_t available_bits[5];
 710     uint64_t all_const_bits;
 711     uint64_t all_available_bits= (uint64_t)(s->bit_rate*(double)rcc->num_entries/fps);
 712     double rate_factor=0;
 713     double step;
 714     //int last_i_frame=-10000000;
 715     const int filter_size= (int)(s->qblur*4) | 1;
 716     double expected_bits;
 717     double *qscale, *blured_qscale;
 718
 719     /* find complexity & const_bits & decide the pict_types */
 720     for(i=0; i<rcc->num_entries; i++){
 721         RateControlEntry *rce= &rcc->entry[i];
 722
 723         rce->new_pict_type= rce->pict_type;
 724         rcc->i_cplx_sum [rce->pict_type] += rce->i_tex_bits*rce->qscale;
 725         rcc->p_cplx_sum [rce->pict_type] += rce->p_tex_bits*rce->qscale;
 726         rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits;
 727         rcc->frame_count[rce->pict_type] ++;
 728
 729         complexity[rce->new_pict_type]+= (rce->i_tex_bits+ rce->p_tex_bits)*(double)rce->qscale;
 730         const_bits[rce->new_pict_type]+= rce->mv_bits + rce->misc_bits;
 731     }
 732     all_const_bits= const_bits[I_TYPE] + const_bits[P_TYPE] + const_bits[B_TYPE];
 733
 734     if(all_available_bits < all_const_bits){
 735         fprintf(stderr, "requested bitrate is to low\n");
 736         return -1;
 737     }
 738
 739     /* find average quantizers */
 740     avg_quantizer[P_TYPE]=0;
 741     for(step=256*256; step>0.0000001; step*=0.5){
 742         double expected_bits=0;
 743         avg_quantizer[P_TYPE]+= step;
 744
 745         avg_quantizer[I_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->i_quant_factor) + s->avctx->i_quant_offset;
 746         avg_quantizer[B_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
 747
 748         expected_bits=
 749             + all_const_bits
 750             + complexity[I_TYPE]/avg_quantizer[I_TYPE]
 751             + complexity[P_TYPE]/avg_quantizer[P_TYPE]
 752             + complexity[B_TYPE]/avg_quantizer[B_TYPE];
 753
 754         if(expected_bits < all_available_bits) avg_quantizer[P_TYPE]-= step;
 755 //printf("%f %lld %f\n", expected_bits, all_available_bits, avg_quantizer[P_TYPE]);
 756     }
 757 //printf("qp_i:%f, qp_p:%f, qp_b:%f\n", avg_quantizer[I_TYPE],avg_quantizer[P_TYPE],avg_quantizer[B_TYPE]);
 758
 759     for(i=0; i<5; i++){
 760         available_bits[i]= const_bits[i] + complexity[i]/avg_quantizer[i];
 761     }
 762 //printf("%lld %lld %lld %lld\n", available_bits[I_TYPE], available_bits[P_TYPE], available_bits[B_TYPE], all_available_bits);
 763
 764     qscale= av_malloc(sizeof(double)*rcc->num_entries);
 765     blured_qscale= av_malloc(sizeof(double)*rcc->num_entries);
 766
 767     for(step=256*256; step>0.0000001; step*=0.5){
 768         expected_bits=0;
 769         rate_factor+= step;
 770
 771         rcc->buffer_index= s->avctx->rc_buffer_size/2;
 772
 773         /* find qscale */
 774         for(i=0; i<rcc->num_entries; i++){
 775             qscale[i]= get_qscale(s, &rcc->entry[i], rate_factor, i);
 776         }
 777         assert(filter_size%2==1);
 778
 779         /* fixed I/B QP relative to P mode */
 780         for(i=rcc->num_entries-1; i>=0; i--){
 781             RateControlEntry *rce= &rcc->entry[i];
 782
 783             qscale[i]= get_diff_limited_q(s, rce, qscale[i]);
 784         }
 785
 786         /* smooth curve */
 787         for(i=0; i<rcc->num_entries; i++){
 788             RateControlEntry *rce= &rcc->entry[i];
 789             const int pict_type= rce->new_pict_type;
 790             int j;
 791             double q=0.0, sum=0.0;
 792
 793             for(j=0; j<filter_size; j++){
 794                 int index= i+j-filter_size/2;
 795                 double d= index-i;
 796                 double coeff= s->qblur==0 ? 1.0 : exp(-d*d/(s->qblur * s->qblur));
 797
 798                 if(index < 0 || index >= rcc->num_entries) continue;
 799                 if(pict_type != rcc->entry[index].new_pict_type) continue;
 800                 q+= qscale[index] * coeff;
 801                 sum+= coeff;
 802             }
 803             blured_qscale[i]= q/sum;
 804         }
 805
 806         /* find expected bits */
 807         for(i=0; i<rcc->num_entries; i++){
 808             RateControlEntry *rce= &rcc->entry[i];
 809             double bits;
 810             rce->new_qscale= modify_qscale(s, rce, blured_qscale[i], i);
 811             bits= qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;
 812 //printf("%d %f\n", rce->new_bits, blured_qscale[i]);
 813             update_rc_buffer(s, bits);
 814
 815             rce->expected_bits= expected_bits;
 816             expected_bits += bits;
 817         }
 818
 819 //        printf("%f %d %f\n", expected_bits, (int)all_available_bits, rate_factor);
 820         if(expected_bits > all_available_bits) rate_factor-= step;
 821     }
 822     av_free(qscale);
 823     av_free(blured_qscale);
 824
 825     if(abs(expected_bits/all_available_bits - 1.0) > 0.01 ){
 826         fprintf(stderr, "Error: 2pass curve failed to converge\n");
 827         return -1;
 828     }
 829
 830     return 0;
 831 }