[FFmpeg-devel] [PATCH 2/2] lavfi: Add blurriness filter
Thilo Borgmann
thilo.borgmann at mail.de
Tue Apr 5 11:56:45 EEST 2022
Hi,
>> v3 updated to current HEAD.
>>
>> Named blurdetect filter now.
>> Minor fixes on allocation and removed -f option.
>>
>
> Please make this per plane filtering, with default to measure only first
> plane.
done in v4.
(Will add Changelog, version.h and fate test once the filter itself looks ok)
Thanks,
Thilo
-------------- next part --------------
From 6411603fe86d4fb6a781aec2ff48e48be12d269e Mon Sep 17 00:00:00 2001
From: Thilo Borgmann <thilo.borgmann at mail.de>
Date: Tue, 5 Apr 2022 10:54:19 +0200
Subject: [PATCH v4 2/2] lavfi: Add blurdetect filter
---
doc/filters.texi | 52 +++++
libavfilter/Makefile | 1 +
libavfilter/allfilters.c | 1 +
libavfilter/vf_blurdetect.c | 394 ++++++++++++++++++++++++++++++++++++
4 files changed, 448 insertions(+)
create mode 100644 libavfilter/vf_blurdetect.c
diff --git a/doc/filters.texi b/doc/filters.texi
index 636c80dbff..c6d4537804 100644
--- a/doc/filters.texi
+++ b/doc/filters.texi
@@ -7990,6 +7990,58 @@ tblend=all_mode=grainextract
@subsection Commands
This filter supports same @ref{commands} as options.
+ at anchor{blurdetect}
+ at section blurdetect
+
+Determines blurriness of frames without altering the input frames.
+
+Based on Marziliano, Pina, et al. "A no-reference perceptual blur metric."
+Allows for a block-based abbreviation.
+
+The filter accepts the following options:
+
+ at table @option
+ at item low
+ at item high
+Set low and high threshold values used by the Canny thresholding
+algorithm.
+
+The high threshold selects the "strong" edge pixels, which are then
+connected through 8-connectivity with the "weak" edge pixels selected
+by the low threshold.
+
+ at var{low} and @var{high} threshold values must be chosen in the range
+[0,1], and @var{low} should be lesser or equal to @var{high}.
+
+Default value for @var{low} is @code{20/255}, and default value for @var{high}
+is @code{50/255}.
+
+ at item radius
+Define the radius to search around an edge pixel for local maxima.
+
+ at item block_pct
+Determine blurriness only for the most significant blocks, given in percentage.
+
+ at item block_width
+Determine blurriness for blocks of width @var{block_width}. If set to any value smaller 1, no blocks are used and the whole image is processed as one no matter of @var{block_height}.
+
+ at item block_height
+Determine blurriness for blocks of height @var{block_height}. If set to any value smaller 1, no blocks are used and the whole image is processed as one no matter of @var{block_width}.
+
+ at item planes
+Set planes to filter. Default is first only.
+ at end table
+
+ at subsection Examples
+
+ at itemize
+ at item
+Determine blur for 80% of most significant 32x32 blocks:
+ at example
+blurdetect=block_width=32:block_height=32:block_pct=80
+ at end example
+ at end itemize
+
@section bm3d
Denoise frames using Block-Matching 3D algorithm.
diff --git a/libavfilter/Makefile b/libavfilter/Makefile
index 006e59b2bd..6332a6f799 100644
--- a/libavfilter/Makefile
+++ b/libavfilter/Makefile
@@ -195,6 +195,7 @@ OBJS-$(CONFIG_BLACKDETECT_FILTER) += vf_blackdetect.o
OBJS-$(CONFIG_BLACKFRAME_FILTER) += vf_blackframe.o
OBJS-$(CONFIG_BLEND_FILTER) += vf_blend.o framesync.o
OBJS-$(CONFIG_BLEND_VULKAN_FILTER) += vf_blend_vulkan.o framesync.o vulkan.o vulkan_filter.o
+OBJS-$(CONFIG_BLURDETECT_FILTER) += vf_blurdetect.o edge_common.o
OBJS-$(CONFIG_BM3D_FILTER) += vf_bm3d.o framesync.o
OBJS-$(CONFIG_BOXBLUR_FILTER) += vf_boxblur.o boxblur.o
OBJS-$(CONFIG_BOXBLUR_OPENCL_FILTER) += vf_avgblur_opencl.o opencl.o \
diff --git a/libavfilter/allfilters.c b/libavfilter/allfilters.c
index 9fbaaacf47..2667d153ad 100644
--- a/libavfilter/allfilters.c
+++ b/libavfilter/allfilters.c
@@ -183,6 +183,7 @@ extern const AVFilter ff_vf_blackdetect;
extern const AVFilter ff_vf_blackframe;
extern const AVFilter ff_vf_blend;
extern const AVFilter ff_vf_blend_vulkan;
+extern const AVFilter ff_vf_blurdetect;
extern const AVFilter ff_vf_bm3d;
extern const AVFilter ff_vf_boxblur;
extern const AVFilter ff_vf_boxblur_opencl;
diff --git a/libavfilter/vf_blurdetect.c b/libavfilter/vf_blurdetect.c
new file mode 100644
index 0000000000..71e46fa962
--- /dev/null
+++ b/libavfilter/vf_blurdetect.c
@@ -0,0 +1,394 @@
+/*
+ * Copyright (c) 2021 Thilo Borgmann <thilo.borgmann _at_ mail.de>
+ *
+ * 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
+ * No-reference blurdetect filter
+ *
+ * Implementing:
+ * Marziliano, Pina, et al. "A no-reference perceptual blur metric." Proceedings.
+ * International conference on image processing. Vol. 3. IEEE, 2002.
+ * https://infoscience.epfl.ch/record/111802/files/14%20A%20no-reference%20perceptual%20blur%20metric.pdf
+ *
+ * @author Thilo Borgmann <thilo.borgmann _at_ mail.de>
+ */
+
+#include "libavutil/avassert.h"
+#include "libavutil/imgutils.h"
+#include "libavutil/opt.h"
+#include "libavutil/pixelutils.h"
+#include "libavutil/motion_vector.h"
+#include "avfilter.h"
+#include "formats.h"
+#include "internal.h"
+#include "video.h"
+#include "edge_common.h"
+
+static int comp(const void *a,const void *b)
+{
+ float x = *(float*)a;
+ float y = *(float*)b;
+ if (x > y) return 1;
+ if (x < y) return -1;
+ return 0;
+}
+
+typedef struct BLRContext {
+ const AVClass *class;
+
+ int hsub, vsub;
+ int nb_planes;
+
+ float low, high;
+ uint8_t low_u8, high_u8;
+ int radius; // radius during local maxima detection
+ int block_pct; // percentage of "sharpest" blocks in the image to use for bluriness calculation
+ int block_width; // width for block abbreviation
+ int block_height; // height for block abbreviation
+ int planes; // number of planes to filter
+
+ double blur_total;
+ uint64_t nb_frames;
+
+ float *blks;
+ uint8_t *filterbuf;
+ uint8_t *tmpbuf;
+ uint16_t *gradients;
+ char *directions;
+} BLRContext;
+
+#define OFFSET(x) offsetof(BLRContext, x)
+#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
+static const AVOption blr_options[] = {
+ { "high", "set high threshold", OFFSET(high), AV_OPT_TYPE_FLOAT, {.dbl=30/255.}, 0, 1, FLAGS },
+ { "low", "set low threshold", OFFSET(low), AV_OPT_TYPE_FLOAT, {.dbl=15/255.}, 0, 1, FLAGS },
+ { "radius", "search radius for maxima detection", OFFSET(radius), AV_OPT_TYPE_INT, {.i64=50}, 1, 100, FLAGS },
+ { "block_pct", "block pooling threshold when calculating blurriness", OFFSET(block_pct), AV_OPT_TYPE_INT, {.i64=80}, 1, 100, FLAGS },
+ { "block_width", "block size for block-based abbreviation of blurriness", OFFSET(block_width), AV_OPT_TYPE_INT, {.i64=-1}, -1, INT_MAX, FLAGS },
+ { "block_height", "block size for block-based abbreviation of blurriness", OFFSET(block_height), AV_OPT_TYPE_INT, {.i64=-1}, -1, INT_MAX, FLAGS },
+ { "planes", "set planes to filter", OFFSET(planes), AV_OPT_TYPE_INT, {.i64=1}, 0, 15, FLAGS },
+ { NULL }
+};
+
+AVFILTER_DEFINE_CLASS(blr);
+
+static av_cold int blr_init(AVFilterContext *ctx)
+{
+ BLRContext *blr = ctx->priv;
+
+ blr->low_u8 = blr->low * 255. + .5;
+ blr->high_u8 = blr->high * 255. + .5;
+
+ return 0;
+}
+
+static int blr_config_input(AVFilterLink *inlink)
+{
+ AVFilterContext *ctx = inlink->dst;
+ BLRContext *blr = ctx->priv;
+ const int bufsize = inlink->w * inlink->h;
+ const AVPixFmtDescriptor *pix_desc;
+
+ pix_desc = av_pix_fmt_desc_get(inlink->format);
+ blr->hsub = pix_desc->log2_chroma_w;
+ blr->vsub = pix_desc->log2_chroma_h;
+ blr->nb_planes = av_pix_fmt_count_planes(inlink->format);
+
+ if (blr->block_width < 1 || blr->block_height < 1) {
+ blr->block_width = inlink->w;
+ blr->block_height = inlink->h;
+ }
+
+ blr->tmpbuf = av_malloc(bufsize);
+ blr->filterbuf = av_malloc(bufsize);
+ blr->gradients = av_calloc(bufsize, sizeof(*blr->gradients));
+ blr->directions = av_malloc(bufsize);
+ blr->blks = av_calloc((inlink->w / blr->block_width) * (inlink->h / blr->block_height),
+ sizeof(*blr->blks));
+
+ if (!blr->tmpbuf || !blr->filterbuf || !blr->gradients ||
+ !blr->directions || !blr->blks)
+ return AVERROR(ENOMEM);
+
+ return 0;
+}
+
+// edge width is defined as the distance between surrounding maxima of the edge pixel
+static float edge_width(BLRContext *blr, int i, int j, int8_t dir, int w, int h,
+ int edge, const uint8_t *src, int src_linesize)
+{
+ float width = 0;
+ int dX, dY;
+ int sign;
+ int tmp;
+ int p1;
+ int p2;
+ int k, x, y;
+ int edge1;
+ int edge2;
+ float luma1 = 0.0; // average luma difference per edge pixel
+ float luma2 = 0.0;
+ int radius = blr->radius;
+
+ switch(dir)
+ {
+ case DIRECTION_HORIZONTAL: dX = 1; dY = 0; break;
+ case DIRECTION_VERTICAL: dX = 0; dY = 1; break;
+ case DIRECTION_45UP: dX = 1; dY = -1; break;
+ case DIRECTION_45DOWN: dX = 1; dY = 1; break;
+ }
+ if (dir == DIRECTION_HORIZONTAL) return 0;
+
+ // determines if search in direction dX/dY is looking for a maximum or minimum
+ sign = src[j * src_linesize + i] > src[(j - dY) * src_linesize + i - dX] ? 1 : -1;
+
+ // search in -(dX/dY) direction
+ for (k = 0; k < radius; k++)
+ {
+ x = i - k*dX;
+ y = j - k*dY;
+ p1 = y * src_linesize + x;
+ x -= dX;
+ y -= dY;
+ p2 = y * src_linesize + x;
+ if (x < 0 || x >= w || y < 0 || y >= h)
+ return 0;
+
+ tmp = (src[p1] - src[p2]) * sign;
+
+ if (tmp <= 0) // local maximum found
+ break;
+
+ luma1 += tmp;
+ }
+ if (k > 0) luma1 /= k;
+ edge1 = k;
+ width += k;
+
+ // search in +(dX/dY) direction
+ for (k = 0; k < radius; k++)
+ {
+ x = i + k * dX;
+ y = j + k * dY;
+ p1 = y * src_linesize + x;
+ x += dX;
+ y += dY;
+ p2 = y * src_linesize + x;
+ if (x < 0 || x >= w || y < 0 || y >= h)
+ return 0;
+
+ tmp = (src[p1] - src[p2]) * sign;
+
+ if (tmp >= 0) // local maximum found
+ break;
+
+ luma2 -= tmp;
+ }
+ if (k > 0) luma2 /= k;
+ edge2 = k;
+ width += k;
+
+ // for 45 degree directions approximate edge width in pixel units: 0.7 ~= sqrt(2)/2
+ if (dir == DIRECTION_45UP || dir == DIRECTION_45DOWN)
+ width *= 0.7;
+
+ return width;
+}
+
+static float calculate_blur(BLRContext *blr, int w, int h, int hsub, int vsub,
+ uint8_t* dir, int dir_linesize,
+ uint8_t* dst, int dst_linesize,
+ uint8_t* src, int src_linesize)
+{
+ float total_width = 0.0;
+ int block_count;
+ double block_total_width;
+
+ int i, j;
+ int blkcnt = 0;
+
+ float *blks = blr->blks;
+ float block_pool_threshold = blr->block_pct / 100.0;
+
+ int block_width = AV_CEIL_RSHIFT(blr->block_width, hsub);
+ int block_height = AV_CEIL_RSHIFT(blr->block_height, vsub);
+ int brows = h / block_height;
+ int bcols = w / block_width;
+
+ for (int blkj = 0; blkj < brows; blkj++) {
+ for (int blki = 0; blki < bcols; blki++) {
+ block_total_width = 0.0;
+ block_count = 0;
+ for (int inj = 0; inj < block_height; inj++) {
+ for (int ini = 0; ini < block_width; ini++) {
+ i = blki * block_width + ini;
+ j = blkj * block_height + inj;
+
+ if (dst[j * dst_linesize + i] > 0) {
+ float width = edge_width(blr, i, j, dir[j*dir_linesize+i],
+ w, h, dst[j*dst_linesize+i],
+ src, src_linesize);
+ if (width > 0.001) { // throw away zeros
+ block_count++;
+ block_total_width += width;
+ }
+ }
+ }
+ }
+ // if not enough edge pixels in a block, consider it smooth
+ if (block_total_width >= 2) {
+ blks[blkcnt] = block_total_width / block_count;
+ blkcnt++;
+ }
+ }
+ }
+
+ // simple block pooling by sorting and keeping the sharper blocks
+ qsort(blks, blkcnt, sizeof(*blks), comp);
+ blkcnt = ceil(blkcnt * block_pool_threshold);
+ for (int i = 0; i < blkcnt; i++) {
+ total_width += blks[i];
+ }
+
+ return total_width / blkcnt;
+}
+
+static void set_meta(AVDictionary **metadata, const char *key, float d)
+{
+ char value[128];
+ snprintf(value, sizeof(value), "%f", d);
+ av_dict_set(metadata, key, value, 0);
+}
+
+static int blr_filter_frame(AVFilterLink *inlink, AVFrame *in)
+{
+ AVFilterContext *ctx = inlink->dst;
+ BLRContext *blr = ctx->priv;
+ AVFilterLink *outlink = ctx->outputs[0];
+
+ const int inw = inlink->w;
+ const int inh = inlink->h;
+
+ uint8_t *tmpbuf = blr->tmpbuf;
+ uint8_t *filterbuf = blr->filterbuf;
+ uint16_t *gradients = blr->gradients;
+ int8_t *directions = blr->directions;
+
+ float blur = 0.0f;
+ int nplanes = 0;
+ AVDictionary **metadata;
+ metadata = &in->metadata;
+
+ for (int plane = 0; plane < blr->nb_planes; plane++) {
+ int hsub = plane == 1 || plane == 2 ? blr->hsub : 0;
+ int vsub = plane == 1 || plane == 2 ? blr->vsub : 0;
+ int w = AV_CEIL_RSHIFT(inw, hsub);
+ int h = AV_CEIL_RSHIFT(inh, vsub);
+
+ if (!((1 << plane) & blr->planes))
+ continue;
+
+ nplanes++;
+
+ // gaussian filter to reduce noise
+ ff_gaussian_blur(w, h,
+ filterbuf, w,
+ in->data[plane], in->linesize[plane]);
+
+ // compute the 16-bits gradients and directions for the next step
+ ff_sobel(w, h, gradients, w, directions, w, filterbuf, w);
+
+ // non_maximum_suppression() will actually keep & clip what's necessary and
+ // ignore the rest, so we need a clean output buffer
+ memset(tmpbuf, 0, inw * inh);
+ ff_non_maximum_suppression(w, h, tmpbuf, w, directions, w, gradients, w);
+
+
+ // keep high values, or low values surrounded by high values
+ ff_double_threshold(blr->low_u8, blr->high_u8, w, h,
+ tmpbuf, w, tmpbuf, w);
+
+ blur += calculate_blur(blr, w, h, hsub, vsub, directions, w,
+ tmpbuf, w, filterbuf, w);
+ }
+
+ if (nplanes)
+ blur /= nplanes;
+
+ blr->blur_total += blur;
+
+ // write stats
+ av_log(ctx, AV_LOG_VERBOSE, "blur: %.7f\n", blur);
+
+ set_meta(metadata, "lavfi.blur", blur);
+
+ blr->nb_frames++;
+
+ return ff_filter_frame(outlink, in);
+}
+
+static av_cold void blr_uninit(AVFilterContext *ctx)
+{
+ BLRContext *blr = ctx->priv;
+
+ if (blr->nb_frames > 0) {
+ int nb_frames = blr->nb_frames;
+ av_log(ctx, AV_LOG_INFO, "blur mean: %.7f\n",
+ blr->blur_total / nb_frames);
+ }
+
+ av_freep(&blr->tmpbuf);
+ av_freep(&blr->filterbuf);
+ av_freep(&blr->gradients);
+ av_freep(&blr->directions);
+ av_freep(&blr->blks);
+}
+
+static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUV420P, AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE };
+
+static const AVFilterPad blr_inputs[] = {
+ {
+ .name = "default",
+ .type = AVMEDIA_TYPE_VIDEO,
+ .config_props = blr_config_input,
+ .filter_frame = blr_filter_frame,
+ },
+};
+
+static const AVFilterPad blr_outputs[] = {
+ {
+ .name = "default",
+ .type = AVMEDIA_TYPE_VIDEO,
+ },
+};
+
+AVFilter ff_vf_blurdetect = {
+ .name = "blurdetect",
+ .description = NULL_IF_CONFIG_SMALL("Blurdetect filter."),
+ .priv_size = sizeof(BLRContext),
+ .init = blr_init,
+ .uninit = blr_uninit,
+ FILTER_PIXFMTS_ARRAY(pix_fmts),
+ FILTER_INPUTS(blr_inputs),
+ FILTER_OUTPUTS(blr_outputs),
+ .priv_class = &blr_class,
+ .flags = AVFILTER_FLAG_METADATA_ONLY,
+};
+
--
2.20.1 (Apple Git-117)
More information about the ffmpeg-devel
mailing list