FFmpeg
vf_chromakey.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015 Timo Rothenpieler <timo@rothenpieler.org>
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/opt.h"
22 #include "libavutil/imgutils.h"
23 #include "libavutil/intreadwrite.h"
24 #include "avfilter.h"
25 #include "formats.h"
26 #include "internal.h"
27 #include "video.h"
28 
29 typedef struct ChromakeyContext {
30  const AVClass *class;
31 
33  uint16_t chromakey_uv[2];
34 
35  float similarity;
36  float blend;
37 
38  int is_yuv;
39  int depth;
40  int mid;
41  int max;
42 
43  int hsub_log2;
44  int vsub_log2;
45 
47  int jobnr, int nb_jobs);
49 
51 {
52  double diff = 0.0;
53  int du, dv, i;
54 
55  for (i = 0; i < 9; ++i) {
56  du = (int)u[i] - ctx->chromakey_uv[0];
57  dv = (int)v[i] - ctx->chromakey_uv[1];
58 
59  diff += sqrt((du * du + dv * dv) / (255.0 * 255.0));
60  }
61 
62  diff /= 9.0;
63 
64  if (ctx->blend > 0.0001) {
65  return av_clipd((diff - ctx->similarity) / ctx->blend, 0.0, 1.0) * 255.0;
66  } else {
67  return (diff > ctx->similarity) ? 255 : 0;
68  }
69 }
70 
71 static uint16_t do_chromakey_pixel16(ChromakeyContext *ctx, uint16_t u[9], uint16_t v[9])
72 {
73  double max = ctx->max;
74  double diff = 0.0;
75  int du, dv, i;
76 
77  for (i = 0; i < 9; ++i) {
78  du = (int)u[i] - ctx->chromakey_uv[0];
79  dv = (int)v[i] - ctx->chromakey_uv[1];
80 
81  diff += sqrt((du * du + dv * dv) / (max * max));
82  }
83 
84  diff /= 9.0;
85 
86  if (ctx->blend > 0.0001) {
87  return av_clipd((diff - ctx->similarity) / ctx->blend, 0.0, 1.0) * max;
88  } else {
89  return (diff > ctx->similarity) ? max : 0;
90  }
91 }
92 
93 static av_always_inline void get_pixel_uv(AVFrame *frame, int hsub_log2, int vsub_log2, int x, int y, uint8_t *u, uint8_t *v)
94 {
95  if (x < 0 || x >= frame->width || y < 0 || y >= frame->height)
96  return;
97 
98  x >>= hsub_log2;
99  y >>= vsub_log2;
100 
101  *u = frame->data[1][frame->linesize[1] * y + x];
102  *v = frame->data[2][frame->linesize[2] * y + x];
103 }
104 
105 static av_always_inline void get_pixel16_uv(AVFrame *frame, int hsub_log2, int vsub_log2, int x, int y, uint16_t *u, uint16_t *v)
106 {
107  if (x < 0 || x >= frame->width || y < 0 || y >= frame->height)
108  return;
109 
110  x >>= hsub_log2;
111  y >>= vsub_log2;
112 
113  *u = AV_RN16(&frame->data[1][frame->linesize[1] * y + 2 * x]);
114  *v = AV_RN16(&frame->data[2][frame->linesize[2] * y + 2 * x]);
115 }
116 
117 static int do_chromakey_slice(AVFilterContext *avctx, void *arg, int jobnr, int nb_jobs)
118 {
119  AVFrame *frame = arg;
120 
121  const int slice_start = (frame->height * jobnr) / nb_jobs;
122  const int slice_end = (frame->height * (jobnr + 1)) / nb_jobs;
123 
124  ChromakeyContext *ctx = avctx->priv;
125 
126  int x, y, xo, yo;
127  uint8_t u[9], v[9];
128 
129  memset(u, ctx->chromakey_uv[0], sizeof(u));
130  memset(v, ctx->chromakey_uv[1], sizeof(v));
131 
132  for (y = slice_start; y < slice_end; ++y) {
133  for (x = 0; x < frame->width; ++x) {
134  for (yo = 0; yo < 3; ++yo) {
135  for (xo = 0; xo < 3; ++xo) {
136  get_pixel_uv(frame, ctx->hsub_log2, ctx->vsub_log2, x + xo - 1, y + yo - 1, &u[yo * 3 + xo], &v[yo * 3 + xo]);
137  }
138  }
139 
140  frame->data[3][frame->linesize[3] * y + x] = do_chromakey_pixel(ctx, u, v);
141  }
142  }
143 
144  return 0;
145 }
146 
147 static int do_chromakey16_slice(AVFilterContext *avctx, void *arg, int jobnr, int nb_jobs)
148 {
149  AVFrame *frame = arg;
150 
151  const int slice_start = (frame->height * jobnr) / nb_jobs;
152  const int slice_end = (frame->height * (jobnr + 1)) / nb_jobs;
153 
154  ChromakeyContext *ctx = avctx->priv;
155 
156  int x, y, xo, yo;
157  uint16_t u[9], v[9];
158 
159  for (int i = 0; i < 9; i++) {
160  u[i] = ctx->chromakey_uv[0];
161  v[i] = ctx->chromakey_uv[1];
162  }
163 
164  for (y = slice_start; y < slice_end; ++y) {
165  for (x = 0; x < frame->width; ++x) {
166  uint16_t *dst = (uint16_t *)(frame->data[3] + frame->linesize[3] * y);
167 
168  for (yo = 0; yo < 3; ++yo) {
169  for (xo = 0; xo < 3; ++xo) {
170  get_pixel16_uv(frame, ctx->hsub_log2, ctx->vsub_log2, x + xo - 1, y + yo - 1, &u[yo * 3 + xo], &v[yo * 3 + xo]);
171  }
172  }
173 
174  dst[x] = do_chromakey_pixel16(ctx, u, v);
175  }
176  }
177 
178  return 0;
179 }
180 
181 static int do_chromahold_slice(AVFilterContext *avctx, void *arg, int jobnr, int nb_jobs)
182 {
183  ChromakeyContext *ctx = avctx->priv;
184  AVFrame *frame = arg;
185  const int slice_start = ((frame->height >> ctx->vsub_log2) * jobnr) / nb_jobs;
186  const int slice_end = ((frame->height >> ctx->vsub_log2) * (jobnr + 1)) / nb_jobs;
187 
188  int x, y, alpha;
189 
190  for (y = slice_start; y < slice_end; ++y) {
191  for (x = 0; x < frame->width >> ctx->hsub_log2; ++x) {
192  int u = frame->data[1][frame->linesize[1] * y + x];
193  int v = frame->data[2][frame->linesize[2] * y + x];
194  double diff;
195  int du, dv;
196 
197  du = u - ctx->chromakey_uv[0];
198  dv = v - ctx->chromakey_uv[1];
199 
200  diff = sqrt((du * du + dv * dv) / (255.0 * 255.0));
201 
202  alpha = diff > ctx->similarity;
203  if (ctx->blend > 0.0001) {
204  double f = 1. - av_clipd((diff - ctx->similarity) / ctx->blend, 0.0, 1.0);
205 
206  frame->data[1][frame->linesize[1] * y + x] = 128 + (u - 128) * f;
207  frame->data[2][frame->linesize[2] * y + x] = 128 + (v - 128) * f;
208  } else if (alpha) {
209  frame->data[1][frame->linesize[1] * y + x] = 128;
210  frame->data[2][frame->linesize[2] * y + x] = 128;
211  }
212  }
213  }
214 
215  return 0;
216 }
217 
218 static int do_chromahold16_slice(AVFilterContext *avctx, void *arg, int jobnr, int nb_jobs)
219 {
220  ChromakeyContext *ctx = avctx->priv;
221  AVFrame *frame = arg;
222  const int slice_start = ((frame->height >> ctx->vsub_log2) * jobnr) / nb_jobs;
223  const int slice_end = ((frame->height >> ctx->vsub_log2) * (jobnr + 1)) / nb_jobs;
224  const int mid = ctx->mid;
225  double max = ctx->max;
226 
227  int x, y, alpha;
228 
229  for (y = slice_start; y < slice_end; ++y) {
230  for (x = 0; x < frame->width >> ctx->hsub_log2; ++x) {
231  int u = AV_RN16(&frame->data[1][frame->linesize[1] * y + 2 * x]);
232  int v = AV_RN16(&frame->data[2][frame->linesize[2] * y + 2 * x]);
233  double diff;
234  int du, dv;
235 
236  du = u - ctx->chromakey_uv[0];
237  dv = v - ctx->chromakey_uv[1];
238 
239  diff = sqrt((du * du + dv * dv) / (max * max));
240 
241  alpha = diff > ctx->similarity;
242  if (ctx->blend > 0.0001) {
243  double f = 1. - av_clipd((diff - ctx->similarity) / ctx->blend, 0.0, 1.0);
244 
245  AV_WN16(&frame->data[1][frame->linesize[1] * y + 2 * x], mid + (u - mid) * f);
246  AV_WN16(&frame->data[2][frame->linesize[2] * y + 2 * x], mid + (v - mid) * f);
247  } else if (alpha) {
248  AV_WN16(&frame->data[1][frame->linesize[1] * y + 2 * x], mid);
249  AV_WN16(&frame->data[2][frame->linesize[2] * y + 2 * x], mid);
250  }
251  }
252  }
253 
254  return 0;
255 }
256 
258 {
259  AVFilterContext *avctx = link->dst;
260  ChromakeyContext *ctx = avctx->priv;
261  int res;
262 
263  if (res = avctx->internal->execute(avctx, ctx->do_slice, frame, NULL, FFMIN(frame->height, ff_filter_get_nb_threads(avctx))))
264  return res;
265 
266  return ff_filter_frame(avctx->outputs[0], frame);
267 }
268 
269 #define FIXNUM(x) lrint((x) * (1 << 10))
270 #define RGB_TO_U(rgb) (((- FIXNUM(0.16874) * rgb[0] - FIXNUM(0.33126) * rgb[1] + FIXNUM(0.50000) * rgb[2] + (1 << 9) - 1) >> 10) + 128)
271 #define RGB_TO_V(rgb) ((( FIXNUM(0.50000) * rgb[0] - FIXNUM(0.41869) * rgb[1] - FIXNUM(0.08131) * rgb[2] + (1 << 9) - 1) >> 10) + 128)
272 
273 static av_cold int config_output(AVFilterLink *outlink)
274 {
276  AVFilterContext *avctx = outlink->src;
277  ChromakeyContext *ctx = avctx->priv;
278  int factor;
279 
280  ctx->depth = desc->comp[0].depth;
281  ctx->mid = 1 << (ctx->depth - 1);
282  ctx->max = (1 << ctx->depth) - 1;
283 
284  factor = 1 << (ctx->depth - 8);
285 
286  if (ctx->is_yuv) {
287  ctx->chromakey_uv[0] = ctx->chromakey_rgba[1] * factor;
288  ctx->chromakey_uv[1] = ctx->chromakey_rgba[2] * factor;
289  } else {
290  ctx->chromakey_uv[0] = RGB_TO_U(ctx->chromakey_rgba) * factor;
291  ctx->chromakey_uv[1] = RGB_TO_V(ctx->chromakey_rgba) * factor;
292  }
293 
294  if (!strcmp(avctx->filter->name, "chromakey")) {
296  } else {
298  }
299 
300  return 0;
301 }
302 
304 {
305  static const enum AVPixelFormat pixel_fmts[] = {
314  };
315 
316  static const enum AVPixelFormat hold_pixel_fmts[] = {
332  AV_PIX_FMT_NONE
333  };
334 
336 
337  formats = ff_make_format_list(!strcmp(avctx->filter->name, "chromahold") ? hold_pixel_fmts : pixel_fmts);
338  if (!formats)
339  return AVERROR(ENOMEM);
340 
341  return ff_set_common_formats(avctx, formats);
342 }
343 
345 {
346  AVFilterContext *avctx = inlink->dst;
347  ChromakeyContext *ctx = avctx->priv;
349 
350  ctx->hsub_log2 = desc->log2_chroma_w;
351  ctx->vsub_log2 = desc->log2_chroma_h;
352 
353  return 0;
354 }
355 
356 static const AVFilterPad chromakey_inputs[] = {
357  {
358  .name = "default",
359  .type = AVMEDIA_TYPE_VIDEO,
360  .needs_writable = 1,
361  .filter_frame = filter_frame,
362  .config_props = config_input,
363  },
364  { NULL }
365 };
366 
367 static const AVFilterPad chromakey_outputs[] = {
368  {
369  .name = "default",
370  .type = AVMEDIA_TYPE_VIDEO,
371  .config_props = config_output,
372  },
373  { NULL }
374 };
375 
376 #define OFFSET(x) offsetof(ChromakeyContext, x)
377 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
378 
379 static const AVOption chromakey_options[] = {
380  { "color", "set the chromakey key color", OFFSET(chromakey_rgba), AV_OPT_TYPE_COLOR, { .str = "black" }, CHAR_MIN, CHAR_MAX, FLAGS },
381  { "similarity", "set the chromakey similarity value", OFFSET(similarity), AV_OPT_TYPE_FLOAT, { .dbl = 0.01 }, 0.01, 1.0, FLAGS },
382  { "blend", "set the chromakey key blend value", OFFSET(blend), AV_OPT_TYPE_FLOAT, { .dbl = 0.0 }, 0.0, 1.0, FLAGS },
383  { "yuv", "color parameter is in yuv instead of rgb", OFFSET(is_yuv), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
384  { NULL }
385 };
386 
387 AVFILTER_DEFINE_CLASS(chromakey);
388 
390  .name = "chromakey",
391  .description = NULL_IF_CONFIG_SMALL("Turns a certain color into transparency. Operates on YUV colors."),
392  .priv_size = sizeof(ChromakeyContext),
393  .priv_class = &chromakey_class,
395  .inputs = chromakey_inputs,
396  .outputs = chromakey_outputs,
398 };
399 
400 static const AVOption chromahold_options[] = {
401  { "color", "set the chromahold key color", OFFSET(chromakey_rgba), AV_OPT_TYPE_COLOR, { .str = "black" }, CHAR_MIN, CHAR_MAX, FLAGS },
402  { "similarity", "set the chromahold similarity value", OFFSET(similarity), AV_OPT_TYPE_FLOAT, { .dbl = 0.01 }, 0.01, 1.0, FLAGS },
403  { "blend", "set the chromahold blend value", OFFSET(blend), AV_OPT_TYPE_FLOAT, { .dbl = 0.0 }, 0.0, 1.0, FLAGS },
404  { "yuv", "color parameter is in yuv instead of rgb", OFFSET(is_yuv), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
405  { NULL }
406 };
407 
408 static const AVFilterPad chromahold_inputs[] = {
409  {
410  .name = "default",
411  .type = AVMEDIA_TYPE_VIDEO,
412  .needs_writable = 1,
413  .filter_frame = filter_frame,
414  .config_props = config_input,
415  },
416  { NULL }
417 };
418 
419 static const AVFilterPad chromahold_outputs[] = {
420  {
421  .name = "default",
422  .type = AVMEDIA_TYPE_VIDEO,
423  .config_props = config_output,
424  },
425  { NULL }
426 };
427 
428 AVFILTER_DEFINE_CLASS(chromahold);
429 
431  .name = "chromahold",
432  .description = NULL_IF_CONFIG_SMALL("Turns a certain color range into gray."),
433  .priv_size = sizeof(ChromakeyContext),
434  .priv_class = &chromahold_class,
436  .inputs = chromahold_inputs,
437  .outputs = chromahold_outputs,
439 };
#define NULL
Definition: coverity.c:32
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:430
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:422
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2522
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
AVOption.
Definition: opt.h:246
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:424
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:397
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:425
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
misc image utilities
Main libavfilter public API header.
const char * desc
Definition: nvenc.c:68
int(* do_slice)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_chromakey.c:46
uint16_t chromakey_uv[2]
Definition: vf_chromakey.c:33
AVFILTER_DEFINE_CLASS(chromakey)
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:391
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283
static const AVOption chromahold_options[]
Definition: vf_chromakey.c:400
static av_always_inline void get_pixel16_uv(AVFrame *frame, int hsub_log2, int vsub_log2, int x, int y, uint16_t *u, uint16_t *v)
Definition: vf_chromakey.c:105
#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
Some filters support a generic "enable" expression option that can be used to enable or disable a fil...
Definition: avfilter.h:125
const char * name
Pad name.
Definition: internal.h:60
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1093
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
uint8_t
#define av_cold
Definition: attributes.h:82
AVOptions.
AVFilter ff_vf_chromahold
Definition: vf_chromakey.c:430
#define f(width, name)
Definition: cbs_vp9.c:255
static const AVFilterPad chromahold_inputs[]
Definition: vf_chromakey.c:408
static const AVFilterPad chromakey_outputs[]
Definition: vf_chromakey.c:367
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:252
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:421
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:400
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:392
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:429
A filter pad used for either input or output.
Definition: internal.h:54
static const AVOption chromakey_options[]
Definition: vf_chromakey.c:379
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:176
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
int width
Definition: frame.h:353
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
A helper for query_formats() which sets all links to the same list of formats.
Definition: formats.c:569
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
static uint8_t do_chromakey_pixel(ChromakeyContext *ctx, uint8_t u[9], uint8_t v[9])
Definition: vf_chromakey.c:50
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
void * priv
private data for use by the filter
Definition: avfilter.h:353
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:116
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:431
const char * arg
Definition: jacosubdec.c:66
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:390
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
static const AVFilterPad chromahold_outputs[]
Definition: vf_chromakey.c:419
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:385
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:802
#define FFMIN(a, b)
Definition: common.h:96
AVFilter ff_vf_chromakey
Definition: vf_chromakey.c:389
#define AV_PIX_FMT_YUVA444P12
Definition: pixfmt.h:428
uint8_t chromakey_rgba[4]
Definition: vf_chromakey.c:32
AVFormatContext * ctx
Definition: movenc.c:48
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 it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
static int do_chromahold16_slice(AVFilterContext *avctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_chromakey.c:218
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:426
static int filter_frame(AVFilterLink *link, AVFrame *frame)
Definition: vf_chromakey.c:257
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:386
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:398
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:395
static int do_chromakey16_slice(AVFilterContext *avctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_chromakey.c:147
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:177
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
static const int16_t alpha[]
Definition: ilbcdata.h:55
#define AV_RN16(p)
Definition: intreadwrite.h:360
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 inputs
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:387
Describe the class of an AVClass context structure.
Definition: log.h:67
Filter definition.
Definition: avfilter.h:144
#define OFFSET(x)
Definition: vf_chromakey.c:376
static const int factor[16]
Definition: vf_pp7.c:75
const char * name
Filter name.
Definition: avfilter.h:148
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:384
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
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:396
static uint16_t do_chromakey_pixel16(ChromakeyContext *ctx, uint16_t u[9], uint16_t v[9])
Definition: vf_chromakey.c:71
#define RGB_TO_U(rgb)
Definition: vf_chromakey.c:270
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AVFilterInternal * internal
An opaque struct for libavfilter internal use.
Definition: avfilter.h:378
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:388
#define FLAGS
Definition: vf_chromakey.c:377
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:394
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
static av_cold int query_formats(AVFilterContext *avctx)
Definition: vf_chromakey.c:303
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
static const AVFilterPad chromakey_inputs[]
Definition: vf_chromakey.c:356
static av_always_inline void get_pixel_uv(AVFrame *frame, int hsub_log2, int vsub_log2, int x, int y, uint8_t *u, uint8_t *v)
Definition: vf_chromakey.c:93
int
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:423
avfilter_execute_func * execute
Definition: internal.h:155
static av_cold int config_input(AVFilterLink *inlink)
Definition: vf_chromakey.c:344
static int do_chromakey_slice(AVFilterContext *avctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_chromakey.c:117
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2036
#define RGB_TO_V(rgb)
Definition: vf_chromakey.c:271
static av_always_inline int diff(const uint32_t a, const uint32_t b)
A list of supported formats for one end of a filter link.
Definition: formats.h:64
An instance of a filter.
Definition: avfilter.h:338
static av_cold int config_output(AVFilterLink *outlink)
Definition: vf_chromakey.c:273
int height
Definition: frame.h:353
#define AV_WN16(p, v)
Definition: intreadwrite.h:372
#define av_always_inline
Definition: attributes.h:39
static int do_chromahold_slice(AVFilterContext *avctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_chromakey.c:181
formats
Definition: signature.h:48
internal API functions
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
int depth
Number of bits in the component.
Definition: pixdesc.h:58
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
const AVFilter * filter
the AVFilter of which this is an instance
Definition: avfilter.h:341
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:399
#define AV_PIX_FMT_YUVA422P12
Definition: pixfmt.h:427