Signed-off-by: Paul B Mahol <one...@gmail.com>
---
libavfilter/af_biquads.c | 351 +++++++++++++++++++++++++++++++++++++--
1 file changed, 336 insertions(+), 15 deletions(-)
diff --git a/libavfilter/af_biquads.c b/libavfilter/af_biquads.c
index 5e2d74f8f9..f3ef3660cc 100644
--- a/libavfilter/af_biquads.c
+++ b/libavfilter/af_biquads.c
@@ -94,6 +94,13 @@ enum WidthType {
NB_WTYPE,
};
+enum TransformType {
+ DI,
+ DII,
+ TDII,
+ NB_TTYPE,
+};
+
typedef struct ChanCache {
double i1, i2;
double o1, o2;
@@ -110,6 +117,7 @@ typedef struct BiquadsContext {
int poles;
int csg;
int reverse;
+ int transform_type;
double gain;
double frequency;
@@ -363,6 +371,216 @@ BIQUAD_FILTER_REVERSE(s32, int32_t, INT32_MIN, INT32_MAX,
1)
BIQUAD_FILTER_REVERSE(flt, float, -1., 1., 0)
BIQUAD_FILTER_REVERSE(dbl, double, -1., 1., 0)
+#define BIQUAD_DII_FILTER(name, type, min, max, need_clipping) \
+static void biquad_dii_## name (BiquadsContext *s, \
+ const void *input, void *output, int len, \
+ double *z1, double *z2, \
+ double *unused1, double *unused2, \
+ double b0, double b1, double b2, \
+ double a1, double a2, int *clippings, \
+ int disabled) \
+{ \
+ const type *ibuf = input; \
+ type *obuf = output; \
+ double w1 = *z1; \
+ double w2 = *z2; \
+ double wet = s->mix; \
+ double dry = 1. - wet; \
+ double in, out, w0; \
+ \
+ a1 = -a1; \
+ a2 = -a2; \
+ \
+ for (int i = 0; i < len; i++) { \
+ in = ibuf[i]; \
+ w0 = in + a1 * w1 + a2 * w2; \
+ out = b0 * w0 + b1 * w1 + b2 * w2; \
+ w2 = w1; \
+ w1 = w0; \
+ out = out * wet + in * dry; \
+ if (disabled) { \
+ obuf[i] = in; \
+ } else if (need_clipping && out < min) { \
+ (*clippings)++; \
+ obuf[i] = min; \
+ } else if (need_clipping && out > max) { \
+ (*clippings)++; \
+ obuf[i] = max; \
+ } else { \
+ obuf[i] = out; \
+ } \
+ } \
+ *z1 = w1; \
+ *z2 = w2; \
+}
+
+BIQUAD_DII_FILTER(s16, int16_t, INT16_MIN, INT16_MAX, 1)
+BIQUAD_DII_FILTER(s32, int32_t, INT32_MIN, INT32_MAX, 1)
+BIQUAD_DII_FILTER(flt, float, -1., 1., 0)
+BIQUAD_DII_FILTER(dbl, double, -1., 1., 0)
+
+#define BIQUAD_REVERSE_DII_FILTER(name, type, min, max, need_clipping) \
+static void biquad_reverse_dii_## name (BiquadsContext *s, \
+ const void *input, void *output, void *dst, \
+ int len, \
+ double *z1, double *z2, \
+ double *unused1, double *unused2, \
+ double b0, double b1, double b2, \
+ double a1, double a2, int *clippings) \
+{ \
+ const double *w = s->window_func_lut; \
+ const type *ibuf = input; \
+ type *obuf = output; \
+ type *dbuf = dst; \
+ double w1 = *z1; \
+ double w2 = *z2; \
+ double wet = s->mix; \
+ double dry = 1. - wet; \
+ double in, out, w0; \
+ \
+ a1 = -a1; \
+ a2 = -a2; \
+ \
+ for (int i = 0; i < len; i++) { \
+ int j = len - 1 - i; \
+ in = ibuf[j]; \
+ w0 = in + a1 * w1 + a2 * w2; \
+ out = b0 * w0 + b1 * w1 + b2 * w2; \
+ w2 = w1; \
+ w1 = w0; \
+ out = out * wet + in * dry; \
+ if (need_clipping && out < min) { \
+ (*clippings)++; \
+ obuf[j] = min; \
+ } else if (need_clipping && out > max) { \
+ (*clippings)++; \
+ obuf[j] = max; \
+ } else { \
+ obuf[j] = out; \
+ } \
+ } \
+ *z1 = w1; \
+ *z2 = w2; \
+ \
+ for (int i = 0; i < len; i++) \
+ dbuf[i] += obuf[i] * w[i]; \
+ for (int i = 0; i < s->hop_size; i++) \
+ obuf[i] = dbuf[i]; \
+ memmove(dbuf, dbuf + s->hop_size, \
+ (s->window_size * 2 - s->hop_size) * s->block_align); \
+ memset(dbuf + s->window_size * 2 - s->hop_size, 0, \
+ s->hop_size * s->block_align); \
+}
+
+BIQUAD_REVERSE_DII_FILTER(s16, int16_t, INT16_MIN, INT16_MAX, 1)
+BIQUAD_REVERSE_DII_FILTER(s32, int32_t, INT32_MIN, INT32_MAX, 1)
+BIQUAD_REVERSE_DII_FILTER(flt, float, -1., 1., 0)
+BIQUAD_REVERSE_DII_FILTER(dbl, double, -1., 1., 0)
+
+#define BIQUAD_TDII_FILTER(name, type, min, max, need_clipping) \
+static void biquad_tdii_## name (BiquadsContext *s, \
+ const void *input, void *output, int len, \
+ double *z1, double *z2, \
+ double *unused1, double *unused2, \
+ double b0, double b1, double b2, \
+ double a1, double a2, int *clippings, \
+ int disabled) \
+{ \
+ const type *ibuf = input; \
+ type *obuf = output; \
+ double w1 = *z1; \
+ double w2 = *z2; \
+ double wet = s->mix; \
+ double dry = 1. - wet; \
+ double in, out; \
+ \
+ a1 = -a1; \
+ a2 = -a2; \
+ \
+ for (int i = 0; i < len; i++) { \
+ in = ibuf[i]; \
+ out = b0 * in + w1; \
+ w1 = b1 * in + w2 + a1 * out; \
+ w2 = b2 * in + a2 * out; \
+ out = out * wet + in * dry; \
+ if (disabled) { \
+ obuf[i] = in; \
+ } else if (need_clipping && out < min) { \
+ (*clippings)++; \
+ obuf[i] = min; \
+ } else if (need_clipping && out > max) { \
+ (*clippings)++; \
+ obuf[i] = max; \
+ } else { \
+ obuf[i] = out; \
+ } \
+ } \
+ *z1 = w1; \
+ *z2 = w2; \
+}
+
+BIQUAD_TDII_FILTER(s16, int16_t, INT16_MIN, INT16_MAX, 1)
+BIQUAD_TDII_FILTER(s32, int32_t, INT32_MIN, INT32_MAX, 1)
+BIQUAD_TDII_FILTER(flt, float, -1., 1., 0)
+BIQUAD_TDII_FILTER(dbl, double, -1., 1., 0)
+
+#define BIQUAD_REVERSE_TDII_FILTER(name, type, min, max, need_clipping) \
+static void biquad_reverse_tdii_## name (BiquadsContext *s, \
+ const void *input, void *output, void *dst, \
+ int len, \
+ double *z1, double *z2, \
+ double *unused1, double *unused2, \
+ double b0, double b1, double b2, \
+ double a1, double a2, int *clippings) \
+{ \
+ const double *w = s->window_func_lut; \
+ const type *ibuf = input; \
+ type *obuf = output; \
+ type *dbuf = dst; \
+ double w1 = *z1; \
+ double w2 = *z2; \
+ double wet = s->mix; \
+ double dry = 1. - wet; \
+ double in, out; \
+ \
+ a1 = -a1; \
+ a2 = -a2; \
+ \
+ for (int i = 0; i < len; i++) { \
+ int j = len - 1 - i; \
+ in = ibuf[j]; \
+ out = b0 * in + w1; \
+ w1 = b1 * in + w2 + a1 * out; \
+ w2 = b2 * in + a2 * out; \
+ out = out * wet + in * dry; \
+ if (need_clipping && out < min) { \
+ (*clippings)++; \
+ obuf[j] = min; \
+ } else if (need_clipping && out > max) { \
+ (*clippings)++; \
+ obuf[j] = max; \
+ } else { \
+ obuf[j] = out; \
+ } \
+ } \
+ *z1 = w1; \
+ *z2 = w2; \
+ \
+ for (int i = 0; i < len; i++) \
+ dbuf[i] += obuf[i] * w[i]; \
+ for (int i = 0; i < s->hop_size; i++) \
+ obuf[i] = dbuf[i]; \
+ memmove(dbuf, dbuf + s->hop_size, \
+ (s->window_size * 2 - s->hop_size) * s->block_align); \
+ memset(dbuf + s->window_size * 2 - s->hop_size, 0, \
+ s->hop_size * s->block_align); \
+}
+
+BIQUAD_REVERSE_TDII_FILTER(s16, int16_t, INT16_MIN, INT16_MAX, 1)
+BIQUAD_REVERSE_TDII_FILTER(s32, int32_t, INT32_MIN, INT32_MAX, 1)
+BIQUAD_REVERSE_TDII_FILTER(flt, float, -1., 1., 0)
+BIQUAD_REVERSE_TDII_FILTER(dbl, double, -1., 1., 0)
+
static int config_filter(AVFilterLink *outlink, int reset)
{
AVFilterContext *ctx = outlink->src;
@@ -554,24 +772,72 @@ static int config_filter(AVFilterLink *outlink, int reset)
if (reset)
memset(s->cache, 0, sizeof(ChanCache) * inlink->channels);
- switch (inlink->format) {
- case AV_SAMPLE_FMT_S16P:
- s->filter = biquad_s16;
- s->reverse_filter = biquad_reverse_s16;
- break;
- case AV_SAMPLE_FMT_S32P:
- s->filter = biquad_s32;
- s->reverse_filter = biquad_reverse_s32;
+ switch (s->transform_type) {
+ case DI:
+ switch (inlink->format) {
+ case AV_SAMPLE_FMT_S16P:
+ s->filter = biquad_s16;
+ s->reverse_filter = biquad_reverse_s16;
+ break;
+ case AV_SAMPLE_FMT_S32P:
+ s->filter = biquad_s32;
+ s->reverse_filter = biquad_reverse_s32;
+ break;
+ case AV_SAMPLE_FMT_FLTP:
+ s->filter = biquad_flt;
+ s->reverse_filter = biquad_reverse_flt;
+ break;
+ case AV_SAMPLE_FMT_DBLP:
+ s->filter = biquad_dbl;
+ s->reverse_filter = biquad_reverse_dbl;
+ break;
+ default: av_assert0(0);
+ }
break;
- case AV_SAMPLE_FMT_FLTP:
- s->filter = biquad_flt;
- s->reverse_filter = biquad_reverse_flt;
+ case DII:
+ switch (inlink->format) {
+ case AV_SAMPLE_FMT_S16P:
+ s->filter = biquad_dii_s16;
+ s->reverse_filter = biquad_reverse_dii_s16;
+ break;
+ case AV_SAMPLE_FMT_S32P:
+ s->filter = biquad_dii_s32;
+ s->reverse_filter = biquad_reverse_dii_s32;
+ break;
+ case AV_SAMPLE_FMT_FLTP:
+ s->filter = biquad_dii_flt;
+ s->reverse_filter = biquad_reverse_dii_flt;
+ break;
+ case AV_SAMPLE_FMT_DBLP:
+ s->filter = biquad_dii_dbl;
+ s->reverse_filter = biquad_reverse_dii_dbl;
+ break;
+ default: av_assert0(0);
+ }
break;
- case AV_SAMPLE_FMT_DBLP:
- s->filter = biquad_dbl;
- s->reverse_filter = biquad_reverse_dbl;
+ case TDII:
+ switch (inlink->format) {
+ case AV_SAMPLE_FMT_S16P:
+ s->filter = biquad_tdii_s16;
+ s->reverse_filter = biquad_reverse_tdii_s16;
+ break;
+ case AV_SAMPLE_FMT_S32P:
+ s->filter = biquad_tdii_s32;
+ s->reverse_filter = biquad_reverse_tdii_s32;
+ break;
+ case AV_SAMPLE_FMT_FLTP:
+ s->filter = biquad_tdii_flt;
+ s->reverse_filter = biquad_reverse_tdii_flt;
+ break;
+ case AV_SAMPLE_FMT_DBLP:
+ s->filter = biquad_tdii_dbl;
+ s->reverse_filter = biquad_reverse_tdii_dbl;
+ break;
+ default: av_assert0(0);
+ }
break;
- default: av_assert0(0);
+ default:
+ av_assert0(0);
}
s->block_align = av_get_bytes_per_sample(inlink->format);
@@ -846,6 +1112,11 @@ static const AVOption equalizer_options[] = {
{"c", "set channels to filter", OFFSET(channels),
AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
{"normalize", "normalize coefficients", OFFSET(normalize),
AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
{"n", "normalize coefficients", OFFSET(normalize),
AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
+ {"transform", "set transform type", OFFSET(transform_type),
AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},
+ {"a", "set transform type", OFFSET(transform_type),
AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform"},
+ {"di", "direct form I", 0, AV_OPT_TYPE_CONST, {.i64=DI}, 0, 0, AF,
"transform_type"},
+ {"dii", "direct form II", 0, AV_OPT_TYPE_CONST, {.i64=DII}, 0, 0, AF,
"transform_type"},
+ {"tdii", "transposed direct form II", 0, AV_OPT_TYPE_CONST, {.i64=TDII},
0, 0, AF, "transform_type"},
{"reverse", "reverse filtering", OFFSET(reverse), AV_OPT_TYPE_BOOL,
{.i64=0}, 0, 1, AF},
{"r", "reverse filtering", OFFSET(reverse), AV_OPT_TYPE_BOOL,
{.i64=0}, 0, 1, AF},
{"size", "set window size for reverse filtering", OFFSET(hop_size),
AV_OPT_TYPE_INT, {.i64=2048}, 256, 32768, AF},
@@ -876,6 +1147,11 @@ static const AVOption bass_options[] = {
{"c", "set channels to filter", OFFSET(channels),
AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
{"normalize", "normalize coefficients", OFFSET(normalize),
AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
{"n", "normalize coefficients", OFFSET(normalize),
AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
+ {"transform", "set transform type", OFFSET(transform_type),
AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},
+ {"a", "set transform type", OFFSET(transform_type),
AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},
+ {"di", "direct form I", 0, AV_OPT_TYPE_CONST, {.i64=DI}, 0, 0, AF,
"transform_type"},
+ {"dii", "direct form II", 0, AV_OPT_TYPE_CONST, {.i64=DII}, 0, 0, AF,
"transform_type"},
+ {"tdii", "transposed direct form II", 0, AV_OPT_TYPE_CONST, {.i64=TDII},
0, 0, AF, "transform_type"},
{"reverse", "reverse filtering", OFFSET(reverse), AV_OPT_TYPE_BOOL,
{.i64=0}, 0, 1, AF},
{"r", "reverse filtering", OFFSET(reverse), AV_OPT_TYPE_BOOL,
{.i64=0}, 0, 1, AF},
{"size", "set window size for reverse filtering", OFFSET(hop_size),
AV_OPT_TYPE_INT, {.i64=2048}, 256, 32768, AF},
@@ -906,6 +1182,11 @@ static const AVOption treble_options[] = {
{"c", "set channels to filter", OFFSET(channels),
AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
{"normalize", "normalize coefficients", OFFSET(normalize),
AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
{"n", "normalize coefficients", OFFSET(normalize),
AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
+ {"transform", "set transform type", OFFSET(transform_type),
AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},
+ {"a", "set transform type", OFFSET(transform_type),
AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},
+ {"di", "direct form I", 0, AV_OPT_TYPE_CONST, {.i64=DI}, 0, 0, AF,
"transform_type"},
+ {"dii", "direct form II", 0, AV_OPT_TYPE_CONST, {.i64=DII}, 0, 0, AF,
"transform_type"},
+ {"tdii", "transposed direct form II", 0, AV_OPT_TYPE_CONST, {.i64=TDII},
0, 0, AF, "transform_type"},
{"reverse", "reverse filtering", OFFSET(reverse), AV_OPT_TYPE_BOOL,
{.i64=0}, 0, 1, AF},
{"r", "reverse filtering", OFFSET(reverse), AV_OPT_TYPE_BOOL,
{.i64=0}, 0, 1, AF},
{"size", "set window size for reverse filtering", OFFSET(hop_size),
AV_OPT_TYPE_INT, {.i64=2048}, 256, 32768, AF},
@@ -935,6 +1216,11 @@ static const AVOption bandpass_options[] = {
{"c", "set channels to filter", OFFSET(channels),
AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
{"normalize", "normalize coefficients", OFFSET(normalize),
AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
{"n", "normalize coefficients", OFFSET(normalize),
AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
+ {"transform", "set transform type", OFFSET(transform_type),
AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},
+ {"a", "set transform type", OFFSET(transform_type),
AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},
+ {"di", "direct form I", 0, AV_OPT_TYPE_CONST, {.i64=DI}, 0, 0, AF,
"transform_type"},
+ {"dii", "direct form II", 0, AV_OPT_TYPE_CONST, {.i64=DII}, 0, 0, AF,
"transform_type"},
+ {"tdii", "transposed direct form II", 0, AV_OPT_TYPE_CONST, {.i64=TDII},
0, 0, AF, "transform_type"},
{"reverse", "reverse filtering", OFFSET(reverse), AV_OPT_TYPE_BOOL,
{.i64=0}, 0, 1, AF},
{"r", "reverse filtering", OFFSET(reverse), AV_OPT_TYPE_BOOL,
{.i64=0}, 0, 1, AF},
{"size", "set window size for reverse filtering", OFFSET(hop_size),
AV_OPT_TYPE_INT, {.i64=2048}, 256, 32768, AF},
@@ -963,6 +1249,11 @@ static const AVOption bandreject_options[] = {
{"c", "set channels to filter", OFFSET(channels),
AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
{"normalize", "normalize coefficients", OFFSET(normalize),
AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
{"n", "normalize coefficients", OFFSET(normalize),
AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
+ {"transform", "set transform type", OFFSET(transform_type),
AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},
+ {"a", "set transform type", OFFSET(transform_type),
AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},
+ {"di", "direct form I", 0, AV_OPT_TYPE_CONST, {.i64=DI}, 0, 0, AF,
"transform_type"},
+ {"dii", "direct form II", 0, AV_OPT_TYPE_CONST, {.i64=DII}, 0, 0, AF,
"transform_type"},
+ {"tdii", "transposed direct form II", 0, AV_OPT_TYPE_CONST, {.i64=TDII},
0, 0, AF, "transform_type"},
{"reverse", "reverse filtering", OFFSET(reverse), AV_OPT_TYPE_BOOL,
{.i64=0}, 0, 1, AF},
{"r", "reverse filtering", OFFSET(reverse), AV_OPT_TYPE_BOOL,
{.i64=0}, 0, 1, AF},
{"size", "set window size for reverse filtering", OFFSET(hop_size),
AV_OPT_TYPE_INT, {.i64=2048}, 256, 32768, AF},
@@ -993,6 +1284,11 @@ static const AVOption lowpass_options[] = {
{"c", "set channels to filter", OFFSET(channels),
AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
{"normalize", "normalize coefficients", OFFSET(normalize),
AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
{"n", "normalize coefficients", OFFSET(normalize),
AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
+ {"transform", "set transform type", OFFSET(transform_type),
AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},
+ {"a", "set transform type", OFFSET(transform_type),
AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},
+ {"di", "direct form I", 0, AV_OPT_TYPE_CONST, {.i64=DI}, 0, 0, AF,
"transform_type"},
+ {"dii", "direct form II", 0, AV_OPT_TYPE_CONST, {.i64=DII}, 0, 0, AF,
"transform_type"},
+ {"tdii", "transposed direct form II", 0, AV_OPT_TYPE_CONST, {.i64=TDII},
0, 0, AF, "transform_type"},
{"reverse", "reverse filtering", OFFSET(reverse), AV_OPT_TYPE_BOOL,
{.i64=0}, 0, 1, AF},
{"r", "reverse filtering", OFFSET(reverse), AV_OPT_TYPE_BOOL,
{.i64=0}, 0, 1, AF},
{"size", "set window size for reverse filtering", OFFSET(hop_size),
AV_OPT_TYPE_INT, {.i64=2048}, 256, 32768, AF},
@@ -1023,6 +1319,11 @@ static const AVOption highpass_options[] = {
{"c", "set channels to filter", OFFSET(channels),
AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
{"normalize", "normalize coefficients", OFFSET(normalize),
AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
{"n", "normalize coefficients", OFFSET(normalize),
AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
+ {"transform", "set transform type", OFFSET(transform_type),
AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},
+ {"a", "set transform type", OFFSET(transform_type),
AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},
+ {"di", "direct form I", 0, AV_OPT_TYPE_CONST, {.i64=DI}, 0, 0, AF,
"transform_type"},
+ {"dii", "direct form II", 0, AV_OPT_TYPE_CONST, {.i64=DII}, 0, 0, AF,
"transform_type"},
+ {"tdii", "transposed direct form II", 0, AV_OPT_TYPE_CONST, {.i64=TDII},
0, 0, AF, "transform_type"},
{"reverse", "reverse filtering", OFFSET(reverse), AV_OPT_TYPE_BOOL,
{.i64=0}, 0, 1, AF},
{"r", "reverse filtering", OFFSET(reverse), AV_OPT_TYPE_BOOL,
{.i64=0}, 0, 1, AF},
{"size", "set window size for reverse filtering", OFFSET(hop_size),
AV_OPT_TYPE_INT, {.i64=2048}, 256, 32768, AF},
@@ -1051,6 +1352,11 @@ static const AVOption allpass_options[] = {
{"c", "set channels to filter", OFFSET(channels),
AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
{"normalize", "normalize coefficients", OFFSET(normalize),
AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
{"n", "normalize coefficients", OFFSET(normalize),
AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
+ {"transform", "set transform type", OFFSET(transform_type),
AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},
+ {"a", "set transform type", OFFSET(transform_type),
AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},
+ {"di", "direct form I", 0, AV_OPT_TYPE_CONST, {.i64=DI}, 0, 0, AF,
"transform_type"},
+ {"dii", "direct form II", 0, AV_OPT_TYPE_CONST, {.i64=DII}, 0, 0, AF,
"transform_type"},
+ {"tdii", "transposed direct form II", 0, AV_OPT_TYPE_CONST, {.i64=TDII},
0, 0, AF, "transform_type"},
{"order", "set filter order", OFFSET(order), AV_OPT_TYPE_INT, {.i64=2}, 1,
2, FLAGS},
{"o", "set filter order", OFFSET(order), AV_OPT_TYPE_INT, {.i64=2}, 1,
2, FLAGS},
{NULL}
@@ -1079,6 +1385,11 @@ static const AVOption lowshelf_options[] = {
{"c", "set channels to filter", OFFSET(channels),
AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
{"normalize", "normalize coefficients", OFFSET(normalize),
AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
{"n", "normalize coefficients", OFFSET(normalize),
AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
+ {"transform", "set transform type", OFFSET(transform_type),
AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},
+ {"a", "set transform type", OFFSET(transform_type),
AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},
+ {"di", "direct form I", 0, AV_OPT_TYPE_CONST, {.i64=DI}, 0, 0, AF,
"transform_type"},
+ {"dii", "direct form II", 0, AV_OPT_TYPE_CONST, {.i64=DII}, 0, 0, AF,
"transform_type"},
+ {"tdii", "transposed direct form II", 0, AV_OPT_TYPE_CONST, {.i64=TDII},
0, 0, AF, "transform_type"},
{"reverse", "reverse filtering", OFFSET(reverse), AV_OPT_TYPE_BOOL,
{.i64=0}, 0, 1, AF},
{"r", "reverse filtering", OFFSET(reverse), AV_OPT_TYPE_BOOL,
{.i64=0}, 0, 1, AF},
{"size", "set window size for reverse filtering", OFFSET(hop_size),
AV_OPT_TYPE_INT, {.i64=2048}, 256, 32768, AF},
@@ -1109,6 +1420,11 @@ static const AVOption highshelf_options[] = {
{"c", "set channels to filter", OFFSET(channels),
AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
{"normalize", "normalize coefficients", OFFSET(normalize),
AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
{"n", "normalize coefficients", OFFSET(normalize),
AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
+ {"transform", "set transform type", OFFSET(transform_type),
AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},
+ {"a", "set transform type", OFFSET(transform_type),
AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},
+ {"di", "direct form I", 0, AV_OPT_TYPE_CONST, {.i64=DI}, 0, 0, AF,
"transform_type"},
+ {"dii", "direct form II", 0, AV_OPT_TYPE_CONST, {.i64=DII}, 0, 0, AF,
"transform_type"},
+ {"tdii", "transposed direct form II", 0, AV_OPT_TYPE_CONST, {.i64=TDII},
0, 0, AF, "transform_type"},
{"reverse", "reverse filtering", OFFSET(reverse), AV_OPT_TYPE_BOOL,
{.i64=0}, 0, 1, AF},
{"r", "reverse filtering", OFFSET(reverse), AV_OPT_TYPE_BOOL,
{.i64=0}, 0, 1, AF},
{"size", "set window size for reverse filtering", OFFSET(hop_size),
AV_OPT_TYPE_INT, {.i64=2048}, 256, 32768, AF},
@@ -1132,6 +1448,11 @@ static const AVOption biquad_options[] = {
{"c", "set channels to filter", OFFSET(channels),
AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
{"normalize", "normalize coefficients", OFFSET(normalize),
AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
{"n", "normalize coefficients", OFFSET(normalize),
AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
+ {"transform", "set transform type", OFFSET(transform_type),
AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},
+ {"a", "set transform type", OFFSET(transform_type),
AV_OPT_TYPE_INT, {.i64=0}, 0, NB_TTYPE-1, AF, "transform_type"},
+ {"di", "direct form I", 0, AV_OPT_TYPE_CONST, {.i64=DI}, 0, 0, AF,
"transform_type"},
+ {"dii", "direct form II", 0, AV_OPT_TYPE_CONST, {.i64=DII}, 0, 0, AF,
"transform_type"},
+ {"tdii", "transposed direct form II", 0, AV_OPT_TYPE_CONST, {.i64=TDII},
0, 0, AF, "transform_type"},
{"reverse", "reverse filtering", OFFSET(reverse), AV_OPT_TYPE_BOOL,
{.i64=0}, 0, 1, AF},
{"r", "reverse filtering", OFFSET(reverse), AV_OPT_TYPE_BOOL,
{.i64=0}, 0, 1, AF},
{"size", "set window size for reverse filtering", OFFSET(hop_size),
AV_OPT_TYPE_INT, {.i64=2048}, 256, 32768, AF},
--
2.17.1
_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel
To unsubscribe, visit link above, or email
ffmpeg-devel-requ...@ffmpeg.org with subject "unsubscribe".
