FFmpeg coverage

Directory:	../../../ffmpeg/
File:	src/libavfilter/vf_elbg.c
Date:	2025-10-24 21:16:34

	Total	Coverage
Lines:	98	0.0%
Functions:	5	0.0%
Branches:	44	0.0%

  
      Line
      Branch
      Exec
      Source
    
      /*
    
       * Copyright (c) 2013 Stefano Sabatini
    
       *
    
       * 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
    
       */
    
      /**
    
       * @file
    
       * video quantizer filter based on ELBG
    
       */
    
      #include "libavcodec/elbg.h"
    
      #include "libavutil/mem.h"
    
      #include "libavutil/opt.h"
    
      #include "libavutil/pixdesc.h"
    
      #include "libavutil/random_seed.h"
    
      #include "avfilter.h"
    
      #include "drawutils.h"
    
      #include "filters.h"
    
      #include "formats.h"
    
      #include "video.h"
    
      typedef struct ELBGFilterContext {
    
          const AVClass *class;
    
          struct ELBGContext *ctx;
    
          AVLFG lfg;
    
          int64_t lfg_seed;
    
          int max_steps_nb;
    
          int *codeword;
    
          int codeword_length;
    
          int *codeword_closest_codebook_idxs;
    
          int *codebook;
    
          int codebook_length;
    
          const AVPixFmtDescriptor *pix_desc;
    
          uint8_t rgba_map[4];
    
          int use_alpha;
    
          int pal8;
    
      } ELBGFilterContext;
    
      #define OFFSET(x) offsetof(ELBGFilterContext, x)
    
      #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
    
      static const AVOption elbg_options[] = {
    
          { "codebook_length", "set codebook length", OFFSET(codebook_length), AV_OPT_TYPE_INT, { .i64 = 256 }, 1, INT_MAX, FLAGS },
    
          { "l",               "set codebook length", OFFSET(codebook_length), AV_OPT_TYPE_INT, { .i64 = 256 }, 1, INT_MAX, FLAGS },
    
          { "nb_steps", "set max number of steps used to compute the mapping", OFFSET(max_steps_nb), AV_OPT_TYPE_INT, { .i64 = 1 }, 1, INT_MAX, FLAGS },
    
          { "n",        "set max number of steps used to compute the mapping", OFFSET(max_steps_nb), AV_OPT_TYPE_INT, { .i64 = 1 }, 1, INT_MAX, FLAGS },
    
          { "seed", "set the random seed", OFFSET(lfg_seed), AV_OPT_TYPE_INT64, {.i64 = -1}, -1, UINT32_MAX, FLAGS },
    
          { "s",    "set the random seed", OFFSET(lfg_seed), AV_OPT_TYPE_INT64, { .i64 = -1 }, -1, UINT32_MAX, FLAGS },
    
          { "pal8", "set the pal8 output", OFFSET(pal8), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
    
          { "use_alpha", "use alpha channel for mapping", OFFSET(use_alpha), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
    
          { NULL }
    
      };
    
      AVFILTER_DEFINE_CLASS(elbg);
    
      ✗
      static av_cold int init(AVFilterContext *ctx)
    
      {
    
      ✗
          ELBGFilterContext *const elbg = ctx->priv;
    
      ✗
          if (elbg->pal8 && elbg->codebook_length > 256) {
    
      ✗
              av_log(ctx, AV_LOG_ERROR, "pal8 output allows max 256 codebook length.\n");
    
      ✗
              return AVERROR(EINVAL);
    
          }
    
      ✗
          if (elbg->lfg_seed == -1)
    
      ✗
              elbg->lfg_seed = av_get_random_seed();
    
      ✗
          av_lfg_init(&elbg->lfg, elbg->lfg_seed);
    
      ✗
          return 0;
    
      }
    
      ✗
      static int query_formats(const AVFilterContext *ctx,
    
                               AVFilterFormatsConfig **cfg_in,
    
                               AVFilterFormatsConfig **cfg_out)
    
      {
    
      ✗
          const ELBGFilterContext *const elbg = ctx->priv;
    
          int ret;
    
          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
    
          };
    
      ✗
          if (!elbg->pal8) {
    
      ✗
              return ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, pix_fmts);
    
          } else {
    
              static const enum AVPixelFormat pal8_fmt[] = {
    
                  AV_PIX_FMT_PAL8,
    
                  AV_PIX_FMT_NONE
    
              };
    
      ✗
              if ((ret = ff_formats_ref(ff_make_format_list(pix_fmts), &cfg_in[0]->formats)) < 0 ||
    
      ✗
                  (ret = ff_formats_ref(ff_make_format_list(pal8_fmt), &cfg_out[0]->formats)) < 0)
    
      ✗
                  return ret;
    
          }
    
      ✗
          return 0;
    
      }
    
      #define NB_COMPONENTS 4
    
      ✗
      static int config_input(AVFilterLink *inlink)
    
      {
    
      ✗
          AVFilterContext *ctx = inlink->dst;
    
      ✗
          ELBGFilterContext *const elbg = ctx->priv;
    
      ✗
          elbg->pix_desc = av_pix_fmt_desc_get(inlink->format);
    
      ✗
          elbg->codeword_length = inlink->w * inlink->h;
    
      ✗
          elbg->codeword = av_realloc_f(elbg->codeword, elbg->codeword_length,
    
                                        NB_COMPONENTS * sizeof(*elbg->codeword));
    
      ✗
          if (!elbg->codeword)
    
      ✗
              return AVERROR(ENOMEM);
    
      ✗
          elbg->codeword_closest_codebook_idxs =
    
      ✗
              av_realloc_f(elbg->codeword_closest_codebook_idxs, elbg->codeword_length,
    
                           sizeof(*elbg->codeword_closest_codebook_idxs));
    
      ✗
          if (!elbg->codeword_closest_codebook_idxs)
    
      ✗
              return AVERROR(ENOMEM);
    
      ✗
          elbg->codebook = av_realloc_f(elbg->codebook, elbg->codebook_length,
    
                                        NB_COMPONENTS * sizeof(*elbg->codebook));
    
      ✗
          if (!elbg->codebook)
    
      ✗
              return AVERROR(ENOMEM);
    
      ✗
          ff_fill_rgba_map(elbg->rgba_map, inlink->format);
    
      ✗
          return 0;
    
      }
    
      #define R 0
    
      #define G 1
    
      #define B 2
    
      #define A 3
    
      ✗
      static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
    
      {
    
      ✗
          ELBGFilterContext *const elbg = inlink->dst->priv;
    
          int i, j, k, ret;
    
          uint8_t *p, *p0;
    
      ✗
          const uint8_t r_idx  = elbg->rgba_map[R];
    
      ✗
          const uint8_t g_idx  = elbg->rgba_map[G];
    
      ✗
          const uint8_t b_idx  = elbg->rgba_map[B];
    
      ✗
          const uint8_t a_idx  = elbg->rgba_map[A];
    
          /* build the codeword */
    
      ✗
          p0 = frame->data[0];
    
      ✗
          k = 0;
    
      ✗
          for (i = 0; i < inlink->h; i++) {
    
      ✗
              p = p0;
    
      ✗
              for (j = 0; j < inlink->w; j++) {
    
      ✗
                  elbg->codeword[k++] = p[b_idx];
    
      ✗
                  elbg->codeword[k++] = p[g_idx];
    
      ✗
                  elbg->codeword[k++] = p[r_idx];
    
      ✗
                  elbg->codeword[k++] = elbg->use_alpha ? p[a_idx] : 0xff;
    
      ✗
                  p += elbg->pix_desc->nb_components;
    
              }
    
      ✗
              p0 += frame->linesize[0];
    
          }
    
          /* compute the codebook */
    
      ✗
          ret = avpriv_elbg_do(&elbg->ctx, elbg->codeword, NB_COMPONENTS,
    
                               elbg->codeword_length, elbg->codebook,
    
                               elbg->codebook_length, elbg->max_steps_nb,
    
                               elbg->codeword_closest_codebook_idxs, &elbg->lfg, 0);
    
      ✗
          if (ret < 0) {
    
      ✗
              av_frame_free(&frame);
    
      ✗
              return ret;
    
          }
    
      ✗
          if (elbg->pal8) {
    
      ✗
              AVFilterLink *outlink = inlink->dst->outputs[0];
    
      ✗
              AVFrame *out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
    
              uint32_t *pal;
    
      ✗
              if (!out) {
    
      ✗
                  av_frame_free(&frame);
    
      ✗
                  return AVERROR(ENOMEM);
    
              }
    
      ✗
              av_frame_copy_props(out, frame);
    
      ✗
              av_frame_free(&frame);
    
      ✗
              pal = (uint32_t *)out->data[1];
    
      ✗
              p0 = (uint8_t *)out->data[0];
    
      ✗
              for (i = 0; i < elbg->codebook_length; i++) {
    
      ✗
                  const unsigned al =  elbg->use_alpha ? elbg->codebook[i*4+3] : 0xff;
    
      ✗
                  pal[i] =  al                    << 24  |
    
      ✗
                           (elbg->codebook[i*4+2] << 16) |
    
      ✗
                           (elbg->codebook[i*4+1] <<  8) |
    
      ✗
                            elbg->codebook[i*4  ];
    
              }
    
      ✗
              k = 0;
    
      ✗
              for (i = 0; i < inlink->h; i++) {
    
      ✗
                  p = p0;
    
      ✗
                  for (j = 0; j < inlink->w; j++, p++) {
    
      ✗
                      p[0] = elbg->codeword_closest_codebook_idxs[k++];
    
                  }
    
      ✗
                  p0 += out->linesize[0];
    
              }
    
      ✗
              return ff_filter_frame(outlink, out);
    
          }
    
          /* fill the output with the codebook values */
    
      ✗
          p0 = frame->data[0];
    
      ✗
          k = 0;
    
      ✗
          for (i = 0; i < inlink->h; i++) {
    
      ✗
              p = p0;
    
      ✗
              for (j = 0; j < inlink->w; j++) {
    
      ✗
                  int cb_idx = NB_COMPONENTS * elbg->codeword_closest_codebook_idxs[k++];
    
      ✗
                  p[b_idx] = elbg->codebook[cb_idx];
    
      ✗
                  p[g_idx] = elbg->codebook[cb_idx+1];
    
      ✗
                  p[r_idx] = elbg->codebook[cb_idx+2];
    
      ✗
                  p[a_idx] = elbg->use_alpha ? elbg->codebook[cb_idx+3] : 0xFFu;
    
      ✗
                  p += elbg->pix_desc->nb_components;
    
              }
    
      ✗
              p0 += frame->linesize[0];
    
          }
    
      ✗
          return ff_filter_frame(inlink->dst->outputs[0], frame);
    
      }
    
      ✗
      static av_cold void uninit(AVFilterContext *ctx)
    
      {
    
      ✗
          ELBGFilterContext *const elbg = ctx->priv;
    
      ✗
          avpriv_elbg_free(&elbg->ctx);
    
      ✗
          av_freep(&elbg->codebook);
    
      ✗
          av_freep(&elbg->codeword);
    
      ✗
          av_freep(&elbg->codeword_closest_codebook_idxs);
    
      ✗
      }
    
      static const AVFilterPad elbg_inputs[] = {
    
          {
    
              .name           = "default",
    
              .type           = AVMEDIA_TYPE_VIDEO,
    
              .flags          = AVFILTERPAD_FLAG_NEEDS_WRITABLE,
    
              .config_props   = config_input,
    
              .filter_frame   = filter_frame,
    
          },
    
      };
    
      const FFFilter ff_vf_elbg = {
    
          .p.name        = "elbg",
    
          .p.description = NULL_IF_CONFIG_SMALL("Apply posterize effect, using the ELBG algorithm."),
    
          .p.priv_class  = &elbg_class,
    
          .priv_size     = sizeof(ELBGFilterContext),
    
          .init          = init,
    
          .uninit        = uninit,
    
          FILTER_INPUTS(elbg_inputs),
    
          FILTER_OUTPUTS(ff_video_default_filterpad),
    
          FILTER_QUERY_FUNC2(query_formats),
    
      };

Line	Exec	Source
1		/*
2		* Copyright (c) 2013 Stefano Sabatini
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		/**
22		* @file
23		* video quantizer filter based on ELBG
24		*/
25
26		#include "libavcodec/elbg.h"
27		#include "libavutil/mem.h"
28		#include "libavutil/opt.h"
29		#include "libavutil/pixdesc.h"
30		#include "libavutil/random_seed.h"
31
32		#include "avfilter.h"
33		#include "drawutils.h"
34		#include "filters.h"
35		#include "formats.h"
36		#include "video.h"
37
38		typedef struct ELBGFilterContext {
39		const AVClass *class;
40		struct ELBGContext *ctx;
41		AVLFG lfg;
42		int64_t lfg_seed;
43		int max_steps_nb;
44		int *codeword;
45		int codeword_length;
46		int *codeword_closest_codebook_idxs;
47		int *codebook;
48		int codebook_length;
49		const AVPixFmtDescriptor *pix_desc;
50		uint8_t rgba_map[4];
51		int use_alpha;
52		int pal8;
53		} ELBGFilterContext;
54
55		#define OFFSET(x) offsetof(ELBGFilterContext, x)
56		#define FLAGS AV_OPT_FLAG_VIDEO_PARAM\|AV_OPT_FLAG_FILTERING_PARAM
57
58		static const AVOption elbg_options[] = {
59		{ "codebook_length", "set codebook length", OFFSET(codebook_length), AV_OPT_TYPE_INT, { .i64 = 256 }, 1, INT_MAX, FLAGS },
60		{ "l", "set codebook length", OFFSET(codebook_length), AV_OPT_TYPE_INT, { .i64 = 256 }, 1, INT_MAX, FLAGS },
61		{ "nb_steps", "set max number of steps used to compute the mapping", OFFSET(max_steps_nb), AV_OPT_TYPE_INT, { .i64 = 1 }, 1, INT_MAX, FLAGS },
62		{ "n", "set max number of steps used to compute the mapping", OFFSET(max_steps_nb), AV_OPT_TYPE_INT, { .i64 = 1 }, 1, INT_MAX, FLAGS },
63		{ "seed", "set the random seed", OFFSET(lfg_seed), AV_OPT_TYPE_INT64, {.i64 = -1}, -1, UINT32_MAX, FLAGS },
64		{ "s", "set the random seed", OFFSET(lfg_seed), AV_OPT_TYPE_INT64, { .i64 = -1 }, -1, UINT32_MAX, FLAGS },
65		{ "pal8", "set the pal8 output", OFFSET(pal8), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
66		{ "use_alpha", "use alpha channel for mapping", OFFSET(use_alpha), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
67		{ NULL }
68		};
69
70		AVFILTER_DEFINE_CLASS(elbg);
71
72	✗	static av_cold int init(AVFilterContext *ctx)
73		{
74	✗	ELBGFilterContext *const elbg = ctx->priv;
75
76	✗	if (elbg->pal8 && elbg->codebook_length > 256) {
77	✗	av_log(ctx, AV_LOG_ERROR, "pal8 output allows max 256 codebook length.\n");
78	✗	return AVERROR(EINVAL);
79		}
80
81	✗	if (elbg->lfg_seed == -1)
82	✗	elbg->lfg_seed = av_get_random_seed();
83
84	✗	av_lfg_init(&elbg->lfg, elbg->lfg_seed);
85	✗	return 0;
86		}
87
88	✗	static int query_formats(const AVFilterContext *ctx,
89		AVFilterFormatsConfig **cfg_in,
90		AVFilterFormatsConfig **cfg_out)
91		{
92	✗	const ELBGFilterContext *const elbg = ctx->priv;
93		int ret;
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	✗	if (!elbg->pal8) {
101	✗	return ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, pix_fmts);
102		} else {
103		static const enum AVPixelFormat pal8_fmt[] = {
104		AV_PIX_FMT_PAL8,
105		AV_PIX_FMT_NONE
106		};
107	✗	if ((ret = ff_formats_ref(ff_make_format_list(pix_fmts), &cfg_in[0]->formats)) < 0 \|\|
108	✗	(ret = ff_formats_ref(ff_make_format_list(pal8_fmt), &cfg_out[0]->formats)) < 0)
109	✗	return ret;
110		}
111	✗	return 0;
112		}
113
114		#define NB_COMPONENTS 4
115
116	✗	static int config_input(AVFilterLink *inlink)
117		{
118	✗	AVFilterContext *ctx = inlink->dst;
119	✗	ELBGFilterContext *const elbg = ctx->priv;
120
121	✗	elbg->pix_desc = av_pix_fmt_desc_get(inlink->format);
122	✗	elbg->codeword_length = inlink->w * inlink->h;
123	✗	elbg->codeword = av_realloc_f(elbg->codeword, elbg->codeword_length,
124		NB_COMPONENTS * sizeof(*elbg->codeword));
125	✗	if (!elbg->codeword)
126	✗	return AVERROR(ENOMEM);
127
128	✗	elbg->codeword_closest_codebook_idxs =
129	✗	av_realloc_f(elbg->codeword_closest_codebook_idxs, elbg->codeword_length,
130		sizeof(*elbg->codeword_closest_codebook_idxs));
131	✗	if (!elbg->codeword_closest_codebook_idxs)
132	✗	return AVERROR(ENOMEM);
133
134	✗	elbg->codebook = av_realloc_f(elbg->codebook, elbg->codebook_length,
135		NB_COMPONENTS * sizeof(*elbg->codebook));
136	✗	if (!elbg->codebook)
137	✗	return AVERROR(ENOMEM);
138
139	✗	ff_fill_rgba_map(elbg->rgba_map, inlink->format);
140
141	✗	return 0;
142		}
143
144		#define R 0
145		#define G 1
146		#define B 2
147		#define A 3
148
149	✗	static int filter_frame(AVFilterLink inlink, AVFrame frame)
150		{
151	✗	ELBGFilterContext *const elbg = inlink->dst->priv;
152		int i, j, k, ret;
153		uint8_t p, p0;
154
155	✗	const uint8_t r_idx = elbg->rgba_map[R];
156	✗	const uint8_t g_idx = elbg->rgba_map[G];
157	✗	const uint8_t b_idx = elbg->rgba_map[B];
158	✗	const uint8_t a_idx = elbg->rgba_map[A];
159
160		/* build the codeword */
161	✗	p0 = frame->data[0];
162	✗	k = 0;
163	✗	for (i = 0; i < inlink->h; i++) {
164	✗	p = p0;
165	✗	for (j = 0; j < inlink->w; j++) {
166	✗	elbg->codeword[k++] = p[b_idx];
167	✗	elbg->codeword[k++] = p[g_idx];
168	✗	elbg->codeword[k++] = p[r_idx];
169	✗	elbg->codeword[k++] = elbg->use_alpha ? p[a_idx] : 0xff;
170	✗	p += elbg->pix_desc->nb_components;
171		}
172	✗	p0 += frame->linesize[0];
173		}
174
175		/* compute the codebook */
176	✗	ret = avpriv_elbg_do(&elbg->ctx, elbg->codeword, NB_COMPONENTS,
177		elbg->codeword_length, elbg->codebook,
178		elbg->codebook_length, elbg->max_steps_nb,
179		elbg->codeword_closest_codebook_idxs, &elbg->lfg, 0);
180	✗	if (ret < 0) {
181	✗	av_frame_free(&frame);
182	✗	return ret;
183		}
184
185	✗	if (elbg->pal8) {
186	✗	AVFilterLink *outlink = inlink->dst->outputs[0];
187	✗	AVFrame *out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
188		uint32_t *pal;
189
190	✗	if (!out) {
191	✗	av_frame_free(&frame);
192	✗	return AVERROR(ENOMEM);
193		}
194	✗	av_frame_copy_props(out, frame);
195	✗	av_frame_free(&frame);
196	✗	pal = (uint32_t *)out->data[1];
197	✗	p0 = (uint8_t *)out->data[0];
198
199	✗	for (i = 0; i < elbg->codebook_length; i++) {
200	✗	const unsigned al = elbg->use_alpha ? elbg->codebook[i*4+3] : 0xff;
201	✗	pal[i] = al << 24 \|
202	✗	(elbg->codebook[i*4+2] << 16) \|
203	✗	(elbg->codebook[i*4+1] << 8) \|
204	✗	elbg->codebook[i*4 ];
205		}
206
207	✗	k = 0;
208	✗	for (i = 0; i < inlink->h; i++) {
209	✗	p = p0;
210	✗	for (j = 0; j < inlink->w; j++, p++) {
211	✗	p[0] = elbg->codeword_closest_codebook_idxs[k++];
212		}
213	✗	p0 += out->linesize[0];
214		}
215
216	✗	return ff_filter_frame(outlink, out);
217		}
218
219		/* fill the output with the codebook values */
220	✗	p0 = frame->data[0];
221
222	✗	k = 0;
223	✗	for (i = 0; i < inlink->h; i++) {
224	✗	p = p0;
225	✗	for (j = 0; j < inlink->w; j++) {
226	✗	int cb_idx = NB_COMPONENTS * elbg->codeword_closest_codebook_idxs[k++];
227	✗	p[b_idx] = elbg->codebook[cb_idx];
228	✗	p[g_idx] = elbg->codebook[cb_idx+1];
229	✗	p[r_idx] = elbg->codebook[cb_idx+2];
230	✗	p[a_idx] = elbg->use_alpha ? elbg->codebook[cb_idx+3] : 0xFFu;
231	✗	p += elbg->pix_desc->nb_components;
232		}
233	✗	p0 += frame->linesize[0];
234		}
235
236	✗	return ff_filter_frame(inlink->dst->outputs[0], frame);
237		}
238
239	✗	static av_cold void uninit(AVFilterContext *ctx)
240		{
241	✗	ELBGFilterContext *const elbg = ctx->priv;
242
243	✗	avpriv_elbg_free(&elbg->ctx);
244
245	✗	av_freep(&elbg->codebook);
246	✗	av_freep(&elbg->codeword);
247	✗	av_freep(&elbg->codeword_closest_codebook_idxs);
248	✗	}
249
250		static const AVFilterPad elbg_inputs[] = {
251		{
252		.name = "default",
253		.type = AVMEDIA_TYPE_VIDEO,
254		.flags = AVFILTERPAD_FLAG_NEEDS_WRITABLE,
255		.config_props = config_input,
256		.filter_frame = filter_frame,
257		},
258		};
259
260		const FFFilter ff_vf_elbg = {
261		.p.name = "elbg",
262		.p.description = NULL_IF_CONFIG_SMALL("Apply posterize effect, using the ELBG algorithm."),
263		.p.priv_class = &elbg_class,
264		.priv_size = sizeof(ELBGFilterContext),
265		.init = init,
266		.uninit = uninit,
267		FILTER_INPUTS(elbg_inputs),
268		FILTER_OUTPUTS(ff_video_default_filterpad),
269		FILTER_QUERY_FUNC2(query_formats),
270		};
271

Function (Line)	Call count	Block coverage
config_input (line 116)	not called	0.0%
filter_frame (line 149)	not called	0.0%
init (line 72)	not called	0.0%
query_formats (line 88)	not called	0.0%
uninit (line 239)	not called	0.0%