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

   1 /*
   2  * Rate control for video encoders
   3  *
   4  * Copyright (c) 2002-2004 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     snprintf(s->avctx->stats_out, 256, "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->current_picture_ptr->display_picture_number, s->current_picture_ptr->coded_picture_number, 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         if(i<=0 || i>=INT_MAX / sizeof(RateControlEntry))
  78             return -1;
  79         rcc->entry = (RateControlEntry*)av_mallocz(i*sizeof(RateControlEntry));
  80         rcc->num_entries= i;
  81
  82         /* init all to skipped p frames (with b frames we might have a not encoded frame at the end FIXME) */
  83         for(i=0; i<rcc->num_entries; i++){
  84             RateControlEntry *rce= &rcc->entry[i];
  85             rce->pict_type= rce->new_pict_type=P_TYPE;
  86             rce->qscale= rce->new_qscale=FF_QP2LAMBDA * 2;
  87             rce->misc_bits= s->mb_num + 10;
  88             rce->mb_var_sum= s->mb_num*100;
  89         }
  90
  91         /* read stats */
  92         p= s->avctx->stats_in;
  93         for(i=0; i<rcc->num_entries - s->max_b_frames; i++){
  94             RateControlEntry *rce;
  95             int picture_number;
  96             int e;
  97             char *next;
  98
  99             next= strchr(p, ';');
 100             if(next){
 101                 (*next)=0; //sscanf in unbelieavle slow on looong strings //FIXME copy / dont write
 102                 next++;
 103             }
 104             e= sscanf(p, " in:%d ", &picture_number);
 105
 106             assert(picture_number >= 0);
 107             assert(picture_number < rcc->num_entries);
 108             rce= &rcc->entry[picture_number];
 109
 110             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",
 111                    &rce->pict_type, &rce->qscale, &rce->i_tex_bits, &rce->p_tex_bits, &rce->mv_bits, &rce->misc_bits,
 112                    &rce->f_code, &rce->b_code, &rce->mc_mb_var_sum, &rce->mb_var_sum, &rce->i_count);
 113             if(e!=12){
 114                 av_log(s->avctx, AV_LOG_ERROR, "statistics are damaged at line %d, parser out=%d\n", i, e);
 115                 return -1;
 116             }
 117             p= next;
 118         }
 119
 120         if(init_pass2(s) < 0) return -1;
 121     }
 122
 123     if(!(s->flags&CODEC_FLAG_PASS2)){
 124
 125         rcc->short_term_qsum=0.001;
 126         rcc->short_term_qcount=0.001;
 127
 128         rcc->pass1_rc_eq_output_sum= 0.001;
 129         rcc->pass1_wanted_bits=0.001;
 130
 131         /* init stuff with the user specified complexity */
 132         if(s->avctx->rc_initial_cplx){
 133             for(i=0; i<60*30; i++){
 134                 double bits= s->avctx->rc_initial_cplx * (i/10000.0 + 1.0)*s->mb_num;
 135                 RateControlEntry rce;
 136                 double q;
 137
 138                 if     (i%((s->gop_size+3)/4)==0) rce.pict_type= I_TYPE;
 139                 else if(i%(s->max_b_frames+1))    rce.pict_type= B_TYPE;
 140                 else                              rce.pict_type= P_TYPE;
 141
 142                 rce.new_pict_type= rce.pict_type;
 143                 rce.mc_mb_var_sum= bits*s->mb_num/100000;
 144                 rce.mb_var_sum   = s->mb_num;
 145                 rce.qscale   = FF_QP2LAMBDA * 2;
 146                 rce.f_code   = 2;
 147                 rce.b_code   = 1;
 148                 rce.misc_bits= 1;
 149
 150                 if(s->pict_type== I_TYPE){
 151                     rce.i_count   = s->mb_num;
 152                     rce.i_tex_bits= bits;
 153                     rce.p_tex_bits= 0;
 154                     rce.mv_bits= 0;
 155                 }else{
 156                     rce.i_count   = 0; //FIXME we do know this approx
 157                     rce.i_tex_bits= 0;
 158                     rce.p_tex_bits= bits*0.9;
 159                     rce.mv_bits= bits*0.1;
 160                 }
 161                 rcc->i_cplx_sum [rce.pict_type] += rce.i_tex_bits*rce.qscale;
 162                 rcc->p_cplx_sum [rce.pict_type] += rce.p_tex_bits*rce.qscale;
 163                 rcc->mv_bits_sum[rce.pict_type] += rce.mv_bits;
 164                 rcc->frame_count[rce.pict_type] ++;
 165
 166                 bits= rce.i_tex_bits + rce.p_tex_bits;
 167
 168                 q= get_qscale(s, &rce, rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum, i);
 169                 rcc->pass1_wanted_bits+= s->bit_rate/(1/av_q2d(s->avctx->time_base)); //FIXME missbehaves a little for variable fps
 170             }
 171         }
 172
 173     }
 174
 175     return 0;
 176 }
 177
 178 void ff_rate_control_uninit(MpegEncContext *s)
 179 {
 180     RateControlContext *rcc= &s->rc_context;
 181     emms_c();
 182
 183     av_freep(&rcc->entry);
 184 }
 185
 186 static inline double qp2bits(RateControlEntry *rce, double qp){
 187     if(qp<=0.0){
 188         av_log(NULL, AV_LOG_ERROR, "qp<=0.0\n");
 189     }
 190     return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits+1)/ qp;
 191 }
 192
 193 static inline double bits2qp(RateControlEntry *rce, double bits){
 194     if(bits<0.9){
 195         av_log(NULL, AV_LOG_ERROR, "bits<0.9\n");
 196     }
 197     return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits+1)/ bits;
 198 }
 199
 200 int ff_vbv_update(MpegEncContext *s, int frame_size){
 201     RateControlContext *rcc= &s->rc_context;
 202     const double fps= 1/av_q2d(s->avctx->time_base);
 203     const int buffer_size= s->avctx->rc_buffer_size;
 204     const double min_rate= s->avctx->rc_min_rate/fps;
 205     const double max_rate= s->avctx->rc_max_rate/fps;
 206
 207 //printf("%d %f %d %f %f\n", buffer_size, rcc->buffer_index, frame_size, min_rate, max_rate);
 208     if(buffer_size){
 209         int left;
 210
 211         rcc->buffer_index-= frame_size;
 212         if(rcc->buffer_index < 0){
 213             av_log(s->avctx, AV_LOG_ERROR, "rc buffer underflow\n");
 214             rcc->buffer_index= 0;
 215         }
 216
 217         left= buffer_size - rcc->buffer_index - 1;
 218         rcc->buffer_index += clip(left, min_rate, max_rate);
 219
 220         if(rcc->buffer_index > buffer_size){
 221             int stuffing= ceil((rcc->buffer_index - buffer_size)/8);
 222
 223             if(stuffing < 4 && s->codec_id == CODEC_ID_MPEG4)
 224                 stuffing=4;
 225             rcc->buffer_index -= 8*stuffing;
 226
 227             if(s->avctx->debug & FF_DEBUG_RC)
 228                 av_log(s->avctx, AV_LOG_DEBUG, "stuffing %d bytes\n", stuffing);
 229
 230             return stuffing;
 231         }
 232     }
 233     return 0;
 234 }
 235
 236 /**
 237  * modifies the bitrate curve from pass1 for one frame
 238  */
 239 static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_factor, int frame_num){
 240     RateControlContext *rcc= &s->rc_context;
 241     AVCodecContext *a= s->avctx;
 242     double q, bits;
 243     const int pict_type= rce->new_pict_type;
 244     const double mb_num= s->mb_num;
 245     int i;
 246
 247     double const_values[]={
 248         M_PI,
 249         M_E,
 250         rce->i_tex_bits*rce->qscale,
 251         rce->p_tex_bits*rce->qscale,
 252         (rce->i_tex_bits + rce->p_tex_bits)*(double)rce->qscale,
 253         rce->mv_bits/mb_num,
 254         rce->pict_type == B_TYPE ? (rce->f_code + rce->b_code)*0.5 : rce->f_code,
 255         rce->i_count/mb_num,
 256         rce->mc_mb_var_sum/mb_num,
 257         rce->mb_var_sum/mb_num,
 258         rce->pict_type == I_TYPE,
 259         rce->pict_type == P_TYPE,
 260         rce->pict_type == B_TYPE,
 261         rcc->qscale_sum[pict_type] / (double)rcc->frame_count[pict_type],
 262         a->qcompress,
 263 /*        rcc->last_qscale_for[I_TYPE],
 264         rcc->last_qscale_for[P_TYPE],
 265         rcc->last_qscale_for[B_TYPE],
 266         rcc->next_non_b_qscale,*/
 267         rcc->i_cplx_sum[I_TYPE] / (double)rcc->frame_count[I_TYPE],
 268         rcc->i_cplx_sum[P_TYPE] / (double)rcc->frame_count[P_TYPE],
 269         rcc->p_cplx_sum[P_TYPE] / (double)rcc->frame_count[P_TYPE],
 270         rcc->p_cplx_sum[B_TYPE] / (double)rcc->frame_count[B_TYPE],
 271         (rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / (double)rcc->frame_count[pict_type],
 272         0
 273     };
 274     static const char *const_names[]={
 275         "PI",
 276         "E",
 277         "iTex",
 278         "pTex",
 279         "tex",
 280         "mv",
 281         "fCode",
 282         "iCount",
 283         "mcVar",
 284         "var",
 285         "isI",
 286         "isP",
 287         "isB",
 288         "avgQP",
 289         "qComp",
 290 /*        "lastIQP",
 291         "lastPQP",
 292         "lastBQP",
 293         "nextNonBQP",*/
 294         "avgIITex",
 295         "avgPITex",
 296         "avgPPTex",
 297         "avgBPTex",
 298         "avgTex",
 299         NULL
 300     };
 301     static double (*func1[])(void *, double)={
 302         (void *)bits2qp,
 303         (void *)qp2bits,
 304         NULL
 305     };
 306     static const char *func1_names[]={
 307         "bits2qp",
 308         "qp2bits",
 309         NULL
 310     };
 311
 312     bits= ff_eval(s->avctx->rc_eq, const_values, const_names, func1, func1_names, NULL, NULL, rce);
 313
 314     rcc->pass1_rc_eq_output_sum+= bits;
 315     bits*=rate_factor;
 316     if(bits<0.0) bits=0.0;
 317     bits+= 1.0; //avoid 1/0 issues
 318
 319     /* user override */
 320     for(i=0; i<s->avctx->rc_override_count; i++){
 321         RcOverride *rco= s->avctx->rc_override;
 322         if(rco[i].start_frame > frame_num) continue;
 323         if(rco[i].end_frame   < frame_num) continue;
 324
 325         if(rco[i].qscale)
 326             bits= qp2bits(rce, rco[i].qscale); //FIXME move at end to really force it?
 327         else
 328             bits*= rco[i].quality_factor;
 329     }
 330
 331     q= bits2qp(rce, bits);
 332
 333     /* I/B difference */
 334     if     (pict_type==I_TYPE && s->avctx->i_quant_factor<0.0)
 335         q= -q*s->avctx->i_quant_factor + s->avctx->i_quant_offset;
 336     else if(pict_type==B_TYPE && s->avctx->b_quant_factor<0.0)
 337         q= -q*s->avctx->b_quant_factor + s->avctx->b_quant_offset;
 338
 339     return q;
 340 }
 341
 342 static double get_diff_limited_q(MpegEncContext *s, RateControlEntry *rce, double q){
 343     RateControlContext *rcc= &s->rc_context;
 344     AVCodecContext *a= s->avctx;
 345     const int pict_type= rce->new_pict_type;
 346     const double last_p_q    = rcc->last_qscale_for[P_TYPE];
 347     const double last_non_b_q= rcc->last_qscale_for[rcc->last_non_b_pict_type];
 348
 349     if     (pict_type==I_TYPE && (a->i_quant_factor>0.0 || rcc->last_non_b_pict_type==P_TYPE))
 350         q= last_p_q    *ABS(a->i_quant_factor) + a->i_quant_offset;
 351     else if(pict_type==B_TYPE && a->b_quant_factor>0.0)
 352         q= last_non_b_q*    a->b_quant_factor  + a->b_quant_offset;
 353
 354     /* last qscale / qdiff stuff */
 355     if(rcc->last_non_b_pict_type==pict_type || pict_type!=I_TYPE){
 356         double last_q= rcc->last_qscale_for[pict_type];
 357         const int maxdiff= FF_QP2LAMBDA * a->max_qdiff;
 358
 359         if     (q > last_q + maxdiff) q= last_q + maxdiff;
 360         else if(q < last_q - maxdiff) q= last_q - maxdiff;
 361     }
 362
 363     rcc->last_qscale_for[pict_type]= q; //Note we cant do that after blurring
 364
 365     if(pict_type!=B_TYPE)
 366         rcc->last_non_b_pict_type= pict_type;
 367
 368     return q;
 369 }
 370
 371 /**
 372  * gets the qmin & qmax for pict_type
 373  */
 374 static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type){
 375     int qmin= s->avctx->lmin;
 376     int qmax= s->avctx->lmax;
 377
 378     assert(qmin <= qmax);
 379
 380     if(pict_type==B_TYPE){
 381         qmin= (int)(qmin*ABS(s->avctx->b_quant_factor)+s->avctx->b_quant_offset + 0.5);
 382         qmax= (int)(qmax*ABS(s->avctx->b_quant_factor)+s->avctx->b_quant_offset + 0.5);
 383     }else if(pict_type==I_TYPE){
 384         qmin= (int)(qmin*ABS(s->avctx->i_quant_factor)+s->avctx->i_quant_offset + 0.5);
 385         qmax= (int)(qmax*ABS(s->avctx->i_quant_factor)+s->avctx->i_quant_offset + 0.5);
 386     }
 387
 388     qmin= clip(qmin, 1, FF_LAMBDA_MAX);
 389     qmax= clip(qmax, 1, FF_LAMBDA_MAX);
 390
 391     if(qmax<qmin) qmax= qmin;
 392
 393     *qmin_ret= qmin;
 394     *qmax_ret= qmax;
 395 }
 396
 397 static double modify_qscale(MpegEncContext *s, RateControlEntry *rce, double q, int frame_num){
 398     RateControlContext *rcc= &s->rc_context;
 399     int qmin, qmax;
 400     double bits;
 401     const int pict_type= rce->new_pict_type;
 402     const double buffer_size= s->avctx->rc_buffer_size;
 403     const double fps= 1/av_q2d(s->avctx->time_base);
 404     const double min_rate= s->avctx->rc_min_rate / fps;
 405     const double max_rate= s->avctx->rc_max_rate / fps;
 406
 407     get_qminmax(&qmin, &qmax, s, pict_type);
 408
 409     /* modulation */
 410     if(s->avctx->rc_qmod_freq && frame_num%s->avctx->rc_qmod_freq==0 && pict_type==P_TYPE)
 411         q*= s->avctx->rc_qmod_amp;
 412
 413     bits= qp2bits(rce, q);
 414 //printf("q:%f\n", q);
 415     /* buffer overflow/underflow protection */
 416     if(buffer_size){
 417         double expected_size= rcc->buffer_index;
 418         double q_limit;
 419
 420         if(min_rate){
 421             double d= 2*(buffer_size - expected_size)/buffer_size;
 422             if(d>1.0) d=1.0;
 423             else if(d<0.0001) d=0.0001;
 424             q*= pow(d, 1.0/s->avctx->rc_buffer_aggressivity);
 425
 426             q_limit= bits2qp(rce, FFMAX((min_rate - buffer_size + rcc->buffer_index)*3, 1));
 427             if(q > q_limit){
 428                 if(s->avctx->debug&FF_DEBUG_RC){
 429                     av_log(s->avctx, AV_LOG_DEBUG, "limiting QP %f -> %f\n", q, q_limit);
 430                 }
 431                 q= q_limit;
 432             }
 433         }
 434
 435         if(max_rate){
 436             double d= 2*expected_size/buffer_size;
 437             if(d>1.0) d=1.0;
 438             else if(d<0.0001) d=0.0001;
 439             q/= pow(d, 1.0/s->avctx->rc_buffer_aggressivity);
 440
 441             q_limit= bits2qp(rce, FFMAX(rcc->buffer_index/3, 1));
 442             if(q < q_limit){
 443                 if(s->avctx->debug&FF_DEBUG_RC){
 444                     av_log(s->avctx, AV_LOG_DEBUG, "limiting QP %f -> %f\n", q, q_limit);
 445                 }
 446                 q= q_limit;
 447             }
 448         }
 449     }
 450 //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);
 451     if(s->avctx->rc_qsquish==0.0 || qmin==qmax){
 452         if     (q<qmin) q=qmin;
 453         else if(q>qmax) q=qmax;
 454     }else{
 455         double min2= log(qmin);
 456         double max2= log(qmax);
 457
 458         q= log(q);
 459         q= (q - min2)/(max2-min2) - 0.5;
 460         q*= -4.0;
 461         q= 1.0/(1.0 + exp(q));
 462         q= q*(max2-min2) + min2;
 463
 464         q= exp(q);
 465     }
 466
 467     return q;
 468 }
 469
 470 //----------------------------------
 471 // 1 Pass Code
 472
 473 static double predict_size(Predictor *p, double q, double var)
 474 {
 475      return p->coeff*var / (q*p->count);
 476 }
 477
 478 /*
 479 static double predict_qp(Predictor *p, double size, double var)
 480 {
 481 //printf("coeff:%f, count:%f, var:%f, size:%f//\n", p->coeff, p->count, var, size);
 482      return p->coeff*var / (size*p->count);
 483 }
 484 */
 485
 486 static void update_predictor(Predictor *p, double q, double var, double size)
 487 {
 488     double new_coeff= size*q / (var + 1);
 489     if(var<10) return;
 490
 491     p->count*= p->decay;
 492     p->coeff*= p->decay;
 493     p->count++;
 494     p->coeff+= new_coeff;
 495 }
 496
 497 static void adaptive_quantization(MpegEncContext *s, double q){
 498     int i;
 499     const float lumi_masking= s->avctx->lumi_masking / (128.0*128.0);
 500     const float dark_masking= s->avctx->dark_masking / (128.0*128.0);
 501     const float temp_cplx_masking= s->avctx->temporal_cplx_masking;
 502     const float spatial_cplx_masking = s->avctx->spatial_cplx_masking;
 503     const float p_masking = s->avctx->p_masking;
 504     const float border_masking = s->avctx->border_masking;
 505     float bits_sum= 0.0;
 506     float cplx_sum= 0.0;
 507     float cplx_tab[s->mb_num];
 508     float bits_tab[s->mb_num];
 509     const int qmin= s->avctx->mb_lmin;
 510     const int qmax= s->avctx->mb_lmax;
 511     Picture * const pic= &s->current_picture;
 512     const int mb_width = s->mb_width;
 513     const int mb_height = s->mb_height;
 514
 515     for(i=0; i<s->mb_num; i++){
 516         const int mb_xy= s->mb_index2xy[i];
 517         float temp_cplx= sqrt(pic->mc_mb_var[mb_xy]); //FIXME merge in pow()
 518         float spat_cplx= sqrt(pic->mb_var[mb_xy]);
 519         const int lumi= pic->mb_mean[mb_xy];
 520         float bits, cplx, factor;
 521         int mb_x = mb_xy % s->mb_stride;
 522         int mb_y = mb_xy / s->mb_stride;
 523         int mb_distance;
 524         float mb_factor = 0.0;
 525 #if 0
 526         if(spat_cplx < q/3) spat_cplx= q/3; //FIXME finetune
 527         if(temp_cplx < q/3) temp_cplx= q/3; //FIXME finetune
 528 #endif
 529         if(spat_cplx < 4) spat_cplx= 4; //FIXME finetune
 530         if(temp_cplx < 4) temp_cplx= 4; //FIXME finetune
 531
 532         if((s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTRA)){//FIXME hq mode
 533             cplx= spat_cplx;
 534             factor= 1.0 + p_masking;
 535         }else{
 536             cplx= temp_cplx;
 537             factor= pow(temp_cplx, - temp_cplx_masking);
 538         }
 539         factor*=pow(spat_cplx, - spatial_cplx_masking);
 540
 541         if(lumi>127)
 542             factor*= (1.0 - (lumi-128)*(lumi-128)*lumi_masking);
 543         else
 544             factor*= (1.0 - (lumi-128)*(lumi-128)*dark_masking);
 545
 546         if(mb_x < mb_width/5){
 547             mb_distance = mb_width/5 - mb_x;
 548             mb_factor = (float)mb_distance / (float)(mb_width/5);
 549         }else if(mb_x > 4*mb_width/5){
 550             mb_distance = mb_x - 4*mb_width/5;
 551             mb_factor = (float)mb_distance / (float)(mb_width/5);
 552         }
 553         if(mb_y < mb_height/5){
 554             mb_distance = mb_height/5 - mb_y;
 555             mb_factor = FFMAX(mb_factor, (float)mb_distance / (float)(mb_height/5));
 556         }else if(mb_y > 4*mb_height/5){
 557             mb_distance = mb_y - 4*mb_height/5;
 558             mb_factor = FFMAX(mb_factor, (float)mb_distance / (float)(mb_height/5));
 559         }
 560
 561         factor*= 1.0 - border_masking*mb_factor;
 562
 563         if(factor<0.00001) factor= 0.00001;
 564
 565         bits= cplx*factor;
 566         cplx_sum+= cplx;
 567         bits_sum+= bits;
 568         cplx_tab[i]= cplx;
 569         bits_tab[i]= bits;
 570     }
 571
 572     /* handle qmin/qmax cliping */
 573     if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
 574         float factor= bits_sum/cplx_sum;
 575         for(i=0; i<s->mb_num; i++){
 576             float newq= q*cplx_tab[i]/bits_tab[i];
 577             newq*= factor;
 578
 579             if     (newq > qmax){
 580                 bits_sum -= bits_tab[i];
 581                 cplx_sum -= cplx_tab[i]*q/qmax;
 582             }
 583             else if(newq < qmin){
 584                 bits_sum -= bits_tab[i];
 585                 cplx_sum -= cplx_tab[i]*q/qmin;
 586             }
 587         }
 588         if(bits_sum < 0.001) bits_sum= 0.001;
 589         if(cplx_sum < 0.001) cplx_sum= 0.001;
 590     }
 591
 592     for(i=0; i<s->mb_num; i++){
 593         const int mb_xy= s->mb_index2xy[i];
 594         float newq= q*cplx_tab[i]/bits_tab[i];
 595         int intq;
 596
 597         if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
 598             newq*= bits_sum/cplx_sum;
 599         }
 600
 601         intq= (int)(newq + 0.5);
 602
 603         if     (intq > qmax) intq= qmax;
 604         else if(intq < qmin) intq= qmin;
 605 //if(i%s->mb_width==0) printf("\n");
 606 //printf("%2d%3d ", intq, ff_sqrt(s->mc_mb_var[i]));
 607         s->lambda_table[mb_xy]= intq;
 608     }
 609 }
 610
 611 void ff_get_2pass_fcode(MpegEncContext *s){
 612     RateControlContext *rcc= &s->rc_context;
 613     int picture_number= s->picture_number;
 614     RateControlEntry *rce;
 615
 616     rce= &rcc->entry[picture_number];
 617     s->f_code= rce->f_code;
 618     s->b_code= rce->b_code;
 619 }
 620
 621 //FIXME rd or at least approx for dquant
 622
 623 float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
 624 {
 625     float q;
 626     int qmin, qmax;
 627     float br_compensation;
 628     double diff;
 629     double short_term_q;
 630     double fps;
 631     int picture_number= s->picture_number;
 632     int64_t wanted_bits;
 633     RateControlContext *rcc= &s->rc_context;
 634     AVCodecContext *a= s->avctx;
 635     RateControlEntry local_rce, *rce;
 636     double bits;
 637     double rate_factor;
 638     int var;
 639     const int pict_type= s->pict_type;
 640     Picture * const pic= &s->current_picture;
 641     emms_c();
 642
 643     get_qminmax(&qmin, &qmax, s, pict_type);
 644
 645     fps= 1/av_q2d(s->avctx->time_base);
 646 //printf("input_pic_num:%d pic_num:%d frame_rate:%d\n", s->input_picture_number, s->picture_number, s->frame_rate);
 647         /* update predictors */
 648     if(picture_number>2 && !dry_run){
 649         const int last_var= s->last_pict_type == I_TYPE ? rcc->last_mb_var_sum : rcc->last_mc_mb_var_sum;
 650         update_predictor(&rcc->pred[s->last_pict_type], rcc->last_qscale, sqrt(last_var), s->frame_bits);
 651     }
 652
 653     if(s->flags&CODEC_FLAG_PASS2){
 654         assert(picture_number>=0);
 655         assert(picture_number<rcc->num_entries);
 656         rce= &rcc->entry[picture_number];
 657         wanted_bits= rce->expected_bits;
 658     }else{
 659         rce= &local_rce;
 660         wanted_bits= (uint64_t)(s->bit_rate*(double)picture_number/fps);
 661     }
 662
 663     diff= s->total_bits - wanted_bits;
 664     br_compensation= (a->bit_rate_tolerance - diff)/a->bit_rate_tolerance;
 665     if(br_compensation<=0.0) br_compensation=0.001;
 666
 667     var= pict_type == I_TYPE ? pic->mb_var_sum : pic->mc_mb_var_sum;
 668
 669     short_term_q = 0; /* avoid warning */
 670     if(s->flags&CODEC_FLAG_PASS2){
 671         if(pict_type!=I_TYPE)
 672             assert(pict_type == rce->new_pict_type);
 673
 674         q= rce->new_qscale / br_compensation;
 675 //printf("%f %f %f last:%d var:%d type:%d//\n", q, rce->new_qscale, br_compensation, s->frame_bits, var, pict_type);
 676     }else{
 677         rce->pict_type=
 678         rce->new_pict_type= pict_type;
 679         rce->mc_mb_var_sum= pic->mc_mb_var_sum;
 680         rce->mb_var_sum   = pic->   mb_var_sum;
 681         rce->qscale   = FF_QP2LAMBDA * 2;
 682         rce->f_code   = s->f_code;
 683         rce->b_code   = s->b_code;
 684         rce->misc_bits= 1;
 685
 686         bits= predict_size(&rcc->pred[pict_type], rce->qscale, sqrt(var));
 687         if(pict_type== I_TYPE){
 688             rce->i_count   = s->mb_num;
 689             rce->i_tex_bits= bits;
 690             rce->p_tex_bits= 0;
 691             rce->mv_bits= 0;
 692         }else{
 693             rce->i_count   = 0; //FIXME we do know this approx
 694             rce->i_tex_bits= 0;
 695             rce->p_tex_bits= bits*0.9;
 696
 697             rce->mv_bits= bits*0.1;
 698         }
 699         rcc->i_cplx_sum [pict_type] += rce->i_tex_bits*rce->qscale;
 700         rcc->p_cplx_sum [pict_type] += rce->p_tex_bits*rce->qscale;
 701         rcc->mv_bits_sum[pict_type] += rce->mv_bits;
 702         rcc->frame_count[pict_type] ++;
 703
 704         bits= rce->i_tex_bits + rce->p_tex_bits;
 705         rate_factor= rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum * br_compensation;
 706
 707         q= get_qscale(s, rce, rate_factor, picture_number);
 708
 709         assert(q>0.0);
 710 //printf("%f ", q);
 711         q= get_diff_limited_q(s, rce, q);
 712 //printf("%f ", q);
 713         assert(q>0.0);
 714
 715         if(pict_type==P_TYPE || s->intra_only){ //FIXME type dependant blur like in 2-pass
 716             rcc->short_term_qsum*=a->qblur;
 717             rcc->short_term_qcount*=a->qblur;
 718
 719             rcc->short_term_qsum+= q;
 720             rcc->short_term_qcount++;
 721 //printf("%f ", q);
 722             q= short_term_q= rcc->short_term_qsum/rcc->short_term_qcount;
 723 //printf("%f ", q);
 724         }
 725         assert(q>0.0);
 726
 727         q= modify_qscale(s, rce, q, picture_number);
 728
 729         rcc->pass1_wanted_bits+= s->bit_rate/fps;
 730
 731         assert(q>0.0);
 732     }
 733
 734     if(s->avctx->debug&FF_DEBUG_RC){
 735         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",
 736         av_get_pict_type_char(pict_type), qmin, q, qmax, picture_number, (int)wanted_bits/1000, (int)s->total_bits/1000,
 737         br_compensation, short_term_q, s->frame_bits, pic->mb_var_sum, pic->mc_mb_var_sum, s->bit_rate/1000, (int)fps
 738         );
 739     }
 740
 741     if     (q<qmin) q=qmin;
 742     else if(q>qmax) q=qmax;
 743
 744     if(s->adaptive_quant)
 745         adaptive_quantization(s, q);
 746     else
 747         q= (int)(q + 0.5);
 748
 749     if(!dry_run){
 750         rcc->last_qscale= q;
 751         rcc->last_mc_mb_var_sum= pic->mc_mb_var_sum;
 752         rcc->last_mb_var_sum= pic->mb_var_sum;
 753     }
 754 #if 0
 755 {
 756     static int mvsum=0, texsum=0;
 757     mvsum += s->mv_bits;
 758     texsum += s->i_tex_bits + s->p_tex_bits;
 759     printf("%d %d//\n\n", mvsum, texsum);
 760 }
 761 #endif
 762     return q;
 763 }
 764
 765 //----------------------------------------------
 766 // 2-Pass code
 767
 768 static int init_pass2(MpegEncContext *s)
 769 {
 770     RateControlContext *rcc= &s->rc_context;
 771     AVCodecContext *a= s->avctx;
 772     int i;
 773     double fps= 1/av_q2d(s->avctx->time_base);
 774     double complexity[5]={0,0,0,0,0};   // aproximate bits at quant=1
 775     double avg_quantizer[5];
 776     uint64_t const_bits[5]={0,0,0,0,0}; // quantizer idependant bits
 777     uint64_t available_bits[5];
 778     uint64_t all_const_bits;
 779     uint64_t all_available_bits= (uint64_t)(s->bit_rate*(double)rcc->num_entries/fps);
 780     double rate_factor=0;
 781     double step;
 782     //int last_i_frame=-10000000;
 783     const int filter_size= (int)(a->qblur*4) | 1;
 784     double expected_bits;
 785     double *qscale, *blured_qscale;
 786
 787     /* find complexity & const_bits & decide the pict_types */
 788     for(i=0; i<rcc->num_entries; i++){
 789         RateControlEntry *rce= &rcc->entry[i];
 790
 791         rce->new_pict_type= rce->pict_type;
 792         rcc->i_cplx_sum [rce->pict_type] += rce->i_tex_bits*rce->qscale;
 793         rcc->p_cplx_sum [rce->pict_type] += rce->p_tex_bits*rce->qscale;
 794         rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits;
 795         rcc->frame_count[rce->pict_type] ++;
 796
 797         complexity[rce->new_pict_type]+= (rce->i_tex_bits+ rce->p_tex_bits)*(double)rce->qscale;
 798         const_bits[rce->new_pict_type]+= rce->mv_bits + rce->misc_bits;
 799     }
 800     all_const_bits= const_bits[I_TYPE] + const_bits[P_TYPE] + const_bits[B_TYPE];
 801
 802     if(all_available_bits < all_const_bits){
 803         av_log(s->avctx, AV_LOG_ERROR, "requested bitrate is to low\n");
 804         return -1;
 805     }
 806
 807     /* find average quantizers */
 808     avg_quantizer[P_TYPE]=0;
 809     for(step=256*256; step>0.0000001; step*=0.5){
 810         double expected_bits=0;
 811         avg_quantizer[P_TYPE]+= step;
 812
 813         avg_quantizer[I_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->i_quant_factor) + s->avctx->i_quant_offset;
 814         avg_quantizer[B_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
 815
 816         expected_bits=
 817             + all_const_bits
 818             + complexity[I_TYPE]/avg_quantizer[I_TYPE]
 819             + complexity[P_TYPE]/avg_quantizer[P_TYPE]
 820             + complexity[B_TYPE]/avg_quantizer[B_TYPE];
 821
 822         if(expected_bits < all_available_bits) avg_quantizer[P_TYPE]-= step;
 823 //printf("%f %lld %f\n", expected_bits, all_available_bits, avg_quantizer[P_TYPE]);
 824     }
 825 //printf("qp_i:%f, qp_p:%f, qp_b:%f\n", avg_quantizer[I_TYPE],avg_quantizer[P_TYPE],avg_quantizer[B_TYPE]);
 826
 827     for(i=0; i<5; i++){
 828         available_bits[i]= const_bits[i] + complexity[i]/avg_quantizer[i];
 829     }
 830 //printf("%lld %lld %lld %lld\n", available_bits[I_TYPE], available_bits[P_TYPE], available_bits[B_TYPE], all_available_bits);
 831
 832     qscale= av_malloc(sizeof(double)*rcc->num_entries);
 833     blured_qscale= av_malloc(sizeof(double)*rcc->num_entries);
 834
 835     for(step=256*256; step>0.0000001; step*=0.5){
 836         expected_bits=0;
 837         rate_factor+= step;
 838
 839         rcc->buffer_index= s->avctx->rc_buffer_size/2;
 840
 841         /* find qscale */
 842         for(i=0; i<rcc->num_entries; i++){
 843             qscale[i]= get_qscale(s, &rcc->entry[i], rate_factor, i);
 844         }
 845         assert(filter_size%2==1);
 846
 847         /* fixed I/B QP relative to P mode */
 848         for(i=rcc->num_entries-1; i>=0; i--){
 849             RateControlEntry *rce= &rcc->entry[i];
 850
 851             qscale[i]= get_diff_limited_q(s, rce, qscale[i]);
 852         }
 853
 854         /* smooth curve */
 855         for(i=0; i<rcc->num_entries; i++){
 856             RateControlEntry *rce= &rcc->entry[i];
 857             const int pict_type= rce->new_pict_type;
 858             int j;
 859             double q=0.0, sum=0.0;
 860
 861             for(j=0; j<filter_size; j++){
 862                 int index= i+j-filter_size/2;
 863                 double d= index-i;
 864                 double coeff= a->qblur==0 ? 1.0 : exp(-d*d/(a->qblur * a->qblur));
 865
 866                 if(index < 0 || index >= rcc->num_entries) continue;
 867                 if(pict_type != rcc->entry[index].new_pict_type) continue;
 868                 q+= qscale[index] * coeff;
 869                 sum+= coeff;
 870             }
 871             blured_qscale[i]= q/sum;
 872         }
 873
 874         /* find expected bits */
 875         for(i=0; i<rcc->num_entries; i++){
 876             RateControlEntry *rce= &rcc->entry[i];
 877             double bits;
 878             rce->new_qscale= modify_qscale(s, rce, blured_qscale[i], i);
 879             bits= qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;
 880 //printf("%d %f\n", rce->new_bits, blured_qscale[i]);
 881             bits += 8*ff_vbv_update(s, bits);
 882
 883             rce->expected_bits= expected_bits;
 884             expected_bits += bits;
 885         }
 886
 887 //        printf("%f %d %f\n", expected_bits, (int)all_available_bits, rate_factor);
 888         if(expected_bits > all_available_bits) rate_factor-= step;
 889     }
 890     av_free(qscale);
 891     av_free(blured_qscale);
 892
 893     if(abs(expected_bits/all_available_bits - 1.0) > 0.01 ){
 894         av_log(s->avctx, AV_LOG_ERROR, "Error: 2pass curve failed to converge\n");
 895         return -1;
 896     }
 897
 898     return 0;
 899 }