avcodec/mpegpicture: Make MPVPicture refcounted

Up until now, an initialized MpegEncContext had an array of MPVPictures (way more than were ever needed) and the MPVPicture* contained in the MPVWorkPictures as well as the input_picture and reordered_input_picture arrays (for the encoder) pointed into this array. Several of the pointers could point to the same slot and because there was no reference counting involved, one had to check for aliasing before unreferencing. Furthermore, given that these pointers were not ownership pointers the pointers were often simply reset without unreferencing the slot (happened e.g. for the RV30 and RV40 decoders) or there were moved without resetting the src pointer (happened for the encoders where the entries in the input_picture and reordered_input_picture arrays were not reset). Instead actually releasing these pictures was performed by looping over the whole array and checking which one of the entries needed to be kept. Given that the array had way too many slots (36), this meant that more than 30 MPVPictures have been unnecessarily unreferenced in every ff_mpv_frame_start(); something similar happened for the encoder. This commit changes this by making the MPVPictures refcounted via the RefStruct API. The MPVPictures itself are part of a pool so that this does not entail constant allocations; instead, the amount of allocations actually goes down, because the earlier code used such a large array of MPVPictures (36 entries) and allocated an AVFrame for every one of these on every ff_mpv_common_init(). In fact, the pool is only freed when closing the codec, so that reinitializations don't lead to new allocations (this avoids having to sync the pool in update_thread_context). Making MPVPictures refcounted also has another key benefit: It makes it possible to directly share them across threads (when using frame-threaded decoding), eliminating ugly code with underlying av_frame_ref()'s; sharing these pictures can't fail any more. The pool is allocated in ff_mpv_decode_init() for decoders, which therefore can fail now. This and the fact that the pool is not unreferenced in ff_mpv_common_end() also necessitated to mark several mpegvideo-decoders with the FF_CODEC_CAP_INIT_CLEANUP flag. *: This also means that there is no good reason any more for ff_mpv_common_frame_size_change() to exist.

Andreas Rheinhardt committed 3 years ago

Commit 9ce56f91 parent 99d269319 files · +175 −247Browse files

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

Unified · Split

19 files

libavcodec/flvdec.c +2 −1
libavcodec/h261dec.c +4 −1
libavcodec/h263dec.c +9 −5
libavcodec/intelh263dec.c +2 −1
libavcodec/mjpegenc.c +1 −1
libavcodec/mpeg12dec.c +7 −4
libavcodec/mpeg4videodec.c +2 −1
libavcodec/mpegpicture.c +49 −108
libavcodec/mpegpicture.h +6 −8
libavcodec/mpegvideo.c +4 −17
libavcodec/mpegvideo.h +1 −1
libavcodec/mpegvideo_dec.c +21 −51
libavcodec/mpegvideo_enc.c +41 −33
libavcodec/mpegvideodec.h +3 −1
libavcodec/msmpeg4dec.c +8 −4
libavcodec/rv10.c +6 −2
libavcodec/rv34.c +4 −2
libavcodec/svq1enc.c +0 −3
libavcodec/vc1dec.c +5 −3

libavcodec/flvdec.c+2−1

@@ -121,6 +121,7 @@ const FFCodec ff_flv_decoder = { · 120 unmodified lines
121	FF_CODEC_DECODE_CB(ff_h263_decode_frame),	121	FF_CODEC_DECODE_CB(ff_h263_decode_frame),
122	.close = ff_mpv_decode_close,	122	.close = ff_mpv_decode_close,
123	.p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND \| AV_CODEC_CAP_DR1,	123	.p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND \| AV_CODEC_CAP_DR1,
124	.caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,	124	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP \|
		125	FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
125	.p.max_lowres = 3,	126	.p.max_lowres = 3,
126	};	127	};

libavcodec/h261dec.c+4−1

     static AVOnce init_static_once = AV_ONCE_INIT;
     H261DecContext *const h = avctx->priv_data;
     MpegEncContext *const s = &h->s;
+    int ret;
     s->private_ctx = &h->common;
     // set defaults
-    ff_mpv_decode_init(s, avctx);
+    ret = ff_mpv_decode_init(s, avctx);
+    if (ret < 0)
+        return ret;
     s->out_format  = FMT_H261;
     s->low_delay   = 1;

libavcodec/h263dec.c+9−5

     s->out_format      = FMT_H263;
     // set defaults
-    ff_mpv_decode_init(s, avctx);
+    ret = ff_mpv_decode_init(s, avctx);
+    if (ret < 0)
+        return ret;
     s->quant_precision = 5;
     s->decode_mb       = ff_h263_decode_mb;
         if (s->low_delay == 0 && s->next_pic.ptr) {
             if ((ret = av_frame_ref(pict, s->next_pic.ptr->f)) < 0)
                 return ret;
-            s->next_pic.ptr = NULL;
+            ff_mpv_unref_picture(&s->next_pic);
             *got_frame = 1;
         } else if (s->skipped_last_frame && s->cur_pic.ptr) {
              * returned picture would be reused */
             if ((ret = ff_decode_frame_props(avctx, pict)) < 0)
                 return ret;
-            s->cur_pic.ptr = NULL;
+            ff_mpv_unref_picture(&s->cur_pic);
             *got_frame = 1;
         }
     .close          = ff_mpv_decode_close,
     .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
                       AV_CODEC_CAP_DELAY,
-    .caps_internal  = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
+    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP |
+                      FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
     .flush          = ff_mpeg_flush,
     .p.max_lowres   = 3,
     .hw_configs     = h263_hw_config_list,
     .close          = ff_mpv_decode_close,
     .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
                       AV_CODEC_CAP_DELAY,
-    .caps_internal  = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
+    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP |
+                      FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
     .flush          = ff_mpeg_flush,
     .p.max_lowres   = 3,
     .hw_configs     = h263_hw_config_list,

libavcodec/intelh263dec.c+2−1

@@ -135,5 +135,6 @@ const FFCodec ff_h263i_decoder = { · 134 unmodified lines
135	FF_CODEC_DECODE_CB(ff_h263_decode_frame),	135	FF_CODEC_DECODE_CB(ff_h263_decode_frame),
136	.close = ff_mpv_decode_close,	136	.close = ff_mpv_decode_close,
137	.p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND \| AV_CODEC_CAP_DR1,	137	.p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND \| AV_CODEC_CAP_DR1,
138	.caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,	138	.caps_internal = FF_CODEC_CAP_INIT_CLEANUP \|
		139	FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
139	};	140	};

libavcodec/mjpegenc.c+1−1

@@ -80,7 +80,7 @@ static av_cold void init_uni_ac_vlc(const uint8_t huff_size_ac[256], · 79 unmodified lines
80		80
81	static void mjpeg_encode_picture_header(MpegEncContext *s)	81	static void mjpeg_encode_picture_header(MpegEncContext *s)
82	{	82	{
83	ff_mjpeg_encode_picture_header(s->avctx, &s->pb, s->picture->f, s->mjpeg_ctx,	83	ff_mjpeg_encode_picture_header(s->avctx, &s->pb, s->cur_pic.ptr->f, s->mjpeg_ctx,
84	s->intra_scantable.permutated, 0,	84	s->intra_scantable.permutated, 0,
85	s->intra_matrix, s->chroma_intra_matrix,	85	s->intra_matrix, s->chroma_intra_matrix,
86	s->slice_context_count > 1);	86	s->slice_context_count > 1);

libavcodec/mpeg12dec.c+7−4

 {
     Mpeg1Context *s    = avctx->priv_data;
     MpegEncContext *s2 = &s->mpeg_enc_ctx;
+    int ret;
     s2->out_format = FMT_MPEG1;
     if (   avctx->codec_tag != AV_RL32("VCR2")
         && avctx->codec_tag != AV_RL32("BW10"))
         avctx->coded_width = avctx->coded_height = 0; // do not trust dimensions from input
-    ff_mpv_decode_init(s2, avctx);
+    ret = ff_mpv_decode_init(s2, avctx);
+    if (ret < 0)
+        return ret;
     ff_mpeg12_init_vlcs();
             if (ret < 0)
                 return ret;
-            s2->next_pic.ptr = NULL;
+            ff_mpv_unref_picture(&s2->next_pic);
             *got_output = 1;
         }
         }
         s->extradata_decoded = 1;
         if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE)) {
-            s2->cur_pic.ptr = NULL;
+            ff_mpv_unref_picture(&s2->cur_pic);
             return ret;
         }
     }
     ret = decode_chunks(avctx, picture, got_output, buf, buf_size);
     if (ret<0 || *got_output) {
-        s2->cur_pic.ptr = NULL;
+        ff_mpv_unref_picture(&s2->cur_pic);
         if (s->timecode_frame_start != -1 && *got_output) {
             char tcbuf[AV_TIMECODE_STR_SIZE];

libavcodec/mpeg4videodec.c+2−1

     .close                 = ff_mpv_decode_close,
     .p.capabilities        = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
                              AV_CODEC_CAP_DELAY | AV_CODEC_CAP_FRAME_THREADS,
-    .caps_internal         = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
+    .caps_internal         = FF_CODEC_CAP_INIT_CLEANUP |
+                             FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
     .flush                 = ff_mpeg_flush,
     .p.max_lowres          = 3,
     .p.profiles            = NULL_IF_CONFIG_SMALL(ff_mpeg4_video_profiles),

libavcodec/mpegpicture.c+49−108

@@ -30,8 +30,14 @@ · 29 unmodified lines
30	#include "refstruct.h"	30	#include "refstruct.h"
31	#include "threadframe.h"	31	#include "threadframe.h"
32		32
33	static void av_noinline free_picture_tables(MPVPicture *pic)	33	static void mpv_pic_reset(FFRefStructOpaque unused, void *obj)
34	{	34	{
		35	MPVPicture *pic = obj;
		36
		37	ff_thread_release_ext_buffer(&pic->tf);
		38
		39	ff_refstruct_unref(&pic->hwaccel_picture_private);
		40
35	ff_refstruct_unref(&pic->mbskip_table);	41	ff_refstruct_unref(&pic->mbskip_table);
36	ff_refstruct_unref(&pic->qscale_table_base);	42	ff_refstruct_unref(&pic->qscale_table_base);
37	ff_refstruct_unref(&pic->mb_type_base);	43	ff_refstruct_unref(&pic->mb_type_base);
@@ -39,16 +45,53 @@ static void av_noinline free_picture_tables(MPVPicture *pic) · 1 unmodified line
39	for (int i = 0; i < 2; i++) {	45	for (int i = 0; i < 2; i++) {
40	ff_refstruct_unref(&pic->motion_val_base[i]);	46	ff_refstruct_unref(&pic->motion_val_base[i]);
41	ff_refstruct_unref(&pic->ref_index[i]);	47	ff_refstruct_unref(&pic->ref_index[i]);
		48
		49	pic->motion_val[i] = NULL;
42	}	50	}
43		51
		52	pic->mb_type = NULL;
		53	pic->qscale_table = NULL;
		54
		55	pic->mb_stride =
44	pic->mb_width =	56	pic->mb_width =
45	pic->mb_height = 0;	57	pic->mb_height = 0;
		58
		59	pic->dummy = 0;
		60	pic->field_picture = 0;
		61	pic->b_frame_score = 0;
		62	pic->reference = 0;
		63	pic->shared = 0;
		64	pic->display_picture_number = 0;
		65	pic->coded_picture_number = 0;
		66	}
		67
		68	static int av_cold mpv_pic_init(FFRefStructOpaque unused, void *obj)
		69	{
		70	MPVPicture *pic = obj;
		71
		72	pic->f = av_frame_alloc();
		73	if (!pic->f)
		74	return AVERROR(ENOMEM);
		75	pic->tf.f = pic->f;
		76	return 0;
		77	}
		78
		79	static void av_cold mpv_pic_free(FFRefStructOpaque unused, void *obj)
		80	{
		81	MPVPicture *pic = obj;
		82
		83	av_frame_free(&pic->f);
		84	}
		85
		86	av_cold FFRefStructPool *ff_mpv_alloc_pic_pool(void)
		87	{
		88	return ff_refstruct_pool_alloc_ext(sizeof(MPVPicture), 0, NULL,
		89	mpv_pic_init, mpv_pic_reset, mpv_pic_free, NULL);
46	}	90	}
47		91
48	void ff_mpv_unref_picture(MPVWorkPicture *pic)	92	void ff_mpv_unref_picture(MPVWorkPicture *pic)
49	{	93	{
50	if (pic->ptr)	94	ff_refstruct_unref(&pic->ptr);
51	ff_mpeg_unref_picture(pic->ptr);
52	memset(pic, 0, sizeof(*pic));	95	memset(pic, 0, sizeof(*pic));
53	}	96	}
54		97
@@ -71,16 +114,18 @@ static void set_workpic_from_pic(MPVWorkPicture wpic, const MPVPicture pic) · 16 unmodified lines
71		114
72	void ff_mpv_replace_picture(MPVWorkPicture dst, const MPVWorkPicture src)	115	void ff_mpv_replace_picture(MPVWorkPicture dst, const MPVWorkPicture src)
73	{	116	{
		117	av_assert1(dst != src);
		118	ff_refstruct_replace(&dst->ptr, src->ptr);
74	memcpy(dst, src, sizeof(*dst));	119	memcpy(dst, src, sizeof(*dst));
75	}	120	}
76		121
77	void ff_mpv_workpic_from_pic(MPVWorkPicture wpic, MPVPicture pic)	122	void ff_mpv_workpic_from_pic(MPVWorkPicture wpic, MPVPicture pic)
78	{	123	{
		124	ff_refstruct_replace(&wpic->ptr, pic);
79	if (!pic) {	125	if (!pic) {
80	memset(wpic, 0, sizeof(*wpic));	126	memset(wpic, 0, sizeof(*wpic));
81	return;	127	return;
82	}	128	}
83	wpic->ptr = pic;
84	set_workpic_from_pic(wpic, pic);	129	set_workpic_from_pic(wpic, pic);
85	}	130	}
86		131
@@ -212,107 +257,3 @@ fail: · 125 unmodified lines
212	av_log(avctx, AV_LOG_ERROR, "Error allocating picture accessories.\n");	257	av_log(avctx, AV_LOG_ERROR, "Error allocating picture accessories.\n");
213	return ret;	258	return ret;
214	}	259	}
215
216	/**
217	* Deallocate a picture; frees the picture tables in case they
218	* need to be reallocated anyway.
219	*/
220	void ff_mpeg_unref_picture(MPVPicture *pic)
221	{
222	pic->tf.f = pic->f;
223	ff_thread_release_ext_buffer(&pic->tf);
224
225	ff_refstruct_unref(&pic->hwaccel_picture_private);
226
227	free_picture_tables(pic);
228
229	pic->dummy = 0;
230
231	pic->field_picture = 0;
232	pic->b_frame_score = 0;
233	pic->reference = 0;
234	pic->shared = 0;
235	pic->display_picture_number = 0;
236	pic->coded_picture_number = 0;
237	}
238
239	static void update_picture_tables(MPVPicture dst, const MPVPicture src)
240	{
241	ff_refstruct_replace(&dst->mbskip_table, src->mbskip_table);
242	ff_refstruct_replace(&dst->qscale_table_base, src->qscale_table_base);
243	ff_refstruct_replace(&dst->mb_type_base, src->mb_type_base);
244	for (int i = 0; i < 2; i++) {
245	ff_refstruct_replace(&dst->motion_val_base[i], src->motion_val_base[i]);
246	ff_refstruct_replace(&dst->ref_index[i], src->ref_index[i]);
247	}
248
249	dst->qscale_table = src->qscale_table;
250	dst->mb_type = src->mb_type;
251	for (int i = 0; i < 2; i++)
252	dst->motion_val[i] = src->motion_val[i];
253
254	dst->mb_width = src->mb_width;
255	dst->mb_height = src->mb_height;
256	dst->mb_stride = src->mb_stride;
257	}
258
259	int ff_mpeg_ref_picture(MPVPicture dst, MPVPicture src)
260	{
261	int ret;
262
263	av_assert0(!dst->f->buf[0]);
264	av_assert0(src->f->buf[0]);
265
266	src->tf.f = src->f;
267	dst->tf.f = dst->f;
268	ret = ff_thread_ref_frame(&dst->tf, &src->tf);
269	if (ret < 0)
270	goto fail;
271
272	update_picture_tables(dst, src);
273
274	ff_refstruct_replace(&dst->hwaccel_picture_private,
275	src->hwaccel_picture_private);
276
277	dst->dummy = src->dummy;
278	dst->field_picture = src->field_picture;
279	dst->b_frame_score = src->b_frame_score;
280	dst->reference = src->reference;
281	dst->shared = src->shared;
282	dst->display_picture_number = src->display_picture_number;
283	dst->coded_picture_number = src->coded_picture_number;
284
285	return 0;
286	fail:
287	ff_mpeg_unref_picture(dst);
288	return ret;
289	}
290
291	int ff_find_unused_picture(AVCodecContext avctx, MPVPicture picture, int shared)
292	{
293	for (int i = 0; i < MAX_PICTURE_COUNT; i++)
294	if (!picture[i].f->buf[0])
295	return i;
296
297	av_log(avctx, AV_LOG_FATAL,
298	"Internal error, picture buffer overflow\n");
299	/* We could return -1, but the codec would crash trying to draw into a
300	* non-existing frame anyway. This is safer than waiting for a random crash.
301	* Also the return of this is never useful, an encoder must only allocate
302	* as much as allowed in the specification. This has no relationship to how
303	* much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
304	* enough for such valid streams).
305	* Plus, a decoder has to check stream validity and remove frames if too
306	* many reference frames are around. Waiting for "OOM" is not correct at
307	* all. Similarly, missing reference frames have to be replaced by
308	* interpolated/MC frames, anything else is a bug in the codec ...
309	*/
310	abort();
311	return -1;
312	}
313
314	void av_cold ff_mpv_picture_free(MPVPicture *pic)
315	{
316	ff_mpeg_unref_picture(pic);
317	av_frame_free(&pic->f);
318	}

libavcodec/mpegpicture.h+6−8

 #include "threadframe.h"
 #define MPV_MAX_PLANES 3
-#define MAX_PICTURE_COUNT 36
 #define EDGE_WIDTH 16
 typedef struct ScratchpadContext {
     uint8_t  *data[MPV_MAX_PLANES];
     ptrdiff_t linesize[MPV_MAX_PLANES];
-    MPVPicture *ptr;
+    MPVPicture *ptr;            ///< RefStruct reference
     int8_t *qscale_table;
     int reference;
 } MPVWorkPicture;
+/**
+ * Allocate a pool of MPVPictures.
+ */
+struct FFRefStructPool *ff_mpv_alloc_pic_pool(void);
 /**
  * Allocate an MPVPicture's accessories (but not the AVFrame's buffer itself)
  * and set the MPVWorkPicture's fields.
 int ff_mpeg_framesize_alloc(AVCodecContext *avctx, MotionEstContext *me,
                             ScratchpadContext *sc, int linesize);
-int ff_mpeg_ref_picture(MPVPicture *dst, MPVPicture *src);
 void ff_mpv_unref_picture(MPVWorkPicture *pic);
 void ff_mpv_workpic_from_pic(MPVWorkPicture *wpic, MPVPicture *pic);
 void ff_mpv_replace_picture(MPVWorkPicture *dst, const MPVWorkPicture *src);
-void ff_mpeg_unref_picture(MPVPicture *picture);
-void ff_mpv_picture_free(MPVPicture *pic);
-int ff_find_unused_picture(AVCodecContext *avctx, MPVPicture *picture, int shared);
 #endif /* AVCODEC_MPEGPICTURE_H */

libavcodec/mpegvideo.c+4−17

     s->bitstream_buffer = NULL;
     s->allocated_bitstream_buffer_size = 0;
-    s->picture          = NULL;
     s->p_field_mv_table_base = NULL;
     for (int i = 0; i < 2; i++)
         for (int j = 0; j < 2; j++)
  */
 av_cold int ff_mpv_common_init(MpegEncContext *s)
 {
-    int i, ret;
     int nb_slices = (HAVE_THREADS &&
                      s->avctx->active_thread_type & FF_THREAD_SLICE) ?
                     s->avctx->thread_count : 1;
+    int ret;
     clear_context(s);
     if (ret)
         return ret;
-    if (!FF_ALLOCZ_TYPED_ARRAY(s->picture, MAX_PICTURE_COUNT))
-        return AVERROR(ENOMEM);
-    for (i = 0; i < MAX_PICTURE_COUNT; i++) {
-        s->picture[i].f = av_frame_alloc();
-        if (!s->picture[i].f)
-            goto fail_nomem;
-    }
     if ((ret = ff_mpv_init_context_frame(s)))
         goto fail;
 //     }
     return 0;
- fail_nomem:
-    ret = AVERROR(ENOMEM);
  fail:
     ff_mpv_common_end(s);
     return ret;
     av_freep(&s->bitstream_buffer);
     s->allocated_bitstream_buffer_size = 0;
-    if (s->picture) {
+    ff_mpv_unref_picture(&s->last_pic);
-        for (int i = 0; i < MAX_PICTURE_COUNT; i++)
+    ff_mpv_unref_picture(&s->cur_pic);
-            ff_mpv_picture_free(&s->picture[i]);
+    ff_mpv_unref_picture(&s->next_pic);
-    }
-    av_freep(&s->picture);
     s->context_initialized      = 0;
     s->context_reinit           = 0;

libavcodec/mpegvideo.h+1−1

@@ -128,7 +128,7 @@ typedef struct MpegEncContext { · 127 unmodified lines
128	int mb_num; ///< number of MBs of a picture	128	int mb_num; ///< number of MBs of a picture
129	ptrdiff_t linesize; ///< line size, in bytes, may be different from width	129	ptrdiff_t linesize; ///< line size, in bytes, may be different from width
130	ptrdiff_t uvlinesize; ///< line size, for chroma in bytes, may be different from width	130	ptrdiff_t uvlinesize; ///< line size, for chroma in bytes, may be different from width
131	MPVPicture *picture; ///< main picture buffer	131	struct FFRefStructPool *picture_pool; ///< Pool for MPVPictures
132	MPVPicture **input_picture;///< next pictures on display order for encoding	132	MPVPicture **input_picture;///< next pictures on display order for encoding
133	MPVPicture **reordered_input_picture; ///< pointer to the next pictures in coded order for encoding	133	MPVPicture **reordered_input_picture; ///< pointer to the next pictures in coded order for encoding
134		134

libavcodec/mpegvideo_dec.c+21−51

 #include "mpegvideo.h"
 #include "mpegvideodec.h"
 #include "mpeg4videodec.h"
+#include "refstruct.h"
 #include "thread.h"
 #include "threadframe.h"
 #include "wmv2dec.h"
-void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
+int ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
 {
     ff_mpv_common_defaults(s);
     ff_mpv_idct_init(s);
     ff_h264chroma_init(&s->h264chroma, 8); //for lowres
+    if (!s->picture_pool && // VC-1 can call this multiple times
+        ff_thread_sync_ref(avctx, offsetof(MpegEncContext, picture_pool))) {
+        s->picture_pool = ff_mpv_alloc_pic_pool();
+        if (!s->picture_pool)
+            return AVERROR(ENOMEM);
+    }
+    return 0;
 }
 int ff_mpeg_update_thread_context(AVCodecContext *dst,
     s->coded_picture_number = s1->coded_picture_number;
     s->picture_number       = s1->picture_number;
-    av_assert0(!s->picture || s->picture != s1->picture);
+    ff_mpv_replace_picture(&s->cur_pic,  &s1->cur_pic);
-    if (s->picture)
+    ff_mpv_replace_picture(&s->last_pic, &s1->last_pic);
-        for (int i = 0; i < MAX_PICTURE_COUNT; i++) {
+    ff_mpv_replace_picture(&s->next_pic, &s1->next_pic);
-            ff_mpeg_unref_picture(&s->picture[i]);
-            if (s1->picture && s1->picture[i].f->buf[0] &&
-                (ret = ff_mpeg_ref_picture(&s->picture[i], &s1->picture[i])) < 0)
-                return ret;
-        }
-#define UPDATE_PICTURE(pic)\
-do {\
-    if (s->picture && s1->picture && s1->pic.ptr && s1->pic.ptr->f->buf[0]) {\
-        ff_mpv_workpic_from_pic(&s->pic, &s->picture[s1->pic.ptr - s1->picture]);\
-    } else\
-        ff_mpv_unref_picture(&s->pic);\
-} while (0)
-    UPDATE_PICTURE(cur_pic);
-    UPDATE_PICTURE(last_pic);
-    UPDATE_PICTURE(next_pic);
     s->linesize   = s1->linesize;
     s->uvlinesize = s1->uvlinesize;
 {
     MpegEncContext *s = avctx->priv_data;
+    ff_refstruct_pool_uninit(&s->picture_pool);
     ff_mpv_common_end(s);
     return 0;
 }
     ff_mpv_free_context_frame(s);
-    s->last_pic.ptr =
+    ff_mpv_unref_picture(&s->last_pic);
-    s->next_pic.ptr =
+    ff_mpv_unref_picture(&s->next_pic);
-    s->cur_pic.ptr  = NULL;
+    ff_mpv_unref_picture(&s->cur_pic);
     if ((s->width || s->height) &&
         (err = av_image_check_size(s->width, s->height, 0, s->avctx)) < 0)
 static int alloc_picture(MpegEncContext *s, MPVWorkPicture *dst, int reference)
 {
     AVCodecContext *avctx = s->avctx;
-    int idx = ff_find_unused_picture(s->avctx, s->picture, 0);
+    MPVPicture *pic = ff_refstruct_pool_get(s->picture_pool);
-    MPVPicture *pic;
     int ret;
-    if (idx < 0)
+    if (!pic)
-        return idx;
+        return AVERROR(ENOMEM);
-    pic = &s->picture[idx];
     dst->ptr = pic;
     pic->tf.f = pic->f;
         return AVERROR_BUG;
     }
-    /* mark & release old frames */
+    ff_mpv_unref_picture(&s->cur_pic);
-    if (s->pict_type != AV_PICTURE_TYPE_B && s->last_pic.ptr &&
-        s->last_pic.ptr != s->next_pic.ptr &&
-        s->last_pic.ptr->f->buf[0]) {
-        ff_mpeg_unref_picture(s->last_pic.ptr);
-    }
-    /* release non reference/forgotten frames */
-    for (int i = 0; i < MAX_PICTURE_COUNT; i++) {
-        if (!s->picture[i].reference ||
-            (&s->picture[i] != s->last_pic.ptr &&
-             &s->picture[i] != s->next_pic.ptr)) {
-            ff_mpeg_unref_picture(&s->picture[i]);
-        }
-    }
     ret = alloc_picture(s, &s->cur_pic,
                         s->pict_type != AV_PICTURE_TYPE_B && !s->droppable);
     if (ret < 0)
 {
     MpegEncContext *const s = avctx->priv_data;
-    if (!s->picture)
-        return;
-    for (int i = 0; i < MAX_PICTURE_COUNT; i++)
-        ff_mpeg_unref_picture(&s->picture[i]);
     ff_mpv_unref_picture(&s->cur_pic);
     ff_mpv_unref_picture(&s->last_pic);
     ff_mpv_unref_picture(&s->next_pic);

libavcodec/mpegvideo_enc.c+41−33

 #include "wmv2enc.h"
 #include "rv10enc.h"
 #include "packet_internal.h"
+#include "refstruct.h"
 #include <limits.h>
 #include "sp5x.h"
         !FF_ALLOCZ_TYPED_ARRAY(s->q_inter_matrix16,        32) ||
         !FF_ALLOCZ_TYPED_ARRAY(s->input_picture,           MAX_B_FRAMES + 1) ||
         !FF_ALLOCZ_TYPED_ARRAY(s->reordered_input_picture, MAX_B_FRAMES + 1) ||
-        !(s->new_pic = av_frame_alloc()))
+        !(s->new_pic = av_frame_alloc()) ||
+        !(s->picture_pool = ff_mpv_alloc_pic_pool()))
         return AVERROR(ENOMEM);
     /* Allocate MV tables; the MV and MB tables will be copied
     ff_rate_control_uninit(&s->rc_context);
     ff_mpv_common_end(s);
+    ff_refstruct_pool_uninit(&s->picture_pool);
+    if (s->input_picture && s->reordered_input_picture) {
+        for (int i = 0; i < MAX_B_FRAMES + 1; i++) {
+            ff_refstruct_unref(&s->input_picture[i]);
+            ff_refstruct_unref(&s->reordered_input_picture[i]);
+        }
+    }
     for (i = 0; i < FF_ARRAY_ELEMS(s->tmp_frames); i++)
         av_frame_free(&s->tmp_frames[i]);
 {
     MPVPicture *pic = NULL;
     int64_t pts;
-    int i, display_picture_number = 0, ret;
+    int display_picture_number = 0, ret;
     int encoding_delay = s->max_b_frames ? s->max_b_frames
                                          : (s->low_delay ? 0 : 1);
     int flush_offset = 1;
     int direct = 1;
+    av_assert1(!s->input_picture[0]);
     if (pic_arg) {
         pts = pic_arg->pts;
         display_picture_number = s->input_picture_number++;
         ff_dlog(s->avctx, "%d %d %"PTRDIFF_SPECIFIER" %"PTRDIFF_SPECIFIER"\n", pic_arg->linesize[0],
                 pic_arg->linesize[1], s->linesize, s->uvlinesize);
-        i = ff_find_unused_picture(s->avctx, s->picture, direct);
+        pic = ff_refstruct_pool_get(s->picture_pool);
-        if (i < 0)
+        if (!pic)
-            return i;
+            return AVERROR(ENOMEM);
-        pic = &s->picture[i];
-        pic->reference = 3;
         if (direct) {
             if ((ret = av_frame_ref(pic->f, pic_arg)) < 0)
-                return ret;
+                goto fail;
             pic->shared = 1;
         } else {
             ret = prepare_picture(s, pic->f, pic_arg);
         pic->display_picture_number = display_picture_number;
         pic->f->pts = pts; // we set this here to avoid modifying pic_arg
-    } else {
+    } else if (!s->reordered_input_picture[1]) {
-        /* Flushing: When we have not received enough input frames,
+        /* Flushing: When the above check is true, the encoder is about to run
-         * ensure s->input_picture[0] contains the first picture */
+         * out of frames to encode. Check if there are input_pictures left;
+         * if so, ensure s->input_picture[0] contains the first picture.
+         * A flush_offset != 1 will only happen if we did not receive enough
+         * input frames. */
         for (flush_offset = 0; flush_offset < encoding_delay + 1; flush_offset++)
             if (s->input_picture[flush_offset])
                 break;
-        if (flush_offset <= 1)
+        encoding_delay -= flush_offset - 1;
-            flush_offset = 1;
-        else
-            encoding_delay = encoding_delay - flush_offset + 1;
     }
     /* shift buffer entries */
     return 0;
 fail:
-    ff_mpeg_unref_picture(pic);
+    ff_refstruct_unref(&pic);
     return ret;
 }
 /**
  * Determines whether an input picture is discarded or not
  * and if not determines the length of the next chain of B frames
- * and puts these pictures (including the P frame) into
+ * and moves these pictures (including the P frame) into
  * reordered_input_picture.
+ * input_picture[0] is always NULL when exiting this function, even on error;
+ * reordered_input_picture[0] is always NULL when exiting this function on error.
  */
 static int set_bframe_chain_length(MpegEncContext *s)
 {
             s->next_pic.ptr &&
             skip_check(s, s->input_picture[0], s->next_pic.ptr)) {
             // FIXME check that the gop check above is +-1 correct
-            ff_mpeg_unref_picture(s->input_picture[0]);
+            ff_refstruct_unref(&s->input_picture[0]);
             ff_vbv_update(s, 0);
     if (/*s->picture_in_gop_number >= s->gop_size ||*/
         !s->next_pic.ptr || s->intra_only) {
         s->reordered_input_picture[0] = s->input_picture[0];
+        s->input_picture[0] = NULL;
         s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_I;
         s->reordered_input_picture[0]->coded_picture_number =
             s->coded_picture_number++;
         } else if (s->b_frame_strategy == 2) {
             b_frames = estimate_best_b_count(s);
             if (b_frames < 0) {
-                ff_mpeg_unref_picture(s->input_picture[0]);
+                ff_refstruct_unref(&s->input_picture[0]);
                 return b_frames;
             }
         }
             b_frames--;
         s->reordered_input_picture[0] = s->input_picture[b_frames];
+        s->input_picture[b_frames]    = NULL;
         if (s->reordered_input_picture[0]->f->pict_type != AV_PICTURE_TYPE_I)
             s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_P;
         s->reordered_input_picture[0]->coded_picture_number =
             s->coded_picture_number++;
         for (int i = 0; i < b_frames; i++) {
             s->reordered_input_picture[i + 1] = s->input_picture[i];
+            s->input_picture[i]               = NULL;
             s->reordered_input_picture[i + 1]->f->pict_type =
                 AV_PICTURE_TYPE_B;
             s->reordered_input_picture[i + 1]->coded_picture_number =
 {
     int ret;
+    av_assert1(!s->reordered_input_picture[0]);
     for (int i = 1; i <= MAX_B_FRAMES; i++)
         s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
     s->reordered_input_picture[MAX_B_FRAMES] = NULL;
     ret = set_bframe_chain_length(s);
+    av_assert1(!s->input_picture[0]);
     if (ret < 0)
         return ret;
             }
         }
         s->cur_pic.ptr = s->reordered_input_picture[0];
+        s->reordered_input_picture[0] = NULL;
         av_assert1(s->mb_width  == s->buffer_pools.alloc_mb_width);
         av_assert1(s->mb_height == s->buffer_pools.alloc_mb_height);
         av_assert1(s->mb_stride == s->buffer_pools.alloc_mb_stride);
     }
     return 0;
 fail:
-    ff_mpeg_unref_picture(s->reordered_input_picture[0]);
+    ff_refstruct_unref(&s->reordered_input_picture[0]);
     return ret;
 }
 static void frame_start(MpegEncContext *s)
 {
-    /* mark & release old frames */
-    if (s->pict_type != AV_PICTURE_TYPE_B && s->last_pic.ptr &&
-        s->last_pic.ptr != s->next_pic.ptr &&
-        s->last_pic.ptr->f->buf[0]) {
-        ff_mpv_unref_picture(&s->last_pic);
-    }
     s->cur_pic.ptr->f->pict_type = s->pict_type;
     if (s->pict_type != AV_PICTURE_TYPE_B) {
     int i, stuffing_count, ret;
     int context_count = s->slice_context_count;
+    ff_mpv_unref_picture(&s->cur_pic);
     s->vbv_ignore_qmax = 0;
     s->picture_in_gop_number++;
         s->frame_bits = 0;
     }
-    /* release non-reference frames */
+    ff_mpv_unref_picture(&s->cur_pic);
-    for (i = 0; i < MAX_PICTURE_COUNT; i++) {
-        if (!s->picture[i].reference)
-            ff_mpeg_unref_picture(&s->picture[i]);
-    }
     av_assert1((s->frame_bits & 7) == 0);

libavcodec/mpegvideodec.h+3−1

  * Initialize the given MpegEncContext for decoding.
  * the changed fields will not depend upon
  * the prior state of the MpegEncContext.
+ *
+ * Also initialize the picture pool.
  */
-void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx);
+int ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx);
 int ff_mpv_common_frame_size_change(MpegEncContext *s);

libavcodec/msmpeg4dec.c+8−4

     FF_CODEC_DECODE_CB(ff_h263_decode_frame),
     .close          = ff_mpv_decode_close,
     .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1,
-    .caps_internal  = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
+    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP |
+                      FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
     .p.max_lowres   = 3,
 };
     FF_CODEC_DECODE_CB(ff_h263_decode_frame),
     .close          = ff_mpv_decode_close,
     .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1,
-    .caps_internal  = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
+    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP |
+                      FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
     .p.max_lowres   = 3,
 };
     FF_CODEC_DECODE_CB(ff_h263_decode_frame),
     .close          = ff_mpv_decode_close,
     .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1,
-    .caps_internal  = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
+    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP |
+                      FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
     .p.max_lowres   = 3,
 };
     FF_CODEC_DECODE_CB(ff_h263_decode_frame),
     .close          = ff_mpv_decode_close,
     .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1,
-    .caps_internal  = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
+    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP |
+                      FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
     .p.max_lowres   = 3,
 };

libavcodec/rv10.c+6−2

                                    avctx->coded_height, 0, avctx)) < 0)
         return ret;
-    ff_mpv_decode_init(s, avctx);
+    ret = ff_mpv_decode_init(s, avctx);
+    if (ret < 0)
+        return ret;
     s->out_format  = FMT_H263;
         }
         // so we can detect if frame_end was not called (find some nicer solution...)
-        s->cur_pic.ptr = NULL;
+        ff_mpv_unref_picture(&s->cur_pic);
     }
     return avpkt->size;
     .close          = ff_mpv_decode_close,
     .p.capabilities = AV_CODEC_CAP_DR1,
     .p.max_lowres   = 3,
+    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };
 const FFCodec ff_rv20_decoder = {
     .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
     .flush          = ff_mpeg_flush,
     .p.max_lowres   = 3,
+    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };

libavcodec/rv34.c+4−2

     MpegEncContext *s = &r->s;
     int ret;
-    ff_mpv_decode_init(s, avctx);
+    ret = ff_mpv_decode_init(s, avctx);
+    if (ret < 0)
+        return ret;
     s->out_format = FMT_H263;
     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
         if (s->next_pic.ptr) {
             if ((ret = av_frame_ref(pict, s->next_pic.ptr->f)) < 0)
                 return ret;
-            s->next_pic.ptr = NULL;
+            ff_mpv_unref_picture(&s->next_pic);
             *got_picture_ptr = 1;
         }

libavcodec/svq1enc.c+0−3

      * else, the idea is to make the motion estimation eventually independent
      * of MpegEncContext, so this will be removed then. */
     MpegEncContext m;
-    MPVPicture cur_pic, last_pic;
     AVCodecContext *avctx;
     MECmpContext mecc;
     HpelDSPContext hdsp;
     if (s->pict_type == AV_PICTURE_TYPE_P) {
         s->m.avctx                         = s->avctx;
-        s->m.cur_pic.ptr                   = &s->cur_pic;
-        s->m.last_pic.ptr                  = &s->last_pic;
         s->m.last_pic.data[0]        = ref_plane;
         s->m.linesize                      =
         s->m.last_pic.linesize[0]    =

libavcodec/vc1dec.c+5−3

     if (ret < 0)
         return ret;
-    ff_mpv_decode_init(s, avctx);
+    ret = ff_mpv_decode_init(s, avctx);
+    if (ret < 0)
+        return ret;
     avctx->pix_fmt = vc1_get_format(avctx);
         if (s->low_delay == 0 && s->next_pic.ptr) {
             if ((ret = av_frame_ref(pict, s->next_pic.ptr->f)) < 0)
                 return ret;
-            s->next_pic.ptr = NULL;
+            ff_mpv_unref_picture(&s->next_pic);
             *got_frame = 1;
         }
     if (s->context_initialized &&
         (s->width  != avctx->coded_width ||
          s->height != avctx->coded_height)) {
-        ff_vc1_decode_end(avctx);
+        vc1_decode_reset(avctx);
     }
     if (!s->context_initialized) {

avcodec/mpegpicture: Make MPVPicture refcounted

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code