[FFmpeg-devel] [PATCH] avfilter/vf_nlmeans: add >8 bit support
Paul B Mahol
onemda at gmail.com
Wed Nov 20 11:54:42 EET 2019
Signed-off-by: Paul B Mahol <onemda at gmail.com>
---
libavfilter/aarch64/vf_nlmeans_init.c | 6 +-
libavfilter/nlmeans_template.c | 370 ++++++++++++++++++
libavfilter/vf_nlmeans.c | 539 ++++++--------------------
libavfilter/vf_nlmeans.h | 59 ++-
4 files changed, 548 insertions(+), 426 deletions(-)
create mode 100644 libavfilter/nlmeans_template.c
diff --git a/libavfilter/aarch64/vf_nlmeans_init.c b/libavfilter/aarch64/vf_nlmeans_init.c
index a1edefb144..6ee157dfe0 100644
--- a/libavfilter/aarch64/vf_nlmeans_init.c
+++ b/libavfilter/aarch64/vf_nlmeans_init.c
@@ -24,10 +24,10 @@ void ff_compute_safe_ssd_integral_image_neon(uint32_t *dst, ptrdiff_t dst_linesi
const uint8_t *s2, ptrdiff_t linesize2,
int w, int h);
-av_cold void ff_nlmeans_init_aarch64(NLMeansDSPContext *dsp)
+av_cold void ff_nlmeans_init_aarch64(NLMeansDSPContext *dsp, int depth)
{
int cpu_flags = av_get_cpu_flags();
- if (have_neon(cpu_flags))
- dsp->compute_safe_ssd_integral_image = ff_compute_safe_ssd_integral_image_neon;
+ if (have_neon(cpu_flags) && depth == 8)
+ dsp->compute_safe_ssd_integral_image32 = ff_compute_safe_ssd_integral_image_neon;
}
diff --git a/libavfilter/nlmeans_template.c b/libavfilter/nlmeans_template.c
new file mode 100644
index 0000000000..b0d7f7482d
--- /dev/null
+++ b/libavfilter/nlmeans_template.c
@@ -0,0 +1,370 @@
+/*
+ * Copyright (c) 2016 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
+ */
+
+#include "libavutil/avassert.h"
+#include "avfilter.h"
+#include "formats.h"
+#include "internal.h"
+#include "vf_nlmeans.h"
+#include "video.h"
+
+#undef pixel
+#undef integral
+#undef INTEGRAL_DEPTH
+#if DEPTH <= 8
+#define INTEGRAL_DEPTH 32
+#define pixel uint8_t
+#define integral uint32_t
+#else
+#define INTEGRAL_DEPTH 64
+#define pixel uint16_t
+#define integral uint64_t
+#endif
+
+#define fn3(a,b) a##b
+#define fn2(a,b) fn3(a,b)
+#define fn(a) fn2(a, DEPTH)
+#define ii(a) fn2(a, INTEGRAL_DEPTH)
+
+/**
+ * Compute squared difference of the safe area (the zone where s1 and s2
+ * overlap). It is likely the largest integral zone, so it is interesting to do
+ * as little checks as possible; contrary to the unsafe version of this
+ * function, we do not need any clipping here.
+ *
+ * The line above dst and the column to its left are always readable.
+ */
+static void fn(compute_safe_ssd_integral_image_c)(integral *dst, ptrdiff_t dst_linesize_32,
+ const uint8_t *ss1, ptrdiff_t linesize1,
+ const uint8_t *ss2, ptrdiff_t linesize2,
+ int w, int h)
+{
+ const pixel *s1 = (const pixel *)ss1;
+ const pixel *s2 = (const pixel *)ss2;
+ int x, y;
+ const integral *dst_top = dst - dst_linesize_32;
+
+ linesize1 /= sizeof(pixel);
+ linesize2 /= sizeof(pixel);
+
+ /* SIMD-friendly assumptions allowed here */
+ av_assert2(!(w & 0xf) && w >= 16 && h >= 1);
+
+ for (y = 0; y < h; y++) {
+ for (x = 0; x < w; x += 4) {
+ const int d0 = s1[x ] - s2[x ];
+ const int d1 = s1[x + 1] - s2[x + 1];
+ const int d2 = s1[x + 2] - s2[x + 2];
+ const int d3 = s1[x + 3] - s2[x + 3];
+
+ dst[x ] = dst_top[x ] - dst_top[x - 1] + d0*d0;
+ dst[x + 1] = dst_top[x + 1] - dst_top[x ] + d1*d1;
+ dst[x + 2] = dst_top[x + 2] - dst_top[x + 1] + d2*d2;
+ dst[x + 3] = dst_top[x + 3] - dst_top[x + 2] + d3*d3;
+
+ dst[x ] += dst[x - 1];
+ dst[x + 1] += dst[x ];
+ dst[x + 2] += dst[x + 1];
+ dst[x + 3] += dst[x + 2];
+ }
+ s1 += linesize1;
+ s2 += linesize2;
+ dst += dst_linesize_32;
+ dst_top += dst_linesize_32;
+ }
+}
+
+/**
+ * Compute squared difference of an unsafe area (the zone nor s1 nor s2 could
+ * be readable).
+ *
+ * On the other hand, the line above dst and the column to its left are always
+ * readable.
+ *
+ * There is little point in having this function SIMDified as it is likely too
+ * complex and only handle small portions of the image.
+ *
+ * @param dst integral image
+ * @param dst_linesize_32 integral image linesize (in 32-bit integers unit)
+ * @param startx integral starting x position
+ * @param starty integral starting y position
+ * @param ssrc source plane buffer
+ * @param linesize source plane linesize
+ * @param offx source offsetting in x
+ * @param offy source offsetting in y
+ * @paran r absolute maximum source offsetting
+ * @param sw source width
+ * @param sh source height
+ * @param w width to compute
+ * @param h height to compute
+ */
+static inline void fn(compute_unsafe_ssd_integral_image)(integral *dst, ptrdiff_t dst_linesize_32,
+ int startx, int starty,
+ const uint8_t *ssrc, ptrdiff_t linesize,
+ int offx, int offy, int r, int sw, int sh,
+ int w, int h)
+{
+ const pixel *src = (const pixel *)ssrc;
+ int x, y;
+
+ linesize /= sizeof(pixel);
+
+ for (y = starty; y < starty + h; y++) {
+ integral acc = dst[y*dst_linesize_32 + startx - 1] - dst[(y-1)*dst_linesize_32 + startx - 1];
+ const int s1y = av_clip(y - r, 0, sh - 1);
+ const int s2y = av_clip(y - (r + offy), 0, sh - 1);
+
+ for (x = startx; x < startx + w; x++) {
+ const int s1x = av_clip(x - r, 0, sw - 1);
+ const int s2x = av_clip(x - (r + offx), 0, sw - 1);
+ const pixel v1 = src[s1y*linesize + s1x];
+ const pixel v2 = src[s2y*linesize + s2x];
+ const int d = v1 - v2;
+ acc += d * d;
+ dst[y*dst_linesize_32 + x] = dst[(y-1)*dst_linesize_32 + x] + acc;
+ }
+ }
+}
+
+/*
+ * Compute the sum of squared difference integral image
+ * http://www.ipol.im/pub/art/2014/57/
+ * Integral Images for Block Matching - Gabriele Facciolo, Nicolas Limare, Enric Meinhardt-Llopis
+ *
+ * @param ii integral image of dimension (w+e*2) x (h+e*2) with
+ * an additional zeroed top line and column already
+ * "applied" to the pointer value
+ * @param ii_linesize_32 integral image linesize (in 32-bit integers unit)
+ * @param src source plane buffer
+ * @param linesize source plane linesize
+ * @param offx x-offsetting ranging in [-e;e]
+ * @param offy y-offsetting ranging in [-e;e]
+ * @param w source width
+ * @param h source height
+ * @param e research padding edge
+ */
+static void fn(compute_ssd_integral_image)(const NLMeansDSPContext *dsp,
+ integral *ii, ptrdiff_t ii_linesize_32,
+ const uint8_t *src, ptrdiff_t linesize, int offx, int offy,
+ int e, int w, int h)
+{
+ // ii has a surrounding padding of thickness "e"
+ const int ii_w = w + e*2;
+ const int ii_h = h + e*2;
+
+ // we center the first source
+ const int s1x = e;
+ const int s1y = e;
+
+ // 2nd source is the frame with offsetting
+ const int s2x = e + offx;
+ const int s2y = e + offy;
+
+ // get the dimension of the overlapping rectangle where it is always safe
+ // to compare the 2 sources pixels
+ const int startx_safe = FFMAX(s1x, s2x);
+ const int starty_safe = FFMAX(s1y, s2y);
+ const int u_endx_safe = FFMIN(s1x + w, s2x + w); // unaligned
+ const int endy_safe = FFMIN(s1y + h, s2y + h);
+
+ // deduce the safe area width and height
+ const int safe_pw = (u_endx_safe - startx_safe) & ~0xf;
+ const int safe_ph = endy_safe - starty_safe;
+
+ // adjusted end x position of the safe area after width of the safe area gets aligned
+ const int endx_safe = startx_safe + safe_pw;
+
+ // top part where only one of s1 and s2 is still readable, or none at all
+ fn(compute_unsafe_ssd_integral_image)(ii, ii_linesize_32,
+ 0, 0,
+ src, linesize,
+ offx, offy, e, w, h,
+ ii_w, starty_safe);
+
+ // fill the left column integral required to compute the central
+ // overlapping one
+ fn(compute_unsafe_ssd_integral_image)(ii, ii_linesize_32,
+ 0, starty_safe,
+ src, linesize,
+ offx, offy, e, w, h,
+ startx_safe, safe_ph);
+
+ // main and safe part of the integral
+ av_assert1(startx_safe - s1x >= 0); av_assert1(startx_safe - s1x < w);
+ av_assert1(starty_safe - s1y >= 0); av_assert1(starty_safe - s1y < h);
+ av_assert1(startx_safe - s2x >= 0); av_assert1(startx_safe - s2x < w);
+ av_assert1(starty_safe - s2y >= 0); av_assert1(starty_safe - s2y < h);
+ if (safe_pw && safe_ph)
+ ii(dsp->compute_safe_ssd_integral_image)(ii + starty_safe*ii_linesize_32 + startx_safe, ii_linesize_32,
+ src + (starty_safe - s1y) * linesize + (startx_safe - s1x) * sizeof(pixel), linesize,
+ src + (starty_safe - s2y) * linesize + (startx_safe - s2x) * sizeof(pixel), linesize,
+ safe_pw, safe_ph);
+
+ // right part of the integral
+ fn(compute_unsafe_ssd_integral_image)(ii, ii_linesize_32,
+ endx_safe, starty_safe,
+ src, linesize,
+ offx, offy, e, w, h,
+ ii_w - endx_safe, safe_ph);
+
+ // bottom part where only one of s1 and s2 is still readable, or none at all
+ fn(compute_unsafe_ssd_integral_image)(ii, ii_linesize_32,
+ 0, endy_safe,
+ src, linesize,
+ offx, offy, e, w, h,
+ ii_w, ii_h - endy_safe);
+}
+
+static int fn(nlmeans_slice)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
+{
+ int x, y;
+ NLMeansContext *s = ctx->priv;
+ const struct thread_data *td = arg;
+ const ptrdiff_t src_linesize = td->src_linesize;
+ const int process_h = td->endy - td->starty;
+ const int slice_start = (process_h * jobnr ) / nb_jobs;
+ const int slice_end = (process_h * (jobnr+1)) / nb_jobs;
+ const int starty = td->starty + slice_start;
+ const int endy = td->starty + slice_end;
+ const int p = td->p;
+ const integral *ii = ii(td->ii_start) + (starty - p - 1) * s->ii_lz_32 - p - 1;
+ const int dist_b = 2*p + 1;
+ const int dist_d = dist_b * s->ii_lz_32;
+ const int dist_e = dist_d + dist_b;
+
+ for (y = starty; y < endy; y++) {
+ const pixel *src = (const pixel *)(td->src + y*src_linesize);
+ struct weighted_avg *wa = s->wa + y*s->wa_linesize;
+ for (x = td->startx; x < td->endx; x++) {
+ /*
+ * M is a discrete map where every entry contains the sum of all the entries
+ * in the rectangle from the top-left origin of M to its coordinate. In the
+ * following schema, "i" contains the sum of the whole map:
+ *
+ * M = +----------+-----------------+----+
+ * | | | |
+ * | | | |
+ * | a| b| c|
+ * +----------+-----------------+----+
+ * | | | |
+ * | | | |
+ * | | X | |
+ * | | | |
+ * | d| e| f|
+ * +----------+-----------------+----+
+ * | | | |
+ * | g| h| i|
+ * +----------+-----------------+----+
+ *
+ * The sum of the X box can be calculated with:
+ * X = e-d-b+a
+ *
+ * See https://en.wikipedia.org/wiki/Summed_area_table
+ *
+ * The compute*_ssd functions compute the integral image M where every entry
+ * contains the sum of the squared difference of every corresponding pixels of
+ * two input planes of the same size as M.
+ */
+ const integral a = ii[x];
+ const integral b = ii[x + dist_b];
+ const integral d = ii[x + dist_d];
+ const integral e = ii[x + dist_e];
+ const integral patch_diff_sq = e + a - d - b;
+
+ if (patch_diff_sq < s->max_meaningful_diff) {
+ const float weight = s->weight_lut[patch_diff_sq]; // exp(-patch_diff_sq * s->pdiff_scale)
+ wa[x].total_weight += weight;
+ wa[x].sum += weight * src[x];
+ }
+ }
+ ii += s->ii_lz_32;
+ }
+ return 0;
+}
+
+static void fn(weight_averages)(uint8_t *ddst, ptrdiff_t dst_linesize,
+ const uint8_t *ssrc, ptrdiff_t src_linesize,
+ struct weighted_avg *wa, ptrdiff_t wa_linesize,
+ int w, int h)
+{
+ const pixel *src = (const pixel *)ssrc;
+ pixel *dst = (pixel *)ddst;
+ int x, y;
+
+ src_linesize /= sizeof(pixel);
+ dst_linesize /= sizeof(pixel);
+
+ for (y = 0; y < h; y++) {
+ for (x = 0; x < w; x++) {
+ // Also weight the centered pixel
+ wa[x].total_weight += 1.f;
+ wa[x].sum += 1.f * src[x];
+ dst[x] = av_clip_uintp2(wa[x].sum / wa[x].total_weight + 0.5f, DEPTH);
+ }
+ dst += dst_linesize;
+ src += src_linesize;
+ wa += wa_linesize;
+ }
+}
+
+static int fn(nlmeans_plane)(AVFilterContext *ctx, int w, int h, int p, int r,
+ uint8_t *dst, ptrdiff_t dst_linesize,
+ const uint8_t *src, ptrdiff_t src_linesize)
+{
+ int offx, offy;
+ NLMeansContext *s = ctx->priv;
+ /* patches center points cover the whole research window so the patches
+ * themselves overflow the research window */
+ const int e = r + p;
+ /* focus an integral pointer on the centered image (s1) */
+ const uint32_t *centered_ii32 = s->ii32 + e*s->ii_lz_32 + e;
+ const uint64_t *centered_ii64 = s->ii64 + e*s->ii_lz_32 + e;
+
+ memset(s->wa, 0, s->wa_linesize * h * sizeof(*s->wa));
+
+ for (offy = -r; offy <= r; offy++) {
+ for (offx = -r; offx <= r; offx++) {
+ if (offx || offy) {
+ struct thread_data td = {
+ .src = src + offy*src_linesize + offx * (int)(sizeof(pixel)),
+ .src_linesize = src_linesize,
+ .startx = FFMAX(0, -offx),
+ .starty = FFMAX(0, -offy),
+ .endx = FFMIN(w, w - offx),
+ .endy = FFMIN(h, h - offy),
+ .ii_start32 = centered_ii32 + offy*s->ii_lz_32 + offx,
+ .ii_start64 = centered_ii64 + offy*s->ii_lz_32 + offx,
+ .p = p,
+ };
+
+ fn(compute_ssd_integral_image)(&s->dsp, ii(s->ii), s->ii_lz_32,
+ src, src_linesize,
+ offx, offy, e, w, h);
+ ctx->internal->execute(ctx, fn(nlmeans_slice), &td, NULL,
+ FFMIN(td.endy - td.starty, ff_filter_get_nb_threads(ctx)));
+ }
+ }
+ }
+
+ fn(weight_averages)(dst, dst_linesize, src, src_linesize,
+ s->wa, s->wa_linesize, w, h);
+
+ return 0;
+}
diff --git a/libavfilter/vf_nlmeans.c b/libavfilter/vf_nlmeans.c
index 06233b0dd4..bf7cf3aa0e 100644
--- a/libavfilter/vf_nlmeans.c
+++ b/libavfilter/vf_nlmeans.c
@@ -38,31 +38,28 @@
#include "vf_nlmeans.h"
#include "video.h"
-struct weighted_avg {
- float total_weight;
- float sum;
-};
+#define DEPTH 8
+#include "nlmeans_template.c"
+
+#undef DEPTH
+#define DEPTH 9
+#include "nlmeans_template.c"
+
+#undef DEPTH
+#define DEPTH 10
+#include "nlmeans_template.c"
+
+#undef DEPTH
+#define DEPTH 12
+#include "nlmeans_template.c"
+
+#undef DEPTH
+#define DEPTH 14
+#include "nlmeans_template.c"
-typedef struct NLMeansContext {
- const AVClass *class;
- int nb_planes;
- int chroma_w, chroma_h;
- double pdiff_scale; // invert of the filtering parameter (sigma*10) squared
- double sigma; // denoising strength
- int patch_size, patch_hsize; // patch size and half size
- int patch_size_uv, patch_hsize_uv; // patch size and half size for chroma planes
- int research_size, research_hsize; // research size and half size
- int research_size_uv, research_hsize_uv; // research size and half size for chroma planes
- uint32_t *ii_orig; // integral image
- uint32_t *ii; // integral image starting after the 0-line and 0-column
- int ii_w, ii_h; // width and height of the integral image
- ptrdiff_t ii_lz_32; // linesize in 32-bit units of the integral image
- struct weighted_avg *wa; // weighted average of every pixel
- ptrdiff_t wa_linesize; // linesize for wa in struct size unit
- float *weight_lut; // lookup table mapping (scaled) patch differences to their associated weights
- uint32_t max_meaningful_diff; // maximum difference considered (if the patch difference is too high we ignore the pixel)
- NLMeansDSPContext dsp;
-} NLMeansContext;
+#undef DEPTH
+#define DEPTH 16
+#include "nlmeans_template.c"
#define OFFSET(x) offsetof(NLMeansContext, x)
#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
@@ -87,6 +84,13 @@ static int query_formats(AVFilterContext *ctx)
AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
AV_PIX_FMT_YUVJ411P,
AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP,
+ AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
+ AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
+ AV_PIX_FMT_YUV440P10,
+ AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV420P12,
+ AV_PIX_FMT_YUV440P12,
+ AV_PIX_FMT_YUV444P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV420P14,
+ AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,
AV_PIX_FMT_NONE
};
@@ -96,380 +100,6 @@ static int query_formats(AVFilterContext *ctx)
return ff_set_common_formats(ctx, fmts_list);
}
-/**
- * Compute squared difference of the safe area (the zone where s1 and s2
- * overlap). It is likely the largest integral zone, so it is interesting to do
- * as little checks as possible; contrary to the unsafe version of this
- * function, we do not need any clipping here.
- *
- * The line above dst and the column to its left are always readable.
- */
-static void compute_safe_ssd_integral_image_c(uint32_t *dst, ptrdiff_t dst_linesize_32,
- const uint8_t *s1, ptrdiff_t linesize1,
- const uint8_t *s2, ptrdiff_t linesize2,
- int w, int h)
-{
- int x, y;
- const uint32_t *dst_top = dst - dst_linesize_32;
-
- /* SIMD-friendly assumptions allowed here */
- av_assert2(!(w & 0xf) && w >= 16 && h >= 1);
-
- for (y = 0; y < h; y++) {
- for (x = 0; x < w; x += 4) {
- const int d0 = s1[x ] - s2[x ];
- const int d1 = s1[x + 1] - s2[x + 1];
- const int d2 = s1[x + 2] - s2[x + 2];
- const int d3 = s1[x + 3] - s2[x + 3];
-
- dst[x ] = dst_top[x ] - dst_top[x - 1] + d0*d0;
- dst[x + 1] = dst_top[x + 1] - dst_top[x ] + d1*d1;
- dst[x + 2] = dst_top[x + 2] - dst_top[x + 1] + d2*d2;
- dst[x + 3] = dst_top[x + 3] - dst_top[x + 2] + d3*d3;
-
- dst[x ] += dst[x - 1];
- dst[x + 1] += dst[x ];
- dst[x + 2] += dst[x + 1];
- dst[x + 3] += dst[x + 2];
- }
- s1 += linesize1;
- s2 += linesize2;
- dst += dst_linesize_32;
- dst_top += dst_linesize_32;
- }
-}
-
-/**
- * Compute squared difference of an unsafe area (the zone nor s1 nor s2 could
- * be readable).
- *
- * On the other hand, the line above dst and the column to its left are always
- * readable.
- *
- * There is little point in having this function SIMDified as it is likely too
- * complex and only handle small portions of the image.
- *
- * @param dst integral image
- * @param dst_linesize_32 integral image linesize (in 32-bit integers unit)
- * @param startx integral starting x position
- * @param starty integral starting y position
- * @param src source plane buffer
- * @param linesize source plane linesize
- * @param offx source offsetting in x
- * @param offy source offsetting in y
- * @paran r absolute maximum source offsetting
- * @param sw source width
- * @param sh source height
- * @param w width to compute
- * @param h height to compute
- */
-static inline void compute_unsafe_ssd_integral_image(uint32_t *dst, ptrdiff_t dst_linesize_32,
- int startx, int starty,
- const uint8_t *src, ptrdiff_t linesize,
- int offx, int offy, int r, int sw, int sh,
- int w, int h)
-{
- int x, y;
-
- for (y = starty; y < starty + h; y++) {
- uint32_t acc = dst[y*dst_linesize_32 + startx - 1] - dst[(y-1)*dst_linesize_32 + startx - 1];
- const int s1y = av_clip(y - r, 0, sh - 1);
- const int s2y = av_clip(y - (r + offy), 0, sh - 1);
-
- for (x = startx; x < startx + w; x++) {
- const int s1x = av_clip(x - r, 0, sw - 1);
- const int s2x = av_clip(x - (r + offx), 0, sw - 1);
- const uint8_t v1 = src[s1y*linesize + s1x];
- const uint8_t v2 = src[s2y*linesize + s2x];
- const int d = v1 - v2;
- acc += d * d;
- dst[y*dst_linesize_32 + x] = dst[(y-1)*dst_linesize_32 + x] + acc;
- }
- }
-}
-
-/*
- * Compute the sum of squared difference integral image
- * http://www.ipol.im/pub/art/2014/57/
- * Integral Images for Block Matching - Gabriele Facciolo, Nicolas Limare, Enric Meinhardt-Llopis
- *
- * @param ii integral image of dimension (w+e*2) x (h+e*2) with
- * an additional zeroed top line and column already
- * "applied" to the pointer value
- * @param ii_linesize_32 integral image linesize (in 32-bit integers unit)
- * @param src source plane buffer
- * @param linesize source plane linesize
- * @param offx x-offsetting ranging in [-e;e]
- * @param offy y-offsetting ranging in [-e;e]
- * @param w source width
- * @param h source height
- * @param e research padding edge
- */
-static void compute_ssd_integral_image(const NLMeansDSPContext *dsp,
- uint32_t *ii, ptrdiff_t ii_linesize_32,
- const uint8_t *src, ptrdiff_t linesize, int offx, int offy,
- int e, int w, int h)
-{
- // ii has a surrounding padding of thickness "e"
- const int ii_w = w + e*2;
- const int ii_h = h + e*2;
-
- // we center the first source
- const int s1x = e;
- const int s1y = e;
-
- // 2nd source is the frame with offsetting
- const int s2x = e + offx;
- const int s2y = e + offy;
-
- // get the dimension of the overlapping rectangle where it is always safe
- // to compare the 2 sources pixels
- const int startx_safe = FFMAX(s1x, s2x);
- const int starty_safe = FFMAX(s1y, s2y);
- const int u_endx_safe = FFMIN(s1x + w, s2x + w); // unaligned
- const int endy_safe = FFMIN(s1y + h, s2y + h);
-
- // deduce the safe area width and height
- const int safe_pw = (u_endx_safe - startx_safe) & ~0xf;
- const int safe_ph = endy_safe - starty_safe;
-
- // adjusted end x position of the safe area after width of the safe area gets aligned
- const int endx_safe = startx_safe + safe_pw;
-
- // top part where only one of s1 and s2 is still readable, or none at all
- compute_unsafe_ssd_integral_image(ii, ii_linesize_32,
- 0, 0,
- src, linesize,
- offx, offy, e, w, h,
- ii_w, starty_safe);
-
- // fill the left column integral required to compute the central
- // overlapping one
- compute_unsafe_ssd_integral_image(ii, ii_linesize_32,
- 0, starty_safe,
- src, linesize,
- offx, offy, e, w, h,
- startx_safe, safe_ph);
-
- // main and safe part of the integral
- av_assert1(startx_safe - s1x >= 0); av_assert1(startx_safe - s1x < w);
- av_assert1(starty_safe - s1y >= 0); av_assert1(starty_safe - s1y < h);
- av_assert1(startx_safe - s2x >= 0); av_assert1(startx_safe - s2x < w);
- av_assert1(starty_safe - s2y >= 0); av_assert1(starty_safe - s2y < h);
- if (safe_pw && safe_ph)
- dsp->compute_safe_ssd_integral_image(ii + starty_safe*ii_linesize_32 + startx_safe, ii_linesize_32,
- src + (starty_safe - s1y) * linesize + (startx_safe - s1x), linesize,
- src + (starty_safe - s2y) * linesize + (startx_safe - s2x), linesize,
- safe_pw, safe_ph);
-
- // right part of the integral
- compute_unsafe_ssd_integral_image(ii, ii_linesize_32,
- endx_safe, starty_safe,
- src, linesize,
- offx, offy, e, w, h,
- ii_w - endx_safe, safe_ph);
-
- // bottom part where only one of s1 and s2 is still readable, or none at all
- compute_unsafe_ssd_integral_image(ii, ii_linesize_32,
- 0, endy_safe,
- src, linesize,
- offx, offy, e, w, h,
- ii_w, ii_h - endy_safe);
-}
-
-static int config_input(AVFilterLink *inlink)
-{
- AVFilterContext *ctx = inlink->dst;
- NLMeansContext *s = ctx->priv;
- const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
- const int e = FFMAX(s->research_hsize, s->research_hsize_uv)
- + FFMAX(s->patch_hsize, s->patch_hsize_uv);
-
- s->chroma_w = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
- s->chroma_h = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
- s->nb_planes = av_pix_fmt_count_planes(inlink->format);
-
- /* Allocate the integral image with extra edges of thickness "e"
- *
- * +_+-------------------------------+
- * |0|0000000000000000000000000000000|
- * +-x-------------------------------+
- * |0|\ ^ |
- * |0| ii | e |
- * |0| v |
- * |0| +-----------------------+ |
- * |0| | | |
- * |0|<->| | |
- * |0| e | | |
- * |0| | | |
- * |0| +-----------------------+ |
- * |0| |
- * |0| |
- * |0| |
- * +-+-------------------------------+
- */
- s->ii_w = inlink->w + e*2;
- s->ii_h = inlink->h + e*2;
-
- // align to 4 the linesize, "+1" is for the space of the left 0-column
- s->ii_lz_32 = FFALIGN(s->ii_w + 1, 4);
-
- // "+1" is for the space of the top 0-line
- s->ii_orig = av_mallocz_array(s->ii_h + 1, s->ii_lz_32 * sizeof(*s->ii_orig));
- if (!s->ii_orig)
- return AVERROR(ENOMEM);
-
- // skip top 0-line and left 0-column
- s->ii = s->ii_orig + s->ii_lz_32 + 1;
-
- // allocate weighted average for every pixel
- s->wa_linesize = inlink->w;
- s->wa = av_malloc_array(s->wa_linesize, inlink->h * sizeof(*s->wa));
- if (!s->wa)
- return AVERROR(ENOMEM);
-
- return 0;
-}
-
-struct thread_data {
- const uint8_t *src;
- ptrdiff_t src_linesize;
- int startx, starty;
- int endx, endy;
- const uint32_t *ii_start;
- int p;
-};
-
-static int nlmeans_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
-{
- int x, y;
- NLMeansContext *s = ctx->priv;
- const struct thread_data *td = arg;
- const ptrdiff_t src_linesize = td->src_linesize;
- const int process_h = td->endy - td->starty;
- const int slice_start = (process_h * jobnr ) / nb_jobs;
- const int slice_end = (process_h * (jobnr+1)) / nb_jobs;
- const int starty = td->starty + slice_start;
- const int endy = td->starty + slice_end;
- const int p = td->p;
- const uint32_t *ii = td->ii_start + (starty - p - 1) * s->ii_lz_32 - p - 1;
- const int dist_b = 2*p + 1;
- const int dist_d = dist_b * s->ii_lz_32;
- const int dist_e = dist_d + dist_b;
-
- for (y = starty; y < endy; y++) {
- const uint8_t *src = td->src + y*src_linesize;
- struct weighted_avg *wa = s->wa + y*s->wa_linesize;
- for (x = td->startx; x < td->endx; x++) {
- /*
- * M is a discrete map where every entry contains the sum of all the entries
- * in the rectangle from the top-left origin of M to its coordinate. In the
- * following schema, "i" contains the sum of the whole map:
- *
- * M = +----------+-----------------+----+
- * | | | |
- * | | | |
- * | a| b| c|
- * +----------+-----------------+----+
- * | | | |
- * | | | |
- * | | X | |
- * | | | |
- * | d| e| f|
- * +----------+-----------------+----+
- * | | | |
- * | g| h| i|
- * +----------+-----------------+----+
- *
- * The sum of the X box can be calculated with:
- * X = e-d-b+a
- *
- * See https://en.wikipedia.org/wiki/Summed_area_table
- *
- * The compute*_ssd functions compute the integral image M where every entry
- * contains the sum of the squared difference of every corresponding pixels of
- * two input planes of the same size as M.
- */
- const uint32_t a = ii[x];
- const uint32_t b = ii[x + dist_b];
- const uint32_t d = ii[x + dist_d];
- const uint32_t e = ii[x + dist_e];
- const uint32_t patch_diff_sq = e - d - b + a;
-
- if (patch_diff_sq < s->max_meaningful_diff) {
- const float weight = s->weight_lut[patch_diff_sq]; // exp(-patch_diff_sq * s->pdiff_scale)
- wa[x].total_weight += weight;
- wa[x].sum += weight * src[x];
- }
- }
- ii += s->ii_lz_32;
- }
- return 0;
-}
-
-static void weight_averages(uint8_t *dst, ptrdiff_t dst_linesize,
- const uint8_t *src, ptrdiff_t src_linesize,
- struct weighted_avg *wa, ptrdiff_t wa_linesize,
- int w, int h)
-{
- int x, y;
-
- for (y = 0; y < h; y++) {
- for (x = 0; x < w; x++) {
- // Also weight the centered pixel
- wa[x].total_weight += 1.f;
- wa[x].sum += 1.f * src[x];
- dst[x] = av_clip_uint8(wa[x].sum / wa[x].total_weight + 0.5f);
- }
- dst += dst_linesize;
- src += src_linesize;
- wa += wa_linesize;
- }
-}
-
-static int nlmeans_plane(AVFilterContext *ctx, int w, int h, int p, int r,
- uint8_t *dst, ptrdiff_t dst_linesize,
- const uint8_t *src, ptrdiff_t src_linesize)
-{
- int offx, offy;
- NLMeansContext *s = ctx->priv;
- /* patches center points cover the whole research window so the patches
- * themselves overflow the research window */
- const int e = r + p;
- /* focus an integral pointer on the centered image (s1) */
- const uint32_t *centered_ii = s->ii + e*s->ii_lz_32 + e;
-
- memset(s->wa, 0, s->wa_linesize * h * sizeof(*s->wa));
-
- for (offy = -r; offy <= r; offy++) {
- for (offx = -r; offx <= r; offx++) {
- if (offx || offy) {
- struct thread_data td = {
- .src = src + offy*src_linesize + offx,
- .src_linesize = src_linesize,
- .startx = FFMAX(0, -offx),
- .starty = FFMAX(0, -offy),
- .endx = FFMIN(w, w - offx),
- .endy = FFMIN(h, h - offy),
- .ii_start = centered_ii + offy*s->ii_lz_32 + offx,
- .p = p,
- };
-
- compute_ssd_integral_image(&s->dsp, s->ii, s->ii_lz_32,
- src, src_linesize,
- offx, offy, e, w, h);
- ctx->internal->execute(ctx, nlmeans_slice, &td, NULL,
- FFMIN(td.endy - td.starty, ff_filter_get_nb_threads(ctx)));
- }
- }
- }
-
- weight_averages(dst, dst_linesize, src, src_linesize,
- s->wa, s->wa_linesize, w, h);
-
- return 0;
-}
-
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
{
int i;
@@ -489,15 +119,30 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
const int h = i ? s->chroma_h : inlink->h;
const int p = i ? s->patch_hsize_uv : s->patch_hsize;
const int r = i ? s->research_hsize_uv : s->research_hsize;
- nlmeans_plane(ctx, w, h, p, r,
- out->data[i], out->linesize[i],
- in->data[i], in->linesize[i]);
+ s->nlmeans_plane(ctx, w, h, p, r,
+ out->data[i], out->linesize[i],
+ in->data[i], in->linesize[i]);
}
av_frame_free(&in);
return ff_filter_frame(outlink, out);
}
+void ff_nlmeans_init(NLMeansDSPContext *dsp, int depth)
+{
+ switch (depth) {
+ case 8: dsp->compute_safe_ssd_integral_image32 = compute_safe_ssd_integral_image_c8; break;
+ case 9: dsp->compute_safe_ssd_integral_image64 = compute_safe_ssd_integral_image_c9; break;
+ case 10: dsp->compute_safe_ssd_integral_image64 = compute_safe_ssd_integral_image_c10; break;
+ case 12: dsp->compute_safe_ssd_integral_image64 = compute_safe_ssd_integral_image_c12; break;
+ case 14: dsp->compute_safe_ssd_integral_image64 = compute_safe_ssd_integral_image_c14; break;
+ case 16: dsp->compute_safe_ssd_integral_image64 = compute_safe_ssd_integral_image_c16; break;
+ }
+
+ if (ARCH_AARCH64)
+ ff_nlmeans_init_aarch64(dsp, depth);
+}
+
#define CHECK_ODD_FIELD(field, name) do { \
if (!(s->field & 1)) { \
s->field |= 1; \
@@ -506,26 +151,22 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
} \
} while (0)
-void ff_nlmeans_init(NLMeansDSPContext *dsp)
-{
- dsp->compute_safe_ssd_integral_image = compute_safe_ssd_integral_image_c;
-
- if (ARCH_AARCH64)
- ff_nlmeans_init_aarch64(dsp);
-}
-
-static av_cold int init(AVFilterContext *ctx)
+static int config_input(AVFilterLink *inlink)
{
- int i;
+ AVFilterContext *ctx = inlink->dst;
NLMeansContext *s = ctx->priv;
- const double h = s->sigma * 10.;
+ const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
+ double h;
+ int e;
+ s->depth = desc->comp[0].depth;
+ h = s->sigma * 10. * (1 << (s->depth - 8));
s->pdiff_scale = 1. / (h * h);
- s->max_meaningful_diff = log(255.) / s->pdiff_scale;
+ s->max_meaningful_diff = FFMIN(log(255.) / s->pdiff_scale, INT32_MAX / 8);
s->weight_lut = av_calloc(s->max_meaningful_diff, sizeof(*s->weight_lut));
if (!s->weight_lut)
return AVERROR(ENOMEM);
- for (i = 0; i < s->max_meaningful_diff; i++)
+ for (int i = 0; i < s->max_meaningful_diff; i++)
s->weight_lut[i] = exp(-i * s->pdiff_scale);
CHECK_ODD_FIELD(research_size, "Luma research window");
@@ -542,11 +183,75 @@ static av_cold int init(AVFilterContext *ctx)
s->patch_hsize = s->patch_size / 2;
s->patch_hsize_uv = s->patch_size_uv / 2;
+ e = FFMAX(s->research_hsize, s->research_hsize_uv) +
+ FFMAX(s->patch_hsize, s->patch_hsize_uv);
av_log(ctx, AV_LOG_INFO, "Research window: %dx%d / %dx%d, patch size: %dx%d / %dx%d\n",
s->research_size, s->research_size, s->research_size_uv, s->research_size_uv,
s->patch_size, s->patch_size, s->patch_size_uv, s->patch_size_uv);
- ff_nlmeans_init(&s->dsp);
+ ff_nlmeans_init(&s->dsp, s->depth);
+
+ s->chroma_w = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
+ s->chroma_h = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
+ s->nb_planes = av_pix_fmt_count_planes(inlink->format);
+
+ /* Allocate the integral image with extra edges of thickness "e"
+ *
+ * +_+-------------------------------+
+ * |0|0000000000000000000000000000000|
+ * +-x-------------------------------+
+ * |0|\ ^ |
+ * |0| ii | e |
+ * |0| v |
+ * |0| +-----------------------+ |
+ * |0| | | |
+ * |0|<->| | |
+ * |0| e | | |
+ * |0| | | |
+ * |0| +-----------------------+ |
+ * |0| |
+ * |0| |
+ * |0| |
+ * +-+-------------------------------+
+ */
+ s->ii_w = inlink->w + e*2;
+ s->ii_h = inlink->h + e*2;
+
+ // align to 4 the linesize, "+1" is for the space of the left 0-column
+ s->ii_lz_32 = FFALIGN(s->ii_w + 1, 4);
+
+ if (s->depth <= 8) {
+ // "+1" is for the space of the top 0-line
+ s->ii_orig32 = av_mallocz_array(s->ii_h + 1, s->ii_lz_32 * sizeof(*s->ii_orig32));
+ if (!s->ii_orig32)
+ return AVERROR(ENOMEM);
+
+ // skip top 0-line and left 0-column
+ s->ii32 = s->ii_orig32 + s->ii_lz_32 + 1;
+ } else {
+ // "+1" is for the space of the top 0-line
+ s->ii_orig64 = av_mallocz_array(s->ii_h + 1, s->ii_lz_32 * sizeof(*s->ii_orig64));
+ if (!s->ii_orig64)
+ return AVERROR(ENOMEM);
+
+ // skip top 0-line and left 0-column
+ s->ii64 = s->ii_orig64 + s->ii_lz_32 + 1;
+ }
+
+ // allocate weighted average for every pixel
+ s->wa_linesize = inlink->w;
+ s->wa = av_malloc_array(s->wa_linesize, inlink->h * sizeof(*s->wa));
+ if (!s->wa)
+ return AVERROR(ENOMEM);
+
+ switch (s->depth) {
+ case 8: s->nlmeans_plane = nlmeans_plane8; break;
+ case 9: s->nlmeans_plane = nlmeans_plane9; break;
+ case 10: s->nlmeans_plane = nlmeans_plane10; break;
+ case 12: s->nlmeans_plane = nlmeans_plane12; break;
+ case 14: s->nlmeans_plane = nlmeans_plane14; break;
+ case 16: s->nlmeans_plane = nlmeans_plane16; break;
+ }
return 0;
}
@@ -555,7 +260,8 @@ static av_cold void uninit(AVFilterContext *ctx)
{
NLMeansContext *s = ctx->priv;
av_freep(&s->weight_lut);
- av_freep(&s->ii_orig);
+ av_freep(&s->ii_orig32);
+ av_freep(&s->ii_orig64);
av_freep(&s->wa);
}
@@ -581,7 +287,6 @@ AVFilter ff_vf_nlmeans = {
.name = "nlmeans",
.description = NULL_IF_CONFIG_SMALL("Non-local means denoiser."),
.priv_size = sizeof(NLMeansContext),
- .init = init,
.uninit = uninit,
.query_formats = query_formats,
.inputs = nlmeans_inputs,
diff --git a/libavfilter/vf_nlmeans.h b/libavfilter/vf_nlmeans.h
index 0a9aab2928..814b95e10f 100644
--- a/libavfilter/vf_nlmeans.h
+++ b/libavfilter/vf_nlmeans.h
@@ -23,13 +23,60 @@
#include <stdint.h>
typedef struct NLMeansDSPContext {
- void (*compute_safe_ssd_integral_image)(uint32_t *dst, ptrdiff_t dst_linesize_32,
- const uint8_t *s1, ptrdiff_t linesize1,
- const uint8_t *s2, ptrdiff_t linesize2,
- int w, int h);
+ void (*compute_safe_ssd_integral_image32)(uint32_t *dst, ptrdiff_t dst_linesize_32,
+ const uint8_t *s1, ptrdiff_t linesize1,
+ const uint8_t *s2, ptrdiff_t linesize2,
+ int w, int h);
+ void (*compute_safe_ssd_integral_image64)(uint64_t *dst, ptrdiff_t dst_linesize_32,
+ const uint8_t *s1, ptrdiff_t linesize1,
+ const uint8_t *s2, ptrdiff_t linesize2,
+ int w, int h);
} NLMeansDSPContext;
-void ff_nlmeans_init(NLMeansDSPContext *dsp);
-void ff_nlmeans_init_aarch64(NLMeansDSPContext *dsp);
+struct weighted_avg {
+ float total_weight;
+ float sum;
+};
+
+struct thread_data {
+ const uint8_t *src;
+ ptrdiff_t src_linesize;
+ int startx, starty;
+ int endx, endy;
+ const uint32_t *ii_start32;
+ const uint64_t *ii_start64;
+ int p;
+};
+
+typedef struct NLMeansContext {
+ const AVClass *class;
+ int nb_planes;
+ int depth;
+ int chroma_w, chroma_h;
+ double pdiff_scale; // invert of the filtering parameter (sigma*10) squared
+ double sigma; // denoising strength
+ int patch_size, patch_hsize; // patch size and half size
+ int patch_size_uv, patch_hsize_uv; // patch size and half size for chroma planes
+ int research_size, research_hsize; // research size and half size
+ int research_size_uv, research_hsize_uv; // research size and half size for chroma planes
+ uint32_t *ii_orig32; // integral image 32-bit
+ uint32_t *ii32; // integral image 32-bit starting after the 0-line and 0-column
+ uint64_t *ii_orig64; // integral image 64-bit
+ uint64_t *ii64; // integral image 64-bit starting after the 0-line and 0-column
+ int ii_w, ii_h; // width and height of the integral image
+ ptrdiff_t ii_lz_32; // linesize in 32-bit units of the integral image
+ struct weighted_avg *wa; // weighted average of every pixel
+ ptrdiff_t wa_linesize; // linesize for wa in struct size unit
+ float *weight_lut; // lookup table mapping (scaled) patch differences to their associated weights
+ uint32_t max_meaningful_diff; // maximum difference considered (if the patch difference is too high we ignore the pixel)
+ NLMeansDSPContext dsp;
+
+ int (*nlmeans_plane)(AVFilterContext *ctx, int w, int h, int p, int r,
+ uint8_t *dst, ptrdiff_t dst_linesize,
+ const uint8_t *src, ptrdiff_t src_linesize);
+} NLMeansContext;
+
+void ff_nlmeans_init(NLMeansDSPContext *dsp, int depth);
+void ff_nlmeans_init_aarch64(NLMeansDSPContext *dsp, int depth);
#endif /* AVFILTER_NLMEANS_H */
--
2.17.1
More information about the ffmpeg-devel
mailing list