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