35 #undef NDEBUG // Always check asserts, the speed effect is far too small to disable them.
39 #define M_E 2.718281828
46 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",
97 static double (*
const func1[])(
void *, double)={
102 static const char *
const func1_names[]={
161 next= strchr(p,
';');
166 e= sscanf(p,
" in:%d ", &picture_number);
168 assert(picture_number >= 0);
169 assert(picture_number < rcc->num_entries);
170 rce= &rcc->
entry[picture_number];
172 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",
210 for(i=0; i<60*30; i++){
274 buffer_size, rcc->
buffer_index, frame_size, min_rate, max_rate);
288 int stuffing= ceil((rcc->
buffer_index - buffer_size)/8);
311 const double mb_num= s->
mb_num;
350 if(bits<0.0) bits=0.0;
357 if(rco[i].
end_frame < frame_num)
continue;
360 bits=
qp2bits(rce, rco[i].qscale);
395 if (q > last_q + maxdiff) q= last_q + maxdiff;
396 else if(q < last_q - maxdiff) q= last_q - maxdiff;
414 assert(qmin <= qmax);
427 if(qmax<qmin) qmax= qmin;
454 double d= 2*(buffer_size - expected_size)/buffer_size;
456 else if(d<0.0001) d=0.0001;
469 double d= 2*expected_size/buffer_size;
471 else if(d<0.0001) d=0.0001;
483 av_dlog(s,
"q:%f max:%f min:%f size:%f index:%f agr:%f\n",
488 else if(q>qmax) q=qmax;
490 double min2= log(qmin);
491 double max2= log(qmax);
494 q= (q - min2)/(max2-min2) - 0.5;
496 q= 1.0/(1.0 + exp(q));
497 q= q*(max2-min2) + min2;
515 double new_coeff= size*q / (var + 1);
521 p->
coeff+= new_coeff;
542 for(i=0; i<s->
mb_num; i++){
544 float temp_cplx= sqrt(pic->
mc_mb_var[mb_xy]);
545 float spat_cplx= sqrt(pic->
mb_var[mb_xy]);
546 const int lumi= pic->
mb_mean[mb_xy];
547 float bits, cplx, factor;
551 float mb_factor = 0.0;
552 if(spat_cplx < 4) spat_cplx= 4;
553 if(temp_cplx < 4) temp_cplx= 4;
557 factor= 1.0 + p_masking;
560 factor= pow(temp_cplx, - temp_cplx_masking);
562 factor*=pow(spat_cplx, - spatial_cplx_masking);
565 factor*= (1.0 - (lumi-128)*(lumi-128)*lumi_masking);
567 factor*= (1.0 - (lumi-128)*(lumi-128)*dark_masking);
569 if(mb_x < mb_width/5){
570 mb_distance = mb_width/5 - mb_x;
571 mb_factor = (float)mb_distance / (
float)(mb_width/5);
572 }
else if(mb_x > 4*mb_width/5){
573 mb_distance = mb_x - 4*mb_width/5;
574 mb_factor = (float)mb_distance / (
float)(mb_width/5);
576 if(mb_y < mb_height/5){
577 mb_distance = mb_height/5 - mb_y;
578 mb_factor =
FFMAX(mb_factor, (
float)mb_distance / (
float)(mb_height/5));
579 }
else if(mb_y > 4*mb_height/5){
580 mb_distance = mb_y - 4*mb_height/5;
581 mb_factor =
FFMAX(mb_factor, (
float)mb_distance / (
float)(mb_height/5));
584 factor*= 1.0 - border_masking*mb_factor;
586 if(factor<0.00001) factor= 0.00001;
597 float factor= bits_sum/cplx_sum;
598 for(i=0; i<s->
mb_num; i++){
599 float newq= q*cplx_tab[i]/bits_tab[i];
603 bits_sum -= bits_tab[i];
604 cplx_sum -= cplx_tab[i]*q/qmax;
606 else if(newq < qmin){
607 bits_sum -= bits_tab[i];
608 cplx_sum -= cplx_tab[i]*q/qmin;
611 if(bits_sum < 0.001) bits_sum= 0.001;
612 if(cplx_sum < 0.001) cplx_sum= 0.001;
615 for(i=0; i<s->
mb_num; i++){
617 float newq= q*cplx_tab[i]/bits_tab[i];
621 newq*= bits_sum/cplx_sum;
624 intq= (int)(newq + 0.5);
626 if (intq > qmax) intq= qmax;
627 else if(intq < qmin) intq= qmin;
637 rce= &rcc->
entry[picture_number];
648 float br_compensation;
673 if(picture_number>2 && !dry_run){
679 assert(picture_number>=0);
680 assert(picture_number<rcc->num_entries);
681 rce= &rcc->
entry[picture_number];
695 wanted_bits= (uint64_t)(s->
bit_rate*(
double)picture_number/fps);
697 wanted_bits = (uint64_t)(s->
bit_rate*(
double)dts_pic->
f.
pts / fps);
702 if(br_compensation<=0.0) br_compensation=0.001;
713 br_compensation, s->
frame_bits, var, pict_type);
745 q=
get_qscale(s, rce, rate_factor, picture_number);
771 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",
778 else if(q>qmax) q=qmax;
802 double complexity[5]={0,0,0,0,0};
803 uint64_t const_bits[5]={0,0,0,0,0};
804 uint64_t all_const_bits;
806 double rate_factor=0;
809 const int filter_size= (int)(a->
qblur*4) | 1;
810 double expected_bits;
811 double *qscale, *blurred_qscale, qscale_sum;
828 if(all_available_bits < all_const_bits){
837 for(step=256*256; step>0.0000001; step*=0.5){
849 assert(filter_size%2==1);
863 double q=0.0, sum=0.0;
865 for(j=0; j<filter_size; j++){
866 int index= i+j-filter_size/2;
870 if(index < 0 || index >= rcc->
num_entries)
continue;
872 q+= qscale[
index] * coeff;
875 blurred_qscale[i]= q/sum;
887 expected_bits +=
bits;
891 "expected_bits: %f all_available_bits: %d rate_factor: %f\n",
892 expected_bits, (
int)all_available_bits, rate_factor);
893 if(expected_bits > all_available_bits) {
904 av_dlog(s,
"[lavc rc] entry[%d].new_qscale = %.3f qp = %.3f\n",
910 assert(toobig <= 40);
912 "[lavc rc] requested bitrate: %d bps expected bitrate: %d bps\n",
914 (
int)(expected_bits / ((
double)all_available_bits/s->
bit_rate)));
916 "[lavc rc] estimated target average qp: %.3f\n",
920 "[lavc rc] Using all of requested bitrate is not "
921 "necessary for this video with these parameters.\n");
922 }
else if (toobig == 40) {
924 "[lavc rc] Error: bitrate too low for this video "
925 "with these parameters.\n");
927 }
else if (fabs(expected_bits/all_available_bits - 1.0) > 0.01) {
929 "[lavc rc] Error: 2pass curve failed to converge\n");
int frame_bits
bits used for the current frame
RateControlContext rc_context
contains stuff only accessed in ratecontrol.c
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
double pass1_rc_eq_output_sum
sum of the output of the rc equation, this is used for normalization
uint8_t * mb_mean
Table for MB luminance.
float qblur
amount of qscale smoothing over time (0.0-1.0)
float border_masking
Border processing masking, raises the quantizer for mbs on the borders of the picture.
uint16_t * mb_var
Table for MB variances.
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
#define CANDIDATE_MB_TYPE_INTRA
void ff_get_2pass_fcode(MpegEncContext *s)
int mb_lmin
minimum MB lagrange multipler
static void update_predictor(Predictor *p, double q, double var, double size)
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
av_dlog(ac->avr,"%d samples - audio_convert: %s to %s (%s)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic?ac->func_descr_generic:ac->func_descr)
int av_expr_parse(AVExpr **expr, const char *s, const char *const *const_names, const char *const *func1_names, double(*const *funcs1)(void *, double), const char *const *func2_names, double(*const *funcs2)(void *, double, double), int log_offset, void *log_ctx)
Parse an expression.
int mb_num
number of MBs of a picture
int lmax
maximum Lagrange multipler
float i_quant_offset
qscale offset between P and I-frames
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type)
Get the qmin & qmax for pict_type.
float p_masking
p block masking (0-> disabled)
int bit_rate_tolerance
number of bits the bitstream is allowed to diverge from the reference.
int mb_lmax
maximum MB lagrange multipler
static av_always_inline av_const int isnan(float x)
float b_quant_factor
qscale factor between IP and B-frames If > 0 then the last P-frame quantizer will be used (q= lastp_q...
int64_t pts
presentation timestamp in time_base units (time when frame should be shown to user) If AV_NOPTS_VALUE...
int misc_bits
cbp, mb_type
Picture current_picture
copy of the current picture structure.
int rc_strategy
obsolete FIXME remove
static double av_q2d(AVRational a)
Convert rational to double.
static const double const_values[]
char av_get_picture_type_char(enum AVPictureType pict_type)
Return a single letter to describe the given picture type pict_type.
int mb_height
number of MBs horizontally & vertically
float lumi_masking
luminance masking (0-> disabled)
char * stats_out
pass1 encoding statistics output buffer
#define FF_RC_STRATEGY_XVID
int num_entries
number of RateControlEntries
int intra_only
if true, only intra pictures are generated
static const uint8_t frame_size[4]
static void adaptive_quantization(MpegEncContext *s, double q)
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
int qmax
maximum quantizer
void ff_write_pass1_stats(MpegEncContext *s)
static double predict_size(Predictor *p, double q, double var)
int rc_max_rate
maximum bitrate
void ff_rate_control_uninit(MpegEncContext *s)
void av_log(void *avcl, int level, const char *fmt,...)
float i_quant_factor
qscale factor between P and I-frames If > 0 then the last p frame quantizer will be used (q= lastp_q*...
uint16_t * mb_type
Table for candidate MB types for encoding.
const char * rc_eq
rate control equation
int low_delay
no reordering needed / has no b-frames
int ff_xvid_rate_control_init(MpegEncContext *s)
static const char *const const_names[]
int rc_buffer_size
decoder bitstream buffer size
int rc_override_count
ratecontrol override, see RcOverride
#define CODEC_FLAG_NORMALIZE_AQP
int display_picture_number
picture number in display order
Picture * current_picture_ptr
pointer to the current picture
float rc_max_available_vbv_use
Ratecontrol attempt to use, at maximum, of what can be used without an underflow. ...
float rc_min_vbv_overflow_use
Ratecontrol attempt to use, at least, times the amount needed to prevent a vbv overflow.
float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
float rc_qsquish
ratecontrol qmin qmax limiting method 0-> clipping, 1-> use a nice continuous function to limit qscal...
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
int max_qdiff
maximum quantizer difference between frames
int lmin
minimum Lagrange multipler
double pass1_wanted_bits
bits which should have been outputed by the pass1 code (including complexity init) ...
int * mb_index2xy
mb_index -> mb_x + mb_y*mb_stride
void ff_xvid_rate_control_uninit(MpegEncContext *s)
uint16_t * mc_mb_var
Table for motion compensated MB variances.
float rc_initial_cplx
initial complexity for pass1 ratecontrol
int coded_picture_number
picture number in bitstream order
double buffer_index
amount of bits in the video/audio buffer
void av_expr_free(AVExpr *e)
Free a parsed expression previously created with av_expr_parse().
main external API structure.
int qmin
minimum quantizer
static int start_frame(AVCodecContext *avctx, av_unused const uint8_t *buffer, av_unused uint32_t size)
float spatial_cplx_masking
spatial complexity masking (0-> disabled)
float rc_buffer_aggressivity
float b_quant_offset
qscale offset between IP and B-frames
int f_code
forward MV resolution
double last_qscale_for[5]
last qscale for a specific pict type, used for max_diff & ipb factor stuff
float qcompress
amount of qscale change between easy & hard scenes (0.0-1.0)
int max_b_frames
max number of b-frames for encoding
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
int bit_rate
wanted bit rate
float dark_masking
darkness masking (0-> disabled)
float temporal_cplx_masking
temporary complexity masking (0-> disabled)
double short_term_qsum
sum of recent qscales
struct AVCodecContext * avctx
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
static int init_pass2(MpegEncContext *s)
static double qp2bits(RateControlEntry *rce, double qp)
int adaptive_quant
use adaptive quantization
Picture * last_picture_ptr
pointer to the previous picture.
int ff_rate_control_init(MpegEncContext *s)
int ff_vbv_update(MpegEncContext *s, int frame_size)
static double bits2qp(RateControlEntry *rce, double bits)
static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_factor, int frame_num)
Modify the bitrate curve from pass1 for one frame.
double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
Evaluate a previously parsed expression.
static double get_diff_limited_q(MpegEncContext *s, RateControlEntry *rce, double q)
int mb_var_sum
sum of MB variance for current frame
int flags
AVCodecContext.flags (HQ, MV4, ...)
int mc_mb_var_sum
motion compensated MB variance for current frame
int rc_min_rate
minimum bitrate
int b_code
backward MV resolution for B Frames (mpeg4)
double short_term_qcount
count of recent qscales
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
float ff_xvid_rate_estimate_qscale(MpegEncContext *s, int dry_run)
simple arithmetic expression evaluator
static int end_frame(AVCodecContext *avctx)
static double modify_qscale(MpegEncContext *s, RateControlEntry *rce, double q, int frame_num)