FFmpeg coverage

Directory:	../../../ffmpeg/
File:	src/libavfilter/vf_histeq.c
Date:	2025-10-25 20:16:37

	Total	Coverage
Lines:	85	0.0%
Functions:	3	0.0%
Branches:	34	0.0%

  
      Line
      Branch
      Exec
      Source
    
      /*
    
       * Copyright (c) 2012 Jeremy Tran
    
       * Copyright (c) 2001 Donald A. Graft
    
       *
    
       * This file is part of FFmpeg.
    
       *
    
       * FFmpeg is free software; you can redistribute it and/or modify
    
       * it under the terms of the GNU General Public License as published by
    
       * the Free Software Foundation; either version 2 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 General Public License for more details.
    
       *
    
       * You should have received a copy of the GNU 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.
    
       */
    
      /**
    
       * @file
    
       * Histogram equalization filter, based on the VirtualDub filter by
    
       * Donald A. Graft  <neuron2 AT home DOT com>.
    
       * Implements global automatic contrast adjustment by means of
    
       * histogram equalization.
    
       */
    
      #include "libavutil/common.h"
    
      #include "libavutil/internal.h"
    
      #include "libavutil/opt.h"
    
      #include "libavutil/pixdesc.h"
    
      #include "avfilter.h"
    
      #include "drawutils.h"
    
      #include "filters.h"
    
      #include "video.h"
    
      // #define DEBUG
    
      // Linear Congruential Generator, see "Numerical Recipes"
    
      #define LCG_A 4096
    
      #define LCG_C 150889
    
      #define LCG_M 714025
    
      #define LCG(x) (((x) * LCG_A + LCG_C) % LCG_M)
    
      #define LCG_SEED 739187
    
      enum HisteqAntibanding {
    
          HISTEQ_ANTIBANDING_NONE   = 0,
    
          HISTEQ_ANTIBANDING_WEAK   = 1,
    
          HISTEQ_ANTIBANDING_STRONG = 2,
    
          HISTEQ_ANTIBANDING_NB,
    
      };
    
      typedef struct HisteqContext {
    
          const AVClass *class;
    
          float strength;
    
          float intensity;
    
          int antibanding;               ///< HisteqAntibanding
    
          int in_histogram [256];        ///< input histogram
    
          int out_histogram[256];        ///< output histogram
    
          int LUT[256];                  ///< lookup table derived from histogram[]
    
          uint8_t rgba_map[4];           ///< components position
    
          int bpp;                       ///< bytes per pixel
    
      } HisteqContext;
    
      #define OFFSET(x) offsetof(HisteqContext, x)
    
      #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
    
      #define CONST(name, help, val, u) { name, help, 0, AV_OPT_TYPE_CONST, {.i64=val}, INT_MIN, INT_MAX, FLAGS, .unit = u }
    
      static const AVOption histeq_options[] = {
    
          { "strength",    "set the strength", OFFSET(strength), AV_OPT_TYPE_FLOAT, {.dbl=0.2}, 0, 1, FLAGS },
    
          { "intensity",   "set the intensity", OFFSET(intensity), AV_OPT_TYPE_FLOAT, {.dbl=0.21}, 0, 1, FLAGS },
    
          { "antibanding", "set the antibanding level", OFFSET(antibanding), AV_OPT_TYPE_INT, {.i64=HISTEQ_ANTIBANDING_NONE}, 0, HISTEQ_ANTIBANDING_NB-1, FLAGS, .unit = "antibanding" },
    
          CONST("none",    "apply no antibanding",     HISTEQ_ANTIBANDING_NONE,   "antibanding"),
    
          CONST("weak",    "apply weak antibanding",   HISTEQ_ANTIBANDING_WEAK,   "antibanding"),
    
          CONST("strong",  "apply strong antibanding", HISTEQ_ANTIBANDING_STRONG, "antibanding"),
    
          { NULL }
    
      };
    
      AVFILTER_DEFINE_CLASS(histeq);
    
      ✗
      static av_cold int init(AVFilterContext *ctx)
    
      {
    
      ✗
          HisteqContext *histeq = ctx->priv;
    
      ✗
          av_log(ctx, AV_LOG_VERBOSE,
    
                 "strength:%0.3f intensity:%0.3f antibanding:%d\n",
    
      ✗
                 histeq->strength, histeq->intensity, histeq->antibanding);
    
      ✗
          return 0;
    
      }
    
      static const enum AVPixelFormat pix_fmts[] = {
    
          AV_PIX_FMT_ARGB, AV_PIX_FMT_RGBA, AV_PIX_FMT_ABGR, AV_PIX_FMT_BGRA,
    
          AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24,
    
          AV_PIX_FMT_NONE
    
      };
    
      ✗
      static int config_input(AVFilterLink *inlink)
    
      {
    
      ✗
          AVFilterContext *ctx = inlink->dst;
    
      ✗
          HisteqContext *histeq = ctx->priv;
    
      ✗
          const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(inlink->format);
    
      ✗
          histeq->bpp = av_get_bits_per_pixel(pix_desc) / 8;
    
      ✗
          ff_fill_rgba_map(histeq->rgba_map, inlink->format);
    
      ✗
          return 0;
    
      }
    
      #define R 0
    
      #define G 1
    
      #define B 2
    
      #define A 3
    
      #define GET_RGB_VALUES(r, g, b, src, map) do { \
    
          r = src[x + map[R]];                       \
    
          g = src[x + map[G]];                       \
    
          b = src[x + map[B]];                       \
    
      } while (0)
    
      ✗
      static int filter_frame(AVFilterLink *inlink, AVFrame *inpic)
    
      {
    
      ✗
          AVFilterContext   *ctx     = inlink->dst;
    
      ✗
          HisteqContext     *histeq  = ctx->priv;
    
      ✗
          AVFilterLink      *outlink = ctx->outputs[0];
    
      ✗
          int strength  = histeq->strength  * 1000;
    
      ✗
          int intensity = histeq->intensity * 1000;
    
          int x, y, i, luthi, lutlo, lut, luma, oluma, m;
    
          AVFrame *outpic;
    
          unsigned int r, g, b, jran;
    
          uint8_t *src, *dst;
    
      ✗
          outpic = ff_get_video_buffer(outlink, outlink->w, outlink->h);
    
      ✗
          if (!outpic) {
    
      ✗
              av_frame_free(&inpic);
    
      ✗
              return AVERROR(ENOMEM);
    
          }
    
      ✗
          av_frame_copy_props(outpic, inpic);
    
          /* Seed random generator for antibanding. */
    
      ✗
          jran = LCG_SEED;
    
          /* Calculate and store the luminance and calculate the global histogram
    
             based on the luminance. */
    
      ✗
          memset(histeq->in_histogram, 0, sizeof(histeq->in_histogram));
    
      ✗
          src = inpic->data[0];
    
      ✗
          dst = outpic->data[0];
    
      ✗
          for (y = 0; y < inlink->h; y++) {
    
      ✗
              for (x = 0; x < inlink->w * histeq->bpp; x += histeq->bpp) {
    
      ✗
                  GET_RGB_VALUES(r, g, b, src, histeq->rgba_map);
    
      ✗
                  luma = (55 * r + 182 * g + 19 * b) >> 8;
    
      ✗
                  dst[x + histeq->rgba_map[A]] = luma;
    
      ✗
                  histeq->in_histogram[luma]++;
    
              }
    
      ✗
              src += inpic->linesize[0];
    
      ✗
              dst += outpic->linesize[0];
    
          }
    
      #ifdef DEBUG
    
          for (x = 0; x < 256; x++)
    
              ff_dlog(ctx, "in[%d]: %u\n", x, histeq->in_histogram[x]);
    
      #endif
    
          /* Calculate the lookup table. */
    
      ✗
          histeq->LUT[0] = histeq->in_histogram[0];
    
          /* Accumulate */
    
      ✗
          for (x = 1; x < 256; x++)
    
      ✗
              histeq->LUT[x] = histeq->LUT[x-1] + histeq->in_histogram[x];
    
          /* Normalize */
    
      ✗
          for (x = 0; x < 256; x++)
    
      ✗
              histeq->LUT[x] = (histeq->LUT[x] * intensity) / (inlink->h * inlink->w);
    
          /* Adjust the LUT based on the selected strength. This is an alpha
    
             mix of the calculated LUT and a linear LUT with gain 1. */
    
      ✗
          for (x = 0; x < 256; x++)
    
      ✗
              histeq->LUT[x] = (strength * histeq->LUT[x]) / 255 +
    
      ✗
                               ((255 - strength) * x)      / 255;
    
          /* Output the equalized frame. */
    
      ✗
          memset(histeq->out_histogram, 0, sizeof(histeq->out_histogram));
    
      ✗
          src = inpic->data[0];
    
      ✗
          dst = outpic->data[0];
    
      ✗
          for (y = 0; y < inlink->h; y++) {
    
      ✗
              for (x = 0; x < inlink->w * histeq->bpp; x += histeq->bpp) {
    
      ✗
                  luma = dst[x + histeq->rgba_map[A]];
    
      ✗
                  if (luma == 0) {
    
      ✗
                      for (i = 0; i < histeq->bpp; ++i)
    
      ✗
                          dst[x + i] = 0;
    
      ✗
                      histeq->out_histogram[0]++;
    
                  } else {
    
      ✗
                      lut = histeq->LUT[luma];
    
      ✗
                      if (histeq->antibanding != HISTEQ_ANTIBANDING_NONE) {
    
      ✗
                          if (luma > 0) {
    
      ✗
                              lutlo = histeq->antibanding == HISTEQ_ANTIBANDING_WEAK ?
    
      ✗
                                      (histeq->LUT[luma] + histeq->LUT[luma - 1]) / 2 :
    
      ✗
                                       histeq->LUT[luma - 1];
    
                          } else
    
      ✗
                              lutlo = lut;
    
      ✗
                          if (luma < 255) {
    
      ✗
                              luthi = (histeq->antibanding == HISTEQ_ANTIBANDING_WEAK) ?
    
      ✗
                                  (histeq->LUT[luma] + histeq->LUT[luma + 1]) / 2 :
    
      ✗
                                   histeq->LUT[luma + 1];
    
                          } else
    
      ✗
                              luthi = lut;
    
      ✗
                          if (lutlo != luthi) {
    
      ✗
                              jran = LCG(jran);
    
      ✗
                              lut = lutlo + ((luthi - lutlo + 1) * jran) / LCG_M;
    
                          }
    
                      }
    
      ✗
                      GET_RGB_VALUES(r, g, b, src, histeq->rgba_map);
    
      ✗
                      if (((m = FFMAX3(r, g, b)) * lut) / luma > 255) {
    
      ✗
                          r = (r * 255) / m;
    
      ✗
                          g = (g * 255) / m;
    
      ✗
                          b = (b * 255) / m;
    
                      } else {
    
      ✗
                          r = (r * lut) / luma;
    
      ✗
                          g = (g * lut) / luma;
    
      ✗
                          b = (b * lut) / luma;
    
                      }
    
      ✗
                      dst[x + histeq->rgba_map[R]] = r;
    
      ✗
                      dst[x + histeq->rgba_map[G]] = g;
    
      ✗
                      dst[x + histeq->rgba_map[B]] = b;
    
      ✗
                      oluma = av_clip_uint8((55 * r + 182 * g + 19 * b) >> 8);
    
      ✗
                      histeq->out_histogram[oluma]++;
    
                  }
    
              }
    
      ✗
              src += inpic->linesize[0];
    
      ✗
              dst += outpic->linesize[0];
    
          }
    
      #ifdef DEBUG
    
          for (x = 0; x < 256; x++)
    
              ff_dlog(ctx, "out[%d]: %u\n", x, histeq->out_histogram[x]);
    
      #endif
    
      ✗
          av_frame_free(&inpic);
    
      ✗
          return ff_filter_frame(outlink, outpic);
    
      }
    
      static const AVFilterPad histeq_inputs[] = {
    
          {
    
              .name         = "default",
    
              .type         = AVMEDIA_TYPE_VIDEO,
    
              .config_props = config_input,
    
              .filter_frame = filter_frame,
    
          },
    
      };
    
      const FFFilter ff_vf_histeq = {
    
          .p.name        = "histeq",
    
          .p.description = NULL_IF_CONFIG_SMALL("Apply global color histogram equalization."),
    
          .p.priv_class  = &histeq_class,
    
          .p.flags       = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
    
          .priv_size     = sizeof(HisteqContext),
    
          .init          = init,
    
          FILTER_INPUTS(histeq_inputs),
    
          FILTER_OUTPUTS(ff_video_default_filterpad),
    
          FILTER_PIXFMTS_ARRAY(pix_fmts),
    
      };

Line	Exec	Source
1		/*
2		* Copyright (c) 2012 Jeremy Tran
3		* Copyright (c) 2001 Donald A. Graft
4		*
5		* This file is part of FFmpeg.
6		*
7		* FFmpeg is free software; you can redistribute it and/or modify
8		* it under the terms of the GNU General Public License as published by
9		* the Free Software Foundation; either version 2 of the License, or
10		* (at your option) any later version.
11		*
12		* FFmpeg is distributed in the hope that it will be useful,
13		* but WITHOUT ANY WARRANTY; without even the implied warranty of
14		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15		* GNU General Public License for more details.
16		*
17		* You should have received a copy of the GNU General Public License along
18		* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
19		* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20		*/
21
22		/**
23		* @file
24		* Histogram equalization filter, based on the VirtualDub filter by
25		* Donald A. Graft <neuron2 AT home DOT com>.
26		* Implements global automatic contrast adjustment by means of
27		* histogram equalization.
28		*/
29
30		#include "libavutil/common.h"
31		#include "libavutil/internal.h"
32		#include "libavutil/opt.h"
33		#include "libavutil/pixdesc.h"
34
35		#include "avfilter.h"
36		#include "drawutils.h"
37		#include "filters.h"
38		#include "video.h"
39
40		// #define DEBUG
41
42		// Linear Congruential Generator, see "Numerical Recipes"
43		#define LCG_A 4096
44		#define LCG_C 150889
45		#define LCG_M 714025
46		#define LCG(x) (((x) * LCG_A + LCG_C) % LCG_M)
47		#define LCG_SEED 739187
48
49		enum HisteqAntibanding {
50		HISTEQ_ANTIBANDING_NONE = 0,
51		HISTEQ_ANTIBANDING_WEAK = 1,
52		HISTEQ_ANTIBANDING_STRONG = 2,
53		HISTEQ_ANTIBANDING_NB,
54		};
55
56		typedef struct HisteqContext {
57		const AVClass *class;
58		float strength;
59		float intensity;
60		int antibanding; ///< HisteqAntibanding
61		int in_histogram [256]; ///< input histogram
62		int out_histogram[256]; ///< output histogram
63		int LUT[256]; ///< lookup table derived from histogram[]
64		uint8_t rgba_map[4]; ///< components position
65		int bpp; ///< bytes per pixel
66		} HisteqContext;
67
68		#define OFFSET(x) offsetof(HisteqContext, x)
69		#define FLAGS AV_OPT_FLAG_VIDEO_PARAM\|AV_OPT_FLAG_FILTERING_PARAM
70		#define CONST(name, help, val, u) { name, help, 0, AV_OPT_TYPE_CONST, {.i64=val}, INT_MIN, INT_MAX, FLAGS, .unit = u }
71
72		static const AVOption histeq_options[] = {
73		{ "strength", "set the strength", OFFSET(strength), AV_OPT_TYPE_FLOAT, {.dbl=0.2}, 0, 1, FLAGS },
74		{ "intensity", "set the intensity", OFFSET(intensity), AV_OPT_TYPE_FLOAT, {.dbl=0.21}, 0, 1, FLAGS },
75		{ "antibanding", "set the antibanding level", OFFSET(antibanding), AV_OPT_TYPE_INT, {.i64=HISTEQ_ANTIBANDING_NONE}, 0, HISTEQ_ANTIBANDING_NB-1, FLAGS, .unit = "antibanding" },
76		CONST("none", "apply no antibanding", HISTEQ_ANTIBANDING_NONE, "antibanding"),
77		CONST("weak", "apply weak antibanding", HISTEQ_ANTIBANDING_WEAK, "antibanding"),
78		CONST("strong", "apply strong antibanding", HISTEQ_ANTIBANDING_STRONG, "antibanding"),
79		{ NULL }
80		};
81
82		AVFILTER_DEFINE_CLASS(histeq);
83
84	✗	static av_cold int init(AVFilterContext *ctx)
85		{
86	✗	HisteqContext *histeq = ctx->priv;
87
88	✗	av_log(ctx, AV_LOG_VERBOSE,
89		"strength:%0.3f intensity:%0.3f antibanding:%d\n",
90	✗	histeq->strength, histeq->intensity, histeq->antibanding);
91
92	✗	return 0;
93		}
94
95		static const enum AVPixelFormat pix_fmts[] = {
96		AV_PIX_FMT_ARGB, AV_PIX_FMT_RGBA, AV_PIX_FMT_ABGR, AV_PIX_FMT_BGRA,
97		AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24,
98		AV_PIX_FMT_NONE
99		};
100
101	✗	static int config_input(AVFilterLink *inlink)
102		{
103	✗	AVFilterContext *ctx = inlink->dst;
104	✗	HisteqContext *histeq = ctx->priv;
105	✗	const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(inlink->format);
106
107	✗	histeq->bpp = av_get_bits_per_pixel(pix_desc) / 8;
108	✗	ff_fill_rgba_map(histeq->rgba_map, inlink->format);
109
110	✗	return 0;
111		}
112
113		#define R 0
114		#define G 1
115		#define B 2
116		#define A 3
117
118		#define GET_RGB_VALUES(r, g, b, src, map) do { \
119		r = src[x + map[R]]; \
120		g = src[x + map[G]]; \
121		b = src[x + map[B]]; \
122		} while (0)
123
124	✗	static int filter_frame(AVFilterLink inlink, AVFrame inpic)
125		{
126	✗	AVFilterContext *ctx = inlink->dst;
127	✗	HisteqContext *histeq = ctx->priv;
128	✗	AVFilterLink *outlink = ctx->outputs[0];
129	✗	int strength = histeq->strength * 1000;
130	✗	int intensity = histeq->intensity * 1000;
131		int x, y, i, luthi, lutlo, lut, luma, oluma, m;
132		AVFrame *outpic;
133		unsigned int r, g, b, jran;
134		uint8_t src, dst;
135
136	✗	outpic = ff_get_video_buffer(outlink, outlink->w, outlink->h);
137	✗	if (!outpic) {
138	✗	av_frame_free(&inpic);
139	✗	return AVERROR(ENOMEM);
140		}
141	✗	av_frame_copy_props(outpic, inpic);
142
143		/* Seed random generator for antibanding. */
144	✗	jran = LCG_SEED;
145
146		/* Calculate and store the luminance and calculate the global histogram
147		based on the luminance. */
148	✗	memset(histeq->in_histogram, 0, sizeof(histeq->in_histogram));
149	✗	src = inpic->data[0];
150	✗	dst = outpic->data[0];
151	✗	for (y = 0; y < inlink->h; y++) {
152	✗	for (x = 0; x < inlink->w * histeq->bpp; x += histeq->bpp) {
153	✗	GET_RGB_VALUES(r, g, b, src, histeq->rgba_map);
154	✗	luma = (55 * r + 182 * g + 19 * b) >> 8;
155	✗	dst[x + histeq->rgba_map[A]] = luma;
156	✗	histeq->in_histogram[luma]++;
157		}
158	✗	src += inpic->linesize[0];
159	✗	dst += outpic->linesize[0];
160		}
161
162		#ifdef DEBUG
163		for (x = 0; x < 256; x++)
164		ff_dlog(ctx, "in[%d]: %u\n", x, histeq->in_histogram[x]);
165		#endif
166
167		/* Calculate the lookup table. */
168	✗	histeq->LUT[0] = histeq->in_histogram[0];
169		/* Accumulate */
170	✗	for (x = 1; x < 256; x++)
171	✗	histeq->LUT[x] = histeq->LUT[x-1] + histeq->in_histogram[x];
172
173		/* Normalize */
174	✗	for (x = 0; x < 256; x++)
175	✗	histeq->LUT[x] = (histeq->LUT[x] * intensity) / (inlink->h * inlink->w);
176
177		/* Adjust the LUT based on the selected strength. This is an alpha
178		mix of the calculated LUT and a linear LUT with gain 1. */
179	✗	for (x = 0; x < 256; x++)
180	✗	histeq->LUT[x] = (strength * histeq->LUT[x]) / 255 +
181	✗	((255 - strength) * x) / 255;
182
183		/* Output the equalized frame. */
184	✗	memset(histeq->out_histogram, 0, sizeof(histeq->out_histogram));
185
186	✗	src = inpic->data[0];
187	✗	dst = outpic->data[0];
188	✗	for (y = 0; y < inlink->h; y++) {
189	✗	for (x = 0; x < inlink->w * histeq->bpp; x += histeq->bpp) {
190	✗	luma = dst[x + histeq->rgba_map[A]];
191	✗	if (luma == 0) {
192	✗	for (i = 0; i < histeq->bpp; ++i)
193	✗	dst[x + i] = 0;
194	✗	histeq->out_histogram[0]++;
195		} else {
196	✗	lut = histeq->LUT[luma];
197	✗	if (histeq->antibanding != HISTEQ_ANTIBANDING_NONE) {
198	✗	if (luma > 0) {
199	✗	lutlo = histeq->antibanding == HISTEQ_ANTIBANDING_WEAK ?
200	✗	(histeq->LUT[luma] + histeq->LUT[luma - 1]) / 2 :
201	✗	histeq->LUT[luma - 1];
202		} else
203	✗	lutlo = lut;
204
205	✗	if (luma < 255) {
206	✗	luthi = (histeq->antibanding == HISTEQ_ANTIBANDING_WEAK) ?
207	✗	(histeq->LUT[luma] + histeq->LUT[luma + 1]) / 2 :
208	✗	histeq->LUT[luma + 1];
209		} else
210	✗	luthi = lut;
211
212	✗	if (lutlo != luthi) {
213	✗	jran = LCG(jran);
214	✗	lut = lutlo + ((luthi - lutlo + 1) * jran) / LCG_M;
215		}
216		}
217
218	✗	GET_RGB_VALUES(r, g, b, src, histeq->rgba_map);
219	✗	if (((m = FFMAX3(r, g, b)) * lut) / luma > 255) {
220	✗	r = (r * 255) / m;
221	✗	g = (g * 255) / m;
222	✗	b = (b * 255) / m;
223		} else {
224	✗	r = (r * lut) / luma;
225	✗	g = (g * lut) / luma;
226	✗	b = (b * lut) / luma;
227		}
228	✗	dst[x + histeq->rgba_map[R]] = r;
229	✗	dst[x + histeq->rgba_map[G]] = g;
230	✗	dst[x + histeq->rgba_map[B]] = b;
231	✗	oluma = av_clip_uint8((55 * r + 182 * g + 19 * b) >> 8);
232	✗	histeq->out_histogram[oluma]++;
233		}
234		}
235	✗	src += inpic->linesize[0];
236	✗	dst += outpic->linesize[0];
237		}
238		#ifdef DEBUG
239		for (x = 0; x < 256; x++)
240		ff_dlog(ctx, "out[%d]: %u\n", x, histeq->out_histogram[x]);
241		#endif
242
243	✗	av_frame_free(&inpic);
244	✗	return ff_filter_frame(outlink, outpic);
245		}
246
247		static const AVFilterPad histeq_inputs[] = {
248		{
249		.name = "default",
250		.type = AVMEDIA_TYPE_VIDEO,
251		.config_props = config_input,
252		.filter_frame = filter_frame,
253		},
254		};
255
256		const FFFilter ff_vf_histeq = {
257		.p.name = "histeq",
258		.p.description = NULL_IF_CONFIG_SMALL("Apply global color histogram equalization."),
259		.p.priv_class = &histeq_class,
260		.p.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
261		.priv_size = sizeof(HisteqContext),
262		.init = init,
263		FILTER_INPUTS(histeq_inputs),
264		FILTER_OUTPUTS(ff_video_default_filterpad),
265		FILTER_PIXFMTS_ARRAY(pix_fmts),
266		};
267

Function (Line)	Call count	Block coverage
config_input (line 101)	not called	0.0%
filter_frame (line 124)	not called	0.0%
init (line 84)	not called	0.0%