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 "libavutil/buffer.h"
20			#include "libavutil/hwcontext.h"
21			#include "libavutil/log.h"
22			#include "libavutil/opt.h"
23			#include "libavutil/pixdesc.h"
24
25			#include "avfilter.h"
26			#include "formats.h"
27			#include "internal.h"
28			#include "video.h"
29
30			typedef struct HWMapContext {
31			const AVClass *class;
32
33			AVBufferRef *hwframes_ref;
34
35			int mode;
36			char *derive_device_type;
37			int reverse;
38			} HWMapContext;
39
40		✗	static int hwmap_query_formats(AVFilterContext *avctx)
41			{
42			int ret;
43
44		✗	if ((ret = ff_formats_ref(ff_all_formats(AVMEDIA_TYPE_VIDEO),
45		✗	&avctx->inputs[0]->outcfg.formats)) < 0 ||
46		✗	(ret = ff_formats_ref(ff_all_formats(AVMEDIA_TYPE_VIDEO),
47		✗	&avctx->outputs[0]->incfg.formats)) < 0)
48		✗	return ret;
49
50		✗	return 0;
51			}
52
53		✗	static int hwmap_config_output(AVFilterLink *outlink)
54			{
55		✗	AVFilterContext *avctx = outlink->src;
56		✗	HWMapContext *ctx = avctx->priv;
57		✗	AVFilterLink *inlink = avctx->inputs[0];
58			AVHWFramesContext *hwfc;
59			AVBufferRef *device;
60			const AVPixFmtDescriptor *desc;
61			int err, device_is_derived;
62
63		✗	av_log(avctx, AV_LOG_DEBUG, "Configure hwmap %s -> %s.\n",
64		✗	av_get_pix_fmt_name(inlink->format),
65		✗	av_get_pix_fmt_name(outlink->format));
66
67		✗	av_buffer_unref(&ctx->hwframes_ref);
68
69		✗	device = avctx->hw_device_ctx;
70		✗	device_is_derived = 0;
71
72		✗	if (inlink->hw_frames_ctx) {
73		✗	hwfc = (AVHWFramesContext*)inlink->hw_frames_ctx->data;
74
75		✗	if (ctx->derive_device_type) {
76			enum AVHWDeviceType type;
77
78		✗	type = av_hwdevice_find_type_by_name(ctx->derive_device_type);
79		✗	if (type == AV_HWDEVICE_TYPE_NONE) {
80		✗	av_log(avctx, AV_LOG_ERROR, "Invalid device type.\n");
81		✗	err = AVERROR(EINVAL);
82		✗	goto fail;
83			}
84
85		✗	err = av_hwdevice_ctx_create_derived(&device, type,
86			hwfc->device_ref, 0);
87		✗	if (err < 0) {
88		✗	av_log(avctx, AV_LOG_ERROR, "Failed to created derived "
89			"device context: %d.\n", err);
90		✗	goto fail;
91			}
92		✗	device_is_derived = 1;
93			}
94
95		✗	desc = av_pix_fmt_desc_get(outlink->format);
96		✗	if (!desc) {
97		✗	err = AVERROR(EINVAL);
98		✗	goto fail;
99			}
100
101		✗	if (inlink->format == hwfc->format &&
102		✗	(desc->flags & AV_PIX_FMT_FLAG_HWACCEL) &&
103		✗	!ctx->reverse) {
104			// Map between two hardware formats (including the case of
105			// undoing an existing mapping).
106
107		✗	if (!device) {
108		✗	av_log(avctx, AV_LOG_ERROR, "A device reference is "
109			"required to map to a hardware format.\n");
110		✗	err = AVERROR(EINVAL);
111		✗	goto fail;
112			}
113
114		✗	err = av_hwframe_ctx_create_derived(&ctx->hwframes_ref,
115		✗	outlink->format,
116			device,
117			inlink->hw_frames_ctx,
118			ctx->mode);
119		✗	if (err < 0) {
120		✗	av_log(avctx, AV_LOG_ERROR, "Failed to create derived "
121			"frames context: %d.\n", err);
122		✗	goto fail;
123			}
124
125		✗	} else if (inlink->format == hwfc->format &&
126		✗	(desc->flags & AV_PIX_FMT_FLAG_HWACCEL) &&
127		✗	ctx->reverse) {
128			// Map between two hardware formats, but do it in reverse.
129			// Make a new hwframe context for the target type, and then
130			// overwrite the input hwframe context with a derived context
131			// mapped from that back to the source type.
132			AVBufferRef *source;
133			AVHWFramesContext *frames;
134
135		✗	ctx->hwframes_ref = av_hwframe_ctx_alloc(device);
136		✗	if (!ctx->hwframes_ref) {
137		✗	err = AVERROR(ENOMEM);
138		✗	goto fail;
139			}
140		✗	frames = (AVHWFramesContext*)ctx->hwframes_ref->data;
141
142		✗	frames->format = outlink->format;
143		✗	frames->sw_format = hwfc->sw_format;
144		✗	frames->width = hwfc->width;
145		✗	frames->height = hwfc->height;
146
147		✗	if (avctx->extra_hw_frames >= 0)
148		✗	frames->initial_pool_size = 2 + avctx->extra_hw_frames;
149
150		✗	err = av_hwframe_ctx_init(ctx->hwframes_ref);
151		✗	if (err < 0) {
152		✗	av_log(avctx, AV_LOG_ERROR, "Failed to initialise "
153			"target frames context: %d.\n", err);
154		✗	goto fail;
155			}
156
157		✗	err = av_hwframe_ctx_create_derived(&source,
158		✗	inlink->format,
159			hwfc->device_ref,
160			ctx->hwframes_ref,
161			ctx->mode);
162		✗	if (err < 0) {
163		✗	av_log(avctx, AV_LOG_ERROR, "Failed to create "
164			"derived source frames context: %d.\n", err);
165		✗	goto fail;
166			}
167
168			// Here is the naughty bit. This overwriting changes what
169			// ff_get_video_buffer() in the previous filter returns -
170			// it will now give a frame allocated here mapped back to
171			// the format it expects. If there were any additional
172			// constraints on the output frames there then this may
173			// break nastily.
174		✗	av_buffer_unref(&inlink->hw_frames_ctx);
175		✗	inlink->hw_frames_ctx = source;
176
177		✗	} else if ((outlink->format == hwfc->format &&
178		✗	inlink->format == hwfc->sw_format) ||
179		✗	inlink->format == hwfc->format) {
180			// Map from a hardware format to a software format, or
181			// undo an existing such mapping.
182
183		✗	ctx->hwframes_ref = av_buffer_ref(inlink->hw_frames_ctx);
184		✗	if (!ctx->hwframes_ref) {
185		✗	err = AVERROR(ENOMEM);
186		✗	goto fail;
187			}
188
189			} else {
190			// Non-matching formats - not supported.
191
192		✗	av_log(avctx, AV_LOG_ERROR, "Unsupported formats for "
193			"hwmap: from %s (%s) to %s.\n",
194		✗	av_get_pix_fmt_name(inlink->format),
195			av_get_pix_fmt_name(hwfc->format),
196		✗	av_get_pix_fmt_name(outlink->format));
197		✗	err = AVERROR(EINVAL);
198		✗	goto fail;
199			}
200		✗	} else if (avctx->hw_device_ctx) {
201			// Map from a software format to a hardware format. This
202			// creates a new hwframe context like hwupload, but then
203			// returns frames mapped from that to the previous link in
204			// order to fill them without an additional copy.
205
206		✗	if (!device) {
207		✗	av_log(avctx, AV_LOG_ERROR, "A device reference is "
208			"required to create new frames with reverse "
209			"mapping.\n");
210		✗	err = AVERROR(EINVAL);
211		✗	goto fail;
212			}
213
214		✗	ctx->reverse = 1;
215
216		✗	ctx->hwframes_ref = av_hwframe_ctx_alloc(device);
217		✗	if (!ctx->hwframes_ref) {
218		✗	err = AVERROR(ENOMEM);
219		✗	goto fail;
220			}
221		✗	hwfc = (AVHWFramesContext*)ctx->hwframes_ref->data;
222
223		✗	hwfc->format = outlink->format;
224		✗	hwfc->sw_format = inlink->format;
225		✗	hwfc->width = inlink->w;
226		✗	hwfc->height = inlink->h;
227
228		✗	if (avctx->extra_hw_frames >= 0)
229		✗	hwfc->initial_pool_size = 2 + avctx->extra_hw_frames;
230
231		✗	err = av_hwframe_ctx_init(ctx->hwframes_ref);
232		✗	if (err < 0) {
233		✗	av_log(avctx, AV_LOG_ERROR, "Failed to create frame "
234			"context for reverse mapping: %d.\n", err);
235		✗	goto fail;
236			}
237
238			} else {
239		✗	av_log(avctx, AV_LOG_ERROR, "Mapping requires a hardware "
240			"context (a device, or frames on input).\n");
241		✗	return AVERROR(EINVAL);
242			}
243
244		✗	outlink->hw_frames_ctx = av_buffer_ref(ctx->hwframes_ref);
245		✗	if (!outlink->hw_frames_ctx) {
246		✗	err = AVERROR(ENOMEM);
247		✗	goto fail;
248			}
249
250		✗	outlink->w = inlink->w;
251		✗	outlink->h = inlink->h;
252
253		✗	if (device_is_derived)
254		✗	av_buffer_unref(&device);
255		✗	return 0;
256
257		✗	fail:
258		✗	if (device_is_derived)
259		✗	av_buffer_unref(&device);
260		✗	av_buffer_unref(&ctx->hwframes_ref);
261		✗	return err;
262			}
263
264		✗	static AVFrame *hwmap_get_buffer(AVFilterLink *inlink, int w, int h)
265			{
266		✗	AVFilterContext *avctx = inlink->dst;
267		✗	AVFilterLink *outlink = avctx->outputs[0];
268		✗	HWMapContext *ctx = avctx->priv;
269
270		✗	if (ctx->reverse && !inlink->hw_frames_ctx) {
271			AVFrame *src, *dst;
272			int err;
273
274		✗	src = ff_get_video_buffer(outlink, w, h);
275		✗	if (!src) {
276		✗	av_log(avctx, AV_LOG_ERROR, "Failed to allocate source "
277			"frame for software mapping.\n");
278		✗	return NULL;
279			}
280
281		✗	dst = av_frame_alloc();
282		✗	if (!dst) {
283		✗	av_frame_free(&src);
284		✗	return NULL;
285			}
286
287		✗	err = av_hwframe_map(dst, src, ctx->mode);
288		✗	if (err) {
289		✗	av_log(avctx, AV_LOG_ERROR, "Failed to map frame to "
290			"software: %d.\n", err);
291		✗	av_frame_free(&src);
292		✗	av_frame_free(&dst);
293		✗	return NULL;
294			}
295
296		✗	av_frame_free(&src);
297		✗	return dst;
298			} else {
299		✗	return ff_default_get_video_buffer(inlink, w, h);
300			}
301			}
302
303		✗	static int hwmap_filter_frame(AVFilterLink *link, AVFrame *input)
304			{
305		✗	AVFilterContext *avctx = link->dst;
306		✗	AVFilterLink *outlink = avctx->outputs[0];
307		✗	HWMapContext *ctx = avctx->priv;
308		✗	AVFrame *map = NULL;
309			int err;
310
311		✗	av_log(ctx, AV_LOG_DEBUG, "Filter input: %s, %ux%u (%"PRId64").\n",
312		✗	av_get_pix_fmt_name(input->format),
313		✗	input->width, input->height, input->pts);
314
315		✗	map = av_frame_alloc();
316		✗	if (!map) {
317		✗	err = AVERROR(ENOMEM);
318		✗	goto fail;
319			}
320
321		✗	map->format = outlink->format;
322		✗	map->hw_frames_ctx = av_buffer_ref(ctx->hwframes_ref);
323		✗	if (!map->hw_frames_ctx) {
324		✗	err = AVERROR(ENOMEM);
325		✗	goto fail;
326			}
327
328		✗	if (ctx->reverse && !input->hw_frames_ctx) {
329			// If we mapped backwards from hardware to software, we need
330			// to attach the hardware frame context to the input frame to
331			// make the mapping visible to av_hwframe_map().
332		✗	input->hw_frames_ctx = av_buffer_ref(ctx->hwframes_ref);
333		✗	if (!input->hw_frames_ctx) {
334		✗	err = AVERROR(ENOMEM);
335		✗	goto fail;
336			}
337			}
338
339		✗	err = av_hwframe_map(map, input, ctx->mode);
340		✗	if (err < 0) {
341		✗	av_log(avctx, AV_LOG_ERROR, "Failed to map frame: %d.\n", err);
342		✗	goto fail;
343			}
344
345		✗	err = av_frame_copy_props(map, input);
346		✗	if (err < 0)
347		✗	goto fail;
348
349		✗	av_frame_free(&input);
350
351		✗	av_log(ctx, AV_LOG_DEBUG, "Filter output: %s, %ux%u (%"PRId64").\n",
352		✗	av_get_pix_fmt_name(map->format),
353		✗	map->width, map->height, map->pts);
354
355		✗	return ff_filter_frame(outlink, map);
356
357		✗	fail:
358		✗	av_frame_free(&input);
359		✗	av_frame_free(&map);
360		✗	return err;
361			}
362
363		✗	static av_cold void hwmap_uninit(AVFilterContext *avctx)
364			{
365		✗	HWMapContext *ctx = avctx->priv;
366
367		✗	av_buffer_unref(&ctx->hwframes_ref);
368		✗	}
369
370			#define OFFSET(x) offsetof(HWMapContext, x)
371			#define FLAGS (AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM)
372			static const AVOption hwmap_options[] = {
373			{ "mode", "Frame mapping mode",
374			OFFSET(mode), AV_OPT_TYPE_FLAGS,
375			{ .i64 = AV_HWFRAME_MAP_READ | AV_HWFRAME_MAP_WRITE },
376			0, INT_MAX, FLAGS, .unit = "mode" },
377
378			{ "read", "Mapping should be readable",
379			0, AV_OPT_TYPE_CONST, { .i64 = AV_HWFRAME_MAP_READ },
380			INT_MIN, INT_MAX, FLAGS, .unit = "mode" },
381			{ "write", "Mapping should be writeable",
382			0, AV_OPT_TYPE_CONST, { .i64 = AV_HWFRAME_MAP_WRITE },
383			INT_MIN, INT_MAX, FLAGS, .unit = "mode" },
384			{ "overwrite", "Mapping will always overwrite the entire frame",
385			0, AV_OPT_TYPE_CONST, { .i64 = AV_HWFRAME_MAP_OVERWRITE },
386			INT_MIN, INT_MAX, FLAGS, .unit = "mode" },
387			{ "direct", "Mapping should not involve any copying",
388			0, AV_OPT_TYPE_CONST, { .i64 = AV_HWFRAME_MAP_DIRECT },
389			INT_MIN, INT_MAX, FLAGS, .unit = "mode" },
390
391			{ "derive_device", "Derive a new device of this type",
392			OFFSET(derive_device_type), AV_OPT_TYPE_STRING,
393			{ .str = NULL }, 0, 0, FLAGS },
394			{ "reverse", "Map in reverse (create and allocate in the sink)",
395			OFFSET(reverse), AV_OPT_TYPE_INT,
396			{ .i64 = 0 }, 0, 1, FLAGS },
397
398			{ NULL }
399			};
400
401			AVFILTER_DEFINE_CLASS(hwmap);
402
403			static const AVFilterPad hwmap_inputs[] = {
404			{
405			.name = "default",
406			.type = AVMEDIA_TYPE_VIDEO,
407			.get_buffer.video = hwmap_get_buffer,
408			.filter_frame = hwmap_filter_frame,
409			},
410			};
411
412			static const AVFilterPad hwmap_outputs[] = {
413			{
414			.name = "default",
415			.type = AVMEDIA_TYPE_VIDEO,
416			.config_props = hwmap_config_output,
417			},
418			};
419
420			const AVFilter ff_vf_hwmap = {
421			.name = "hwmap",
422			.description = NULL_IF_CONFIG_SMALL("Map hardware frames"),
423			.uninit = hwmap_uninit,
424			.priv_size = sizeof(HWMapContext),
425			.priv_class = &hwmap_class,
426			FILTER_INPUTS(hwmap_inputs),
427			FILTER_OUTPUTS(hwmap_outputs),
428			FILTER_QUERY_FUNC(hwmap_query_formats),
429			.flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
430			.flags = AVFILTER_FLAG_HWDEVICE,
431			};
432