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