FFmpeg  4.2.1
vf_dedot.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2018 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/imgutils.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 "internal.h"
29 #include "video.h"
30 
31 typedef struct DedotContext {
32  const AVClass *class;
33  int m;
34  float lt;
35  float tl;
36  float tc;
37  float ct;
38 
40  int depth;
41  int max;
42  int luma2d;
43  int lumaT;
44  int chromaT1;
45  int chromaT2;
46 
47  int eof;
49  int nb_planes;
50  int planewidth[4];
51  int planeheight[4];
52 
54 
55  int (*dedotcrawl)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
56  int (*derainbow)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
57 } DedotContext;
58 
60 {
61  static const enum AVPixelFormat pixel_fmts[] = {
76  };
78  if (!formats)
79  return AVERROR(ENOMEM);
80  return ff_set_common_formats(ctx, formats);
81 }
82 
83 #define DEFINE_DEDOTCRAWL(name, type, div) \
84 static int dedotcrawl##name(AVFilterContext *ctx, void *arg, \
85  int jobnr, int nb_jobs) \
86 { \
87  DedotContext *s = ctx->priv; \
88  AVFrame *out = arg; \
89  int src_linesize = s->frames[2]->linesize[0] / div; \
90  int dst_linesize = out->linesize[0] / div; \
91  int p0_linesize = s->frames[0]->linesize[0] / div; \
92  int p1_linesize = s->frames[1]->linesize[0] / div; \
93  int p3_linesize = s->frames[3]->linesize[0] / div; \
94  int p4_linesize = s->frames[4]->linesize[0] / div; \
95  const int h = s->planeheight[0]; \
96  int slice_start = (h * jobnr) / nb_jobs; \
97  int slice_end = (h * (jobnr+1)) / nb_jobs; \
98  type *p0 = (type *)s->frames[0]->data[0]; \
99  type *p1 = (type *)s->frames[1]->data[0]; \
100  type *p3 = (type *)s->frames[3]->data[0]; \
101  type *p4 = (type *)s->frames[4]->data[0]; \
102  type *src = (type *)s->frames[2]->data[0]; \
103  type *dst = (type *)out->data[0]; \
104  const int luma2d = s->luma2d; \
105  const int lumaT = s->lumaT; \
106  \
107  if (!slice_start) { \
108  slice_start++; \
109  } \
110  p0 += p0_linesize * slice_start; \
111  p1 += p1_linesize * slice_start; \
112  p3 += p3_linesize * slice_start; \
113  p4 += p4_linesize * slice_start; \
114  src += src_linesize * slice_start; \
115  dst += dst_linesize * slice_start; \
116  if (slice_end == h) { \
117  slice_end--; \
118  } \
119  for (int y = slice_start; y < slice_end; y++) { \
120  for (int x = 1; x < s->planewidth[0] - 1; x++) { \
121  int above = src[x - src_linesize]; \
122  int bellow = src[x + src_linesize]; \
123  int cur = src[x]; \
124  int left = src[x - 1]; \
125  int right = src[x + 1]; \
126  \
127  if (FFABS(above + bellow - 2 * cur) <= luma2d && \
128  FFABS(left + right - 2 * cur) <= luma2d) \
129  continue; \
130  \
131  if (FFABS(cur - p0[x]) <= lumaT && \
132  FFABS(cur - p4[x]) <= lumaT && \
133  FFABS(p1[x] - p3[x]) <= lumaT) { \
134  int diff1 = FFABS(cur - p1[x]); \
135  int diff2 = FFABS(cur - p3[x]); \
136  \
137  if (diff1 < diff2) \
138  dst[x] = (src[x] + p1[x] + 1) >> 1; \
139  else \
140  dst[x] = (src[x] + p3[x] + 1) >> 1; \
141  } \
142  } \
143  \
144  dst += dst_linesize; \
145  src += src_linesize; \
146  p0 += p0_linesize; \
147  p1 += p1_linesize; \
148  p3 += p3_linesize; \
149  p4 += p4_linesize; \
150  } \
151  return 0; \
152 }
153 
155 DEFINE_DEDOTCRAWL(16, uint16_t, 2)
156 
157 typedef struct ThreadData {
158  AVFrame *out;
159  int plane;
160 } ThreadData;
161 
162 #define DEFINE_DERAINBOW(name, type, div) \
163 static int derainbow##name(AVFilterContext *ctx, void *arg, \
164  int jobnr, int nb_jobs) \
165 { \
166  DedotContext *s = ctx->priv; \
167  ThreadData *td = arg; \
168  AVFrame *out = td->out; \
169  const int plane = td->plane; \
170  const int h = s->planeheight[plane]; \
171  int slice_start = (h * jobnr) / nb_jobs; \
172  int slice_end = (h * (jobnr+1)) / nb_jobs; \
173  int src_linesize = s->frames[2]->linesize[plane] / div; \
174  int dst_linesize = out->linesize[plane] / div; \
175  int p0_linesize = s->frames[0]->linesize[plane] / div; \
176  int p1_linesize = s->frames[1]->linesize[plane] / div; \
177  int p3_linesize = s->frames[3]->linesize[plane] / div; \
178  int p4_linesize = s->frames[4]->linesize[plane] / div; \
179  type *p0 = (type *)s->frames[0]->data[plane]; \
180  type *p1 = (type *)s->frames[1]->data[plane]; \
181  type *p3 = (type *)s->frames[3]->data[plane]; \
182  type *p4 = (type *)s->frames[4]->data[plane]; \
183  type *src = (type *)s->frames[2]->data[plane]; \
184  type *dst = (type *)out->data[plane]; \
185  const int chromaT1 = s->chromaT1; \
186  const int chromaT2 = s->chromaT2; \
187  \
188  p0 += slice_start * p0_linesize; \
189  p1 += slice_start * p1_linesize; \
190  p3 += slice_start * p3_linesize; \
191  p4 += slice_start * p4_linesize; \
192  src += slice_start * src_linesize; \
193  dst += slice_start * dst_linesize; \
194  for (int y = slice_start; y < slice_end; y++) { \
195  for (int x = 0; x < s->planewidth[plane]; x++) { \
196  int cur = src[x]; \
197  \
198  if (FFABS(cur - p0[x]) <= chromaT1 && \
199  FFABS(cur - p4[x]) <= chromaT1 && \
200  FFABS(p1[x] - p3[x]) <= chromaT1 && \
201  FFABS(cur - p1[x]) > chromaT2 && \
202  FFABS(cur - p3[x]) > chromaT2) { \
203  int diff1 = FFABS(cur - p1[x]); \
204  int diff2 = FFABS(cur - p3[x]); \
205  \
206  if (diff1 < diff2) \
207  dst[x] = (src[x] + p1[x] + 1) >> 1; \
208  else \
209  dst[x] = (src[x] + p3[x] + 1) >> 1; \
210  } \
211  } \
212  \
213  dst += dst_linesize; \
214  src += src_linesize; \
215  p0 += p0_linesize; \
216  p1 += p1_linesize; \
217  p3 += p3_linesize; \
218  p4 += p4_linesize; \
219  } \
220  return 0; \
221 }
222 
224 DEFINE_DERAINBOW(16, uint16_t, 2)
225 
226 static int config_output(AVFilterLink *outlink)
227 {
228  AVFilterContext *ctx = outlink->src;
229  DedotContext *s = ctx->priv;
230  AVFilterLink *inlink = ctx->inputs[0];
231 
232  s->desc = av_pix_fmt_desc_get(outlink->format);
233  if (!s->desc)
234  return AVERROR_BUG;
235  s->nb_planes = av_pix_fmt_count_planes(outlink->format);
236  s->depth = s->desc->comp[0].depth;
237  s->max = (1 << s->depth) - 1;
238  s->luma2d = s->lt * s->max;
239  s->lumaT = s->tl * s->max;
240  s->chromaT1 = s->tc * s->max;
241  s->chromaT2 = s->ct * s->max;
242 
243  s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, s->desc->log2_chroma_w);
244  s->planewidth[0] = s->planewidth[3] = inlink->w;
245 
246  s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, s->desc->log2_chroma_h);
247  s->planeheight[0] = s->planeheight[3] = inlink->h;
248 
249  if (s->depth <= 8) {
250  s->dedotcrawl = dedotcrawl8;
251  s->derainbow = derainbow8;
252  } else {
253  s->dedotcrawl = dedotcrawl16;
254  s->derainbow = derainbow16;
255  }
256 
257  return 0;
258 }
259 
261 {
262  AVFilterLink *inlink = ctx->inputs[0];
263  AVFilterLink *outlink = ctx->outputs[0];
264  DedotContext *s = ctx->priv;
265  AVFrame *frame = NULL;
266  int64_t pts;
267  int status;
268  int ret = 0;
269 
270  FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink);
271 
272  if (s->eof == 0) {
273  ret = ff_inlink_consume_frame(inlink, &frame);
274  if (ret < 0)
275  return ret;
276  }
277  if (frame || s->eof_frames > 0) {
278  AVFrame *out = NULL;
279 
280  if (frame) {
281  for (int i = 2; i < 5; i++) {
282  if (!s->frames[i])
283  s->frames[i] = av_frame_clone(frame);
284  }
285  av_frame_free(&frame);
286  } else {
287  s->eof_frames--;
288  s->frames[4] = av_frame_clone(s->frames[3]);
289  }
290 
291  if (s->frames[0] &&
292  s->frames[1] &&
293  s->frames[2] &&
294  s->frames[3] &&
295  s->frames[4]) {
296  out = av_frame_clone(s->frames[2]);
297  if (out && !ctx->is_disabled) {
298  ret = av_frame_make_writable(out);
299  if (ret >= 0) {
300  if (s->m & 1)
301  ctx->internal->execute(ctx, s->dedotcrawl, out, NULL,
302  FFMIN(s->planeheight[0],
304  if (s->m & 2) {
305  ThreadData td;
306  td.out = out; td.plane = 1;
307  ctx->internal->execute(ctx, s->derainbow, &td, NULL,
308  FFMIN(s->planeheight[1],
310  td.plane = 2;
311  ctx->internal->execute(ctx, s->derainbow, &td, NULL,
312  FFMIN(s->planeheight[2],
314  }
315  }
316  } else if (!out) {
317  ret = AVERROR(ENOMEM);
318  }
319  }
320 
321  av_frame_free(&s->frames[0]);
322  s->frames[0] = s->frames[1];
323  s->frames[1] = s->frames[2];
324  s->frames[2] = s->frames[3];
325  s->frames[3] = s->frames[4];
326  s->frames[4] = NULL;
327 
328  if (ret < 0)
329  return ret;
330  if (out)
331  return ff_filter_frame(outlink, out);
332  }
333 
334  if (s->eof) {
335  if (s->eof_frames <= 0) {
336  ff_outlink_set_status(outlink, AVERROR_EOF, s->frames[2]->pts);
337  } else {
338  ff_filter_set_ready(ctx, 10);
339  }
340  return 0;
341  }
342 
343  if (!s->eof && ff_inlink_acknowledge_status(inlink, &status, &pts)) {
344  if (status == AVERROR_EOF) {
345  s->eof = 1;
346  s->eof_frames = 2;
347  ff_filter_set_ready(ctx, 10);
348  return 0;
349  }
350  }
351 
352  FF_FILTER_FORWARD_WANTED(outlink, inlink);
353 
354  return FFERROR_NOT_READY;
355 }
356 
358 {
359  DedotContext *s = ctx->priv;
360 
361  for (int i = 0; i < 5; i++)
362  av_frame_free(&s->frames[i]);
363 }
364 
365 #define OFFSET(x) offsetof(DedotContext, x)
366 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM
367 
368 static const AVOption dedot_options[] = {
369  { "m", "set filtering mode", OFFSET( m), AV_OPT_TYPE_FLAGS, {.i64=3}, 0, 3, FLAGS, "m" },
370  { "dotcrawl", 0, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "m" },
371  { "rainbows", 0, 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, FLAGS, "m" },
372  { "lt", "set spatial luma threshold", OFFSET(lt), AV_OPT_TYPE_FLOAT, {.dbl=.079}, 0, 1, FLAGS },
373  { "tl", "set tolerance for temporal luma", OFFSET(tl), AV_OPT_TYPE_FLOAT, {.dbl=.079}, 0, 1, FLAGS },
374  { "tc", "set tolerance for chroma temporal variation", OFFSET(tc), AV_OPT_TYPE_FLOAT, {.dbl=.058}, 0, 1, FLAGS },
375  { "ct", "set temporal chroma threshold", OFFSET(ct), AV_OPT_TYPE_FLOAT, {.dbl=.019}, 0, 1, FLAGS },
376  { NULL },
377 };
378 
379 static const AVFilterPad inputs[] = {
380  {
381  .name = "default",
382  .type = AVMEDIA_TYPE_VIDEO,
383  },
384  { NULL }
385 };
386 
387 static const AVFilterPad outputs[] = {
388  {
389  .name = "default",
390  .type = AVMEDIA_TYPE_VIDEO,
391  .config_props = config_output,
392  },
393  { NULL }
394 };
395 
396 AVFILTER_DEFINE_CLASS(dedot);
397 
399  .name = "dedot",
400  .description = NULL_IF_CONFIG_SMALL("Reduce cross-luminance and cross-color."),
401  .priv_size = sizeof(DedotContext),
402  .priv_class = &dedot_class,
404  .activate = activate,
405  .uninit = uninit,
406  .inputs = inputs,
407  .outputs = outputs,
409 };
int planewidth[4]
Definition: vf_dedot.c:50
int plane
Definition: avisynth_c.h:384
int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
Take a frame from the link&#39;s FIFO and update the link&#39;s stats.
Definition: avfilter.c:1481
#define NULL
Definition: coverity.c:32
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:430
AVFrame * out
Definition: af_adeclick.c:488
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:422
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2522
int eof_frames
Definition: vf_dedot.c:48
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
static const AVOption dedot_options[]
Definition: vf_dedot.c:368
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:397
int chromaT2
Definition: vf_dedot.c:45
#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.
float tl
Definition: vf_dedot.c:35
#define FFERROR_NOT_READY
Filters implementation helper functions.
Definition: filters.h:34
static int activate(AVFilterContext *ctx)
Definition: vf_dedot.c:260
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:391
const AVPixFmtDescriptor * desc
Definition: vf_dedot.c:39
static int query_formats(AVFilterContext *ctx)
Definition: vf_dedot.c:59
AVFilter ff_vf_dedot
Definition: vf_dedot.c:398
int is_disabled
the enabled state from the last expression evaluation
Definition: avfilter.h:385
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92
static void ff_outlink_set_status(AVFilterLink *link, int status, int64_t pts)
Set the status field of a link from the source filter.
Definition: filters.h:189
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283
const char * name
Pad name.
Definition: internal.h:60
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:346
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1080
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.
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:388
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:421
static AVFrame * frame
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
#define AVERROR_EOF
End of file.
Definition: error.h:55
int nb_planes
Definition: vf_dedot.c:49
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:400
int(* dedotcrawl)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_dedot.c:55
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:392
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:429
#define FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink)
Forward the status on an output link to an input link.
Definition: filters.h:199
A filter pad used for either input or output.
Definition: internal.h:54
int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
Test and acknowledge the change of status on the link.
Definition: avfilter.c:1436
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:568
#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
#define AVERROR(e)
Definition: error.h:43
#define FLAGS
Definition: vf_dedot.c:366
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
#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
int chromaT1
Definition: vf_dedot.c:44
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:390
AVFILTER_DEFINE_CLASS(dedot)
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:385
float tc
Definition: vf_dedot.c:36
#define FF_FILTER_FORWARD_WANTED(outlink, inlink)
Forward the frame_wanted_out flag from an output link to an input link.
Definition: filters.h:254
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
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:78
#define DEFINE_DERAINBOW(name, type, div)
Definition: vf_dedot.c:162
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:426
#define OFFSET(x)
Definition: vf_dedot.c:365
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:386
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:540
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:398
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:395
Used for passing data between threads.
Definition: af_adeclick.c:487
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
float ct
Definition: vf_dedot.c:37
float lt
Definition: vf_dedot.c:34
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:50
#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
Filter definition.
Definition: avfilter.h:144
#define DEFINE_DEDOTCRAWL(name, type, div)
Definition: vf_dedot.c:83
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
#define AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
Same as AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, except that the filter will have its filter_frame() c...
Definition: avfilter.h:133
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
static const AVFilterPad inputs[]
Definition: vf_dedot.c:379
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:396
int(* derainbow)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_dedot.c:56
static int64_t pts
int av_frame_make_writable(AVFrame *frame)
Ensure that the frame data is writable, avoiding data copy if possible.
Definition: frame.c:611
#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 AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:394
AVFrame * frames[5]
Definition: vf_dedot.c:53
int
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_dedot.c:357
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
static const AVFilterPad outputs[]
Definition: vf_dedot.c:387
void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
Mark a filter ready and schedule it for activation.
Definition: avfilter.c:193
#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
avfilter_execute_func * execute
Definition: internal.h:155
int luma2d
Definition: vf_dedot.c:42
static int config_output(AVFilterLink *outlink)
Definition: vf_dedot.c:226
A list of supported formats for one end of a filter link.
Definition: formats.h:64
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
Definition: pixfmt.h:258
An instance of a filter.
Definition: avfilter.h:338
int planeheight[4]
Definition: vf_dedot.c:51
FILE * out
Definition: movenc.c:54
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
formats
Definition: signature.h:48
internal API functions
int depth
Number of bits in the component.
Definition: pixdesc.h:58
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:399
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58