FFmpeg coverage

Line	Branch	Exec	Source
1			/*
2			* This file is part of FFmpeg.
3			*
4			* FFmpeg is free software; you can redistribute it and/or
5			* modify it under the terms of the GNU Lesser General Public
6			* License as published by the Free Software Foundation; either
7			* version 2.1 of the License, or (at your option) any later version.
8			*
9			* FFmpeg is distributed in the hope that it will be useful,
10			* but WITHOUT ANY WARRANTY; without even the implied warranty of
11			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12			* Lesser General Public License for more details.
13			*
14			* You should have received a copy of the GNU Lesser General Public
15			* License along with FFmpeg; if not, write to the Free Software
16			* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17			*/
18
19			#include "config_components.h"
20
21			#include "libavutil/avassert.h"
22			#include "libavutil/frame.h"
23			#include "libavutil/imgutils.h"
24			#include "libavutil/log.h"
25			#include "libavutil/mem.h"
26			#include "decode.h"
27			#include "lcevcdec.h"
28
29			#if CONFIG_LIBLCEVC_DEC
30			static LCEVC_ColorFormat map_format(int format)
31			{
32			switch (format) {
33			case AV_PIX_FMT_YUV420P:
34			return LCEVC_I420_8;
35			case AV_PIX_FMT_YUV420P10:
36			return LCEVC_I420_10_LE;
37			case AV_PIX_FMT_NV12:
38			return LCEVC_NV12_8;
39			case AV_PIX_FMT_NV21:
40			return LCEVC_NV21_8;
41			case AV_PIX_FMT_GRAY8:
42			return LCEVC_GRAY_8;
43			}
44
45			return LCEVC_ColorFormat_Unknown;
46			}
47
48			static int alloc_base_frame(void *logctx, LCEVC_DecoderHandle decoder,
49			const AVFrame *frame, LCEVC_PictureHandle *picture)
50			{
51			LCEVC_PictureDesc desc;
52			LCEVC_ColorFormat fmt = map_format(frame->format);
53			LCEVC_PictureLockHandle lock;
54			uint8_t *data[4] = { NULL };
55			int linesizes[4] = { 0 };
56			uint32_t planes;
57			LCEVC_ReturnCode res;
58
59			res = LCEVC_DefaultPictureDesc(&desc, fmt, frame->width, frame->height);
60			if (res != LCEVC_Success)
61			return AVERROR_EXTERNAL;
62
63			desc.cropTop = frame->crop_top;
64			desc.cropBottom = frame->crop_bottom;
65			desc.cropLeft = frame->crop_left;
66			desc.cropRight = frame->crop_right;
67			desc.sampleAspectRatioNum = frame->sample_aspect_ratio.num;
68			desc.sampleAspectRatioDen = frame->sample_aspect_ratio.den;
69
70			/* Allocate LCEVC Picture */
71			res = LCEVC_AllocPicture(decoder, &desc, picture);
72			if (res != LCEVC_Success) {
73			return AVERROR_EXTERNAL;
74			}
75			res = LCEVC_LockPicture(decoder, *picture, LCEVC_Access_Write, &lock);
76			if (res != LCEVC_Success)
77			return AVERROR_EXTERNAL;
78
79			res = LCEVC_GetPicturePlaneCount(decoder, *picture, &planes);
80			if (res != LCEVC_Success)
81			return AVERROR_EXTERNAL;
82
83			for (unsigned i = 0; i < planes; i++) {
84			LCEVC_PicturePlaneDesc plane;
85
86			res = LCEVC_GetPictureLockPlaneDesc(decoder, lock, i, &plane);
87			if (res != LCEVC_Success)
88			return AVERROR_EXTERNAL;
89
90			data[i] = plane.firstSample;
91			linesizes[i] = plane.rowByteStride;
92			}
93
94			av_image_copy2(data, linesizes, frame->data, frame->linesize,
95			frame->format, frame->width, frame->height);
96
97			res = LCEVC_UnlockPicture(decoder, lock);
98			if (res != LCEVC_Success)
99			return AVERROR_EXTERNAL;
100
101			return 0;
102			}
103
104			static int alloc_enhanced_frame(void *logctx, LCEVC_DecoderHandle decoder,
105			const AVFrame *frame, LCEVC_PictureHandle *picture)
106			{
107			LCEVC_PictureDesc desc ;
108			LCEVC_ColorFormat fmt = map_format(frame->format);
109			LCEVC_PicturePlaneDesc planes[4] = { 0 };
110			int width = frame->width * 2 / FFMAX(frame->sample_aspect_ratio.den, 1);
111			int height = frame->height * 2 / FFMAX(frame->sample_aspect_ratio.num, 1);
112			LCEVC_ReturnCode res;
113
114			res = LCEVC_DefaultPictureDesc(&desc, fmt, width, height);
115			if (res != LCEVC_Success)
116			return AVERROR_EXTERNAL;
117
118			/* Set plane description */
119			for (int i = 0; i < 4; i++) {
120			planes[i].firstSample = frame->data[i];
121			planes[i].rowByteStride = frame->linesize[i];
122			}
123
124			/* Allocate LCEVC Picture */
125			res = LCEVC_AllocPictureExternal(decoder, &desc, NULL, planes, picture);
126			if (res != LCEVC_Success) {
127			return AVERROR_EXTERNAL;
128			}
129			return 0;
130			}
131
132			static int lcevc_send_frame(void *logctx, FFLCEVCContext *lcevc, const AVFrame *in)
133			{
134			const AVFrameSideData *sd = av_frame_get_side_data(in, AV_FRAME_DATA_LCEVC);
135			LCEVC_PictureHandle picture;
136			LCEVC_ReturnCode res;
137			int ret = 0;
138
139			if (!sd)
140			return 1;
141
142			res = LCEVC_SendDecoderEnhancementData(lcevc->decoder, in->pts, 0, sd->data, sd->size);
143			if (res != LCEVC_Success)
144			return AVERROR_EXTERNAL;
145
146			ret = alloc_base_frame(logctx, lcevc->decoder, in, &picture);
147			if (ret < 0)
148			return ret;
149
150			res = LCEVC_SendDecoderBase(lcevc->decoder, in->pts, 0, picture, -1, NULL);
151			if (res != LCEVC_Success)
152			return AVERROR_EXTERNAL;
153
154			memset(&picture, 0, sizeof(picture));
155			ret = alloc_enhanced_frame(logctx, lcevc->decoder, in, &picture);
156			if (ret < 0)
157			return ret;
158
159			res = LCEVC_SendDecoderPicture(lcevc->decoder, picture);
160			if (res != LCEVC_Success)
161			return AVERROR_EXTERNAL;
162
163			return 0;
164			}
165
166			static int generate_output(void *logctx, FFLCEVCContext *lcevc, AVFrame *out)
167			{
168			LCEVC_PictureDesc desc;
169			LCEVC_DecodeInformation info;
170			LCEVC_PictureHandle picture;
171			LCEVC_ReturnCode res;
172
173			res = LCEVC_ReceiveDecoderPicture(lcevc->decoder, &picture, &info);
174			if (res != LCEVC_Success)
175			return AVERROR_EXTERNAL;
176
177			res = LCEVC_GetPictureDesc(lcevc->decoder, picture, &desc);
178			if (res != LCEVC_Success)
179			return AVERROR_EXTERNAL;
180
181			out->crop_top = desc.cropTop;
182			out->crop_bottom = desc.cropBottom;
183			out->crop_left = desc.cropLeft;
184			out->crop_right = desc.cropRight;
185			out->sample_aspect_ratio.num = desc.sampleAspectRatioNum;
186			out->sample_aspect_ratio.den = desc.sampleAspectRatioDen;
187			out->width = desc.width + out->crop_left + out->crop_right;
188			out->height = desc.height + out->crop_top + out->crop_bottom;
189
190			res = LCEVC_FreePicture(lcevc->decoder, picture);
191			if (res != LCEVC_Success)
192			return AVERROR_EXTERNAL;
193
194			return 0;
195			}
196
197			static int lcevc_receive_frame(void *logctx, FFLCEVCContext *lcevc, AVFrame *out)
198			{
199			LCEVC_PictureHandle picture;
200			LCEVC_ReturnCode res;
201			int ret;
202
203			ret = generate_output(logctx, lcevc, out);
204			if (ret < 0)
205			return ret;
206
207			while (1) {
208			res = LCEVC_ReceiveDecoderBase (lcevc->decoder, &picture);
209			if (res != LCEVC_Success && res != LCEVC_Again)
210			return AVERROR_EXTERNAL;
211
212			if (res == LCEVC_Again)
213			break;
214
215			res = LCEVC_FreePicture(lcevc->decoder, picture);
216			if (res != LCEVC_Success)
217			return AVERROR_EXTERNAL;
218			}
219
220			return 0;
221			}
222
223			static void event_callback(LCEVC_DecoderHandle dec, LCEVC_Event event,
224			LCEVC_PictureHandle pic, const LCEVC_DecodeInformation *info,
225			const uint8_t *data, uint32_t size, void *logctx)
226			{
227			switch (event) {
228			case LCEVC_Log:
229			av_log(logctx, AV_LOG_INFO, "%s\n", data);
230			break;
231			default:
232			break;
233			}
234			}
235
236			static void lcevc_free(FFRefStructOpaque unused, void *obj)
237			{
238			FFLCEVCContext *lcevc = obj;
239			if (lcevc->initialized)
240			LCEVC_DestroyDecoder(lcevc->decoder);
241			memset(lcevc, 0, sizeof(*lcevc));
242			}
243			#endif
244
245		✗	static int lcevc_init(FFLCEVCContext *lcevc, void *logctx)
246			{
247			#if CONFIG_LIBLCEVC_DEC
248			LCEVC_AccelContextHandle dummy = { 0 };
249			const int32_t event = LCEVC_Log;
250			#endif
251
252		✗	if (lcevc->initialized)
253		✗	return 0;
254
255			#if CONFIG_LIBLCEVC_DEC
256			if (LCEVC_CreateDecoder(&lcevc->decoder, dummy) != LCEVC_Success) {
257			av_log(logctx, AV_LOG_ERROR, "Failed to create LCEVC decoder\n");
258			return AVERROR_EXTERNAL;
259			}
260
261			LCEVC_ConfigureDecoderInt(lcevc->decoder, "log_level", 4);
262			LCEVC_ConfigureDecoderIntArray(lcevc->decoder, "events", 1, &event);
263			LCEVC_SetDecoderEventCallback(lcevc->decoder, event_callback, logctx);
264
265			if (LCEVC_InitializeDecoder(lcevc->decoder) != LCEVC_Success) {
266			av_log(logctx, AV_LOG_ERROR, "Failed to initialize LCEVC decoder\n");
267			LCEVC_DestroyDecoder(lcevc->decoder);
268			return AVERROR_EXTERNAL;
269			}
270
271			#endif
272		✗	lcevc->initialized = 1;
273
274		✗	return 0;
275			}
276
277		✗	int ff_lcevc_process(void *logctx, AVFrame *frame)
278			{
279		✗	FrameDecodeData *fdd = (FrameDecodeData*)frame->private_ref->data;
280		✗	FFLCEVCContext *lcevc = fdd->post_process_opaque;
281			int ret;
282
283		✗	if (!lcevc->initialized) {
284		✗	ret = lcevc_init(lcevc, logctx);
285		✗	if (ret < 0)
286		✗	return ret;
287			}
288
289			#if CONFIG_LIBLCEVC_DEC
290			ret = lcevc_send_frame(logctx, lcevc, frame);
291			if (ret)
292			return ret < 0 ? ret : 0;
293
294			lcevc_receive_frame(logctx, lcevc, frame);
295			if (ret < 0)
296			return ret;
297
298			av_frame_remove_side_data(frame, AV_FRAME_DATA_LCEVC);
299			#endif
300
301		✗	return 0;
302			}
303
304		15298	int ff_lcevc_alloc(FFLCEVCContext **plcevc)
305			{
306		15298	FFLCEVCContext *lcevc = NULL;
307			#if CONFIG_LIBLCEVC_DEC
308			lcevc = ff_refstruct_alloc_ext(sizeof(*lcevc), 0, NULL, lcevc_free);
309			if (!lcevc)
310			return AVERROR(ENOMEM);
311			#endif
312		15298	*plcevc = lcevc;
313		15298	return 0;
314			}
315
316		✗	void ff_lcevc_unref(void *opaque)
317			{
318		✗	ff_refstruct_unref(&opaque);
319		✗	}
320