2 * Copyright (c) 2012 Jeremy Tran
3 * Copyright (c) 2001 Donald A. Graft
5 * This file is part of FFmpeg.
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.
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.
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.
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.
30 #include "libavutil/common.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/pixdesc.h"
35 #include "drawutils.h"
42 // Linear Congruential Generator, see "Numerical Recipes"
46 #define LCG(x) (((x) * LCG_A + LCG_C) % LCG_M)
47 #define LCG_SEED 739187
49 enum HisteqAntibanding {
50 HISTEQ_ANTIBANDING_NONE = 0,
51 HISTEQ_ANTIBANDING_WEAK = 1,
52 HISTEQ_ANTIBANDING_STRONG = 2,
53 HISTEQ_ANTIBANDING_NB,
60 enum HisteqAntibanding antibanding;
61 char* antibanding_str;
62 int in_histogram [256]; ///< input histogram
63 int out_histogram[256]; ///< output histogram
64 int LUT[256]; ///< lookup table derived from histogram[]
65 uint8_t rgba_map[4]; ///< components position
66 int bpp; ///< bytes per pixel
69 #define OFFSET(x) offsetof(HisteqContext, x)
70 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
71 #define CONST(name, help, val, unit) { name, help, 0, AV_OPT_TYPE_CONST, {.i64=val}, INT_MIN, INT_MAX, FLAGS, unit }
73 static const AVOption histeq_options[] = {
74 { "strength", "set the strength", OFFSET(strength), AV_OPT_TYPE_FLOAT, {.dbl=0.2}, 0, 1, FLAGS },
75 { "intensity", "set the intensity", OFFSET(intensity), AV_OPT_TYPE_FLOAT, {.dbl=0.21}, 0, 1, FLAGS },
76 { "antibanding", "set the antibanding level", OFFSET(antibanding), AV_OPT_TYPE_INT, {.i64=HISTEQ_ANTIBANDING_NONE}, 0, HISTEQ_ANTIBANDING_NB-1, FLAGS, "antibanding" },
77 CONST("none", "apply no antibanding", HISTEQ_ANTIBANDING_NONE, "antibanding"),
78 CONST("weak", "apply weak antibanding", HISTEQ_ANTIBANDING_WEAK, "antibanding"),
79 CONST("strong", "apply strong antibanding", HISTEQ_ANTIBANDING_STRONG, "antibanding"),
83 AVFILTER_DEFINE_CLASS(histeq);
85 static av_cold int init(AVFilterContext *ctx, const char *args)
87 HisteqContext *histeq = ctx->priv;
88 const char *shorthand[] = { "strength", "intensity", "antibanding", NULL };
91 histeq->class = &histeq_class;
92 av_opt_set_defaults(histeq);
94 if ((ret = av_opt_set_from_string(histeq, args, shorthand, "=", ":")) < 0)
97 av_log(ctx, AV_LOG_VERBOSE,
98 "strength:%0.3f intensity:%0.3f antibanding:%d\n",
99 histeq->strength, histeq->intensity, histeq->antibanding);
104 static av_cold void uninit(AVFilterContext *ctx)
106 HisteqContext *histeq = ctx->priv;
110 static int query_formats(AVFilterContext *ctx)
112 static const enum PixelFormat pix_fmts[] = {
113 AV_PIX_FMT_ARGB, AV_PIX_FMT_RGBA, AV_PIX_FMT_ABGR, AV_PIX_FMT_BGRA,
114 AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24,
118 ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
122 static int config_input(AVFilterLink *inlink)
124 AVFilterContext *ctx = inlink->dst;
125 HisteqContext *histeq = ctx->priv;
126 const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(inlink->format);
128 histeq->bpp = av_get_bits_per_pixel(pix_desc) / 8;
129 ff_fill_rgba_map(histeq->rgba_map, inlink->format);
139 #define GET_RGB_VALUES(r, g, b, src, map) do { \
140 r = src[x + map[R]]; \
141 g = src[x + map[G]]; \
142 b = src[x + map[B]]; \
145 static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *inpic)
147 AVFilterContext *ctx = inlink->dst;
148 HisteqContext *histeq = ctx->priv;
149 AVFilterLink *outlink = ctx->outputs[0];
150 int strength = histeq->strength * 1000;
151 int intensity = histeq->intensity * 1000;
152 int x, y, i, luthi, lutlo, lut, luma, oluma, m;
153 AVFilterBufferRef *outpic;
154 unsigned int r, g, b, jran;
157 outpic = ff_get_video_buffer(outlink, AV_PERM_WRITE|AV_PERM_ALIGN, outlink->w, outlink->h);
159 avfilter_unref_bufferp(&inpic);
160 return AVERROR(ENOMEM);
162 avfilter_copy_buffer_ref_props(outpic, inpic);
164 /* Seed random generator for antibanding. */
167 /* Calculate and store the luminance and calculate the global histogram
168 based on the luminance. */
169 memset(histeq->in_histogram, 0, sizeof(histeq->in_histogram));
170 src = inpic->data[0];
171 dst = outpic->data[0];
172 for (y = 0; y < inlink->h; y++) {
173 for (x = 0; x < inlink->w * histeq->bpp; x += histeq->bpp) {
174 GET_RGB_VALUES(r, g, b, src, histeq->rgba_map);
175 luma = (55 * r + 182 * g + 19 * b) >> 8;
176 dst[x + histeq->rgba_map[A]] = luma;
177 histeq->in_histogram[luma]++;
179 src += inpic->linesize[0];
180 dst += outpic->linesize[0];
184 for (x = 0; x < 256; x++)
185 av_dlog(ctx, "in[%d]: %u\n", x, histeq->in_histogram[x]);
188 /* Calculate the lookup table. */
189 histeq->LUT[0] = histeq->in_histogram[0];
191 for (x = 1; x < 256; x++)
192 histeq->LUT[x] = histeq->LUT[x-1] + histeq->in_histogram[x];
195 for (x = 0; x < 256; x++)
196 histeq->LUT[x] = (histeq->LUT[x] * intensity) / (inlink->h * inlink->w);
198 /* Adjust the LUT based on the selected strength. This is an alpha
199 mix of the calculated LUT and a linear LUT with gain 1. */
200 for (x = 0; x < 256; x++)
201 histeq->LUT[x] = (strength * histeq->LUT[x]) / 255 +
202 ((255 - strength) * x) / 255;
204 /* Output the equalized frame. */
205 memset(histeq->out_histogram, 0, sizeof(histeq->out_histogram));
207 src = inpic->data[0];
208 dst = outpic->data[0];
209 for (y = 0; y < inlink->h; y++) {
210 for (x = 0; x < inlink->w * histeq->bpp; x += histeq->bpp) {
211 luma = dst[x + histeq->rgba_map[A]];
213 for (i = 0; i < histeq->bpp; ++i)
215 histeq->out_histogram[0]++;
217 lut = histeq->LUT[luma];
218 if (histeq->antibanding != HISTEQ_ANTIBANDING_NONE) {
220 lutlo = histeq->antibanding == HISTEQ_ANTIBANDING_WEAK ?
221 (histeq->LUT[luma] + histeq->LUT[luma - 1]) / 2 :
222 histeq->LUT[luma - 1];
227 luthi = (histeq->antibanding == HISTEQ_ANTIBANDING_WEAK) ?
228 (histeq->LUT[luma] + histeq->LUT[luma + 1]) / 2 :
229 histeq->LUT[luma + 1];
233 if (lutlo != luthi) {
235 lut = lutlo + ((luthi - lutlo + 1) * jran) / LCG_M;
239 GET_RGB_VALUES(r, g, b, src, histeq->rgba_map);
240 if (((m = FFMAX3(r, g, b)) * lut) / luma > 255) {
245 r = (r * lut) / luma;
246 g = (g * lut) / luma;
247 b = (b * lut) / luma;
249 dst[x + histeq->rgba_map[R]] = r;
250 dst[x + histeq->rgba_map[G]] = g;
251 dst[x + histeq->rgba_map[B]] = b;
252 oluma = (55 * r + 182 * g + 19 * b) >> 8;
253 histeq->out_histogram[oluma]++;
256 src += inpic->linesize[0];
257 dst += outpic->linesize[0];
260 for (x = 0; x < 256; x++)
261 av_dlog(ctx, "out[%d]: %u\n", x, histeq->out_histogram[x]);
264 avfilter_unref_bufferp(&inpic);
265 return ff_filter_frame(outlink, outpic);
268 static const AVFilterPad histeq_inputs[] = {
271 .type = AVMEDIA_TYPE_VIDEO,
272 .config_props = config_input,
273 .filter_frame = filter_frame,
274 .min_perms = AV_PERM_READ,
279 static const AVFilterPad histeq_outputs[] = {
282 .type = AVMEDIA_TYPE_VIDEO,
287 AVFilter avfilter_vf_histeq = {
289 .description = NULL_IF_CONFIG_SMALL("Apply global color histogram equalization."),
290 .priv_size = sizeof(HisteqContext),
293 .query_formats = query_formats,
295 .inputs = histeq_inputs,
296 .outputs = histeq_outputs,
297 .priv_class = &histeq_class,