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

Generated on Tue Nov 4 2014 12:59:22 for ffmpeg by  doxygen 1.7.1