avcodec/mpegvideoenc: Move ratecontrol to MPVMainEncContext

Andreas Rheinhardt committed 4 years ago

Commit d8c79251 parent bb0a72b6 files · +140 −120Browse files

Showing the changes to libavcodec (6 of 6 files). Show all

Unified · Split

6 files

libavcodec/mpegvideo.h +0 −8
libavcodec/mpegvideo_enc.c +40 −33
libavcodec/mpegvideoenc.h +9 −1
libavcodec/ratecontrol.c +42 −33
libavcodec/ratecontrol.h +6 −6
libavcodec/snowenc.c +43 −39

@@ -42,7 +42,6 @@ · 41 unmodified lines
42	42	#include "mpegvideoencdsp.h"
43	43	#include "pixblockdsp.h"
44	44	#include "put_bits.h"
45		−#include "ratecontrol.h"
46	45	#include "qpeldsp.h"
47	46	#include "videodsp.h"
48	47
@@ -327,13 +326,6 @@ typedef struct MpegEncContext { · 278 unmodified lines
327	326	int dct_count[2];
328	327	uint16_t (*dct_offset)[64];
329	328
330		− /* bit rate control */
331		− int64_t total_bits;
332		− int frame_bits; ///< bits used for the current frame
333		− int stuffing_bits; ///< bits used for stuffing
334		− int next_lambda; ///< next lambda used for retrying to encode a frame
335		− RateControlContext rc_context; ///< contains stuff only accessed in ratecontrol.c
336		−
337	329	/* statistics, used for 2-pass encoding */
338	330	int mv_bits;
339	331	int header_bits;

libavcodec/mpegvideo_enc.c+40−33

@@ -84,7 +84,7 @@ · 83 unmodified lines
84	84	#define QMAT_SHIFT_MMX 16
85	85	#define QMAT_SHIFT 21
86	86
87		−static int encode_picture(MpegEncContext s, const AVPacket pkt);
	87	+static int encode_picture(MPVMainEncContext const s, const AVPacket pkt);
88	88	static int dct_quantize_refine(MpegEncContext s, int16_t block, int16_t weight, int16_t orig, int n, int qscale);
89	89	static int sse_mb(MpegEncContext *s);
90	90	static void denoise_dct_c(MpegEncContext s, int16_t block);
@@ -1008,7 +1008,8 @@ av_cold int ff_mpv_encode_init(AVCodecContext *avctx) · 917 unmodified lines
1008	1008	#endif
1009	1009	}
1010	1010
1011		− if ((ret = ff_rate_control_init(s)) < 0)
	1011	+ ret = ff_rate_control_init(m);
	1012	+ if (ret < 0)
1012	1013	return ret;
1013	1014
1014	1015	if (m->b_frame_strategy == 2) {
@@ -1043,7 +1044,7 @@ av_cold int ff_mpv_encode_end(AVCodecContext *avctx) · 28 unmodified lines
1043	1044	MPVMainEncContext *const m = avctx->priv_data;
1044	1045	MpegEncContext *const s = &m->s;
1045	1046
1046		− ff_rate_control_uninit(&s->rc_context);
	1047	+ ff_rate_control_uninit(&m->rc_context);
1047	1048
1048	1049	ff_mpv_common_end(s);
1049	1050	av_refstruct_pool_uninit(&s->picture_pool);
@@ -1622,7 +1623,7 @@ static int set_bframe_chain_length(MPVMainEncContext *const m) · 572 unmodified lines
1622	1623	// FIXME check that the gop check above is +-1 correct
1623	1624	av_refstruct_unref(&s->input_picture[0]);
1624	1625
1625		− ff_vbv_update(s, 0);
	1626	+ ff_vbv_update(m, 0);
1626	1627
1627	1628	return 0;
1628	1629	}
@@ -1642,15 +1643,15 @@ static int set_bframe_chain_length(MPVMainEncContext *const m) · 13 unmodified lines
1642	1643	for (int i = 0; i < s->max_b_frames + 1; i++) {
1643	1644	int pict_num = s->input_picture[0]->display_picture_number + i;
1644	1645
1645		− if (pict_num >= s->rc_context.num_entries)
	1646	+ if (pict_num >= m->rc_context.num_entries)
1646	1647	break;
1647	1648	if (!s->input_picture[i]) {
1648		− s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
	1649	+ m->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1649	1650	break;
1650	1651	}
1651	1652
1652	1653	s->input_picture[i]->f->pict_type =
1653		− s->rc_context.entry[pict_num].new_pict_type;
	1654	+ m->rc_context.entry[pict_num].new_pict_type;
1654	1655	}
1655	1656	}
1656	1657
@@ -1918,7 +1919,7 @@ int ff_mpv_encode_picture(AVCodecContext avctx, AVPacket pkt, · 261 unmodified lines
1918	1919	//emms_c();
1919	1920	frame_start(s);
1920	1921	vbv_retry:
1921		− ret = encode_picture(s, pkt);
	1922	+ ret = encode_picture(m, pkt);
1922	1923	if (growing_buffer) {
1923	1924	av_assert0(s->pb.buf == avctx->internal->byte_buffer);
1924	1925	pkt->data = s->pb.buf;
@@ -1933,14 +1934,14 @@ vbv_retry: · 8 unmodified lines
1933	1934	ff_mjpeg_encode_picture_trailer(&s->pb, s->header_bits);
1934	1935
1935	1936	if (avctx->rc_buffer_size) {
1936		− RateControlContext *rcc = &s->rc_context;
	1937	+ RateControlContext *rcc = &m->rc_context;
1937	1938	int max_size = FFMAX(rcc->buffer_index * avctx->rc_max_available_vbv_use, rcc->buffer_index - 500);
1938	1939	int hq = (avctx->mb_decision == FF_MB_DECISION_RD \|\| avctx->trellis);
1939	1940	int min_step = hq ? 1 : (1<<(FF_LAMBDA_SHIFT + 7))/139;
1940	1941
1941	1942	if (put_bits_count(&s->pb) > max_size &&
1942	1943	s->lambda < s->lmax) {
1943		− s->next_lambda = FFMAX(s->lambda + min_step, s->lambda *
	1944	+ m->next_lambda = FFMAX(s->lambda + min_step, s->lambda *
1944	1945	(s->qscale + 1) / s->qscale);
1945	1946	if (s->adaptive_quant) {
1946	1947	int i;
@@ -1968,7 +1969,7 @@ vbv_retry: · 21 unmodified lines
1968	1969	}
1969	1970
1970	1971	if (avctx->flags & AV_CODEC_FLAG_PASS1)
1971		− ff_write_pass1_stats(s);
	1972	+ ff_write_pass1_stats(m);
1972	1973
1973	1974	for (int i = 0; i < MPV_MAX_PLANES; i++)
1974	1975	avctx->error[i] += s->encoding_error[i];
@@ -1982,10 +1983,10 @@ vbv_retry: · 7 unmodified lines
1982	1983	s->misc_bits + s->i_tex_bits +
1983	1984	s->p_tex_bits);
1984	1985	flush_put_bits(&s->pb);
1985		− s->frame_bits = put_bits_count(&s->pb);
	1986	+ m->frame_bits = put_bits_count(&s->pb);
1986	1987
1987		− stuffing_count = ff_vbv_update(s, s->frame_bits);
1988		− s->stuffing_bits = 8*stuffing_count;
	1988	+ stuffing_count = ff_vbv_update(m, m->frame_bits);
	1989	+ m->stuffing_bits = 8*stuffing_count;
1989	1990	if (stuffing_count) {
1990	1991	if (put_bytes_left(&s->pb, 0) < stuffing_count + 50) {
1991	1992	av_log(avctx, AV_LOG_ERROR, "stuffing too large\n");
@@ -2009,10 +2010,10 @@ vbv_retry: · 17 unmodified lines
2009	2010	break;
2010	2011	default:
2011	2012	av_log(avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2012		− s->stuffing_bits = 0;
	2013	+ m->stuffing_bits = 0;
2013	2014	}
2014	2015	flush_put_bits(&s->pb);
2015		− s->frame_bits = put_bits_count(&s->pb);
	2016	+ m->frame_bits = put_bits_count(&s->pb);
2016	2017	}
2017	2018
2018	2019	/* update MPEG-1/2 vbv_delay for CBR */
@@ -2027,9 +2028,9 @@ vbv_retry: · 8 unmodified lines
2027	2028	int vbv_delay, min_delay;
2028	2029	double inbits = avctx->rc_max_rate *
2029	2030	av_q2d(avctx->time_base);
2030		− int minbits = s->frame_bits - 8 *
	2031	+ int minbits = m->frame_bits - 8 *
2031	2032	(s->vbv_delay_pos - 1);
2032		− double bits = s->rc_context.buffer_index + minbits - inbits;
	2033	+ double bits = m->rc_context.buffer_index + minbits - inbits;
2033	2034	uint8_t *const vbv_delay_ptr = s->pb.buf + s->vbv_delay_pos;
2034	2035
2035	2036	if (bits < 0)
@@ -2064,7 +2065,7 @@ vbv_retry: · 28 unmodified lines
2064	2065	return ret;
2065	2066	}
2066	2067	}
2067		− s->total_bits += s->frame_bits;
	2068	+ m->total_bits += m->frame_bits;
2068	2069
2069	2070	pkt->pts = s->cur_pic.ptr->f->pts;
2070	2071	pkt->duration = s->cur_pic.ptr->f->duration;
@@ -2089,14 +2090,14 @@ vbv_retry: · 18 unmodified lines
2089	2090	if (s->mb_info)
2090	2091	av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
2091	2092	} else {
2092		− s->frame_bits = 0;
	2093	+ m->frame_bits = 0;
2093	2094	}
2094	2095
2095	2096	ff_mpv_unref_picture(&s->cur_pic);
2096	2097
2097		− av_assert1((s->frame_bits & 7) == 0);
	2098	+ av_assert1((m->frame_bits & 7) == 0);
2098	2099
2099		− pkt->size = s->frame_bits / 8;
	2100	+ pkt->size = m->frame_bits / 8;
2100	2101	*got_packet = !!pkt->size;
2101	2102	return 0;
2102	2103	}
@@ -3611,12 +3612,15 @@ static void merge_context_after_encode(MpegEncContext dst, MpegEncContext src) · 1508 unmodified lines
3611	3612	flush_put_bits(&dst->pb);
3612	3613	}
3613	3614
3614		−static int estimate_qp(MpegEncContext *s, int dry_run){
3615		− if (s->next_lambda){
3616		− s->cur_pic.ptr->f->quality = s->next_lambda;
3617		− if(!dry_run) s->next_lambda= 0;
	3615	+static int estimate_qp(MPVMainEncContext *const m, int dry_run)
	3616	+{
	3617	+ MpegEncContext *const s = &m->s;
	3618	+
	3619	+ if (m->next_lambda){
	3620	+ s->cur_pic.ptr->f->quality = m->next_lambda;
	3621	+ if(!dry_run) m->next_lambda= 0;
3618	3622	} else if (!s->fixed_qscale) {
3619		− int quality = ff_rate_estimate_qscale(s, dry_run);
	3623	+ int quality = ff_rate_estimate_qscale(m, dry_run);
3620	3624	s->cur_pic.ptr->f->quality = quality;
3621	3625	if (s->cur_pic.ptr->f->quality < 0)
3622	3626	return -1;
@@ -3661,8 +3665,9 @@ static void set_frame_distances(MpegEncContext * s){ · 38 unmodified lines
3661	3665	}
3662	3666	}
3663	3667
3664		−static int encode_picture(MpegEncContext s, const AVPacket pkt)
	3668	+static int encode_picture(MPVMainEncContext const m, const AVPacket pkt)
3665	3669	{
	3670	+ MpegEncContext *const s = &m->s;
3666	3671	int i, ret;
3667	3672	int bits;
3668	3673	int context_count = s->slice_context_count;
@@ -3689,9 +3694,10 @@ static int encode_picture(MpegEncContext s, const AVPacket pkt) · 20 unmodified lines
3689	3694	}
3690	3695
3691	3696	if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
3692		− if (estimate_qp(s,1) < 0)
3693		− return -1;
3694		− ff_get_2pass_fcode(s);
	3697	+ ret = estimate_qp(m, 1);
	3698	+ if (ret < 0)
	3699	+ return ret;
	3700	+ ff_get_2pass_fcode(m);
3695	3701	} else if (!(s->avctx->flags & AV_CODEC_FLAG_QSCALE)) {
3696	3702	if(s->pict_type==AV_PICTURE_TYPE_B)
3697	3703	s->lambda= s->last_lambda_for[s->pict_type];
@@ -3814,8 +3820,9 @@ static int encode_picture(MpegEncContext s, const AVPacket pkt) · 116 unmodified lines
3814	3820	}
3815	3821	}
3816	3822
3817		− if (estimate_qp(s, 0) < 0)
3818		− return -1;
	3823	+ ret = estimate_qp(m, 0);
	3824	+ if (ret < 0)
	3825	+ return ret;
3819	3826
3820	3827	if (s->qscale < 3 && s->max_qcoeff <= 128 &&
3821	3828	s->pict_type == AV_PICTURE_TYPE_I &&

libavcodec/mpegvideoenc.h+9−1

@@ -32,6 +32,7 @@ · 31 unmodified lines
32	32
33	33	#include "libavutil/opt.h"
34	34	#include "mpegvideo.h"
	35	+#include "ratecontrol.h"
35	36
36	37	#define MPVENC_MAX_B_FRAMES 16
37	38
@@ -43,6 +44,13 @@ typedef struct MPVMainEncContext { · 5 unmodified lines
43	44	int b_frame_strategy;
44	45	int b_sensitivity;
45	46	int brd_scale;
	47	+
	48	+ /* bit rate control */
	49	+ int64_t total_bits;
	50	+ int frame_bits; ///< bits used for the current frame
	51	+ int stuffing_bits; ///< bits used for stuffing
	52	+ int next_lambda; ///< next lambda used for retrying to encode a frame
	53	+ RateControlContext rc_context; ///< contains stuff only accessed in ratecontrol.c
46	54	} MPVMainEncContext;
47	55
48	56	#define MAX_FCODE 7
@@ -94,7 +102,7 @@ typedef struct MPVMainEncContext { · 45 unmodified lines
94	102
95	103	#define FF_MPV_OFFSET(x) offsetof(MpegEncContext, x)
96	104	#define FF_MPV_MAIN_OFFSET(x) offsetof(MPVMainEncContext, x)
97		−#define FF_RC_OFFSET(x) offsetof(MpegEncContext, rc_context.x)
	105	+#define FF_RC_OFFSET(x) offsetof(MPVMainEncContext, rc_context.x)
98	106	#define FF_MPV_OPT_FLAGS (AV_OPT_FLAG_VIDEO_PARAM \| AV_OPT_FLAG_ENCODING_PARAM)
99	107	#define FF_MPV_COMMON_OPTS \
100	108	FF_MPV_OPT_CMP_FUNC, \

libavcodec/ratecontrol.c+42−33

@@ -35,8 +35,9 @@ · 34 unmodified lines
35	35	#include "mpegvideoenc.h"
36	36	#include "libavutil/eval.h"
37	37
38		−void ff_write_pass1_stats(MpegEncContext *s)
	38	+void ff_write_pass1_stats(MPVMainEncContext *const m)
39	39	{
	40	+ const MpegEncContext *const s = &m->s;
40	41	snprintf(s->avctx->stats_out, 256,
41	42	"in:%d out:%d type:%d q:%d itex:%d ptex:%d mv:%d misc:%d "
42	43	"fcode:%d bcode:%d mc-var:%"PRId64" var:%"PRId64" icount:%d hbits:%d;\n",
@@ -101,9 +102,10 @@ static double bits2qp_cb(void *rce, double qp) · 58 unmodified lines
101	102	return bits2qp(rce, qp);
102	103	}
103	104
104		−static double get_diff_limited_q(MpegEncContext s, const RateControlEntry rce, double q)
	105	+static double get_diff_limited_q(MPVMainEncContext m, const RateControlEntry rce, double q)
105	106	{
106		− RateControlContext *rcc = &s->rc_context;
	107	+ MpegEncContext *const s = &m->s;
	108	+ RateControlContext *const rcc = &m->rc_context;
107	109	AVCodecContext *a = s->avctx;
108	110	const int pict_type = rce->new_pict_type;
109	111	const double last_p_q = rcc->last_qscale_for[AV_PICTURE_TYPE_P];
@@ -168,10 +170,11 @@ static void get_qminmax(int qmin_ret, int qmax_ret, MpegEncContext *s, int pic · 58 unmodified lines
168	170	*qmax_ret = qmax;
169	171	}
170	172
171		−static double modify_qscale(MpegEncContext s, const RateControlEntry rce,
	173	+static double modify_qscale(MPVMainEncContext const m, const RateControlEntry rce,
172	174	double q, int frame_num)
173	175	{
174		− RateControlContext *rcc = &s->rc_context;
	176	+ MpegEncContext *const s = &m->s;
	177	+ RateControlContext *const rcc = &m->rc_context;
175	178	const double buffer_size = s->avctx->rc_buffer_size;
176	179	const double fps = get_fps(s->avctx);
177	180	const double min_rate = s->avctx->rc_min_rate / fps;
@@ -259,10 +262,11 @@ static double modify_qscale(MpegEncContext s, const RateControlEntry rce, · 81 unmodified lines
259	262	/**
260	263	* Modify the bitrate curve from pass1 for one frame.
261	264	*/
262		−static double get_qscale(MpegEncContext s, RateControlEntry rce,
	265	+static double get_qscale(MPVMainEncContext const m, RateControlEntry rce,
263	266	double rate_factor, int frame_num)
264	267	{
265		− RateControlContext *rcc = &s->rc_context;
	268	+ MpegEncContext *const s = &m->s;
	269	+ RateControlContext *rcc = &m->rc_context;
266	270	AVCodecContext *a = s->avctx;
267	271	const int pict_type = rce->new_pict_type;
268	272	const double mb_num = s->mb_num;
@@ -332,9 +336,10 @@ static double get_qscale(MpegEncContext s, RateControlEntry rce, · 63 unmodified lines
332	336	return q;
333	337	}
334	338
335		−static int init_pass2(MpegEncContext *s)
	339	+static int init_pass2(MPVMainEncContext *const m)
336	340	{
337		− RateControlContext *rcc = &s->rc_context;
	341	+ RateControlContext *const rcc = &m->rc_context;
	342	+ MpegEncContext *const s = &m->s;
338	343	AVCodecContext *a = s->avctx;
339	344	int i, toobig;
340	345	AVRational fps = get_fpsQ(s->avctx);
@@ -393,7 +398,7 @@ static int init_pass2(MpegEncContext *s) · 52 unmodified lines
393	398	for (i = 0; i < rcc->num_entries; i++) {
394	399	const RateControlEntry *rce = &rcc->entry[i];
395	400
396		− qscale[i] = get_qscale(s, &rcc->entry[i], rate_factor, i);
	401	+ qscale[i] = get_qscale(m, &rcc->entry[i], rate_factor, i);
397	402	rcc->last_qscale_for[rce->pict_type] = qscale[i];
398	403	}
399	404	av_assert0(filter_size % 2 == 1);
@@ -402,13 +407,13 @@ static int init_pass2(MpegEncContext *s) · 2 unmodified lines
402	407	for (i = FFMAX(0, rcc->num_entries - 300); i < rcc->num_entries; i++) {
403	408	const RateControlEntry *rce = &rcc->entry[i];
404	409
405		− qscale[i] = get_diff_limited_q(s, rce, qscale[i]);
	410	+ qscale[i] = get_diff_limited_q(m, rce, qscale[i]);
406	411	}
407	412
408	413	for (i = rcc->num_entries - 1; i >= 0; i--) {
409	414	const RateControlEntry *rce = &rcc->entry[i];
410	415
411		− qscale[i] = get_diff_limited_q(s, rce, qscale[i]);
	416	+ qscale[i] = get_diff_limited_q(m, rce, qscale[i]);
412	417	}
413	418
414	419	/* smooth curve */
@@ -438,10 +443,10 @@ static int init_pass2(MpegEncContext *s) · 23 unmodified lines
438	443	RateControlEntry *rce = &rcc->entry[i];
439	444	double bits;
440	445
441		− rce->new_qscale = modify_qscale(s, rce, blurred_qscale[i], i);
	446	+ rce->new_qscale = modify_qscale(m, rce, blurred_qscale[i], i);
442	447
443	448	bits = qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;
444		− bits += 8 * ff_vbv_update(s, bits);
	449	+ bits += 8 * ff_vbv_update(m, bits);
445	450
446	451	rce->expected_bits = expected_bits;
447	452	expected_bits += bits;
@@ -494,9 +499,10 @@ static int init_pass2(MpegEncContext *s) · 46 unmodified lines
494	499	return 0;
495	500	}
496	501
497		−av_cold int ff_rate_control_init(MpegEncContext *s)
	502	+av_cold int ff_rate_control_init(MPVMainEncContext *const m)
498	503	{
499		− RateControlContext *rcc = &s->rc_context;
	504	+ MpegEncContext *const s = &m->s;
	505	+ RateControlContext *rcc = &m->rc_context;
500	506	int i, res;
501	507	static const char * const const_names[] = {
502	508	"PI",
@@ -632,7 +638,7 @@ av_cold int ff_rate_control_init(MpegEncContext *s) · 129 unmodified lines
632	638	p = next;
633	639	}
634	640
635		− res = init_pass2(s);
	641	+ res = init_pass2(m);
636	642	if (res < 0)
637	643	return res;
638	644	}
@@ -686,7 +692,7 @@ av_cold int ff_rate_control_init(MpegEncContext *s) · 47 unmodified lines
686	692	rcc->mv_bits_sum[rce.pict_type] += rce.mv_bits;
687	693	rcc->frame_count[rce.pict_type]++;
688	694
689		− get_qscale(s, &rce, rcc->pass1_wanted_bits / rcc->pass1_rc_eq_output_sum, i);
	695	+ get_qscale(m, &rce, rcc->pass1_wanted_bits / rcc->pass1_rc_eq_output_sum, i);
690	696
691	697	// FIXME misbehaves a little for variable fps
692	698	rcc->pass1_wanted_bits += s->bit_rate / get_fps(s->avctx);
@@ -717,9 +723,10 @@ av_cold void ff_rate_control_uninit(RateControlContext *rcc) · 24 unmodified lines
717	723	av_freep(&rcc->cplx_tab);
718	724	}
719	725
720		−int ff_vbv_update(MpegEncContext *s, int frame_size)
	726	+int ff_vbv_update(MPVMainEncContext *m, int frame_size)
721	727	{
722		− RateControlContext *rcc = &s->rc_context;
	728	+ MpegEncContext *const s = &m->s;
	729	+ RateControlContext *const rcc = &m->rc_context;
723	730	const double fps = get_fps(s->avctx);
724	731	const int buffer_size = s->avctx->rc_buffer_size;
725	732	const double min_rate = s->avctx->rc_min_rate / fps;
@@ -893,9 +900,10 @@ static void adaptive_quantization(RateControlContext *const rcc, · 167 unmodified lines
893	900	}
894	901	}
895	902
896		−void ff_get_2pass_fcode(MpegEncContext *s)
	903	+void ff_get_2pass_fcode(MPVMainEncContext *const m)
897	904	{
898		− const RateControlContext *rcc = &s->rc_context;
	905	+ MpegEncContext *const s = &m->s;
	906	+ const RateControlContext *rcc = &m->rc_context;
899	907	const RateControlEntry *rce = &rcc->entry[s->picture_number];
900	908
901	909	s->f_code = rce->f_code;
@@ -904,8 +912,10 @@ void ff_get_2pass_fcode(MpegEncContext *s) · 2 unmodified lines
904	912
905	913	// FIXME rd or at least approx for dquant
906	914
907		−float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
	915	+float ff_rate_estimate_qscale(MPVMainEncContext *const m, int dry_run)
908	916	{
	917	+ MpegEncContext *const s = &m->s;
	918	+ RateControlContext *rcc = &m->rc_context;
909	919	float q;
910	920	int qmin, qmax;
911	921	float br_compensation;
@@ -914,7 +924,6 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run) · 2 unmodified lines
914	924	double fps;
915	925	int picture_number = s->picture_number;
916	926	int64_t wanted_bits;
917		− RateControlContext *rcc = &s->rc_context;
918	927	AVCodecContext *a = s->avctx;
919	928	RateControlEntry local_rce, *rce;
920	929	double bits;
@@ -931,11 +940,11 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run) · 10 unmodified lines
931	940	const int64_t last_var =
932	941	s->last_pict_type == AV_PICTURE_TYPE_I ? rcc->last_mb_var_sum
933	942	: rcc->last_mc_mb_var_sum;
934		− av_assert1(s->frame_bits >= s->stuffing_bits);
	943	+ av_assert1(m->frame_bits >= m->stuffing_bits);
935	944	update_predictor(&rcc->pred[s->last_pict_type],
936	945	rcc->last_qscale,
937	946	sqrt(last_var),
938		− s->frame_bits - s->stuffing_bits);
	947	+ m->frame_bits - m->stuffing_bits);
939	948	}
940	949
941	950	if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
@@ -970,7 +979,7 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run) · 28 unmodified lines
970	979	wanted_bits = (int64_t)wanted_bits_double;
971	980	}
972	981
973		− diff = s->total_bits - wanted_bits;
	982	+ diff = m->total_bits - wanted_bits;
974	983	br_compensation = (a->bit_rate_tolerance - diff) / a->bit_rate_tolerance;
975	984	if (br_compensation <= 0.0)
976	985	br_compensation = 0.001;
@@ -984,7 +993,7 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run) · 7 unmodified lines
984	993
985	994	q = rce->new_qscale / br_compensation;
986	995	ff_dlog(s->avctx, "%f %f %f last:%d var:%"PRId64" type:%d//\n", q, rce->new_qscale,
987		− br_compensation, s->frame_bits, var, pict_type);
	996	+ br_compensation, m->frame_bits, var, pict_type);
988	997	} else {
989	998	rce->pict_type =
990	999	rce->new_pict_type = pict_type;
@@ -1015,12 +1024,12 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run) · 24 unmodified lines
1015	1024	rate_factor = rcc->pass1_wanted_bits /
1016	1025	rcc->pass1_rc_eq_output_sum * br_compensation;
1017	1026
1018		− q = get_qscale(s, rce, rate_factor, picture_number);
	1027	+ q = get_qscale(m, rce, rate_factor, picture_number);
1019	1028	if (q < 0)
1020	1029	return -1;
1021	1030
1022	1031	av_assert0(q > 0.0);
1023		− q = get_diff_limited_q(s, rce, q);
	1032	+ q = get_diff_limited_q(m, rce, q);
1024	1033	av_assert0(q > 0.0);
1025	1034
1026	1035	// FIXME type dependent blur like in 2-pass
@@ -1034,7 +1043,7 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run) · 7 unmodified lines
1034	1043	}
1035	1044	av_assert0(q > 0.0);
1036	1045
1037		− q = modify_qscale(s, rce, q, picture_number);
	1046	+ q = modify_qscale(m, rce, q, picture_number);
1038	1047
1039	1048	rcc->pass1_wanted_bits += s->bit_rate / fps;
1040	1049
@@ -1047,8 +1056,8 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run) · 6 unmodified lines
1047	1056	"size:%d var:%"PRId64"/%"PRId64" br:%"PRId64" fps:%d\n",
1048	1057	av_get_picture_type_char(pict_type),
1049	1058	qmin, q, qmax, picture_number,
1050		− wanted_bits / 1000, s->total_bits / 1000,
1051		− br_compensation, short_term_q, s->frame_bits,
	1059	+ wanted_bits / 1000, m->total_bits / 1000,
	1060	+ br_compensation, short_term_q, m->frame_bits,
1052	1061	s->mb_var_sum, s->mc_mb_var_sum,
1053	1062	s->bit_rate / 1000, (int)fps);
1054	1063	}

libavcodec/ratecontrol.h+6−6

@@ -93,14 +93,14 @@ typedef struct RateControlContext{ · 92 unmodified lines
93	93	float cplx_tab, bits_tab;
94	94	}RateControlContext;
95	95
96		−struct MpegEncContext;
	96	+typedef struct MPVMainEncContext MPVMainEncContext;
97	97
98	98	/* rate control */
99		−int ff_rate_control_init(struct MpegEncContext *s);
100		−float ff_rate_estimate_qscale(struct MpegEncContext *s, int dry_run);
101		−void ff_write_pass1_stats(struct MpegEncContext *s);
102		−int ff_vbv_update(struct MpegEncContext *s, int frame_size);
103		−void ff_get_2pass_fcode(struct MpegEncContext *s);
	99	+int ff_rate_control_init(MPVMainEncContext *m);
	100	+float ff_rate_estimate_qscale(MPVMainEncContext *m, int dry_run);
	101	+void ff_write_pass1_stats(MPVMainEncContext *m);
	102	+int ff_vbv_update(MPVMainEncContext *m, int frame_size);
	103	+void ff_get_2pass_fcode(MPVMainEncContext *m);
104	104	void ff_rate_control_uninit(RateControlContext *rcc);
105	105
106	106	#endif /* AVCODEC_RATECONTROL_H */

libavcodec/snowenc.c+43−39

@@ -61,7 +61,7 @@ typedef struct SnowEncContext { · 60 unmodified lines
61	61	int scenechange_threshold;
62	62
63	63	MECmpContext mecc;
64		− MpegEncContext m; // needed for motion estimation, should not be used for anything else, the idea is to eventually make the motion estimation independent of MpegEncContext, so this will be removed then (FIXME/XXX)
	64	+ MPVMainEncContext m; // needed for motion estimation, should not be used for anything else, the idea is to eventually make the motion estimation independent of MpegEncContext, so this will be removed then (FIXME/XXX)
65	65	MPVPicture cur_pic, last_pic;
66	66	#define ME_CACHE_SIZE 1024
67	67	unsigned me_cache[ME_CACHE_SIZE];
@@ -160,7 +160,7 @@ static av_cold int encode_init(AVCodecContext *avctx) · 92 unmodified lines
160	160	{
161	161	SnowEncContext *const enc = avctx->priv_data;
162	162	SnowContext *const s = &enc->com;
163		− MpegEncContext *const mpv = &enc->m;
	163	+ MpegEncContext *const mpv = &enc->m.s;
164	164	int plane_index, ret;
165	165	int i;
166	166
@@ -217,7 +217,7 @@ static av_cold int encode_init(AVCodecContext *avctx) · 50 unmodified lines
217	217	mcf(12,12)
218	218
219	219	ff_me_cmp_init(&enc->mecc, avctx);
220		− ret = ff_me_init(&enc->m.me, avctx, &enc->mecc, 0);
	220	+ ret = ff_me_init(&mpv->me, avctx, &enc->mecc, 0);
221	221	if (ret < 0)
222	222	return ret;
223	223	ff_mpegvideoencdsp_init(&enc->mpvencdsp, avctx);
@@ -252,7 +252,7 @@ static av_cold int encode_init(AVCodecContext *avctx) · 28 unmodified lines
252	252	return AVERROR(ENOMEM);
253	253	}
254	254	if((avctx->flags&AV_CODEC_FLAG_PASS2) \|\| !(avctx->flags&AV_CODEC_FLAG_QSCALE)){
255		− ret = ff_rate_control_init(mpv);
	255	+ ret = ff_rate_control_init(&enc->m);
256	256	if(ret < 0)
257	257	return ret;
258	258	}
@@ -369,7 +369,7 @@ static inline int get_penalty_factor(int lambda, int lambda2, int type){ · 110 unmodified lines
369	369	static int encode_q_branch(SnowEncContext *enc, int level, int x, int y)
370	370	{
371	371	SnowContext *const s = &enc->com;
372		− MotionEstContext *const c = &enc->m.me;
	372	+ MotionEstContext *const c = &enc->m.s.me;
373	373	uint8_t p_buffer[1024];
374	374	uint8_t i_buffer[1024];
375	375	uint8_t p_state[sizeof(s->block_state)];
@@ -435,9 +435,9 @@ static int encode_q_branch(SnowEncContext *enc, int level, int x, int y) · 59 unmodified lines
435	435	last_mv[2][0]= bottom->mx;
436	436	last_mv[2][1]= bottom->my;
437	437
438		− enc->m.mb_stride = 2;
439		− enc->m.mb_x =
440		− enc->m.mb_y = 0;
	438	+ enc->m.s.mb_stride = 2;
	439	+ enc->m.s.mb_x =
	440	+ enc->m.s.mb_y = 0;
441	441	c->skip= 0;
442	442
443	443	av_assert1(c-> stride == stride);
@@ -446,7 +446,7 @@ static int encode_q_branch(SnowEncContext *enc, int level, int x, int y) · 2 unmodified lines
446	446	c->penalty_factor = get_penalty_factor(enc->lambda, enc->lambda2, c->avctx->me_cmp);
447	447	c->sub_penalty_factor= get_penalty_factor(enc->lambda, enc->lambda2, c->avctx->me_sub_cmp);
448	448	c->mb_penalty_factor = get_penalty_factor(enc->lambda, enc->lambda2, c->avctx->mb_cmp);
449		− c->current_mv_penalty = c->mv_penalty[enc->m.f_code=1] + MAX_DMV;
	449	+ c->current_mv_penalty = c->mv_penalty[enc->m.s.f_code=1] + MAX_DMV;
450	450
451	451	c->xmin = - x*block_w - 16+3;
452	452	c->ymin = - y*block_w - 16+3;
@@ -482,7 +482,7 @@ static int encode_q_branch(SnowEncContext *enc, int level, int x, int y) · 29 unmodified lines
482	482	for(ref=0; ref<s->ref_frames; ref++){
483	483	init_ref(c, current_data, s->last_picture[ref]->data, NULL, block_wx, block_wy, 0);
484	484
485		− ref_score= ff_epzs_motion_search(&enc->m, &ref_mx, &ref_my, P, 0, /ref_index/ 0, last_mv,
	485	+ ref_score = ff_epzs_motion_search(&enc->m.s, &ref_mx, &ref_my, P, 0, /ref_index/ 0, last_mv,
486	486	(1<<16)>>shift, level-LOG2_MB_SIZE+4, block_w);
487	487
488	488	av_assert2(ref_mx >= c->xmin);
@@ -490,8 +490,10 @@ static int encode_q_branch(SnowEncContext *enc, int level, int x, int y) · 1 unmodified line
490	490	av_assert2(ref_my >= c->ymin);
491	491	av_assert2(ref_my <= c->ymax);
492	492
493		− ref_score= c->sub_motion_search(&enc->m, &ref_mx, &ref_my, ref_score, 0, 0, level-LOG2_MB_SIZE+4, block_w);
494		− ref_score= ff_get_mb_score(&enc->m, ref_mx, ref_my, 0, 0, level-LOG2_MB_SIZE+4, block_w, 0);
	493	+ ref_score = c->sub_motion_search(&enc->m.s, &ref_mx, &ref_my, ref_score,
	494	+ 0, 0, level-LOG2_MB_SIZE+4, block_w);
	495	+ ref_score = ff_get_mb_score(&enc->m.s, ref_mx, ref_my, 0, 0,
	496	+ level-LOG2_MB_SIZE+4, block_w, 0);
495	497	ref_score+= 2av_log2(2ref)*c->penalty_factor;
496	498	if(s->ref_mvs[ref]){
497	499	s->ref_mvs[ref][index][0]= ref_mx;
@@ -567,7 +569,7 @@ static int encode_q_branch(SnowEncContext *enc, int level, int x, int y) · 69 unmodified lines
567	569	if (vard <= 64 \|\| vard < varc)
568	570	c->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc);
569	571	else
570		− c->scene_change_score += enc->m.qscale;
	572	+ c->scene_change_score += enc->m.s.qscale;
571	573	}
572	574
573	575	if(level!=s->block_max_depth){
@@ -670,7 +672,7 @@ static int get_dc(SnowEncContext *enc, int mb_x, int mb_y, int plane_index) · 96 unmodified lines
670	672	const int obmc_stride= plane_index ? (2block_size)>>s->chroma_h_shift : 2block_size;
671	673	const int ref_stride= s->current_picture->linesize[plane_index];
672	674	const uint8_t *src = s->input_picture->data[plane_index];
673		− IDWTELEM dst= (IDWTELEM)enc->m.sc.obmc_scratchpad + plane_indexblock_sizeblock_size*4; //FIXME change to unsigned
	675	+ IDWTELEM dst= (IDWTELEM)enc->m.s.sc.obmc_scratchpad + plane_indexblock_sizeblock_size*4; //FIXME change to unsigned
674	676	const int b_stride = s->b_width << s->block_max_depth;
675	677	const int w= p->width;
676	678	const int h= p->height;
@@ -768,7 +770,7 @@ static int get_block_rd(SnowEncContext *enc, int mb_x, int mb_y, · 91 unmodified lines
768	770	const int ref_stride= s->current_picture->linesize[plane_index];
769	771	uint8_t *dst= s->current_picture->data[plane_index];
770	772	const uint8_t *src = s->input_picture->data[plane_index];
771		− IDWTELEM pred= (IDWTELEM)enc->m.sc.obmc_scratchpad + plane_indexblock_sizeblock_size*4;
	773	+ IDWTELEM pred= (IDWTELEM)enc->m.s.sc.obmc_scratchpad + plane_indexblock_sizeblock_size*4;
772	774	uint8_t *cur = s->scratchbuf;
773	775	uint8_t *tmp = s->emu_edge_buffer;
774	776	const int b_stride = s->b_width << s->block_max_depth;
@@ -831,19 +833,19 @@ static int get_block_rd(SnowEncContext *enc, int mb_x, int mb_y, · 56 unmodified lines
831	833	* to improve the score of the whole frame, thus iterative motion
832	834	* estimation does not always converge. */
833	835	if(s->avctx->me_cmp == FF_CMP_W97)
834		− distortion = ff_w97_32_c(&enc->m, src + sx + syref_stride, dst + sx + syref_stride, ref_stride, 32);
	836	+ distortion = ff_w97_32_c(&enc->m.s, src + sx + syref_stride, dst + sx + syref_stride, ref_stride, 32);
835	837	else if(s->avctx->me_cmp == FF_CMP_W53)
836		− distortion = ff_w53_32_c(&enc->m, src + sx + syref_stride, dst + sx + syref_stride, ref_stride, 32);
	838	+ distortion = ff_w53_32_c(&enc->m.s, src + sx + syref_stride, dst + sx + syref_stride, ref_stride, 32);
837	839	else{
838	840	distortion = 0;
839	841	for(i=0; i<4; i++){
840	842	int off = sx+16(i&1) + (sy+16(i>>1))*ref_stride;
841		− distortion += enc->m.me.me_cmp[0](&enc->m, src + off, dst + off, ref_stride, 16);
	843	+ distortion += enc->m.s.me.me_cmp[0](&enc->m.s, src + off, dst + off, ref_stride, 16);
842	844	}
843	845	}
844	846	}else{
845	847	av_assert2(block_w==8);
846		− distortion = enc->m.me.me_cmp[0](&enc->m, src + sx + syref_stride, dst + sx + syref_stride, ref_stride, block_w*2);
	848	+ distortion = enc->m.s.me.me_cmp[0](&enc->m.s, src + sx + syref_stride, dst + sx + syref_stride, ref_stride, block_w*2);
847	849	}
848	850
849	851	if(plane_index==0){
@@ -909,7 +911,7 @@ static int get_4block_rd(SnowEncContext *enc, int mb_x, int mb_y, int plane_inde · 59 unmodified lines
909	911	}
910	912
911	913	av_assert1(block_w== 8 \|\| block_w==16);
912		− distortion += enc->m.me.me_cmp[block_w==8](&enc->m, src + x + yref_stride, dst + x + yref_stride, ref_stride, block_h);
	914	+ distortion += enc->m.s.me.me_cmp[block_w==8](&enc->m.s, src + x + yref_stride, dst + x + yref_stride, ref_stride, block_h);
913	915	}
914	916
915	917	if(plane_index==0){
@@ -1706,11 +1708,11 @@ static int ratecontrol_1pass(SnowEncContext enc, AVFrame pict) · 790 unmodified lines
1706	1708	coef_sum = (uint64_t)coef_sum * coef_sum >> 16;
1707	1709
1708	1710	if(pict->pict_type == AV_PICTURE_TYPE_I){
1709		− enc->m.mb_var_sum = coef_sum;
1710		− enc->m.mc_mb_var_sum = 0;
	1711	+ enc->m.s.mb_var_sum = coef_sum;
	1712	+ enc->m.s.mc_mb_var_sum = 0;
1711	1713	}else{
1712		− enc->m.mc_mb_var_sum = coef_sum;
1713		− enc->m.mb_var_sum = 0;
	1714	+ enc->m.s.mc_mb_var_sum = coef_sum;
	1715	+ enc->m.s.mb_var_sum = 0;
1714	1716	}
1715	1717
1716	1718	pict->quality= ff_rate_estimate_qscale(&enc->m, 1);
@@ -1757,7 +1759,7 @@ static int encode_frame(AVCodecContext avctx, AVPacket pkt, · 40 unmodified lines
1757	1759	{
1758	1760	SnowEncContext *const enc = avctx->priv_data;
1759	1761	SnowContext *const s = &enc->com;
1760		− MpegEncContext *const mpv = &enc->m;
	1762	+ MpegEncContext *const mpv = &enc->m.s;
1761	1763	RangeCoder * const c= &s->c;
1762	1764	AVCodecInternal *avci = avctx->internal;
1763	1765	AVFrame *pic;
@@ -1793,10 +1795,10 @@ static int encode_frame(AVCodecContext avctx, AVPacket pkt, · 29 unmodified lines
1793	1795
1794	1796	mpv->picture_number = avctx->frame_num;
1795	1797	if(avctx->flags&AV_CODEC_FLAG_PASS2){
1796		− mpv->pict_type = pic->pict_type = mpv->rc_context.entry[avctx->frame_num].new_pict_type;
	1798	+ mpv->pict_type = pic->pict_type = enc->m.rc_context.entry[avctx->frame_num].new_pict_type;
1797	1799	s->keyframe = pic->pict_type == AV_PICTURE_TYPE_I;
1798	1800	if(!(avctx->flags&AV_CODEC_FLAG_QSCALE)) {
1799		− pic->quality = ff_rate_estimate_qscale(mpv, 0);
	1801	+ pic->quality = ff_rate_estimate_qscale(&enc->m, 0);
1800	1802	if (pic->quality < 0)
1801	1803	return -1;
1802	1804	}
@@ -1877,7 +1879,7 @@ static int encode_frame(AVCodecContext avctx, AVPacket pkt, · 74 unmodified lines
1877	1879
1878	1880	mpv->qdsp = enc->qdsp; //move
1879	1881	mpv->hdsp = s->hdsp;
1880		− ff_me_init_pic(&enc->m);
	1882	+ ff_me_init_pic(mpv);
1881	1883	s->hdsp = mpv->hdsp;
1882	1884	}
1883	1885
@@ -2043,17 +2045,19 @@ redo_frame: · 159 unmodified lines
2043	2045
2044	2046	s->current_picture->pict_type = pic->pict_type;
2045	2047	s->current_picture->quality = pic->quality;
2046		− mpv->frame_bits = 8 * (s->c.bytestream - s->c.bytestream_start);
2047		− mpv->p_tex_bits = mpv->frame_bits - mpv->misc_bits - mpv->mv_bits;
2048		− mpv->total_bits += 8*(s->c.bytestream - s->c.bytestream_start);
	2048	+ enc->m.frame_bits = 8 * (s->c.bytestream - s->c.bytestream_start);
	2049	+ mpv->p_tex_bits = enc->m.frame_bits - mpv->misc_bits - mpv->mv_bits;
	2050	+ enc->m.total_bits += 8*(s->c.bytestream - s->c.bytestream_start);
2049	2051	enc->cur_pic.display_picture_number =
2050	2052	enc->cur_pic.coded_picture_number = avctx->frame_num;
2051	2053	enc->cur_pic.f->quality = pic->quality;
2052		− if (enc->pass1_rc)
2053		− if (ff_rate_estimate_qscale(mpv, 0) < 0)
2054		− return -1;
	2054	+ if (enc->pass1_rc) {
	2055	+ ret = ff_rate_estimate_qscale(&enc->m, 0);
	2056	+ if (ret < 0)
	2057	+ return ret;
	2058	+ }
2055	2059	if(avctx->flags&AV_CODEC_FLAG_PASS1)
2056		− ff_write_pass1_stats(mpv);
	2060	+ ff_write_pass1_stats(&enc->m);
2057	2061	mpv->last_pict_type = mpv->pict_type;
2058	2062
2059	2063	emms_c();
@@ -2088,10 +2092,10 @@ static av_cold int encode_end(AVCodecContext *avctx) · 28 unmodified lines
2088	2092	av_freep(&s->ref_scores[i]);
2089	2093	}
2090	2094
2091		− enc->m.me.temp = NULL;
2092		− av_freep(&enc->m.me.scratchpad);
2093		− av_freep(&enc->m.me.map);
2094		− av_freep(&enc->m.sc.obmc_scratchpad);
	2095	+ enc->m.s.me.temp = NULL;
	2096	+ av_freep(&enc->m.s.me.scratchpad);
	2097	+ av_freep(&enc->m.s.me.map);
	2098	+ av_freep(&enc->m.s.sc.obmc_scratchpad);
2095	2099
2096	2100	av_freep(&avctx->stats_out);
2097	2101

avcodec/mpegvideoenc: Move ratecontrol to MPVMainEncContext

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code