zita_convolver: Use fir_parse_opts() and fir_read_filter().

Also provide zita_convolver_init_with_filter() and make use of
Convproc.impdata_link().

Author: bmc0

README.md

@@ -307,10 +307,14 @@ Example:
 	one filter channel. Missing values are filled with zeros.
 
 	See the `fir` effect description an explanation of the `input_options`.
-* `zita_convolver [min_part_len [max_part_len]] [~/]filter_path`  
+* `zita_convolver [input_options] [min_part_len [max_part_len]] [file:][~/]filter_path|coefs:list[/list...]`  
 	Partitioned 32-bit FFT convolution using the zita-convolver library.
 	Latency is equal to `min_part_len` (64 samples by default).
-	`{min,max}_part_len` must be powers of 2 between 64 and 8192.
+	`{min,max}_part_len` must be powers of 2 between 64 and 8192. Each `list`
+	is a comma-separated list of coefficients for one filter channel. Missing
+	values are filled with zeros.
+
+	See the `fir` effect description an explanation of the `input_options`.
 * `hilbert [-p] taps`  
 	Simple FIR approximation of a Hilbert transform. The number of taps must be
 	odd. Bandwidth is controlled by the number of taps. If `-p` is given, the

dsp.1

@@ -327,10 +327,14 @@ one filter channel. Missing values are filled with zeros.
 .sp 0.5
 See the \fBfir\fR effect description for an explanation of the \fIinput_options\fR.
 .TP
-\fBzita_convolver\fR [\fImin_part_len\fR [\fImax_part_len\fR]] [~/]\fIfilter_path\fR
+\fBzita_convolver\fR [\fIinput_options\fR] [\fImin_part_len\fR [\fImax_part_len\fR]] [file:][~/]\fIfilter_path\fR|coefs:\fIlist\fR[/\fIlist\fR...]
 Partitioned 32-bit FFT convolution using the zita-convolver library.
 Latency is equal to \fImin_part_len\fR (64 samples by default).
-\fI{min,max}_part_len\fR must be powers of 2 between 64 and 8192.
+\fI{min,max}_part_len\fR must be powers of 2 between 64 and 8192. Each \fIlist\fR
+is a comma-separated list of coefficients for one filter channel. Missing
+values are filled with zeros.
+.sp 0.5
+See the \fBfir\fR effect description for an explanation of the \fIinput_options\fR.
 .TP
 \fBhilbert\fR [\fI\-p\fR] \fItaps\fR
 Simple FIR approximation of a Hilbert transform. The number of taps must be

effect.c

@@ -85,7 +85,7 @@ static const struct effect_info effects[] = {
 	{ "fir_p",              "fir_p [input_options] [max_part_len] [file:][~/]filter_path|coefs:list[/list...]", fir_p_effect_init, 0 },
 #endif
 #ifdef HAVE_ZITA_CONVOLVER
-	{ "zita_convolver",     "zita_convolver [min_part_len [max_part_len]] [~/]filter_path", zita_convolver_effect_init, 0 },
+	{ "zita_convolver",     "zita_convolver [input_options] [min_part_len [max_part_len]] [file:][~/]filter_path|coefs:list[/list...]", zita_convolver_effect_init, 0 },
 #endif
 #ifdef HAVE_FFTW3
 	{ "hilbert",            "hilbert [-p] taps",                       hilbert_effect_init,   0 },

zita_convolver.cpp

@@ -25,6 +25,7 @@ extern "C" {
 	#include "util.h"
 	#include "codec.h"
 	#include "sampleconv.h"
+	#include "fir.h"
 }
 
 struct zita_convolver_state {
@@ -149,82 +150,47 @@ static void write_buf_floatp(sample_t *in, float **out, int channels, ssize_t s)
 	}
 }
 
-struct effect * zita_convolver_effect_init(const struct effect_info *ei, const struct stream_info *istream, const char *channel_selector, const char *dir, int argc, const char *const *argv)
+struct effect * zita_convolver_effect_init_with_filter(const struct effect_info *ei, const struct stream_info *istream, const char *channel_selector, sample_t *filter_data, int filter_channels, ssize_t filter_frames, int min_part_len, int max_part_len)
 {
-	int i, k;
-	unsigned int min_part_len = 0, max_part_len = 0;
 	struct effect *e;
 	struct zita_convolver_state *state;
-	struct codec *c_filter;
-	Convproc *cproc;
-	sample_t *buf_interleaved;
-	float **buf_planar;
-	char *endptr, *fp;
 
-	if (argc > 4 || argc < 2) {
-		LOG_FMT(LL_ERROR, "%s: usage: %s", argv[0], ei->usage);
+	const int n_channels = num_bits_set(channel_selector, istream->channels);
+	if (n_channels > MINIMUM(Convproc::MAXINP, Convproc::MAXOUT)) {
+		LOG_FMT(LL_ERROR, "%s: error: number of channels must not exceed %d", ei->name, MINIMUM(Convproc::MAXINP, Convproc::MAXOUT));
 		return NULL;
 	}
-	if (argc > 2) {
-		min_part_len = strtol(argv[1], &endptr, 10);
-		CHECK_ENDPTR(argv[1], endptr, "min_part_len", return NULL);
+	if (filter_channels != 1 && filter_channels != n_channels) {
+		LOG_FMT(LL_ERROR, "%s: error: channel mismatch: channels=%d filter_channels=%d", ei->name, n_channels, filter_channels);
+		return NULL;
 	}
-	if (argc > 3) {
-		max_part_len = strtol(argv[2], &endptr, 10);
-		CHECK_ENDPTR(argv[2], endptr, "max_part_len", return NULL);
+	if (filter_frames < 1) {
+		LOG_FMT(LL_ERROR, "%s: error: filter length must be >= 1", ei->name);
+		return NULL;
 	}
+
 	min_part_len = (min_part_len == 0) ? Convproc::MINPART : min_part_len;
 	max_part_len = (max_part_len == 0) ? Convproc::MAXPART : max_part_len;
 	if (min_part_len < Convproc::MINPART || min_part_len > Convproc::MAXPART || max_part_len < Convproc::MINPART || max_part_len > Convproc::MAXPART) {
-		LOG_FMT(LL_ERROR, "%s: error: partition lengths must be within [%d,%d] or 0 for default", argv[0], Convproc::MINPART, Convproc::MAXPART);
+		LOG_FMT(LL_ERROR, "%s: error: partition lengths must be within [%d,%d] or 0 for default", ei->name, Convproc::MINPART, Convproc::MAXPART);
 		return NULL;
 	}
 	if (max_part_len < min_part_len) {
-		LOG_FMT(LL_ERROR, "%s: warning: max_part_len < min_part_len", argv[0]);
+		LOG_FMT(LL_ERROR, "%s: warning: max_part_len < min_part_len", ei->name);
 		max_part_len = min_part_len;
 	}
 
-	const int n_channels = num_bits_set(channel_selector, istream->channels);
-	if (n_channels > MINIMUM(Convproc::MAXINP, Convproc::MAXOUT)) {
-		LOG_FMT(LL_ERROR, "%s: error: number of channels must not exceed %d", argv[0], MINIMUM(Convproc::MAXINP, Convproc::MAXOUT));
-		return NULL;
-	}
-	fp = construct_full_path(dir, argv[argc - 1]);
-	struct codec_params c_params = CODEC_PARAMS_AUTO(fp, CODEC_MODE_READ);
-	c_filter = init_codec(&c_params);
-	if (c_filter == NULL) {
-		LOG_FMT(LL_ERROR, "%s: error: failed to open filter file: %s", argv[0], fp);
-		free(fp);
-		return NULL;
-	}
-	free(fp);
-	if (c_filter->channels != 1 && c_filter->channels != n_channels) {
-		LOG_FMT(LL_ERROR, "%s: error: channel mismatch: channels=%d filter_channels=%d", argv[0], n_channels, c_filter->channels);
-		destroy_codec(c_filter);
-		return NULL;
-	}
-	if (c_filter->fs != istream->fs) {
-		LOG_FMT(LL_ERROR, "%s: error: sample rate mismatch: fs=%d filter_fs=%d", argv[0], istream->fs, c_filter->fs);
-		destroy_codec(c_filter);
-		return NULL;
-	}
-	if (c_filter->frames < 1) {
-		LOG_FMT(LL_ERROR, "%s: error: filter length must be >= 1", argv[0]);
-		destroy_codec(c_filter);
-		return NULL;
-	}
-	cproc = new Convproc;
+	Convproc *cproc = new Convproc;
 #if ZITA_CONVOLVER_MAJOR_VERSION >= 4
-	if (cproc->configure(n_channels, n_channels, c_filter->frames, min_part_len, min_part_len, max_part_len, 0.0f)) {
+	if (cproc->configure(n_channels, n_channels, filter_frames, min_part_len, min_part_len, max_part_len, 0.0f)) {
 #else
-	if (cproc->configure(n_channels, n_channels, c_filter->frames, min_part_len, min_part_len, max_part_len)) {
+	if (cproc->configure(n_channels, n_channels, filter_frames, min_part_len, min_part_len, max_part_len)) {
 #endif
-		LOG_FMT(LL_ERROR, "%s: error: failed to configure convolution engine", argv[0]);
-		destroy_codec(c_filter);
+		LOG_FMT(LL_ERROR, "%s: error: failed to configure convolution engine", ei->name);
 		delete cproc;
 		return NULL;
 	}
-	LOG_FMT(LL_VERBOSE, "%s: info: filter_frames=%zd min_part_len=%d max_part_len=%d", argv[0], c_filter->frames, min_part_len, max_part_len);
+	LOG_FMT(LL_VERBOSE, "%s: info: filter_frames=%zd min_part_len=%d max_part_len=%d", ei->name, filter_frames, min_part_len, max_part_len);
 
 	e = (struct effect *) calloc(1, sizeof(struct effect));
 	e->name = ei->name;
@@ -240,33 +206,63 @@ struct effect * zita_convolver_effect_init(const struct effect_info *ei, const s
 	e->destroy = zita_convolver_effect_destroy;
 
 	state = (struct zita_convolver_state *) calloc(1, sizeof(struct zita_convolver_state));
-	state->filter_frames = c_filter->frames;
+	state->filter_frames = filter_frames;
 	state->len = min_part_len;
 	state->cproc = cproc;
 	state->output = (sample_t **) calloc(istream->channels, sizeof(sample_t *));
-	for (i = 0; i < istream->channels; ++i)
+	for (int i = 0; i < istream->channels; ++i)
 		state->output[i] = (sample_t *) calloc(state->len, sizeof(sample_t));
 	e->data = (void *) state;
 
-	buf_interleaved = (sample_t *) calloc(c_filter->frames * c_filter->channels, sizeof(sample_t));
-	if (c_filter->read(c_filter, buf_interleaved, c_filter->frames) != c_filter->frames)
-		LOG_FMT(LL_ERROR, "%s: warning: short read", argv[0]);
-	buf_planar = (float **) calloc(c_filter->channels, sizeof(float *));
-	for (i = 0; i < c_filter->channels; ++i)
-		buf_planar[i] = (float *) calloc(c_filter->frames, sizeof(float));
-	write_buf_floatp(buf_interleaved, buf_planar, c_filter->channels, c_filter->frames);
-	free(buf_interleaved);
-	for (i = k = 0; i < istream->channels; ++i) {
+	float **buf_planar = (float **) calloc(filter_channels, sizeof(float *));
+	for (int i = 0; i < filter_channels; ++i)
+		buf_planar[i] = (float *) calloc(filter_frames, sizeof(float));
+	write_buf_floatp(filter_data, buf_planar, filter_channels, filter_frames);
+	for (int i = 0, k = 0; i < istream->channels; ++i) {
 		if (GET_BIT(channel_selector, i)) {
-			cproc->impdata_create(k, k, 1, buf_planar[(c_filter->channels == 1) ? 0 : k], 0, c_filter->frames);
+			if (filter_channels == 1 && k > 0) cproc->impdata_link(0, 0, k, k);
+			else cproc->impdata_create(k, k, 1, buf_planar[k], 0, filter_frames);
 			++k;
 		}
 	}
-	for (i = 0; i < c_filter->channels; ++i)
+	for (int i = 0; i < filter_channels; ++i)
 		free(buf_planar[i]);
 	free(buf_planar);
-	destroy_codec(c_filter);
+
 	cproc->start_process(0, 0);
+	return e;
+}
+
+struct effect * zita_convolver_effect_init(const struct effect_info *ei, const struct stream_info *istream, const char *channel_selector, const char *dir, int argc, const char *const *argv)
+{
+	int filter_channels, min_part_len = 0, max_part_len = 0;
+	ssize_t filter_frames;
+	struct effect *e;
+	sample_t *filter_data;
+	struct codec_params c_params;
+	struct dsp_getopt_state g = DSP_GETOPT_STATE_INITIALIZER;
+	char *endptr;
 
+	int err = fir_parse_opts(ei, istream, &c_params, &g, argc, argv, NULL, NULL);
+	if (err || g.ind < argc-3 || g.ind > argc-1) {
+		LOG_FMT(LL_ERROR, "%s: usage: %s", argv[0], ei->usage);
+		return NULL;
+	}
+	if (g.ind <= argc-2) {
+		min_part_len = strtol(argv[g.ind], &endptr, 10);
+		CHECK_ENDPTR(argv[g.ind], endptr, "min_part_len", return NULL);
+		++g.ind;
+	}
+	if (g.ind <= argc-2) {
+		max_part_len = strtol(argv[g.ind], &endptr, 10);
+		CHECK_ENDPTR(argv[g.ind], endptr, "max_part_len", return NULL);
+		++g.ind;
+	}
+	c_params.path = argv[g.ind];
+	filter_data = fir_read_filter(ei, istream, dir, &c_params, &filter_channels, &filter_frames);
+	if (filter_data == NULL)
+		return NULL;
+	e = zita_convolver_effect_init_with_filter(ei, istream, channel_selector, filter_data, filter_channels, filter_frames, min_part_len, max_part_len);
+	free(filter_data);
 	return e;
 }

zita_convolver.h

@@ -1,7 +1,7 @@
 /*
  * This file is part of dsp.
  *
- * Copyright (c) 2016-2024 Michael Barbour <[email protected]>
+ * Copyright (c) 2016-2025 Michael Barbour <[email protected]>
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -26,6 +26,7 @@ extern "C" {
 #include "dsp.h"
 #include "effect.h"
 
+struct effect * zita_convolver_effect_init_with_filter(const struct effect_info *, const struct stream_info *, const char *, sample_t *, int, ssize_t, int, int);
 struct effect * zita_convolver_effect_init(const struct effect_info *, const struct stream_info *, const char *, const char *, int, const char *const *);
 
 #ifdef __cplusplus