FFmpeg
vf_bm3d.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015-2016 mawen1250
3  * Copyright (c) 2018 Paul B Mahol
4  *
5  * This file is part of FFmpeg.
6  *
7  * Permission is hereby granted, free of charge, to any person obtaining a copy
8  * of this software and associated documentation files (the "Software"), to deal
9  * in the Software without restriction, including without limitation the rights
10  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11  * copies of the Software, and to permit persons to whom the Software is
12  * furnished to do so, subject to the following conditions:
13  *
14  * The above copyright notice and this permission notice shall be included in all
15  * copies or substantial portions of the Software.
16  *
17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23  * SOFTWARE.
24  */
25 
26 /**
27  * @todo
28  * - non-power of 2 DCT
29  * - opponent color space
30  * - temporal support
31  */
32 
33 #include <float.h>
34 
35 #include "libavutil/imgutils.h"
36 #include "libavutil/opt.h"
37 #include "libavutil/pixdesc.h"
38 #include "libavcodec/avfft.h"
39 #include "avfilter.h"
40 #include "filters.h"
41 #include "formats.h"
42 #include "framesync.h"
43 #include "internal.h"
44 #include "video.h"
45 
46 #define MAX_NB_THREADS 32
47 
52 };
53 
54 typedef struct ThreadData {
55  const uint8_t *src;
57  const uint8_t *ref;
59  int plane;
60 } ThreadData;
61 
62 typedef struct PosCode {
63  int x, y;
64 } PosCode;
65 
66 typedef struct PosPairCode {
67  double score;
68  int x, y;
69 } PosPairCode;
70 
71 typedef struct SliceContext {
82  float *num, *den;
86 } SliceContext;
87 
88 typedef struct BM3DContext {
89  const AVClass *class;
90 
91  float sigma;
95  int bm_range;
96  int bm_step;
97  float th_mse;
99  int mode;
100  int ref;
101  int planes;
102 
103  int depth;
104  int max;
106  int planewidth[4];
107  int planeheight[4];
110 
112 
115 
116  void (*get_block_row)(const uint8_t *srcp, int src_linesize,
117  int y, int x, int block_size, float *dst);
118  double (*do_block_ssd)(struct BM3DContext *s, PosCode *pos,
119  const uint8_t *src, int src_stride,
120  int r_y, int r_x);
121  void (*do_output)(struct BM3DContext *s, uint8_t *dst, int dst_linesize,
122  int plane, int nb_jobs);
123  void (*block_filtering)(struct BM3DContext *s,
124  const uint8_t *src, int src_linesize,
125  const uint8_t *ref, int ref_linesize,
126  int y, int x, int plane, int jobnr);
127 } BM3DContext;
128 
129 #define OFFSET(x) offsetof(BM3DContext, x)
130 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
131 static const AVOption bm3d_options[] = {
132  { "sigma", "set denoising strength",
133  OFFSET(sigma), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 99999.9, FLAGS },
134  { "block", "set log2(size) of local patch",
135  OFFSET(block_size), AV_OPT_TYPE_INT, {.i64=4}, 4, 6, FLAGS },
136  { "bstep", "set sliding step for processing blocks",
137  OFFSET(block_step), AV_OPT_TYPE_INT, {.i64=4}, 1, 64, FLAGS },
138  { "group", "set maximal number of similar blocks",
139  OFFSET(group_size), AV_OPT_TYPE_INT, {.i64=1}, 1, 256, FLAGS },
140  { "range", "set block matching range",
141  OFFSET(bm_range), AV_OPT_TYPE_INT, {.i64=9}, 1, INT32_MAX, FLAGS },
142  { "mstep", "set step for block matching",
143  OFFSET(bm_step), AV_OPT_TYPE_INT, {.i64=1}, 1, 64, FLAGS },
144  { "thmse", "set threshold of mean square error for block matching",
145  OFFSET(th_mse), AV_OPT_TYPE_FLOAT, {.dbl=0}, 0, INT32_MAX, FLAGS },
146  { "hdthr", "set hard threshold for 3D transfer domain",
147  OFFSET(hard_threshold), AV_OPT_TYPE_FLOAT, {.dbl=2.7}, 0, INT32_MAX, FLAGS },
148  { "estim", "set filtering estimation mode",
149  OFFSET(mode), AV_OPT_TYPE_INT, {.i64=BASIC}, 0, NB_MODES-1, FLAGS, "mode" },
150  { "basic", "basic estimate",
151  0, AV_OPT_TYPE_CONST, {.i64=BASIC}, 0, 0, FLAGS, "mode" },
152  { "final", "final estimate",
153  0, AV_OPT_TYPE_CONST, {.i64=FINAL}, 0, 0, FLAGS, "mode" },
154  { "ref", "have reference stream",
155  OFFSET(ref), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
156  { "planes", "set planes to filter",
157  OFFSET(planes), AV_OPT_TYPE_INT, {.i64=7}, 0, 15, FLAGS },
158  { NULL }
159 };
160 
162 
163 static const enum AVPixelFormat pix_fmts[] = {
187 };
188 
189 static int do_search_boundary(int pos, int plane_boundary, int search_range, int search_step)
190 {
191  int search_boundary;
192 
193  search_range = search_range / search_step * search_step;
194 
195  if (pos == plane_boundary) {
196  search_boundary = plane_boundary;
197  } else if (pos > plane_boundary) {
198  search_boundary = pos - search_range;
199 
200  while (search_boundary < plane_boundary) {
201  search_boundary += search_step;
202  }
203  } else {
204  search_boundary = pos + search_range;
205 
206  while (search_boundary > plane_boundary) {
207  search_boundary -= search_step;
208  }
209  }
210 
211  return search_boundary;
212 }
213 
214 static int search_boundary(int plane_boundary, int search_range, int search_step, int vertical, int y, int x)
215 {
216  return do_search_boundary(vertical ? y : x, plane_boundary, search_range, search_step);
217 }
218 
219 static int cmp_scores(const void *a, const void *b)
220 {
221  const struct PosPairCode *pair1 = a;
222  const struct PosPairCode *pair2 = b;
223  return FFDIFFSIGN(pair1->score, pair2->score);
224 }
225 
226 static double do_block_ssd(BM3DContext *s, PosCode *pos, const uint8_t *src, int src_stride, int r_y, int r_x)
227 {
228  const uint8_t *srcp = src + pos->y * src_stride + pos->x;
229  const uint8_t *refp = src + r_y * src_stride + r_x;
230  const int block_size = s->block_size;
231  double dist = 0.;
232  int x, y;
233 
234  for (y = 0; y < block_size; y++) {
235  for (x = 0; x < block_size; x++) {
236  double temp = refp[x] - srcp[x];
237  dist += temp * temp;
238  }
239 
240  srcp += src_stride;
241  refp += src_stride;
242  }
243 
244  return dist;
245 }
246 
247 static double do_block_ssd16(BM3DContext *s, PosCode *pos, const uint8_t *src, int src_stride, int r_y, int r_x)
248 {
249  const uint16_t *srcp = (uint16_t *)src + pos->y * src_stride / 2 + pos->x;
250  const uint16_t *refp = (uint16_t *)src + r_y * src_stride / 2 + r_x;
251  const int block_size = s->block_size;
252  double dist = 0.;
253  int x, y;
254 
255  for (y = 0; y < block_size; y++) {
256  for (x = 0; x < block_size; x++) {
257  double temp = refp[x] - srcp[x];
258  dist += temp * temp;
259  }
260 
261  srcp += src_stride / 2;
262  refp += src_stride / 2;
263  }
264 
265  return dist;
266 }
267 
268 static void do_block_matching_multi(BM3DContext *s, const uint8_t *src, int src_stride, int src_range,
269  const PosCode *search_pos, int search_size, float th_mse,
270  int r_y, int r_x, int plane, int jobnr)
271 {
272  SliceContext *sc = &s->slices[jobnr];
273  double MSE2SSE = s->group_size * s->block_size * s->block_size * src_range * src_range / (s->max * s->max);
274  double distMul = 1. / MSE2SSE;
275  double th_sse = th_mse * MSE2SSE;
276  int i, index = sc->nb_match_blocks;
277 
278  for (i = 0; i < search_size; i++) {
279  PosCode pos = search_pos[i];
280  double dist;
281 
282  dist = s->do_block_ssd(s, &pos, src, src_stride, r_y, r_x);
283 
284  // Only match similar blocks but not identical blocks
285  if (dist <= th_sse && dist != 0) {
286  const double score = dist * distMul;
287 
288  if (index >= s->group_size && score >= sc->match_blocks[index - 1].score) {
289  continue;
290  }
291 
292  if (index >= s->group_size)
293  index = s->group_size - 1;
294 
295  sc->match_blocks[index].score = score;
296  sc->match_blocks[index].y = pos.y;
297  sc->match_blocks[index].x = pos.x;
298  index++;
299  qsort(sc->match_blocks, index, sizeof(PosPairCode), cmp_scores);
300  }
301  }
302 
303  sc->nb_match_blocks = index;
304 }
305 
306 static void block_matching_multi(BM3DContext *s, const uint8_t *ref, int ref_linesize, int y, int x,
307  int exclude_cur_pos, int plane, int jobnr)
308 {
309  SliceContext *sc = &s->slices[jobnr];
310  const int width = s->planewidth[plane];
311  const int height = s->planeheight[plane];
312  const int block_size = s->block_size;
313  const int step = s->bm_step;
314  const int range = s->bm_range / step * step;
315  int l = search_boundary(0, range, step, 0, y, x);
316  int r = search_boundary(width - block_size, range, step, 0, y, x);
317  int t = search_boundary(0, range, step, 1, y, x);
318  int b = search_boundary(height - block_size, range, step, 1, y, x);
319  int j, i, index = 0;
320 
321  for (j = t; j <= b; j += step) {
322  for (i = l; i <= r; i += step) {
323  PosCode pos;
324 
325  if (exclude_cur_pos > 0 && j == y && i == x) {
326  continue;
327  }
328 
329  pos.y = j;
330  pos.x = i;
331  sc->search_positions[index++] = pos;
332  }
333  }
334 
335  if (exclude_cur_pos == 1) {
336  sc->match_blocks[0].score = 0;
337  sc->match_blocks[0].y = y;
338  sc->match_blocks[0].x = x;
339  sc->nb_match_blocks = 1;
340  }
341 
342  do_block_matching_multi(s, ref, ref_linesize, s->bm_range,
343  sc->search_positions, index, s->th_mse, y, x, plane, jobnr);
344 }
345 
346 static void block_matching(BM3DContext *s, const uint8_t *ref, int ref_linesize,
347  int j, int i, int plane, int jobnr)
348 {
349  SliceContext *sc = &s->slices[jobnr];
350 
351  if (s->group_size == 1 || s->th_mse <= 0.f) {
352  sc->match_blocks[0].score = 1;
353  sc->match_blocks[0].x = i;
354  sc->match_blocks[0].y = j;
355  sc->nb_match_blocks = 1;
356  return;
357  }
358 
359  sc->nb_match_blocks = 0;
360  block_matching_multi(s, ref, ref_linesize, j, i, 1, plane, jobnr);
361 }
362 
363 static void get_block_row(const uint8_t *srcp, int src_linesize,
364  int y, int x, int block_size, float *dst)
365 {
366  const uint8_t *src = srcp + y * src_linesize + x;
367  int j;
368 
369  for (j = 0; j < block_size; j++) {
370  dst[j] = src[j];
371  }
372 }
373 
374 static void get_block_row16(const uint8_t *srcp, int src_linesize,
375  int y, int x, int block_size, float *dst)
376 {
377  const uint16_t *src = (uint16_t *)srcp + y * src_linesize / 2 + x;
378  int j;
379 
380  for (j = 0; j < block_size; j++) {
381  dst[j] = src[j];
382  }
383 }
384 
385 static void basic_block_filtering(BM3DContext *s, const uint8_t *src, int src_linesize,
386  const uint8_t *ref, int ref_linesize,
387  int y, int x, int plane, int jobnr)
388 {
389  SliceContext *sc = &s->slices[jobnr];
390  const int buffer_linesize = s->block_size * s->block_size;
391  const int nb_match_blocks = sc->nb_match_blocks;
392  const int block_size = s->block_size;
393  const int width = s->planewidth[plane];
394  const int pgroup_size = s->pgroup_size;
395  const int group_size = s->group_size;
396  float *buffer = sc->buffer;
397  float *bufferh = sc->bufferh;
398  float *bufferv = sc->bufferv;
399  float *bufferz = sc->bufferz;
400  float threshold[4];
401  float den_weight, num_weight;
402  int retained = 0;
403  int i, j, k;
404 
405  for (k = 0; k < nb_match_blocks; k++) {
406  const int y = sc->match_blocks[k].y;
407  const int x = sc->match_blocks[k].x;
408 
409  for (i = 0; i < block_size; i++) {
410  s->get_block_row(src, src_linesize, y + i, x, block_size, bufferh + block_size * i);
411  av_dct_calc(sc->dctf, bufferh + block_size * i);
412  }
413 
414  for (i = 0; i < block_size; i++) {
415  for (j = 0; j < block_size; j++) {
416  bufferv[i * block_size + j] = bufferh[j * block_size + i];
417  }
418  av_dct_calc(sc->dctf, bufferv + i * block_size);
419  }
420 
421  for (i = 0; i < block_size; i++) {
422  memcpy(buffer + k * buffer_linesize + i * block_size,
423  bufferv + i * block_size, block_size * 4);
424  }
425  }
426 
427  for (i = 0; i < block_size; i++) {
428  for (j = 0; j < block_size; j++) {
429  for (k = 0; k < nb_match_blocks; k++)
430  bufferz[k] = buffer[buffer_linesize * k + i * block_size + j];
431  if (group_size > 1)
432  av_dct_calc(sc->gdctf, bufferz);
433  bufferz += pgroup_size;
434  }
435  }
436 
437  threshold[0] = s->hard_threshold * s->sigma * M_SQRT2 * block_size * block_size * (1 << (s->depth - 8)) / 255.f;
438  threshold[1] = threshold[0] * sqrtf(2.f);
439  threshold[2] = threshold[0] * 2.f;
440  threshold[3] = threshold[0] * sqrtf(8.f);
441  bufferz = sc->bufferz;
442 
443  for (i = 0; i < block_size; i++) {
444  for (j = 0; j < block_size; j++) {
445  for (k = 0; k < nb_match_blocks; k++) {
446  const float thresh = threshold[(j == 0) + (i == 0) + (k == 0)];
447 
448  if (bufferz[k] > thresh || bufferz[k] < -thresh) {
449  retained++;
450  } else {
451  bufferz[k] = 0;
452  }
453  }
454  bufferz += pgroup_size;
455  }
456  }
457 
458  bufferz = sc->bufferz;
459  buffer = sc->buffer;
460  for (i = 0; i < block_size; i++) {
461  for (j = 0; j < block_size; j++) {
462  if (group_size > 1)
463  av_dct_calc(sc->gdcti, bufferz);
464  for (k = 0; k < nb_match_blocks; k++) {
465  buffer[buffer_linesize * k + i * block_size + j] = bufferz[k];
466  }
467  bufferz += pgroup_size;
468  }
469  }
470 
471  den_weight = retained < 1 ? 1.f : 1.f / retained;
472  num_weight = den_weight;
473 
474  buffer = sc->buffer;
475  for (k = 0; k < nb_match_blocks; k++) {
476  float *num = sc->num + y * width + x;
477  float *den = sc->den + y * width + x;
478 
479  for (i = 0; i < block_size; i++) {
480  memcpy(bufferv + i * block_size,
481  buffer + k * buffer_linesize + i * block_size,
482  block_size * 4);
483  }
484 
485  for (i = 0; i < block_size; i++) {
486  av_dct_calc(sc->dcti, bufferv + block_size * i);
487  for (j = 0; j < block_size; j++) {
488  bufferh[j * block_size + i] = bufferv[i * block_size + j];
489  }
490  }
491 
492  for (i = 0; i < block_size; i++) {
493  av_dct_calc(sc->dcti, bufferh + block_size * i);
494  for (j = 0; j < block_size; j++) {
495  num[j] += bufferh[i * block_size + j] * num_weight;
496  den[j] += den_weight;
497  }
498  num += width;
499  den += width;
500  }
501  }
502 }
503 
504 static void final_block_filtering(BM3DContext *s, const uint8_t *src, int src_linesize,
505  const uint8_t *ref, int ref_linesize,
506  int y, int x, int plane, int jobnr)
507 {
508  SliceContext *sc = &s->slices[jobnr];
509  const int buffer_linesize = s->block_size * s->block_size;
510  const int nb_match_blocks = sc->nb_match_blocks;
511  const int block_size = s->block_size;
512  const int width = s->planewidth[plane];
513  const int pgroup_size = s->pgroup_size;
514  const int group_size = s->group_size;
515  const float sigma_sqr = s->sigma * s->sigma;
516  float *buffer = sc->buffer;
517  float *bufferh = sc->bufferh;
518  float *bufferv = sc->bufferv;
519  float *bufferz = sc->bufferz;
520  float *rbuffer = sc->rbuffer;
521  float *rbufferh = sc->rbufferh;
522  float *rbufferv = sc->rbufferv;
523  float *rbufferz = sc->rbufferz;
524  float den_weight, num_weight;
525  float l2_wiener = 0;
526  int i, j, k;
527 
528  for (k = 0; k < nb_match_blocks; k++) {
529  const int y = sc->match_blocks[k].y;
530  const int x = sc->match_blocks[k].x;
531 
532  for (i = 0; i < block_size; i++) {
533  s->get_block_row(src, src_linesize, y + i, x, block_size, bufferh + block_size * i);
534  s->get_block_row(ref, ref_linesize, y + i, x, block_size, rbufferh + block_size * i);
535  av_dct_calc(sc->dctf, bufferh + block_size * i);
536  av_dct_calc(sc->dctf, rbufferh + block_size * i);
537  }
538 
539  for (i = 0; i < block_size; i++) {
540  for (j = 0; j < block_size; j++) {
541  bufferv[i * block_size + j] = bufferh[j * block_size + i];
542  rbufferv[i * block_size + j] = rbufferh[j * block_size + i];
543  }
544  av_dct_calc(sc->dctf, bufferv + i * block_size);
545  av_dct_calc(sc->dctf, rbufferv + i * block_size);
546  }
547 
548  for (i = 0; i < block_size; i++) {
549  memcpy(buffer + k * buffer_linesize + i * block_size,
550  bufferv + i * block_size, block_size * 4);
551  memcpy(rbuffer + k * buffer_linesize + i * block_size,
552  rbufferv + i * block_size, block_size * 4);
553  }
554  }
555 
556  for (i = 0; i < block_size; i++) {
557  for (j = 0; j < block_size; j++) {
558  for (k = 0; k < nb_match_blocks; k++) {
559  bufferz[k] = buffer[buffer_linesize * k + i * block_size + j];
560  rbufferz[k] = rbuffer[buffer_linesize * k + i * block_size + j];
561  }
562  if (group_size > 1) {
563  av_dct_calc(sc->gdctf, bufferz);
564  av_dct_calc(sc->gdctf, rbufferz);
565  }
566  bufferz += pgroup_size;
567  rbufferz += pgroup_size;
568  }
569  }
570 
571  bufferz = sc->bufferz;
572  rbufferz = sc->rbufferz;
573 
574  for (i = 0; i < block_size; i++) {
575  for (j = 0; j < block_size; j++) {
576  for (k = 0; k < nb_match_blocks; k++) {
577  const float ref_sqr = rbufferz[k] * rbufferz[k];
578  float wiener_coef = ref_sqr / (ref_sqr + sigma_sqr);
579 
580  if (isnan(wiener_coef))
581  wiener_coef = 1;
582  bufferz[k] *= wiener_coef;
583  l2_wiener += wiener_coef * wiener_coef;
584  }
585  bufferz += pgroup_size;
586  rbufferz += pgroup_size;
587  }
588  }
589 
590  bufferz = sc->bufferz;
591  buffer = sc->buffer;
592  for (i = 0; i < block_size; i++) {
593  for (j = 0; j < block_size; j++) {
594  if (group_size > 1)
595  av_dct_calc(sc->gdcti, bufferz);
596  for (k = 0; k < nb_match_blocks; k++) {
597  buffer[buffer_linesize * k + i * block_size + j] = bufferz[k];
598  }
599  bufferz += pgroup_size;
600  }
601  }
602 
603  l2_wiener = FFMAX(l2_wiener, 1e-15f);
604  den_weight = 1.f / l2_wiener;
605  num_weight = den_weight;
606 
607  for (k = 0; k < nb_match_blocks; k++) {
608  float *num = sc->num + y * width + x;
609  float *den = sc->den + y * width + x;
610 
611  for (i = 0; i < block_size; i++) {
612  memcpy(bufferv + i * block_size,
613  buffer + k * buffer_linesize + i * block_size,
614  block_size * 4);
615  }
616 
617  for (i = 0; i < block_size; i++) {
618  av_dct_calc(sc->dcti, bufferv + block_size * i);
619  for (j = 0; j < block_size; j++) {
620  bufferh[j * block_size + i] = bufferv[i * block_size + j];
621  }
622  }
623 
624  for (i = 0; i < block_size; i++) {
625  av_dct_calc(sc->dcti, bufferh + block_size * i);
626  for (j = 0; j < block_size; j++) {
627  num[j] += bufferh[i * block_size + j] * num_weight;
628  den[j] += den_weight;
629  }
630  num += width;
631  den += width;
632  }
633  }
634 }
635 
636 static void do_output(BM3DContext *s, uint8_t *dst, int dst_linesize,
637  int plane, int nb_jobs)
638 {
639  const int height = s->planeheight[plane];
640  const int width = s->planewidth[plane];
641  int i, j, k;
642 
643  for (i = 0; i < height; i++) {
644  for (j = 0; j < width; j++) {
645  uint8_t *dstp = dst + i * dst_linesize;
646  float sum_den = 0.f;
647  float sum_num = 0.f;
648 
649  for (k = 0; k < nb_jobs; k++) {
650  SliceContext *sc = &s->slices[k];
651  float num = sc->num[i * width + j];
652  float den = sc->den[i * width + j];
653 
654  sum_num += num;
655  sum_den += den;
656  }
657 
658  dstp[j] = av_clip_uint8(lrintf(sum_num / sum_den));
659  }
660  }
661 }
662 
663 static void do_output16(BM3DContext *s, uint8_t *dst, int dst_linesize,
664  int plane, int nb_jobs)
665 {
666  const int height = s->planeheight[plane];
667  const int width = s->planewidth[plane];
668  const int depth = s->depth;
669  int i, j, k;
670 
671  for (i = 0; i < height; i++) {
672  for (j = 0; j < width; j++) {
673  uint16_t *dstp = (uint16_t *)dst + i * dst_linesize / 2;
674  float sum_den = 0.f;
675  float sum_num = 0.f;
676 
677  for (k = 0; k < nb_jobs; k++) {
678  SliceContext *sc = &s->slices[k];
679  float num = sc->num[i * width + j];
680  float den = sc->den[i * width + j];
681 
682  sum_num += num;
683  sum_den += den;
684  }
685 
686  dstp[j] = av_clip_uintp2_c(lrintf(sum_num / sum_den), depth);
687  }
688  }
689 }
690 
691 static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
692 {
693  BM3DContext *s = ctx->priv;
694  SliceContext *sc = &s->slices[jobnr];
695  const int block_step = s->block_step;
696  ThreadData *td = arg;
697  const uint8_t *src = td->src;
698  const uint8_t *ref = td->ref;
699  const int src_linesize = td->src_linesize;
700  const int ref_linesize = td->ref_linesize;
701  const int plane = td->plane;
702  const int width = s->planewidth[plane];
703  const int height = s->planeheight[plane];
704  const int block_pos_bottom = FFMAX(0, height - s->block_size);
705  const int block_pos_right = FFMAX(0, width - s->block_size);
706  const int slice_start = (((height + block_step - 1) / block_step) * jobnr / nb_jobs) * block_step;
707  const int slice_end = (jobnr == nb_jobs - 1) ? block_pos_bottom + block_step :
708  (((height + block_step - 1) / block_step) * (jobnr + 1) / nb_jobs) * block_step;
709  int i, j;
710 
711  memset(sc->num, 0, width * height * sizeof(FFTSample));
712  memset(sc->den, 0, width * height * sizeof(FFTSample));
713 
714  for (j = slice_start; j < slice_end; j += block_step) {
715  if (j > block_pos_bottom) {
716  j = block_pos_bottom;
717  }
718 
719  for (i = 0; i < block_pos_right + block_step; i += block_step) {
720  if (i > block_pos_right) {
721  i = block_pos_right;
722  }
723 
724  block_matching(s, ref, ref_linesize, j, i, plane, jobnr);
725 
726  s->block_filtering(s, src, src_linesize,
727  ref, ref_linesize, j, i, plane, jobnr);
728  }
729  }
730 
731  return 0;
732 }
733 
735 {
736  BM3DContext *s = ctx->priv;
737  AVFilterLink *outlink = ctx->outputs[0];
738  int p;
739 
740  *out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
741  if (!*out)
742  return AVERROR(ENOMEM);
743  av_frame_copy_props(*out, in);
744 
745  for (p = 0; p < s->nb_planes; p++) {
746  const int nb_jobs = FFMAX(1, FFMIN(s->nb_threads, s->planeheight[p] / s->block_size));
747  ThreadData td;
748 
749  if (!((1 << p) & s->planes) || ctx->is_disabled) {
750  av_image_copy_plane((*out)->data[p], (*out)->linesize[p],
751  in->data[p], in->linesize[p],
752  s->planewidth[p], s->planeheight[p]);
753  continue;
754  }
755 
756  td.src = in->data[p];
757  td.src_linesize = in->linesize[p];
758  td.ref = ref->data[p];
759  td.ref_linesize = ref->linesize[p];
760  td.plane = p;
761  ff_filter_execute(ctx, filter_slice, &td, NULL, nb_jobs);
762 
763  s->do_output(s, (*out)->data[p], (*out)->linesize[p], p, nb_jobs);
764  }
765 
766  return 0;
767 }
768 
769 #define SQR(x) ((x) * (x))
770 
772 {
774  AVFilterContext *ctx = inlink->dst;
775  BM3DContext *s = ctx->priv;
776  int i, group_bits;
777 
779  s->nb_planes = av_pix_fmt_count_planes(inlink->format);
780  s->depth = desc->comp[0].depth;
781  s->max = (1 << s->depth) - 1;
782  s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
783  s->planeheight[0] = s->planeheight[3] = inlink->h;
784  s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
785  s->planewidth[0] = s->planewidth[3] = inlink->w;
786 
787  for (group_bits = 4; 1 << group_bits < s->group_size; group_bits++);
788  s->group_bits = group_bits;
789  s->pgroup_size = 1 << group_bits;
790 
791  for (i = 0; i < s->nb_threads; i++) {
792  SliceContext *sc = &s->slices[i];
793 
794  sc->num = av_calloc(FFALIGN(s->planewidth[0], s->block_size) * FFALIGN(s->planeheight[0], s->block_size), sizeof(FFTSample));
795  sc->den = av_calloc(FFALIGN(s->planewidth[0], s->block_size) * FFALIGN(s->planeheight[0], s->block_size), sizeof(FFTSample));
796  if (!sc->num || !sc->den)
797  return AVERROR(ENOMEM);
798 
799  sc->dctf = av_dct_init(av_log2(s->block_size), DCT_II);
800  sc->dcti = av_dct_init(av_log2(s->block_size), DCT_III);
801  if (!sc->dctf || !sc->dcti)
802  return AVERROR(ENOMEM);
803 
804  if (s->group_bits > 1) {
805  sc->gdctf = av_dct_init(s->group_bits, DCT_II);
806  sc->gdcti = av_dct_init(s->group_bits, DCT_III);
807  if (!sc->gdctf || !sc->gdcti)
808  return AVERROR(ENOMEM);
809  }
810 
811  sc->buffer = av_calloc(s->block_size * s->block_size * s->pgroup_size, sizeof(*sc->buffer));
812  sc->bufferz = av_calloc(s->block_size * s->block_size * s->pgroup_size, sizeof(*sc->bufferz));
813  sc->bufferh = av_calloc(s->block_size * s->block_size, sizeof(*sc->bufferh));
814  sc->bufferv = av_calloc(s->block_size * s->block_size, sizeof(*sc->bufferv));
815  if (!sc->bufferh || !sc->bufferv || !sc->buffer || !sc->bufferz)
816  return AVERROR(ENOMEM);
817 
818  if (s->mode == FINAL) {
819  sc->rbuffer = av_calloc(s->block_size * s->block_size * s->pgroup_size, sizeof(*sc->rbuffer));
820  sc->rbufferz = av_calloc(s->block_size * s->block_size * s->pgroup_size, sizeof(*sc->rbufferz));
821  sc->rbufferh = av_calloc(s->block_size * s->block_size, sizeof(*sc->rbufferh));
822  sc->rbufferv = av_calloc(s->block_size * s->block_size, sizeof(*sc->rbufferv));
823  if (!sc->rbufferh || !sc->rbufferv || !sc->rbuffer || !sc->rbufferz)
824  return AVERROR(ENOMEM);
825  }
826 
827  sc->search_positions = av_calloc(SQR(2 * s->bm_range / s->bm_step + 1), sizeof(*sc->search_positions));
828  if (!sc->search_positions)
829  return AVERROR(ENOMEM);
830  }
831 
832  s->do_output = do_output;
833  s->do_block_ssd = do_block_ssd;
834  s->get_block_row = get_block_row;
835 
836  if (s->depth > 8) {
837  s->do_output = do_output16;
838  s->do_block_ssd = do_block_ssd16;
839  s->get_block_row = get_block_row16;
840  }
841 
842  return 0;
843 }
844 
846 {
847  BM3DContext *s = ctx->priv;
848 
849  if (!s->ref) {
850  AVFrame *frame = NULL;
851  AVFrame *out = NULL;
852  int ret, status;
853  int64_t pts;
854 
855  FF_FILTER_FORWARD_STATUS_BACK(ctx->outputs[0], ctx->inputs[0]);
856 
857  if ((ret = ff_inlink_consume_frame(ctx->inputs[0], &frame)) > 0) {
860  if (ret < 0)
861  return ret;
862  ret = ff_filter_frame(ctx->outputs[0], out);
863  }
864  if (ret < 0) {
865  return ret;
866  } else if (ff_inlink_acknowledge_status(ctx->inputs[0], &status, &pts)) {
867  ff_outlink_set_status(ctx->outputs[0], status, pts);
868  return 0;
869  } else {
870  if (ff_outlink_frame_wanted(ctx->outputs[0]))
871  ff_inlink_request_frame(ctx->inputs[0]);
872  return 0;
873  }
874  } else {
875  return ff_framesync_activate(&s->fs);
876  }
877 }
878 
880 {
881  AVFilterContext *ctx = fs->parent;
882  BM3DContext *s = fs->opaque;
883  AVFilterLink *outlink = ctx->outputs[0];
884  AVFrame *out = NULL, *src, *ref;
885  int ret;
886 
887  if ((ret = ff_framesync_get_frame(&s->fs, 0, &src, 0)) < 0 ||
888  (ret = ff_framesync_get_frame(&s->fs, 1, &ref, 0)) < 0)
889  return ret;
890 
891  if ((ret = filter_frame(ctx, &out, src, ref)) < 0)
892  return ret;
893 
894  out->pts = av_rescale_q(src->pts, s->fs.time_base, outlink->time_base);
895 
896  return ff_filter_frame(outlink, out);
897 }
898 
900 {
901  BM3DContext *s = ctx->priv;
902  AVFilterPad pad = { 0 };
903  int ret;
904 
905  if (s->mode == BASIC) {
906  if (s->th_mse == 0.f)
907  s->th_mse = 400.f + s->sigma * 80.f;
908  s->block_filtering = basic_block_filtering;
909  } else if (s->mode == FINAL) {
910  if (!s->ref) {
911  av_log(ctx, AV_LOG_WARNING, "Reference stream is mandatory in final estimation mode.\n");
912  s->ref = 1;
913  }
914  if (s->th_mse == 0.f)
915  s->th_mse = 200.f + s->sigma * 10.f;
916 
917  s->block_filtering = final_block_filtering;
918  } else {
919  return AVERROR_BUG;
920  }
921 
922  s->block_size = 1 << s->block_size;
923 
924  if (s->block_step > s->block_size) {
925  av_log(ctx, AV_LOG_WARNING, "bstep: %d can't be bigger than block size. Changing to %d.\n",
926  s->block_step, s->block_size);
927  s->block_step = s->block_size;
928  }
929  if (s->bm_step > s->bm_range) {
930  av_log(ctx, AV_LOG_WARNING, "mstep: %d can't be bigger than block matching range. Changing to %d.\n",
931  s->bm_step, s->bm_range);
932  s->bm_step = s->bm_range;
933  }
934 
935  pad.type = AVMEDIA_TYPE_VIDEO;
936  pad.name = "source";
938 
939  if ((ret = ff_append_inpad(ctx, &pad)) < 0)
940  return ret;
941 
942  if (s->ref) {
943  pad.type = AVMEDIA_TYPE_VIDEO;
944  pad.name = "reference";
945  pad.config_props = NULL;
946 
947  if ((ret = ff_append_inpad(ctx, &pad)) < 0)
948  return ret;
949  }
950 
951  return 0;
952 }
953 
954 static int config_output(AVFilterLink *outlink)
955 {
956  AVFilterContext *ctx = outlink->src;
957  BM3DContext *s = ctx->priv;
958  AVFilterLink *src = ctx->inputs[0];
959  AVFilterLink *ref;
960  FFFrameSyncIn *in;
961  int ret;
962 
963  if (s->ref) {
964  ref = ctx->inputs[1];
965 
966  if (src->w != ref->w ||
967  src->h != ref->h) {
968  av_log(ctx, AV_LOG_ERROR, "First input link %s parameters "
969  "(size %dx%d) do not match the corresponding "
970  "second input link %s parameters (%dx%d) ",
971  ctx->input_pads[0].name, src->w, src->h,
972  ctx->input_pads[1].name, ref->w, ref->h);
973  return AVERROR(EINVAL);
974  }
975  }
976 
977  outlink->w = src->w;
978  outlink->h = src->h;
979  outlink->time_base = src->time_base;
980  outlink->sample_aspect_ratio = src->sample_aspect_ratio;
981  outlink->frame_rate = src->frame_rate;
982 
983  if (!s->ref)
984  return 0;
985 
986  if ((ret = ff_framesync_init(&s->fs, ctx, 2)) < 0)
987  return ret;
988 
989  in = s->fs.in;
990  in[0].time_base = src->time_base;
991  in[1].time_base = ref->time_base;
992  in[0].sync = 1;
993  in[0].before = EXT_STOP;
994  in[0].after = EXT_STOP;
995  in[1].sync = 1;
996  in[1].before = EXT_STOP;
997  in[1].after = EXT_STOP;
998  s->fs.opaque = s;
999  s->fs.on_event = process_frame;
1000 
1001  return ff_framesync_configure(&s->fs);
1002 }
1003 
1005 {
1006  BM3DContext *s = ctx->priv;
1007  int i;
1008 
1009  if (s->ref)
1010  ff_framesync_uninit(&s->fs);
1011 
1012  for (i = 0; i < s->nb_threads; i++) {
1013  SliceContext *sc = &s->slices[i];
1014 
1015  av_freep(&sc->num);
1016  av_freep(&sc->den);
1017 
1018  av_dct_end(sc->gdctf);
1019  av_dct_end(sc->gdcti);
1020  av_dct_end(sc->dctf);
1021  av_dct_end(sc->dcti);
1022 
1023  av_freep(&sc->buffer);
1024  av_freep(&sc->bufferh);
1025  av_freep(&sc->bufferv);
1026  av_freep(&sc->bufferz);
1027  av_freep(&sc->rbuffer);
1028  av_freep(&sc->rbufferh);
1029  av_freep(&sc->rbufferv);
1030  av_freep(&sc->rbufferz);
1031 
1032  av_freep(&sc->search_positions);
1033  }
1034 }
1035 
1036 static const AVFilterPad bm3d_outputs[] = {
1037  {
1038  .name = "default",
1039  .type = AVMEDIA_TYPE_VIDEO,
1040  .config_props = config_output,
1041  },
1042 };
1043 
1045  .name = "bm3d",
1046  .description = NULL_IF_CONFIG_SMALL("Block-Matching 3D denoiser."),
1047  .priv_size = sizeof(BM3DContext),
1048  .init = init,
1049  .uninit = uninit,
1050  .activate = activate,
1051  .inputs = NULL,
1054  .priv_class = &bm3d_class,
1058 };
SliceContext::num
float * num
Definition: vf_bm3d.c:82
ff_get_video_buffer
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:98
AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:434
AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:413
FFFrameSyncIn::time_base
AVRational time_base
Time base for the incoming frames.
Definition: framesync.h:96
ff_framesync_configure
int ff_framesync_configure(FFFrameSync *fs)
Configure a frame sync structure.
Definition: framesync.c:119
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
BM3DContext::slices
SliceContext slices[MAX_NB_THREADS]
Definition: vf_bm3d.c:111
td
#define td
Definition: regdef.h:70
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
status
they must not be accessed directly The fifo field contains the frames that are queued in the input for processing by the filter The status_in and status_out fields contains the queued status(EOF or error) of the link
r
const char * r
Definition: vf_curves.c:116
AVERROR
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
opt.h
ff_framesync_uninit
void ff_framesync_uninit(FFFrameSync *fs)
Free all memory currently allocated.
Definition: framesync.c:285
out
FILE * out
Definition: movenc.c:54
FLAGS
#define FLAGS
Definition: vf_bm3d.c:130
SliceContext::dcti
DCTContext * dcti
Definition: vf_bm3d.c:73
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1018
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2564
SliceContext::bufferz
FFTSample * bufferz
Definition: vf_bm3d.c:76
ff_framesync_get_frame
int ff_framesync_get_frame(FFFrameSync *fs, unsigned in, AVFrame **rframe, unsigned get)
Get the current frame in an input.
Definition: framesync.c:248
FILTER_PIXFMTS_ARRAY
#define FILTER_PIXFMTS_ARRAY(array)
Definition: internal.h:171
inlink
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
Definition: filter_design.txt:212
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:112
BM3DContext::do_block_ssd
double(* do_block_ssd)(struct BM3DContext *s, PosCode *pos, const uint8_t *src, int src_stride, int r_y, int r_x)
Definition: vf_bm3d.c:118
BM3DContext::th_mse
float th_mse
Definition: vf_bm3d.c:97
AV_PIX_FMT_YUVA422P9
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:426
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
pixdesc.h
av_clip_uintp2_c
static av_always_inline av_const unsigned av_clip_uintp2_c(int a, int p)
Clip a signed integer to an unsigned power of two range.
Definition: common.h:276
bm3d_options
static const AVOption bm3d_options[]
Definition: vf_bm3d.c:131
step
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
Definition: rate_distortion.txt:58
index
fg index
Definition: ffmpeg_filter.c:168
AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:433
ThreadData::ref_linesize
int ref_linesize
Definition: vf_bm3d.c:58
AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:428
AVOption
AVOption.
Definition: opt.h:247
BASIC
@ BASIC
Definition: vf_bm3d.c:49
b
#define b
Definition: input.c:40
NB_MODES
@ NB_MODES
Definition: vf_bm3d.c:51
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:391
av_dct_init
DCTContext * av_dct_init(int nbits, enum DCTTransformType type)
Set up DCT.
float.h
SliceContext::rbufferz
FFTSample * rbufferz
Definition: vf_bm3d.c:80
AV_PIX_FMT_YUV440P
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:153
FFFrameSync
Frame sync structure.
Definition: framesync.h:146
block_matching
static void block_matching(BM3DContext *s, const uint8_t *ref, int ref_linesize, int j, int i, int plane, int jobnr)
Definition: vf_bm3d.c:346
BM3DContext::block_step
int block_step
Definition: vf_bm3d.c:93
video.h
AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:429
SliceContext::nb_match_blocks
int nb_match_blocks
Definition: vf_bm3d.c:84
FF_FILTER_FORWARD_STATUS_BACK
#define FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink)
Forward the status on an output link to an input link.
Definition: filters.h:199
BM3DContext::planes
int planes
Definition: vf_bm3d.c:101
BM3DContext::mode
int mode
Definition: vf_bm3d.c:99
AV_PIX_FMT_GRAY9
#define AV_PIX_FMT_GRAY9
Definition: pixfmt.h:371
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:317
av_image_copy_plane
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:374
planes
static const struct @320 planes[]
do_block_ssd
static double do_block_ssd(BM3DContext *s, PosCode *pos, const uint8_t *src, int src_stride, int r_y, int r_x)
Definition: vf_bm3d.c:226
formats.h
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(bm3d)
ff_inlink_consume_frame
int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
Take a frame from the link's FIFO and update the link's stats.
Definition: avfilter.c:1417
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2604
AV_PIX_FMT_YUVA420P9
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:425
EXT_STOP
@ EXT_STOP
Completely stop all streams with this one.
Definition: framesync.h:65
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: vf_bm3d.c:163
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:409
ff_append_inpad
int ff_append_inpad(AVFilterContext *f, AVFilterPad *p)
Append a new input/output pad to the filter's list of such pads.
Definition: avfilter.c:139
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:205
DCT_III
@ DCT_III
Definition: avfft.h:95
BM3DContext::ref
int ref
Definition: vf_bm3d.c:100
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:407
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:435
FFFrameSyncIn
Input stream structure.
Definition: framesync.h:81
BM3DContext::hard_threshold
float hard_threshold
Definition: vf_bm3d.c:98
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:389
PosPairCode::x
int x
Definition: vf_bm3d.c:68
SliceContext::den
float * den
Definition: vf_bm3d.c:82
pts
static int64_t pts
Definition: transcode_aac.c:653
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:375
FFFrameSyncIn::sync
unsigned sync
Synchronization level: frames on input at the highest sync level will generate output frame events.
Definition: framesync.h:139
AVFILTER_FLAG_DYNAMIC_INPUTS
#define AVFILTER_FLAG_DYNAMIC_INPUTS
The number of the filter inputs is not determined just by AVFilter.inputs.
Definition: avfilter.h:110
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:50
FFDIFFSIGN
#define FFDIFFSIGN(x, y)
Comparator.
Definition: macros.h:45
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:394
AV_PIX_FMT_YUVJ411P
@ AV_PIX_FMT_YUVJ411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
Definition: pixfmt.h:248
BM3DContext::group_bits
int group_bits
Definition: vf_bm3d.c:108
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
inputs
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
Definition: filter_design.txt:243
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:403
SliceContext::match_blocks
PosPairCode match_blocks[256]
Definition: vf_bm3d.c:83
BM3DContext::fs
FFFrameSync fs
Definition: vf_bm3d.c:113
av_dct_end
void av_dct_end(DCTContext *s)
BM3DContext::do_output
void(* do_output)(struct BM3DContext *s, uint8_t *dst, int dst_linesize, int plane, int nb_jobs)
Definition: vf_bm3d.c:121
SliceContext::dctf
DCTContext * dctf
Definition: vf_bm3d.c:73
AV_PIX_FMT_YUVJ422P
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
Definition: pixfmt.h:79
AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:411
ThreadData::plane
int plane
Definition: vf_blend.c:85
ff_outlink_set_status
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
ff_inlink_request_frame
void ff_inlink_request_frame(AVFilterLink *link)
Mark that a frame is wanted on the link.
Definition: avfilter.c:1534
width
#define width
s
#define s(width, name)
Definition: cbs_vp9.c:257
AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:412
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
search_boundary
static int search_boundary(int plane_boundary, int search_range, int search_step, int vertical, int y, int x)
Definition: vf_bm3d.c:214
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:404
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:51
BM3DContext::bm_range
int bm_range
Definition: vf_bm3d.c:95
PosCode::x
int x
Definition: vf_bm3d.c:63
slice_end
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2041
PosCode
Definition: vf_bm3d.c:62
filters.h
AV_PIX_FMT_YUVA444P12
#define AV_PIX_FMT_YUVA444P12
Definition: pixfmt.h:432
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:388
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:402
ctx
AVFormatContext * ctx
Definition: movenc.c:48
final_block_filtering
static void final_block_filtering(BM3DContext *s, const uint8_t *src, int src_linesize, const uint8_t *ref, int ref_linesize, int y, int x, int plane, int jobnr)
Definition: vf_bm3d.c:504
AV_PIX_FMT_GRAY14
#define AV_PIX_FMT_GRAY14
Definition: pixfmt.h:374
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:141
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
BM3DContext::max
int max
Definition: vf_bm3d.c:104
filter_slice
static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_bm3d.c:691
f
#define f(width, name)
Definition: cbs_vp9.c:255
AV_PIX_FMT_YUVJ444P
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:80
arg
const char * arg
Definition: jacosubdec.c:67
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:372
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:410
SQR
#define SQR(x)
Definition: vf_bm3d.c:769
av_dct_calc
void av_dct_calc(DCTContext *s, FFTSample *data)
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
process_frame
static int process_frame(FFFrameSync *fs)
Definition: vf_bm3d.c:879
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:537
fs
#define fs(width, name, subs,...)
Definition: cbs_vp9.c:259
ThreadData::src
const uint8_t * src
Definition: vf_bm3d.c:55
basic_block_filtering
static void basic_block_filtering(BM3DContext *s, const uint8_t *src, int src_linesize, const uint8_t *ref, int ref_linesize, int y, int x, int plane, int jobnr)
Definition: vf_bm3d.c:385
isnan
#define isnan(x)
Definition: libm.h:340
AV_PIX_FMT_YUVJ420P
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:78
do_output
static void do_output(BM3DContext *s, uint8_t *dst, int dst_linesize, int plane, int nb_jobs)
Definition: vf_bm3d.c:636
src
#define src
Definition: vp8dsp.c:255
AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:393
MAX_NB_THREADS
#define MAX_NB_THREADS
Definition: vf_bm3d.c:46
FFTSample
float FFTSample
Definition: avfft.h:35
avfft.h
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:392
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
AV_PIX_FMT_GBRP9
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:406
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_bm3d.c:1004
BM3DContext::planewidth
int planewidth[4]
Definition: vf_bm3d.c:106
ff_inlink_acknowledge_status
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:1371
SliceContext::gdcti
DCTContext * gdcti
Definition: vf_bm3d.c:72
SliceContext
Definition: mss12.h:70
FINAL
@ FINAL
Definition: vf_bm3d.c:50
AVFilterPad::config_props
int(* config_props)(AVFilterLink *link)
Link configuration callback.
Definition: internal.h:130
cmp_scores
static int cmp_scores(const void *a, const void *b)
Definition: vf_bm3d.c:219
SliceContext::rbufferv
FFTSample * rbufferv
Definition: vf_bm3d.c:79
OFFSET
#define OFFSET(x)
Definition: vf_bm3d.c:129
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
BM3DContext::pgroup_size
int pgroup_size
Definition: vf_bm3d.c:109
PosPairCode
Definition: vf_bm3d.c:66
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:396
bm3d_outputs
static const AVFilterPad bm3d_outputs[]
Definition: vf_bm3d.c:1036
SliceContext::buffer
FFTSample * buffer
Definition: vf_bm3d.c:77
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:398
BM3DContext::bm_step
int bm_step
Definition: vf_bm3d.c:96
height
#define height
a
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:41
AV_PIX_FMT_YUVA444P
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:167
AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:430
BM3DContext::group_size
int group_size
Definition: vf_bm3d.c:94
SliceContext::search_positions
PosCode * search_positions
Definition: vf_bm3d.c:85
BM3DContext::planeheight
int planeheight[4]
Definition: vf_bm3d.c:107
internal.h
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Definition: opt.h:227
lrintf
#define lrintf(x)
Definition: libm_mips.h:72
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
BM3DContext::get_block_row
void(* get_block_row)(const uint8_t *srcp, int src_linesize, int y, int x, int block_size, float *dst)
Definition: vf_bm3d.c:116
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:408
do_output16
static void do_output16(BM3DContext *s, uint8_t *dst, int dst_linesize, int plane, int nb_jobs)
Definition: vf_bm3d.c:663
ff_filter_get_nb_threads
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:803
ThreadData
Used for passing data between threads.
Definition: dsddec.c:67
do_search_boundary
static int do_search_boundary(int pos, int plane_boundary, int search_range, int search_step)
Definition: vf_bm3d.c:189
config_input
static int config_input(AVFilterLink *inlink)
Definition: vf_bm3d.c:771
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
PosPairCode::y
int y
Definition: vf_bm3d.c:68
block_matching_multi
static void block_matching_multi(BM3DContext *s, const uint8_t *ref, int ref_linesize, int y, int x, int exclude_cur_pos, int plane, int jobnr)
Definition: vf_bm3d.c:306
AV_PIX_FMT_YUVJ440P
@ AV_PIX_FMT_YUVJ440P
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range
Definition: pixfmt.h:100
DCTContext
Definition: dct.h:32
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:56
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:271
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:390
filter_frame
static int filter_frame(AVFilterContext *ctx, AVFrame **out, AVFrame *in, AVFrame *ref)
Definition: vf_bm3d.c:734
do_block_matching_multi
static void do_block_matching_multi(BM3DContext *s, const uint8_t *src, int src_stride, int src_range, const PosCode *search_pos, int search_size, float th_mse, int r_y, int r_x, int plane, int jobnr)
Definition: vf_bm3d.c:268
AVFilter
Filter definition.
Definition: avfilter.h:149
ret
ret
Definition: filter_design.txt:187
AVFilterPad::type
enum AVMediaType type
AVFilterPad type.
Definition: internal.h:61
frame
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
Definition: filter_design.txt:264
AV_PIX_FMT_YUVA444P9
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:427
ff_framesync_init
int ff_framesync_init(FFFrameSync *fs, AVFilterContext *parent, unsigned nb_in)
Initialize a frame sync structure.
Definition: framesync.c:79
pos
unsigned int pos
Definition: spdifenc.c:412
SliceContext::rbufferh
FFTSample * rbufferh
Definition: vf_bm3d.c:78
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:395
AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:400
init
static av_cold int init(AVFilterContext *ctx)
Definition: vf_bm3d.c:899
ThreadData::src_linesize
int src_linesize
Definition: vf_bm3d.c:56
FFFrameSyncIn::before
enum FFFrameSyncExtMode before
Extrapolation mode for timestamps before the first frame.
Definition: framesync.h:86
BM3DContext::sigma
float sigma
Definition: vf_bm3d.c:91
framesync.h
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
mode
mode
Definition: ebur128.h:83
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
get_block_row
static void get_block_row(const uint8_t *srcp, int src_linesize, int y, int x, int block_size, float *dst)
Definition: vf_bm3d.c:363
AV_PIX_FMT_YUVA422P12
#define AV_PIX_FMT_YUVA422P12
Definition: pixfmt.h:431
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
avfilter.h
BM3DContext::block_size
int block_size
Definition: vf_bm3d.c:92
config_output
static int config_output(AVFilterLink *outlink)
Definition: vf_bm3d.c:954
SliceContext::bufferv
FFTSample * bufferv
Definition: vf_bm3d.c:75
PosCode::y
int y
Definition: vf_bm3d.c:63
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
temp
else temp
Definition: vf_mcdeint.c:248
SliceContext::rbuffer
FFTSample * rbuffer
Definition: vf_bm3d.c:81
do_block_ssd16
static double do_block_ssd16(BM3DContext *s, PosCode *pos, const uint8_t *src, int src_stride, int r_y, int r_x)
Definition: vf_bm3d.c:247
PosPairCode::score
double score
Definition: vf_bm3d.c:67
av_clip_uint8
#define av_clip_uint8
Definition: common.h:102
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
AVFilterContext
An instance of a filter.
Definition: avfilter.h:386
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:158
AVFILTER_FLAG_SLICE_THREADS
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:121
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
BM3DContext::nb_planes
int nb_planes
Definition: vf_bm3d.c:105
M_SQRT2
#define M_SQRT2
Definition: mathematics.h:61
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
SliceContext::bufferh
FFTSample * bufferh
Definition: vf_bm3d.c:74
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:241
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:192
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
BM3DContext::nb_threads
int nb_threads
Definition: vf_bm3d.c:114
AV_PIX_FMT_YUV411P
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
DCT_II
@ DCT_II
Definition: avfft.h:94
AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
#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:138
imgutils.h
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:334
AV_PIX_FMT_YUV410P
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
FFFrameSyncIn::after
enum FFFrameSyncExtMode after
Extrapolation mode for timestamps after the last frame.
Definition: framesync.h:91
BM3DContext::depth
int depth
Definition: vf_bm3d.c:103
AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:397
SliceContext::gdctf
DCTContext * gdctf
Definition: vf_bm3d.c:72
ff_outlink_frame_wanted
the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the ff_outlink_frame_wanted() function. If this function returns true
AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:401
BM3DContext::block_filtering
void(* block_filtering)(struct BM3DContext *s, const uint8_t *src, int src_linesize, const uint8_t *ref, int ref_linesize, int y, int x, int plane, int jobnr)
Definition: vf_bm3d.c:123
get_block_row16
static void get_block_row16(const uint8_t *srcp, int src_linesize, int y, int x, int block_size, float *dst)
Definition: vf_bm3d.c:374
ff_framesync_activate
int ff_framesync_activate(FFFrameSync *fs)
Examine the frames in the filter's input and try to produce output.
Definition: framesync.c:336
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:373
BM3DContext
Definition: vf_bm3d.c:88
ff_filter_execute
static av_always_inline int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
Definition: internal.h:143
ThreadData::ref
const uint8_t * ref
Definition: vf_bm3d.c:57
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:233
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
ff_vf_bm3d
const AVFilter ff_vf_bm3d
Definition: vf_bm3d.c:1044
AV_PIX_FMT_YUVA422P
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:166
AV_PIX_FMT_YUV420P14
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:399
activate
static int activate(AVFilterContext *ctx)
Definition: vf_bm3d.c:845
FilterModes
FilterModes
Definition: vf_bm3d.c:48