FFmpeg
vf_vaguedenoiser.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2003 LeFunGus, lefungus@altern.org
3  *
4  * This file is part of FFmpeg
5  *
6  * FFmpeg is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (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
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License along
17  * with FFmpeg; if not, write to the Free Software Foundation, Inc.,
18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19  */
20 
21 #include <float.h>
22 
23 #include "libavutil/imgutils.h"
24 #include "libavutil/attributes.h"
25 #include "libavutil/common.h"
26 #include "libavutil/pixdesc.h"
27 #include "libavutil/intreadwrite.h"
28 #include "libavutil/opt.h"
29 
30 #include "avfilter.h"
31 #include "formats.h"
32 #include "internal.h"
33 #include "video.h"
34 
35 typedef struct VagueDenoiserContext {
36  const AVClass *class;
37 
38  float threshold;
39  float percent;
40  int method;
41  int nsteps;
42  int planes;
43 
44  int depth;
45  int bpc;
46  int peak;
47  int nb_planes;
48  int planeheight[4];
49  int planewidth[4];
50 
51  float *block;
52  float *in;
53  float *out;
54  float *tmp;
55 
56  int hlowsize[4][32];
57  int hhighsize[4][32];
58  int vlowsize[4][32];
59  int vhighsize[4][32];
60 
61  void (*thresholding)(float *block, const int width, const int height,
62  const int stride, const float threshold,
63  const float percent, const int nsteps);
65 
66 #define OFFSET(x) offsetof(VagueDenoiserContext, x)
67 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM
68 static const AVOption vaguedenoiser_options[] = {
69  { "threshold", "set filtering strength", OFFSET(threshold), AV_OPT_TYPE_FLOAT, {.dbl=2.}, 0,DBL_MAX, FLAGS },
70  { "method", "set filtering method", OFFSET(method), AV_OPT_TYPE_INT, {.i64=2 }, 0, 2, FLAGS, "method" },
71  { "hard", "hard thresholding", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "method" },
72  { "soft", "soft thresholding", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "method" },
73  { "garrote", "garotte thresholding", 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, FLAGS, "method" },
74  { "nsteps", "set number of steps", OFFSET(nsteps), AV_OPT_TYPE_INT, {.i64=6 }, 1, 32, FLAGS },
75  { "percent", "set percent of full denoising", OFFSET(percent),AV_OPT_TYPE_FLOAT, {.dbl=85}, 0,100, FLAGS },
76  { "planes", "set planes to filter", OFFSET(planes), AV_OPT_TYPE_INT, {.i64=15 }, 0, 15, FLAGS },
77  { NULL }
78 };
79 
80 AVFILTER_DEFINE_CLASS(vaguedenoiser);
81 
82 #define NPAD 10
83 
84 static const float analysis_low[9] = {
85  0.037828455506995f, -0.023849465019380f, -0.110624404418423f, 0.377402855612654f,
86  0.852698679009403f, 0.377402855612654f, -0.110624404418423f, -0.023849465019380f, 0.037828455506995f
87 };
88 
89 static const float analysis_high[7] = {
90  -0.064538882628938f, 0.040689417609558f, 0.418092273222212f, -0.788485616405664f,
91  0.418092273222212f, 0.040689417609558f, -0.064538882628938f
92 };
93 
94 static const float synthesis_low[7] = {
95  -0.064538882628938f, -0.040689417609558f, 0.418092273222212f, 0.788485616405664f,
96  0.418092273222212f, -0.040689417609558f, -0.064538882628938f
97 };
98 
99 static const float synthesis_high[9] = {
100  -0.037828455506995f, -0.023849465019380f, 0.110624404418423f, 0.377402855612654f,
101  -0.852698679009403f, 0.377402855612654f, 0.110624404418423f, -0.023849465019380f, -0.037828455506995f
102 };
103 
105 {
106  static const enum AVPixelFormat pix_fmts[] = {
125  };
126  AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
127  if (!fmts_list)
128  return AVERROR(ENOMEM);
129  return ff_set_common_formats(ctx, fmts_list);
130 }
131 
133 {
134  VagueDenoiserContext *s = inlink->dst->priv;
136  int p, i, nsteps_width, nsteps_height, nsteps_max;
137 
138  s->depth = desc->comp[0].depth;
139  s->bpc = (s->depth + 7) / 8;
140  s->nb_planes = desc->nb_components;
141 
142  s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
143  s->planeheight[0] = s->planeheight[3] = inlink->h;
144  s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
145  s->planewidth[0] = s->planewidth[3] = inlink->w;
146 
147  s->block = av_malloc_array(inlink->w * inlink->h, sizeof(*s->block));
148  s->in = av_malloc_array(32 + FFMAX(inlink->w, inlink->h), sizeof(*s->in));
149  s->out = av_malloc_array(32 + FFMAX(inlink->w, inlink->h), sizeof(*s->out));
150  s->tmp = av_malloc_array(32 + FFMAX(inlink->w, inlink->h), sizeof(*s->tmp));
151 
152  if (!s->block || !s->in || !s->out || !s->tmp)
153  return AVERROR(ENOMEM);
154 
155  s->threshold *= 1 << (s->depth - 8);
156  s->peak = (1 << s->depth) - 1;
157 
158  nsteps_width = ((s->planes & 2 || s->planes & 4) && s->nb_planes > 1) ? s->planewidth[1] : s->planewidth[0];
159  nsteps_height = ((s->planes & 2 || s->planes & 4) && s->nb_planes > 1) ? s->planeheight[1] : s->planeheight[0];
160 
161  for (nsteps_max = 1; nsteps_max < 15; nsteps_max++) {
162  if (pow(2, nsteps_max) >= nsteps_width || pow(2, nsteps_max) >= nsteps_height)
163  break;
164  }
165 
166  s->nsteps = FFMIN(s->nsteps, nsteps_max - 2);
167 
168  for (p = 0; p < 4; p++) {
169  s->hlowsize[p][0] = (s->planewidth[p] + 1) >> 1;
170  s->hhighsize[p][0] = s->planewidth[p] >> 1;
171  s->vlowsize[p][0] = (s->planeheight[p] + 1) >> 1;
172  s->vhighsize[p][0] = s->planeheight[p] >> 1;
173 
174  for (i = 1; i < s->nsteps; i++) {
175  s->hlowsize[p][i] = (s->hlowsize[p][i - 1] + 1) >> 1;
176  s->hhighsize[p][i] = s->hlowsize[p][i - 1] >> 1;
177  s->vlowsize[p][i] = (s->vlowsize[p][i - 1] + 1) >> 1;
178  s->vhighsize[p][i] = s->vlowsize[p][i - 1] >> 1;
179  }
180  }
181 
182  return 0;
183 }
184 
185 static inline void copy(const float *p1, float *p2, const int length)
186 {
187  memcpy(p2, p1, length * sizeof(float));
188 }
189 
190 static inline void copyv(const float *p1, const int stride1, float *p2, const int length)
191 {
192  int i;
193 
194  for (i = 0; i < length; i++) {
195  p2[i] = *p1;
196  p1 += stride1;
197  }
198 }
199 
200 static inline void copyh(const float *p1, float *p2, const int stride2, const int length)
201 {
202  int i;
203 
204  for (i = 0; i < length; i++) {
205  *p2 = p1[i];
206  p2 += stride2;
207  }
208 }
209 
210 // Do symmetric extension of data using prescribed symmetries
211 // Original values are in output[npad] through output[npad+size-1]
212 // New values will be placed in output[0] through output[npad] and in output[npad+size] through output[2*npad+size-1] (note: end values may not be filled in)
213 // extension at left bdry is ... 3 2 1 0 | 0 1 2 3 ...
214 // same for right boundary
215 // if right_ext=1 then ... 3 2 1 0 | 1 2 3
216 static void symmetric_extension(float *output, const int size, const int left_ext, const int right_ext)
217 {
218  int first = NPAD;
219  int last = NPAD - 1 + size;
220  const int originalLast = last;
221  int i, nextend, idx;
222 
223  if (left_ext == 2)
224  output[--first] = output[NPAD];
225  if (right_ext == 2)
226  output[++last] = output[originalLast];
227 
228  // extend left end
229  nextend = first;
230  for (i = 0; i < nextend; i++)
231  output[--first] = output[NPAD + 1 + i];
232 
233  idx = NPAD + NPAD - 1 + size;
234 
235  // extend right end
236  nextend = idx - last;
237  for (i = 0; i < nextend; i++)
238  output[++last] = output[originalLast - 1 - i];
239 }
240 
241 static void transform_step(float *input, float *output, const int size, const int low_size, VagueDenoiserContext *s)
242 {
243  int i;
244 
245  symmetric_extension(input, size, 1, 1);
246 
247  for (i = NPAD; i < NPAD + low_size; i++) {
248  const float a = input[2 * i - 14] * analysis_low[0];
249  const float b = input[2 * i - 13] * analysis_low[1];
250  const float c = input[2 * i - 12] * analysis_low[2];
251  const float d = input[2 * i - 11] * analysis_low[3];
252  const float e = input[2 * i - 10] * analysis_low[4];
253  const float f = input[2 * i - 9] * analysis_low[3];
254  const float g = input[2 * i - 8] * analysis_low[2];
255  const float h = input[2 * i - 7] * analysis_low[1];
256  const float k = input[2 * i - 6] * analysis_low[0];
257 
258  output[i] = a + b + c + d + e + f + g + h + k;
259  }
260 
261  for (i = NPAD; i < NPAD + low_size; i++) {
262  const float a = input[2 * i - 12] * analysis_high[0];
263  const float b = input[2 * i - 11] * analysis_high[1];
264  const float c = input[2 * i - 10] * analysis_high[2];
265  const float d = input[2 * i - 9] * analysis_high[3];
266  const float e = input[2 * i - 8] * analysis_high[2];
267  const float f = input[2 * i - 7] * analysis_high[1];
268  const float g = input[2 * i - 6] * analysis_high[0];
269 
270  output[i + low_size] = a + b + c + d + e + f + g;
271  }
272 }
273 
274 static void invert_step(const float *input, float *output, float *temp, const int size, VagueDenoiserContext *s)
275 {
276  const int low_size = (size + 1) >> 1;
277  const int high_size = size >> 1;
278  int left_ext = 1, right_ext, i;
279  int findex;
280 
281  memcpy(temp + NPAD, input + NPAD, low_size * sizeof(float));
282 
283  right_ext = (size % 2 == 0) ? 2 : 1;
284  symmetric_extension(temp, low_size, left_ext, right_ext);
285 
286  memset(output, 0, (NPAD + NPAD + size) * sizeof(float));
287  findex = (size + 2) >> 1;
288 
289  for (i = 9; i < findex + 11; i++) {
290  const float a = temp[i] * synthesis_low[0];
291  const float b = temp[i] * synthesis_low[1];
292  const float c = temp[i] * synthesis_low[2];
293  const float d = temp[i] * synthesis_low[3];
294 
295  output[2 * i - 13] += a;
296  output[2 * i - 12] += b;
297  output[2 * i - 11] += c;
298  output[2 * i - 10] += d;
299  output[2 * i - 9] += c;
300  output[2 * i - 8] += b;
301  output[2 * i - 7] += a;
302  }
303 
304  memcpy(temp + NPAD, input + NPAD + low_size, high_size * sizeof(float));
305 
306  left_ext = 2;
307  right_ext = (size % 2 == 0) ? 1 : 2;
308  symmetric_extension(temp, high_size, left_ext, right_ext);
309 
310  for (i = 8; i < findex + 11; i++) {
311  const float a = temp[i] * synthesis_high[0];
312  const float b = temp[i] * synthesis_high[1];
313  const float c = temp[i] * synthesis_high[2];
314  const float d = temp[i] * synthesis_high[3];
315  const float e = temp[i] * synthesis_high[4];
316 
317  output[2 * i - 13] += a;
318  output[2 * i - 12] += b;
319  output[2 * i - 11] += c;
320  output[2 * i - 10] += d;
321  output[2 * i - 9] += e;
322  output[2 * i - 8] += d;
323  output[2 * i - 7] += c;
324  output[2 * i - 6] += b;
325  output[2 * i - 5] += a;
326  }
327 }
328 
329 static void hard_thresholding(float *block, const int width, const int height,
330  const int stride, const float threshold,
331  const float percent, const int unused)
332 {
333  const float frac = 1.f - percent * 0.01f;
334  int y, x;
335 
336  for (y = 0; y < height; y++) {
337  for (x = 0; x < width; x++) {
338  if (FFABS(block[x]) <= threshold)
339  block[x] *= frac;
340  }
341  block += stride;
342  }
343 }
344 
345 static void soft_thresholding(float *block, const int width, const int height, const int stride,
346  const float threshold, const float percent, const int nsteps)
347 {
348  const float frac = 1.f - percent * 0.01f;
349  const float shift = threshold * 0.01f * percent;
350  int w = width;
351  int h = height;
352  int y, x, l;
353 
354  for (l = 0; l < nsteps; l++) {
355  w = (w + 1) >> 1;
356  h = (h + 1) >> 1;
357  }
358 
359  for (y = 0; y < height; y++) {
360  const int x0 = (y < h) ? w : 0;
361  for (x = x0; x < width; x++) {
362  const float temp = FFABS(block[x]);
363  if (temp <= threshold)
364  block[x] *= frac;
365  else
366  block[x] = (block[x] < 0.f ? -1.f : (block[x] > 0.f ? 1.f : 0.f)) * (temp - shift);
367  }
368  block += stride;
369  }
370 }
371 
372 static void qian_thresholding(float *block, const int width, const int height,
373  const int stride, const float threshold,
374  const float percent, const int unused)
375 {
376  const float percent01 = percent * 0.01f;
377  const float tr2 = threshold * threshold * percent01;
378  const float frac = 1.f - percent01;
379  int y, x;
380 
381  for (y = 0; y < height; y++) {
382  for (x = 0; x < width; x++) {
383  const float temp = FFABS(block[x]);
384  if (temp <= threshold) {
385  block[x] *= frac;
386  } else {
387  const float tp2 = temp * temp;
388  block[x] *= (tp2 - tr2) / tp2;
389  }
390  }
391  block += stride;
392  }
393 }
394 
396 {
397  int p, y, x, i, j;
398 
399  for (p = 0; p < s->nb_planes; p++) {
400  const int height = s->planeheight[p];
401  const int width = s->planewidth[p];
402  const uint8_t *srcp8 = in->data[p];
403  const uint16_t *srcp16 = (const uint16_t *)in->data[p];
404  uint8_t *dstp8 = out->data[p];
405  uint16_t *dstp16 = (uint16_t *)out->data[p];
406  float *output = s->block;
407  int h_low_size0 = width;
408  int v_low_size0 = height;
409  int nsteps_transform = s->nsteps;
410  int nsteps_invert = s->nsteps;
411  const float *input = s->block;
412 
413  if (!((1 << p) & s->planes)) {
414  av_image_copy_plane(out->data[p], out->linesize[p], in->data[p], in->linesize[p],
415  s->planewidth[p] * s->bpc, s->planeheight[p]);
416  continue;
417  }
418 
419  if (s->depth <= 8) {
420  for (y = 0; y < height; y++) {
421  for (x = 0; x < width; x++)
422  output[x] = srcp8[x];
423  srcp8 += in->linesize[p];
424  output += width;
425  }
426  } else {
427  for (y = 0; y < height; y++) {
428  for (x = 0; x < width; x++)
429  output[x] = srcp16[x];
430  srcp16 += in->linesize[p] / 2;
431  output += width;
432  }
433  }
434 
435  while (nsteps_transform--) {
436  int low_size = (h_low_size0 + 1) >> 1;
437  float *input = s->block;
438  for (j = 0; j < v_low_size0; j++) {
439  copy(input, s->in + NPAD, h_low_size0);
440  transform_step(s->in, s->out, h_low_size0, low_size, s);
441  copy(s->out + NPAD, input, h_low_size0);
442  input += width;
443  }
444 
445  low_size = (v_low_size0 + 1) >> 1;
446  input = s->block;
447  for (j = 0; j < h_low_size0; j++) {
448  copyv(input, width, s->in + NPAD, v_low_size0);
449  transform_step(s->in, s->out, v_low_size0, low_size, s);
450  copyh(s->out + NPAD, input, width, v_low_size0);
451  input++;
452  }
453 
454  h_low_size0 = (h_low_size0 + 1) >> 1;
455  v_low_size0 = (v_low_size0 + 1) >> 1;
456  }
457 
458  s->thresholding(s->block, width, height, width, s->threshold, s->percent, s->nsteps);
459 
460  while (nsteps_invert--) {
461  const int idx = s->vlowsize[p][nsteps_invert] + s->vhighsize[p][nsteps_invert];
462  const int idx2 = s->hlowsize[p][nsteps_invert] + s->hhighsize[p][nsteps_invert];
463  float * idx3 = s->block;
464  for (i = 0; i < idx2; i++) {
465  copyv(idx3, width, s->in + NPAD, idx);
466  invert_step(s->in, s->out, s->tmp, idx, s);
467  copyh(s->out + NPAD, idx3, width, idx);
468  idx3++;
469  }
470 
471  idx3 = s->block;
472  for (i = 0; i < idx; i++) {
473  copy(idx3, s->in + NPAD, idx2);
474  invert_step(s->in, s->out, s->tmp, idx2, s);
475  copy(s->out + NPAD, idx3, idx2);
476  idx3 += width;
477  }
478  }
479 
480  if (s->depth <= 8) {
481  for (y = 0; y < height; y++) {
482  for (x = 0; x < width; x++)
483  dstp8[x] = av_clip_uint8(input[x] + 0.5f);
484  input += width;
485  dstp8 += out->linesize[p];
486  }
487  } else {
488  for (y = 0; y < height; y++) {
489  for (x = 0; x < width; x++)
490  dstp16[x] = av_clip(input[x] + 0.5f, 0, s->peak);
491  input += width;
492  dstp16 += out->linesize[p] / 2;
493  }
494  }
495  }
496 }
497 
499 {
500  AVFilterContext *ctx = inlink->dst;
501  VagueDenoiserContext *s = ctx->priv;
502  AVFilterLink *outlink = ctx->outputs[0];
503  AVFrame *out;
504  int direct = av_frame_is_writable(in);
505 
506  if (direct) {
507  out = in;
508  } else {
509  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
510  if (!out) {
511  av_frame_free(&in);
512  return AVERROR(ENOMEM);
513  }
514 
515  av_frame_copy_props(out, in);
516  }
517 
518  filter(s, in, out);
519 
520  if (!direct)
521  av_frame_free(&in);
522 
523  return ff_filter_frame(outlink, out);
524 }
525 
527 {
528  VagueDenoiserContext *s = ctx->priv;
529 
530  switch (s->method) {
531  case 0:
533  break;
534  case 1:
536  break;
537  case 2:
539  break;
540  }
541 
542  return 0;
543 }
544 
546 {
547  VagueDenoiserContext *s = ctx->priv;
548 
549  av_freep(&s->block);
550  av_freep(&s->in);
551  av_freep(&s->out);
552  av_freep(&s->tmp);
553 }
554 
556  {
557  .name = "default",
558  .type = AVMEDIA_TYPE_VIDEO,
559  .config_props = config_input,
560  .filter_frame = filter_frame,
561  },
562  { NULL }
563 };
564 
565 
567  {
568  .name = "default",
569  .type = AVMEDIA_TYPE_VIDEO
570  },
571  { NULL }
572 };
573 
575  .name = "vaguedenoiser",
576  .description = NULL_IF_CONFIG_SMALL("Apply a Wavelet based Denoiser."),
577  .priv_size = sizeof(VagueDenoiserContext),
578  .priv_class = &vaguedenoiser_class,
579  .init = init,
580  .uninit = uninit,
582  .inputs = vaguedenoiser_inputs,
583  .outputs = vaguedenoiser_outputs,
585 };
#define NULL
Definition: coverity.c:32
static av_cold int init(AVFilterContext *ctx)
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
static int shift(int a, int b)
Definition: sonic.c:82
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:389
static void qian_thresholding(float *block, const int width, const int height, const int stride, const float threshold, const float percent, const int unused)
static void copy(const float *p1, float *p2, const int length)
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_YUV444P14
Definition: pixfmt.h:397
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.
else temp
Definition: vf_mcdeint.c:256
const char * g
Definition: vf_curves.c:115
const char * desc
Definition: nvenc.c:68
static void hard_thresholding(float *block, const int width, const int height, const int stride, const float threshold, const float percent, const int unused)
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:403
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:391
AVFilter ff_vf_vaguedenoiser
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
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92
Macro definitions for various function/variable attributes.
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283
#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
AVFILTER_DEFINE_CLASS(vaguedenoiser)
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1080
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
uint8_t
#define av_cold
Definition: attributes.h:82
static void copyv(const float *p1, const int stride1, float *p2, const int length)
AVOptions.
#define f(width, name)
Definition: cbs_vp9.c:255
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
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 output
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But first
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:402
#define height
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 AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:400
ptrdiff_t size
Definition: opengl_enc.c:100
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:392
A filter pad used for either input or output.
Definition: internal.h:54
static const float synthesis_low[7]
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
static void symmetric_extension(float *output, const int size, const int left_ext, const int right_ext)
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
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
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
GLsizei GLsizei * length
Definition: opengl_enc.c:114
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:390
static void invert_step(const float *input, float *output, float *temp, const int size, VagueDenoiserContext *s)
#define FFMAX(a, b)
Definition: common.h:94
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
static const AVOption vaguedenoiser_options[]
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:385
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:83
#define b
Definition: input.c:41
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:406
#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
#define width
uint8_t w
Definition: llviddspenc.c:38
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
static const AVFilterPad vaguedenoiser_outputs[]
AVFormatContext * ctx
Definition: movenc.c:48
#define FLAGS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
static const AVFilterPad vaguedenoiser_inputs[]
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:386
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:405
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
static int query_formats(AVFilterContext *ctx)
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:398
static void transform_step(float *input, float *output, const int size, const int low_size, VagueDenoiserContext *s)
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:395
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:594
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
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
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 OFFSET(x)
void(* thresholding)(float *block, const int width, const int height, const int stride, const float threshold, const float percent, const int nsteps)
const char * name
Filter name.
Definition: avfilter.h:148
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:393
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
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:384
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
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
#define flags(name, subs,...)
Definition: cbs_av1.c:561
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:388
static av_cold void uninit(AVFilterContext *ctx)
#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
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
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
common internal and external API header
static const float synthesis_high[9]
#define NPAD
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
static int config_input(AVFilterLink *inlink)
static void filter(VagueDenoiserContext *s, AVFrame *in, AVFrame *out)
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
static const float analysis_high[7]
An instance of a filter.
Definition: avfilter.h:338
#define av_freep(p)
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
#define av_malloc_array(a, b)
static void soft_thresholding(float *block, const int width, const int height, const int stride, const float threshold, const float percent, const int nsteps)
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
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
static void copyh(const float *p1, float *p2, const int stride2, const int length)
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
#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
static const float analysis_low[9]
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58