FFmpeg coverage

Directory:	../../../ffmpeg/
File:	src/libavfilter/vf_chromanr.c
Date:	2026-04-24 19:58:39

	Total	Coverage
Lines:	56	0.0%
Functions:	10	0.0%
Branches:	146	0.0%

  
      Line
      Branch
      Exec
      Source
    
      /*
    
       * Copyright (c) 2020 Paul B Mahol
    
       *
    
       * This file is part of FFmpeg.
    
       *
    
       * FFmpeg is free software; you can redistribute it and/or
    
       * modify it under the terms of the GNU Lesser General Public
    
       * License as published by the Free Software Foundation; either
    
       * version 2.1 of the License, or (at your option) any later version.
    
       *
    
       * FFmpeg is distributed in the hope that it will be useful,
    
       * but WITHOUT ANY WARRANTY; without even the implied warranty of
    
       * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    
       * Lesser General Public License for more details.
    
       *
    
       * You should have received a copy of the GNU Lesser General Public
    
       * License along with FFmpeg; if not, write to the Free Software
    
       * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
    
       */
    
      #include "libavutil/imgutils.h"
    
      #include "libavutil/opt.h"
    
      #include "libavutil/pixdesc.h"
    
      #include "avfilter.h"
    
      #include "filters.h"
    
      #include "video.h"
    
      typedef struct ChromaNRContext {
    
          const AVClass *class;
    
          float threshold;
    
          float threshold_y;
    
          float threshold_u;
    
          float threshold_v;
    
          int distance;
    
          int thres;
    
          int thres_y;
    
          int thres_u;
    
          int thres_v;
    
          int sizew;
    
          int sizeh;
    
          int stepw;
    
          int steph;
    
          int depth;
    
          int chroma_w;
    
          int chroma_h;
    
          int nb_planes;
    
          int linesize[4];
    
          int planeheight[4];
    
          int planewidth[4];
    
          AVFrame *out;
    
          int (*filter_slice)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
    
      } ChromaNRContext;
    
      static const enum AVPixelFormat pix_fmts[] = {
    
          AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV444P,
    
          AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
    
          AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ411P,
    
          AV_PIX_FMT_YUV420P9,   AV_PIX_FMT_YUV422P9,   AV_PIX_FMT_YUV444P9,
    
          AV_PIX_FMT_YUV420P10,  AV_PIX_FMT_YUV422P10,  AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV444P10,
    
          AV_PIX_FMT_YUV444P12,  AV_PIX_FMT_YUV422P12,  AV_PIX_FMT_YUV440P12, AV_PIX_FMT_YUV420P12,
    
          AV_PIX_FMT_YUV444P14,  AV_PIX_FMT_YUV422P14,  AV_PIX_FMT_YUV420P14,
    
          AV_PIX_FMT_YUV420P16,  AV_PIX_FMT_YUV422P16,  AV_PIX_FMT_YUV444P16,
    
          AV_PIX_FMT_YUVA420P9,  AV_PIX_FMT_YUVA422P9,  AV_PIX_FMT_YUVA444P9,
    
          AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,
    
          AV_PIX_FMT_YUVA422P12, AV_PIX_FMT_YUVA444P12,
    
          AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
    
          AV_PIX_FMT_NONE
    
      };
    
      #define MANHATTAN_DISTANCE(x, y, z) ((x) + (y) + (z))
    
      #define EUCLIDEAN_DISTANCE(x, y, z) (sqrtf((x)*(x) + (y)*(y) + (z)*(z)))
    
      #define FILTER_FUNC(distance, name, ctype, type, fun, extra)                             \
    
      static int distance ## _slice##name(AVFilterContext *ctx, void *arg,                     \
    
                                          int jobnr, int nb_jobs)                              \
    
      {                                                                                        \
    
          ChromaNRContext *s = ctx->priv;                                                      \
    
          AVFrame *in = arg;                                                                   \
    
          AVFrame *out = s->out;                                                               \
    
                                                                                               \
    
          {                                                                                    \
    
              const int h = s->planeheight[0];                                                 \
    
              const int slice_start = (h * jobnr) / nb_jobs;                                   \
    
              const int slice_end = (h * (jobnr+1)) / nb_jobs;                                 \
    
                                                                                               \
    
              av_image_copy_plane(out->data[0] + slice_start * out->linesize[0],               \
    
                                  out->linesize[0],                                            \
    
                                  in->data[0] + slice_start * in->linesize[0],                 \
    
                                  in->linesize[0],                                             \
    
                                  s->linesize[0], slice_end - slice_start);                    \
    
                                                                                               \
    
              if (s->nb_planes == 4) {                                                         \
    
                  av_image_copy_plane(out->data[3] + slice_start * out->linesize[3],           \
    
                                      out->linesize[3],                                        \
    
                                      in->data[3] + slice_start * in->linesize[3],             \
    
                                      in->linesize[3],                                         \
    
                                      s->linesize[3], slice_end - slice_start);                \
    
              }                                                                                \
    
          }                                                                                    \
    
                                                                                               \
    
          const int in_ylinesize = in->linesize[0];                                            \
    
          const int in_ulinesize = in->linesize[1];                                            \
    
          const int in_vlinesize = in->linesize[2];                                            \
    
          const int out_ulinesize = out->linesize[1];                                          \
    
          const int out_vlinesize = out->linesize[2];                                          \
    
          const int chroma_w = s->chroma_w;                                                    \
    
          const int chroma_h = s->chroma_h;                                                    \
    
          const int stepw = s->stepw;                                                          \
    
          const int steph = s->steph;                                                          \
    
          const int sizew = s->sizew;                                                          \
    
          const int sizeh = s->sizeh;                                                          \
    
          const int thres = s->thres;                                                          \
    
          const int thres_y = s->thres_y;                                                      \
    
          const int thres_u = s->thres_u;                                                      \
    
          const int thres_v = s->thres_v;                                                      \
    
          const int h = s->planeheight[1];                                                     \
    
          const int w = s->planewidth[1];                                                      \
    
          const int slice_start = (h * jobnr) / nb_jobs;                                       \
    
          const int slice_end = (h * (jobnr+1)) / nb_jobs;                                     \
    
          type *out_uptr = (type *)(out->data[1] + slice_start * out_ulinesize);               \
    
          type *out_vptr = (type *)(out->data[2] + slice_start * out_vlinesize);               \
    
                                                                                               \
    
          for (int y = slice_start; y < slice_end; y++) {                                      \
    
              const type *in_yptr = (const type *)(in->data[0] + y * chroma_h * in_ylinesize); \
    
              const type *in_uptr = (const type *)(in->data[1] + y * in_ulinesize);            \
    
              const type *in_vptr = (const type *)(in->data[2] + y * in_vlinesize);            \
    
              const int yystart = FFMAX(0, y - sizeh);                                         \
    
              const int yystop  = FFMIN(h - 1, y + sizeh);                                     \
    
                                                                                               \
    
              for (int x = 0; x < w; x++) {                                                    \
    
                  const int xxstart = FFMAX(0, x - sizew);                                     \
    
                  const int xxstop  = FFMIN(w - 1, x + sizew);                                 \
    
                  const int cy = in_yptr[x * chroma_w];                                        \
    
                  const int cu = in_uptr[x];                                                   \
    
                  const int cv = in_vptr[x];                                                   \
    
                  int su = cu;                                                                 \
    
                  int sv = cv;                                                                 \
    
                  int cn = 1;                                                                  \
    
                                                                                               \
    
                  for (int yy = yystart; yy <= yystop; yy += steph) {                          \
    
                      const type *in_y = (const type *)(in->data[0] + yy * chroma_h * in_ylinesize); \
    
                      const type *in_u = (const type *)(in->data[1] + yy * in_ulinesize);            \
    
                      const type *in_v = (const type *)(in->data[2] + yy * in_vlinesize);            \
    
                                                                                                        \
    
                      for (int xx = xxstart; xx <= xxstop; xx += stepw) {                    \
    
                          const ctype Y = in_y[xx * chroma_w];                               \
    
                          const ctype U = in_u[xx];                                          \
    
                          const ctype V = in_v[xx];                                          \
    
                          const ctype cyY = FFABS(cy - Y);                                   \
    
                          const ctype cuU = FFABS(cu - U);                                   \
    
                          const ctype cvV = FFABS(cv - V);                                   \
    
                                                                                             \
    
                          if (extra && fun(cyY, cuU, cvV) < thres &&                         \
    
                              cuU < thres_u && cvV < thres_v &&                              \
    
                              cyY < thres_y) {                                               \
    
                              su += U;                                                       \
    
                              sv += V;                                                       \
    
                              cn++;                                                          \
    
                          } else if (!extra && fun(cyY, cuU, cvV) < thres) {                 \
    
                              su += U;                                                       \
    
                              sv += V;                                                       \
    
                              cn++;                                                          \
    
                          }                                                                  \
    
                      }                                                                      \
    
                  }                                                                          \
    
                                                                                             \
    
                  out_uptr[x] = (su + (cn >> 1)) / cn;                                       \
    
                  out_vptr[x] = (sv + (cn >> 1)) / cn;                                       \
    
              }                                                                              \
    
                                                                                             \
    
              out_uptr += out_ulinesize / sizeof(type);                                      \
    
              out_vptr += out_vlinesize / sizeof(type);                                      \
    
          }                                                                                  \
    
                                                                                             \
    
          return 0;                                                                          \
    
      }
    
      ✗
      FILTER_FUNC(manhattan, 8,  int, uint8_t, MANHATTAN_DISTANCE, 0)
    
      ✗
      FILTER_FUNC(manhattan, 16, int, uint16_t, MANHATTAN_DISTANCE, 0)
    
      ✗
      FILTER_FUNC(euclidean, 8,  int, uint8_t, EUCLIDEAN_DISTANCE, 0)
    
      ✗
      FILTER_FUNC(euclidean, 16, int64_t, uint16_t, EUCLIDEAN_DISTANCE, 0)
    
      ✗
      FILTER_FUNC(manhattan_e, 8,  int, uint8_t, MANHATTAN_DISTANCE, 1)
    
      ✗
      FILTER_FUNC(manhattan_e, 16, int, uint16_t, MANHATTAN_DISTANCE, 1)
    
      ✗
      FILTER_FUNC(euclidean_e, 8,  int, uint8_t, EUCLIDEAN_DISTANCE, 1)
    
      ✗
      FILTER_FUNC(euclidean_e, 16, int64_t, uint16_t, EUCLIDEAN_DISTANCE, 1)
    
      ✗
      static int filter_frame(AVFilterLink *inlink, AVFrame *in)
    
      {
    
      ✗
          AVFilterContext *ctx = inlink->dst;
    
      ✗
          AVFilterLink *outlink = ctx->outputs[0];
    
      ✗
          ChromaNRContext *s = ctx->priv;
    
          AVFrame *out;
    
      ✗
          switch (s->distance) {
    
      ✗
          case 0:
    
      ✗
              s->filter_slice = s->depth <= 8 ? manhattan_slice8 : manhattan_slice16;
    
      ✗
              break;
    
      ✗
          case 1:
    
      ✗
              s->filter_slice = s->depth <= 8 ? euclidean_slice8 : euclidean_slice16;
    
      ✗
              break;
    
          }
    
      ✗
          s->thres = s->threshold * (1 << (s->depth - 8));
    
      ✗
          s->thres_y = s->threshold_y * (1 << (s->depth - 8));
    
      ✗
          s->thres_u = s->threshold_u * (1 << (s->depth - 8));
    
      ✗
          s->thres_v = s->threshold_v * (1 << (s->depth - 8));
    
      ✗
          if (s->threshold_y < 200.f || s->threshold_u < 200.f || s->threshold_v < 200.f) {
    
      ✗
              switch (s->distance) {
    
      ✗
              case 0:
    
      ✗
                  s->filter_slice = s->depth <= 8 ? manhattan_e_slice8 : manhattan_e_slice16;
    
      ✗
                  break;
    
      ✗
              case 1:
    
      ✗
                  s->filter_slice = s->depth <= 8 ? euclidean_e_slice8 : euclidean_e_slice16;
    
      ✗
                  break;
    
              }
    
          }
    
      ✗
          out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
    
      ✗
          if (!out) {
    
      ✗
              av_frame_free(&in);
    
      ✗
              return AVERROR(ENOMEM);
    
          }
    
      ✗
          av_frame_copy_props(out, in);
    
      ✗
          s->out = out;
    
      ✗
          ff_filter_execute(ctx, s->filter_slice, in, NULL,
    
      ✗
                            FFMIN3(s->planeheight[1],
    
                                   s->planeheight[2],
    
                                   ff_filter_get_nb_threads(ctx)));
    
      ✗
          av_frame_free(&in);
    
      ✗
          return ff_filter_frame(outlink, out);
    
      }
    
      ✗
      static int config_input(AVFilterLink *inlink)
    
      {
    
      ✗
          AVFilterContext *ctx = inlink->dst;
    
      ✗
          ChromaNRContext *s = ctx->priv;
    
      ✗
          const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
    
          int ret;
    
      ✗
          s->nb_planes = desc->nb_components;
    
      ✗
          s->depth = desc->comp[0].depth;
    
      ✗
          s->chroma_w = 1 << desc->log2_chroma_w;
    
      ✗
          s->chroma_h = 1 << desc->log2_chroma_h;
    
      ✗
          s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
    
      ✗
          s->planeheight[0] = s->planeheight[3] = inlink->h;
    
      ✗
          s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
    
      ✗
          s->planewidth[0] = s->planewidth[3] = inlink->w;
    
      ✗
          if ((ret = av_image_fill_linesizes(s->linesize, inlink->format, inlink->w)) < 0)
    
      ✗
              return ret;
    
      ✗
          return 0;
    
      }
    
      #define OFFSET(x) offsetof(ChromaNRContext, x)
    
      #define VF AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_RUNTIME_PARAM
    
      static const AVOption chromanr_options[] = {
    
          { "thres", "set y+u+v threshold", OFFSET(threshold), AV_OPT_TYPE_FLOAT, {.dbl=30}, 1,   200, VF },
    
          { "sizew", "set horizontal patch size", OFFSET(sizew),     AV_OPT_TYPE_INT,   {.i64=5},  1,   100, VF },
    
          { "sizeh", "set vertical patch size",   OFFSET(sizeh),     AV_OPT_TYPE_INT,   {.i64=5},  1,   100, VF },
    
          { "stepw", "set horizontal step", OFFSET(stepw),     AV_OPT_TYPE_INT,   {.i64=1},  1,    50, VF },
    
          { "steph", "set vertical step",   OFFSET(steph),     AV_OPT_TYPE_INT,   {.i64=1},  1,    50, VF },
    
          { "threy", "set y threshold",   OFFSET(threshold_y), AV_OPT_TYPE_FLOAT, {.dbl=200},1,   200, VF },
    
          { "threu", "set u threshold",   OFFSET(threshold_u), AV_OPT_TYPE_FLOAT, {.dbl=200},1,   200, VF },
    
          { "threv", "set v threshold",   OFFSET(threshold_v), AV_OPT_TYPE_FLOAT, {.dbl=200},1,   200, VF },
    
          { "distance", "set distance type", OFFSET(distance), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, VF, .unit = "distance" },
    
          {   "manhattan", "", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, VF, .unit = "distance" },
    
          {   "euclidean", "", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, VF, .unit = "distance" },
    
          { NULL }
    
      };
    
      static const AVFilterPad inputs[] = {
    
          {
    
              .name         = "default",
    
              .type         = AVMEDIA_TYPE_VIDEO,
    
              .filter_frame = filter_frame,
    
              .config_props = config_input,
    
          },
    
      };
    
      AVFILTER_DEFINE_CLASS(chromanr);
    
      const FFFilter ff_vf_chromanr = {
    
          .p.name        = "chromanr",
    
          .p.description = NULL_IF_CONFIG_SMALL("Reduce chrominance noise."),
    
          .p.priv_class  = &chromanr_class,
    
          .p.flags       = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
    
          .priv_size     = sizeof(ChromaNRContext),
    
          FILTER_OUTPUTS(ff_video_default_filterpad),
    
          FILTER_INPUTS(inputs),
    
          FILTER_PIXFMTS_ARRAY(pix_fmts),
    
          .process_command = ff_filter_process_command,
    
      };

Line	Exec	Source
1		/*
2		* Copyright (c) 2020 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 "video.h"
28
29		typedef struct ChromaNRContext {
30		const AVClass *class;
31
32		float threshold;
33		float threshold_y;
34		float threshold_u;
35		float threshold_v;
36		int distance;
37		int thres;
38		int thres_y;
39		int thres_u;
40		int thres_v;
41		int sizew;
42		int sizeh;
43		int stepw;
44		int steph;
45		int depth;
46		int chroma_w;
47		int chroma_h;
48		int nb_planes;
49		int linesize[4];
50		int planeheight[4];
51		int planewidth[4];
52
53		AVFrame *out;
54		int (filter_slice)(AVFilterContext ctx, void *arg, int jobnr, int nb_jobs);
55		} ChromaNRContext;
56
57		static const enum AVPixelFormat pix_fmts[] = {
58		AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV444P,
59		AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
60		AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ411P,
61		AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
62		AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV444P10,
63		AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV440P12, AV_PIX_FMT_YUV420P12,
64		AV_PIX_FMT_YUV444P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV420P14,
65		AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,
66		AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9,
67		AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,
68		AV_PIX_FMT_YUVA422P12, AV_PIX_FMT_YUVA444P12,
69		AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
70		AV_PIX_FMT_NONE
71		};
72
73		#define MANHATTAN_DISTANCE(x, y, z) ((x) + (y) + (z))
74		#define EUCLIDEAN_DISTANCE(x, y, z) (sqrtf((x)(x) + (y)(y) + (z)*(z)))
75
76		#define FILTER_FUNC(distance, name, ctype, type, fun, extra) \
77		static int distance ## _slice##name(AVFilterContext ctx, void arg, \
78		int jobnr, int nb_jobs) \
79		{ \
80		ChromaNRContext *s = ctx->priv; \
81		AVFrame *in = arg; \
82		AVFrame *out = s->out; \
83		\
84		{ \
85		const int h = s->planeheight[0]; \
86		const int slice_start = (h * jobnr) / nb_jobs; \
87		const int slice_end = (h * (jobnr+1)) / nb_jobs; \
88		\
89		av_image_copy_plane(out->data[0] + slice_start * out->linesize[0], \
90		out->linesize[0], \
91		in->data[0] + slice_start * in->linesize[0], \
92		in->linesize[0], \
93		s->linesize[0], slice_end - slice_start); \
94		\
95		if (s->nb_planes == 4) { \
96		av_image_copy_plane(out->data[3] + slice_start * out->linesize[3], \
97		out->linesize[3], \
98		in->data[3] + slice_start * in->linesize[3], \
99		in->linesize[3], \
100		s->linesize[3], slice_end - slice_start); \
101		} \
102		} \
103		\
104		const int in_ylinesize = in->linesize[0]; \
105		const int in_ulinesize = in->linesize[1]; \
106		const int in_vlinesize = in->linesize[2]; \
107		const int out_ulinesize = out->linesize[1]; \
108		const int out_vlinesize = out->linesize[2]; \
109		const int chroma_w = s->chroma_w; \
110		const int chroma_h = s->chroma_h; \
111		const int stepw = s->stepw; \
112		const int steph = s->steph; \
113		const int sizew = s->sizew; \
114		const int sizeh = s->sizeh; \
115		const int thres = s->thres; \
116		const int thres_y = s->thres_y; \
117		const int thres_u = s->thres_u; \
118		const int thres_v = s->thres_v; \
119		const int h = s->planeheight[1]; \
120		const int w = s->planewidth[1]; \
121		const int slice_start = (h * jobnr) / nb_jobs; \
122		const int slice_end = (h * (jobnr+1)) / nb_jobs; \
123		type out_uptr = (type )(out->data[1] + slice_start * out_ulinesize); \
124		type out_vptr = (type )(out->data[2] + slice_start * out_vlinesize); \
125		\
126		for (int y = slice_start; y < slice_end; y++) { \
127		const type in_yptr = (const type )(in->data[0] + y * chroma_h * in_ylinesize); \
128		const type in_uptr = (const type )(in->data[1] + y * in_ulinesize); \
129		const type in_vptr = (const type )(in->data[2] + y * in_vlinesize); \
130		const int yystart = FFMAX(0, y - sizeh); \
131		const int yystop = FFMIN(h - 1, y + sizeh); \
132		\
133		for (int x = 0; x < w; x++) { \
134		const int xxstart = FFMAX(0, x - sizew); \
135		const int xxstop = FFMIN(w - 1, x + sizew); \
136		const int cy = in_yptr[x * chroma_w]; \
137		const int cu = in_uptr[x]; \
138		const int cv = in_vptr[x]; \
139		int su = cu; \
140		int sv = cv; \
141		int cn = 1; \
142		\
143		for (int yy = yystart; yy <= yystop; yy += steph) { \
144		const type in_y = (const type )(in->data[0] + yy * chroma_h * in_ylinesize); \
145		const type in_u = (const type )(in->data[1] + yy * in_ulinesize); \
146		const type in_v = (const type )(in->data[2] + yy * in_vlinesize); \
147		\
148		for (int xx = xxstart; xx <= xxstop; xx += stepw) { \
149		const ctype Y = in_y[xx * chroma_w]; \
150		const ctype U = in_u[xx]; \
151		const ctype V = in_v[xx]; \
152		const ctype cyY = FFABS(cy - Y); \
153		const ctype cuU = FFABS(cu - U); \
154		const ctype cvV = FFABS(cv - V); \
155		\
156		if (extra && fun(cyY, cuU, cvV) < thres && \
157		cuU < thres_u && cvV < thres_v && \
158		cyY < thres_y) { \
159		su += U; \
160		sv += V; \
161		cn++; \
162		} else if (!extra && fun(cyY, cuU, cvV) < thres) { \
163		su += U; \
164		sv += V; \
165		cn++; \
166		} \
167		} \
168		} \
169		\
170		out_uptr[x] = (su + (cn >> 1)) / cn; \
171		out_vptr[x] = (sv + (cn >> 1)) / cn; \
172		} \
173		\
174		out_uptr += out_ulinesize / sizeof(type); \
175		out_vptr += out_vlinesize / sizeof(type); \
176		} \
177		\
178		return 0; \
179		}
180
181	✗	FILTER_FUNC(manhattan, 8, int, uint8_t, MANHATTAN_DISTANCE, 0)
182	✗	FILTER_FUNC(manhattan, 16, int, uint16_t, MANHATTAN_DISTANCE, 0)
183
184	✗	FILTER_FUNC(euclidean, 8, int, uint8_t, EUCLIDEAN_DISTANCE, 0)
185	✗	FILTER_FUNC(euclidean, 16, int64_t, uint16_t, EUCLIDEAN_DISTANCE, 0)
186
187	✗	FILTER_FUNC(manhattan_e, 8, int, uint8_t, MANHATTAN_DISTANCE, 1)
188	✗	FILTER_FUNC(manhattan_e, 16, int, uint16_t, MANHATTAN_DISTANCE, 1)
189
190	✗	FILTER_FUNC(euclidean_e, 8, int, uint8_t, EUCLIDEAN_DISTANCE, 1)
191	✗	FILTER_FUNC(euclidean_e, 16, int64_t, uint16_t, EUCLIDEAN_DISTANCE, 1)
192
193	✗	static int filter_frame(AVFilterLink inlink, AVFrame in)
194		{
195	✗	AVFilterContext *ctx = inlink->dst;
196	✗	AVFilterLink *outlink = ctx->outputs[0];
197	✗	ChromaNRContext *s = ctx->priv;
198		AVFrame *out;
199
200	✗	switch (s->distance) {
201	✗	case 0:
202	✗	s->filter_slice = s->depth <= 8 ? manhattan_slice8 : manhattan_slice16;
203	✗	break;
204	✗	case 1:
205	✗	s->filter_slice = s->depth <= 8 ? euclidean_slice8 : euclidean_slice16;
206	✗	break;
207		}
208
209	✗	s->thres = s->threshold * (1 << (s->depth - 8));
210	✗	s->thres_y = s->threshold_y * (1 << (s->depth - 8));
211	✗	s->thres_u = s->threshold_u * (1 << (s->depth - 8));
212	✗	s->thres_v = s->threshold_v * (1 << (s->depth - 8));
213
214	✗	if (s->threshold_y < 200.f \|\| s->threshold_u < 200.f \|\| s->threshold_v < 200.f) {
215	✗	switch (s->distance) {
216	✗	case 0:
217	✗	s->filter_slice = s->depth <= 8 ? manhattan_e_slice8 : manhattan_e_slice16;
218	✗	break;
219	✗	case 1:
220	✗	s->filter_slice = s->depth <= 8 ? euclidean_e_slice8 : euclidean_e_slice16;
221	✗	break;
222		}
223		}
224
225	✗	out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
226	✗	if (!out) {
227	✗	av_frame_free(&in);
228	✗	return AVERROR(ENOMEM);
229		}
230
231	✗	av_frame_copy_props(out, in);
232	✗	s->out = out;
233	✗	ff_filter_execute(ctx, s->filter_slice, in, NULL,
234	✗	FFMIN3(s->planeheight[1],
235		s->planeheight[2],
236		ff_filter_get_nb_threads(ctx)));
237
238	✗	av_frame_free(&in);
239	✗	return ff_filter_frame(outlink, out);
240		}
241
242	✗	static int config_input(AVFilterLink *inlink)
243		{
244	✗	AVFilterContext *ctx = inlink->dst;
245	✗	ChromaNRContext *s = ctx->priv;
246	✗	const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
247		int ret;
248
249	✗	s->nb_planes = desc->nb_components;
250	✗	s->depth = desc->comp[0].depth;
251	✗	s->chroma_w = 1 << desc->log2_chroma_w;
252	✗	s->chroma_h = 1 << desc->log2_chroma_h;
253	✗	s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
254	✗	s->planeheight[0] = s->planeheight[3] = inlink->h;
255	✗	s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
256	✗	s->planewidth[0] = s->planewidth[3] = inlink->w;
257
258	✗	if ((ret = av_image_fill_linesizes(s->linesize, inlink->format, inlink->w)) < 0)
259	✗	return ret;
260
261	✗	return 0;
262		}
263
264		#define OFFSET(x) offsetof(ChromaNRContext, x)
265		#define VF AV_OPT_FLAG_VIDEO_PARAM \| AV_OPT_FLAG_FILTERING_PARAM \| AV_OPT_FLAG_RUNTIME_PARAM
266
267		static const AVOption chromanr_options[] = {
268		{ "thres", "set y+u+v threshold", OFFSET(threshold), AV_OPT_TYPE_FLOAT, {.dbl=30}, 1, 200, VF },
269		{ "sizew", "set horizontal patch size", OFFSET(sizew), AV_OPT_TYPE_INT, {.i64=5}, 1, 100, VF },
270		{ "sizeh", "set vertical patch size", OFFSET(sizeh), AV_OPT_TYPE_INT, {.i64=5}, 1, 100, VF },
271		{ "stepw", "set horizontal step", OFFSET(stepw), AV_OPT_TYPE_INT, {.i64=1}, 1, 50, VF },
272		{ "steph", "set vertical step", OFFSET(steph), AV_OPT_TYPE_INT, {.i64=1}, 1, 50, VF },
273		{ "threy", "set y threshold", OFFSET(threshold_y), AV_OPT_TYPE_FLOAT, {.dbl=200},1, 200, VF },
274		{ "threu", "set u threshold", OFFSET(threshold_u), AV_OPT_TYPE_FLOAT, {.dbl=200},1, 200, VF },
275		{ "threv", "set v threshold", OFFSET(threshold_v), AV_OPT_TYPE_FLOAT, {.dbl=200},1, 200, VF },
276		{ "distance", "set distance type", OFFSET(distance), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, VF, .unit = "distance" },
277		{ "manhattan", "", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, VF, .unit = "distance" },
278		{ "euclidean", "", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, VF, .unit = "distance" },
279		{ NULL }
280		};
281
282		static const AVFilterPad inputs[] = {
283		{
284		.name = "default",
285		.type = AVMEDIA_TYPE_VIDEO,
286		.filter_frame = filter_frame,
287		.config_props = config_input,
288		},
289		};
290
291		AVFILTER_DEFINE_CLASS(chromanr);
292
293		const FFFilter ff_vf_chromanr = {
294		.p.name = "chromanr",
295		.p.description = NULL_IF_CONFIG_SMALL("Reduce chrominance noise."),
296		.p.priv_class = &chromanr_class,
297		.p.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC \| AVFILTER_FLAG_SLICE_THREADS,
298		.priv_size = sizeof(ChromaNRContext),
299		FILTER_OUTPUTS(ff_video_default_filterpad),
300		FILTER_INPUTS(inputs),
301		FILTER_PIXFMTS_ARRAY(pix_fmts),
302		.process_command = ff_filter_process_command,
303		};
304

Function (Line)	Call count	Block coverage
config_input (line 242)	not called	0.0%
euclidean_e_slice16 (line 191)	not called	0.0%
euclidean_e_slice8 (line 190)	not called	0.0%
euclidean_slice16 (line 185)	not called	0.0%
euclidean_slice8 (line 184)	not called	0.0%
filter_frame (line 193)	not called	0.0%
manhattan_e_slice16 (line 188)	not called	0.0%
manhattan_e_slice8 (line 187)	not called	0.0%
manhattan_slice16 (line 182)	not called	0.0%
manhattan_slice8 (line 181)	not called	0.0%