libavfilter/vf_histeq.c - manifest_repos/ffmpeg - Git at Google

 /*
  * 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 "formats.h"
 #include "internal.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, unit) { name, help, 0, AV_OPT_TYPE_CONST, {.i64=val}, INT_MIN, INT_MAX, FLAGS, unit }

 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, "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 int query_formats(AVFilterContext *ctx)
 {
     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
     };
     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
     if (!fmts_list)
         return AVERROR(ENOMEM);
     return ff_set_common_formats(ctx, fmts_list);
 }

 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,
     },
     { NULL }
 };

 static const AVFilterPad histeq_outputs[] = {
     {
         .name = "default",
         .type = AVMEDIA_TYPE_VIDEO,
     },
     { NULL }
 };

 AVFilter ff_vf_histeq = {
     .name          = "histeq",
     .description   = NULL_IF_CONFIG_SMALL("Apply global color histogram equalization."),
     .priv_size     = sizeof(HisteqContext),
     .init          = init,
     .query_formats = query_formats,
     .inputs        = histeq_inputs,
     .outputs       = histeq_outputs,
     .priv_class    = &histeq_class,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };
	/*
	* 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 "formats.h"
	#include "internal.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, unit) { name, help, 0, AV_OPT_TYPE_CONST, {.i64=val}, INT_MIN, INT_MAX, FLAGS, unit }

	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, "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 int query_formats(AVFilterContext *ctx)
	{
	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
	};
	AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	if (!fmts_list)
	return AVERROR(ENOMEM);
	return ff_set_common_formats(ctx, fmts_list);
	}

	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,
	},
	{ NULL }
	};

	static const AVFilterPad histeq_outputs[] = {
	{
	.name = "default",
	.type = AVMEDIA_TYPE_VIDEO,
	},
	{ NULL }
	};

	AVFilter ff_vf_histeq = {
	.name = "histeq",
	.description = NULL_IF_CONFIG_SMALL("Apply global color histogram equalization."),
	.priv_size = sizeof(HisteqContext),
	.init = init,
	.query_formats = query_formats,
	.inputs = histeq_inputs,
	.outputs = histeq_outputs,
	.priv_class = &histeq_class,
	.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
	};