[FFmpeg-cvslog] avfilter/af_arls: add double sample format support
Paul B Mahol
git at videolan.org
Mon Nov 27 21:21:04 EET 2023
ffmpeg | branch: master | Paul B Mahol <onemda at gmail.com> | Mon Nov 27 20:13:31 2023 +0100| [3bca828d397251ea363988842a9df4a75df83135] | committer: Paul B Mahol
avfilter/af_arls: add double sample format support
> http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=3bca828d397251ea363988842a9df4a75df83135
---
doc/filters.texi | 14 ++++
libavfilter/af_arls.c | 158 ++++++++++++++------------------------------
libavfilter/arls_template.c | 158 ++++++++++++++++++++++++++++++++++++++++++++
3 files changed, 222 insertions(+), 108 deletions(-)
diff --git a/doc/filters.texi b/doc/filters.texi
index 83c48fe367..566bb94f97 100644
--- a/doc/filters.texi
+++ b/doc/filters.texi
@@ -3041,6 +3041,20 @@ Pass error signal estimated samples.
Default value is @var{o}.
@end table
+
+ at item precision
+Set which precision to use when processing samples.
+
+ at table @option
+ at item auto
+Auto pick internal sample format depending on other filters.
+
+ at item float
+Always use single-floating point precision sample format.
+
+ at item double
+Always use double-floating point precision sample format.
+ at end table
@end table
@section arnndn
diff --git a/libavfilter/af_arls.c b/libavfilter/af_arls.c
index 4f2eddffc4..85e4f92425 100644
--- a/libavfilter/af_arls.c
+++ b/libavfilter/af_arls.c
@@ -24,6 +24,7 @@
#include "audio.h"
#include "avfilter.h"
+#include "formats.h"
#include "filters.h"
#include "internal.h"
@@ -43,6 +44,7 @@ typedef struct AudioRLSContext {
float lambda;
float delta;
int output_mode;
+ int precision;
int kernel_size;
AVFrame *offset;
@@ -54,6 +56,8 @@ typedef struct AudioRLSContext {
AVFrame *frame[2];
+ int (*filter_channels)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
+
AVFloatDSPContext *fdsp;
} AudioRLSContext;
@@ -71,117 +75,32 @@ static const AVOption arls_options[] = {
{ "o", "output", 0, AV_OPT_TYPE_CONST, {.i64=OUT_MODE}, 0, 0, AT, "mode" },
{ "n", "noise", 0, AV_OPT_TYPE_CONST, {.i64=NOISE_MODE}, 0, 0, AT, "mode" },
{ "e", "error", 0, AV_OPT_TYPE_CONST, {.i64=ERROR_MODE}, 0, 0, AT, "mode" },
+ { "precision", "set processing precision", OFFSET(precision), AV_OPT_TYPE_INT, {.i64=0}, 0, 2, A, "precision" },
+ { "auto", "set auto processing precision", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, A, "precision" },
+ { "float", "set single-floating point processing precision", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, A, "precision" },
+ { "double","set double-floating point processing precision", 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, A, "precision" },
{ NULL }
};
AVFILTER_DEFINE_CLASS(arls);
-static float fir_sample(AudioRLSContext *s, float sample, float *delay,
- float *coeffs, float *tmp, int *offset)
-{
- const int order = s->order;
- float output;
-
- delay[*offset] = sample;
-
- memcpy(tmp, coeffs + order - *offset, order * sizeof(float));
-
- output = s->fdsp->scalarproduct_float(delay, tmp, s->kernel_size);
-
- if (--(*offset) < 0)
- *offset = order - 1;
-
- return output;
-}
-
-static float process_sample(AudioRLSContext *s, float input, float desired, int ch)
+static int query_formats(AVFilterContext *ctx)
{
- float *coeffs = (float *)s->coeffs->extended_data[ch];
- float *delay = (float *)s->delay->extended_data[ch];
- float *gains = (float *)s->gains->extended_data[ch];
- float *tmp = (float *)s->tmp->extended_data[ch];
- float *u = (float *)s->u->extended_data[ch];
- float *p = (float *)s->p->extended_data[ch];
- float *dp = (float *)s->dp->extended_data[ch];
- int *offsetp = (int *)s->offset->extended_data[ch];
- const int kernel_size = s->kernel_size;
- const int order = s->order;
- const float lambda = s->lambda;
- int offset = *offsetp;
- float g = lambda;
- float output, e;
-
- delay[offset + order] = input;
-
- output = fir_sample(s, input, delay, coeffs, tmp, offsetp);
- e = desired - output;
-
- for (int i = 0, pos = offset; i < order; i++, pos++) {
- const int ikernel_size = i * kernel_size;
-
- u[i] = 0.f;
- for (int k = 0, pos = offset; k < order; k++, pos++)
- u[i] += p[ikernel_size + k] * delay[pos];
-
- g += u[i] * delay[pos];
- }
-
- g = 1.f / g;
-
- for (int i = 0; i < order; i++) {
- const int ikernel_size = i * kernel_size;
-
- gains[i] = u[i] * g;
- coeffs[i] = coeffs[order + i] = coeffs[i] + gains[i] * e;
- tmp[i] = 0.f;
- for (int k = 0, pos = offset; k < order; k++, pos++)
- tmp[i] += p[ikernel_size + k] * delay[pos];
- }
-
- for (int i = 0; i < order; i++) {
- const int ikernel_size = i * kernel_size;
-
- for (int k = 0; k < order; k++)
- dp[ikernel_size + k] = gains[i] * tmp[k];
- }
-
- for (int i = 0; i < order; i++) {
- const int ikernel_size = i * kernel_size;
-
- for (int k = 0; k < order; k++)
- p[ikernel_size + k] = (p[ikernel_size + k] - (dp[ikernel_size + k] + dp[kernel_size * k + i]) * 0.5f) * lambda;
- }
+ AudioRLSContext *s = ctx->priv;
+ static const enum AVSampleFormat sample_fmts[3][3] = {
+ { AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_DBLP, AV_SAMPLE_FMT_NONE },
+ { AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE },
+ { AV_SAMPLE_FMT_DBLP, AV_SAMPLE_FMT_NONE },
+ };
+ int ret;
- switch (s->output_mode) {
- case IN_MODE: output = input; break;
- case DESIRED_MODE: output = desired; break;
- case OUT_MODE: output = desired - output; break;
- case NOISE_MODE: output = input - output; break;
- case ERROR_MODE: break;
- }
- return output;
-}
+ if ((ret = ff_set_common_all_channel_counts(ctx)) < 0)
+ return ret;
-static int process_channels(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
-{
- AudioRLSContext *s = ctx->priv;
- AVFrame *out = arg;
- const int start = (out->ch_layout.nb_channels * jobnr) / nb_jobs;
- const int end = (out->ch_layout.nb_channels * (jobnr+1)) / nb_jobs;
-
- for (int c = start; c < end; c++) {
- const float *input = (const float *)s->frame[0]->extended_data[c];
- const float *desired = (const float *)s->frame[1]->extended_data[c];
- float *output = (float *)out->extended_data[c];
-
- for (int n = 0; n < out->nb_samples; n++) {
- output[n] = process_sample(s, input[n], desired[n], c);
- if (ctx->is_disabled)
- output[n] = input[n];
- }
- }
+ if ((ret = ff_set_common_formats_from_list(ctx, sample_fmts[s->precision])) < 0)
+ return ret;
- return 0;
+ return ff_set_common_all_samplerates(ctx);
}
static int activate(AVFilterContext *ctx)
@@ -216,7 +135,7 @@ static int activate(AVFilterContext *ctx)
return AVERROR(ENOMEM);
}
- ff_filter_execute(ctx, process_channels, out, NULL,
+ ff_filter_execute(ctx, s->filter_channels, out, NULL,
FFMIN(ctx->outputs[0]->ch_layout.nb_channels, ff_filter_get_nb_threads(ctx)));
out->pts = s->frame[0]->pts;
@@ -249,6 +168,13 @@ static int activate(AVFilterContext *ctx)
return 0;
}
+#define DEPTH 32
+#include "arls_template.c"
+
+#undef DEPTH
+#define DEPTH 64
+#include "arls_template.c"
+
static int config_output(AVFilterLink *outlink)
{
AVFilterContext *ctx = outlink->src;
@@ -283,11 +209,27 @@ static int config_output(AVFilterLink *outlink)
dst[0] = s->kernel_size - 1;
}
- for (int ch = 0; ch < s->p->ch_layout.nb_channels; ch++) {
- float *dst = (float *)s->p->extended_data[ch];
+ switch (outlink->format) {
+ case AV_SAMPLE_FMT_DBLP:
+ for (int ch = 0; ch < s->p->ch_layout.nb_channels; ch++) {
+ double *dst = (double *)s->p->extended_data[ch];
- for (int i = 0; i < s->kernel_size; i++)
- dst[i * s->kernel_size + i] = s->delta;
+ for (int i = 0; i < s->kernel_size; i++)
+ dst[i * s->kernel_size + i] = s->delta;
+ }
+
+ s->filter_channels = filter_channels_double;
+ break;
+ case AV_SAMPLE_FMT_FLTP:
+ for (int ch = 0; ch < s->p->ch_layout.nb_channels; ch++) {
+ float *dst = (float *)s->p->extended_data[ch];
+
+ for (int i = 0; i < s->kernel_size; i++)
+ dst[i * s->kernel_size + i] = s->delta;
+ }
+
+ s->filter_channels = filter_channels_float;
+ break;
}
return 0;
@@ -348,7 +290,7 @@ const AVFilter ff_af_arls = {
.activate = activate,
FILTER_INPUTS(inputs),
FILTER_OUTPUTS(outputs),
- FILTER_SINGLE_SAMPLEFMT(AV_SAMPLE_FMT_FLTP),
+ FILTER_QUERY_FUNC(query_formats),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |
AVFILTER_FLAG_SLICE_THREADS,
.process_command = ff_filter_process_command,
diff --git a/libavfilter/arls_template.c b/libavfilter/arls_template.c
new file mode 100644
index 0000000000..e5b91d0a85
--- /dev/null
+++ b/libavfilter/arls_template.c
@@ -0,0 +1,158 @@
+/*
+ * 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
+ */
+
+#undef ONE
+#undef ftype
+#undef SAMPLE_FORMAT
+#if DEPTH == 32
+#define SAMPLE_FORMAT float
+#define ftype float
+#define ONE 1.f
+#else
+#define SAMPLE_FORMAT double
+#define ftype double
+#define ONE 1.0
+#endif
+
+#define fn3(a,b) a##_##b
+#define fn2(a,b) fn3(a,b)
+#define fn(a) fn2(a, SAMPLE_FORMAT)
+
+#if DEPTH == 64
+static double scalarproduct_double(const double *v1, const double *v2, int len)
+{
+ double p = 0.0;
+
+ for (int i = 0; i < len; i++)
+ p += v1[i] * v2[i];
+
+ return p;
+}
+#endif
+
+static ftype fn(fir_sample)(AudioRLSContext *s, ftype sample, ftype *delay,
+ ftype *coeffs, ftype *tmp, int *offset)
+{
+ const int order = s->order;
+ ftype output;
+
+ delay[*offset] = sample;
+
+ memcpy(tmp, coeffs + order - *offset, order * sizeof(ftype));
+
+#if DEPTH == 32
+ output = s->fdsp->scalarproduct_float(delay, tmp, s->kernel_size);
+#else
+ output = scalarproduct_double(delay, tmp, s->kernel_size);
+#endif
+
+ if (--(*offset) < 0)
+ *offset = order - 1;
+
+ return output;
+}
+
+static ftype fn(process_sample)(AudioRLSContext *s, ftype input, ftype desired, int ch)
+{
+ ftype *coeffs = (ftype *)s->coeffs->extended_data[ch];
+ ftype *delay = (ftype *)s->delay->extended_data[ch];
+ ftype *gains = (ftype *)s->gains->extended_data[ch];
+ ftype *tmp = (ftype *)s->tmp->extended_data[ch];
+ ftype *u = (ftype *)s->u->extended_data[ch];
+ ftype *p = (ftype *)s->p->extended_data[ch];
+ ftype *dp = (ftype *)s->dp->extended_data[ch];
+ int *offsetp = (int *)s->offset->extended_data[ch];
+ const int kernel_size = s->kernel_size;
+ const int order = s->order;
+ const ftype lambda = s->lambda;
+ int offset = *offsetp;
+ ftype g = lambda;
+ ftype output, e;
+
+ delay[offset + order] = input;
+
+ output = fn(fir_sample)(s, input, delay, coeffs, tmp, offsetp);
+ e = desired - output;
+
+ for (int i = 0, pos = offset; i < order; i++, pos++) {
+ const int ikernel_size = i * kernel_size;
+
+ u[i] = 0.f;
+ for (int k = 0, pos = offset; k < order; k++, pos++)
+ u[i] += p[ikernel_size + k] * delay[pos];
+
+ g += u[i] * delay[pos];
+ }
+
+ g = 1.f / g;
+
+ for (int i = 0; i < order; i++) {
+ const int ikernel_size = i * kernel_size;
+
+ gains[i] = u[i] * g;
+ coeffs[i] = coeffs[order + i] = coeffs[i] + gains[i] * e;
+ tmp[i] = 0.f;
+ for (int k = 0, pos = offset; k < order; k++, pos++)
+ tmp[i] += p[ikernel_size + k] * delay[pos];
+ }
+
+ for (int i = 0; i < order; i++) {
+ const int ikernel_size = i * kernel_size;
+
+ for (int k = 0; k < order; k++)
+ dp[ikernel_size + k] = gains[i] * tmp[k];
+ }
+
+ for (int i = 0; i < order; i++) {
+ const int ikernel_size = i * kernel_size;
+
+ for (int k = 0; k < order; k++)
+ p[ikernel_size + k] = (p[ikernel_size + k] - (dp[ikernel_size + k] + dp[kernel_size * k + i]) * 0.5f) * lambda;
+ }
+
+ switch (s->output_mode) {
+ case IN_MODE: output = input; break;
+ case DESIRED_MODE: output = desired; break;
+ case OUT_MODE: output = desired - output; break;
+ case NOISE_MODE: output = input - output; break;
+ case ERROR_MODE: break;
+ }
+ return output;
+}
+
+static int fn(filter_channels)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
+{
+ AudioRLSContext *s = ctx->priv;
+ AVFrame *out = arg;
+ const int start = (out->ch_layout.nb_channels * jobnr) / nb_jobs;
+ const int end = (out->ch_layout.nb_channels * (jobnr+1)) / nb_jobs;
+
+ for (int c = start; c < end; c++) {
+ const ftype *input = (const ftype *)s->frame[0]->extended_data[c];
+ const ftype *desired = (const ftype *)s->frame[1]->extended_data[c];
+ ftype *output = (ftype *)out->extended_data[c];
+
+ for (int n = 0; n < out->nb_samples; n++) {
+ output[n] = fn(process_sample)(s, input[n], desired[n], c);
+ if (ctx->is_disabled)
+ output[n] = input[n];
+ }
+ }
+
+ return 0;
+}
More information about the ffmpeg-cvslog
mailing list