Libav
|
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 }