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->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->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
 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->qmin;
 360     int qmax= s->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->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
 483     for(i=0; i<s->mb_num; i++){
 484         float temp_cplx= sqrt(pic->mc_mb_var[i]);
 485         float spat_cplx= sqrt(pic->mb_var[i]);
 486         const int lumi= pic->mb_mean[i];
 487         float bits, cplx, factor;
 488
 489         if(spat_cplx < q/3) spat_cplx= q/3; //FIXME finetune
 490         if(temp_cplx < q/3) temp_cplx= q/3; //FIXME finetune
 491
 492         if((s->mb_type[i]&MB_TYPE_INTRA)){//FIXME hq mode
 493             cplx= spat_cplx;
 494             factor= 1.0 + p_masking;
 495         }else{
 496             cplx= temp_cplx;
 497             factor= pow(temp_cplx, - temp_cplx_masking);
 498         }
 499         factor*=pow(spat_cplx, - spatial_cplx_masking);
 500
 501         if(lumi>127)
 502             factor*= (1.0 - (lumi-128)*(lumi-128)*lumi_masking);
 503         else
 504             factor*= (1.0 - (lumi-128)*(lumi-128)*dark_masking);
 505
 506         if(factor<0.00001) factor= 0.00001;
 507
 508         bits= cplx*factor;
 509         cplx_sum+= cplx;
 510         bits_sum+= bits;
 511         cplx_tab[i]= cplx;
 512         bits_tab[i]= bits;
 513     }
 514
 515     /* handle qmin/qmax cliping */
 516     if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
 517         for(i=0; i<s->mb_num; i++){
 518             float newq= q*cplx_tab[i]/bits_tab[i];
 519             newq*= bits_sum/cplx_sum;
 520
 521             if     (newq > qmax){
 522                 bits_sum -= bits_tab[i];
 523                 cplx_sum -= cplx_tab[i]*q/qmax;
 524             }
 525             else if(newq < qmin){
 526                 bits_sum -= bits_tab[i];
 527                 cplx_sum -= cplx_tab[i]*q/qmin;
 528             }
 529         }
 530     }
 531
 532     for(i=0; i<s->mb_num; i++){
 533         float newq= q*cplx_tab[i]/bits_tab[i];
 534         int intq;
 535
 536         if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
 537             newq*= bits_sum/cplx_sum;
 538         }
 539
 540         if(i && ABS(pic->qscale_table[i-1] - newq)<0.75)
 541             intq= pic->qscale_table[i-1];
 542         else
 543             intq= (int)(newq + 0.5);
 544
 545         if     (intq > qmax) intq= qmax;
 546         else if(intq < qmin) intq= qmin;
 547 //if(i%s->mb_width==0) printf("\n");
 548 //printf("%2d%3d ", intq, ff_sqrt(s->mc_mb_var[i]));
 549         pic->qscale_table[i]= intq;
 550     }
 551 }
 552
 553 float ff_rate_estimate_qscale(MpegEncContext *s)
 554 {
 555     float q;
 556     int qmin, qmax;
 557     float br_compensation;
 558     double diff;
 559     double short_term_q;
 560     double fps;
 561     int picture_number= s->picture_number;
 562     int64_t wanted_bits;
 563     RateControlContext *rcc= &s->rc_context;
 564     RateControlEntry local_rce, *rce;
 565     double bits;
 566     double rate_factor;
 567     int var;
 568     const int pict_type= s->pict_type;
 569     Picture * const pic= &s->current_picture;
 570     emms_c();
 571
 572     get_qminmax(&qmin, &qmax, s, pict_type);
 573
 574     fps= (double)s->frame_rate / FRAME_RATE_BASE;
 575 //printf("input_pic_num:%d pic_num:%d frame_rate:%d\n", s->input_picture_number, s->picture_number, s->frame_rate);
 576         /* update predictors */
 577     if(picture_number>2){
 578         const int last_var= s->last_pict_type == I_TYPE ? rcc->last_mb_var_sum : rcc->last_mc_mb_var_sum;
 579         update_predictor(&rcc->pred[s->last_pict_type], rcc->last_qscale, sqrt(last_var), s->frame_bits);
 580     }
 581
 582     if(s->flags&CODEC_FLAG_PASS2){
 583         assert(picture_number>=0);
 584         assert(picture_number<rcc->num_entries);
 585         rce= &rcc->entry[picture_number];
 586         wanted_bits= rce->expected_bits;
 587     }else{
 588         rce= &local_rce;
 589         wanted_bits= (uint64_t)(s->bit_rate*(double)picture_number/fps);
 590     }
 591
 592     diff= s->total_bits - wanted_bits;
 593     br_compensation= (s->bit_rate_tolerance - diff)/s->bit_rate_tolerance;
 594     if(br_compensation<=0.0) br_compensation=0.001;
 595
 596     var= pict_type == I_TYPE ? pic->mb_var_sum : pic->mc_mb_var_sum;
 597
 598     if(s->flags&CODEC_FLAG_PASS2){
 599         if(pict_type!=I_TYPE)
 600             assert(pict_type == rce->new_pict_type);
 601
 602         q= rce->new_qscale / br_compensation;
 603 //printf("%f %f %f last:%d var:%d type:%d//\n", q, rce->new_qscale, br_compensation, s->frame_bits, var, pict_type);
 604     }else{
 605         rce->pict_type=
 606         rce->new_pict_type= pict_type;
 607         rce->mc_mb_var_sum= pic->mc_mb_var_sum;
 608         rce->mb_var_sum   = pic->   mb_var_sum;
 609         rce->qscale   = 2;
 610         rce->f_code   = s->f_code;
 611         rce->b_code   = s->b_code;
 612         rce->misc_bits= 1;
 613
 614         if(picture_number>0)
 615             update_rc_buffer(s, s->frame_bits);
 616
 617         bits= predict_size(&rcc->pred[pict_type], rce->qscale, sqrt(var));
 618         if(pict_type== I_TYPE){
 619             rce->i_count   = s->mb_num;
 620             rce->i_tex_bits= bits;
 621             rce->p_tex_bits= 0;
 622             rce->mv_bits= 0;
 623         }else{
 624             rce->i_count   = 0; //FIXME we do know this approx
 625             rce->i_tex_bits= 0;
 626             rce->p_tex_bits= bits*0.9;
 627
 628             rce->mv_bits= bits*0.1;
 629         }
 630         rcc->i_cplx_sum [pict_type] += rce->i_tex_bits*rce->qscale;
 631         rcc->p_cplx_sum [pict_type] += rce->p_tex_bits*rce->qscale;
 632         rcc->mv_bits_sum[pict_type] += rce->mv_bits;
 633         rcc->frame_count[pict_type] ++;
 634
 635         bits= rce->i_tex_bits + rce->p_tex_bits;
 636         rate_factor= rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum * br_compensation;
 637
 638         q= get_qscale(s, rce, rate_factor, picture_number);
 639
 640         assert(q>0.0);
 641 //printf("%f ", q);
 642         q= get_diff_limited_q(s, rce, q);
 643 //printf("%f ", q);
 644         assert(q>0.0);
 645
 646         if(pict_type==P_TYPE || s->intra_only){ //FIXME type dependant blur like in 2-pass
 647             rcc->short_term_qsum*=s->qblur;
 648             rcc->short_term_qcount*=s->qblur;
 649
 650             rcc->short_term_qsum+= q;
 651             rcc->short_term_qcount++;
 652 //printf("%f ", q);
 653             q= short_term_q= rcc->short_term_qsum/rcc->short_term_qcount;
 654 //printf("%f ", q);
 655         }
 656         assert(q>0.0);
 657
 658         q= modify_qscale(s, rce, q, picture_number);
 659
 660         rcc->pass1_wanted_bits+= s->bit_rate/fps;
 661
 662         assert(q>0.0);
 663     }
 664
 665     if(s->avctx->debug&FF_DEBUG_RC){
 666         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",
 667         ff_get_pict_type_char(pict_type), qmin, q, qmax, picture_number, (int)wanted_bits/1000, (int)s->total_bits/1000,
 668         br_compensation, short_term_q, s->frame_bits, pic->mb_var_sum, pic->mc_mb_var_sum, s->bit_rate/1000, (int)fps
 669         );
 670     }
 671
 672     if     (q<qmin) q=qmin;
 673     else if(q>qmax) q=qmax;
 674
 675     if(s->adaptive_quant)
 676         adaptive_quantization(s, q);
 677     else
 678         q= (int)(q + 0.5);
 679
 680     rcc->last_qscale= q;
 681     rcc->last_mc_mb_var_sum= pic->mc_mb_var_sum;
 682     rcc->last_mb_var_sum= pic->mb_var_sum;
 683 #if 0
 684 {
 685     static int mvsum=0, texsum=0;
 686     mvsum += s->mv_bits;
 687     texsum += s->i_tex_bits + s->p_tex_bits;
 688     printf("%d %d//\n\n", mvsum, texsum);
 689 }
 690 #endif
 691     return q;
 692 }
 693
 694 //----------------------------------------------
 695 // 2-Pass code
 696
 697 static int init_pass2(MpegEncContext *s)
 698 {
 699     RateControlContext *rcc= &s->rc_context;
 700     int i;
 701     double fps= (double)s->frame_rate / FRAME_RATE_BASE;
 702     double complexity[5]={0,0,0,0,0};   // aproximate bits at quant=1
 703     double avg_quantizer[5];
 704     uint64_t const_bits[5]={0,0,0,0,0}; // quantizer idependant bits
 705     uint64_t available_bits[5];
 706     uint64_t all_const_bits;
 707     uint64_t all_available_bits= (uint64_t)(s->bit_rate*(double)rcc->num_entries/fps);
 708     double rate_factor=0;
 709     double step;
 710     //int last_i_frame=-10000000;
 711     const int filter_size= (int)(s->qblur*4) | 1;
 712     double expected_bits;
 713     double *qscale, *blured_qscale;
 714
 715     /* find complexity & const_bits & decide the pict_types */
 716     for(i=0; i<rcc->num_entries; i++){
 717         RateControlEntry *rce= &rcc->entry[i];
 718
 719         rce->new_pict_type= rce->pict_type;
 720         rcc->i_cplx_sum [rce->pict_type] += rce->i_tex_bits*rce->qscale;
 721         rcc->p_cplx_sum [rce->pict_type] += rce->p_tex_bits*rce->qscale;
 722         rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits;
 723         rcc->frame_count[rce->pict_type] ++;
 724
 725         complexity[rce->new_pict_type]+= (rce->i_tex_bits+ rce->p_tex_bits)*(double)rce->qscale;
 726         const_bits[rce->new_pict_type]+= rce->mv_bits + rce->misc_bits;
 727     }
 728     all_const_bits= const_bits[I_TYPE] + const_bits[P_TYPE] + const_bits[B_TYPE];
 729
 730     if(all_available_bits < all_const_bits){
 731         fprintf(stderr, "requested bitrate is to low\n");
 732         return -1;
 733     }
 734
 735     /* find average quantizers */
 736     avg_quantizer[P_TYPE]=0;
 737     for(step=256*256; step>0.0000001; step*=0.5){
 738         double expected_bits=0;
 739         avg_quantizer[P_TYPE]+= step;
 740
 741         avg_quantizer[I_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->i_quant_factor) + s->avctx->i_quant_offset;
 742         avg_quantizer[B_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
 743
 744         expected_bits=
 745             + all_const_bits
 746             + complexity[I_TYPE]/avg_quantizer[I_TYPE]
 747             + complexity[P_TYPE]/avg_quantizer[P_TYPE]
 748             + complexity[B_TYPE]/avg_quantizer[B_TYPE];
 749
 750         if(expected_bits < all_available_bits) avg_quantizer[P_TYPE]-= step;
 751 //printf("%f %lld %f\n", expected_bits, all_available_bits, avg_quantizer[P_TYPE]);
 752     }
 753 //printf("qp_i:%f, qp_p:%f, qp_b:%f\n", avg_quantizer[I_TYPE],avg_quantizer[P_TYPE],avg_quantizer[B_TYPE]);
 754
 755     for(i=0; i<5; i++){
 756         available_bits[i]= const_bits[i] + complexity[i]/avg_quantizer[i];
 757     }
 758 //printf("%lld %lld %lld %lld\n", available_bits[I_TYPE], available_bits[P_TYPE], available_bits[B_TYPE], all_available_bits);
 759
 760     qscale= malloc(sizeof(double)*rcc->num_entries);
 761     blured_qscale= malloc(sizeof(double)*rcc->num_entries);
 762
 763     for(step=256*256; step>0.0000001; step*=0.5){
 764         expected_bits=0;
 765         rate_factor+= step;
 766
 767         rcc->buffer_index= s->avctx->rc_buffer_size/2;
 768
 769         /* find qscale */
 770         for(i=0; i<rcc->num_entries; i++){
 771             qscale[i]= get_qscale(s, &rcc->entry[i], rate_factor, i);
 772         }
 773         assert(filter_size%2==1);
 774
 775         /* fixed I/B QP relative to P mode */
 776         for(i=rcc->num_entries-1; i>=0; i--){
 777             RateControlEntry *rce= &rcc->entry[i];
 778
 779             qscale[i]= get_diff_limited_q(s, rce, qscale[i]);
 780         }
 781
 782         /* smooth curve */
 783         for(i=0; i<rcc->num_entries; i++){
 784             RateControlEntry *rce= &rcc->entry[i];
 785             const int pict_type= rce->new_pict_type;
 786             int j;
 787             double q=0.0, sum=0.0;
 788
 789             for(j=0; j<filter_size; j++){
 790                 int index= i+j-filter_size/2;
 791                 double d= index-i;
 792                 double coeff= s->qblur==0 ? 1.0 : exp(-d*d/(s->qblur * s->qblur));
 793
 794                 if(index < 0 || index >= rcc->num_entries) continue;
 795                 if(pict_type != rcc->entry[index].new_pict_type) continue;
 796                 q+= qscale[index] * coeff;
 797                 sum+= coeff;
 798             }
 799             blured_qscale[i]= q/sum;
 800         }
 801
 802         /* find expected bits */
 803         for(i=0; i<rcc->num_entries; i++){
 804             RateControlEntry *rce= &rcc->entry[i];
 805             double bits;
 806             rce->new_qscale= modify_qscale(s, rce, blured_qscale[i], i);
 807             bits= qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;
 808 //printf("%d %f\n", rce->new_bits, blured_qscale[i]);
 809             update_rc_buffer(s, bits);
 810
 811             rce->expected_bits= expected_bits;
 812             expected_bits += bits;
 813         }
 814
 815 //        printf("%f %d %f\n", expected_bits, (int)all_available_bits, rate_factor);
 816         if(expected_bits > all_available_bits) rate_factor-= step;
 817     }
 818     free(qscale);
 819     free(blured_qscale);
 820
 821     if(abs(expected_bits/all_available_bits - 1.0) > 0.01 ){
 822         fprintf(stderr, "Error: 2pass curve failed to converge\n");
 823         return -1;
 824     }
 825
 826     return 0;
 827 }