• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • File List
  • Globals

libavcodec/ratecontrol.c

Go to the documentation of this file.
00001 /*
00002  * Rate control for video encoders
00003  *
00004  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
00005  *
00006  * This file is part of FFmpeg.
00007  *
00008  * FFmpeg is free software; you can redistribute it and/or
00009  * modify it under the terms of the GNU Lesser General Public
00010  * License as published by the Free Software Foundation; either
00011  * version 2.1 of the License, or (at your option) any later version.
00012  *
00013  * FFmpeg is distributed in the hope that it will be useful,
00014  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00015  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00016  * Lesser General Public License for more details.
00017  *
00018  * You should have received a copy of the GNU Lesser General Public
00019  * License along with FFmpeg; if not, write to the Free Software
00020  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00021  */
00022 
00028 #include "libavutil/intmath.h"
00029 #include "avcodec.h"
00030 #include "dsputil.h"
00031 #include "ratecontrol.h"
00032 #include "mpegvideo.h"
00033 #include "eval.h"
00034 
00035 #undef NDEBUG // Always check asserts, the speed effect is far too small to disable them.
00036 #include <assert.h>
00037 
00038 #ifndef M_E
00039 #define M_E 2.718281828
00040 #endif
00041 
00042 static int init_pass2(MpegEncContext *s);
00043 static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_factor, int frame_num);
00044 
00045 void ff_write_pass1_stats(MpegEncContext *s){
00046     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 skipcount:%d hbits:%d;\n",
00047             s->current_picture_ptr->display_picture_number, s->current_picture_ptr->coded_picture_number, s->pict_type,
00048             s->current_picture.quality, s->i_tex_bits, s->p_tex_bits, s->mv_bits, s->misc_bits,
00049             s->f_code, s->b_code, s->current_picture.mc_mb_var_sum, s->current_picture.mb_var_sum, s->i_count, s->skip_count, s->header_bits);
00050 }
00051 
00052 static inline double qp2bits(RateControlEntry *rce, double qp){
00053     if(qp<=0.0){
00054         av_log(NULL, AV_LOG_ERROR, "qp<=0.0\n");
00055     }
00056     return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits+1)/ qp;
00057 }
00058 
00059 static inline double bits2qp(RateControlEntry *rce, double bits){
00060     if(bits<0.9){
00061         av_log(NULL, AV_LOG_ERROR, "bits<0.9\n");
00062     }
00063     return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits+1)/ bits;
00064 }
00065 
00066 int ff_rate_control_init(MpegEncContext *s)
00067 {
00068     RateControlContext *rcc= &s->rc_context;
00069     int i;
00070     const char *error = NULL;
00071     static const char * const const_names[]={
00072         "PI",
00073         "E",
00074         "iTex",
00075         "pTex",
00076         "tex",
00077         "mv",
00078         "fCode",
00079         "iCount",
00080         "mcVar",
00081         "var",
00082         "isI",
00083         "isP",
00084         "isB",
00085         "avgQP",
00086         "qComp",
00087 /*        "lastIQP",
00088         "lastPQP",
00089         "lastBQP",
00090         "nextNonBQP",*/
00091         "avgIITex",
00092         "avgPITex",
00093         "avgPPTex",
00094         "avgBPTex",
00095         "avgTex",
00096         NULL
00097     };
00098     static double (* const func1[])(void *, double)={
00099         (void *)bits2qp,
00100         (void *)qp2bits,
00101         NULL
00102     };
00103     static const char * const func1_names[]={
00104         "bits2qp",
00105         "qp2bits",
00106         NULL
00107     };
00108     emms_c();
00109 
00110     rcc->rc_eq_eval = ff_parse_expr(s->avctx->rc_eq ? s->avctx->rc_eq : "tex^qComp", const_names, func1, func1_names, NULL, NULL, &error);
00111     if (!rcc->rc_eq_eval) {
00112         av_log(s->avctx, AV_LOG_ERROR, "Error parsing rc_eq \"%s\": %s\n", s->avctx->rc_eq, error? error : "");
00113         return -1;
00114     }
00115 
00116     for(i=0; i<5; i++){
00117         rcc->pred[i].coeff= FF_QP2LAMBDA * 7.0;
00118         rcc->pred[i].count= 1.0;
00119 
00120         rcc->pred[i].decay= 0.4;
00121         rcc->i_cplx_sum [i]=
00122         rcc->p_cplx_sum [i]=
00123         rcc->mv_bits_sum[i]=
00124         rcc->qscale_sum [i]=
00125         rcc->frame_count[i]= 1; // 1 is better because of 1/0 and such
00126         rcc->last_qscale_for[i]=FF_QP2LAMBDA * 5;
00127     }
00128     rcc->buffer_index= s->avctx->rc_initial_buffer_occupancy;
00129 
00130     if(s->flags&CODEC_FLAG_PASS2){
00131         int i;
00132         char *p;
00133 
00134         /* find number of pics */
00135         p= s->avctx->stats_in;
00136         for(i=-1; p; i++){
00137             p= strchr(p+1, ';');
00138         }
00139         i+= s->max_b_frames;
00140         if(i<=0 || i>=INT_MAX / sizeof(RateControlEntry))
00141             return -1;
00142         rcc->entry = av_mallocz(i*sizeof(RateControlEntry));
00143         rcc->num_entries= i;
00144 
00145         /* init all to skipped p frames (with b frames we might have a not encoded frame at the end FIXME) */
00146         for(i=0; i<rcc->num_entries; i++){
00147             RateControlEntry *rce= &rcc->entry[i];
00148             rce->pict_type= rce->new_pict_type=FF_P_TYPE;
00149             rce->qscale= rce->new_qscale=FF_QP2LAMBDA * 2;
00150             rce->misc_bits= s->mb_num + 10;
00151             rce->mb_var_sum= s->mb_num*100;
00152         }
00153 
00154         /* read stats */
00155         p= s->avctx->stats_in;
00156         for(i=0; i<rcc->num_entries - s->max_b_frames; i++){
00157             RateControlEntry *rce;
00158             int picture_number;
00159             int e;
00160             char *next;
00161 
00162             next= strchr(p, ';');
00163             if(next){
00164                 (*next)=0; //sscanf in unbelievably slow on looong strings //FIXME copy / do not write
00165                 next++;
00166             }
00167             e= sscanf(p, " in:%d ", &picture_number);
00168 
00169             assert(picture_number >= 0);
00170             assert(picture_number < rcc->num_entries);
00171             rce= &rcc->entry[picture_number];
00172 
00173             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 skipcount:%d hbits:%d",
00174                    &rce->pict_type, &rce->qscale, &rce->i_tex_bits, &rce->p_tex_bits, &rce->mv_bits, &rce->misc_bits,
00175                    &rce->f_code, &rce->b_code, &rce->mc_mb_var_sum, &rce->mb_var_sum, &rce->i_count, &rce->skip_count, &rce->header_bits);
00176             if(e!=14){
00177                 av_log(s->avctx, AV_LOG_ERROR, "statistics are damaged at line %d, parser out=%d\n", i, e);
00178                 return -1;
00179             }
00180 
00181             p= next;
00182         }
00183 
00184         if(init_pass2(s) < 0) return -1;
00185 
00186         //FIXME maybe move to end
00187         if((s->flags&CODEC_FLAG_PASS2) && s->avctx->rc_strategy == FF_RC_STRATEGY_XVID) {
00188 #if CONFIG_LIBXVID
00189             return ff_xvid_rate_control_init(s);
00190 #else
00191             av_log(s->avctx, AV_LOG_ERROR, "Xvid ratecontrol requires libavcodec compiled with Xvid support.\n");
00192             return -1;
00193 #endif
00194         }
00195     }
00196 
00197     if(!(s->flags&CODEC_FLAG_PASS2)){
00198 
00199         rcc->short_term_qsum=0.001;
00200         rcc->short_term_qcount=0.001;
00201 
00202         rcc->pass1_rc_eq_output_sum= 0.001;
00203         rcc->pass1_wanted_bits=0.001;
00204 
00205         if(s->avctx->qblur > 1.0){
00206             av_log(s->avctx, AV_LOG_ERROR, "qblur too large\n");
00207             return -1;
00208         }
00209         /* init stuff with the user specified complexity */
00210         if(s->avctx->rc_initial_cplx){
00211             for(i=0; i<60*30; i++){
00212                 double bits= s->avctx->rc_initial_cplx * (i/10000.0 + 1.0)*s->mb_num;
00213                 RateControlEntry rce;
00214 
00215                 if     (i%((s->gop_size+3)/4)==0) rce.pict_type= FF_I_TYPE;
00216                 else if(i%(s->max_b_frames+1))    rce.pict_type= FF_B_TYPE;
00217                 else                              rce.pict_type= FF_P_TYPE;
00218 
00219                 rce.new_pict_type= rce.pict_type;
00220                 rce.mc_mb_var_sum= bits*s->mb_num/100000;
00221                 rce.mb_var_sum   = s->mb_num;
00222                 rce.qscale   = FF_QP2LAMBDA * 2;
00223                 rce.f_code   = 2;
00224                 rce.b_code   = 1;
00225                 rce.misc_bits= 1;
00226 
00227                 if(s->pict_type== FF_I_TYPE){
00228                     rce.i_count   = s->mb_num;
00229                     rce.i_tex_bits= bits;
00230                     rce.p_tex_bits= 0;
00231                     rce.mv_bits= 0;
00232                 }else{
00233                     rce.i_count   = 0; //FIXME we do know this approx
00234                     rce.i_tex_bits= 0;
00235                     rce.p_tex_bits= bits*0.9;
00236                     rce.mv_bits= bits*0.1;
00237                 }
00238                 rcc->i_cplx_sum [rce.pict_type] += rce.i_tex_bits*rce.qscale;
00239                 rcc->p_cplx_sum [rce.pict_type] += rce.p_tex_bits*rce.qscale;
00240                 rcc->mv_bits_sum[rce.pict_type] += rce.mv_bits;
00241                 rcc->frame_count[rce.pict_type] ++;
00242 
00243                 get_qscale(s, &rce, rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum, i);
00244                 rcc->pass1_wanted_bits+= s->bit_rate/(1/av_q2d(s->avctx->time_base)); //FIXME misbehaves a little for variable fps
00245             }
00246         }
00247 
00248     }
00249 
00250     return 0;
00251 }
00252 
00253 void ff_rate_control_uninit(MpegEncContext *s)
00254 {
00255     RateControlContext *rcc= &s->rc_context;
00256     emms_c();
00257 
00258     ff_free_expr(rcc->rc_eq_eval);
00259     av_freep(&rcc->entry);
00260 
00261 #if CONFIG_LIBXVID
00262     if((s->flags&CODEC_FLAG_PASS2) && s->avctx->rc_strategy == FF_RC_STRATEGY_XVID)
00263         ff_xvid_rate_control_uninit(s);
00264 #endif
00265 }
00266 
00267 int ff_vbv_update(MpegEncContext *s, int frame_size){
00268     RateControlContext *rcc= &s->rc_context;
00269     const double fps= 1/av_q2d(s->avctx->time_base);
00270     const int buffer_size= s->avctx->rc_buffer_size;
00271     const double min_rate= s->avctx->rc_min_rate/fps;
00272     const double max_rate= s->avctx->rc_max_rate/fps;
00273 
00274 //printf("%d %f %d %f %f\n", buffer_size, rcc->buffer_index, frame_size, min_rate, max_rate);
00275     if(buffer_size){
00276         int left;
00277 
00278         rcc->buffer_index-= frame_size;
00279         if(rcc->buffer_index < 0){
00280             av_log(s->avctx, AV_LOG_ERROR, "rc buffer underflow\n");
00281             rcc->buffer_index= 0;
00282         }
00283 
00284         left= buffer_size - rcc->buffer_index - 1;
00285         rcc->buffer_index += av_clip(left, min_rate, max_rate);
00286 
00287         if(rcc->buffer_index > buffer_size){
00288             int stuffing= ceil((rcc->buffer_index - buffer_size)/8);
00289 
00290             if(stuffing < 4 && s->codec_id == CODEC_ID_MPEG4)
00291                 stuffing=4;
00292             rcc->buffer_index -= 8*stuffing;
00293 
00294             if(s->avctx->debug & FF_DEBUG_RC)
00295                 av_log(s->avctx, AV_LOG_DEBUG, "stuffing %d bytes\n", stuffing);
00296 
00297             return stuffing;
00298         }
00299     }
00300     return 0;
00301 }
00302 
00306 static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_factor, int frame_num){
00307     RateControlContext *rcc= &s->rc_context;
00308     AVCodecContext *a= s->avctx;
00309     double q, bits;
00310     const int pict_type= rce->new_pict_type;
00311     const double mb_num= s->mb_num;
00312     int i;
00313 
00314     double const_values[]={
00315         M_PI,
00316         M_E,
00317         rce->i_tex_bits*rce->qscale,
00318         rce->p_tex_bits*rce->qscale,
00319         (rce->i_tex_bits + rce->p_tex_bits)*(double)rce->qscale,
00320         rce->mv_bits/mb_num,
00321         rce->pict_type == FF_B_TYPE ? (rce->f_code + rce->b_code)*0.5 : rce->f_code,
00322         rce->i_count/mb_num,
00323         rce->mc_mb_var_sum/mb_num,
00324         rce->mb_var_sum/mb_num,
00325         rce->pict_type == FF_I_TYPE,
00326         rce->pict_type == FF_P_TYPE,
00327         rce->pict_type == FF_B_TYPE,
00328         rcc->qscale_sum[pict_type] / (double)rcc->frame_count[pict_type],
00329         a->qcompress,
00330 /*        rcc->last_qscale_for[FF_I_TYPE],
00331         rcc->last_qscale_for[FF_P_TYPE],
00332         rcc->last_qscale_for[FF_B_TYPE],
00333         rcc->next_non_b_qscale,*/
00334         rcc->i_cplx_sum[FF_I_TYPE] / (double)rcc->frame_count[FF_I_TYPE],
00335         rcc->i_cplx_sum[FF_P_TYPE] / (double)rcc->frame_count[FF_P_TYPE],
00336         rcc->p_cplx_sum[FF_P_TYPE] / (double)rcc->frame_count[FF_P_TYPE],
00337         rcc->p_cplx_sum[FF_B_TYPE] / (double)rcc->frame_count[FF_B_TYPE],
00338         (rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / (double)rcc->frame_count[pict_type],
00339         0
00340     };
00341 
00342     bits= ff_eval_expr(rcc->rc_eq_eval, const_values, rce);
00343     if (isnan(bits)) {
00344         av_log(s->avctx, AV_LOG_ERROR, "Error evaluating rc_eq \"%s\"\n", s->avctx->rc_eq);
00345         return -1;
00346     }
00347 
00348     rcc->pass1_rc_eq_output_sum+= bits;
00349     bits*=rate_factor;
00350     if(bits<0.0) bits=0.0;
00351     bits+= 1.0; //avoid 1/0 issues
00352 
00353     /* user override */
00354     for(i=0; i<s->avctx->rc_override_count; i++){
00355         RcOverride *rco= s->avctx->rc_override;
00356         if(rco[i].start_frame > frame_num) continue;
00357         if(rco[i].end_frame   < frame_num) continue;
00358 
00359         if(rco[i].qscale)
00360             bits= qp2bits(rce, rco[i].qscale); //FIXME move at end to really force it?
00361         else
00362             bits*= rco[i].quality_factor;
00363     }
00364 
00365     q= bits2qp(rce, bits);
00366 
00367     /* I/B difference */
00368     if     (pict_type==FF_I_TYPE && s->avctx->i_quant_factor<0.0)
00369         q= -q*s->avctx->i_quant_factor + s->avctx->i_quant_offset;
00370     else if(pict_type==FF_B_TYPE && s->avctx->b_quant_factor<0.0)
00371         q= -q*s->avctx->b_quant_factor + s->avctx->b_quant_offset;
00372     if(q<1) q=1;
00373 
00374     return q;
00375 }
00376 
00377 static double get_diff_limited_q(MpegEncContext *s, RateControlEntry *rce, double q){
00378     RateControlContext *rcc= &s->rc_context;
00379     AVCodecContext *a= s->avctx;
00380     const int pict_type= rce->new_pict_type;
00381     const double last_p_q    = rcc->last_qscale_for[FF_P_TYPE];
00382     const double last_non_b_q= rcc->last_qscale_for[rcc->last_non_b_pict_type];
00383 
00384     if     (pict_type==FF_I_TYPE && (a->i_quant_factor>0.0 || rcc->last_non_b_pict_type==FF_P_TYPE))
00385         q= last_p_q    *FFABS(a->i_quant_factor) + a->i_quant_offset;
00386     else if(pict_type==FF_B_TYPE && a->b_quant_factor>0.0)
00387         q= last_non_b_q*    a->b_quant_factor  + a->b_quant_offset;
00388     if(q<1) q=1;
00389 
00390     /* last qscale / qdiff stuff */
00391     if(rcc->last_non_b_pict_type==pict_type || pict_type!=FF_I_TYPE){
00392         double last_q= rcc->last_qscale_for[pict_type];
00393         const int maxdiff= FF_QP2LAMBDA * a->max_qdiff;
00394 
00395         if     (q > last_q + maxdiff) q= last_q + maxdiff;
00396         else if(q < last_q - maxdiff) q= last_q - maxdiff;
00397     }
00398 
00399     rcc->last_qscale_for[pict_type]= q; //Note we cannot do that after blurring
00400 
00401     if(pict_type!=FF_B_TYPE)
00402         rcc->last_non_b_pict_type= pict_type;
00403 
00404     return q;
00405 }
00406 
00410 static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type){
00411     int qmin= s->avctx->lmin;
00412     int qmax= s->avctx->lmax;
00413 
00414     assert(qmin <= qmax);
00415 
00416     if(pict_type==FF_B_TYPE){
00417         qmin= (int)(qmin*FFABS(s->avctx->b_quant_factor)+s->avctx->b_quant_offset + 0.5);
00418         qmax= (int)(qmax*FFABS(s->avctx->b_quant_factor)+s->avctx->b_quant_offset + 0.5);
00419     }else if(pict_type==FF_I_TYPE){
00420         qmin= (int)(qmin*FFABS(s->avctx->i_quant_factor)+s->avctx->i_quant_offset + 0.5);
00421         qmax= (int)(qmax*FFABS(s->avctx->i_quant_factor)+s->avctx->i_quant_offset + 0.5);
00422     }
00423 
00424     qmin= av_clip(qmin, 1, FF_LAMBDA_MAX);
00425     qmax= av_clip(qmax, 1, FF_LAMBDA_MAX);
00426 
00427     if(qmax<qmin) qmax= qmin;
00428 
00429     *qmin_ret= qmin;
00430     *qmax_ret= qmax;
00431 }
00432 
00433 static double modify_qscale(MpegEncContext *s, RateControlEntry *rce, double q, int frame_num){
00434     RateControlContext *rcc= &s->rc_context;
00435     int qmin, qmax;
00436     const int pict_type= rce->new_pict_type;
00437     const double buffer_size= s->avctx->rc_buffer_size;
00438     const double fps= 1/av_q2d(s->avctx->time_base);
00439     const double min_rate= s->avctx->rc_min_rate / fps;
00440     const double max_rate= s->avctx->rc_max_rate / fps;
00441 
00442     get_qminmax(&qmin, &qmax, s, pict_type);
00443 
00444     /* modulation */
00445     if(s->avctx->rc_qmod_freq && frame_num%s->avctx->rc_qmod_freq==0 && pict_type==FF_P_TYPE)
00446         q*= s->avctx->rc_qmod_amp;
00447 
00448 //printf("q:%f\n", q);
00449     /* buffer overflow/underflow protection */
00450     if(buffer_size){
00451         double expected_size= rcc->buffer_index;
00452         double q_limit;
00453 
00454         if(min_rate){
00455             double d= 2*(buffer_size - expected_size)/buffer_size;
00456             if(d>1.0) d=1.0;
00457             else if(d<0.0001) d=0.0001;
00458             q*= pow(d, 1.0/s->avctx->rc_buffer_aggressivity);
00459 
00460             q_limit= bits2qp(rce, FFMAX((min_rate - buffer_size + rcc->buffer_index) * s->avctx->rc_min_vbv_overflow_use, 1));
00461             if(q > q_limit){
00462                 if(s->avctx->debug&FF_DEBUG_RC){
00463                     av_log(s->avctx, AV_LOG_DEBUG, "limiting QP %f -> %f\n", q, q_limit);
00464                 }
00465                 q= q_limit;
00466             }
00467         }
00468 
00469         if(max_rate){
00470             double d= 2*expected_size/buffer_size;
00471             if(d>1.0) d=1.0;
00472             else if(d<0.0001) d=0.0001;
00473             q/= pow(d, 1.0/s->avctx->rc_buffer_aggressivity);
00474 
00475             q_limit= bits2qp(rce, FFMAX(rcc->buffer_index * s->avctx->rc_max_available_vbv_use, 1));
00476             if(q < q_limit){
00477                 if(s->avctx->debug&FF_DEBUG_RC){
00478                     av_log(s->avctx, AV_LOG_DEBUG, "limiting QP %f -> %f\n", q, q_limit);
00479                 }
00480                 q= q_limit;
00481             }
00482         }
00483     }
00484 //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);
00485     if(s->avctx->rc_qsquish==0.0 || qmin==qmax){
00486         if     (q<qmin) q=qmin;
00487         else if(q>qmax) q=qmax;
00488     }else{
00489         double min2= log(qmin);
00490         double max2= log(qmax);
00491 
00492         q= log(q);
00493         q= (q - min2)/(max2-min2) - 0.5;
00494         q*= -4.0;
00495         q= 1.0/(1.0 + exp(q));
00496         q= q*(max2-min2) + min2;
00497 
00498         q= exp(q);
00499     }
00500 
00501     return q;
00502 }
00503 
00504 //----------------------------------
00505 // 1 Pass Code
00506 
00507 static double predict_size(Predictor *p, double q, double var)
00508 {
00509      return p->coeff*var / (q*p->count);
00510 }
00511 
00512 /*
00513 static double predict_qp(Predictor *p, double size, double var)
00514 {
00515 //printf("coeff:%f, count:%f, var:%f, size:%f//\n", p->coeff, p->count, var, size);
00516      return p->coeff*var / (size*p->count);
00517 }
00518 */
00519 
00520 static void update_predictor(Predictor *p, double q, double var, double size)
00521 {
00522     double new_coeff= size*q / (var + 1);
00523     if(var<10) return;
00524 
00525     p->count*= p->decay;
00526     p->coeff*= p->decay;
00527     p->count++;
00528     p->coeff+= new_coeff;
00529 }
00530 
00531 static void adaptive_quantization(MpegEncContext *s, double q){
00532     int i;
00533     const float lumi_masking= s->avctx->lumi_masking / (128.0*128.0);
00534     const float dark_masking= s->avctx->dark_masking / (128.0*128.0);
00535     const float temp_cplx_masking= s->avctx->temporal_cplx_masking;
00536     const float spatial_cplx_masking = s->avctx->spatial_cplx_masking;
00537     const float p_masking = s->avctx->p_masking;
00538     const float border_masking = s->avctx->border_masking;
00539     float bits_sum= 0.0;
00540     float cplx_sum= 0.0;
00541     float cplx_tab[s->mb_num];
00542     float bits_tab[s->mb_num];
00543     const int qmin= s->avctx->mb_lmin;
00544     const int qmax= s->avctx->mb_lmax;
00545     Picture * const pic= &s->current_picture;
00546     const int mb_width = s->mb_width;
00547     const int mb_height = s->mb_height;
00548 
00549     for(i=0; i<s->mb_num; i++){
00550         const int mb_xy= s->mb_index2xy[i];
00551         float temp_cplx= sqrt(pic->mc_mb_var[mb_xy]); //FIXME merge in pow()
00552         float spat_cplx= sqrt(pic->mb_var[mb_xy]);
00553         const int lumi= pic->mb_mean[mb_xy];
00554         float bits, cplx, factor;
00555         int mb_x = mb_xy % s->mb_stride;
00556         int mb_y = mb_xy / s->mb_stride;
00557         int mb_distance;
00558         float mb_factor = 0.0;
00559 #if 0
00560         if(spat_cplx < q/3) spat_cplx= q/3; //FIXME finetune
00561         if(temp_cplx < q/3) temp_cplx= q/3; //FIXME finetune
00562 #endif
00563         if(spat_cplx < 4) spat_cplx= 4; //FIXME finetune
00564         if(temp_cplx < 4) temp_cplx= 4; //FIXME finetune
00565 
00566         if((s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTRA)){//FIXME hq mode
00567             cplx= spat_cplx;
00568             factor= 1.0 + p_masking;
00569         }else{
00570             cplx= temp_cplx;
00571             factor= pow(temp_cplx, - temp_cplx_masking);
00572         }
00573         factor*=pow(spat_cplx, - spatial_cplx_masking);
00574 
00575         if(lumi>127)
00576             factor*= (1.0 - (lumi-128)*(lumi-128)*lumi_masking);
00577         else
00578             factor*= (1.0 - (lumi-128)*(lumi-128)*dark_masking);
00579 
00580         if(mb_x < mb_width/5){
00581             mb_distance = mb_width/5 - mb_x;
00582             mb_factor = (float)mb_distance / (float)(mb_width/5);
00583         }else if(mb_x > 4*mb_width/5){
00584             mb_distance = mb_x - 4*mb_width/5;
00585             mb_factor = (float)mb_distance / (float)(mb_width/5);
00586         }
00587         if(mb_y < mb_height/5){
00588             mb_distance = mb_height/5 - mb_y;
00589             mb_factor = FFMAX(mb_factor, (float)mb_distance / (float)(mb_height/5));
00590         }else if(mb_y > 4*mb_height/5){
00591             mb_distance = mb_y - 4*mb_height/5;
00592             mb_factor = FFMAX(mb_factor, (float)mb_distance / (float)(mb_height/5));
00593         }
00594 
00595         factor*= 1.0 - border_masking*mb_factor;
00596 
00597         if(factor<0.00001) factor= 0.00001;
00598 
00599         bits= cplx*factor;
00600         cplx_sum+= cplx;
00601         bits_sum+= bits;
00602         cplx_tab[i]= cplx;
00603         bits_tab[i]= bits;
00604     }
00605 
00606     /* handle qmin/qmax clipping */
00607     if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
00608         float factor= bits_sum/cplx_sum;
00609         for(i=0; i<s->mb_num; i++){
00610             float newq= q*cplx_tab[i]/bits_tab[i];
00611             newq*= factor;
00612 
00613             if     (newq > qmax){
00614                 bits_sum -= bits_tab[i];
00615                 cplx_sum -= cplx_tab[i]*q/qmax;
00616             }
00617             else if(newq < qmin){
00618                 bits_sum -= bits_tab[i];
00619                 cplx_sum -= cplx_tab[i]*q/qmin;
00620             }
00621         }
00622         if(bits_sum < 0.001) bits_sum= 0.001;
00623         if(cplx_sum < 0.001) cplx_sum= 0.001;
00624     }
00625 
00626     for(i=0; i<s->mb_num; i++){
00627         const int mb_xy= s->mb_index2xy[i];
00628         float newq= q*cplx_tab[i]/bits_tab[i];
00629         int intq;
00630 
00631         if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
00632             newq*= bits_sum/cplx_sum;
00633         }
00634 
00635         intq= (int)(newq + 0.5);
00636 
00637         if     (intq > qmax) intq= qmax;
00638         else if(intq < qmin) intq= qmin;
00639 //if(i%s->mb_width==0) printf("\n");
00640 //printf("%2d%3d ", intq, ff_sqrt(s->mc_mb_var[i]));
00641         s->lambda_table[mb_xy]= intq;
00642     }
00643 }
00644 
00645 void ff_get_2pass_fcode(MpegEncContext *s){
00646     RateControlContext *rcc= &s->rc_context;
00647     int picture_number= s->picture_number;
00648     RateControlEntry *rce;
00649 
00650     rce= &rcc->entry[picture_number];
00651     s->f_code= rce->f_code;
00652     s->b_code= rce->b_code;
00653 }
00654 
00655 //FIXME rd or at least approx for dquant
00656 
00657 float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
00658 {
00659     float q;
00660     int qmin, qmax;
00661     float br_compensation;
00662     double diff;
00663     double short_term_q;
00664     double fps;
00665     int picture_number= s->picture_number;
00666     int64_t wanted_bits;
00667     RateControlContext *rcc= &s->rc_context;
00668     AVCodecContext *a= s->avctx;
00669     RateControlEntry local_rce, *rce;
00670     double bits;
00671     double rate_factor;
00672     int var;
00673     const int pict_type= s->pict_type;
00674     Picture * const pic= &s->current_picture;
00675     emms_c();
00676 
00677 #if CONFIG_LIBXVID
00678     if((s->flags&CODEC_FLAG_PASS2) && s->avctx->rc_strategy == FF_RC_STRATEGY_XVID)
00679         return ff_xvid_rate_estimate_qscale(s, dry_run);
00680 #endif
00681 
00682     get_qminmax(&qmin, &qmax, s, pict_type);
00683 
00684     fps= 1/av_q2d(s->avctx->time_base);
00685 //printf("input_pic_num:%d pic_num:%d frame_rate:%d\n", s->input_picture_number, s->picture_number, s->frame_rate);
00686         /* update predictors */
00687     if(picture_number>2 && !dry_run){
00688         const int last_var= s->last_pict_type == FF_I_TYPE ? rcc->last_mb_var_sum : rcc->last_mc_mb_var_sum;
00689         update_predictor(&rcc->pred[s->last_pict_type], rcc->last_qscale, sqrt(last_var), s->frame_bits);
00690     }
00691 
00692     if(s->flags&CODEC_FLAG_PASS2){
00693         assert(picture_number>=0);
00694         assert(picture_number<rcc->num_entries);
00695         rce= &rcc->entry[picture_number];
00696         wanted_bits= rce->expected_bits;
00697     }else{
00698         Picture *dts_pic;
00699         rce= &local_rce;
00700 
00701         //FIXME add a dts field to AVFrame and ensure its set and use it here instead of reordering
00702         //but the reordering is simpler for now until h.264 b pyramid must be handeld
00703         if(s->pict_type == FF_B_TYPE || s->low_delay)
00704             dts_pic= s->current_picture_ptr;
00705         else
00706             dts_pic= s->last_picture_ptr;
00707 
00708 //if(dts_pic)
00709 //            av_log(NULL, AV_LOG_ERROR, "%Ld %Ld %Ld %d\n", s->current_picture_ptr->pts, s->user_specified_pts, dts_pic->pts, picture_number);
00710 
00711         if(!dts_pic || dts_pic->pts == AV_NOPTS_VALUE)
00712             wanted_bits= (uint64_t)(s->bit_rate*(double)picture_number/fps);
00713         else
00714             wanted_bits= (uint64_t)(s->bit_rate*(double)dts_pic->pts/fps);
00715     }
00716 
00717     diff= s->total_bits - wanted_bits;
00718     br_compensation= (a->bit_rate_tolerance - diff)/a->bit_rate_tolerance;
00719     if(br_compensation<=0.0) br_compensation=0.001;
00720 
00721     var= pict_type == FF_I_TYPE ? pic->mb_var_sum : pic->mc_mb_var_sum;
00722 
00723     short_term_q = 0; /* avoid warning */
00724     if(s->flags&CODEC_FLAG_PASS2){
00725         if(pict_type!=FF_I_TYPE)
00726             assert(pict_type == rce->new_pict_type);
00727 
00728         q= rce->new_qscale / br_compensation;
00729 //printf("%f %f %f last:%d var:%d type:%d//\n", q, rce->new_qscale, br_compensation, s->frame_bits, var, pict_type);
00730     }else{
00731         rce->pict_type=
00732         rce->new_pict_type= pict_type;
00733         rce->mc_mb_var_sum= pic->mc_mb_var_sum;
00734         rce->mb_var_sum   = pic->   mb_var_sum;
00735         rce->qscale   = FF_QP2LAMBDA * 2;
00736         rce->f_code   = s->f_code;
00737         rce->b_code   = s->b_code;
00738         rce->misc_bits= 1;
00739 
00740         bits= predict_size(&rcc->pred[pict_type], rce->qscale, sqrt(var));
00741         if(pict_type== FF_I_TYPE){
00742             rce->i_count   = s->mb_num;
00743             rce->i_tex_bits= bits;
00744             rce->p_tex_bits= 0;
00745             rce->mv_bits= 0;
00746         }else{
00747             rce->i_count   = 0; //FIXME we do know this approx
00748             rce->i_tex_bits= 0;
00749             rce->p_tex_bits= bits*0.9;
00750 
00751             rce->mv_bits= bits*0.1;
00752         }
00753         rcc->i_cplx_sum [pict_type] += rce->i_tex_bits*rce->qscale;
00754         rcc->p_cplx_sum [pict_type] += rce->p_tex_bits*rce->qscale;
00755         rcc->mv_bits_sum[pict_type] += rce->mv_bits;
00756         rcc->frame_count[pict_type] ++;
00757 
00758         bits= rce->i_tex_bits + rce->p_tex_bits;
00759         rate_factor= rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum * br_compensation;
00760 
00761         q= get_qscale(s, rce, rate_factor, picture_number);
00762         if (q < 0)
00763             return -1;
00764 
00765         assert(q>0.0);
00766 //printf("%f ", q);
00767         q= get_diff_limited_q(s, rce, q);
00768 //printf("%f ", q);
00769         assert(q>0.0);
00770 
00771         if(pict_type==FF_P_TYPE || s->intra_only){ //FIXME type dependent blur like in 2-pass
00772             rcc->short_term_qsum*=a->qblur;
00773             rcc->short_term_qcount*=a->qblur;
00774 
00775             rcc->short_term_qsum+= q;
00776             rcc->short_term_qcount++;
00777 //printf("%f ", q);
00778             q= short_term_q= rcc->short_term_qsum/rcc->short_term_qcount;
00779 //printf("%f ", q);
00780         }
00781         assert(q>0.0);
00782 
00783         q= modify_qscale(s, rce, q, picture_number);
00784 
00785         rcc->pass1_wanted_bits+= s->bit_rate/fps;
00786 
00787         assert(q>0.0);
00788     }
00789 
00790     if(s->avctx->debug&FF_DEBUG_RC){
00791         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",
00792         av_get_pict_type_char(pict_type), qmin, q, qmax, picture_number, (int)wanted_bits/1000, (int)s->total_bits/1000,
00793         br_compensation, short_term_q, s->frame_bits, pic->mb_var_sum, pic->mc_mb_var_sum, s->bit_rate/1000, (int)fps
00794         );
00795     }
00796 
00797     if     (q<qmin) q=qmin;
00798     else if(q>qmax) q=qmax;
00799 
00800     if(s->adaptive_quant)
00801         adaptive_quantization(s, q);
00802     else
00803         q= (int)(q + 0.5);
00804 
00805     if(!dry_run){
00806         rcc->last_qscale= q;
00807         rcc->last_mc_mb_var_sum= pic->mc_mb_var_sum;
00808         rcc->last_mb_var_sum= pic->mb_var_sum;
00809     }
00810 #if 0
00811 {
00812     static int mvsum=0, texsum=0;
00813     mvsum += s->mv_bits;
00814     texsum += s->i_tex_bits + s->p_tex_bits;
00815     printf("%d %d//\n\n", mvsum, texsum);
00816 }
00817 #endif
00818     return q;
00819 }
00820 
00821 //----------------------------------------------
00822 // 2-Pass code
00823 
00824 static int init_pass2(MpegEncContext *s)
00825 {
00826     RateControlContext *rcc= &s->rc_context;
00827     AVCodecContext *a= s->avctx;
00828     int i, toobig;
00829     double fps= 1/av_q2d(s->avctx->time_base);
00830     double complexity[5]={0,0,0,0,0};   // aproximate bits at quant=1
00831     uint64_t const_bits[5]={0,0,0,0,0}; // quantizer independent bits
00832     uint64_t all_const_bits;
00833     uint64_t all_available_bits= (uint64_t)(s->bit_rate*(double)rcc->num_entries/fps);
00834     double rate_factor=0;
00835     double step;
00836     //int last_i_frame=-10000000;
00837     const int filter_size= (int)(a->qblur*4) | 1;
00838     double expected_bits;
00839     double *qscale, *blurred_qscale, qscale_sum;
00840 
00841     /* find complexity & const_bits & decide the pict_types */
00842     for(i=0; i<rcc->num_entries; i++){
00843         RateControlEntry *rce= &rcc->entry[i];
00844 
00845         rce->new_pict_type= rce->pict_type;
00846         rcc->i_cplx_sum [rce->pict_type] += rce->i_tex_bits*rce->qscale;
00847         rcc->p_cplx_sum [rce->pict_type] += rce->p_tex_bits*rce->qscale;
00848         rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits;
00849         rcc->frame_count[rce->pict_type] ++;
00850 
00851         complexity[rce->new_pict_type]+= (rce->i_tex_bits+ rce->p_tex_bits)*(double)rce->qscale;
00852         const_bits[rce->new_pict_type]+= rce->mv_bits + rce->misc_bits;
00853     }
00854     all_const_bits= const_bits[FF_I_TYPE] + const_bits[FF_P_TYPE] + const_bits[FF_B_TYPE];
00855 
00856     if(all_available_bits < all_const_bits){
00857         av_log(s->avctx, AV_LOG_ERROR, "requested bitrate is too low\n");
00858         return -1;
00859     }
00860 
00861     qscale= av_malloc(sizeof(double)*rcc->num_entries);
00862     blurred_qscale= av_malloc(sizeof(double)*rcc->num_entries);
00863     toobig = 0;
00864 
00865     for(step=256*256; step>0.0000001; step*=0.5){
00866         expected_bits=0;
00867         rate_factor+= step;
00868 
00869         rcc->buffer_index= s->avctx->rc_buffer_size/2;
00870 
00871         /* find qscale */
00872         for(i=0; i<rcc->num_entries; i++){
00873             qscale[i]= get_qscale(s, &rcc->entry[i], rate_factor, i);
00874         }
00875         assert(filter_size%2==1);
00876 
00877         /* fixed I/B QP relative to P mode */
00878         for(i=rcc->num_entries-1; i>=0; i--){
00879             RateControlEntry *rce= &rcc->entry[i];
00880 
00881             qscale[i]= get_diff_limited_q(s, rce, qscale[i]);
00882         }
00883 
00884         /* smooth curve */
00885         for(i=0; i<rcc->num_entries; i++){
00886             RateControlEntry *rce= &rcc->entry[i];
00887             const int pict_type= rce->new_pict_type;
00888             int j;
00889             double q=0.0, sum=0.0;
00890 
00891             for(j=0; j<filter_size; j++){
00892                 int index= i+j-filter_size/2;
00893                 double d= index-i;
00894                 double coeff= a->qblur==0 ? 1.0 : exp(-d*d/(a->qblur * a->qblur));
00895 
00896                 if(index < 0 || index >= rcc->num_entries) continue;
00897                 if(pict_type != rcc->entry[index].new_pict_type) continue;
00898                 q+= qscale[index] * coeff;
00899                 sum+= coeff;
00900             }
00901             blurred_qscale[i]= q/sum;
00902         }
00903 
00904         /* find expected bits */
00905         for(i=0; i<rcc->num_entries; i++){
00906             RateControlEntry *rce= &rcc->entry[i];
00907             double bits;
00908             rce->new_qscale= modify_qscale(s, rce, blurred_qscale[i], i);
00909             bits= qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;
00910 //printf("%d %f\n", rce->new_bits, blurred_qscale[i]);
00911             bits += 8*ff_vbv_update(s, bits);
00912 
00913             rce->expected_bits= expected_bits;
00914             expected_bits += bits;
00915         }
00916 
00917         /*
00918         av_log(s->avctx, AV_LOG_INFO,
00919             "expected_bits: %f all_available_bits: %d rate_factor: %f\n",
00920             expected_bits, (int)all_available_bits, rate_factor);
00921         */
00922         if(expected_bits > all_available_bits) {
00923             rate_factor-= step;
00924             ++toobig;
00925         }
00926     }
00927     av_free(qscale);
00928     av_free(blurred_qscale);
00929 
00930     /* check bitrate calculations and print info */
00931     qscale_sum = 0.0;
00932     for(i=0; i<rcc->num_entries; i++){
00933         /* av_log(s->avctx, AV_LOG_DEBUG, "[lavc rc] entry[%d].new_qscale = %.3f  qp = %.3f\n",
00934             i, rcc->entry[i].new_qscale, rcc->entry[i].new_qscale / FF_QP2LAMBDA); */
00935         qscale_sum += av_clip(rcc->entry[i].new_qscale / FF_QP2LAMBDA, s->avctx->qmin, s->avctx->qmax);
00936     }
00937     assert(toobig <= 40);
00938     av_log(s->avctx, AV_LOG_DEBUG,
00939         "[lavc rc] requested bitrate: %d bps  expected bitrate: %d bps\n",
00940         s->bit_rate,
00941         (int)(expected_bits / ((double)all_available_bits/s->bit_rate)));
00942     av_log(s->avctx, AV_LOG_DEBUG,
00943         "[lavc rc] estimated target average qp: %.3f\n",
00944         (float)qscale_sum / rcc->num_entries);
00945     if (toobig == 0) {
00946         av_log(s->avctx, AV_LOG_INFO,
00947             "[lavc rc] Using all of requested bitrate is not "
00948             "necessary for this video with these parameters.\n");
00949     } else if (toobig == 40) {
00950         av_log(s->avctx, AV_LOG_ERROR,
00951             "[lavc rc] Error: bitrate too low for this video "
00952             "with these parameters.\n");
00953         return -1;
00954     } else if (fabs(expected_bits/all_available_bits - 1.0) > 0.01) {
00955         av_log(s->avctx, AV_LOG_ERROR,
00956             "[lavc rc] Error: 2pass curve failed to converge\n");
00957         return -1;
00958     }
00959 
00960     return 0;
00961 }

Generated on Fri Sep 16 2011 17:17:42 for FFmpeg by  doxygen 1.7.1