| /* |
| * Copyright (c) 2012-2014 Clément Bœsch <u pkh me> |
| * |
| * 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 |
| * Edge detection filter |
| * |
| * @see https://en.wikipedia.org/wiki/Canny_edge_detector |
| */ |
| |
| #include "libavutil/avassert.h" |
| #include "libavutil/imgutils.h" |
| #include "libavutil/opt.h" |
| #include "avfilter.h" |
| #include "formats.h" |
| #include "internal.h" |
| #include "video.h" |
| #include "edge_common.h" |
| |
| #define PLANE_R 0x4 |
| #define PLANE_G 0x1 |
| #define PLANE_B 0x2 |
| #define PLANE_Y 0x1 |
| #define PLANE_U 0x2 |
| #define PLANE_V 0x4 |
| #define PLANE_A 0x8 |
| |
| enum FilterMode { |
| MODE_WIRES, |
| MODE_COLORMIX, |
| MODE_CANNY, |
| NB_MODE |
| }; |
| |
| struct plane_info { |
| uint8_t *tmpbuf; |
| uint16_t *gradients; |
| char *directions; |
| int width, height; |
| }; |
| |
| typedef struct EdgeDetectContext { |
| const AVClass *class; |
| struct plane_info planes[3]; |
| int filter_planes; |
| int nb_planes; |
| double low, high; |
| uint8_t low_u8, high_u8; |
| int mode; |
| } EdgeDetectContext; |
| |
| #define OFFSET(x) offsetof(EdgeDetectContext, x) |
| #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM |
| static const AVOption edgedetect_options[] = { |
| { "high", "set high threshold", OFFSET(high), AV_OPT_TYPE_DOUBLE, {.dbl=50/255.}, 0, 1, FLAGS }, |
| { "low", "set low threshold", OFFSET(low), AV_OPT_TYPE_DOUBLE, {.dbl=20/255.}, 0, 1, FLAGS }, |
| { "mode", "set mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=MODE_WIRES}, 0, NB_MODE-1, FLAGS, "mode" }, |
| { "wires", "white/gray wires on black", 0, AV_OPT_TYPE_CONST, {.i64=MODE_WIRES}, INT_MIN, INT_MAX, FLAGS, "mode" }, |
| { "colormix", "mix colors", 0, AV_OPT_TYPE_CONST, {.i64=MODE_COLORMIX}, INT_MIN, INT_MAX, FLAGS, "mode" }, |
| { "canny", "detect edges on planes", 0, AV_OPT_TYPE_CONST, {.i64=MODE_CANNY}, INT_MIN, INT_MAX, FLAGS, "mode" }, |
| { "planes", "set planes to filter", OFFSET(filter_planes), AV_OPT_TYPE_FLAGS, {.i64=7}, 1, 0x7, FLAGS, "flags" }, |
| { "y", "filter luma plane", 0, AV_OPT_TYPE_CONST, {.i64=PLANE_Y}, 0, 0, FLAGS, "flags" }, |
| { "u", "filter u plane", 0, AV_OPT_TYPE_CONST, {.i64=PLANE_U}, 0, 0, FLAGS, "flags" }, |
| { "v", "filter v plane", 0, AV_OPT_TYPE_CONST, {.i64=PLANE_V}, 0, 0, FLAGS, "flags" }, |
| { "r", "filter red plane", 0, AV_OPT_TYPE_CONST, {.i64=PLANE_R}, 0, 0, FLAGS, "flags" }, |
| { "g", "filter green plane", 0, AV_OPT_TYPE_CONST, {.i64=PLANE_G}, 0, 0, FLAGS, "flags" }, |
| { "b", "filter blue plane", 0, AV_OPT_TYPE_CONST, {.i64=PLANE_B}, 0, 0, FLAGS, "flags" }, |
| { NULL } |
| }; |
| |
| AVFILTER_DEFINE_CLASS(edgedetect); |
| |
| static av_cold int init(AVFilterContext *ctx) |
| { |
| EdgeDetectContext *edgedetect = ctx->priv; |
| |
| edgedetect->low_u8 = edgedetect->low * 255. + .5; |
| edgedetect->high_u8 = edgedetect->high * 255. + .5; |
| return 0; |
| } |
| |
| static int query_formats(AVFilterContext *ctx) |
| { |
| const EdgeDetectContext *edgedetect = ctx->priv; |
| static const enum AVPixelFormat wires_pix_fmts[] = {AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE}; |
| static const enum AVPixelFormat canny_pix_fmts[] = {AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_GBRP, AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE}; |
| static const enum AVPixelFormat colormix_pix_fmts[] = {AV_PIX_FMT_GBRP, AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE}; |
| const enum AVPixelFormat *pix_fmts = NULL; |
| |
| if (edgedetect->mode == MODE_WIRES) { |
| pix_fmts = wires_pix_fmts; |
| } else if (edgedetect->mode == MODE_COLORMIX) { |
| pix_fmts = colormix_pix_fmts; |
| } else if (edgedetect->mode == MODE_CANNY) { |
| pix_fmts = canny_pix_fmts; |
| } else { |
| av_assert0(0); |
| } |
| return ff_set_common_formats_from_list(ctx, pix_fmts); |
| } |
| |
| static int config_props(AVFilterLink *inlink) |
| { |
| int p; |
| AVFilterContext *ctx = inlink->dst; |
| EdgeDetectContext *edgedetect = ctx->priv; |
| const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format); |
| |
| edgedetect->nb_planes = inlink->format == AV_PIX_FMT_GRAY8 ? 1 : 3; |
| for (p = 0; p < edgedetect->nb_planes; p++) { |
| struct plane_info *plane = &edgedetect->planes[p]; |
| int vsub = p ? desc->log2_chroma_h : 0; |
| int hsub = p ? desc->log2_chroma_w : 0; |
| |
| plane->width = AV_CEIL_RSHIFT(inlink->w, hsub); |
| plane->height = AV_CEIL_RSHIFT(inlink->h, vsub); |
| plane->tmpbuf = av_malloc(plane->width * plane->height); |
| plane->gradients = av_calloc(plane->width * plane->height, sizeof(*plane->gradients)); |
| plane->directions = av_malloc(plane->width * plane->height); |
| if (!plane->tmpbuf || !plane->gradients || !plane->directions) |
| return AVERROR(ENOMEM); |
| } |
| return 0; |
| } |
| |
| static void color_mix(int w, int h, |
| uint8_t *dst, int dst_linesize, |
| const uint8_t *src, int src_linesize) |
| { |
| int i, j; |
| |
| for (j = 0; j < h; j++) { |
| for (i = 0; i < w; i++) |
| dst[i] = (dst[i] + src[i]) >> 1; |
| dst += dst_linesize; |
| src += src_linesize; |
| } |
| } |
| |
| static int filter_frame(AVFilterLink *inlink, AVFrame *in) |
| { |
| AVFilterContext *ctx = inlink->dst; |
| EdgeDetectContext *edgedetect = ctx->priv; |
| AVFilterLink *outlink = ctx->outputs[0]; |
| int p, direct = 0; |
| AVFrame *out; |
| |
| if (edgedetect->mode != MODE_COLORMIX && av_frame_is_writable(in)) { |
| direct = 1; |
| out = in; |
| } else { |
| out = ff_get_video_buffer(outlink, outlink->w, outlink->h); |
| if (!out) { |
| av_frame_free(&in); |
| return AVERROR(ENOMEM); |
| } |
| av_frame_copy_props(out, in); |
| } |
| |
| for (p = 0; p < edgedetect->nb_planes; p++) { |
| struct plane_info *plane = &edgedetect->planes[p]; |
| uint8_t *tmpbuf = plane->tmpbuf; |
| uint16_t *gradients = plane->gradients; |
| int8_t *directions = plane->directions; |
| const int width = plane->width; |
| const int height = plane->height; |
| |
| if (!((1 << p) & edgedetect->filter_planes)) { |
| if (!direct) |
| av_image_copy_plane(out->data[p], out->linesize[p], |
| in->data[p], in->linesize[p], |
| width, height); |
| continue; |
| } |
| |
| /* gaussian filter to reduce noise */ |
| ff_gaussian_blur_8(width, height, |
| tmpbuf, width, |
| in->data[p], in->linesize[p], 1); |
| |
| /* compute the 16-bits gradients and directions for the next step */ |
| ff_sobel_8(width, height, |
| gradients, width, |
| directions,width, |
| tmpbuf, width, 1); |
| |
| /* non_maximum_suppression() will actually keep & clip what's necessary and |
| * ignore the rest, so we need a clean output buffer */ |
| memset(tmpbuf, 0, width * height); |
| ff_non_maximum_suppression(width, height, |
| tmpbuf, width, |
| directions,width, |
| gradients, width); |
| |
| /* keep high values, or low values surrounded by high values */ |
| ff_double_threshold(edgedetect->low_u8, edgedetect->high_u8, |
| width, height, |
| out->data[p], out->linesize[p], |
| tmpbuf, width); |
| |
| if (edgedetect->mode == MODE_COLORMIX) { |
| color_mix(width, height, |
| out->data[p], out->linesize[p], |
| in->data[p], in->linesize[p]); |
| } |
| } |
| |
| if (!direct) |
| av_frame_free(&in); |
| return ff_filter_frame(outlink, out); |
| } |
| |
| static av_cold void uninit(AVFilterContext *ctx) |
| { |
| int p; |
| EdgeDetectContext *edgedetect = ctx->priv; |
| |
| for (p = 0; p < edgedetect->nb_planes; p++) { |
| struct plane_info *plane = &edgedetect->planes[p]; |
| av_freep(&plane->tmpbuf); |
| av_freep(&plane->gradients); |
| av_freep(&plane->directions); |
| } |
| } |
| |
| static const AVFilterPad edgedetect_inputs[] = { |
| { |
| .name = "default", |
| .type = AVMEDIA_TYPE_VIDEO, |
| .config_props = config_props, |
| .filter_frame = filter_frame, |
| }, |
| }; |
| |
| static const AVFilterPad edgedetect_outputs[] = { |
| { |
| .name = "default", |
| .type = AVMEDIA_TYPE_VIDEO, |
| }, |
| }; |
| |
| const AVFilter ff_vf_edgedetect = { |
| .name = "edgedetect", |
| .description = NULL_IF_CONFIG_SMALL("Detect and draw edge."), |
| .priv_size = sizeof(EdgeDetectContext), |
| .init = init, |
| .uninit = uninit, |
| FILTER_INPUTS(edgedetect_inputs), |
| FILTER_OUTPUTS(edgedetect_outputs), |
| FILTER_QUERY_FUNC(query_formats), |
| .priv_class = &edgedetect_class, |
| .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, |
| }; |