libavfilter/ebur128: add target value to statistics line
[ffmpeg.git] / libavfilter / vf_hwmap.c
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]->out_formats)) < 0 ||
46         (ret = ff_formats_ref(ff_all_formats(AVMEDIA_TYPE_VIDEO),
47                               &avctx->outputs[0]->in_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, "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, "mode" },
381     { "write", "Mapping should be writeable",
382       0, AV_OPT_TYPE_CONST, { .i64 = AV_HWFRAME_MAP_WRITE },
383       INT_MIN, INT_MAX, FLAGS, "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, "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, "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_video_buffer = hwmap_get_buffer,
408         .filter_frame     = hwmap_filter_frame,
409     },
410     { NULL }
411 };
412
413 static const AVFilterPad hwmap_outputs[] = {
414     {
415         .name         = "default",
416         .type         = AVMEDIA_TYPE_VIDEO,
417         .config_props = hwmap_config_output,
418     },
419     { NULL }
420 };
421
422 AVFilter 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 };