FFmpeg coverage

Directory:	../../../ffmpeg/
File:	src/libavfilter/vf_chromanr.c
Date:	2024-11-20 23:03:26

	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 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);               \
    
                                                                                               \
    
          {                                                                                    \
    
              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);                \
    
              }                                                                                \
    
          }                                                                                    \
    
                                                                                               \
    
          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_yptr = (const type *)(in->data[0] + yy * chroma_h * in_ylinesize); \
    
                      const type *in_uptr = (const type *)(in->data[1] + yy * in_ulinesize);            \
    
                      const type *in_vptr = (const type *)(in->data[2] + yy * in_vlinesize);            \
    
                                                                                                        \
    
                      for (int xx = xxstart; xx <= xxstop; xx += stepw) {                    \
    
                          const ctype Y = in_yptr[xx * chroma_w];                            \
    
                          const ctype U = in_uptr[xx];                                       \
    
                          const ctype V = in_vptr[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 AVFilter ff_vf_chromanr = {
    
          .name          = "chromanr",
    
          .description   = NULL_IF_CONFIG_SMALL("Reduce chrominance noise."),
    
          .priv_size     = sizeof(ChromaNRContext),
    
          .priv_class    = &chromanr_class,
    
          FILTER_OUTPUTS(ff_video_default_filterpad),
    
          FILTER_INPUTS(inputs),
    
          FILTER_PIXFMTS_ARRAY(pix_fmts),
    
          .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
    
          .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		const int in_ylinesize = in->linesize[0]; \
84		const int in_ulinesize = in->linesize[1]; \
85		const int in_vlinesize = in->linesize[2]; \
86		const int out_ulinesize = out->linesize[1]; \
87		const int out_vlinesize = out->linesize[2]; \
88		const int chroma_w = s->chroma_w; \
89		const int chroma_h = s->chroma_h; \
90		const int stepw = s->stepw; \
91		const int steph = s->steph; \
92		const int sizew = s->sizew; \
93		const int sizeh = s->sizeh; \
94		const int thres = s->thres; \
95		const int thres_y = s->thres_y; \
96		const int thres_u = s->thres_u; \
97		const int thres_v = s->thres_v; \
98		const int h = s->planeheight[1]; \
99		const int w = s->planewidth[1]; \
100		const int slice_start = (h * jobnr) / nb_jobs; \
101		const int slice_end = (h * (jobnr+1)) / nb_jobs; \
102		type out_uptr = (type )(out->data[1] + slice_start * out_ulinesize); \
103		type out_vptr = (type )(out->data[2] + slice_start * out_vlinesize); \
104		\
105		{ \
106		const int h = s->planeheight[0]; \
107		const int slice_start = (h * jobnr) / nb_jobs; \
108		const int slice_end = (h * (jobnr+1)) / nb_jobs; \
109		\
110		av_image_copy_plane(out->data[0] + slice_start * out->linesize[0], \
111		out->linesize[0], \
112		in->data[0] + slice_start * in->linesize[0], \
113		in->linesize[0], \
114		s->linesize[0], slice_end - slice_start); \
115		\
116		if (s->nb_planes == 4) { \
117		av_image_copy_plane(out->data[3] + slice_start * out->linesize[3], \
118		out->linesize[3], \
119		in->data[3] + slice_start * in->linesize[3], \
120		in->linesize[3], \
121		s->linesize[3], slice_end - slice_start); \
122		} \
123		} \
124		\
125		for (int y = slice_start; y < slice_end; y++) { \
126		const type in_yptr = (const type )(in->data[0] + y * chroma_h * in_ylinesize); \
127		const type in_uptr = (const type )(in->data[1] + y * in_ulinesize); \
128		const type in_vptr = (const type )(in->data[2] + y * in_vlinesize); \
129		const int yystart = FFMAX(0, y - sizeh); \
130		const int yystop = FFMIN(h - 1, y + sizeh); \
131		\
132		for (int x = 0; x < w; x++) { \
133		const int xxstart = FFMAX(0, x - sizew); \
134		const int xxstop = FFMIN(w - 1, x + sizew); \
135		const int cy = in_yptr[x * chroma_w]; \
136		const int cu = in_uptr[x]; \
137		const int cv = in_vptr[x]; \
138		int su = cu; \
139		int sv = cv; \
140		int cn = 1; \
141		\
142		for (int yy = yystart; yy <= yystop; yy += steph) { \
143		const type in_yptr = (const type )(in->data[0] + yy * chroma_h * in_ylinesize); \
144		const type in_uptr = (const type )(in->data[1] + yy * in_ulinesize); \
145		const type in_vptr = (const type )(in->data[2] + yy * in_vlinesize); \
146		\
147		for (int xx = xxstart; xx <= xxstop; xx += stepw) { \
148		const ctype Y = in_yptr[xx * chroma_w]; \
149		const ctype U = in_uptr[xx]; \
150		const ctype V = in_vptr[xx]; \
151		const ctype cyY = FFABS(cy - Y); \
152		const ctype cuU = FFABS(cu - U); \
153		const ctype cvV = FFABS(cv - V); \
154		\
155		if (extra && fun(cyY, cuU, cvV) < thres && \
156		cuU < thres_u && cvV < thres_v && \
157		cyY < thres_y) { \
158		su += U; \
159		sv += V; \
160		cn++; \
161		} else if (!extra && fun(cyY, cuU, cvV) < thres) { \
162		su += U; \
163		sv += V; \
164		cn++; \
165		} \
166		} \
167		} \
168		\
169		out_uptr[x] = (su + (cn >> 1)) / cn; \
170		out_vptr[x] = (sv + (cn >> 1)) / cn; \
171		} \
172		\
173		out_uptr += out_ulinesize / sizeof(type); \
174		out_vptr += out_vlinesize / sizeof(type); \
175		} \
176		\
177		return 0; \
178		}
179
180	✗	FILTER_FUNC(manhattan, 8, int, uint8_t, MANHATTAN_DISTANCE, 0)
181	✗	FILTER_FUNC(manhattan, 16, int, uint16_t, MANHATTAN_DISTANCE, 0)
182
183	✗	FILTER_FUNC(euclidean, 8, int, uint8_t, EUCLIDEAN_DISTANCE, 0)
184	✗	FILTER_FUNC(euclidean, 16, int64_t, uint16_t, EUCLIDEAN_DISTANCE, 0)
185
186	✗	FILTER_FUNC(manhattan_e, 8, int, uint8_t, MANHATTAN_DISTANCE, 1)
187	✗	FILTER_FUNC(manhattan_e, 16, int, uint16_t, MANHATTAN_DISTANCE, 1)
188
189	✗	FILTER_FUNC(euclidean_e, 8, int, uint8_t, EUCLIDEAN_DISTANCE, 1)
190	✗	FILTER_FUNC(euclidean_e, 16, int64_t, uint16_t, EUCLIDEAN_DISTANCE, 1)
191
192	✗	static int filter_frame(AVFilterLink inlink, AVFrame in)
193		{
194	✗	AVFilterContext *ctx = inlink->dst;
195	✗	AVFilterLink *outlink = ctx->outputs[0];
196	✗	ChromaNRContext *s = ctx->priv;
197		AVFrame *out;
198
199	✗	switch (s->distance) {
200	✗	case 0:
201	✗	s->filter_slice = s->depth <= 8 ? manhattan_slice8 : manhattan_slice16;
202	✗	break;
203	✗	case 1:
204	✗	s->filter_slice = s->depth <= 8 ? euclidean_slice8 : euclidean_slice16;
205	✗	break;
206		}
207
208	✗	s->thres = s->threshold * (1 << (s->depth - 8));
209	✗	s->thres_y = s->threshold_y * (1 << (s->depth - 8));
210	✗	s->thres_u = s->threshold_u * (1 << (s->depth - 8));
211	✗	s->thres_v = s->threshold_v * (1 << (s->depth - 8));
212
213	✗	if (s->threshold_y < 200.f \|\| s->threshold_u < 200.f \|\| s->threshold_v < 200.f) {
214	✗	switch (s->distance) {
215	✗	case 0:
216	✗	s->filter_slice = s->depth <= 8 ? manhattan_e_slice8 : manhattan_e_slice16;
217	✗	break;
218	✗	case 1:
219	✗	s->filter_slice = s->depth <= 8 ? euclidean_e_slice8 : euclidean_e_slice16;
220	✗	break;
221		}
222		}
223
224	✗	out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
225	✗	if (!out) {
226	✗	av_frame_free(&in);
227	✗	return AVERROR(ENOMEM);
228		}
229
230	✗	av_frame_copy_props(out, in);
231	✗	s->out = out;
232	✗	ff_filter_execute(ctx, s->filter_slice, in, NULL,
233	✗	FFMIN3(s->planeheight[1],
234		s->planeheight[2],
235		ff_filter_get_nb_threads(ctx)));
236
237	✗	av_frame_free(&in);
238	✗	return ff_filter_frame(outlink, out);
239		}
240
241	✗	static int config_input(AVFilterLink *inlink)
242		{
243	✗	AVFilterContext *ctx = inlink->dst;
244	✗	ChromaNRContext *s = ctx->priv;
245	✗	const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
246		int ret;
247
248	✗	s->nb_planes = desc->nb_components;
249	✗	s->depth = desc->comp[0].depth;
250	✗	s->chroma_w = 1 << desc->log2_chroma_w;
251	✗	s->chroma_h = 1 << desc->log2_chroma_h;
252	✗	s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
253	✗	s->planeheight[0] = s->planeheight[3] = inlink->h;
254	✗	s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
255	✗	s->planewidth[0] = s->planewidth[3] = inlink->w;
256
257	✗	if ((ret = av_image_fill_linesizes(s->linesize, inlink->format, inlink->w)) < 0)
258	✗	return ret;
259
260	✗	return 0;
261		}
262
263		#define OFFSET(x) offsetof(ChromaNRContext, x)
264		#define VF AV_OPT_FLAG_VIDEO_PARAM \| AV_OPT_FLAG_FILTERING_PARAM \| AV_OPT_FLAG_RUNTIME_PARAM
265
266		static const AVOption chromanr_options[] = {
267		{ "thres", "set y+u+v threshold", OFFSET(threshold), AV_OPT_TYPE_FLOAT, {.dbl=30}, 1, 200, VF },
268		{ "sizew", "set horizontal patch size", OFFSET(sizew), AV_OPT_TYPE_INT, {.i64=5}, 1, 100, VF },
269		{ "sizeh", "set vertical patch size", OFFSET(sizeh), AV_OPT_TYPE_INT, {.i64=5}, 1, 100, VF },
270		{ "stepw", "set horizontal step", OFFSET(stepw), AV_OPT_TYPE_INT, {.i64=1}, 1, 50, VF },
271		{ "steph", "set vertical step", OFFSET(steph), AV_OPT_TYPE_INT, {.i64=1}, 1, 50, VF },
272		{ "threy", "set y threshold", OFFSET(threshold_y), AV_OPT_TYPE_FLOAT, {.dbl=200},1, 200, VF },
273		{ "threu", "set u threshold", OFFSET(threshold_u), AV_OPT_TYPE_FLOAT, {.dbl=200},1, 200, VF },
274		{ "threv", "set v threshold", OFFSET(threshold_v), AV_OPT_TYPE_FLOAT, {.dbl=200},1, 200, VF },
275		{ "distance", "set distance type", OFFSET(distance), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, VF, .unit = "distance" },
276		{ "manhattan", "", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, VF, .unit = "distance" },
277		{ "euclidean", "", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, VF, .unit = "distance" },
278		{ NULL }
279		};
280
281		static const AVFilterPad inputs[] = {
282		{
283		.name = "default",
284		.type = AVMEDIA_TYPE_VIDEO,
285		.filter_frame = filter_frame,
286		.config_props = config_input,
287		},
288		};
289
290		AVFILTER_DEFINE_CLASS(chromanr);
291
292		const AVFilter ff_vf_chromanr = {
293		.name = "chromanr",
294		.description = NULL_IF_CONFIG_SMALL("Reduce chrominance noise."),
295		.priv_size = sizeof(ChromaNRContext),
296		.priv_class = &chromanr_class,
297		FILTER_OUTPUTS(ff_video_default_filterpad),
298		FILTER_INPUTS(inputs),
299		FILTER_PIXFMTS_ARRAY(pix_fmts),
300		.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC \| AVFILTER_FLAG_SLICE_THREADS,
301		.process_command = ff_filter_process_command,
302		};
303

Function (Line)	Call count	Block coverage
config_input (line 241)	not called	0.0%
euclidean_e_slice16 (line 190)	not called	0.0%
euclidean_e_slice8 (line 189)	not called	0.0%
euclidean_slice16 (line 184)	not called	0.0%
euclidean_slice8 (line 183)	not called	0.0%
filter_frame (line 192)	not called	0.0%
manhattan_e_slice16 (line 187)	not called	0.0%
manhattan_e_slice8 (line 186)	not called	0.0%
manhattan_slice16 (line 181)	not called	0.0%
manhattan_slice8 (line 180)	not called	0.0%