FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavfilter/vf_hwmap.c
Date: 2024-04-12 08:31:17
Exec Total Coverage
Lines: 0 184 0.0%
Functions: 0 5 0.0%
Branches: 0 86 0.0%

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