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

   1 /*
   2  * Rate control for video encoders
   3  *
   4  * Copyright (c) 2002 Michael Niedermayer <michaelni@gmx.at>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 /**
  22  * @file ratecontrol.c
  23  * Rate control for video encoders.
  24  */
  25
  26 #include "avcodec.h"
  27 #include "dsputil.h"
  28 #include "mpegvideo.h"
  29
  30 #undef NDEBUG // allways check asserts, the speed effect is far too small to disable them
  31 #include <assert.h>
  32
  33 #ifndef M_E
  34 #define M_E 2.718281828
  35 #endif
  36
  37 static int init_pass2(MpegEncContext *s);
  38 static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_factor, int frame_num);
  39
  40 void ff_write_pass1_stats(MpegEncContext *s){
  41     sprintf(s->avctx->stats_out, "in:%d out:%d type:%d q:%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_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=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                 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   = 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         fprintf(stderr, "qp<=0.0\n");
 187     }
 188     return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits+1)/ qp;
 189 }
 190
 191 static inline double bits2qp(RateControlEntry *rce, double bits){
 192     if(bits<0.9){
 193         fprintf(stderr, "bits<0.9\n");
 194     }
 195     return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits+1)/ bits;
 196 }
 197
 198 static void update_rc_buffer(MpegEncContext *s, int frame_size){
 199     RateControlContext *rcc= &s->rc_context;
 200     const double fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base;
 201     const double buffer_size= s->avctx->rc_buffer_size;
 202     const double min_rate= s->avctx->rc_min_rate/fps;
 203     const double max_rate= s->avctx->rc_max_rate/fps;
 204
 205     if(buffer_size){
 206         rcc->buffer_index-= frame_size;
 207         if(rcc->buffer_index < buffer_size/2 /*FIXME /2 */ || min_rate==0){
 208             rcc->buffer_index+= max_rate;
 209             if(rcc->buffer_index >= buffer_size)
 210                 rcc->buffer_index= buffer_size-1;
 211         }else{
 212             rcc->buffer_index+= min_rate;
 213         }
 214
 215         if(rcc->buffer_index < 0)
 216             fprintf(stderr, "rc buffer underflow\n");
 217         if(rcc->buffer_index >= s->avctx->rc_buffer_size)
 218             fprintf(stderr, "rc buffer overflow\n");
 219     }
 220 }
 221
 222 /**
 223  * modifies the bitrate curve from pass1 for one frame
 224  */
 225 static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_factor, int frame_num){
 226     RateControlContext *rcc= &s->rc_context;
 227     double q, bits;
 228     const int pict_type= rce->new_pict_type;
 229     const double mb_num= s->mb_num;
 230     int i;
 231
 232     double const_values[]={
 233         M_PI,
 234         M_E,
 235         rce->i_tex_bits*rce->qscale,
 236         rce->p_tex_bits*rce->qscale,
 237         (rce->i_tex_bits + rce->p_tex_bits)*(double)rce->qscale,
 238         rce->mv_bits/mb_num,
 239         rce->pict_type == B_TYPE ? (rce->f_code + rce->b_code)*0.5 : rce->f_code,
 240         rce->i_count/mb_num,
 241         rce->mc_mb_var_sum/mb_num,
 242         rce->mb_var_sum/mb_num,
 243         rce->pict_type == I_TYPE,
 244         rce->pict_type == P_TYPE,
 245         rce->pict_type == B_TYPE,
 246         rcc->qscale_sum[pict_type] / (double)rcc->frame_count[pict_type],
 247         s->qcompress,
 248 /*        rcc->last_qscale_for[I_TYPE],
 249         rcc->last_qscale_for[P_TYPE],
 250         rcc->last_qscale_for[B_TYPE],
 251         rcc->next_non_b_qscale,*/
 252         rcc->i_cplx_sum[I_TYPE] / (double)rcc->frame_count[I_TYPE],
 253         rcc->i_cplx_sum[P_TYPE] / (double)rcc->frame_count[P_TYPE],
 254         rcc->p_cplx_sum[P_TYPE] / (double)rcc->frame_count[P_TYPE],
 255         rcc->p_cplx_sum[B_TYPE] / (double)rcc->frame_count[B_TYPE],
 256         (rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / (double)rcc->frame_count[pict_type],
 257         0
 258     };
 259     static const char *const_names[]={
 260         "PI",
 261         "E",
 262         "iTex",
 263         "pTex",
 264         "tex",
 265         "mv",
 266         "fCode",
 267         "iCount",
 268         "mcVar",
 269         "var",
 270         "isI",
 271         "isP",
 272         "isB",
 273         "avgQP",
 274         "qComp",
 275 /*        "lastIQP",
 276         "lastPQP",
 277         "lastBQP",
 278         "nextNonBQP",*/
 279         "avgIITex",
 280         "avgPITex",
 281         "avgPPTex",
 282         "avgBPTex",
 283         "avgTex",
 284         NULL
 285     };
 286     static double (*func1[])(void *, double)={
 287         (void *)bits2qp,
 288         (void *)qp2bits,
 289         NULL
 290     };
 291     static const char *func1_names[]={
 292         "bits2qp",
 293         "qp2bits",
 294         NULL
 295     };
 296
 297     bits= ff_eval(s->avctx->rc_eq, const_values, const_names, func1, func1_names, NULL, NULL, rce);
 298
 299     rcc->pass1_rc_eq_output_sum+= bits;
 300     bits*=rate_factor;
 301     if(bits<0.0) bits=0.0;
 302     bits+= 1.0; //avoid 1/0 issues
 303
 304     /* user override */
 305     for(i=0; i<s->avctx->rc_override_count; i++){
 306         RcOverride *rco= s->avctx->rc_override;
 307         if(rco[i].start_frame > frame_num) continue;
 308         if(rco[i].end_frame   < frame_num) continue;
 309
 310         if(rco[i].qscale)
 311             bits= qp2bits(rce, rco[i].qscale); //FIXME move at end to really force it?
 312         else
 313             bits*= rco[i].quality_factor;
 314     }
 315
 316     q= bits2qp(rce, bits);
 317
 318     /* I/B difference */
 319     if     (pict_type==I_TYPE && s->avctx->i_quant_factor<0.0)
 320         q= -q*s->avctx->i_quant_factor + s->avctx->i_quant_offset;
 321     else if(pict_type==B_TYPE && s->avctx->b_quant_factor<0.0)
 322         q= -q*s->avctx->b_quant_factor + s->avctx->b_quant_offset;
 323
 324     return q;
 325 }
 326
 327 static double get_diff_limited_q(MpegEncContext *s, RateControlEntry *rce, double q){
 328     RateControlContext *rcc= &s->rc_context;
 329     AVCodecContext *a= s->avctx;
 330     const int pict_type= rce->new_pict_type;
 331     const double last_p_q    = rcc->last_qscale_for[P_TYPE];
 332     const double last_non_b_q= rcc->last_qscale_for[rcc->last_non_b_pict_type];
 333
 334     if     (pict_type==I_TYPE && (a->i_quant_factor>0.0 || rcc->last_non_b_pict_type==P_TYPE))
 335         q= last_p_q    *ABS(a->i_quant_factor) + a->i_quant_offset;
 336     else if(pict_type==B_TYPE && a->b_quant_factor>0.0)
 337         q= last_non_b_q*    a->b_quant_factor  + a->b_quant_offset;
 338
 339     /* last qscale / qdiff stuff */
 340     if(rcc->last_non_b_pict_type==pict_type || pict_type!=I_TYPE){
 341         double last_q= rcc->last_qscale_for[pict_type];
 342         const int maxdiff= FF_QP2LAMBDA * a->max_qdiff;
 343
 344         if     (q > last_q + maxdiff) q= last_q + maxdiff;
 345         else if(q < last_q - maxdiff) q= last_q - maxdiff;
 346     }
 347
 348     rcc->last_qscale_for[pict_type]= q; //Note we cant do that after blurring
 349
 350     if(pict_type!=B_TYPE)
 351         rcc->last_non_b_pict_type= pict_type;
 352
 353     return q;
 354 }
 355
 356 /**
 357  * gets the qmin & qmax for pict_type
 358  */
 359 static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type){
 360     int qmin= s->avctx->lmin;
 361     int qmax= s->avctx->lmax;
 362
 363     assert(qmin <= qmax);
 364
 365     if(pict_type==B_TYPE){
 366         qmin= (int)(qmin*ABS(s->avctx->b_quant_factor)+s->avctx->b_quant_offset + 0.5);
 367         qmax= (int)(qmax*ABS(s->avctx->b_quant_factor)+s->avctx->b_quant_offset + 0.5);
 368     }else if(pict_type==I_TYPE){
 369         qmin= (int)(qmin*ABS(s->avctx->i_quant_factor)+s->avctx->i_quant_offset + 0.5);
 370         qmax= (int)(qmax*ABS(s->avctx->i_quant_factor)+s->avctx->i_quant_offset + 0.5);
 371     }
 372
 373     qmin= clip(qmin, 1, FF_LAMBDA_MAX);
 374     qmax= clip(qmax, 1, FF_LAMBDA_MAX);
 375
 376     if(qmax<qmin) qmax= qmin;
 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->lmin;
 480     const int qmax= s->avctx->lmax;
 481     Picture * const pic= &s->current_picture;
 482
 483     for(i=0; i<s->mb_num; i++){
 484         const int mb_xy= s->mb_index2xy[i];
 485         float temp_cplx= sqrt(pic->mc_mb_var[mb_xy]); //FIXME merge in pow()
 486         float spat_cplx= sqrt(pic->mb_var[mb_xy]);
 487         const int lumi= pic->mb_mean[mb_xy];
 488         float bits, cplx, factor;
 489 #if 0
 490         if(spat_cplx < q/3) spat_cplx= q/3; //FIXME finetune
 491         if(temp_cplx < q/3) temp_cplx= q/3; //FIXME finetune
 492 #endif
 493         if(spat_cplx < 4) spat_cplx= 4; //FIXME finetune
 494         if(temp_cplx < 4) temp_cplx= 4; //FIXME finetune
 495
 496         if((s->mb_type[mb_xy]&MB_TYPE_INTRA)){//FIXME hq mode
 497             cplx= spat_cplx;
 498             factor= 1.0 + p_masking;
 499         }else{
 500             cplx= temp_cplx;
 501             factor= pow(temp_cplx, - temp_cplx_masking);
 502         }
 503         factor*=pow(spat_cplx, - spatial_cplx_masking);
 504
 505         if(lumi>127)
 506             factor*= (1.0 - (lumi-128)*(lumi-128)*lumi_masking);
 507         else
 508             factor*= (1.0 - (lumi-128)*(lumi-128)*dark_masking);
 509
 510         if(factor<0.00001) factor= 0.00001;
 511
 512         bits= cplx*factor;
 513         cplx_sum+= cplx;
 514         bits_sum+= bits;
 515         cplx_tab[i]= cplx;
 516         bits_tab[i]= bits;
 517     }
 518
 519     /* handle qmin/qmax cliping */
 520     if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
 521         for(i=0; i<s->mb_num; i++){
 522             float newq= q*cplx_tab[i]/bits_tab[i];
 523             newq*= bits_sum/cplx_sum;
 524
 525             if     (newq > qmax){
 526                 bits_sum -= bits_tab[i];
 527                 cplx_sum -= cplx_tab[i]*q/qmax;
 528             }
 529             else if(newq < qmin){
 530                 bits_sum -= bits_tab[i];
 531                 cplx_sum -= cplx_tab[i]*q/qmin;
 532             }
 533         }
 534     }
 535
 536     for(i=0; i<s->mb_num; i++){
 537         const int mb_xy= s->mb_index2xy[i];
 538         float newq= q*cplx_tab[i]/bits_tab[i];
 539         int intq;
 540
 541         if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
 542             newq*= bits_sum/cplx_sum;
 543         }
 544
 545         intq= (int)(newq + 0.5);
 546
 547         if     (intq > qmax) intq= qmax;
 548         else if(intq < qmin) intq= qmin;
 549 //if(i%s->mb_width==0) printf("\n");
 550 //printf("%2d%3d ", intq, ff_sqrt(s->mc_mb_var[i]));
 551         s->lambda_table[mb_xy]= intq;
 552     }
 553 }
 554 //FIXME rd or at least approx for dquant
 555
 556 float ff_rate_estimate_qscale(MpegEncContext *s)
 557 {
 558     float q;
 559     int qmin, qmax;
 560     float br_compensation;
 561     double diff;
 562     double short_term_q;
 563     double fps;
 564     int picture_number= s->picture_number;
 565     int64_t wanted_bits;
 566     RateControlContext *rcc= &s->rc_context;
 567     RateControlEntry local_rce, *rce;
 568     double bits;
 569     double rate_factor;
 570     int var;
 571     const int pict_type= s->pict_type;
 572     Picture * const pic= &s->current_picture;
 573     emms_c();
 574
 575     get_qminmax(&qmin, &qmax, s, pict_type);
 576
 577     fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base;
 578 //printf("input_pic_num:%d pic_num:%d frame_rate:%d\n", s->input_picture_number, s->picture_number, s->frame_rate);
 579         /* update predictors */
 580     if(picture_number>2){
 581         const int last_var= s->last_pict_type == I_TYPE ? rcc->last_mb_var_sum : rcc->last_mc_mb_var_sum;
 582         update_predictor(&rcc->pred[s->last_pict_type], rcc->last_qscale, sqrt(last_var), s->frame_bits);
 583     }
 584
 585     if(s->flags&CODEC_FLAG_PASS2){
 586         assert(picture_number>=0);
 587         assert(picture_number<rcc->num_entries);
 588         rce= &rcc->entry[picture_number];
 589         wanted_bits= rce->expected_bits;
 590     }else{
 591         rce= &local_rce;
 592         wanted_bits= (uint64_t)(s->bit_rate*(double)picture_number/fps);
 593     }
 594
 595     diff= s->total_bits - wanted_bits;
 596     br_compensation= (s->bit_rate_tolerance - diff)/s->bit_rate_tolerance;
 597     if(br_compensation<=0.0) br_compensation=0.001;
 598
 599     var= pict_type == I_TYPE ? pic->mb_var_sum : pic->mc_mb_var_sum;
 600
 601     short_term_q = 0; /* avoid warning */
 602     if(s->flags&CODEC_FLAG_PASS2){
 603         if(pict_type!=I_TYPE)
 604             assert(pict_type == rce->new_pict_type);
 605
 606         q= rce->new_qscale / br_compensation;
 607 //printf("%f %f %f last:%d var:%d type:%d//\n", q, rce->new_qscale, br_compensation, s->frame_bits, var, pict_type);
 608     }else{
 609         rce->pict_type=
 610         rce->new_pict_type= pict_type;
 611         rce->mc_mb_var_sum= pic->mc_mb_var_sum;
 612         rce->mb_var_sum   = pic->   mb_var_sum;
 613         rce->qscale   = FF_QP2LAMBDA * 2;
 614         rce->f_code   = s->f_code;
 615         rce->b_code   = s->b_code;
 616         rce->misc_bits= 1;
 617
 618         if(picture_number>0)
 619             update_rc_buffer(s, s->frame_bits);
 620
 621         bits= predict_size(&rcc->pred[pict_type], rce->qscale, sqrt(var));
 622         if(pict_type== I_TYPE){
 623             rce->i_count   = s->mb_num;
 624             rce->i_tex_bits= bits;
 625             rce->p_tex_bits= 0;
 626             rce->mv_bits= 0;
 627         }else{
 628             rce->i_count   = 0; //FIXME we do know this approx
 629             rce->i_tex_bits= 0;
 630             rce->p_tex_bits= bits*0.9;
 631
 632             rce->mv_bits= bits*0.1;
 633         }
 634         rcc->i_cplx_sum [pict_type] += rce->i_tex_bits*rce->qscale;
 635         rcc->p_cplx_sum [pict_type] += rce->p_tex_bits*rce->qscale;
 636         rcc->mv_bits_sum[pict_type] += rce->mv_bits;
 637         rcc->frame_count[pict_type] ++;
 638
 639         bits= rce->i_tex_bits + rce->p_tex_bits;
 640         rate_factor= rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum * br_compensation;
 641
 642         q= get_qscale(s, rce, rate_factor, picture_number);
 643
 644         assert(q>0.0);
 645 //printf("%f ", q);
 646         q= get_diff_limited_q(s, rce, q);
 647 //printf("%f ", q);
 648         assert(q>0.0);
 649
 650         if(pict_type==P_TYPE || s->intra_only){ //FIXME type dependant blur like in 2-pass
 651             rcc->short_term_qsum*=s->qblur;
 652             rcc->short_term_qcount*=s->qblur;
 653
 654             rcc->short_term_qsum+= q;
 655             rcc->short_term_qcount++;
 656 //printf("%f ", q);
 657             q= short_term_q= rcc->short_term_qsum/rcc->short_term_qcount;
 658 //printf("%f ", q);
 659         }
 660         assert(q>0.0);
 661
 662         q= modify_qscale(s, rce, q, picture_number);
 663
 664         rcc->pass1_wanted_bits+= s->bit_rate/fps;
 665
 666         assert(q>0.0);
 667     }
 668
 669     if(s->avctx->debug&FF_DEBUG_RC){
 670         printf("%c qp:%d<%2.1f<%d %d want:%d total:%d comp:%f st_q:%2.2f size:%d var:%d/%d br:%d fps:%d\n",
 671         av_get_pict_type_char(pict_type), qmin, q, qmax, picture_number, (int)wanted_bits/1000, (int)s->total_bits/1000,
 672         br_compensation, short_term_q, s->frame_bits, pic->mb_var_sum, pic->mc_mb_var_sum, s->bit_rate/1000, (int)fps
 673         );
 674     }
 675
 676     if     (q<qmin) q=qmin;
 677     else if(q>qmax) q=qmax;
 678
 679     if(s->adaptive_quant)
 680         adaptive_quantization(s, q);
 681     else
 682         q= (int)(q + 0.5);
 683
 684     rcc->last_qscale= q;
 685     rcc->last_mc_mb_var_sum= pic->mc_mb_var_sum;
 686     rcc->last_mb_var_sum= pic->mb_var_sum;
 687 #if 0
 688 {
 689     static int mvsum=0, texsum=0;
 690     mvsum += s->mv_bits;
 691     texsum += s->i_tex_bits + s->p_tex_bits;
 692     printf("%d %d//\n\n", mvsum, texsum);
 693 }
 694 #endif
 695     return q;
 696 }
 697
 698 //----------------------------------------------
 699 // 2-Pass code
 700
 701 static int init_pass2(MpegEncContext *s)
 702 {
 703     RateControlContext *rcc= &s->rc_context;
 704     int i;
 705     double fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base;
 706     double complexity[5]={0,0,0,0,0};   // aproximate bits at quant=1
 707     double avg_quantizer[5];
 708     uint64_t const_bits[5]={0,0,0,0,0}; // quantizer idependant bits
 709     uint64_t available_bits[5];
 710     uint64_t all_const_bits;
 711     uint64_t all_available_bits= (uint64_t)(s->bit_rate*(double)rcc->num_entries/fps);
 712     double rate_factor=0;
 713     double step;
 714     //int last_i_frame=-10000000;
 715     const int filter_size= (int)(s->qblur*4) | 1;
 716     double expected_bits;
 717     double *qscale, *blured_qscale;
 718
 719     /* find complexity & const_bits & decide the pict_types */
 720     for(i=0; i<rcc->num_entries; i++){
 721         RateControlEntry *rce= &rcc->entry[i];
 722
 723         rce->new_pict_type= rce->pict_type;
 724         rcc->i_cplx_sum [rce->pict_type] += rce->i_tex_bits*rce->qscale;
 725         rcc->p_cplx_sum [rce->pict_type] += rce->p_tex_bits*rce->qscale;
 726         rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits;
 727         rcc->frame_count[rce->pict_type] ++;
 728
 729         complexity[rce->new_pict_type]+= (rce->i_tex_bits+ rce->p_tex_bits)*(double)rce->qscale;
 730         const_bits[rce->new_pict_type]+= rce->mv_bits + rce->misc_bits;
 731     }
 732     all_const_bits= const_bits[I_TYPE] + const_bits[P_TYPE] + const_bits[B_TYPE];
 733
 734     if(all_available_bits < all_const_bits){
 735         fprintf(stderr, "requested bitrate is to low\n");
 736         return -1;
 737     }
 738
 739     /* find average quantizers */
 740     avg_quantizer[P_TYPE]=0;
 741     for(step=256*256; step>0.0000001; step*=0.5){
 742         double expected_bits=0;
 743         avg_quantizer[P_TYPE]+= step;
 744
 745         avg_quantizer[I_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->i_quant_factor) + s->avctx->i_quant_offset;
 746         avg_quantizer[B_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
 747
 748         expected_bits=
 749             + all_const_bits
 750             + complexity[I_TYPE]/avg_quantizer[I_TYPE]
 751             + complexity[P_TYPE]/avg_quantizer[P_TYPE]
 752             + complexity[B_TYPE]/avg_quantizer[B_TYPE];
 753
 754         if(expected_bits < all_available_bits) avg_quantizer[P_TYPE]-= step;
 755 //printf("%f %lld %f\n", expected_bits, all_available_bits, avg_quantizer[P_TYPE]);
 756     }
 757 //printf("qp_i:%f, qp_p:%f, qp_b:%f\n", avg_quantizer[I_TYPE],avg_quantizer[P_TYPE],avg_quantizer[B_TYPE]);
 758
 759     for(i=0; i<5; i++){
 760         available_bits[i]= const_bits[i] + complexity[i]/avg_quantizer[i];
 761     }
 762 //printf("%lld %lld %lld %lld\n", available_bits[I_TYPE], available_bits[P_TYPE], available_bits[B_TYPE], all_available_bits);
 763
 764     qscale= av_malloc(sizeof(double)*rcc->num_entries);
 765     blured_qscale= av_malloc(sizeof(double)*rcc->num_entries);
 766
 767     for(step=256*256; step>0.0000001; step*=0.5){
 768         expected_bits=0;
 769         rate_factor+= step;
 770
 771         rcc->buffer_index= s->avctx->rc_buffer_size/2;
 772
 773         /* find qscale */
 774         for(i=0; i<rcc->num_entries; i++){
 775             qscale[i]= get_qscale(s, &rcc->entry[i], rate_factor, i);
 776         }
 777         assert(filter_size%2==1);
 778
 779         /* fixed I/B QP relative to P mode */
 780         for(i=rcc->num_entries-1; i>=0; i--){
 781             RateControlEntry *rce= &rcc->entry[i];
 782
 783             qscale[i]= get_diff_limited_q(s, rce, qscale[i]);
 784         }
 785
 786         /* smooth curve */
 787         for(i=0; i<rcc->num_entries; i++){
 788             RateControlEntry *rce= &rcc->entry[i];
 789             const int pict_type= rce->new_pict_type;
 790             int j;
 791             double q=0.0, sum=0.0;
 792
 793             for(j=0; j<filter_size; j++){
 794                 int index= i+j-filter_size/2;
 795                 double d= index-i;
 796                 double coeff= s->qblur==0 ? 1.0 : exp(-d*d/(s->qblur * s->qblur));
 797
 798                 if(index < 0 || index >= rcc->num_entries) continue;
 799                 if(pict_type != rcc->entry[index].new_pict_type) continue;
 800                 q+= qscale[index] * coeff;
 801                 sum+= coeff;
 802             }
 803             blured_qscale[i]= q/sum;
 804         }
 805
 806         /* find expected bits */
 807         for(i=0; i<rcc->num_entries; i++){
 808             RateControlEntry *rce= &rcc->entry[i];
 809             double bits;
 810             rce->new_qscale= modify_qscale(s, rce, blured_qscale[i], i);
 811             bits= qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;
 812 //printf("%d %f\n", rce->new_bits, blured_qscale[i]);
 813             update_rc_buffer(s, bits);
 814
 815             rce->expected_bits= expected_bits;
 816             expected_bits += bits;
 817         }
 818
 819 //        printf("%f %d %f\n", expected_bits, (int)all_available_bits, rate_factor);
 820         if(expected_bits > all_available_bits) rate_factor-= step;
 821     }
 822     av_free(qscale);
 823     av_free(blured_qscale);
 824
 825     if(abs(expected_bits/all_available_bits - 1.0) > 0.01 ){
 826         fprintf(stderr, "Error: 2pass curve failed to converge\n");
 827         return -1;
 828     }
 829
 830     return 0;
 831 }