libavcodec/ratecontrol.c

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