From e0728d799151d24b58f4a824bc97014b3b2473a4 Mon Sep 17 00:00:00 2001 From: Bobby Bingham Date: Wed, 7 Apr 2010 01:05:24 +0000 Subject: [PATCH] Add unsharp video filter. Contributed by Daniel G. Taylor (dan/at/programmer-art/dot/org) Originally committed as revision 22813 to svn://svn.ffmpeg.org/ffmpeg/trunk --- doc/libavfilter.texi | 53 +++++++++ libavfilter/Makefile | 1 + libavfilter/allfilters.c | 1 + libavfilter/vf_unsharp.c | 236 +++++++++++++++++++++++++++++++++++++++ 4 files changed, 291 insertions(+) create mode 100644 libavfilter/vf_unsharp.c diff --git a/doc/libavfilter.texi b/doc/libavfilter.texi index 32bf10fd9a..3aeded9524 100644 --- a/doc/libavfilter.texi +++ b/doc/libavfilter.texi @@ -217,6 +217,59 @@ not specified it will use the default value of 16. Adding this in the beginning of filter chains should make filtering faster due to better use of the memory cache. +@section unsharp + +Sharpen or blur the input video. It accepts the following parameters: + +@multitable @columnfractions .2 .5 .1 .1 .1 +@headitem Name @tab Description @tab Min @tab Max @tab Default +@item @var{luma_msize_x} +@tab Luma matrix horizontal size +@tab 3 +@tab 13 +@tab 5 +@item @var{luma_msize_y} +@tab Luma matrix vertical size +@tab 3 +@tab 13 +@tab 5 +@item @var{luma_amount} +@tab Luma effect strength +@tab -2.0 +@tab 5.0 +@tab 1.0 +@item @var{chroma_msize_x} +@tab Chroma matrix horizontal size +@tab 3 +@tab 13 +@tab 0 +@item @var{chroma_msize_y} +@tab Chroma matrix vertical size +@tab 3 +@tab 13 +@tab 0 +@item @var{chroma_amount} +@tab Chroma effect strength +@tab -2.0 +@tab 5.0 +@tab 0.0 +@end multitable + +Negative values for the amount will blur the input video, while positive +values will sharpen. All parameters are optional and default to the +equivalent of the string '5:5:1.0:0:0:0.0'. + +@example +# Strong luma sharpen effect parameters +unsharp=7:7:2.5 + +# Strong blur of both luma and chroma parameters +unsharp=7:7:-2:7:7:-2 + +# Use the default values with @command{ffmpeg} +./ffmpeg -i in.avi -vfilters "unsharp" out.mp4 +@end example + @section vflip Flip the input video vertically. diff --git a/libavfilter/Makefile b/libavfilter/Makefile index 29857c0496..84f7a9c1bf 100644 --- a/libavfilter/Makefile +++ b/libavfilter/Makefile @@ -22,6 +22,7 @@ OBJS-$(CONFIG_NULL_FILTER) += vf_null.o OBJS-$(CONFIG_PIXELASPECT_FILTER) += vf_aspect.o OBJS-$(CONFIG_SCALE_FILTER) += vf_scale.o OBJS-$(CONFIG_SLICIFY_FILTER) += vf_slicify.o +OBJS-$(CONFIG_UNSHARP_FILTER) += vf_unsharp.o OBJS-$(CONFIG_VFLIP_FILTER) += vf_vflip.o OBJS-$(CONFIG_NULLSRC_FILTER) += vsrc_nullsrc.o diff --git a/libavfilter/allfilters.c b/libavfilter/allfilters.c index fccd1f5154..75d42cc026 100644 --- a/libavfilter/allfilters.c +++ b/libavfilter/allfilters.c @@ -42,6 +42,7 @@ void avfilter_register_all(void) REGISTER_FILTER (PIXELASPECT, pixelaspect, vf); REGISTER_FILTER (SCALE, scale, vf); REGISTER_FILTER (SLICIFY, slicify, vf); + REGISTER_FILTER (UNSHARP, unsharp, vf); REGISTER_FILTER (VFLIP, vflip, vf); REGISTER_FILTER (NULLSRC, nullsrc, vsrc); diff --git a/libavfilter/vf_unsharp.c b/libavfilter/vf_unsharp.c new file mode 100644 index 0000000000..4231aa5f05 --- /dev/null +++ b/libavfilter/vf_unsharp.c @@ -0,0 +1,236 @@ +/* + * Ported to FFmpeg from MPlayer libmpcodecs/unsharp.c + * Original copyright (C) 2002 Remi Guyomarch + * Port copyright (C) 2010 Daniel G. Taylor + * Relicensed to the LGPL with permission from Remi Guyomarch. + * + * 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 libavfilter/vf_unsharp.c + * blur / sharpen filter + * + * This code is based on: + * + * An Efficient algorithm for Gaussian blur using finite-state machines + * Frederick M. Waltz and John W. V. Miller + * + * SPIE Conf. on Machine Vision Systems for Inspection and Metrology VII + * Originally published Boston, Nov 98 + * + * http://www.engin.umd.umich.edu/~jwvm/ece581/21_GBlur.pdf + */ + +#include "avfilter.h" +#include "libavutil/common.h" +#include "libavutil/mem.h" +#include "libavutil/pixdesc.h" + +#define MIN_SIZE 3 +#define MAX_SIZE 13 + +#define CHROMA_WIDTH(link) -((-link->w) >> av_pix_fmt_descriptors[link->format].log2_chroma_w) +#define CHROMA_HEIGHT(link) -((-link->h) >> av_pix_fmt_descriptors[link->format].log2_chroma_h) + +typedef struct FilterParam { + int msize_x; ///< matrix width + int msize_y; ///< matrix height + int amount; ///< effect amount + int steps_x; ///< horizontal step count + int steps_y; ///< vertical step count + int scalebits; ///< bits to shift pixel + int32_t halfscale; ///< amount to add to pixel + uint32_t *sc[(MAX_SIZE * MAX_SIZE) - 1]; ///< finite state machine storage +} FilterParam; + +typedef struct { + FilterParam luma; ///< luma parameters (width, height, amount) + FilterParam chroma; ///< chroma parameters (width, height, amount) +} UnsharpContext; + +static void unsharpen(uint8_t *dst, uint8_t *src, int dst_stride, int src_stride, int width, int height, FilterParam *fp) +{ + uint32_t **sc = fp->sc; + uint32_t sr[(MAX_SIZE * MAX_SIZE) - 1], tmp1, tmp2; + + int32_t res; + int x, y, z; + + if (!fp->amount) { + if (dst_stride == src_stride) + memcpy(dst, src, src_stride * height); + else + for (y = 0; y < height; y++, dst += dst_stride, src += src_stride) + memcpy(dst, src, width); + return; + } + + for (y = 0; y < 2 * fp->steps_y; y++) + memset(sc[y], 0, sizeof(sc[y][0]) * (width + 2 * fp->steps_x)); + + for (y =- fp->steps_y; y < height + fp->steps_y; y++) { + memset(sr, 0, sizeof(sr[0]) * (2 * fp->steps_x - 1)); + for (x =- fp->steps_x; x < width + fp->steps_x; x++) { + tmp1 = x <= 0 ? src[0] : x >= width ? src[width-1] : src[x]; + for (z = 0; z < fp->steps_x * 2; z += 2) { + tmp2 = sr[z + 0] + tmp1; sr[z + 0] = tmp1; + tmp1 = sr[z + 1] + tmp2; sr[z + 1] = tmp2; + } + for (z = 0; z < fp->steps_y * 2; z += 2) { + tmp2 = sc[z + 0][x + fp->steps_x] + tmp1; sc[z + 0][x + fp->steps_x] = tmp1; + tmp1 = sc[z + 1][x + fp->steps_x] + tmp2; sc[z + 1][x + fp->steps_x] = tmp2; + } + if (x >= fp->steps_x && y >= fp->steps_y) { + uint8_t* srx = src - fp->steps_y * src_stride + x - fp->steps_x; + uint8_t* dsx = dst - fp->steps_y * dst_stride + x - fp->steps_x; + + res = (int32_t)*srx + ((((int32_t) * srx - (int32_t)((tmp1 + fp->halfscale) >> fp->scalebits)) * fp->amount) >> 16); + *dsx = av_clip_uint8(res); + } + } + if (y >= 0) { + dst += dst_stride; + src += src_stride; + } + } +} + +static void set_filter_param(FilterParam *fp, int msize_x, int msize_y, double amount) +{ + fp->msize_x = msize_x; + fp->msize_y = msize_y; + fp->amount = amount * 65536.0; + + fp->steps_x = msize_x / 2; + fp->steps_y = msize_y / 2; + fp->scalebits = (fp->steps_x + fp->steps_y) * 2; + fp->halfscale = 1 << (fp->scalebits - 1); +} + +static av_cold int init(AVFilterContext *ctx, const char *args, void *opaque) +{ + UnsharpContext *unsharp = ctx->priv; + int lmsize_x = 5, cmsize_x = 0; + int lmsize_y = 5, cmsize_y = 0; + double lamount = 1.0f, camount = 0.0f; + + if (args) + sscanf(args, "%d:%d:%lf:%d:%d:%lf", &lmsize_x, &lmsize_y, &lamount, + &cmsize_x, &cmsize_y, &camount); + + set_filter_param(&unsharp->luma, lmsize_x, lmsize_y, lamount); + set_filter_param(&unsharp->chroma, cmsize_x, cmsize_y, camount); + + return 0; +} + +static int query_formats(AVFilterContext *ctx) +{ + enum PixelFormat pix_fmts[] = { + PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_YUV410P, + PIX_FMT_YUV411P, PIX_FMT_YUV440P, PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, + PIX_FMT_YUVJ444P, PIX_FMT_YUVJ440P, PIX_FMT_NONE + }; + + avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts)); + + return 0; +} + +static void init_filter_param(AVFilterContext *ctx, FilterParam *fp, const char *effect_type, int width) +{ + int z; + const char *effect; + + effect = fp->amount == 0 ? "none" : fp->amount < 0 ? "blur" : "sharpen"; + + av_log(ctx, AV_LOG_INFO, "effect:%s type:%s msize_x:%d msize_y:%d amount:%0.2f\n", + effect, effect_type, fp->msize_x, fp->msize_y, fp->amount / 65535.0); + + for (z = 0; z < 2 * fp->steps_y; z++) + fp->sc[z] = av_malloc(sizeof(*(fp->sc[z])) * (width + 2 * fp->steps_x)); +} + +static int config_props(AVFilterLink *link) +{ + UnsharpContext *unsharp = link->dst->priv; + + init_filter_param(link->dst, &unsharp->luma, "luma", link->w); + init_filter_param(link->dst, &unsharp->chroma, "chroma", CHROMA_WIDTH(link)); + + return 0; +} + +static void free_filter_param(FilterParam *fp) +{ + int z; + + for (z = 0; z < 2 * fp->steps_y; z++) + av_free(fp->sc[z]); +} + +static av_cold void uninit(AVFilterContext *ctx) +{ + UnsharpContext *unsharp = ctx->priv; + + free_filter_param(&unsharp->luma); + free_filter_param(&unsharp->chroma); +} + +static void end_frame(AVFilterLink *link) +{ + UnsharpContext *unsharp = link->dst->priv; + AVFilterPicRef *in = link->cur_pic; + AVFilterPicRef *out = link->dst->outputs[0]->outpic; + + unsharpen(out->data[0], in->data[0], out->linesize[0], in->linesize[0], link->w, link->h, &unsharp->luma); + unsharpen(out->data[1], in->data[1], out->linesize[1], in->linesize[1], CHROMA_WIDTH(link), CHROMA_HEIGHT(link), &unsharp->chroma); + unsharpen(out->data[2], in->data[2], out->linesize[2], in->linesize[2], CHROMA_WIDTH(link), CHROMA_HEIGHT(link), &unsharp->chroma); + + avfilter_unref_pic(in); + avfilter_draw_slice(link->dst->outputs[0], 0, link->h, 1); + avfilter_end_frame(link->dst->outputs[0]); + avfilter_unref_pic(out); +} + +static void draw_slice(AVFilterLink *link, int y, int h, int slice_dir) +{ +} + +AVFilter avfilter_vf_unsharp = { + .name = "unsharp", + .description = NULL_IF_CONFIG_SMALL("Sharpen or blur the input video."), + + .priv_size = sizeof(UnsharpContext), + + .init = init, + .uninit = uninit, + .query_formats = query_formats, + + .inputs = (AVFilterPad[]) {{ .name = "default", + .type = AVMEDIA_TYPE_VIDEO, + .draw_slice = draw_slice, + .end_frame = end_frame, + .config_props = config_props, + .min_perms = AV_PERM_READ, }, + { .name = NULL}}, + + .outputs = (AVFilterPad[]) {{ .name = "default", + .type = AVMEDIA_TYPE_VIDEO, }, + { .name = NULL}}, +};