mirror of
https://git.videolan.org/git/ffmpeg.git
synced 2024-08-09 19:05:05 +02:00
ratecontrol: K&R cosmetic formatting
Signed-off-by: Diego Biurrun <diego@biurrun.de>
This commit is contained in:
Luca Barbato
Diego Biurrun
parent
f6804c3e1b
commit
f61272f0ef
@ -40,23 +40,40 @@
|
||||
#endif
|
||||
|
||||
static int init_pass2(MpegEncContext *s);
|
||||
static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_factor, int frame_num);
|
||||
static double get_qscale(MpegEncContext *s, RateControlEntry *rce,
|
||||
double rate_factor, int frame_num);
|
||||
|
||||
void ff_write_pass1_stats(MpegEncContext *s){
|
||||
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",
|
||||
s->current_picture_ptr->f.display_picture_number, s->current_picture_ptr->f.coded_picture_number, s->pict_type,
|
||||
s->current_picture.f.quality, s->i_tex_bits, s->p_tex_bits, s->mv_bits, s->misc_bits,
|
||||
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);
|
||||
void ff_write_pass1_stats(MpegEncContext *s)
|
||||
{
|
||||
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",
|
||||
s->current_picture_ptr->f.display_picture_number,
|
||||
s->current_picture_ptr->f.coded_picture_number,
|
||||
s->pict_type,
|
||||
s->current_picture.f.quality,
|
||||
s->i_tex_bits,
|
||||
s->p_tex_bits,
|
||||
s->mv_bits,
|
||||
s->misc_bits,
|
||||
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);
|
||||
}
|
||||
|
||||
static inline double qp2bits(RateControlEntry *rce, double qp){
|
||||
static inline double qp2bits(RateControlEntry *rce, double qp)
|
||||
{
|
||||
if (qp <= 0.0) {
|
||||
av_log(NULL, AV_LOG_ERROR, "qp<=0.0\n");
|
||||
}
|
||||
return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits + 1) / qp;
|
||||
}
|
||||
|
||||
static inline double bits2qp(RateControlEntry *rce, double bits){
|
||||
static inline double bits2qp(RateControlEntry *rce, double bits)
|
||||
{
|
||||
if (bits < 0.9) {
|
||||
av_log(NULL, AV_LOG_ERROR, "bits<0.9\n");
|
||||
}
|
||||
@ -83,10 +100,12 @@ int ff_rate_control_init(MpegEncContext *s)
|
||||
"isB",
|
||||
"avgQP",
|
||||
"qComp",
|
||||
/* "lastIQP",
|
||||
#if 0
|
||||
"lastIQP",
|
||||
"lastPQP",
|
||||
"lastBQP",
|
||||
"nextNonBQP",*/
|
||||
"nextNonBQP",
|
||||
#endif
|
||||
"avgIITex",
|
||||
"avgPITex",
|
||||
"avgPPTex",
|
||||
@ -106,7 +125,10 @@ int ff_rate_control_init(MpegEncContext *s)
|
||||
};
|
||||
emms_c();
|
||||
|
||||
res = av_expr_parse(&rcc->rc_eq_eval, s->avctx->rc_eq ? s->avctx->rc_eq : "tex^qComp", const_names, func1_names, func1, NULL, NULL, 0, s->avctx);
|
||||
res = av_expr_parse(&rcc->rc_eq_eval,
|
||||
s->avctx->rc_eq ? s->avctx->rc_eq : "tex^qComp",
|
||||
const_names, func1_names, func1,
|
||||
NULL, NULL, 0, s->avctx);
|
||||
if (res < 0) {
|
||||
av_log(s->avctx, AV_LOG_ERROR, "Error parsing rc_eq \"%s\"\n", s->avctx->rc_eq);
|
||||
return res;
|
||||
@ -115,13 +137,14 @@ int ff_rate_control_init(MpegEncContext *s)
|
||||
for (i = 0; i < 5; i++) {
|
||||
rcc->pred[i].coeff = FF_QP2LAMBDA * 7.0;
|
||||
rcc->pred[i].count = 1.0;
|
||||
|
||||
rcc->pred[i].decay = 0.4;
|
||||
|
||||
rcc->i_cplx_sum [i] =
|
||||
rcc->p_cplx_sum [i] =
|
||||
rcc->mv_bits_sum[i] =
|
||||
rcc->qscale_sum [i] =
|
||||
rcc->frame_count[i] = 1; // 1 is better because of 1/0 and such
|
||||
|
||||
rcc->last_qscale_for[i] = FF_QP2LAMBDA * 5;
|
||||
}
|
||||
rcc->buffer_index = s->avctx->rc_initial_buffer_occupancy;
|
||||
@ -132,18 +155,19 @@ int ff_rate_control_init(MpegEncContext *s)
|
||||
|
||||
/* find number of pics */
|
||||
p = s->avctx->stats_in;
|
||||
for(i=-1; p; i++){
|
||||
for (i = -1; p; i++)
|
||||
p = strchr(p + 1, ';');
|
||||
}
|
||||
i += s->max_b_frames;
|
||||
if (i <= 0 || i >= INT_MAX / sizeof(RateControlEntry))
|
||||
return -1;
|
||||
rcc->entry = av_mallocz(i * sizeof(RateControlEntry));
|
||||
rcc->num_entries = i;
|
||||
|
||||
/* init all to skipped p frames (with b frames we might have a not encoded frame at the end FIXME) */
|
||||
/* init all to skipped p frames
|
||||
* (with b frames we might have a not encoded frame at the end FIXME) */
|
||||
for (i = 0; i < rcc->num_entries; i++) {
|
||||
RateControlEntry *rce = &rcc->entry[i];
|
||||
|
||||
rce->pict_type = rce->new_pict_type = AV_PICTURE_TYPE_P;
|
||||
rce->qscale = rce->new_qscale = FF_QP2LAMBDA * 2;
|
||||
rce->misc_bits = s->mb_num + 10;
|
||||
@ -170,31 +194,37 @@ int ff_rate_control_init(MpegEncContext *s)
|
||||
rce = &rcc->entry[picture_number];
|
||||
|
||||
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",
|
||||
&rce->pict_type, &rce->qscale, &rce->i_tex_bits, &rce->p_tex_bits, &rce->mv_bits, &rce->misc_bits,
|
||||
&rce->f_code, &rce->b_code, &rce->mc_mb_var_sum, &rce->mb_var_sum, &rce->i_count, &rce->skip_count, &rce->header_bits);
|
||||
&rce->pict_type, &rce->qscale, &rce->i_tex_bits, &rce->p_tex_bits,
|
||||
&rce->mv_bits, &rce->misc_bits,
|
||||
&rce->f_code, &rce->b_code,
|
||||
&rce->mc_mb_var_sum, &rce->mb_var_sum,
|
||||
&rce->i_count, &rce->skip_count, &rce->header_bits);
|
||||
if (e != 14) {
|
||||
av_log(s->avctx, AV_LOG_ERROR, "statistics are damaged at line %d, parser out=%d\n", i, e);
|
||||
av_log(s->avctx, AV_LOG_ERROR,
|
||||
"statistics are damaged at line %d, parser out=%d\n",
|
||||
i, e);
|
||||
return -1;
|
||||
}
|
||||
|
||||
p = next;
|
||||
}
|
||||
|
||||
if(init_pass2(s) < 0) return -1;
|
||||
if (init_pass2(s) < 0)
|
||||
return -1;
|
||||
|
||||
// FIXME maybe move to end
|
||||
if ((s->flags & CODEC_FLAG_PASS2) && s->avctx->rc_strategy == FF_RC_STRATEGY_XVID) {
|
||||
#if CONFIG_LIBXVID
|
||||
return ff_xvid_rate_control_init(s);
|
||||
#else
|
||||
av_log(s->avctx, AV_LOG_ERROR, "Xvid ratecontrol requires libavcodec compiled with Xvid support.\n");
|
||||
av_log(s->avctx, AV_LOG_ERROR,
|
||||
"Xvid ratecontrol requires libavcodec compiled with Xvid support.\n");
|
||||
return -1;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
if (!(s->flags & CODEC_FLAG_PASS2)) {
|
||||
|
||||
rcc->short_term_qsum = 0.001;
|
||||
rcc->short_term_qcount = 0.001;
|
||||
|
||||
@ -211,13 +241,17 @@ int ff_rate_control_init(MpegEncContext *s)
|
||||
double bits = s->avctx->rc_initial_cplx * (i / 10000.0 + 1.0) * s->mb_num;
|
||||
RateControlEntry rce;
|
||||
|
||||
if (i%((s->gop_size+3)/4)==0) rce.pict_type= AV_PICTURE_TYPE_I;
|
||||
else if(i%(s->max_b_frames+1)) rce.pict_type= AV_PICTURE_TYPE_B;
|
||||
else rce.pict_type= AV_PICTURE_TYPE_P;
|
||||
if (i % ((s->gop_size + 3) / 4) == 0)
|
||||
rce.pict_type = AV_PICTURE_TYPE_I;
|
||||
else if (i % (s->max_b_frames + 1))
|
||||
rce.pict_type = AV_PICTURE_TYPE_B;
|
||||
else
|
||||
rce.pict_type = AV_PICTURE_TYPE_P;
|
||||
|
||||
rce.new_pict_type = rce.pict_type;
|
||||
rce.mc_mb_var_sum = bits * s->mb_num / 100000;
|
||||
rce.mb_var_sum = s->mb_num;
|
||||
|
||||
rce.qscale = FF_QP2LAMBDA * 2;
|
||||
rce.f_code = 2;
|
||||
rce.b_code = 1;
|
||||
@ -240,10 +274,11 @@ int ff_rate_control_init(MpegEncContext *s)
|
||||
rcc->frame_count[rce.pict_type]++;
|
||||
|
||||
get_qscale(s, &rce, rcc->pass1_wanted_bits / rcc->pass1_rc_eq_output_sum, i);
|
||||
rcc->pass1_wanted_bits+= s->bit_rate/(1/av_q2d(s->avctx->time_base)); //FIXME misbehaves a little for variable fps
|
||||
}
|
||||
}
|
||||
|
||||
// FIXME misbehaves a little for variable fps
|
||||
rcc->pass1_wanted_bits += s->bit_rate / (1 / av_q2d(s->avctx->time_base));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
@ -263,7 +298,8 @@ void ff_rate_control_uninit(MpegEncContext *s)
|
||||
#endif
|
||||
}
|
||||
|
||||
int ff_vbv_update(MpegEncContext *s, int frame_size){
|
||||
int ff_vbv_update(MpegEncContext *s, int frame_size)
|
||||
{
|
||||
RateControlContext *rcc = &s->rc_context;
|
||||
const double fps = 1 / av_q2d(s->avctx->time_base);
|
||||
const int buffer_size = s->avctx->rc_buffer_size;
|
||||
@ -272,6 +308,7 @@ int ff_vbv_update(MpegEncContext *s, int frame_size){
|
||||
|
||||
av_dlog(s, "%d %f %d %f %f\n",
|
||||
buffer_size, rcc->buffer_index, frame_size, min_rate, max_rate);
|
||||
|
||||
if (buffer_size) {
|
||||
int left;
|
||||
|
||||
@ -303,12 +340,14 @@ int ff_vbv_update(MpegEncContext *s, int frame_size){
|
||||
/**
|
||||
* Modify the bitrate curve from pass1 for one frame.
|
||||
*/
|
||||
static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_factor, int frame_num){
|
||||
static double get_qscale(MpegEncContext *s, RateControlEntry *rce,
|
||||
double rate_factor, int frame_num)
|
||||
{
|
||||
RateControlContext *rcc = &s->rc_context;
|
||||
AVCodecContext *a = s->avctx;
|
||||
double q, bits;
|
||||
const int pict_type = rce->new_pict_type;
|
||||
const double mb_num = s->mb_num;
|
||||
double q, bits;
|
||||
int i;
|
||||
|
||||
double const_values[] = {
|
||||
@ -327,10 +366,12 @@ static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_f
|
||||
rce->pict_type == AV_PICTURE_TYPE_B,
|
||||
rcc->qscale_sum[pict_type] / (double)rcc->frame_count[pict_type],
|
||||
a->qcompress,
|
||||
/* rcc->last_qscale_for[AV_PICTURE_TYPE_I],
|
||||
#if 0
|
||||
rcc->last_qscale_for[AV_PICTURE_TYPE_I],
|
||||
rcc->last_qscale_for[AV_PICTURE_TYPE_P],
|
||||
rcc->last_qscale_for[AV_PICTURE_TYPE_B],
|
||||
rcc->next_non_b_qscale,*/
|
||||
rcc->next_non_b_qscale,
|
||||
#endif
|
||||
rcc->i_cplx_sum[AV_PICTURE_TYPE_I] / (double)rcc->frame_count[AV_PICTURE_TYPE_I],
|
||||
rcc->i_cplx_sum[AV_PICTURE_TYPE_P] / (double)rcc->frame_count[AV_PICTURE_TYPE_P],
|
||||
rcc->p_cplx_sum[AV_PICTURE_TYPE_P] / (double)rcc->frame_count[AV_PICTURE_TYPE_P],
|
||||
@ -347,14 +388,17 @@ static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_f
|
||||
|
||||
rcc->pass1_rc_eq_output_sum += bits;
|
||||
bits *= rate_factor;
|
||||
if(bits<0.0) bits=0.0;
|
||||
if (bits < 0.0)
|
||||
bits = 0.0;
|
||||
bits += 1.0; // avoid 1/0 issues
|
||||
|
||||
/* user override */
|
||||
for (i = 0; i < s->avctx->rc_override_count; i++) {
|
||||
RcOverride *rco = s->avctx->rc_override;
|
||||
if(rco[i].start_frame > frame_num) continue;
|
||||
if(rco[i].end_frame < frame_num) continue;
|
||||
if (rco[i].start_frame > frame_num)
|
||||
continue;
|
||||
if (rco[i].end_frame < frame_num)
|
||||
continue;
|
||||
|
||||
if (rco[i].qscale)
|
||||
bits = qp2bits(rce, rco[i].qscale); // FIXME move at end to really force it?
|
||||
@ -369,31 +413,38 @@ static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_f
|
||||
q = -q * s->avctx->i_quant_factor + s->avctx->i_quant_offset;
|
||||
else if (pict_type == AV_PICTURE_TYPE_B && s->avctx->b_quant_factor < 0.0)
|
||||
q = -q * s->avctx->b_quant_factor + s->avctx->b_quant_offset;
|
||||
if(q<1) q=1;
|
||||
if (q < 1)
|
||||
q = 1;
|
||||
|
||||
return q;
|
||||
}
|
||||
|
||||
static double get_diff_limited_q(MpegEncContext *s, RateControlEntry *rce, double q){
|
||||
static double get_diff_limited_q(MpegEncContext *s, RateControlEntry *rce, double q)
|
||||
{
|
||||
RateControlContext *rcc = &s->rc_context;
|
||||
AVCodecContext *a = s->avctx;
|
||||
const int pict_type = rce->new_pict_type;
|
||||
const double last_p_q = rcc->last_qscale_for[AV_PICTURE_TYPE_P];
|
||||
const double last_non_b_q = rcc->last_qscale_for[rcc->last_non_b_pict_type];
|
||||
|
||||
if (pict_type==AV_PICTURE_TYPE_I && (a->i_quant_factor>0.0 || rcc->last_non_b_pict_type==AV_PICTURE_TYPE_P))
|
||||
if (pict_type == AV_PICTURE_TYPE_I &&
|
||||
(a->i_quant_factor > 0.0 || rcc->last_non_b_pict_type == AV_PICTURE_TYPE_P))
|
||||
q = last_p_q * FFABS(a->i_quant_factor) + a->i_quant_offset;
|
||||
else if(pict_type==AV_PICTURE_TYPE_B && a->b_quant_factor>0.0)
|
||||
else if (pict_type == AV_PICTURE_TYPE_B &&
|
||||
a->b_quant_factor > 0.0)
|
||||
q = last_non_b_q * a->b_quant_factor + a->b_quant_offset;
|
||||
if(q<1) q=1;
|
||||
if (q < 1)
|
||||
q = 1;
|
||||
|
||||
/* last qscale / qdiff stuff */
|
||||
if (rcc->last_non_b_pict_type == pict_type || pict_type != AV_PICTURE_TYPE_I) {
|
||||
double last_q = rcc->last_qscale_for[pict_type];
|
||||
const int maxdiff = FF_QP2LAMBDA * a->max_qdiff;
|
||||
|
||||
if (q > last_q + maxdiff) q= last_q + maxdiff;
|
||||
else if(q < last_q - maxdiff) q= last_q - maxdiff;
|
||||
if (q > last_q + maxdiff)
|
||||
q = last_q + maxdiff;
|
||||
else if (q < last_q - maxdiff)
|
||||
q = last_q - maxdiff;
|
||||
}
|
||||
|
||||
rcc->last_qscale_for[pict_type] = q; // Note we cannot do that after blurring
|
||||
@ -407,42 +458,51 @@ static double get_diff_limited_q(MpegEncContext *s, RateControlEntry *rce, doubl
|
||||
/**
|
||||
* Get the qmin & qmax for pict_type.
|
||||
*/
|
||||
static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type){
|
||||
static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type)
|
||||
{
|
||||
int qmin = s->avctx->lmin;
|
||||
int qmax = s->avctx->lmax;
|
||||
|
||||
assert(qmin <= qmax);
|
||||
|
||||
if(pict_type==AV_PICTURE_TYPE_B){
|
||||
switch (pict_type) {
|
||||
case AV_PICTURE_TYPE_B:
|
||||
qmin = (int)(qmin * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset + 0.5);
|
||||
qmax = (int)(qmax * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset + 0.5);
|
||||
}else if(pict_type==AV_PICTURE_TYPE_I){
|
||||
break;
|
||||
case AV_PICTURE_TYPE_I:
|
||||
qmin = (int)(qmin * FFABS(s->avctx->i_quant_factor) + s->avctx->i_quant_offset + 0.5);
|
||||
qmax = (int)(qmax * FFABS(s->avctx->i_quant_factor) + s->avctx->i_quant_offset + 0.5);
|
||||
break;
|
||||
}
|
||||
|
||||
qmin = av_clip(qmin, 1, FF_LAMBDA_MAX);
|
||||
qmax = av_clip(qmax, 1, FF_LAMBDA_MAX);
|
||||
|
||||
if(qmax<qmin) qmax= qmin;
|
||||
if (qmax < qmin)
|
||||
qmax = qmin;
|
||||
|
||||
*qmin_ret = qmin;
|
||||
*qmax_ret = qmax;
|
||||
}
|
||||
|
||||
static double modify_qscale(MpegEncContext *s, RateControlEntry *rce, double q, int frame_num){
|
||||
static double modify_qscale(MpegEncContext *s, RateControlEntry *rce,
|
||||
double q, int frame_num)
|
||||
{
|
||||
RateControlContext *rcc = &s->rc_context;
|
||||
int qmin, qmax;
|
||||
const int pict_type= rce->new_pict_type;
|
||||
const double buffer_size = s->avctx->rc_buffer_size;
|
||||
const double fps = 1 / av_q2d(s->avctx->time_base);
|
||||
const double min_rate = s->avctx->rc_min_rate / fps;
|
||||
const double max_rate = s->avctx->rc_max_rate / fps;
|
||||
const int pict_type = rce->new_pict_type;
|
||||
int qmin, qmax;
|
||||
|
||||
get_qminmax(&qmin, &qmax, s, pict_type);
|
||||
|
||||
/* modulation */
|
||||
if(s->avctx->rc_qmod_freq && frame_num%s->avctx->rc_qmod_freq==0 && pict_type==AV_PICTURE_TYPE_P)
|
||||
if (s->avctx->rc_qmod_freq &&
|
||||
frame_num % s->avctx->rc_qmod_freq == 0 &&
|
||||
pict_type == AV_PICTURE_TYPE_P)
|
||||
q *= s->avctx->rc_qmod_amp;
|
||||
|
||||
/* buffer overflow/underflow protection */
|
||||
@ -452,30 +512,40 @@ static double modify_qscale(MpegEncContext *s, RateControlEntry *rce, double q,
|
||||
|
||||
if (min_rate) {
|
||||
double d = 2 * (buffer_size - expected_size) / buffer_size;
|
||||
if(d>1.0) d=1.0;
|
||||
else if(d<0.0001) d=0.0001;
|
||||
if (d > 1.0)
|
||||
d = 1.0;
|
||||
else if (d < 0.0001)
|
||||
d = 0.0001;
|
||||
q *= pow(d, 1.0 / s->avctx->rc_buffer_aggressivity);
|
||||
|
||||
q_limit= bits2qp(rce, FFMAX((min_rate - buffer_size + rcc->buffer_index) * s->avctx->rc_min_vbv_overflow_use, 1));
|
||||
q_limit = bits2qp(rce,
|
||||
FFMAX((min_rate - buffer_size + rcc->buffer_index) *
|
||||
s->avctx->rc_min_vbv_overflow_use, 1));
|
||||
|
||||
if (q > q_limit) {
|
||||
if(s->avctx->debug&FF_DEBUG_RC){
|
||||
av_log(s->avctx, AV_LOG_DEBUG, "limiting QP %f -> %f\n", q, q_limit);
|
||||
}
|
||||
if (s->avctx->debug & FF_DEBUG_RC)
|
||||
av_log(s->avctx, AV_LOG_DEBUG,
|
||||
"limiting QP %f -> %f\n", q, q_limit);
|
||||
q = q_limit;
|
||||
}
|
||||
}
|
||||
|
||||
if (max_rate) {
|
||||
double d = 2 * expected_size / buffer_size;
|
||||
if(d>1.0) d=1.0;
|
||||
else if(d<0.0001) d=0.0001;
|
||||
if (d > 1.0)
|
||||
d = 1.0;
|
||||
else if (d < 0.0001)
|
||||
d = 0.0001;
|
||||
q /= pow(d, 1.0 / s->avctx->rc_buffer_aggressivity);
|
||||
|
||||
q_limit= bits2qp(rce, FFMAX(rcc->buffer_index * s->avctx->rc_max_available_vbv_use, 1));
|
||||
q_limit = bits2qp(rce,
|
||||
FFMAX(rcc->buffer_index *
|
||||
s->avctx->rc_max_available_vbv_use,
|
||||
1));
|
||||
if (q < q_limit) {
|
||||
if(s->avctx->debug&FF_DEBUG_RC){
|
||||
av_log(s->avctx, AV_LOG_DEBUG, "limiting QP %f -> %f\n", q, q_limit);
|
||||
}
|
||||
if (s->avctx->debug & FF_DEBUG_RC)
|
||||
av_log(s->avctx, AV_LOG_DEBUG,
|
||||
"limiting QP %f -> %f\n", q, q_limit);
|
||||
q = q_limit;
|
||||
}
|
||||
}
|
||||
@ -484,8 +554,10 @@ static double modify_qscale(MpegEncContext *s, RateControlEntry *rce, double q,
|
||||
q, max_rate, min_rate, buffer_size, rcc->buffer_index,
|
||||
s->avctx->rc_buffer_aggressivity);
|
||||
if (s->avctx->rc_qsquish == 0.0 || qmin == qmax) {
|
||||
if (q<qmin) q=qmin;
|
||||
else if(q>qmax) q=qmax;
|
||||
if (q < qmin)
|
||||
q = qmin;
|
||||
else if (q > qmax)
|
||||
q = qmax;
|
||||
} else {
|
||||
double min2 = log(qmin);
|
||||
double max2 = log(qmax);
|
||||
@ -513,7 +585,8 @@ static double predict_size(Predictor *p, double q, double var)
|
||||
static void update_predictor(Predictor *p, double q, double var, double size)
|
||||
{
|
||||
double new_coeff = size * q / (var + 1);
|
||||
if(var<10) return;
|
||||
if (var < 10)
|
||||
return;
|
||||
|
||||
p->count *= p->decay;
|
||||
p->coeff *= p->decay;
|
||||
@ -521,7 +594,8 @@ static void update_predictor(Predictor *p, double q, double var, double size)
|
||||
p->coeff += new_coeff;
|
||||
}
|
||||
|
||||
static void adaptive_quantization(MpegEncContext *s, double q){
|
||||
static void adaptive_quantization(MpegEncContext *s, double q)
|
||||
{
|
||||
int i;
|
||||
const float lumi_masking = s->avctx->lumi_masking / (128.0 * 128.0);
|
||||
const float dark_masking = s->avctx->dark_masking / (128.0 * 128.0);
|
||||
@ -549,8 +623,10 @@ static void adaptive_quantization(MpegEncContext *s, double q){
|
||||
int mb_y = mb_xy / s->mb_stride;
|
||||
int mb_distance;
|
||||
float mb_factor = 0.0;
|
||||
if(spat_cplx < 4) spat_cplx= 4; //FIXME finetune
|
||||
if(temp_cplx < 4) temp_cplx= 4; //FIXME finetune
|
||||
if (spat_cplx < 4)
|
||||
spat_cplx = 4; // FIXME finetune
|
||||
if (temp_cplx < 4)
|
||||
temp_cplx = 4; // FIXME finetune
|
||||
|
||||
if ((s->mb_type[mb_xy] & CANDIDATE_MB_TYPE_INTRA)) { // FIXME hq mode
|
||||
cplx = spat_cplx;
|
||||
@ -575,15 +651,18 @@ static void adaptive_quantization(MpegEncContext *s, double q){
|
||||
}
|
||||
if (mb_y < mb_height / 5) {
|
||||
mb_distance = mb_height / 5 - mb_y;
|
||||
mb_factor = FFMAX(mb_factor, (float)mb_distance / (float)(mb_height/5));
|
||||
mb_factor = FFMAX(mb_factor,
|
||||
(float)mb_distance / (float)(mb_height / 5));
|
||||
} else if (mb_y > 4 * mb_height / 5) {
|
||||
mb_distance = mb_y - 4 * mb_height / 5;
|
||||
mb_factor = FFMAX(mb_factor, (float)mb_distance / (float)(mb_height/5));
|
||||
mb_factor = FFMAX(mb_factor,
|
||||
(float)mb_distance / (float)(mb_height / 5));
|
||||
}
|
||||
|
||||
factor *= 1.0 - border_masking * mb_factor;
|
||||
|
||||
if(factor<0.00001) factor= 0.00001;
|
||||
if (factor < 0.00001)
|
||||
factor = 0.00001;
|
||||
|
||||
bits = cplx * factor;
|
||||
cplx_sum += cplx;
|
||||
@ -602,14 +681,15 @@ static void adaptive_quantization(MpegEncContext *s, double q){
|
||||
if (newq > qmax) {
|
||||
bits_sum -= bits_tab[i];
|
||||
cplx_sum -= cplx_tab[i] * q / qmax;
|
||||
}
|
||||
else if(newq < qmin){
|
||||
} else if (newq < qmin) {
|
||||
bits_sum -= bits_tab[i];
|
||||
cplx_sum -= cplx_tab[i] * q / qmin;
|
||||
}
|
||||
}
|
||||
if(bits_sum < 0.001) bits_sum= 0.001;
|
||||
if(cplx_sum < 0.001) cplx_sum= 0.001;
|
||||
if (bits_sum < 0.001)
|
||||
bits_sum = 0.001;
|
||||
if (cplx_sum < 0.001)
|
||||
cplx_sum = 0.001;
|
||||
}
|
||||
|
||||
for (i = 0; i < s->mb_num; i++) {
|
||||
@ -623,18 +703,19 @@ static void adaptive_quantization(MpegEncContext *s, double q){
|
||||
|
||||
intq = (int)(newq + 0.5);
|
||||
|
||||
if (intq > qmax) intq= qmax;
|
||||
else if(intq < qmin) intq= qmin;
|
||||
if (intq > qmax)
|
||||
intq = qmax;
|
||||
else if (intq < qmin)
|
||||
intq = qmin;
|
||||
s->lambda_table[mb_xy] = intq;
|
||||
}
|
||||
}
|
||||
|
||||
void ff_get_2pass_fcode(MpegEncContext *s){
|
||||
void ff_get_2pass_fcode(MpegEncContext *s)
|
||||
{
|
||||
RateControlContext *rcc = &s->rc_context;
|
||||
int picture_number= s->picture_number;
|
||||
RateControlEntry *rce;
|
||||
RateControlEntry *rce = &rcc->entry[s->picture_number];
|
||||
|
||||
rce= &rcc->entry[picture_number];
|
||||
s->f_code = rce->f_code;
|
||||
s->b_code = rce->b_code;
|
||||
}
|
||||
@ -662,7 +743,8 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
|
||||
emms_c();
|
||||
|
||||
#if CONFIG_LIBXVID
|
||||
if((s->flags&CODEC_FLAG_PASS2) && s->avctx->rc_strategy == FF_RC_STRATEGY_XVID)
|
||||
if ((s->flags & CODEC_FLAG_PASS2) &&
|
||||
s->avctx->rc_strategy == FF_RC_STRATEGY_XVID)
|
||||
return ff_xvid_rate_estimate_qscale(s, dry_run);
|
||||
#endif
|
||||
|
||||
@ -671,8 +753,11 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
|
||||
fps = 1 / av_q2d(s->avctx->time_base);
|
||||
/* update predictors */
|
||||
if (picture_number > 2 && !dry_run) {
|
||||
const int last_var= s->last_pict_type == AV_PICTURE_TYPE_I ? rcc->last_mb_var_sum : rcc->last_mc_mb_var_sum;
|
||||
update_predictor(&rcc->pred[s->last_pict_type], rcc->last_qscale, sqrt(last_var), s->frame_bits);
|
||||
const int last_var = s->last_pict_type == AV_PICTURE_TYPE_I ? rcc->last_mb_var_sum
|
||||
: rcc->last_mc_mb_var_sum;
|
||||
update_predictor(&rcc->pred[s->last_pict_type],
|
||||
rcc->last_qscale,
|
||||
sqrt(last_var), s->frame_bits);
|
||||
}
|
||||
|
||||
if (s->flags & CODEC_FLAG_PASS2) {
|
||||
@ -684,8 +769,9 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
|
||||
Picture *dts_pic;
|
||||
rce = &local_rce;
|
||||
|
||||
//FIXME add a dts field to AVFrame and ensure its set and use it here instead of reordering
|
||||
//but the reordering is simpler for now until h.264 b pyramid must be handeld
|
||||
/* FIXME add a dts field to AVFrame and ensure it is set and use it
|
||||
* here instead of reordering but the reordering is simpler for now
|
||||
* until H.264 B-pyramid must be handled. */
|
||||
if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay)
|
||||
dts_pic = s->current_picture_ptr;
|
||||
else
|
||||
@ -699,7 +785,8 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
|
||||
|
||||
diff = s->total_bits - wanted_bits;
|
||||
br_compensation = (a->bit_rate_tolerance - diff) / a->bit_rate_tolerance;
|
||||
if(br_compensation<=0.0) br_compensation=0.001;
|
||||
if (br_compensation <= 0.0)
|
||||
br_compensation = 0.001;
|
||||
|
||||
var = pict_type == AV_PICTURE_TYPE_I ? pic->mb_var_sum : pic->mc_mb_var_sum;
|
||||
|
||||
@ -731,7 +818,6 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
|
||||
rce->i_count = 0; // FIXME we do know this approx
|
||||
rce->i_tex_bits = 0;
|
||||
rce->p_tex_bits = bits * 0.9;
|
||||
|
||||
rce->mv_bits = bits * 0.1;
|
||||
}
|
||||
rcc->i_cplx_sum[pict_type] += rce->i_tex_bits * rce->qscale;
|
||||
@ -740,7 +826,8 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
|
||||
rcc->frame_count[pict_type]++;
|
||||
|
||||
bits = rce->i_tex_bits + rce->p_tex_bits;
|
||||
rate_factor= rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum * br_compensation;
|
||||
rate_factor = rcc->pass1_wanted_bits /
|
||||
rcc->pass1_rc_eq_output_sum * br_compensation;
|
||||
|
||||
q = get_qscale(s, rce, rate_factor, picture_number);
|
||||
if (q < 0)
|
||||
@ -750,7 +837,8 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
|
||||
q = get_diff_limited_q(s, rce, q);
|
||||
assert(q > 0.0);
|
||||
|
||||
if(pict_type==AV_PICTURE_TYPE_P || s->intra_only){ //FIXME type dependent blur like in 2-pass
|
||||
// FIXME type dependent blur like in 2-pass
|
||||
if (pict_type == AV_PICTURE_TYPE_P || s->intra_only) {
|
||||
rcc->short_term_qsum *= a->qblur;
|
||||
rcc->short_term_qcount *= a->qblur;
|
||||
|
||||
@ -768,14 +856,21 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
|
||||
}
|
||||
|
||||
if (s->avctx->debug & FF_DEBUG_RC) {
|
||||
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",
|
||||
av_get_picture_type_char(pict_type), qmin, q, qmax, picture_number, (int)wanted_bits/1000, (int)s->total_bits/1000,
|
||||
br_compensation, short_term_q, s->frame_bits, pic->mb_var_sum, pic->mc_mb_var_sum, s->bit_rate/1000, (int)fps
|
||||
);
|
||||
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",
|
||||
av_get_picture_type_char(pict_type),
|
||||
qmin, q, qmax, picture_number,
|
||||
(int)wanted_bits / 1000, (int)s->total_bits / 1000,
|
||||
br_compensation, short_term_q, s->frame_bits,
|
||||
pic->mb_var_sum, pic->mc_mb_var_sum,
|
||||
s->bit_rate / 1000, (int)fps);
|
||||
}
|
||||
|
||||
if (q<qmin) q=qmin;
|
||||
else if(q>qmax) q=qmax;
|
||||
if (q < qmin)
|
||||
q = qmin;
|
||||
else if (q > qmax)
|
||||
q = qmax;
|
||||
|
||||
if (s->adaptive_quant)
|
||||
adaptive_quantization(s, q);
|
||||
@ -799,13 +894,13 @@ static int init_pass2(MpegEncContext *s)
|
||||
AVCodecContext *a = s->avctx;
|
||||
int i, toobig;
|
||||
double fps = 1 / av_q2d(s->avctx->time_base);
|
||||
double complexity[5]={0,0,0,0,0}; // approximate bits at quant=1
|
||||
uint64_t const_bits[5]={0,0,0,0,0}; // quantizer independent bits
|
||||
double complexity[5] = { 0 }; // approximate bits at quant=1
|
||||
uint64_t const_bits[5] = { 0 }; // quantizer independent bits
|
||||
uint64_t all_const_bits;
|
||||
uint64_t all_available_bits= (uint64_t)(s->bit_rate*(double)rcc->num_entries/fps);
|
||||
uint64_t all_available_bits = (uint64_t)(s->bit_rate *
|
||||
(double)rcc->num_entries / fps);
|
||||
double rate_factor = 0;
|
||||
double step;
|
||||
//int last_i_frame=-10000000;
|
||||
const int filter_size = (int)(a->qblur * 4) | 1;
|
||||
double expected_bits;
|
||||
double *qscale, *blurred_qscale, qscale_sum;
|
||||
@ -820,10 +915,14 @@ static int init_pass2(MpegEncContext *s)
|
||||
rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits;
|
||||
rcc->frame_count[rce->pict_type]++;
|
||||
|
||||
complexity[rce->new_pict_type]+= (rce->i_tex_bits+ rce->p_tex_bits)*(double)rce->qscale;
|
||||
complexity[rce->new_pict_type] += (rce->i_tex_bits + rce->p_tex_bits) *
|
||||
(double)rce->qscale;
|
||||
const_bits[rce->new_pict_type] += rce->mv_bits + rce->misc_bits;
|
||||
}
|
||||
all_const_bits= const_bits[AV_PICTURE_TYPE_I] + const_bits[AV_PICTURE_TYPE_P] + const_bits[AV_PICTURE_TYPE_B];
|
||||
|
||||
all_const_bits = const_bits[AV_PICTURE_TYPE_I] +
|
||||
const_bits[AV_PICTURE_TYPE_P] +
|
||||
const_bits[AV_PICTURE_TYPE_B];
|
||||
|
||||
if (all_available_bits < all_const_bits) {
|
||||
av_log(s->avctx, AV_LOG_ERROR, "requested bitrate is too low\n");
|
||||
@ -843,6 +942,7 @@ static int init_pass2(MpegEncContext *s)
|
||||
/* find qscale */
|
||||
for (i = 0; i < rcc->num_entries; i++) {
|
||||
RateControlEntry *rce = &rcc->entry[i];
|
||||
|
||||
qscale[i] = get_qscale(s, &rcc->entry[i], rate_factor, i);
|
||||
rcc->last_qscale_for[rce->pict_type] = qscale[i];
|
||||
}
|
||||
@ -867,8 +967,10 @@ static int init_pass2(MpegEncContext *s)
|
||||
double d = index - i;
|
||||
double coeff = a->qblur == 0 ? 1.0 : exp(-d * d / (a->qblur * a->qblur));
|
||||
|
||||
if(index < 0 || index >= rcc->num_entries) continue;
|
||||
if(pict_type != rcc->entry[index].new_pict_type) continue;
|
||||
if (index < 0 || index >= rcc->num_entries)
|
||||
continue;
|
||||
if (pict_type != rcc->entry[index].new_pict_type)
|
||||
continue;
|
||||
q += qscale[index] * coeff;
|
||||
sum += coeff;
|
||||
}
|
||||
@ -879,7 +981,9 @@ static int init_pass2(MpegEncContext *s)
|
||||
for (i = 0; i < rcc->num_entries; i++) {
|
||||
RateControlEntry *rce = &rcc->entry[i];
|
||||
double bits;
|
||||
|
||||
rce->new_qscale = modify_qscale(s, rce, blurred_qscale[i], i);
|
||||
|
||||
bits = qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;
|
||||
bits += 8 * ff_vbv_update(s, bits);
|
||||
|
||||
@ -905,7 +1009,8 @@ static int init_pass2(MpegEncContext *s)
|
||||
i,
|
||||
rcc->entry[i].new_qscale,
|
||||
rcc->entry[i].new_qscale / FF_QP2LAMBDA);
|
||||
qscale_sum += av_clip(rcc->entry[i].new_qscale / FF_QP2LAMBDA, s->avctx->qmin, s->avctx->qmax);
|
||||
qscale_sum += av_clip(rcc->entry[i].new_qscale / FF_QP2LAMBDA,
|
||||
s->avctx->qmin, s->avctx->qmax);
|
||||
}
|
||||
assert(toobig <= 40);
|
||||
av_log(s->avctx, AV_LOG_DEBUG,
|
||||
|
||||
Loading…
Reference in New Issue
Block a user