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         for(i=0; i<s->mb_num; i++){
 549             float newq= q*cplx_tab[i]/bits_tab[i];
 550             newq*= bits_sum/cplx_sum;
 551
 552             if     (newq > qmax){
 553                 bits_sum -= bits_tab[i];
 554                 cplx_sum -= cplx_tab[i]*q/qmax;
 555             }
 556             else if(newq < qmin){
 557                 bits_sum -= bits_tab[i];
 558                 cplx_sum -= cplx_tab[i]*q/qmin;
 559             }
 560         }
 561     }
 562
 563     for(i=0; i<s->mb_num; i++){
 564         const int mb_xy= s->mb_index2xy[i];
 565         float newq= q*cplx_tab[i]/bits_tab[i];
 566         int intq;
 567
 568         if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
 569             newq*= bits_sum/cplx_sum;
 570         }
 571
 572         intq= (int)(newq + 0.5);
 573
 574         if     (intq > qmax) intq= qmax;
 575         else if(intq < qmin) intq= qmin;
 576 //if(i%s->mb_width==0) printf("\n");
 577 //printf("%2d%3d ", intq, ff_sqrt(s->mc_mb_var[i]));
 578         s->lambda_table[mb_xy]= intq;
 579     }
 580 }
 581 //FIXME rd or at least approx for dquant
 582
 583 float ff_rate_estimate_qscale(MpegEncContext *s)
 584 {
 585     float q;
 586     int qmin, qmax;
 587     float br_compensation;
 588     double diff;
 589     double short_term_q;
 590     double fps;
 591     int picture_number= s->picture_number;
 592     int64_t wanted_bits;
 593     RateControlContext *rcc= &s->rc_context;
 594     AVCodecContext *a= s->avctx;
 595     RateControlEntry local_rce, *rce;
 596     double bits;
 597     double rate_factor;
 598     int var;
 599     const int pict_type= s->pict_type;
 600     Picture * const pic= &s->current_picture;
 601     emms_c();
 602
 603     get_qminmax(&qmin, &qmax, s, pict_type);
 604
 605     fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base;
 606 //printf("input_pic_num:%d pic_num:%d frame_rate:%d\n", s->input_picture_number, s->picture_number, s->frame_rate);
 607         /* update predictors */
 608     if(picture_number>2){
 609         const int last_var= s->last_pict_type == I_TYPE ? rcc->last_mb_var_sum : rcc->last_mc_mb_var_sum;
 610         update_predictor(&rcc->pred[s->last_pict_type], rcc->last_qscale, sqrt(last_var), s->frame_bits);
 611     }
 612
 613     if(s->flags&CODEC_FLAG_PASS2){
 614         assert(picture_number>=0);
 615         assert(picture_number<rcc->num_entries);
 616         rce= &rcc->entry[picture_number];
 617         wanted_bits= rce->expected_bits;
 618     }else{
 619         rce= &local_rce;
 620         wanted_bits= (uint64_t)(s->bit_rate*(double)picture_number/fps);
 621     }
 622
 623     diff= s->total_bits - wanted_bits;
 624     br_compensation= (a->bit_rate_tolerance - diff)/a->bit_rate_tolerance;
 625     if(br_compensation<=0.0) br_compensation=0.001;
 626
 627     var= pict_type == I_TYPE ? pic->mb_var_sum : pic->mc_mb_var_sum;
 628
 629     short_term_q = 0; /* avoid warning */
 630     if(s->flags&CODEC_FLAG_PASS2){
 631         if(pict_type!=I_TYPE)
 632             assert(pict_type == rce->new_pict_type);
 633
 634         q= rce->new_qscale / br_compensation;
 635 //printf("%f %f %f last:%d var:%d type:%d//\n", q, rce->new_qscale, br_compensation, s->frame_bits, var, pict_type);
 636     }else{
 637         rce->pict_type=
 638         rce->new_pict_type= pict_type;
 639         rce->mc_mb_var_sum= pic->mc_mb_var_sum;
 640         rce->mb_var_sum   = pic->   mb_var_sum;
 641         rce->qscale   = FF_QP2LAMBDA * 2;
 642         rce->f_code   = s->f_code;
 643         rce->b_code   = s->b_code;
 644         rce->misc_bits= 1;
 645
 646         bits= predict_size(&rcc->pred[pict_type], rce->qscale, sqrt(var));
 647         if(pict_type== I_TYPE){
 648             rce->i_count   = s->mb_num;
 649             rce->i_tex_bits= bits;
 650             rce->p_tex_bits= 0;
 651             rce->mv_bits= 0;
 652         }else{
 653             rce->i_count   = 0; //FIXME we do know this approx
 654             rce->i_tex_bits= 0;
 655             rce->p_tex_bits= bits*0.9;
 656
 657             rce->mv_bits= bits*0.1;
 658         }
 659         rcc->i_cplx_sum [pict_type] += rce->i_tex_bits*rce->qscale;
 660         rcc->p_cplx_sum [pict_type] += rce->p_tex_bits*rce->qscale;
 661         rcc->mv_bits_sum[pict_type] += rce->mv_bits;
 662         rcc->frame_count[pict_type] ++;
 663
 664         bits= rce->i_tex_bits + rce->p_tex_bits;
 665         rate_factor= rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum * br_compensation;
 666
 667         q= get_qscale(s, rce, rate_factor, picture_number);
 668
 669         assert(q>0.0);
 670 //printf("%f ", q);
 671         q= get_diff_limited_q(s, rce, q);
 672 //printf("%f ", q);
 673         assert(q>0.0);
 674
 675         if(pict_type==P_TYPE || s->intra_only){ //FIXME type dependant blur like in 2-pass
 676             rcc->short_term_qsum*=a->qblur;
 677             rcc->short_term_qcount*=a->qblur;
 678
 679             rcc->short_term_qsum+= q;
 680             rcc->short_term_qcount++;
 681 //printf("%f ", q);
 682             q= short_term_q= rcc->short_term_qsum/rcc->short_term_qcount;
 683 //printf("%f ", q);
 684         }
 685         assert(q>0.0);
 686
 687         q= modify_qscale(s, rce, q, picture_number);
 688
 689         rcc->pass1_wanted_bits+= s->bit_rate/fps;
 690
 691         assert(q>0.0);
 692     }
 693
 694     if(s->avctx->debug&FF_DEBUG_RC){
 695         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",
 696         av_get_pict_type_char(pict_type), qmin, q, qmax, picture_number, (int)wanted_bits/1000, (int)s->total_bits/1000,
 697         br_compensation, short_term_q, s->frame_bits, pic->mb_var_sum, pic->mc_mb_var_sum, s->bit_rate/1000, (int)fps
 698         );
 699     }
 700
 701     if     (q<qmin) q=qmin;
 702     else if(q>qmax) q=qmax;
 703
 704     if(s->adaptive_quant)
 705         adaptive_quantization(s, q);
 706     else
 707         q= (int)(q + 0.5);
 708
 709     rcc->last_qscale= q;
 710     rcc->last_mc_mb_var_sum= pic->mc_mb_var_sum;
 711     rcc->last_mb_var_sum= pic->mb_var_sum;
 712 #if 0
 713 {
 714     static int mvsum=0, texsum=0;
 715     mvsum += s->mv_bits;
 716     texsum += s->i_tex_bits + s->p_tex_bits;
 717     printf("%d %d//\n\n", mvsum, texsum);
 718 }
 719 #endif
 720     return q;
 721 }
 722
 723 //----------------------------------------------
 724 // 2-Pass code
 725
 726 static int init_pass2(MpegEncContext *s)
 727 {
 728     RateControlContext *rcc= &s->rc_context;
 729     AVCodecContext *a= s->avctx;
 730     int i;
 731     double fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base;
 732     double complexity[5]={0,0,0,0,0};   // aproximate bits at quant=1
 733     double avg_quantizer[5];
 734     uint64_t const_bits[5]={0,0,0,0,0}; // quantizer idependant bits
 735     uint64_t available_bits[5];
 736     uint64_t all_const_bits;
 737     uint64_t all_available_bits= (uint64_t)(s->bit_rate*(double)rcc->num_entries/fps);
 738     double rate_factor=0;
 739     double step;
 740     //int last_i_frame=-10000000;
 741     const int filter_size= (int)(a->qblur*4) | 1;
 742     double expected_bits;
 743     double *qscale, *blured_qscale;
 744
 745     /* find complexity & const_bits & decide the pict_types */
 746     for(i=0; i<rcc->num_entries; i++){
 747         RateControlEntry *rce= &rcc->entry[i];
 748
 749         rce->new_pict_type= rce->pict_type;
 750         rcc->i_cplx_sum [rce->pict_type] += rce->i_tex_bits*rce->qscale;
 751         rcc->p_cplx_sum [rce->pict_type] += rce->p_tex_bits*rce->qscale;
 752         rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits;
 753         rcc->frame_count[rce->pict_type] ++;
 754
 755         complexity[rce->new_pict_type]+= (rce->i_tex_bits+ rce->p_tex_bits)*(double)rce->qscale;
 756         const_bits[rce->new_pict_type]+= rce->mv_bits + rce->misc_bits;
 757     }
 758     all_const_bits= const_bits[I_TYPE] + const_bits[P_TYPE] + const_bits[B_TYPE];
 759
 760     if(all_available_bits < all_const_bits){
 761         av_log(s->avctx, AV_LOG_ERROR, "requested bitrate is to low\n");
 762         return -1;
 763     }
 764
 765     /* find average quantizers */
 766     avg_quantizer[P_TYPE]=0;
 767     for(step=256*256; step>0.0000001; step*=0.5){
 768         double expected_bits=0;
 769         avg_quantizer[P_TYPE]+= step;
 770
 771         avg_quantizer[I_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->i_quant_factor) + s->avctx->i_quant_offset;
 772         avg_quantizer[B_TYPE]= avg_quantizer[P_TYPE]*ABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
 773
 774         expected_bits=
 775             + all_const_bits
 776             + complexity[I_TYPE]/avg_quantizer[I_TYPE]
 777             + complexity[P_TYPE]/avg_quantizer[P_TYPE]
 778             + complexity[B_TYPE]/avg_quantizer[B_TYPE];
 779
 780         if(expected_bits < all_available_bits) avg_quantizer[P_TYPE]-= step;
 781 //printf("%f %lld %f\n", expected_bits, all_available_bits, avg_quantizer[P_TYPE]);
 782     }
 783 //printf("qp_i:%f, qp_p:%f, qp_b:%f\n", avg_quantizer[I_TYPE],avg_quantizer[P_TYPE],avg_quantizer[B_TYPE]);
 784
 785     for(i=0; i<5; i++){
 786         available_bits[i]= const_bits[i] + complexity[i]/avg_quantizer[i];
 787     }
 788 //printf("%lld %lld %lld %lld\n", available_bits[I_TYPE], available_bits[P_TYPE], available_bits[B_TYPE], all_available_bits);
 789
 790     qscale= av_malloc(sizeof(double)*rcc->num_entries);
 791     blured_qscale= av_malloc(sizeof(double)*rcc->num_entries);
 792
 793     for(step=256*256; step>0.0000001; step*=0.5){
 794         expected_bits=0;
 795         rate_factor+= step;
 796
 797         rcc->buffer_index= s->avctx->rc_buffer_size/2;
 798
 799         /* find qscale */
 800         for(i=0; i<rcc->num_entries; i++){
 801             qscale[i]= get_qscale(s, &rcc->entry[i], rate_factor, i);
 802         }
 803         assert(filter_size%2==1);
 804
 805         /* fixed I/B QP relative to P mode */
 806         for(i=rcc->num_entries-1; i>=0; i--){
 807             RateControlEntry *rce= &rcc->entry[i];
 808
 809             qscale[i]= get_diff_limited_q(s, rce, qscale[i]);
 810         }
 811
 812         /* smooth curve */
 813         for(i=0; i<rcc->num_entries; i++){
 814             RateControlEntry *rce= &rcc->entry[i];
 815             const int pict_type= rce->new_pict_type;
 816             int j;
 817             double q=0.0, sum=0.0;
 818
 819             for(j=0; j<filter_size; j++){
 820                 int index= i+j-filter_size/2;
 821                 double d= index-i;
 822                 double coeff= a->qblur==0 ? 1.0 : exp(-d*d/(a->qblur * a->qblur));
 823
 824                 if(index < 0 || index >= rcc->num_entries) continue;
 825                 if(pict_type != rcc->entry[index].new_pict_type) continue;
 826                 q+= qscale[index] * coeff;
 827                 sum+= coeff;
 828             }
 829             blured_qscale[i]= q/sum;
 830         }
 831
 832         /* find expected bits */
 833         for(i=0; i<rcc->num_entries; i++){
 834             RateControlEntry *rce= &rcc->entry[i];
 835             double bits;
 836             rce->new_qscale= modify_qscale(s, rce, blured_qscale[i], i);
 837             bits= qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;
 838 //printf("%d %f\n", rce->new_bits, blured_qscale[i]);
 839             bits += 8*ff_vbv_update(s, bits);
 840
 841             rce->expected_bits= expected_bits;
 842             expected_bits += bits;
 843         }
 844
 845 //        printf("%f %d %f\n", expected_bits, (int)all_available_bits, rate_factor);
 846         if(expected_bits > all_available_bits) rate_factor-= step;
 847     }
 848     av_free(qscale);
 849     av_free(blured_qscale);
 850
 851     if(abs(expected_bits/all_available_bits - 1.0) > 0.01 ){
 852         av_log(s->avctx, AV_LOG_ERROR, "Error: 2pass curve failed to converge\n");
 853         return -1;
 854     }
 855
 856     return 0;
 857 }