* Rate control for video encoders.
*/
+#include "libavutil/attributes.h"
+#include "libavutil/internal.h"
+
#include "avcodec.h"
+#include "internal.h"
#include "ratecontrol.h"
+#include "mpegutils.h"
#include "mpegvideo.h"
#include "libavutil/eval.h"
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->current_picture_ptr->f->display_picture_number,
+ s->current_picture_ptr->f->coded_picture_number,
s->pict_type,
- s->current_picture.f.quality,
+ s->current_picture.f->quality,
s->i_tex_bits,
s->p_tex_bits,
s->mv_bits,
return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits + 1) / bits;
}
-int ff_rate_control_init(MpegEncContext *s)
+av_cold int ff_rate_control_init(MpegEncContext *s)
{
RateControlContext *rcc = &s->rc_context;
int i, res;
emms_c();
res = av_expr_parse(&rcc->rc_eq_eval,
- s->avctx->rc_eq ? s->avctx->rc_eq : "tex^qComp",
+ s->rc_eq ? s->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);
+ av_log(s->avctx, AV_LOG_ERROR, "Error parsing rc_eq \"%s\"\n", s->rc_eq);
return res;
}
+#if FF_API_RC_STRATEGY
+FF_DISABLE_DEPRECATION_WARNINGS
+ if (!s->rc_strategy)
+ s->rc_strategy = s->avctx->rc_strategy;
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
+
for (i = 0; i < 5; i++) {
rcc->pred[i].coeff = FF_QP2LAMBDA * 7.0;
rcc->pred[i].count = 1.0;
}
rcc->buffer_index = s->avctx->rc_initial_buffer_occupancy;
- if (s->flags & CODEC_FLAG_PASS2) {
+ if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
int i;
char *p;
return -1;
rcc->entry = av_mallocz(i * sizeof(RateControlEntry));
rcc->num_entries = i;
+ if (!rcc->entry)
+ return AVERROR(ENOMEM);
/* init all to skipped p frames
* (with b frames we might have a not encoded frame at the end FIXME) */
p = next;
}
- if (init_pass2(s) < 0)
+ if (init_pass2(s) < 0) {
+ ff_rate_control_uninit(s);
return -1;
+ }
// FIXME maybe move to end
- if ((s->flags & CODEC_FLAG_PASS2) && s->avctx->rc_strategy == FF_RC_STRATEGY_XVID) {
+ if ((s->avctx->flags & AV_CODEC_FLAG_PASS2) && s->rc_strategy == 1) {
#if CONFIG_LIBXVID
return ff_xvid_rate_control_init(s);
#else
}
}
- if (!(s->flags & CODEC_FLAG_PASS2)) {
+ if (!(s->avctx->flags & AV_CODEC_FLAG_PASS2)) {
rcc->short_term_qsum = 0.001;
rcc->short_term_qcount = 0.001;
return -1;
}
/* init stuff with the user specified complexity */
- if (s->avctx->rc_initial_cplx) {
+ if (s->rc_initial_cplx) {
for (i = 0; i < 60 * 30; i++) {
- double bits = s->avctx->rc_initial_cplx * (i / 10000.0 + 1.0) * s->mb_num;
+ double bits = s->rc_initial_cplx * (i / 10000.0 + 1.0) * s->mb_num;
RateControlEntry rce;
if (i % ((s->gop_size + 3) / 4) == 0)
return 0;
}
-void ff_rate_control_uninit(MpegEncContext *s)
+av_cold void ff_rate_control_uninit(MpegEncContext *s)
{
RateControlContext *rcc = &s->rc_context;
emms_c();
av_freep(&rcc->entry);
#if CONFIG_LIBXVID
- if ((s->flags & CODEC_FLAG_PASS2) && s->avctx->rc_strategy == FF_RC_STRATEGY_XVID)
+ if ((s->avctx->flags & AV_CODEC_FLAG_PASS2) && s->rc_strategy == 1)
ff_xvid_rate_control_uninit(s);
#endif
}
const double min_rate = s->avctx->rc_min_rate / fps;
const double max_rate = s->avctx->rc_max_rate / fps;
- av_dlog(s, "%d %f %d %f %f\n",
+ ff_dlog(s, "%d %f %d %f %f\n",
buffer_size, rcc->buffer_index, frame_size, min_rate, max_rate);
if (buffer_size) {
bits = av_expr_eval(rcc->rc_eq_eval, const_values, rce);
if (isnan(bits)) {
- av_log(s->avctx, AV_LOG_ERROR, "Error evaluating rc_eq \"%s\"\n", s->avctx->rc_eq);
+ av_log(s->avctx, AV_LOG_ERROR, "Error evaluating rc_eq \"%s\"\n", s->rc_eq);
return -1;
}
*/
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;
+ int qmin = s->lmin;
+ int qmax = s->lmax;
assert(qmin <= qmax);
get_qminmax(&qmin, &qmax, s, pict_type);
/* modulation */
- if (s->avctx->rc_qmod_freq &&
- frame_num % s->avctx->rc_qmod_freq == 0 &&
+ if (s->rc_qmod_freq &&
+ frame_num % s->rc_qmod_freq == 0 &&
pict_type == AV_PICTURE_TYPE_P)
- q *= s->avctx->rc_qmod_amp;
+ q *= s->rc_qmod_amp;
/* buffer overflow/underflow protection */
if (buffer_size) {
d = 1.0;
else if (d < 0.0001)
d = 0.0001;
- q *= pow(d, 1.0 / s->avctx->rc_buffer_aggressivity);
+ q *= pow(d, 1.0 / s->rc_buffer_aggressivity);
q_limit = bits2qp(rce,
FFMAX((min_rate - buffer_size + rcc->buffer_index) *
d = 1.0;
else if (d < 0.0001)
d = 0.0001;
- q /= pow(d, 1.0 / s->avctx->rc_buffer_aggressivity);
+ q /= pow(d, 1.0 / s->rc_buffer_aggressivity);
q_limit = bits2qp(rce,
FFMAX(rcc->buffer_index *
}
}
}
- av_dlog(s, "q:%f max:%f min:%f size:%f index:%f agr:%f\n",
+ ff_dlog(s, "q:%f max:%f min:%f size:%f index:%f agr:%f\n",
q, max_rate, min_rate, buffer_size, rcc->buffer_index,
- s->avctx->rc_buffer_aggressivity);
- if (s->avctx->rc_qsquish == 0.0 || qmin == qmax) {
+ s->rc_buffer_aggressivity);
+ if (s->rc_qsquish == 0.0 || qmin == qmax) {
if (q < qmin)
q = qmin;
else if (q > qmax)
const float temp_cplx_masking = s->avctx->temporal_cplx_masking;
const float spatial_cplx_masking = s->avctx->spatial_cplx_masking;
const float p_masking = s->avctx->p_masking;
- const float border_masking = s->avctx->border_masking;
+ const float border_masking = s->border_masking;
float bits_sum = 0.0;
float cplx_sum = 0.0;
float *cplx_tab = s->cplx_tab;
}
/* handle qmin/qmax clipping */
- if (s->flags & CODEC_FLAG_NORMALIZE_AQP) {
+ if (s->mpv_flags & FF_MPV_FLAG_NAQ) {
float factor = bits_sum / cplx_sum;
for (i = 0; i < s->mb_num; i++) {
float newq = q * cplx_tab[i] / bits_tab[i];
float newq = q * cplx_tab[i] / bits_tab[i];
int intq;
- if (s->flags & CODEC_FLAG_NORMALIZE_AQP) {
+ if (s->mpv_flags & FF_MPV_FLAG_NAQ) {
newq *= bits_sum / cplx_sum;
}
emms_c();
#if CONFIG_LIBXVID
- if ((s->flags & CODEC_FLAG_PASS2) &&
- s->avctx->rc_strategy == FF_RC_STRATEGY_XVID)
+ if ((s->avctx->flags & AV_CODEC_FLAG_PASS2) && s->rc_strategy == 1)
return ff_xvid_rate_estimate_qscale(s, dry_run);
#endif
sqrt(last_var), s->frame_bits);
}
- if (s->flags & CODEC_FLAG_PASS2) {
+ if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
assert(picture_number >= 0);
assert(picture_number < rcc->num_entries);
rce = &rcc->entry[picture_number];
else
dts_pic = s->last_picture_ptr;
- if (!dts_pic || dts_pic->f.pts == AV_NOPTS_VALUE)
+ if (!dts_pic || dts_pic->f->pts == AV_NOPTS_VALUE)
wanted_bits = (uint64_t)(s->bit_rate * (double)picture_number / fps);
else
- wanted_bits = (uint64_t)(s->bit_rate * (double)dts_pic->f.pts / fps);
+ wanted_bits = (uint64_t)(s->bit_rate * (double)dts_pic->f->pts / fps);
}
diff = s->total_bits - wanted_bits;
var = pict_type == AV_PICTURE_TYPE_I ? pic->mb_var_sum : pic->mc_mb_var_sum;
short_term_q = 0; /* avoid warning */
- if (s->flags & CODEC_FLAG_PASS2) {
+ if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
if (pict_type != AV_PICTURE_TYPE_I)
assert(pict_type == rce->new_pict_type);
q = rce->new_qscale / br_compensation;
- av_dlog(s, "%f %f %f last:%d var:%d type:%d//\n", q, rce->new_qscale,
+ ff_dlog(s, "%f %f %f last:%d var:%d type:%d//\n", q, rce->new_qscale,
br_compensation, s->frame_bits, var, pict_type);
} else {
rce->pict_type =
qscale = av_malloc(sizeof(double) * rcc->num_entries);
blurred_qscale = av_malloc(sizeof(double) * rcc->num_entries);
+ if (!qscale || !blurred_qscale) {
+ av_free(qscale);
+ av_free(blurred_qscale);
+ return AVERROR(ENOMEM);
+ }
toobig = 0;
for (step = 256 * 256; step > 0.0000001; step *= 0.5) {
expected_bits += bits;
}
- av_dlog(s->avctx,
+ ff_dlog(s->avctx,
"expected_bits: %f all_available_bits: %d rate_factor: %f\n",
expected_bits, (int)all_available_bits, rate_factor);
if (expected_bits > all_available_bits) {
/* check bitrate calculations and print info */
qscale_sum = 0.0;
for (i = 0; i < rcc->num_entries; i++) {
- av_dlog(s, "[lavc rc] entry[%d].new_qscale = %.3f qp = %.3f\n",
+ ff_dlog(s, "[lavc rc] entry[%d].new_qscale = %.3f qp = %.3f\n",
i,
rcc->entry[i].new_qscale,
rcc->entry[i].new_qscale / FF_QP2LAMBDA);
projects / ffmpeg / blobdiff