FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavfilter/vf_histeq.c
Date: 2024-07-16 12:46:59
Exec Total Coverage
Lines: 0 85 0.0%
Functions: 0 3 0.0%
Branches: 0 34 0.0%

Line Branch 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 "internal.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 AVFilter ff_vf_histeq = {
257 .name = "histeq",
258 .description = NULL_IF_CONFIG_SMALL("Apply global color histogram equalization."),
259 .priv_size = sizeof(HisteqContext),
260 .init = init,
261 FILTER_INPUTS(histeq_inputs),
262 FILTER_OUTPUTS(ff_video_default_filterpad),
263 FILTER_PIXFMTS_ARRAY(pix_fmts),
264 .priv_class = &histeq_class,
265 .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
266 };
267