[FFmpeg-cvslog] Merge commit 'a1f6a2dfdaf9beb42ca66e49d10bfaf5905a0128'
Clément Bœsch
git at videolan.org
Wed Feb 1 15:50:44 EET 2017
ffmpeg | branch: master | Clément Bœsch <u at pkh.me> | Wed Feb 1 14:47:14 2017 +0100| [26d5caf67994eb8ea34c16144b1de4920c8a7403] | committer: Clément Bœsch
Merge commit 'a1f6a2dfdaf9beb42ca66e49d10bfaf5905a0128'
* commit 'a1f6a2dfdaf9beb42ca66e49d10bfaf5905a0128':
ratecontrol: Reorder functions to avoid forward declarations
Merged, but this seems to break the clear separation of 1-pass vs
2-pass.
Merged-by: Clément Bœsch <u at pkh.me>
> http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=26d5caf67994eb8ea34c16144b1de4920c8a7403
---
libavcodec/ratecontrol.c | 882 +++++++++++++++++++++++------------------------
1 file changed, 436 insertions(+), 446 deletions(-)
diff --git a/libavcodec/ratecontrol.c b/libavcodec/ratecontrol.c
index b731f72..6b28c75 100644
--- a/libavcodec/ratecontrol.c
+++ b/libavcodec/ratecontrol.c
@@ -35,10 +35,6 @@
#include "mpegvideo.h"
#include "libavutil/eval.h"
-static int init_pass2(MpegEncContext *s);
-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,
@@ -60,25 +56,417 @@ void ff_write_pass1_stats(MpegEncContext *s)
s->header_bits);
}
-static double get_fps(AVCodecContext *avctx)
-{
- return 1.0 / av_q2d(avctx->time_base) / FFMAX(avctx->ticks_per_frame, 1);
-}
+static double get_fps(AVCodecContext *avctx)
+{
+ return 1.0 / av_q2d(avctx->time_base) / FFMAX(avctx->ticks_per_frame, 1);
+}
+
+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)
+{
+ if (bits < 0.9) {
+ av_log(NULL, AV_LOG_ERROR, "bits<0.9\n");
+ }
+ return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits + 1) / bits;
+}
+
+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))
+ 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)
+ q = last_non_b_q * a->b_quant_factor + a->b_quant_offset;
+ 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;
+ }
+
+ rcc->last_qscale_for[pict_type] = q; // Note we cannot do that after blurring
+
+ if (pict_type != AV_PICTURE_TYPE_B)
+ rcc->last_non_b_pict_type = pict_type;
+
+ return q;
+}
+
+/**
+ * Get the qmin & qmax for pict_type.
+ */
+static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type)
+{
+ int qmin = s->lmin;
+ int qmax = s->lmax;
+
+ av_assert0(qmin <= qmax);
+
+ 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);
+ 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;
+
+ *qmin_ret = qmin;
+ *qmax_ret = qmax;
+}
+
+static double modify_qscale(MpegEncContext *s, RateControlEntry *rce,
+ double q, int frame_num)
+{
+ RateControlContext *rcc = &s->rc_context;
+ const double buffer_size = s->avctx->rc_buffer_size;
+ const double fps = get_fps(s->avctx);
+ 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->rc_qmod_freq &&
+ frame_num % s->rc_qmod_freq == 0 &&
+ pict_type == AV_PICTURE_TYPE_P)
+ q *= s->rc_qmod_amp;
+
+ /* buffer overflow/underflow protection */
+ if (buffer_size) {
+ double expected_size = rcc->buffer_index;
+ double q_limit;
+
+ 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;
+ q *= pow(d, 1.0 / s->rc_buffer_aggressivity);
+
+ 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);
+ 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;
+ q /= pow(d, 1.0 / s->rc_buffer_aggressivity);
+
+ 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);
+ q = q_limit;
+ }
+ }
+ }
+ 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->rc_buffer_aggressivity);
+ if (s->rc_qsquish == 0.0 || qmin == qmax) {
+ if (q < qmin)
+ q = qmin;
+ else if (q > qmax)
+ q = qmax;
+ } else {
+ double min2 = log(qmin);
+ double max2 = log(qmax);
+
+ q = log(q);
+ q = (q - min2) / (max2 - min2) - 0.5;
+ q *= -4.0;
+ q = 1.0 / (1.0 + exp(q));
+ q = q * (max2 - min2) + min2;
+
+ q = exp(q);
+ }
+
+ return q;
+}
+
+/**
+ * Modify the bitrate curve from pass1 for one frame.
+ */
+static double get_qscale(MpegEncContext *s, RateControlEntry *rce,
+ double rate_factor, int frame_num)
+{
+ RateControlContext *rcc = &s->rc_context;
+ AVCodecContext *a = s->avctx;
+ const int pict_type = rce->new_pict_type;
+ const double mb_num = s->mb_num;
+ double q, bits;
+ int i;
+
+ double const_values[] = {
+ M_PI,
+ M_E,
+ rce->i_tex_bits * rce->qscale,
+ rce->p_tex_bits * rce->qscale,
+ (rce->i_tex_bits + rce->p_tex_bits) * (double)rce->qscale,
+ rce->mv_bits / mb_num,
+ rce->pict_type == AV_PICTURE_TYPE_B ? (rce->f_code + rce->b_code) * 0.5 : rce->f_code,
+ rce->i_count / mb_num,
+ rce->mc_mb_var_sum / mb_num,
+ rce->mb_var_sum / mb_num,
+ rce->pict_type == AV_PICTURE_TYPE_I,
+ rce->pict_type == AV_PICTURE_TYPE_P,
+ rce->pict_type == AV_PICTURE_TYPE_B,
+ rcc->qscale_sum[pict_type] / (double)rcc->frame_count[pict_type],
+ a->qcompress,
+ 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],
+ rcc->p_cplx_sum[AV_PICTURE_TYPE_B] / (double)rcc->frame_count[AV_PICTURE_TYPE_B],
+ (rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / (double)rcc->frame_count[pict_type],
+ 0
+ };
+
+ 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->rc_eq);
+ return -1;
+ }
+
+ rcc->pass1_rc_eq_output_sum += bits;
+ bits *= rate_factor;
+ 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].qscale)
+ bits = qp2bits(rce, rco[i].qscale); // FIXME move at end to really force it?
+ else
+ bits *= rco[i].quality_factor;
+ }
+
+ q = bits2qp(rce, bits);
+
+ /* I/B difference */
+ if (pict_type == AV_PICTURE_TYPE_I && s->avctx->i_quant_factor < 0.0)
+ 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;
+
+ return q;
+}
+
+static int init_pass2(MpegEncContext *s)
+{
+ RateControlContext *rcc = &s->rc_context;
+ AVCodecContext *a = s->avctx;
+ int i, toobig;
+ double fps = get_fps(s->avctx);
+ 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);
+ double rate_factor = 0;
+ double step;
+ const int filter_size = (int)(a->qblur * 4) | 1;
+ double expected_bits = 0; // init to silence gcc warning
+ double *qscale, *blurred_qscale, qscale_sum;
+
+ /* find complexity & const_bits & decide the pict_types */
+ for (i = 0; i < rcc->num_entries; i++) {
+ RateControlEntry *rce = &rcc->entry[i];
+
+ rce->new_pict_type = rce->pict_type;
+ rcc->i_cplx_sum[rce->pict_type] += rce->i_tex_bits * rce->qscale;
+ rcc->p_cplx_sum[rce->pict_type] += rce->p_tex_bits * rce->qscale;
+ 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;
+ 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];
+
+ if (all_available_bits < all_const_bits) {
+ av_log(s->avctx, AV_LOG_ERROR, "requested bitrate is too low\n");
+ return -1;
+ }
+
+ qscale = av_malloc_array(rcc->num_entries, sizeof(double));
+ blurred_qscale = av_malloc_array(rcc->num_entries, sizeof(double));
+ 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 = 0;
+ rate_factor += step;
+
+ rcc->buffer_index = s->avctx->rc_buffer_size / 2;
+
+ /* 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];
+ }
+ av_assert0(filter_size % 2 == 1);
+
+ /* fixed I/B QP relative to P mode */
+ for (i = FFMAX(0, rcc->num_entries - 300); i < rcc->num_entries; i++) {
+ RateControlEntry *rce = &rcc->entry[i];
+
+ qscale[i] = get_diff_limited_q(s, rce, qscale[i]);
+ }
+
+ for (i = rcc->num_entries - 1; i >= 0; i--) {
+ RateControlEntry *rce = &rcc->entry[i];
+
+ qscale[i] = get_diff_limited_q(s, rce, qscale[i]);
+ }
+
+ /* smooth curve */
+ for (i = 0; i < rcc->num_entries; i++) {
+ RateControlEntry *rce = &rcc->entry[i];
+ const int pict_type = rce->new_pict_type;
+ int j;
+ double q = 0.0, sum = 0.0;
+
+ for (j = 0; j < filter_size; j++) {
+ int index = i + j - filter_size / 2;
+ 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;
+ q += qscale[index] * coeff;
+ sum += coeff;
+ }
+ blurred_qscale[i] = q / sum;
+ }
+
+ /* find expected bits */
+ 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);
+
+ rce->expected_bits = expected_bits;
+ expected_bits += bits;
+ }
-static inline double qp2bits(RateControlEntry *rce, double qp)
-{
- if (qp <= 0.0) {
- av_log(NULL, AV_LOG_ERROR, "qp<=0.0\n");
+ 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) {
+ rate_factor -= step;
+ ++toobig;
+ }
}
- return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits + 1) / qp;
-}
+ av_free(qscale);
+ av_free(blurred_qscale);
-static inline double bits2qp(RateControlEntry *rce, double bits)
-{
- if (bits < 0.9) {
- av_log(NULL, AV_LOG_ERROR, "bits<0.9\n");
+ /* check bitrate calculations and print info */
+ qscale_sum = 0.0;
+ for (i = 0; i < rcc->num_entries; i++) {
+ 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);
+ qscale_sum += av_clip(rcc->entry[i].new_qscale / FF_QP2LAMBDA,
+ s->avctx->qmin, s->avctx->qmax);
}
- return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits + 1) / bits;
+ av_assert0(toobig <= 40);
+ av_log(s->avctx, AV_LOG_DEBUG,
+ "[lavc rc] requested bitrate: %"PRId64" bps expected bitrate: %"PRId64" bps\n",
+ s->bit_rate,
+ (int64_t)(expected_bits / ((double)all_available_bits / s->bit_rate)));
+ av_log(s->avctx, AV_LOG_DEBUG,
+ "[lavc rc] estimated target average qp: %.3f\n",
+ (float)qscale_sum / rcc->num_entries);
+ if (toobig == 0) {
+ av_log(s->avctx, AV_LOG_INFO,
+ "[lavc rc] Using all of requested bitrate is not "
+ "necessary for this video with these parameters.\n");
+ } else if (toobig == 40) {
+ av_log(s->avctx, AV_LOG_ERROR,
+ "[lavc rc] Error: bitrate too low for this video "
+ "with these parameters.\n");
+ return -1;
+ } else if (fabs(expected_bits / all_available_bits - 1.0) > 0.01) {
+ av_log(s->avctx, AV_LOG_ERROR,
+ "[lavc rc] Error: 2pass curve failed to converge\n");
+ return -1;
+ }
+
+ return 0;
}
av_cold int ff_rate_control_init(MpegEncContext *s)
@@ -290,282 +678,48 @@ av_cold void ff_rate_control_uninit(MpegEncContext *s)
av_freep(&rcc->entry);
}
-int ff_vbv_update(MpegEncContext *s, int frame_size)
-{
- RateControlContext *rcc = &s->rc_context;
- const double fps = get_fps(s->avctx);
- const int buffer_size = s->avctx->rc_buffer_size;
- const double min_rate = s->avctx->rc_min_rate / fps;
- const double max_rate = s->avctx->rc_max_rate / fps;
-
- ff_dlog(s, "%d %f %d %f %f\n",
- buffer_size, rcc->buffer_index, frame_size, min_rate, max_rate);
-
- if (buffer_size) {
- int left;
-
- rcc->buffer_index -= frame_size;
- if (rcc->buffer_index < 0) {
- av_log(s->avctx, AV_LOG_ERROR, "rc buffer underflow\n");
- if (frame_size > max_rate && s->qscale == s->avctx->qmax) {
- av_log(s->avctx, AV_LOG_ERROR, "max bitrate possibly too small or try trellis with large lmax or increase qmax\n");
- }
- rcc->buffer_index = 0;
- }
-
- left = buffer_size - rcc->buffer_index - 1;
- rcc->buffer_index += av_clip(left, min_rate, max_rate);
-
- if (rcc->buffer_index > buffer_size) {
- int stuffing = ceil((rcc->buffer_index - buffer_size) / 8);
-
- if (stuffing < 4 && s->codec_id == AV_CODEC_ID_MPEG4)
- stuffing = 4;
- rcc->buffer_index -= 8 * stuffing;
-
- if (s->avctx->debug & FF_DEBUG_RC)
- av_log(s->avctx, AV_LOG_DEBUG, "stuffing %d bytes\n", stuffing);
-
- return stuffing;
- }
- }
- return 0;
-}
-
-/**
- * Modify the bitrate curve from pass1 for one frame.
- */
-static double get_qscale(MpegEncContext *s, RateControlEntry *rce,
- double rate_factor, int frame_num)
-{
- RateControlContext *rcc = &s->rc_context;
- AVCodecContext *a = s->avctx;
- const int pict_type = rce->new_pict_type;
- const double mb_num = s->mb_num;
- double q, bits;
- int i;
-
- double const_values[] = {
- M_PI,
- M_E,
- rce->i_tex_bits * rce->qscale,
- rce->p_tex_bits * rce->qscale,
- (rce->i_tex_bits + rce->p_tex_bits) * (double)rce->qscale,
- rce->mv_bits / mb_num,
- rce->pict_type == AV_PICTURE_TYPE_B ? (rce->f_code + rce->b_code) * 0.5 : rce->f_code,
- rce->i_count / mb_num,
- rce->mc_mb_var_sum / mb_num,
- rce->mb_var_sum / mb_num,
- rce->pict_type == AV_PICTURE_TYPE_I,
- rce->pict_type == AV_PICTURE_TYPE_P,
- rce->pict_type == AV_PICTURE_TYPE_B,
- rcc->qscale_sum[pict_type] / (double)rcc->frame_count[pict_type],
- a->qcompress,
- 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],
- rcc->p_cplx_sum[AV_PICTURE_TYPE_B] / (double)rcc->frame_count[AV_PICTURE_TYPE_B],
- (rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / (double)rcc->frame_count[pict_type],
- 0
- };
-
- 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->rc_eq);
- return -1;
- }
-
- rcc->pass1_rc_eq_output_sum += bits;
- bits *= rate_factor;
- 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].qscale)
- bits = qp2bits(rce, rco[i].qscale); // FIXME move at end to really force it?
- else
- bits *= rco[i].quality_factor;
- }
-
- q = bits2qp(rce, bits);
-
- /* I/B difference */
- if (pict_type == AV_PICTURE_TYPE_I && s->avctx->i_quant_factor < 0.0)
- 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;
-
- return 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))
- 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)
- q = last_non_b_q * a->b_quant_factor + a->b_quant_offset;
- 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;
- }
-
- rcc->last_qscale_for[pict_type] = q; // Note we cannot do that after blurring
-
- if (pict_type != AV_PICTURE_TYPE_B)
- rcc->last_non_b_pict_type = pict_type;
-
- return q;
-}
-
-/**
- * Get the qmin & qmax for pict_type.
- */
-static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type)
-{
- int qmin = s->lmin;
- int qmax = s->lmax;
-
- av_assert0(qmin <= qmax);
-
- 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);
- 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;
-
- *qmin_ret = qmin;
- *qmax_ret = qmax;
-}
-
-static double modify_qscale(MpegEncContext *s, RateControlEntry *rce,
- double q, int frame_num)
-{
- RateControlContext *rcc = &s->rc_context;
- const double buffer_size = s->avctx->rc_buffer_size;
- const double fps = get_fps(s->avctx);
- 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);
+int ff_vbv_update(MpegEncContext *s, int frame_size)
+{
+ RateControlContext *rcc = &s->rc_context;
+ const double fps = get_fps(s->avctx);
+ const int buffer_size = s->avctx->rc_buffer_size;
+ const double min_rate = s->avctx->rc_min_rate / fps;
+ const double max_rate = s->avctx->rc_max_rate / fps;
- /* modulation */
- if (s->rc_qmod_freq &&
- frame_num % s->rc_qmod_freq == 0 &&
- pict_type == AV_PICTURE_TYPE_P)
- q *= s->rc_qmod_amp;
+ ff_dlog(s, "%d %f %d %f %f\n",
+ buffer_size, rcc->buffer_index, frame_size, min_rate, max_rate);
- /* buffer overflow/underflow protection */
if (buffer_size) {
- double expected_size = rcc->buffer_index;
- double q_limit;
-
- 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;
- q *= pow(d, 1.0 / s->rc_buffer_aggressivity);
-
- q_limit = bits2qp(rce,
- FFMAX((min_rate - buffer_size + rcc->buffer_index) *
- s->avctx->rc_min_vbv_overflow_use, 1));
+ int left;
- 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);
- q = q_limit;
+ rcc->buffer_index -= frame_size;
+ if (rcc->buffer_index < 0) {
+ av_log(s->avctx, AV_LOG_ERROR, "rc buffer underflow\n");
+ if (frame_size > max_rate && s->qscale == s->avctx->qmax) {
+ av_log(s->avctx, AV_LOG_ERROR, "max bitrate possibly too small or try trellis with large lmax or increase qmax\n");
}
+ rcc->buffer_index = 0;
}
- 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;
- q /= pow(d, 1.0 / s->rc_buffer_aggressivity);
+ left = buffer_size - rcc->buffer_index - 1;
+ rcc->buffer_index += av_clip(left, min_rate, max_rate);
- 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);
- q = q_limit;
- }
- }
- }
- 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->rc_buffer_aggressivity);
- if (s->rc_qsquish == 0.0 || qmin == qmax) {
- if (q < qmin)
- q = qmin;
- else if (q > qmax)
- q = qmax;
- } else {
- double min2 = log(qmin);
- double max2 = log(qmax);
+ if (rcc->buffer_index > buffer_size) {
+ int stuffing = ceil((rcc->buffer_index - buffer_size) / 8);
- q = log(q);
- q = (q - min2) / (max2 - min2) - 0.5;
- q *= -4.0;
- q = 1.0 / (1.0 + exp(q));
- q = q * (max2 - min2) + min2;
+ if (stuffing < 4 && s->codec_id == AV_CODEC_ID_MPEG4)
+ stuffing = 4;
+ rcc->buffer_index -= 8 * stuffing;
- q = exp(q);
- }
+ if (s->avctx->debug & FF_DEBUG_RC)
+ av_log(s->avctx, AV_LOG_DEBUG, "stuffing %d bytes\n", stuffing);
- return q;
+ return stuffing;
+ }
+ }
+ return 0;
}
-// ----------------------------------
-// 1 Pass Code
-
static double predict_size(Predictor *p, double q, double var)
{
return p->coeff * var / (q * p->count);
@@ -872,167 +1026,3 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
}
return q;
}
-
-// ----------------------------------------------
-// 2-Pass code
-
-static int init_pass2(MpegEncContext *s)
-{
- RateControlContext *rcc = &s->rc_context;
- AVCodecContext *a = s->avctx;
- int i, toobig;
- double fps = get_fps(s->avctx);
- 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);
- double rate_factor = 0;
- double step;
- const int filter_size = (int)(a->qblur * 4) | 1;
- double expected_bits = 0; // init to silence gcc warning
- double *qscale, *blurred_qscale, qscale_sum;
-
- /* find complexity & const_bits & decide the pict_types */
- for (i = 0; i < rcc->num_entries; i++) {
- RateControlEntry *rce = &rcc->entry[i];
-
- rce->new_pict_type = rce->pict_type;
- rcc->i_cplx_sum[rce->pict_type] += rce->i_tex_bits * rce->qscale;
- rcc->p_cplx_sum[rce->pict_type] += rce->p_tex_bits * rce->qscale;
- 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;
- 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];
-
- if (all_available_bits < all_const_bits) {
- av_log(s->avctx, AV_LOG_ERROR, "requested bitrate is too low\n");
- return -1;
- }
-
- qscale = av_malloc_array(rcc->num_entries, sizeof(double));
- blurred_qscale = av_malloc_array(rcc->num_entries, sizeof(double));
- 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 = 0;
- rate_factor += step;
-
- rcc->buffer_index = s->avctx->rc_buffer_size / 2;
-
- /* 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];
- }
- av_assert0(filter_size % 2 == 1);
-
- /* fixed I/B QP relative to P mode */
- for (i = FFMAX(0, rcc->num_entries - 300); i < rcc->num_entries; i++) {
- RateControlEntry *rce = &rcc->entry[i];
-
- qscale[i] = get_diff_limited_q(s, rce, qscale[i]);
- }
-
- for (i = rcc->num_entries - 1; i >= 0; i--) {
- RateControlEntry *rce = &rcc->entry[i];
-
- qscale[i] = get_diff_limited_q(s, rce, qscale[i]);
- }
-
- /* smooth curve */
- for (i = 0; i < rcc->num_entries; i++) {
- RateControlEntry *rce = &rcc->entry[i];
- const int pict_type = rce->new_pict_type;
- int j;
- double q = 0.0, sum = 0.0;
-
- for (j = 0; j < filter_size; j++) {
- int index = i + j - filter_size / 2;
- 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;
- q += qscale[index] * coeff;
- sum += coeff;
- }
- blurred_qscale[i] = q / sum;
- }
-
- /* find expected bits */
- 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);
-
- rce->expected_bits = expected_bits;
- expected_bits += bits;
- }
-
- 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) {
- rate_factor -= step;
- ++toobig;
- }
- }
- av_free(qscale);
- av_free(blurred_qscale);
-
- /* check bitrate calculations and print info */
- qscale_sum = 0.0;
- for (i = 0; i < rcc->num_entries; i++) {
- 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);
- qscale_sum += av_clip(rcc->entry[i].new_qscale / FF_QP2LAMBDA,
- s->avctx->qmin, s->avctx->qmax);
- }
- av_assert0(toobig <= 40);
- av_log(s->avctx, AV_LOG_DEBUG,
- "[lavc rc] requested bitrate: %"PRId64" bps expected bitrate: %"PRId64" bps\n",
- s->bit_rate,
- (int64_t)(expected_bits / ((double)all_available_bits / s->bit_rate)));
- av_log(s->avctx, AV_LOG_DEBUG,
- "[lavc rc] estimated target average qp: %.3f\n",
- (float)qscale_sum / rcc->num_entries);
- if (toobig == 0) {
- av_log(s->avctx, AV_LOG_INFO,
- "[lavc rc] Using all of requested bitrate is not "
- "necessary for this video with these parameters.\n");
- } else if (toobig == 40) {
- av_log(s->avctx, AV_LOG_ERROR,
- "[lavc rc] Error: bitrate too low for this video "
- "with these parameters.\n");
- return -1;
- } else if (fabs(expected_bits / all_available_bits - 1.0) > 0.01) {
- av_log(s->avctx, AV_LOG_ERROR,
- "[lavc rc] Error: 2pass curve failed to converge\n");
- return -1;
- }
-
- return 0;
-}
======================================================================
diff --cc libavcodec/ratecontrol.c
index b731f72,78a438f..6b28c75
--- a/libavcodec/ratecontrol.c
+++ b/libavcodec/ratecontrol.c
@@@ -35,50 -35,413 +35,438 @@@
#include "mpegvideo.h"
#include "libavutil/eval.h"
- static int init_pass2(MpegEncContext *s);
- static double get_qscale(MpegEncContext *s, RateControlEntry *rce,
- double rate_factor, int frame_num);
-
-#undef NDEBUG // Always check asserts, the speed effect is far too small to disable them.
-#include <assert.h>
+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:%"PRId64" var:%"PRId64" 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 double get_fps(AVCodecContext *avctx)
- {
- return 1.0 / av_q2d(avctx->time_base) / FFMAX(avctx->ticks_per_frame, 1);
- }
-#ifndef M_E
-#define M_E 2.718281828
-#endif
++static double get_fps(AVCodecContext *avctx)
++{
++ return 1.0 / av_q2d(avctx->time_base) / FFMAX(avctx->ticks_per_frame, 1);
++}
+
+ 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)
+ {
+ if (bits < 0.9) {
+ av_log(NULL, AV_LOG_ERROR, "bits<0.9\n");
+ }
+ return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits + 1) / bits;
+ }
+
+ 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))
+ 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)
+ q = last_non_b_q * a->b_quant_factor + a->b_quant_offset;
+ 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;
+ }
+
+ rcc->last_qscale_for[pict_type] = q; // Note we cannot do that after blurring
+
+ if (pict_type != AV_PICTURE_TYPE_B)
+ rcc->last_non_b_pict_type = pict_type;
+
+ return q;
+ }
+
+ /**
+ * Get the qmin & qmax for pict_type.
+ */
+ static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type)
+ {
+ int qmin = s->lmin;
+ int qmax = s->lmax;
+
- assert(qmin <= qmax);
++ av_assert0(qmin <= qmax);
+
+ 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);
+ 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;
+
+ *qmin_ret = qmin;
+ *qmax_ret = qmax;
+ }
+
+ static double modify_qscale(MpegEncContext *s, RateControlEntry *rce,
+ double q, int frame_num)
+ {
+ RateControlContext *rcc = &s->rc_context;
+ const double buffer_size = s->avctx->rc_buffer_size;
- const double fps = 1 / av_q2d(s->avctx->time_base);
++ const double fps = get_fps(s->avctx);
+ 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->rc_qmod_freq &&
+ frame_num % s->rc_qmod_freq == 0 &&
+ pict_type == AV_PICTURE_TYPE_P)
+ q *= s->rc_qmod_amp;
+
+ /* buffer overflow/underflow protection */
+ if (buffer_size) {
+ double expected_size = rcc->buffer_index;
+ double q_limit;
+
+ 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;
+ q *= pow(d, 1.0 / s->rc_buffer_aggressivity);
+
+ 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);
+ 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;
+ q /= pow(d, 1.0 / s->rc_buffer_aggressivity);
+
+ 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);
+ q = q_limit;
+ }
+ }
+ }
+ 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->rc_buffer_aggressivity);
+ if (s->rc_qsquish == 0.0 || qmin == qmax) {
+ if (q < qmin)
+ q = qmin;
+ else if (q > qmax)
+ q = qmax;
+ } else {
+ double min2 = log(qmin);
+ double max2 = log(qmax);
+
+ q = log(q);
+ q = (q - min2) / (max2 - min2) - 0.5;
+ q *= -4.0;
+ q = 1.0 / (1.0 + exp(q));
+ q = q * (max2 - min2) + min2;
+
+ q = exp(q);
+ }
+
+ return q;
+ }
+
+ /**
+ * Modify the bitrate curve from pass1 for one frame.
+ */
+ static double get_qscale(MpegEncContext *s, RateControlEntry *rce,
+ double rate_factor, int frame_num)
+ {
+ RateControlContext *rcc = &s->rc_context;
+ AVCodecContext *a = s->avctx;
+ const int pict_type = rce->new_pict_type;
+ const double mb_num = s->mb_num;
+ double q, bits;
+ int i;
+
+ double const_values[] = {
+ M_PI,
+ M_E,
+ rce->i_tex_bits * rce->qscale,
+ rce->p_tex_bits * rce->qscale,
+ (rce->i_tex_bits + rce->p_tex_bits) * (double)rce->qscale,
+ rce->mv_bits / mb_num,
+ rce->pict_type == AV_PICTURE_TYPE_B ? (rce->f_code + rce->b_code) * 0.5 : rce->f_code,
+ rce->i_count / mb_num,
+ rce->mc_mb_var_sum / mb_num,
+ rce->mb_var_sum / mb_num,
+ rce->pict_type == AV_PICTURE_TYPE_I,
+ rce->pict_type == AV_PICTURE_TYPE_P,
+ rce->pict_type == AV_PICTURE_TYPE_B,
+ rcc->qscale_sum[pict_type] / (double)rcc->frame_count[pict_type],
+ a->qcompress,
+ 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],
+ rcc->p_cplx_sum[AV_PICTURE_TYPE_B] / (double)rcc->frame_count[AV_PICTURE_TYPE_B],
+ (rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / (double)rcc->frame_count[pict_type],
+ 0
+ };
+
+ 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->rc_eq);
+ return -1;
+ }
+
+ rcc->pass1_rc_eq_output_sum += bits;
+ bits *= rate_factor;
+ 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].qscale)
+ bits = qp2bits(rce, rco[i].qscale); // FIXME move at end to really force it?
+ else
+ bits *= rco[i].quality_factor;
+ }
+
+ q = bits2qp(rce, bits);
+
+ /* I/B difference */
+ if (pict_type == AV_PICTURE_TYPE_I && s->avctx->i_quant_factor < 0.0)
+ 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;
+
+ return q;
+ }
+
+ static int init_pass2(MpegEncContext *s)
+ {
+ RateControlContext *rcc = &s->rc_context;
+ AVCodecContext *a = s->avctx;
+ int i, toobig;
- double fps = 1 / av_q2d(s->avctx->time_base);
++ double fps = get_fps(s->avctx);
+ 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);
+ double rate_factor = 0;
+ double step;
+ const int filter_size = (int)(a->qblur * 4) | 1;
- double expected_bits;
++ double expected_bits = 0; // init to silence gcc warning
+ double *qscale, *blurred_qscale, qscale_sum;
+
+ /* find complexity & const_bits & decide the pict_types */
+ for (i = 0; i < rcc->num_entries; i++) {
+ RateControlEntry *rce = &rcc->entry[i];
+
+ rce->new_pict_type = rce->pict_type;
+ rcc->i_cplx_sum[rce->pict_type] += rce->i_tex_bits * rce->qscale;
+ rcc->p_cplx_sum[rce->pict_type] += rce->p_tex_bits * rce->qscale;
+ 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;
+ 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];
+
+ if (all_available_bits < all_const_bits) {
+ av_log(s->avctx, AV_LOG_ERROR, "requested bitrate is too low\n");
+ return -1;
+ }
+
- qscale = av_malloc(sizeof(double) * rcc->num_entries);
- blurred_qscale = av_malloc(sizeof(double) * rcc->num_entries);
++ qscale = av_malloc_array(rcc->num_entries, sizeof(double));
++ blurred_qscale = av_malloc_array(rcc->num_entries, sizeof(double));
+ 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 = 0;
+ rate_factor += step;
+
+ rcc->buffer_index = s->avctx->rc_buffer_size / 2;
+
+ /* 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];
+ }
- assert(filter_size % 2 == 1);
++ av_assert0(filter_size % 2 == 1);
+
+ /* fixed I/B QP relative to P mode */
++ for (i = FFMAX(0, rcc->num_entries - 300); i < rcc->num_entries; i++) {
++ RateControlEntry *rce = &rcc->entry[i];
++
++ qscale[i] = get_diff_limited_q(s, rce, qscale[i]);
++ }
++
+ for (i = rcc->num_entries - 1; i >= 0; i--) {
+ RateControlEntry *rce = &rcc->entry[i];
+
+ qscale[i] = get_diff_limited_q(s, rce, qscale[i]);
+ }
+
+ /* smooth curve */
+ for (i = 0; i < rcc->num_entries; i++) {
+ RateControlEntry *rce = &rcc->entry[i];
+ const int pict_type = rce->new_pict_type;
+ int j;
+ double q = 0.0, sum = 0.0;
+
+ for (j = 0; j < filter_size; j++) {
+ int index = i + j - filter_size / 2;
+ 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;
+ q += qscale[index] * coeff;
+ sum += coeff;
+ }
+ blurred_qscale[i] = q / sum;
+ }
+
+ /* find expected bits */
+ 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);
+
+ rce->expected_bits = expected_bits;
+ expected_bits += bits;
+ }
- static inline double qp2bits(RateControlEntry *rce, double qp)
- {
- if (qp <= 0.0) {
- av_log(NULL, AV_LOG_ERROR, "qp<=0.0\n");
+ 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) {
+ rate_factor -= step;
+ ++toobig;
+ }
}
- return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits + 1) / qp;
- }
+ av_free(qscale);
+ av_free(blurred_qscale);
- static inline double bits2qp(RateControlEntry *rce, double bits)
- {
- if (bits < 0.9) {
- av_log(NULL, AV_LOG_ERROR, "bits<0.9\n");
+ /* check bitrate calculations and print info */
+ qscale_sum = 0.0;
+ for (i = 0; i < rcc->num_entries; i++) {
+ 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);
+ qscale_sum += av_clip(rcc->entry[i].new_qscale / FF_QP2LAMBDA,
+ s->avctx->qmin, s->avctx->qmax);
}
- return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits + 1) / bits;
- assert(toobig <= 40);
++ av_assert0(toobig <= 40);
+ av_log(s->avctx, AV_LOG_DEBUG,
- "[lavc rc] requested bitrate: %d bps expected bitrate: %d bps\n",
++ "[lavc rc] requested bitrate: %"PRId64" bps expected bitrate: %"PRId64" bps\n",
+ s->bit_rate,
- (int)(expected_bits / ((double)all_available_bits / s->bit_rate)));
++ (int64_t)(expected_bits / ((double)all_available_bits / s->bit_rate)));
+ av_log(s->avctx, AV_LOG_DEBUG,
+ "[lavc rc] estimated target average qp: %.3f\n",
+ (float)qscale_sum / rcc->num_entries);
+ if (toobig == 0) {
+ av_log(s->avctx, AV_LOG_INFO,
+ "[lavc rc] Using all of requested bitrate is not "
+ "necessary for this video with these parameters.\n");
+ } else if (toobig == 40) {
+ av_log(s->avctx, AV_LOG_ERROR,
+ "[lavc rc] Error: bitrate too low for this video "
+ "with these parameters.\n");
+ return -1;
+ } else if (fabs(expected_bits / all_available_bits - 1.0) > 0.01) {
+ av_log(s->avctx, AV_LOG_ERROR,
+ "[lavc rc] Error: 2pass curve failed to converge\n");
+ return -1;
+ }
+
+ return 0;
}
av_cold int ff_rate_control_init(MpegEncContext *s)
@@@ -290,282 -644,45 +678,48 @@@ av_cold void ff_rate_control_uninit(Mpe
av_freep(&rcc->entry);
}
- int ff_vbv_update(MpegEncContext *s, int frame_size)
- {
- RateControlContext *rcc = &s->rc_context;
- const double fps = get_fps(s->avctx);
- const int buffer_size = s->avctx->rc_buffer_size;
- const double min_rate = s->avctx->rc_min_rate / fps;
- const double max_rate = s->avctx->rc_max_rate / fps;
-
- ff_dlog(s, "%d %f %d %f %f\n",
- buffer_size, rcc->buffer_index, frame_size, min_rate, max_rate);
-
- if (buffer_size) {
- int left;
-
- rcc->buffer_index -= frame_size;
- if (rcc->buffer_index < 0) {
- av_log(s->avctx, AV_LOG_ERROR, "rc buffer underflow\n");
- if (frame_size > max_rate && s->qscale == s->avctx->qmax) {
- av_log(s->avctx, AV_LOG_ERROR, "max bitrate possibly too small or try trellis with large lmax or increase qmax\n");
- }
- rcc->buffer_index = 0;
- }
-
- left = buffer_size - rcc->buffer_index - 1;
- rcc->buffer_index += av_clip(left, min_rate, max_rate);
-
- if (rcc->buffer_index > buffer_size) {
- int stuffing = ceil((rcc->buffer_index - buffer_size) / 8);
-
- if (stuffing < 4 && s->codec_id == AV_CODEC_ID_MPEG4)
- stuffing = 4;
- rcc->buffer_index -= 8 * stuffing;
-
- if (s->avctx->debug & FF_DEBUG_RC)
- av_log(s->avctx, AV_LOG_DEBUG, "stuffing %d bytes\n", stuffing);
-
- return stuffing;
- }
- }
- return 0;
- }
-
- /**
- * Modify the bitrate curve from pass1 for one frame.
- */
- static double get_qscale(MpegEncContext *s, RateControlEntry *rce,
- double rate_factor, int frame_num)
- {
- RateControlContext *rcc = &s->rc_context;
- AVCodecContext *a = s->avctx;
- const int pict_type = rce->new_pict_type;
- const double mb_num = s->mb_num;
- double q, bits;
- int i;
-
- double const_values[] = {
- M_PI,
- M_E,
- rce->i_tex_bits * rce->qscale,
- rce->p_tex_bits * rce->qscale,
- (rce->i_tex_bits + rce->p_tex_bits) * (double)rce->qscale,
- rce->mv_bits / mb_num,
- rce->pict_type == AV_PICTURE_TYPE_B ? (rce->f_code + rce->b_code) * 0.5 : rce->f_code,
- rce->i_count / mb_num,
- rce->mc_mb_var_sum / mb_num,
- rce->mb_var_sum / mb_num,
- rce->pict_type == AV_PICTURE_TYPE_I,
- rce->pict_type == AV_PICTURE_TYPE_P,
- rce->pict_type == AV_PICTURE_TYPE_B,
- rcc->qscale_sum[pict_type] / (double)rcc->frame_count[pict_type],
- a->qcompress,
- 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],
- rcc->p_cplx_sum[AV_PICTURE_TYPE_B] / (double)rcc->frame_count[AV_PICTURE_TYPE_B],
- (rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / (double)rcc->frame_count[pict_type],
- 0
- };
-
- 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->rc_eq);
- return -1;
- }
-
- rcc->pass1_rc_eq_output_sum += bits;
- bits *= rate_factor;
- 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].qscale)
- bits = qp2bits(rce, rco[i].qscale); // FIXME move at end to really force it?
- else
- bits *= rco[i].quality_factor;
- }
-
- q = bits2qp(rce, bits);
-
- /* I/B difference */
- if (pict_type == AV_PICTURE_TYPE_I && s->avctx->i_quant_factor < 0.0)
- 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;
-
- return 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))
- 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)
- q = last_non_b_q * a->b_quant_factor + a->b_quant_offset;
- 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;
- }
-
- rcc->last_qscale_for[pict_type] = q; // Note we cannot do that after blurring
-
- if (pict_type != AV_PICTURE_TYPE_B)
- rcc->last_non_b_pict_type = pict_type;
-
- return q;
- }
-
- /**
- * Get the qmin & qmax for pict_type.
- */
- static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type)
- {
- int qmin = s->lmin;
- int qmax = s->lmax;
-
- av_assert0(qmin <= qmax);
-
- 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);
- 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;
-
- *qmin_ret = qmin;
- *qmax_ret = qmax;
- }
-
- static double modify_qscale(MpegEncContext *s, RateControlEntry *rce,
- double q, int frame_num)
- {
- RateControlContext *rcc = &s->rc_context;
- const double buffer_size = s->avctx->rc_buffer_size;
- const double fps = get_fps(s->avctx);
- 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);
+ 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 double fps = get_fps(s->avctx);
+ const int buffer_size = s->avctx->rc_buffer_size;
+ const double min_rate = s->avctx->rc_min_rate / fps;
+ const double max_rate = s->avctx->rc_max_rate / fps;
- /* modulation */
- if (s->rc_qmod_freq &&
- frame_num % s->rc_qmod_freq == 0 &&
- pict_type == AV_PICTURE_TYPE_P)
- q *= s->rc_qmod_amp;
+ ff_dlog(s, "%d %f %d %f %f\n",
+ buffer_size, rcc->buffer_index, frame_size, min_rate, max_rate);
- /* buffer overflow/underflow protection */
if (buffer_size) {
- double expected_size = rcc->buffer_index;
- double q_limit;
-
- 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;
- q *= pow(d, 1.0 / s->rc_buffer_aggressivity);
-
- q_limit = bits2qp(rce,
- FFMAX((min_rate - buffer_size + rcc->buffer_index) *
- s->avctx->rc_min_vbv_overflow_use, 1));
+ int left;
- 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);
- q = q_limit;
+ rcc->buffer_index -= frame_size;
+ if (rcc->buffer_index < 0) {
+ av_log(s->avctx, AV_LOG_ERROR, "rc buffer underflow\n");
++ if (frame_size > max_rate && s->qscale == s->avctx->qmax) {
++ av_log(s->avctx, AV_LOG_ERROR, "max bitrate possibly too small or try trellis with large lmax or increase qmax\n");
+ }
+ rcc->buffer_index = 0;
}
- 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;
- q /= pow(d, 1.0 / s->rc_buffer_aggressivity);
+ left = buffer_size - rcc->buffer_index - 1;
+ rcc->buffer_index += av_clip(left, min_rate, max_rate);
- 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);
- q = q_limit;
- }
- }
- }
- 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->rc_buffer_aggressivity);
- if (s->rc_qsquish == 0.0 || qmin == qmax) {
- if (q < qmin)
- q = qmin;
- else if (q > qmax)
- q = qmax;
- } else {
- double min2 = log(qmin);
- double max2 = log(qmax);
+ if (rcc->buffer_index > buffer_size) {
+ int stuffing = ceil((rcc->buffer_index - buffer_size) / 8);
- q = log(q);
- q = (q - min2) / (max2 - min2) - 0.5;
- q *= -4.0;
- q = 1.0 / (1.0 + exp(q));
- q = q * (max2 - min2) + min2;
+ if (stuffing < 4 && s->codec_id == AV_CODEC_ID_MPEG4)
+ stuffing = 4;
+ rcc->buffer_index -= 8 * stuffing;
- q = exp(q);
- }
+ if (s->avctx->debug & FF_DEBUG_RC)
+ av_log(s->avctx, AV_LOG_DEBUG, "stuffing %d bytes\n", stuffing);
- return q;
+ return stuffing;
+ }
+ }
+ return 0;
}
- // ----------------------------------
- // 1 Pass Code
-
static double predict_size(Predictor *p, double q, double var)
{
return p->coeff * var / (q * p->count);
More information about the ffmpeg-cvslog
mailing list