FFmpeg  4.4.5
vf_extractplanes.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2013 Paul B Mahol
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include "libavutil/avstring.h"
22 #include "libavutil/imgutils.h"
23 #include "libavutil/opt.h"
24 #include "libavutil/pixdesc.h"
25 
26 #include "avfilter.h"
27 #include "drawutils.h"
28 #include "filters.h"
29 #include "internal.h"
30 
31 #define PLANE_R 0x01
32 #define PLANE_G 0x02
33 #define PLANE_B 0x04
34 #define PLANE_A 0x08
35 #define PLANE_Y 0x10
36 #define PLANE_U 0x20
37 #define PLANE_V 0x40
38 
39 typedef struct ExtractPlanesContext {
40  const AVClass *class;
42  int map[4];
43  int linesize[4];
44  int is_packed;
45  int depth;
46  int step;
48 
49 #define OFFSET(x) offsetof(ExtractPlanesContext, x)
50 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
51 static const AVOption extractplanes_options[] = {
52  { "planes", "set planes", OFFSET(requested_planes), AV_OPT_TYPE_FLAGS, {.i64=1}, 1, 0xff, FLAGS, "flags"},
53  { "y", "set luma plane", 0, AV_OPT_TYPE_CONST, {.i64=PLANE_Y}, 0, 0, FLAGS, "flags"},
54  { "u", "set u plane", 0, AV_OPT_TYPE_CONST, {.i64=PLANE_U}, 0, 0, FLAGS, "flags"},
55  { "v", "set v plane", 0, AV_OPT_TYPE_CONST, {.i64=PLANE_V}, 0, 0, FLAGS, "flags"},
56  { "r", "set red plane", 0, AV_OPT_TYPE_CONST, {.i64=PLANE_R}, 0, 0, FLAGS, "flags"},
57  { "g", "set green plane", 0, AV_OPT_TYPE_CONST, {.i64=PLANE_G}, 0, 0, FLAGS, "flags"},
58  { "b", "set blue plane", 0, AV_OPT_TYPE_CONST, {.i64=PLANE_B}, 0, 0, FLAGS, "flags"},
59  { "a", "set alpha plane", 0, AV_OPT_TYPE_CONST, {.i64=PLANE_A}, 0, 0, FLAGS, "flags"},
60  { NULL }
61 };
62 
63 AVFILTER_DEFINE_CLASS(extractplanes);
64 
65 #define EIGHTBIT_FORMATS \
66  AV_PIX_FMT_YUV410P, \
67  AV_PIX_FMT_YUV411P, \
68  AV_PIX_FMT_YUV440P, \
69  AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, \
70  AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA422P, \
71  AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, \
72  AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P, \
73  AV_PIX_FMT_YUVJ411P, \
74  AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVA444P, \
75  AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY8A, \
76  AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24, \
77  AV_PIX_FMT_RGBA, AV_PIX_FMT_BGRA, \
78  AV_PIX_FMT_ARGB, AV_PIX_FMT_ABGR, \
79  AV_PIX_FMT_RGB0, AV_PIX_FMT_BGR0, \
80  AV_PIX_FMT_0RGB, AV_PIX_FMT_0BGR, \
81  AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP
82 
83 #define HIGHDEPTH_FORMATS(suf) \
84  AV_PIX_FMT_YA16##suf, AV_PIX_FMT_GRAY16##suf, \
85  AV_PIX_FMT_YUV420P16##suf, AV_PIX_FMT_YUVA420P16##suf, \
86  AV_PIX_FMT_YUV422P16##suf, AV_PIX_FMT_YUVA422P16##suf, \
87  AV_PIX_FMT_YUV444P16##suf, AV_PIX_FMT_YUVA444P16##suf, \
88  AV_PIX_FMT_RGB48##suf, AV_PIX_FMT_BGR48##suf, \
89  AV_PIX_FMT_RGBA64##suf, AV_PIX_FMT_BGRA64##suf, \
90  AV_PIX_FMT_GBRP16##suf, AV_PIX_FMT_GBRAP16##suf, \
91  AV_PIX_FMT_YUV420P10##suf, \
92  AV_PIX_FMT_YUV422P10##suf, \
93  AV_PIX_FMT_YUV444P10##suf, \
94  AV_PIX_FMT_YUV440P10##suf, \
95  AV_PIX_FMT_YUVA420P10##suf, \
96  AV_PIX_FMT_YUVA422P10##suf, \
97  AV_PIX_FMT_YUVA444P10##suf, \
98  AV_PIX_FMT_YUV420P12##suf, \
99  AV_PIX_FMT_YUV422P12##suf, \
100  AV_PIX_FMT_YUV444P12##suf, \
101  AV_PIX_FMT_YUV440P12##suf, \
102  AV_PIX_FMT_YUVA422P12##suf, \
103  AV_PIX_FMT_YUVA444P12##suf, \
104  AV_PIX_FMT_GBRP10##suf, AV_PIX_FMT_GBRAP10##suf, \
105  AV_PIX_FMT_GBRP12##suf, AV_PIX_FMT_GBRAP12##suf, \
106  AV_PIX_FMT_YUV420P9##suf, \
107  AV_PIX_FMT_YUV422P9##suf, \
108  AV_PIX_FMT_YUV444P9##suf, \
109  AV_PIX_FMT_YUVA420P9##suf, \
110  AV_PIX_FMT_YUVA422P9##suf, \
111  AV_PIX_FMT_YUVA444P9##suf, \
112  AV_PIX_FMT_GBRP9##suf, \
113  AV_PIX_FMT_GBRP14##suf, \
114  AV_PIX_FMT_YUV420P14##suf, \
115  AV_PIX_FMT_YUV422P14##suf, \
116  AV_PIX_FMT_YUV444P14##suf
117 
118 #define FLOAT_FORMATS(suf) \
119  AV_PIX_FMT_GRAYF32##suf, \
120  AV_PIX_FMT_GBRPF32##suf, AV_PIX_FMT_GBRAPF32##suf \
121 
123 {
124  static const enum AVPixelFormat in_pixfmts_le[] = {
126  HIGHDEPTH_FORMATS(LE),
127  FLOAT_FORMATS(LE),
129  };
130  static const enum AVPixelFormat in_pixfmts_be[] = {
132  HIGHDEPTH_FORMATS(BE),
133  FLOAT_FORMATS(BE),
135  };
136  static const enum AVPixelFormat out8_pixfmts[] = { AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE };
137  static const enum AVPixelFormat out9le_pixfmts[] = { AV_PIX_FMT_GRAY9LE, AV_PIX_FMT_NONE };
138  static const enum AVPixelFormat out9be_pixfmts[] = { AV_PIX_FMT_GRAY9BE, AV_PIX_FMT_NONE };
139  static const enum AVPixelFormat out10le_pixfmts[] = { AV_PIX_FMT_GRAY10LE, AV_PIX_FMT_NONE };
140  static const enum AVPixelFormat out10be_pixfmts[] = { AV_PIX_FMT_GRAY10BE, AV_PIX_FMT_NONE };
141  static const enum AVPixelFormat out12le_pixfmts[] = { AV_PIX_FMT_GRAY12LE, AV_PIX_FMT_NONE };
142  static const enum AVPixelFormat out12be_pixfmts[] = { AV_PIX_FMT_GRAY12BE, AV_PIX_FMT_NONE };
143  static const enum AVPixelFormat out14le_pixfmts[] = { AV_PIX_FMT_GRAY14LE, AV_PIX_FMT_NONE };
144  static const enum AVPixelFormat out14be_pixfmts[] = { AV_PIX_FMT_GRAY14BE, AV_PIX_FMT_NONE };
145  static const enum AVPixelFormat out16le_pixfmts[] = { AV_PIX_FMT_GRAY16LE, AV_PIX_FMT_NONE };
146  static const enum AVPixelFormat out16be_pixfmts[] = { AV_PIX_FMT_GRAY16BE, AV_PIX_FMT_NONE };
147  static const enum AVPixelFormat out32le_pixfmts[] = { AV_PIX_FMT_GRAYF32LE, AV_PIX_FMT_NONE };
148  static const enum AVPixelFormat out32be_pixfmts[] = { AV_PIX_FMT_GRAYF32BE, AV_PIX_FMT_NONE };
149  const enum AVPixelFormat *out_pixfmts, *in_pixfmts;
150  const AVPixFmtDescriptor *desc;
151  AVFilterFormats *avff;
152  int i, ret, depth = 0, be = 0;
153 
154  if (!ctx->inputs[0]->incfg.formats ||
155  !ctx->inputs[0]->incfg.formats->nb_formats) {
156  return AVERROR(EAGAIN);
157  }
158 
159  avff = ctx->inputs[0]->incfg.formats;
160  desc = av_pix_fmt_desc_get(avff->formats[0]);
161  depth = desc->comp[0].depth;
162  be = desc->flags & AV_PIX_FMT_FLAG_BE;
163  if (be) {
164  in_pixfmts = in_pixfmts_be;
165  } else {
166  in_pixfmts = in_pixfmts_le;
167  }
168  if (!ctx->inputs[0]->outcfg.formats)
169  if ((ret = ff_formats_ref(ff_make_format_list(in_pixfmts), &ctx->inputs[0]->outcfg.formats)) < 0)
170  return ret;
171 
172  for (i = 1; i < avff->nb_formats; i++) {
173  desc = av_pix_fmt_desc_get(avff->formats[i]);
174  if (depth != desc->comp[0].depth ||
175  be != (desc->flags & AV_PIX_FMT_FLAG_BE)) {
176  return AVERROR(EAGAIN);
177  }
178  }
179 
180  if (depth == 8)
181  out_pixfmts = out8_pixfmts;
182  else if (!be && depth == 9)
183  out_pixfmts = out9le_pixfmts;
184  else if (be && depth == 9)
185  out_pixfmts = out9be_pixfmts;
186  else if (!be && depth == 10)
187  out_pixfmts = out10le_pixfmts;
188  else if (be && depth == 10)
189  out_pixfmts = out10be_pixfmts;
190  else if (!be && depth == 12)
191  out_pixfmts = out12le_pixfmts;
192  else if (be && depth == 12)
193  out_pixfmts = out12be_pixfmts;
194  else if (!be && depth == 14)
195  out_pixfmts = out14le_pixfmts;
196  else if (be && depth == 14)
197  out_pixfmts = out14be_pixfmts;
198  else if (be && depth == 16)
199  out_pixfmts = out16be_pixfmts;
200  else if (!be && depth == 16)
201  out_pixfmts = out16le_pixfmts;
202  else if (be && depth == 32)
203  out_pixfmts = out32be_pixfmts;
204  else
205  out_pixfmts = out32le_pixfmts;
206 
207  for (i = 0; i < ctx->nb_outputs; i++)
208  if ((ret = ff_formats_ref(ff_make_format_list(out_pixfmts), &ctx->outputs[i]->incfg.formats)) < 0)
209  return ret;
210  return 0;
211 }
212 
213 static int config_input(AVFilterLink *inlink)
214 {
215  AVFilterContext *ctx = inlink->dst;
216  ExtractPlanesContext *s = ctx->priv;
218  int plane_avail, ret, i;
219  uint8_t rgba_map[4];
220 
221  plane_avail = ((desc->flags & AV_PIX_FMT_FLAG_RGB) ? PLANE_R|PLANE_G|PLANE_B :
222  PLANE_Y |
223  ((desc->nb_components > 2) ? PLANE_U|PLANE_V : 0)) |
224  ((desc->flags & AV_PIX_FMT_FLAG_ALPHA) ? PLANE_A : 0);
225  if (s->requested_planes & ~plane_avail) {
226  av_log(ctx, AV_LOG_ERROR, "Requested planes not available.\n");
227  return AVERROR(EINVAL);
228  }
229  if ((ret = av_image_fill_linesizes(s->linesize, inlink->format, inlink->w)) < 0)
230  return ret;
231 
232  s->depth = desc->comp[0].depth >> 3;
233  s->step = av_get_padded_bits_per_pixel(desc) >> 3;
234  s->is_packed = !(desc->flags & AV_PIX_FMT_FLAG_PLANAR) &&
235  (desc->nb_components > 1);
236  if (desc->flags & AV_PIX_FMT_FLAG_RGB) {
237  ff_fill_rgba_map(rgba_map, inlink->format);
238  for (i = 0; i < 4; i++)
239  s->map[i] = rgba_map[s->map[i]];
240  }
241 
242  return 0;
243 }
244 
245 static int config_output(AVFilterLink *outlink)
246 {
247  AVFilterContext *ctx = outlink->src;
248  AVFilterLink *inlink = ctx->inputs[0];
249  ExtractPlanesContext *s = ctx->priv;
251  const int output = outlink->srcpad - ctx->output_pads;
252 
253  if (s->map[output] == 1 || s->map[output] == 2) {
254  outlink->h = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
255  outlink->w = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
256  }
257 
258  return 0;
259 }
260 
261 static void extract_from_packed(uint8_t *dst, int dst_linesize,
262  const uint8_t *src, int src_linesize,
263  int width, int height,
264  int depth, int step, int comp)
265 {
266  int x, y;
267 
268  for (y = 0; y < height; y++) {
269  switch (depth) {
270  case 1:
271  for (x = 0; x < width; x++)
272  dst[x] = src[x * step + comp];
273  break;
274  case 2:
275  for (x = 0; x < width; x++) {
276  dst[x * 2 ] = src[x * step + comp * 2 ];
277  dst[x * 2 + 1] = src[x * step + comp * 2 + 1];
278  }
279  break;
280  }
281  dst += dst_linesize;
282  src += src_linesize;
283  }
284 }
285 
286 static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
287 {
288  AVFilterContext *ctx = inlink->dst;
289  ExtractPlanesContext *s = ctx->priv;
290  int i, eof = 0, ret = 0;
291 
292  for (i = 0; i < ctx->nb_outputs; i++) {
293  AVFilterLink *outlink = ctx->outputs[i];
294  const int idx = s->map[i];
295  AVFrame *out;
296 
297  if (ff_outlink_get_status(outlink))
298  continue;
299 
300  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
301  if (!out) {
302  ret = AVERROR(ENOMEM);
303  break;
304  }
306 
307  if (s->is_packed) {
308  extract_from_packed(out->data[0], out->linesize[0],
309  frame->data[0], frame->linesize[0],
310  outlink->w, outlink->h,
311  s->depth,
312  s->step, idx);
313  } else {
314  av_image_copy_plane(out->data[0], out->linesize[0],
315  frame->data[idx], frame->linesize[idx],
316  s->linesize[idx], outlink->h);
317  }
318 
319  ret = ff_filter_frame(outlink, out);
320  if (ret == AVERROR_EOF)
321  eof++;
322  else if (ret < 0)
323  break;
324  }
326 
327  if (eof == ctx->nb_outputs)
328  ret = AVERROR_EOF;
329  else if (ret == AVERROR_EOF)
330  ret = 0;
331  return ret;
332 }
333 
335 {
336  ExtractPlanesContext *s = ctx->priv;
337  int planes = (s->requested_planes & 0xf) | (s->requested_planes >> 4);
338  int i, ret;
339 
340  for (i = 0; i < 4; i++) {
341  char *name;
342  AVFilterPad pad = { 0 };
343 
344  if (!(planes & (1 << i)))
345  continue;
346 
347  name = av_asprintf("out%d", ctx->nb_outputs);
348  if (!name)
349  return AVERROR(ENOMEM);
350  s->map[ctx->nb_outputs] = i;
351  pad.name = name;
352  pad.type = AVMEDIA_TYPE_VIDEO;
354 
355  if ((ret = ff_insert_outpad(ctx, ctx->nb_outputs, &pad)) < 0) {
356  av_freep(&pad.name);
357  return ret;
358  }
359  }
360 
361  return 0;
362 }
363 
365 {
366  int i;
367 
368  for (i = 0; i < ctx->nb_outputs; i++)
369  av_freep(&ctx->output_pads[i].name);
370 }
371 
373  {
374  .name = "default",
375  .type = AVMEDIA_TYPE_VIDEO,
376  .filter_frame = filter_frame,
377  .config_props = config_input,
378  },
379  { NULL }
380 };
381 
383  .name = "extractplanes",
384  .description = NULL_IF_CONFIG_SMALL("Extract planes as grayscale frames."),
385  .priv_size = sizeof(ExtractPlanesContext),
386  .priv_class = &extractplanes_class,
387  .init = init,
388  .uninit = uninit,
391  .outputs = NULL,
393 };
394 
395 #if CONFIG_ALPHAEXTRACT_FILTER
396 
397 static av_cold int init_alphaextract(AVFilterContext *ctx)
398 {
399  ExtractPlanesContext *s = ctx->priv;
400 
401  s->requested_planes = PLANE_A;
402 
403  return init(ctx);
404 }
405 
407  .name = "alphaextract",
408  .description = NULL_IF_CONFIG_SMALL("Extract an alpha channel as a "
409  "grayscale image component."),
410  .priv_size = sizeof(ExtractPlanesContext),
411  .init = init_alphaextract,
412  .uninit = uninit,
415  .outputs = NULL,
417 };
418 #endif /* CONFIG_ALPHAEXTRACT_FILTER */
static const AVFilterPad inputs[]
Definition: af_acontrast.c:193
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
AVFilter ff_vf_alphaextract
#define av_cold
Definition: attributes.h:88
uint8_t
int ff_outlink_get_status(AVFilterLink *link)
Get the status on an output link.
Definition: avfilter.c:1643
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1096
Main libavfilter public API header.
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:113
#define flags(name, subs,...)
Definition: cbs_av1.c:572
#define s(width, name)
Definition: cbs_vp9.c:257
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
#define NULL
Definition: coverity.c:32
static AVFrame * frame
int ff_fill_rgba_map(uint8_t *rgba_map, enum AVPixelFormat pix_fmt)
Definition: drawutils.c:35
misc drawing utilities
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:85
int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
Add ref as a new reference to formats.
Definition: formats.c:466
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:286
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
@ AV_OPT_TYPE_FLAGS
Definition: opt.h:224
#define AVFILTER_FLAG_DYNAMIC_OUTPUTS
The number of the filter outputs is not determined just by AVFilter.outputs.
Definition: avfilter.h:112
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define AVERROR(e)
Definition: error.h:43
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:658
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
void av_image_copy_plane(uint8_t *dst, int dst_linesize, const uint8_t *src, int src_linesize, int bytewidth, int height)
Copy image plane from src to dst.
Definition: imgutils.c:373
int av_image_fill_linesizes(int linesizes[4], enum AVPixelFormat pix_fmt, int width)
Fill plane linesizes for an image with pixel format pix_fmt and width width.
Definition: imgutils.c:89
misc image utilities
int i
Definition: input.c:407
static int ff_insert_outpad(AVFilterContext *f, unsigned index, AVFilterPad *p)
Insert a new output pad for the filter.
Definition: internal.h:248
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
const char * desc
Definition: libsvtav1.c:79
static const struct @322 planes[]
AVOptions.
int av_get_padded_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
Return the number of bits per pixel for the pixel format described by pixdesc, including any padding ...
Definition: pixdesc.c:2538
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
Definition: pixdesc.h:179
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
Definition: pixdesc.h:148
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
Definition: pixdesc.h:144
#define AV_PIX_FMT_FLAG_BE
Pixel format is big-endian.
Definition: pixdesc.h:128
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
@ AV_PIX_FMT_GRAY16BE
Y , 16bpp, big-endian.
Definition: pixfmt.h:97
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
@ AV_PIX_FMT_GRAY10LE
Y , 10bpp, little-endian.
Definition: pixfmt.h:298
@ AV_PIX_FMT_GRAYF32LE
IEEE-754 single precision Y, 32bpp, little-endian.
Definition: pixfmt.h:341
@ AV_PIX_FMT_GRAY12LE
Y , 12bpp, little-endian.
Definition: pixfmt.h:296
@ AV_PIX_FMT_GRAY12BE
Y , 12bpp, big-endian.
Definition: pixfmt.h:295
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
@ AV_PIX_FMT_GRAY14LE
Y , 14bpp, little-endian.
Definition: pixfmt.h:338
@ AV_PIX_FMT_GRAY9BE
Y , 9bpp, big-endian.
Definition: pixfmt.h:315
@ AV_PIX_FMT_GRAYF32BE
IEEE-754 single precision Y, 32bpp, big-endian.
Definition: pixfmt.h:340
@ AV_PIX_FMT_GRAY16LE
Y , 16bpp, little-endian.
Definition: pixfmt.h:98
@ AV_PIX_FMT_GRAY9LE
Y , 9bpp, little-endian.
Definition: pixfmt.h:316
@ AV_PIX_FMT_GRAY10BE
Y , 10bpp, big-endian.
Definition: pixfmt.h:297
@ AV_PIX_FMT_GRAY14BE
Y , 14bpp, big-endian.
Definition: pixfmt.h:337
const char * name
Definition: qsvenc.c:46
Describe the class of an AVClass context structure.
Definition: log.h:67
An instance of a filter.
Definition: avfilter.h:341
A list of supported formats for one end of a filter link.
Definition: formats.h:65
int * formats
list of media formats
Definition: formats.h:67
unsigned nb_formats
number of formats
Definition: formats.h:66
A filter pad used for either input or output.
Definition: internal.h:54
int(* config_props)(AVFilterLink *link)
Link configuration callback.
Definition: internal.h:118
enum AVMediaType type
AVFilterPad type.
Definition: internal.h:65
const char * name
Pad name.
Definition: internal.h:60
Filter definition.
Definition: avfilter.h:145
const char * name
Filter name.
Definition: avfilter.h:149
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:349
AVOption.
Definition: opt.h:248
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
#define av_freep(p)
#define av_log(a,...)
#define src
Definition: vp8dsp.c:255
FILE * out
Definition: movenc.c:54
AVFormatContext * ctx
Definition: movenc.c:48
#define height
#define width
#define PLANE_B
#define PLANE_R
#define PLANE_Y
AVFILTER_DEFINE_CLASS(extractplanes)
static const AVOption extractplanes_options[]
#define PLANE_U
static const AVFilterPad extractplanes_inputs[]
#define HIGHDEPTH_FORMATS(suf)
static int query_formats(AVFilterContext *ctx)
static int config_input(AVFilterLink *inlink)
static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
#define FLAGS
#define EIGHTBIT_FORMATS
static void extract_from_packed(uint8_t *dst, int dst_linesize, const uint8_t *src, int src_linesize, int width, int height, int depth, int step, int comp)
AVFilter ff_vf_extractplanes
#define FLOAT_FORMATS(suf)
#define PLANE_G
static av_cold int init(AVFilterContext *ctx)
static av_cold void uninit(AVFilterContext *ctx)
#define OFFSET(x)
static int config_output(AVFilterLink *outlink)
#define PLANE_V
#define PLANE_A
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:104