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