FFmpeg
vf_neighbor.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2012-2013 Oka Motofumi (chikuzen.mo at gmail dot com)
3  * Copyright (c) 2015 Paul B Mahol
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "libavutil/imgutils.h"
23 #include "libavutil/intreadwrite.h"
24 #include "libavutil/pixdesc.h"
25 #include "libavutil/opt.h"
26 #include "avfilter.h"
27 #include "formats.h"
28 #include "internal.h"
29 #include "video.h"
30 
31 typedef struct ThreadData {
32  AVFrame *in, *out;
33 } ThreadData;
34 
35 typedef struct NContext {
36  const AVClass *class;
37  int planeheight[4];
38  int planewidth[4];
39  int nb_planes;
40  int threshold[4];
42 
43  int depth;
44  int max;
45  int bpc;
46 
47  void (*filter)(uint8_t *dst, const uint8_t *p1, int width,
48  int threshold, const uint8_t *coordinates[], int coord,
49  int maxc);
50 } NContext;
51 
53 {
54  static const enum AVPixelFormat pix_fmts[] = {
73  };
74 
75  return ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
76 }
77 
78 static void erosion(uint8_t *dst, const uint8_t *p1, int width,
79  int threshold, const uint8_t *coordinates[], int coord,
80  int maxc)
81 {
82  int x, i;
83 
84  for (x = 0; x < width; x++) {
85  int min = p1[x];
86  int limit = FFMAX(min - threshold, 0);
87 
88  for (i = 0; i < 8; i++) {
89  if (coord & (1 << i)) {
90  min = FFMIN(min, *(coordinates[i] + x));
91  }
92  min = FFMAX(min, limit);
93  }
94 
95  dst[x] = min;
96  }
97 }
98 
99 static void erosion16(uint8_t *dstp, const uint8_t *p1, int width,
100  int threshold, const uint8_t *coordinates[], int coord,
101  int maxc)
102 {
103  uint16_t *dst = (uint16_t *)dstp;
104  int x, i;
105 
106  for (x = 0; x < width; x++) {
107  int min = AV_RN16A(&p1[2 * x]);
108  int limit = FFMAX(min - threshold, 0);
109 
110  for (i = 0; i < 8; i++) {
111  if (coord & (1 << i)) {
112  min = FFMIN(min, AV_RN16A(coordinates[i] + x * 2));
113  }
114  min = FFMAX(min, limit);
115  }
116 
117  dst[x] = min;
118  }
119 }
120 
121 static void dilation(uint8_t *dst, const uint8_t *p1, int width,
122  int threshold, const uint8_t *coordinates[], int coord,
123  int maxc)
124 {
125  int x, i;
126 
127  for (x = 0; x < width; x++) {
128  int max = p1[x];
129  int limit = FFMIN(max + threshold, 255);
130 
131  for (i = 0; i < 8; i++) {
132  if (coord & (1 << i)) {
133  max = FFMAX(max, *(coordinates[i] + x));
134  }
135  max = FFMIN(max, limit);
136  }
137 
138  dst[x] = max;
139  }
140 }
141 
142 static void dilation16(uint8_t *dstp, const uint8_t *p1, int width,
143  int threshold, const uint8_t *coordinates[], int coord,
144  int maxc)
145 {
146  uint16_t *dst = (uint16_t *)dstp;
147  int x, i;
148 
149  for (x = 0; x < width; x++) {
150  int max = AV_RN16A(&p1[x * 2]);
151  int limit = FFMIN(max + threshold, maxc);
152 
153  for (i = 0; i < 8; i++) {
154  if (coord & (1 << i)) {
155  max = FFMAX(max, AV_RN16A(coordinates[i] + x * 2));
156  }
157  max = FFMIN(max, limit);
158  }
159 
160  dst[x] = max;
161  }
162 }
163 
164 static void deflate(uint8_t *dst, const uint8_t *p1, int width,
165  int threshold, const uint8_t *coordinates[], int coord,
166  int maxc)
167 {
168  int x, i;
169 
170  for (x = 0; x < width; x++) {
171  int sum = 0;
172  int limit = FFMAX(p1[x] - threshold, 0);
173 
174  for (i = 0; i < 8; sum += *(coordinates[i++] + x));
175 
176  dst[x] = FFMAX(FFMIN(sum / 8, p1[x]), limit);
177  }
178 }
179 
180 static void deflate16(uint8_t *dstp, const uint8_t *p1, int width,
181  int threshold, const uint8_t *coordinates[], int coord,
182  int maxc)
183 {
184  uint16_t *dst = (uint16_t *)dstp;
185  int x, i;
186 
187  for (x = 0; x < width; x++) {
188  int sum = 0;
189  int limit = FFMAX(AV_RN16A(&p1[2 * x]) - threshold, 0);
190 
191  for (i = 0; i < 8; sum += AV_RN16A(coordinates[i++] + x * 2));
192 
193  dst[x] = FFMAX(FFMIN(sum / 8, AV_RN16A(&p1[2 * x])), limit);
194  }
195 }
196 
197 static void inflate(uint8_t *dst, const uint8_t *p1, int width,
198  int threshold, const uint8_t *coordinates[], int coord,
199  int maxc)
200 {
201  int x, i;
202 
203  for (x = 0; x < width; x++) {
204  int sum = 0;
205  int limit = FFMIN(p1[x] + threshold, 255);
206 
207  for (i = 0; i < 8; sum += *(coordinates[i++] + x));
208 
209  dst[x] = FFMIN(FFMAX(sum / 8, p1[x]), limit);
210  }
211 }
212 
213 static void inflate16(uint8_t *dstp, const uint8_t *p1, int width,
214  int threshold, const uint8_t *coordinates[], int coord,
215  int maxc)
216 {
217  uint16_t *dst = (uint16_t *)dstp;
218  int x, i;
219 
220  for (x = 0; x < width; x++) {
221  int sum = 0;
222  int limit = FFMIN(AV_RN16A(&p1[2 * x]) + threshold, maxc);
223 
224  for (i = 0; i < 8; sum += AV_RN16A(coordinates[i++] + x * 2));
225 
226  dst[x] = FFMIN(FFMAX(sum / 8, AV_RN16A(&p1[x * 2])), limit);
227  }
228 }
229 
231 {
232  AVFilterContext *ctx = inlink->dst;
233  NContext *s = ctx->priv;
235 
236  s->depth = desc->comp[0].depth;
237  s->max = (1 << s->depth) - 1;
238  s->bpc = (s->depth + 7) / 8;
239 
240  s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
241  s->planewidth[0] = s->planewidth[3] = inlink->w;
242  s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
243  s->planeheight[0] = s->planeheight[3] = inlink->h;
244 
246 
247  if (!strcmp(ctx->filter->name, "erosion"))
248  s->filter = s->depth > 8 ? erosion16 : erosion;
249  else if (!strcmp(ctx->filter->name, "dilation"))
250  s->filter = s->depth > 8 ? dilation16 : dilation;
251  else if (!strcmp(ctx->filter->name, "deflate"))
252  s->filter = s->depth > 8 ? deflate16 : deflate;
253  else if (!strcmp(ctx->filter->name, "inflate"))
254  s->filter = s->depth > 8 ? inflate16 : inflate;
255 
256  return 0;
257 }
258 
259 static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
260 {
261  NContext *s = ctx->priv;
262  ThreadData *td = arg;
263  AVFrame *out = td->out;
264  AVFrame *in = td->in;
265  int plane, y;
266 
267  for (plane = 0; plane < s->nb_planes; plane++) {
268  const int bpc = s->bpc;
269  const int threshold = s->threshold[plane];
270  const int stride = in->linesize[plane];
271  const int dstride = out->linesize[plane];
272  const int height = s->planeheight[plane];
273  const int width = s->planewidth[plane];
274  const int slice_start = (height * jobnr) / nb_jobs;
275  const int slice_end = (height * (jobnr+1)) / nb_jobs;
276  const uint8_t *src = (const uint8_t *)in->data[plane] + slice_start * stride;
277  uint8_t *dst = out->data[plane] + slice_start * dstride;
278 
279  if (!threshold) {
280  av_image_copy_plane(dst, dstride, src, stride, width * bpc, slice_end - slice_start);
281  continue;
282  }
283 
284  for (y = slice_start; y < slice_end; y++) {
285  const int nh = y > 0;
286  const int ph = y < height - 1;
287  const uint8_t *coordinates[] = { src - nh * stride, src + 1 * bpc - nh * stride, src + 2 * bpc - nh * stride,
288  src, src + 2 * bpc,
289  src + ph * stride, src + 1 * bpc + ph * stride, src + 2 * bpc + ph * stride};
290 
291  const uint8_t *coordinateslb[] = { src + 1 * bpc - nh * stride, src - nh * stride, src + 1 * bpc - nh * stride,
292  src + 1 * bpc, src + 1 * bpc,
293  src + 1 * bpc + ph * stride, src + ph * stride, src + 1 * bpc + ph * stride};
294 
295  const uint8_t *coordinatesrb[] = { src + (width - 2) * bpc - nh * stride, src + (width - 1) * bpc - nh * stride, src + (width - 2) * bpc - nh * stride,
296  src + (width - 2) * bpc, src + (width - 2) * bpc,
297  src + (width - 2) * bpc + ph * stride, src + (width - 1) * bpc + ph * stride, src + (width - 2) * bpc + ph * stride};
298 
299  s->filter(dst, src, 1, threshold, coordinateslb, s->coordinates, s->max);
300  if (width > 1) {
301  s->filter(dst + 1 * bpc, src + 1 * bpc, width - 2, threshold, coordinates, s->coordinates, s->max);
302  s->filter(dst + (width - 1) * bpc, src + (width - 1) * bpc, 1, threshold, coordinatesrb, s->coordinates, s->max);
303  }
304 
305  src += stride;
306  dst += dstride;
307  }
308  }
309 
310  return 0;
311 }
312 
314 {
315  AVFilterContext *ctx = inlink->dst;
316  AVFilterLink *outlink = ctx->outputs[0];
317  NContext *s = ctx->priv;
318  ThreadData td;
319  AVFrame *out;
320 
321  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
322  if (!out) {
323  av_frame_free(&in);
324  return AVERROR(ENOMEM);
325  }
326  av_frame_copy_props(out, in);
327 
328  td.in = in;
329  td.out = out;
331 
332  av_frame_free(&in);
333  return ff_filter_frame(outlink, out);
334 }
335 
336 static const AVFilterPad neighbor_inputs[] = {
337  {
338  .name = "default",
339  .type = AVMEDIA_TYPE_VIDEO,
340  .filter_frame = filter_frame,
341  .config_props = config_input,
342  },
343  { NULL }
344 };
345 
346 static const AVFilterPad neighbor_outputs[] = {
347  {
348  .name = "default",
349  .type = AVMEDIA_TYPE_VIDEO,
350  },
351  { NULL }
352 };
353 
354 #define OFFSET(x) offsetof(NContext, x)
355 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
356 
357 #define DEFINE_NEIGHBOR_FILTER(name_, description_) \
358 AVFILTER_DEFINE_CLASS(name_); \
359  \
360 AVFilter ff_vf_##name_ = { \
361  .name = #name_, \
362  .description = NULL_IF_CONFIG_SMALL(description_), \
363  .priv_size = sizeof(NContext), \
364  .priv_class = &name_##_class, \
365  .query_formats = query_formats, \
366  .inputs = neighbor_inputs, \
367  .outputs = neighbor_outputs, \
368  .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC| \
369  AVFILTER_FLAG_SLICE_THREADS, \
370 }
371 
372 #if CONFIG_EROSION_FILTER
373 
374 static const AVOption erosion_options[] = {
375  { "threshold0", "set threshold for 1st plane", OFFSET(threshold[0]), AV_OPT_TYPE_INT, {.i64=65535}, 0, 65535, FLAGS },
376  { "threshold1", "set threshold for 2nd plane", OFFSET(threshold[1]), AV_OPT_TYPE_INT, {.i64=65535}, 0, 65535, FLAGS },
377  { "threshold2", "set threshold for 3rd plane", OFFSET(threshold[2]), AV_OPT_TYPE_INT, {.i64=65535}, 0, 65535, FLAGS },
378  { "threshold3", "set threshold for 4th plane", OFFSET(threshold[3]), AV_OPT_TYPE_INT, {.i64=65535}, 0, 65535, FLAGS },
379  { "coordinates", "set coordinates", OFFSET(coordinates), AV_OPT_TYPE_INT, {.i64=255}, 0, 255, FLAGS },
380  { NULL }
381 };
382 
383 DEFINE_NEIGHBOR_FILTER(erosion, "Apply erosion effect.");
384 
385 #endif /* CONFIG_EROSION_FILTER */
386 
387 #if CONFIG_DILATION_FILTER
388 
389 static const AVOption dilation_options[] = {
390  { "threshold0", "set threshold for 1st plane", OFFSET(threshold[0]), AV_OPT_TYPE_INT, {.i64=65535}, 0, 65535, FLAGS },
391  { "threshold1", "set threshold for 2nd plane", OFFSET(threshold[1]), AV_OPT_TYPE_INT, {.i64=65535}, 0, 65535, FLAGS },
392  { "threshold2", "set threshold for 3rd plane", OFFSET(threshold[2]), AV_OPT_TYPE_INT, {.i64=65535}, 0, 65535, FLAGS },
393  { "threshold3", "set threshold for 4th plane", OFFSET(threshold[3]), AV_OPT_TYPE_INT, {.i64=65535}, 0, 65535, FLAGS },
394  { "coordinates", "set coordinates", OFFSET(coordinates), AV_OPT_TYPE_INT, {.i64=255}, 0, 255, FLAGS },
395  { NULL }
396 };
397 
398 DEFINE_NEIGHBOR_FILTER(dilation, "Apply dilation effect.");
399 
400 #endif /* CONFIG_DILATION_FILTER */
401 
402 #if CONFIG_DEFLATE_FILTER
403 
404 static const AVOption deflate_options[] = {
405  { "threshold0", "set threshold for 1st plane", OFFSET(threshold[0]), AV_OPT_TYPE_INT, {.i64=65535}, 0, 65535, FLAGS },
406  { "threshold1", "set threshold for 2nd plane", OFFSET(threshold[1]), AV_OPT_TYPE_INT, {.i64=65535}, 0, 65535, FLAGS },
407  { "threshold2", "set threshold for 3rd plane", OFFSET(threshold[2]), AV_OPT_TYPE_INT, {.i64=65535}, 0, 65535, FLAGS },
408  { "threshold3", "set threshold for 4th plane", OFFSET(threshold[3]), AV_OPT_TYPE_INT, {.i64=65535}, 0, 65535, FLAGS },
409  { NULL }
410 };
411 
412 DEFINE_NEIGHBOR_FILTER(deflate, "Apply deflate effect.");
413 
414 #endif /* CONFIG_DEFLATE_FILTER */
415 
416 #if CONFIG_INFLATE_FILTER
417 
418 static const AVOption inflate_options[] = {
419  { "threshold0", "set threshold for 1st plane", OFFSET(threshold[0]), AV_OPT_TYPE_INT, {.i64=65535}, 0, 65535, FLAGS },
420  { "threshold1", "set threshold for 2nd plane", OFFSET(threshold[1]), AV_OPT_TYPE_INT, {.i64=65535}, 0, 65535, FLAGS },
421  { "threshold2", "set threshold for 3rd plane", OFFSET(threshold[2]), AV_OPT_TYPE_INT, {.i64=65535}, 0, 65535, FLAGS },
422  { "threshold3", "set threshold for 4th plane", OFFSET(threshold[3]), AV_OPT_TYPE_INT, {.i64=65535}, 0, 65535, FLAGS },
423  { NULL }
424 };
425 
426 DEFINE_NEIGHBOR_FILTER(inflate, "Apply inflate effect.");
427 
428 #endif /* CONFIG_INFLATE_FILTER */
#define NULL
Definition: coverity.c:32
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:430
AVFrame * out
Definition: af_adeclick.c:488
int planewidth[4]
Definition: vf_neighbor.c:38
#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_GBRAP10
Definition: pixfmt.h:407
#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
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2562
Main libavfilter public API header.
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:403
#define AV_PIX_FMT_GRAY9
Definition: pixfmt.h:367
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:391
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:99
static void inflate16(uint8_t *dstp, const uint8_t *p1, int width, int threshold, const uint8_t *coordinates[], int coord, int maxc)
Definition: vf_neighbor.c:213
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
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:368
const char * name
Pad name.
Definition: internal.h:60
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:369
static void erosion16(uint8_t *dstp, const uint8_t *p1, int width, int threshold, const uint8_t *coordinates[], int coord, int maxc)
Definition: vf_neighbor.c:99
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
AVOptions.
int threshold[4]
Definition: vf_neighbor.c:40
static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_neighbor.c:259
static void erosion(uint8_t *dst, const uint8_t *p1, int width, int threshold, const uint8_t *coordinates[], int coord, int maxc)
Definition: vf_neighbor.c:78
static void deflate16(uint8_t *dstp, const uint8_t *p1, int width, int threshold, const uint8_t *coordinates[], int coord, int maxc)
Definition: vf_neighbor.c:180
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:421
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:402
int height
Definition: vf_avgblur.c:61
AVFrame * dst
Definition: vf_blend.c:55
int plane
Definition: vf_blend.c:57
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range...
Definition: pixfmt.h:100
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
Definition: pixfmt.h:79
static const AVFilterPad neighbor_outputs[]
Definition: vf_neighbor.c:346
#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
#define FLAGS
Definition: vf_neighbor.c:355
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: vf_neighbor.c:313
A filter pad used for either input or output.
Definition: internal.h:54
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 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
#define td
Definition: regdef.h:70
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
int nb_planes
Definition: vf_neighbor.c:39
BYTE * dstp
Definition: avisynth_c.h:908
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
void * priv
private data for use by the filter
Definition: avfilter.h:353
#define OFFSET(x)
Definition: vf_neighbor.c:354
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:431
const char * arg
Definition: jacosubdec.c:66
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:408
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:390
#define FFMAX(a, b)
Definition: common.h:94
int coordinates
Definition: vf_neighbor.c:41
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:409
const uint8_t * src
Definition: vf_bm3d.c:56
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
static void dilation16(uint8_t *dstp, const uint8_t *p1, int width, int threshold, const uint8_t *coordinates[], int coord, int maxc)
Definition: vf_neighbor.c:142
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:385
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:406
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:802
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:371
#define FFMIN(a, b)
Definition: common.h:96
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:78
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
AVFormatContext * ctx
Definition: movenc.c:48
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:426
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:386
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:405
if(ret)
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:398
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:395
void(* filter)(uint8_t *dst, const uint8_t *p1, int width, int threshold, const uint8_t *coordinates[], int coord, int maxc)
Definition: vf_neighbor.c:47
Used for passing data between threads.
Definition: dsddec.c:64
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
static int query_formats(AVFilterContext *ctx)
Definition: vf_neighbor.c:52
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
#define AV_PIX_FMT_GRAY14
Definition: pixfmt.h:370
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:387
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
Describe the class of an AVClass context structure.
Definition: log.h:67
static void inflate(uint8_t *dst, const uint8_t *p1, int width, int threshold, const uint8_t *coordinates[], int coord, int maxc)
Definition: vf_neighbor.c:197
const char * name
Filter name.
Definition: avfilter.h:148
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:393
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:384
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
AVFrame * min
Definition: vf_threshold.c:74
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:396
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:404
AVFilterInternal * internal
An opaque struct for libavfilter internal use.
Definition: avfilter.h:378
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:388
#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 int config_input(AVFilterLink *inlink)
Definition: vf_neighbor.c:230
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:104
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
Y , 8bpp.
Definition: pixfmt.h:74
int planeheight[4]
Definition: vf_neighbor.c:37
static const AVFilterPad neighbor_inputs[]
Definition: vf_neighbor.c:336
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:215
AVFrame * threshold
Definition: vf_threshold.c:73
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:423
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:80
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
#define DEFINE_NEIGHBOR_FILTER(name_, description_)
Definition: vf_neighbor.c:357
avfilter_execute_func * execute
Definition: internal.h:155
static void deflate(uint8_t *dst, const uint8_t *p1, int width, int threshold, const uint8_t *coordinates[], int coord, int maxc)
Definition: vf_neighbor.c:164
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2036
const AVPixFmtDescriptor * desc
Definition: vf_tonemap.c:196
int depth
Definition: vf_neighbor.c:43
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
Definition: pixfmt.h:258
#define AV_RN16A(p)
Definition: intreadwrite.h:522
An instance of a filter.
Definition: avfilter.h:338
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
AVFrame * in
Definition: af_afftdn.c:1082
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:338
#define stride
AVFilterLink * inlink
Definition: vf_blend.c:56
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
static void dilation(uint8_t *dst, const uint8_t *p1, int width, int threshold, const uint8_t *coordinates[], int coord, int maxc)
Definition: vf_neighbor.c:121
const AVFilter * filter
the AVFilter of which this is an instance
Definition: avfilter.h:341
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:399
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:654
AVFrame * max
Definition: vf_threshold.c:75
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58