FFmpeg
vf_hwmap.c
Go to the documentation of this file.
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 "filters.h"
27 #include "formats.h"
28 #include "video.h"
29 
30 typedef struct HWMapContext {
31  const AVClass *class;
32 
34 
35  int mode;
37  int reverse;
38 } HWMapContext;
39 
40 static int hwmap_query_formats(const AVFilterContext *avctx,
41  AVFilterFormatsConfig **cfg_in,
42  AVFilterFormatsConfig **cfg_out)
43 {
44  int ret;
45 
47  &cfg_in[0]->formats)) < 0 ||
49  &cfg_out[0]->formats)) < 0)
50  return ret;
51 
52  return 0;
53 }
54 
55 static int hwmap_config_output(AVFilterLink *outlink)
56 {
57  FilterLink *outl = ff_filter_link(outlink);
58  AVFilterContext *avctx = outlink->src;
59  HWMapContext *ctx = avctx->priv;
60  AVFilterLink *inlink = avctx->inputs[0];
62  AVHWFramesContext *hwfc;
63  AVBufferRef *device;
64  const AVPixFmtDescriptor *desc;
65  int err, device_is_derived;
66 
67  av_log(avctx, AV_LOG_DEBUG, "Configure hwmap %s -> %s.\n",
68  av_get_pix_fmt_name(inlink->format),
69  av_get_pix_fmt_name(outlink->format));
70 
71  av_buffer_unref(&ctx->hwframes_ref);
72 
73  device = avctx->hw_device_ctx;
74  device_is_derived = 0;
75 
76  if (inl->hw_frames_ctx) {
77  hwfc = (AVHWFramesContext*)inl->hw_frames_ctx->data;
78 
79  if (ctx->derive_device_type) {
80  enum AVHWDeviceType type;
81 
82  type = av_hwdevice_find_type_by_name(ctx->derive_device_type);
83  if (type == AV_HWDEVICE_TYPE_NONE) {
84  av_log(avctx, AV_LOG_ERROR, "Invalid device type.\n");
85  err = AVERROR(EINVAL);
86  goto fail;
87  }
88 
89  err = av_hwdevice_ctx_create_derived(&device, type,
90  hwfc->device_ref, 0);
91  if (err < 0) {
92  av_log(avctx, AV_LOG_ERROR, "Failed to created derived "
93  "device context: %d.\n", err);
94  goto fail;
95  }
96  device_is_derived = 1;
97  }
98 
99  desc = av_pix_fmt_desc_get(outlink->format);
100  if (!desc) {
101  err = AVERROR(EINVAL);
102  goto fail;
103  }
104 
105  if (inlink->format == hwfc->format &&
106  (desc->flags & AV_PIX_FMT_FLAG_HWACCEL) &&
107  !ctx->reverse) {
108  // Map between two hardware formats (including the case of
109  // undoing an existing mapping).
110 
111  if (!device) {
112  av_log(avctx, AV_LOG_ERROR, "A device reference is "
113  "required to map to a hardware format.\n");
114  err = AVERROR(EINVAL);
115  goto fail;
116  }
117 
118  err = av_hwframe_ctx_create_derived(&ctx->hwframes_ref,
119  outlink->format,
120  device,
121  inl->hw_frames_ctx,
122  ctx->mode);
123  if (err < 0) {
124  av_log(avctx, AV_LOG_ERROR, "Failed to create derived "
125  "frames context: %d.\n", err);
126  goto fail;
127  }
128 
129  } else if (inlink->format == hwfc->format &&
130  (desc->flags & AV_PIX_FMT_FLAG_HWACCEL) &&
131  ctx->reverse) {
132  // Map between two hardware formats, but do it in reverse.
133  // Make a new hwframe context for the target type, and then
134  // overwrite the input hwframe context with a derived context
135  // mapped from that back to the source type.
138 
139  ctx->hwframes_ref = av_hwframe_ctx_alloc(device);
140  if (!ctx->hwframes_ref) {
141  err = AVERROR(ENOMEM);
142  goto fail;
143  }
144  frames = (AVHWFramesContext*)ctx->hwframes_ref->data;
145 
146  frames->format = outlink->format;
147  frames->sw_format = hwfc->sw_format;
148  frames->width = hwfc->width;
149  frames->height = hwfc->height;
150 
151  if (avctx->extra_hw_frames >= 0)
152  frames->initial_pool_size = 2 + avctx->extra_hw_frames;
153 
154  err = av_hwframe_ctx_init(ctx->hwframes_ref);
155  if (err < 0) {
156  av_log(avctx, AV_LOG_ERROR, "Failed to initialise "
157  "target frames context: %d.\n", err);
158  goto fail;
159  }
160 
162  inlink->format,
163  hwfc->device_ref,
164  ctx->hwframes_ref,
165  ctx->mode);
166  if (err < 0) {
167  av_log(avctx, AV_LOG_ERROR, "Failed to create "
168  "derived source frames context: %d.\n", err);
169  goto fail;
170  }
171 
172  // Here is the naughty bit. This overwriting changes what
173  // ff_get_video_buffer() in the previous filter returns -
174  // it will now give a frame allocated here mapped back to
175  // the format it expects. If there were any additional
176  // constraints on the output frames there then this may
177  // break nastily.
179  inl->hw_frames_ctx = source;
180 
181  } else if ((outlink->format == hwfc->format &&
182  inlink->format == hwfc->sw_format) ||
183  inlink->format == hwfc->format) {
184  // Map from a hardware format to a software format, or
185  // undo an existing such mapping.
186 
187  ctx->hwframes_ref = av_buffer_ref(inl->hw_frames_ctx);
188  if (!ctx->hwframes_ref) {
189  err = AVERROR(ENOMEM);
190  goto fail;
191  }
192 
193  } else {
194  // Non-matching formats - not supported.
195 
196  av_log(avctx, AV_LOG_ERROR, "Unsupported formats for "
197  "hwmap: from %s (%s) to %s.\n",
198  av_get_pix_fmt_name(inlink->format),
200  av_get_pix_fmt_name(outlink->format));
201  err = AVERROR(EINVAL);
202  goto fail;
203  }
204  } else if (avctx->hw_device_ctx) {
205  // Map from a software format to a hardware format. This
206  // creates a new hwframe context like hwupload, but then
207  // returns frames mapped from that to the previous link in
208  // order to fill them without an additional copy.
209 
210  if (!device) {
211  av_log(avctx, AV_LOG_ERROR, "A device reference is "
212  "required to create new frames with reverse "
213  "mapping.\n");
214  err = AVERROR(EINVAL);
215  goto fail;
216  }
217 
218  ctx->reverse = 1;
219 
220  ctx->hwframes_ref = av_hwframe_ctx_alloc(device);
221  if (!ctx->hwframes_ref) {
222  err = AVERROR(ENOMEM);
223  goto fail;
224  }
225  hwfc = (AVHWFramesContext*)ctx->hwframes_ref->data;
226 
227  hwfc->format = outlink->format;
228  hwfc->sw_format = inlink->format;
229  hwfc->width = inlink->w;
230  hwfc->height = inlink->h;
231 
232  if (avctx->extra_hw_frames >= 0)
233  hwfc->initial_pool_size = 2 + avctx->extra_hw_frames;
234 
235  err = av_hwframe_ctx_init(ctx->hwframes_ref);
236  if (err < 0) {
237  av_log(avctx, AV_LOG_ERROR, "Failed to create frame "
238  "context for reverse mapping: %d.\n", err);
239  goto fail;
240  }
241 
242  } else {
243  av_log(avctx, AV_LOG_ERROR, "Mapping requires a hardware "
244  "context (a device, or frames on input).\n");
245  return AVERROR(EINVAL);
246  }
247 
248  outl->hw_frames_ctx = av_buffer_ref(ctx->hwframes_ref);
249  if (!outl->hw_frames_ctx) {
250  err = AVERROR(ENOMEM);
251  goto fail;
252  }
253 
254  outlink->w = inlink->w;
255  outlink->h = inlink->h;
256 
257  if (device_is_derived)
258  av_buffer_unref(&device);
259  return 0;
260 
261 fail:
262  if (device_is_derived)
263  av_buffer_unref(&device);
264  av_buffer_unref(&ctx->hwframes_ref);
265  return err;
266 }
267 
269 {
271  AVFilterContext *avctx = inlink->dst;
272  AVFilterLink *outlink = avctx->outputs[0];
273  HWMapContext *ctx = avctx->priv;
274 
275  if (ctx->reverse && !l->hw_frames_ctx) {
276  AVFrame *src, *dst;
277  int err;
278 
279  src = ff_get_video_buffer(outlink, w, h);
280  if (!src) {
281  av_log(avctx, AV_LOG_ERROR, "Failed to allocate source "
282  "frame for software mapping.\n");
283  return NULL;
284  }
285 
286  dst = av_frame_alloc();
287  if (!dst) {
288  av_frame_free(&src);
289  return NULL;
290  }
291 
292  err = av_hwframe_map(dst, src, ctx->mode);
293  if (err) {
294  av_log(avctx, AV_LOG_ERROR, "Failed to map frame to "
295  "software: %d.\n", err);
296  av_frame_free(&src);
297  av_frame_free(&dst);
298  return NULL;
299  }
300 
301  av_frame_free(&src);
302  return dst;
303  } else {
305  }
306 }
307 
309 {
310  AVFilterContext *avctx = link->dst;
311  AVFilterLink *outlink = avctx->outputs[0];
312  HWMapContext *ctx = avctx->priv;
313  AVFrame *map = NULL;
314  int err;
315 
316  av_log(ctx, AV_LOG_DEBUG, "Filter input: %s, %ux%u (%"PRId64").\n",
317  av_get_pix_fmt_name(input->format),
318  input->width, input->height, input->pts);
319 
320  map = av_frame_alloc();
321  if (!map) {
322  err = AVERROR(ENOMEM);
323  goto fail;
324  }
325 
326  map->format = outlink->format;
327  map->hw_frames_ctx = av_buffer_ref(ctx->hwframes_ref);
328  if (!map->hw_frames_ctx) {
329  err = AVERROR(ENOMEM);
330  goto fail;
331  }
332 
333  if (ctx->reverse && !input->hw_frames_ctx) {
334  // If we mapped backwards from hardware to software, we need
335  // to attach the hardware frame context to the input frame to
336  // make the mapping visible to av_hwframe_map().
337  input->hw_frames_ctx = av_buffer_ref(ctx->hwframes_ref);
338  if (!input->hw_frames_ctx) {
339  err = AVERROR(ENOMEM);
340  goto fail;
341  }
342  }
343 
344  err = av_hwframe_map(map, input, ctx->mode);
345  if (err < 0) {
346  av_log(avctx, AV_LOG_ERROR, "Failed to map frame: %d.\n", err);
347  goto fail;
348  }
349 
350  err = av_frame_copy_props(map, input);
351  if (err < 0)
352  goto fail;
353 
355 
356  av_log(ctx, AV_LOG_DEBUG, "Filter output: %s, %ux%u (%"PRId64").\n",
357  av_get_pix_fmt_name(map->format),
358  map->width, map->height, map->pts);
359 
360  return ff_filter_frame(outlink, map);
361 
362 fail:
364  av_frame_free(&map);
365  return err;
366 }
367 
369 {
370  HWMapContext *ctx = avctx->priv;
371 
372  av_buffer_unref(&ctx->hwframes_ref);
373 }
374 
375 #define OFFSET(x) offsetof(HWMapContext, x)
376 #define FLAGS (AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM)
377 static const AVOption hwmap_options[] = {
378  { "mode", "Frame mapping mode",
381  0, INT_MAX, FLAGS, .unit = "mode" },
382 
383  { "read", "Mapping should be readable",
384  0, AV_OPT_TYPE_CONST, { .i64 = AV_HWFRAME_MAP_READ },
385  INT_MIN, INT_MAX, FLAGS, .unit = "mode" },
386  { "write", "Mapping should be writeable",
388  INT_MIN, INT_MAX, FLAGS, .unit = "mode" },
389  { "overwrite", "Mapping will always overwrite the entire frame",
391  INT_MIN, INT_MAX, FLAGS, .unit = "mode" },
392  { "direct", "Mapping should not involve any copying",
394  INT_MIN, INT_MAX, FLAGS, .unit = "mode" },
395 
396  { "derive_device", "Derive a new device of this type",
397  OFFSET(derive_device_type), AV_OPT_TYPE_STRING,
398  { .str = NULL }, 0, 0, FLAGS },
399  { "reverse", "Map in reverse (create and allocate in the sink)",
400  OFFSET(reverse), AV_OPT_TYPE_INT,
401  { .i64 = 0 }, 0, 1, FLAGS },
402 
403  { NULL }
404 };
405 
406 AVFILTER_DEFINE_CLASS(hwmap);
407 
408 static const AVFilterPad hwmap_inputs[] = {
409  {
410  .name = "default",
411  .type = AVMEDIA_TYPE_VIDEO,
412  .get_buffer.video = hwmap_get_buffer,
413  .filter_frame = hwmap_filter_frame,
414  },
415 };
416 
417 static const AVFilterPad hwmap_outputs[] = {
418  {
419  .name = "default",
420  .type = AVMEDIA_TYPE_VIDEO,
421  .config_props = hwmap_config_output,
422  },
423 };
424 
426  .name = "hwmap",
427  .description = NULL_IF_CONFIG_SMALL("Map hardware frames"),
428  .uninit = hwmap_uninit,
429  .priv_size = sizeof(HWMapContext),
430  .priv_class = &hwmap_class,
434  .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
435  .flags = AVFILTER_FLAG_HWDEVICE,
436 };
formats
formats
Definition: signature.h:47
ff_get_video_buffer
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:116
HWMapContext::derive_device_type
char * derive_device_type
Definition: vf_hwmap.c:36
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
AV_HWFRAME_MAP_OVERWRITE
@ AV_HWFRAME_MAP_OVERWRITE
The mapped frame will be overwritten completely in subsequent operations, so the current frame data n...
Definition: hwcontext.h:522
hwmap_options
static const AVOption hwmap_options[]
Definition: vf_hwmap.c:377
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1062
HWMapContext
Definition: vf_hwmap.c:30
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3025
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
AVHWFramesContext::format
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
Definition: hwcontext.h:197
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:162
av_hwframe_ctx_init
int av_hwframe_ctx_init(AVBufferRef *ref)
Finalize the context before use.
Definition: hwcontext.c:322
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: filters.h:262
test::height
int height
Definition: vc1dsp.c:40
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
pixdesc.h
w
uint8_t w
Definition: llviddspenc.c:38
av_hwframe_ctx_alloc
AVBufferRef * av_hwframe_ctx_alloc(AVBufferRef *device_ref_in)
Allocate an AVHWFramesContext tied to a given device context.
Definition: hwcontext.c:248
AV_HWDEVICE_TYPE_NONE
@ AV_HWDEVICE_TYPE_NONE
Definition: hwcontext.h:28
AVOption
AVOption.
Definition: opt.h:429
av_hwframe_map
int av_hwframe_map(AVFrame *dst, const AVFrame *src, int flags)
Map a hardware frame.
Definition: hwcontext.c:778
HWMapContext::hwframes_ref
AVBufferRef * hwframes_ref
Definition: vf_hwmap.c:33
av_hwdevice_find_type_by_name
enum AVHWDeviceType av_hwdevice_find_type_by_name(const char *name)
Look up an AVHWDeviceType by name.
Definition: hwcontext.c:102
AVFilterContext::hw_device_ctx
AVBufferRef * hw_device_ctx
For filters which will create hardware frames, sets the device the filter should create them in.
Definition: avfilter.h:539
hwmap_outputs
static const AVFilterPad hwmap_outputs[]
Definition: vf_hwmap.c:417
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:205
AVHWFramesContext::width
int width
The allocated dimensions of the frames in this pool.
Definition: hwcontext.h:217
video.h
HWMapContext::reverse
int reverse
Definition: vf_hwmap.c:37
formats.h
ff_default_get_video_buffer
AVFrame * ff_default_get_video_buffer(AVFilterLink *link, int w, int h)
Definition: video.c:111
AVFilterContext::priv
void * priv
private data for use by the filter
Definition: avfilter.h:472
fail
#define fail()
Definition: checkasm.h:188
AV_PIX_FMT_FLAG_HWACCEL
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
Definition: pixdesc.h:128
frames
if it could not because there are no more frames
Definition: filter_design.txt:266
AVFilterContext::extra_hw_frames
int extra_hw_frames
Sets the number of extra hardware frames which the filter will allocate on its output links for use i...
Definition: avfilter.h:563
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
ff_all_formats
AVFilterFormats * ff_all_formats(enum AVMediaType type)
Return a list of all formats supported by FFmpeg for the given media type.
Definition: formats.c:535
AVFilterPad
A filter pad used for either input or output.
Definition: filters.h:38
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:150
hwmap_uninit
static av_cold void hwmap_uninit(AVFilterContext *avctx)
Definition: vf_hwmap.c:368
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
av_cold
#define av_cold
Definition: attributes.h:90
AVHWFramesContext::height
int height
Definition: hwcontext.h:217
AV_HWFRAME_MAP_READ
@ AV_HWFRAME_MAP_READ
The mapping must be readable.
Definition: hwcontext.h:512
ff_vf_hwmap
const AVFilter ff_vf_hwmap
Definition: vf_hwmap.c:425
ff_formats_ref
int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
Add *ref as a new reference to formats.
Definition: formats.c:678
AVHWDeviceType
AVHWDeviceType
Definition: hwcontext.h:27
filters.h
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
ctx
AVFormatContext * ctx
Definition: movenc.c:49
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: filters.h:263
link
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a link
Definition: filter_design.txt:23
if
if(ret)
Definition: filter_design.txt:179
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
NULL
#define NULL
Definition: coverity.c:32
AVHWFramesContext::sw_format
enum AVPixelFormat sw_format
The pixel format identifying the actual data layout of the hardware frames.
Definition: hwcontext.h:210
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:713
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
hwmap_query_formats
static int hwmap_query_formats(const AVFilterContext *avctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out)
Definition: vf_hwmap.c:40
AVHWFramesContext::device_ref
AVBufferRef * device_ref
A reference to the parent AVHWDeviceContext.
Definition: hwcontext.h:126
AVFilterContext::inputs
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:465
AV_HWFRAME_MAP_WRITE
@ AV_HWFRAME_MAP_WRITE
The mapping must be writeable.
Definition: hwcontext.h:516
av_hwframe_ctx_create_derived
int av_hwframe_ctx_create_derived(AVBufferRef **derived_frame_ctx, enum AVPixelFormat format, AVBufferRef *derived_device_ctx, AVBufferRef *source_frame_ctx, int flags)
Create and initialise an AVHWFramesContext as a mapping of another existing AVHWFramesContext on a di...
Definition: hwcontext.c:856
AVFilterFormatsConfig
Lists of formats / etc.
Definition: avfilter.h:111
ff_filter_link
static FilterLink * ff_filter_link(AVFilterLink *link)
Definition: filters.h:197
FF_FILTER_FLAG_HWFRAME_AWARE
#define FF_FILTER_FLAG_HWFRAME_AWARE
The filter is aware of hardware frames, and any hardware frame context should not be automatically pr...
Definition: filters.h:206
source
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a source
Definition: filter_design.txt:255
test::width
int width
Definition: vc1dsp.c:39
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:94
HWMapContext::mode
int mode
Definition: vf_hwmap.c:35
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:83
AVFILTER_FLAG_HWDEVICE
#define AVFILTER_FLAG_HWDEVICE
The filter can create hardware frames using AVFilterContext.hw_device_ctx.
Definition: avfilter.h:173
buffer.h
input
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some input
Definition: filter_design.txt:172
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(hwmap)
OFFSET
#define OFFSET(x)
Definition: vf_hwmap.c:375
av_hwdevice_ctx_create_derived
int av_hwdevice_ctx_create_derived(AVBufferRef **dst_ref_ptr, enum AVHWDeviceType type, AVBufferRef *src_ref, int flags)
Create a new device of the specified type from an existing device.
Definition: hwcontext.c:703
log.h
FILTER_QUERY_FUNC2
#define FILTER_QUERY_FUNC2(func)
Definition: filters.h:239
AVFilterPad::name
const char * name
Pad name.
Definition: filters.h:44
AVFilter
Filter definition.
Definition: avfilter.h:201
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:115
ret
ret
Definition: filter_design.txt:187
FLAGS
#define FLAGS
Definition: vf_hwmap.c:376
mode
mode
Definition: ebur128.h:83
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
avfilter.h
AV_HWFRAME_MAP_DIRECT
@ AV_HWFRAME_MAP_DIRECT
The mapping must be direct.
Definition: hwcontext.h:528
AVFilterContext
An instance of a filter.
Definition: avfilter.h:457
AVHWFramesContext::initial_pool_size
int initial_pool_size
Initial size of the frame pool.
Definition: hwcontext.h:187
desc
const char * desc
Definition: libsvtav1.c:79
hwmap_filter_frame
static int hwmap_filter_frame(AVFilterLink *link, AVFrame *input)
Definition: vf_hwmap.c:308
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
map
const VDPAUPixFmtMap * map
Definition: hwcontext_vdpau.c:71
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Underlying C type is unsigned int.
Definition: opt.h:255
hwcontext.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
h
h
Definition: vp9dsp_template.c:2070
hwmap_config_output
static int hwmap_config_output(AVFilterLink *outlink)
Definition: vf_hwmap.c:55
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Underlying C type is a uint8_t* that is either NULL or points to a C string allocated with the av_mal...
Definition: opt.h:276
hwmap_inputs
static const AVFilterPad hwmap_inputs[]
Definition: vf_hwmap.c:408
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
hwmap_get_buffer
static AVFrame * hwmap_get_buffer(AVFilterLink *inlink, int w, int h)
Definition: vf_hwmap.c:268
src
#define src
Definition: vp8dsp.c:248
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:2945
AVFilterContext::outputs
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:469