FFmpeg coverage

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

	Total	Coverage
Lines:	69	0.0%
Functions:	2	0.0%
Branches:	64	0.0%

  
      Line
      Branch
      Exec
      Source
    
      /*
    
       * Copyright (c) 2016 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/opt.h"
    
      #include "libavutil/pixdesc.h"
    
      #include "avfilter.h"
    
      #include "filters.h"
    
      #include "video.h"
    
      typedef struct BPNContext {
    
          const AVClass *class;
    
          int bitplane;
    
          int filter;
    
          int nb_planes;
    
          int planeheight[4];
    
          int planewidth[4];
    
          int depth;
    
      } BPNContext;
    
      #define OFFSET(x) offsetof(BPNContext, x)
    
      #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
    
      static const AVOption bitplanenoise_options[] = {
    
          { "bitplane", "set bit plane to use for measuring noise",  OFFSET(bitplane), AV_OPT_TYPE_INT,  {.i64=1}, 1, 16, FLAGS},
    
          { "filter",   "show noisy pixels",                         OFFSET(filter),   AV_OPT_TYPE_BOOL, {.i64=0}, 0,  1, FLAGS},
    
          { NULL }
    
      };
    
      AVFILTER_DEFINE_CLASS(bitplanenoise);
    
      static const enum AVPixelFormat pixfmts[] = {
    
          AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV411P,
    
          AV_PIX_FMT_YUV440P,
    
          AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ411P,
    
          AV_PIX_FMT_YUVJ440P,
    
          AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV420P9,
    
          AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV420P10,
    
          AV_PIX_FMT_YUV440P10,
    
          AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV420P12,
    
          AV_PIX_FMT_YUV440P12,
    
          AV_PIX_FMT_YUV444P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV420P14,
    
          AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV420P16,
    
          AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
    
          AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
    
          AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14, AV_PIX_FMT_GRAY16,
    
          AV_PIX_FMT_NONE
    
      };
    
      ✗
      static int config_input(AVFilterLink *inlink)
    
      {
    
      ✗
          const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
    
      ✗
          AVFilterContext *ctx = inlink->dst;
    
      ✗
          BPNContext *s = ctx->priv;
    
      ✗
          s->nb_planes = desc->nb_components;
    
      ✗
          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;
    
      ✗
          s->depth = desc->comp[0].depth;
    
      ✗
          return 0;
    
      }
    
      #define CHECK_BIT(x, a, b, c) { \
    
          bit = (((val[(x)] & mask) == (val[(x) + (a)] & mask)) + \
    
                 ((val[(x)] & mask) == (val[(x) + (b)] & mask)) + \
    
                 ((val[(x)] & mask) == (val[(x) + (c)] & mask))) > 1; \
    
          if (dst) \
    
              dst[(x)] = factor * bit; \
    
          stats[plane] += bit; }
    
      ✗
      static int filter_frame(AVFilterLink *inlink, AVFrame *in)
    
      {
    
      ✗
          AVFilterContext *ctx = inlink->dst;
    
      ✗
          AVFilterLink *outlink = ctx->outputs[0];
    
      ✗
          BPNContext *s = ctx->priv;
    
      ✗
          const int mask = (1 << (s->bitplane - 1));
    
      ✗
          const int factor = (1 << s->depth) - 1;
    
      ✗
          float stats[4] = { 0 };
    
          char metabuf[128];
    
          int plane, y, x, bit;
    
      ✗
          AVFrame *out = s->filter ? NULL : in;
    
      ✗
          if (!out) {
    
      ✗
              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);
    
          }
    
      ✗
          if (s->depth <= 8) {
    
      ✗
              for (plane = 0; plane < s->nb_planes; plane++) {
    
      ✗
                  const int linesize = s->planeheight[plane] > 1 ? in->linesize[plane] : 0;
    
      ✗
                  const int dlinesize = out->linesize[plane];
    
      ✗
                  uint8_t *val = in->data[plane];
    
      ✗
                  uint8_t *dst = s->filter ? out->data[plane]: NULL;
    
      ✗
                  for (y = 0; y < s->planeheight[plane] - 1; y++) {
    
      ✗
                      CHECK_BIT(0, 1, 1 + linesize, linesize)
    
      ✗
                      for (x = 1; x < s->planewidth[plane] - 1; x++) {
    
      ✗
                          CHECK_BIT(x, -1, 1, linesize)
    
                      }
    
      ✗
                      CHECK_BIT(x, -1, -1 + linesize, linesize)
    
      ✗
                      val += linesize;
    
      ✗
                      if (dst)
    
      ✗
                          dst += dlinesize;
    
                  }
    
      ✗
                  CHECK_BIT(0, 1, 1 - linesize, -linesize)
    
      ✗
                  for (x = 1; x < s->planewidth[plane] - 1; x++) {
    
      ✗
                      CHECK_BIT(x, -1, 1, -linesize)
    
                  }
    
      ✗
                  CHECK_BIT(x, -1, -1 - linesize, -linesize)
    
              }
    
          } else {
    
      ✗
              for (plane = 0; plane < s->nb_planes; plane++) {
    
      ✗
                  const int linesize = s->planeheight[plane] > 1 ? in->linesize[plane] / 2 : 0;
    
      ✗
                  const int dlinesize = out->linesize[plane] / 2;
    
      ✗
                  uint16_t *val = (uint16_t *)in->data[plane];
    
      ✗
                  uint16_t *dst = s->filter ? (uint16_t *)out->data[plane] : NULL;
    
      ✗
                  val = (uint16_t *)in->data[plane];
    
      ✗
                  for (y = 0; y < s->planeheight[plane] - 1; y++) {
    
      ✗
                      CHECK_BIT(0, 1, 1 + linesize, linesize)
    
      ✗
                      for (x = 1; x < s->planewidth[plane] - 1; x++) {
    
      ✗
                          CHECK_BIT(x, -1, 1, linesize)
    
                      }
    
      ✗
                      CHECK_BIT(x, -1, -1 + linesize, linesize)
    
      ✗
                      val += linesize;
    
      ✗
                      if (dst)
    
      ✗
                          dst += dlinesize;
    
                  }
    
      ✗
                  CHECK_BIT(0, 1, 1 - linesize, -linesize)
    
      ✗
                  for (x = 1; x < s->planewidth[plane] - 1; x++) {
    
      ✗
                      CHECK_BIT(x, -1, 1, -linesize)
    
                  }
    
      ✗
                  CHECK_BIT(x, -1, -1 -linesize, -linesize)
    
              }
    
          }
    
      ✗
          for (plane = 0; plane < s->nb_planes; plane++) {
    
              char key[32];
    
      ✗
              stats[plane] /= s->planewidth[plane] * s->planeheight[plane];
    
      ✗
              snprintf(key, sizeof(key), "lavfi.bitplanenoise.%d.%d", plane, s->bitplane);
    
      ✗
              snprintf(metabuf, sizeof(metabuf), "%f", 1. - 2.* fabs((stats[plane] - 0.5)));
    
      ✗
              av_dict_set(&out->metadata, key, metabuf, 0);
    
          }
    
      ✗
          if (out != in)
    
      ✗
              av_frame_free(&in);
    
      ✗
          return ff_filter_frame(outlink, out);
    
      }
    
      static const AVFilterPad inputs[] = {
    
          {
    
              .name           = "default",
    
              .type           = AVMEDIA_TYPE_VIDEO,
    
              .filter_frame   = filter_frame,
    
              .config_props   = config_input,
    
          },
    
      };
    
      const AVFilter ff_vf_bitplanenoise = {
    
          .name           = "bitplanenoise",
    
          .description    = NULL_IF_CONFIG_SMALL("Measure bit plane noise."),
    
          .priv_size      = sizeof(BPNContext),
    
          FILTER_INPUTS(inputs),
    
          FILTER_OUTPUTS(ff_video_default_filterpad),
    
          FILTER_PIXFMTS_ARRAY(pixfmts),
    
          .priv_class     = &bitplanenoise_class,
    
          .flags          = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
    
      };

Line	Exec	Source
1		/*
2		* Copyright (c) 2016 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/opt.h"
22		#include "libavutil/pixdesc.h"
23		#include "avfilter.h"
24		#include "filters.h"
25		#include "video.h"
26
27		typedef struct BPNContext {
28		const AVClass *class;
29
30		int bitplane;
31		int filter;
32
33		int nb_planes;
34		int planeheight[4];
35		int planewidth[4];
36		int depth;
37		} BPNContext;
38
39		#define OFFSET(x) offsetof(BPNContext, x)
40		#define FLAGS AV_OPT_FLAG_FILTERING_PARAM\|AV_OPT_FLAG_VIDEO_PARAM
41		static const AVOption bitplanenoise_options[] = {
42		{ "bitplane", "set bit plane to use for measuring noise", OFFSET(bitplane), AV_OPT_TYPE_INT, {.i64=1}, 1, 16, FLAGS},
43		{ "filter", "show noisy pixels", OFFSET(filter), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
44		{ NULL }
45		};
46
47		AVFILTER_DEFINE_CLASS(bitplanenoise);
48
49		static const enum AVPixelFormat pixfmts[] = {
50		AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV411P,
51		AV_PIX_FMT_YUV440P,
52		AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ411P,
53		AV_PIX_FMT_YUVJ440P,
54		AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV420P9,
55		AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV420P10,
56		AV_PIX_FMT_YUV440P10,
57		AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV420P12,
58		AV_PIX_FMT_YUV440P12,
59		AV_PIX_FMT_YUV444P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV420P14,
60		AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV420P16,
61		AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
62		AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
63		AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14, AV_PIX_FMT_GRAY16,
64		AV_PIX_FMT_NONE
65		};
66
67	✗	static int config_input(AVFilterLink *inlink)
68		{
69	✗	const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
70	✗	AVFilterContext *ctx = inlink->dst;
71	✗	BPNContext *s = ctx->priv;
72
73	✗	s->nb_planes = desc->nb_components;
74
75	✗	s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
76	✗	s->planeheight[0] = s->planeheight[3] = inlink->h;
77	✗	s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
78	✗	s->planewidth[0] = s->planewidth[3] = inlink->w;
79
80	✗	s->depth = desc->comp[0].depth;
81
82	✗	return 0;
83		}
84
85		#define CHECK_BIT(x, a, b, c) { \
86		bit = (((val[(x)] & mask) == (val[(x) + (a)] & mask)) + \
87		((val[(x)] & mask) == (val[(x) + (b)] & mask)) + \
88		((val[(x)] & mask) == (val[(x) + (c)] & mask))) > 1; \
89		if (dst) \
90		dst[(x)] = factor * bit; \
91		stats[plane] += bit; }
92
93	✗	static int filter_frame(AVFilterLink inlink, AVFrame in)
94		{
95	✗	AVFilterContext *ctx = inlink->dst;
96	✗	AVFilterLink *outlink = ctx->outputs[0];
97	✗	BPNContext *s = ctx->priv;
98	✗	const int mask = (1 << (s->bitplane - 1));
99	✗	const int factor = (1 << s->depth) - 1;
100	✗	float stats[4] = { 0 };
101		char metabuf[128];
102		int plane, y, x, bit;
103	✗	AVFrame *out = s->filter ? NULL : in;
104
105	✗	if (!out) {
106	✗	out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
107	✗	if (!out) {
108	✗	av_frame_free(&in);
109	✗	return AVERROR(ENOMEM);
110		}
111	✗	av_frame_copy_props(out, in);
112		}
113
114	✗	if (s->depth <= 8) {
115	✗	for (plane = 0; plane < s->nb_planes; plane++) {
116	✗	const int linesize = s->planeheight[plane] > 1 ? in->linesize[plane] : 0;
117	✗	const int dlinesize = out->linesize[plane];
118	✗	uint8_t *val = in->data[plane];
119	✗	uint8_t *dst = s->filter ? out->data[plane]: NULL;
120
121	✗	for (y = 0; y < s->planeheight[plane] - 1; y++) {
122	✗	CHECK_BIT(0, 1, 1 + linesize, linesize)
123
124	✗	for (x = 1; x < s->planewidth[plane] - 1; x++) {
125	✗	CHECK_BIT(x, -1, 1, linesize)
126		}
127
128	✗	CHECK_BIT(x, -1, -1 + linesize, linesize)
129
130	✗	val += linesize;
131	✗	if (dst)
132	✗	dst += dlinesize;
133		}
134
135	✗	CHECK_BIT(0, 1, 1 - linesize, -linesize)
136
137	✗	for (x = 1; x < s->planewidth[plane] - 1; x++) {
138	✗	CHECK_BIT(x, -1, 1, -linesize)
139		}
140
141	✗	CHECK_BIT(x, -1, -1 - linesize, -linesize)
142		}
143		} else {
144	✗	for (plane = 0; plane < s->nb_planes; plane++) {
145	✗	const int linesize = s->planeheight[plane] > 1 ? in->linesize[plane] / 2 : 0;
146	✗	const int dlinesize = out->linesize[plane] / 2;
147	✗	uint16_t val = (uint16_t )in->data[plane];
148	✗	uint16_t dst = s->filter ? (uint16_t )out->data[plane] : NULL;
149
150	✗	val = (uint16_t *)in->data[plane];
151	✗	for (y = 0; y < s->planeheight[plane] - 1; y++) {
152	✗	CHECK_BIT(0, 1, 1 + linesize, linesize)
153
154	✗	for (x = 1; x < s->planewidth[plane] - 1; x++) {
155	✗	CHECK_BIT(x, -1, 1, linesize)
156		}
157
158	✗	CHECK_BIT(x, -1, -1 + linesize, linesize)
159
160	✗	val += linesize;
161	✗	if (dst)
162	✗	dst += dlinesize;
163		}
164
165	✗	CHECK_BIT(0, 1, 1 - linesize, -linesize)
166
167	✗	for (x = 1; x < s->planewidth[plane] - 1; x++) {
168	✗	CHECK_BIT(x, -1, 1, -linesize)
169		}
170
171	✗	CHECK_BIT(x, -1, -1 -linesize, -linesize)
172		}
173		}
174
175	✗	for (plane = 0; plane < s->nb_planes; plane++) {
176		char key[32];
177
178	✗	stats[plane] /= s->planewidth[plane] * s->planeheight[plane];
179	✗	snprintf(key, sizeof(key), "lavfi.bitplanenoise.%d.%d", plane, s->bitplane);
180	✗	snprintf(metabuf, sizeof(metabuf), "%f", 1. - 2.* fabs((stats[plane] - 0.5)));
181	✗	av_dict_set(&out->metadata, key, metabuf, 0);
182		}
183
184	✗	if (out != in)
185	✗	av_frame_free(&in);
186
187	✗	return ff_filter_frame(outlink, out);
188		}
189
190		static const AVFilterPad inputs[] = {
191		{
192		.name = "default",
193		.type = AVMEDIA_TYPE_VIDEO,
194		.filter_frame = filter_frame,
195		.config_props = config_input,
196		},
197		};
198
199		const AVFilter ff_vf_bitplanenoise = {
200		.name = "bitplanenoise",
201		.description = NULL_IF_CONFIG_SMALL("Measure bit plane noise."),
202		.priv_size = sizeof(BPNContext),
203		FILTER_INPUTS(inputs),
204		FILTER_OUTPUTS(ff_video_default_filterpad),
205		FILTER_PIXFMTS_ARRAY(pixfmts),
206		.priv_class = &bitplanenoise_class,
207		.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
208		};
209

Function (Line)	Call count	Block coverage
config_input (line 67)	not called	0.0%
filter_frame (line 93)	not called	0.0%