virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2025-08-10 06:10:52 +02:00
Code Issues Releases Activity

avfilter/af_afir: improve output when IR switching at runtime

Browse Source 
Also improve normalization and add more gtype modes
This commit is contained in:
Paul B Mahol
2022-12-13 11:46:02 +01:00
parent 7af947c0c0
commit 8c75e5fdd3
4 changed files with 253 additions and 161 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
doc/filters.texi
View File

@@ -1631,6 +1631,12 @@ select DC gain, limited application.
@item gn @item gn
select gain to noise approach, this is most popular one. select gain to noise approach, this is most popular one.
@item ac
select AC gain.
@item rms
select RMS gain.
@end table @end table
@item irgain @item irgain

148
libavfilter/af_afir.c
View File

@@ -105,8 +105,9 @@ static void draw_line(AVFrame *out, int x0, int y0, int x1, int y1, uint32_t col
static int fir_channel(AVFilterContext *ctx, AVFrame *out, int ch) static int fir_channel(AVFilterContext *ctx, AVFrame *out, int ch)
{ {
AudioFIRContext *s = ctx->priv; AudioFIRContext *s = ctx->priv;
const int min_part_size = s->min_part_size;
for (int offset = 0; offset < out->nb_samples; offset += s->min_part_size) { for (int offset = 0; offset < out->nb_samples; offset += min_part_size) {
switch (s->format) { switch (s->format) {
case AV_SAMPLE_FMT_FLTP: case AV_SAMPLE_FMT_FLTP:
fir_quantum_float(ctx, out, ch, offset); fir_quantum_float(ctx, out, ch, offset);
@@ -126,9 +127,8 @@ static int fir_channels(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
const int start = (out->ch_layout.nb_channels * jobnr) / nb_jobs; const int start = (out->ch_layout.nb_channels * jobnr) / nb_jobs;
const int end = (out->ch_layout.nb_channels * (jobnr+1)) / nb_jobs; const int end = (out->ch_layout.nb_channels * (jobnr+1)) / nb_jobs;
for (int ch = start; ch < end; ch++) { for (int ch = start; ch < end; ch++)
fir_channel(ctx, out, ch); fir_channel(ctx, out, ch);
}
return 0; return 0;
} }
@@ -143,7 +143,7 @@ static int fir_frame(AudioFIRContext *s, AVFrame *in, AVFilterLink *outlink)
av_frame_free(&in); av_frame_free(&in);
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
out->pts = in->pts; out->pts = s->pts = in->pts;
s->in = in; s->in = in;
ff_filter_execute(ctx, fir_channels, out, NULL, ff_filter_execute(ctx, fir_channels, out, NULL,
@@ -156,7 +156,7 @@ static int fir_frame(AudioFIRContext *s, AVFrame *in, AVFilterLink *outlink)
} }
static int init_segment(AVFilterContext *ctx, AudioFIRSegment *seg, static int init_segment(AVFilterContext *ctx, AudioFIRSegment *seg,
int offset, int nb_partitions, int part_size) int offset, int nb_partitions, int part_size, int index)
{ {
AudioFIRContext *s = ctx->priv; AudioFIRContext *s = ctx->priv;
const size_t cpu_align = av_cpu_max_align(); const size_t cpu_align = av_cpu_max_align();
@@ -165,8 +165,9 @@ static int init_segment(AVFilterContext *ctx, AudioFIRSegment *seg,
int ret; int ret;
seg->tx = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->tx)); seg->tx = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->tx));
seg->ctx = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->ctx));
seg->itx = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->itx)); seg->itx = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->itx));
if (!seg->tx || !seg->itx) if (!seg->tx || !seg->ctx || !seg->itx)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
seg->fft_length = part_size * 2 + 2; seg->fft_length = part_size * 2 + 2;
@@ -177,9 +178,10 @@ static int init_segment(AVFilterContext *ctx, AudioFIRSegment *seg,
seg->input_size = offset + s->min_part_size; seg->input_size = offset + s->min_part_size;
seg->input_offset = offset; seg->input_offset = offset;
seg->loading = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->loading));
seg->part_index = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->part_index)); seg->part_index = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->part_index));
seg->output_offset = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->output_offset)); seg->output_offset = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->output_offset));
if (!seg->part_index || !seg->output_offset) if (!seg->part_index || !seg->output_offset || !seg->loading)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
switch (s->format) { switch (s->format) {
@@ -197,12 +199,12 @@ static int init_segment(AVFilterContext *ctx, AudioFIRSegment *seg,
break; break;
} }
ret = av_tx_init(&seg->ctx, &seg->ctx_fn, tx_type,
0, 2 * part_size, &cscale, 0);
if (ret < 0)
return ret;
for (int ch = 0; ch < ctx->inputs[0]->ch_layout.nb_channels && part_size >= 1; ch++) { for (int ch = 0; ch < ctx->inputs[0]->ch_layout.nb_channels && part_size >= 1; ch++) {
ret = av_tx_init(&seg->ctx[ch], &seg->ctx_fn, tx_type,
0, 2 * part_size, &cscale, 0);
if (ret < 0)
return ret;
ret = av_tx_init(&seg->tx[ch], &seg->tx_fn, tx_type, ret = av_tx_init(&seg->tx[ch], &seg->tx_fn, tx_type,
0, 2 * part_size, &scale, 0); 0, 2 * part_size, &scale, 0);
if (ret < 0) if (ret < 0)
@@ -215,13 +217,17 @@ static int init_segment(AVFilterContext *ctx, AudioFIRSegment *seg,
seg->sumin = ff_get_audio_buffer(ctx->inputs[0], seg->fft_length); seg->sumin = ff_get_audio_buffer(ctx->inputs[0], seg->fft_length);
seg->sumout = ff_get_audio_buffer(ctx->inputs[0], seg->fft_length); seg->sumout = ff_get_audio_buffer(ctx->inputs[0], seg->fft_length);
seg->blockin = ff_get_audio_buffer(ctx->inputs[0], seg->nb_partitions * seg->block_size); seg->blockin = ff_get_audio_buffer(ctx->inputs[0], seg->block_size * seg->nb_partitions);
seg->blockout = ff_get_audio_buffer(ctx->inputs[0], seg->nb_partitions * seg->block_size); seg->blockout = ff_get_audio_buffer(ctx->inputs[0], seg->block_size * seg->nb_partitions);
seg->tempin = ff_get_audio_buffer(ctx->inputs[0], seg->block_size);
seg->tempout = ff_get_audio_buffer(ctx->inputs[0], seg->block_size);
seg->buffer = ff_get_audio_buffer(ctx->inputs[0], seg->part_size); seg->buffer = ff_get_audio_buffer(ctx->inputs[0], seg->part_size);
seg->coeff = ff_get_audio_buffer(ctx->inputs[1 + s->selir], seg->nb_partitions * seg->coeff_size * 2); seg->coeff = ff_get_audio_buffer(ctx->inputs[0], seg->nb_partitions * seg->coeff_size * 2);
seg->input = ff_get_audio_buffer(ctx->inputs[0], seg->input_size); seg->input = ff_get_audio_buffer(ctx->inputs[0], seg->input_size);
seg->output = ff_get_audio_buffer(ctx->inputs[0], seg->part_size); seg->output = ff_get_audio_buffer(ctx->inputs[0], seg->part_size);
if (!seg->buffer || !seg->sumin || !seg->sumout || !seg->blockin || !seg->blockout || !seg->coeff || !seg->input || !seg->output) seg->loaded = ff_get_audio_buffer(ctx->inputs[0], seg->nb_partitions);
if (!seg->buffer || !seg->sumin || !seg->sumout || !seg->blockin || !seg->blockout ||
!seg->coeff || !seg->input || !seg->output || !seg->loaded || !seg->tempin || !seg->tempout)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
return 0; return 0;
@@ -231,25 +237,30 @@ static void uninit_segment(AVFilterContext *ctx, AudioFIRSegment *seg)
{ {
AudioFIRContext *s = ctx->priv; AudioFIRContext *s = ctx->priv;
av_tx_uninit(&seg->ctx); if (seg->ctx) {
for (int ch = 0; ch < s->nb_channels; ch++)
av_tx_uninit(&seg->ctx[ch]);
}
av_freep(&seg->ctx);
if (seg->tx) { if (seg->tx) {
for (int ch = 0; ch < s->nb_channels; ch++) { for (int ch = 0; ch < s->nb_channels; ch++)
av_tx_uninit(&seg->tx[ch]); av_tx_uninit(&seg->tx[ch]);
}
} }
av_freep(&seg->tx); av_freep(&seg->tx);
if (seg->itx) { if (seg->itx) {
for (int ch = 0; ch < s->nb_channels; ch++) { for (int ch = 0; ch < s->nb_channels; ch++)
av_tx_uninit(&seg->itx[ch]); av_tx_uninit(&seg->itx[ch]);
}
} }
av_freep(&seg->itx); av_freep(&seg->itx);
av_freep(&seg->loading);
av_freep(&seg->output_offset); av_freep(&seg->output_offset);
av_freep(&seg->part_index); av_freep(&seg->part_index);
av_frame_free(&seg->tempin);
av_frame_free(&seg->tempout);
av_frame_free(&seg->blockin); av_frame_free(&seg->blockin);
av_frame_free(&seg->blockout); av_frame_free(&seg->blockout);
av_frame_free(&seg->sumin); av_frame_free(&seg->sumin);
@@ -258,38 +269,42 @@ static void uninit_segment(AVFilterContext *ctx, AudioFIRSegment *seg)
av_frame_free(&seg->coeff); av_frame_free(&seg->coeff);
av_frame_free(&seg->input); av_frame_free(&seg->input);
av_frame_free(&seg->output); av_frame_free(&seg->output);
av_frame_free(&seg->loaded);
seg->input_size = 0; seg->input_size = 0;
} }
static int convert_coeffs(AVFilterContext *ctx) static int convert_coeffs(AVFilterContext *ctx, int selir)
{ {
AudioFIRContext *s = ctx->priv; AudioFIRContext *s = ctx->priv;
int ret, i, cur_nb_taps; const int prev_selir = s->prev_selir;
int ret, nb_taps, cur_nb_taps, prev_nb_taps;
if (!s->nb_taps) { if (!s->nb_taps[selir]) {
int part_size, max_part_size; int part_size, max_part_size;
int left, offset = 0; int left, offset = 0;
s->nb_taps = ff_inlink_queued_samples(ctx->inputs[1 + s->selir]); s->nb_taps[selir] = ff_inlink_queued_samples(ctx->inputs[1 + selir]);
if (s->nb_taps <= 0) if (s->nb_taps[selir] <= 0)
return AVERROR(EINVAL); return AVERROR(EINVAL);
if (s->minp > s->maxp) { if (s->minp > s->maxp)
s->maxp = s->minp; s->maxp = s->minp;
}
left = s->nb_taps; if (s->nb_segments)
goto skip;
left = s->nb_taps[selir];
part_size = 1 << av_log2(s->minp); part_size = 1 << av_log2(s->minp);
max_part_size = 1 << av_log2(s->maxp); max_part_size = 1 << av_log2(s->maxp);
s->min_part_size = part_size; s->min_part_size = part_size;
for (i = 0; left > 0; i++) { for (int i = 0; left > 0; i++) {
int step = part_size == max_part_size ? INT_MAX : 1 + (i == 0); int step = part_size == max_part_size ? INT_MAX : 1 + (i == 0);
int nb_partitions = FFMIN(step, (left + part_size - 1) / part_size); int nb_partitions = FFMIN(step, (left + part_size - 1) / part_size);
s->nb_segments = i + 1; s->nb_segments = i + 1;
ret = init_segment(ctx, &s->seg[i], offset, nb_partitions, part_size); ret = init_segment(ctx, &s->seg[i], offset, nb_partitions, part_size, i);
if (ret < 0) if (ret < 0)
return ret; return ret;
offset += nb_partitions * part_size; offset += nb_partitions * part_size;
@@ -299,8 +314,9 @@ static int convert_coeffs(AVFilterContext *ctx)
} }
} }
if (!s->ir[s->selir]) { skip:
ret = ff_inlink_consume_samples(ctx->inputs[1 + s->selir], s->nb_taps, s->nb_taps, &s->ir[s->selir]); if (!s->ir[selir]) {
ret = ff_inlink_consume_samples(ctx->inputs[1 + selir], s->nb_taps[selir], s->nb_taps[selir], &s->ir[selir]);
if (ret < 0) if (ret < 0)
return ret; return ret;
if (ret == 0) if (ret == 0)
@@ -318,34 +334,21 @@ static int convert_coeffs(AVFilterContext *ctx)
} }
} }
s->gain = 1; cur_nb_taps = s->ir[selir]->nb_samples;
cur_nb_taps = s->ir[s->selir]->nb_samples; prev_nb_taps = s->ir[prev_selir]->nb_samples;
nb_taps = FFMAX(cur_nb_taps, prev_nb_taps);
switch (s->format) { if (!s->norm_ir || s->norm_ir->nb_samples < nb_taps) {
case AV_SAMPLE_FMT_FLTP: av_frame_free(&s->norm_ir);
ret = get_power_float(ctx, s, cur_nb_taps); s->norm_ir = ff_get_audio_buffer(ctx->inputs[0], FFALIGN(nb_taps, 8));
break; if (!s->norm_ir)
case AV_SAMPLE_FMT_DBLP: return AVERROR(ENOMEM);
ret = get_power_double(ctx, s, cur_nb_taps);
break;
} }
if (ret < 0)
return ret;
av_log(ctx, AV_LOG_DEBUG, "nb_taps: %d\n", cur_nb_taps); av_log(ctx, AV_LOG_DEBUG, "nb_taps: %d\n", cur_nb_taps);
av_log(ctx, AV_LOG_DEBUG, "nb_segments: %d\n", s->nb_segments); av_log(ctx, AV_LOG_DEBUG, "nb_segments: %d\n", s->nb_segments);
switch (s->format) { s->have_coeffs[selir] = 1;
case AV_SAMPLE_FMT_FLTP:
convert_channels_float(ctx, s);
break;
case AV_SAMPLE_FMT_DBLP:
convert_channels_double(ctx, s);
break;
}
s->have_coeffs = 1;
return 0; return 0;
} }
@@ -394,8 +397,8 @@ static int activate(AVFilterContext *ctx)
} }
} }
if (!s->have_coeffs && s->eof_coeffs[s->selir]) { if (!s->have_coeffs[s->selir] && s->eof_coeffs[s->selir]) {
ret = convert_coeffs(ctx); ret = convert_coeffs(ctx, s->selir);
if (ret < 0) if (ret < 0)
return ret; return ret;
} }
@@ -409,7 +412,7 @@ static int activate(AVFilterContext *ctx)
if (ret < 0) if (ret < 0)
return ret; return ret;
if (s->response && s->have_coeffs) { if (s->response && s->have_coeffs[s->selir]) {
int64_t old_pts = s->video->pts; int64_t old_pts = s->video->pts;
int64_t new_pts = av_rescale_q(s->pts, ctx->inputs[0]->time_base, ctx->outputs[1]->time_base); int64_t new_pts = av_rescale_q(s->pts, ctx->inputs[0]->time_base, ctx->outputs[1]->time_base);
@@ -520,9 +523,8 @@ FF_ENABLE_DEPRECATION_WARNINGS
return ret; return ret;
outlink->ch_layout.nb_channels = ctx->inputs[0]->ch_layout.nb_channels; outlink->ch_layout.nb_channels = ctx->inputs[0]->ch_layout.nb_channels;
s->nb_channels = outlink->ch_layout.nb_channels;
s->nb_coef_channels = ctx->inputs[1 + s->selir]->ch_layout.nb_channels;
s->format = outlink->format; s->format = outlink->format;
s->nb_channels = outlink->ch_layout.nb_channels;
return 0; return 0;
} }
@@ -531,15 +533,14 @@ static av_cold void uninit(AVFilterContext *ctx)
{ {
AudioFIRContext *s = ctx->priv; AudioFIRContext *s = ctx->priv;
for (int i = 0; i < s->nb_segments; i++) { for (int i = 0; i < s->nb_segments; i++)
uninit_segment(ctx, &s->seg[i]); uninit_segment(ctx, &s->seg[i]);
}
av_freep(&s->fdsp); av_freep(&s->fdsp);
for (int i = 0; i < s->nb_irs; i++) { av_frame_free(&s->norm_ir);
for (int i = 0; i < s->nb_irs; i++)
av_frame_free(&s->ir[i]); av_frame_free(&s->ir[i]);
}
av_frame_free(&s->video); av_frame_free(&s->video);
} }
@@ -569,6 +570,8 @@ static av_cold int init(AVFilterContext *ctx)
AVFilterPad pad, vpad; AVFilterPad pad, vpad;
int ret; int ret;
s->prev_selir = FFMIN(s->nb_irs - 1, s->selir);
pad = (AVFilterPad) { pad = (AVFilterPad) {
.name = "main", .name = "main",
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
@@ -631,16 +634,21 @@ static int process_command(AVFilterContext *ctx,
int flags) int flags)
{ {
AudioFIRContext *s = ctx->priv; AudioFIRContext *s = ctx->priv;
int prev_ir = s->selir; int ret;
int ret = ff_filter_process_command(ctx, cmd, arg, res, res_len, flags);
s->prev_selir = s->selir;
ret = ff_filter_process_command(ctx, cmd, arg, res, res_len, flags);
if (ret < 0) if (ret < 0)
return ret; return ret;
s->selir = FFMIN(s->nb_irs - 1, s->selir); s->selir = FFMIN(s->nb_irs - 1, s->selir);
if (s->selir != s->prev_selir) {
for (int n = 0; n < s->nb_segments; n++) {
AudioFIRSegment *seg = &s->seg[n];
if (prev_ir != s->selir) { for (int ch = 0; ch < s->nb_channels; ch++)
s->have_coeffs = 0; seg->loading[ch] = 0;
}
} }
return 0; return 0;
@@ -655,11 +663,13 @@ static const AVOption afir_options[] = {
{ "dry", "set dry gain", OFFSET(dry_gain), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 10, AF }, { "dry", "set dry gain", OFFSET(dry_gain), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 10, AF },
{ "wet", "set wet gain", OFFSET(wet_gain), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 10, AF }, { "wet", "set wet gain", OFFSET(wet_gain), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 10, AF },
{ "length", "set IR length", OFFSET(length), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 1, AF }, { "length", "set IR length", OFFSET(length), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 1, AF },
{ "gtype", "set IR auto gain type",OFFSET(gtype), AV_OPT_TYPE_INT, {.i64=0}, -1, 2, AF, "gtype" }, { "gtype", "set IR auto gain type",OFFSET(gtype), AV_OPT_TYPE_INT, {.i64=0}, -1, 4, AF, "gtype" },
{ "none", "without auto gain", 0, AV_OPT_TYPE_CONST, {.i64=-1}, 0, 0, AF, "gtype" }, { "none", "without auto gain", 0, AV_OPT_TYPE_CONST, {.i64=-1}, 0, 0, AF, "gtype" },
{ "peak", "peak gain", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, AF, "gtype" }, { "peak", "peak gain", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, AF, "gtype" },
{ "dc", "DC gain", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, AF, "gtype" }, { "dc", "DC gain", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, AF, "gtype" },
{ "gn", "gain to noise", 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, AF, "gtype" }, { "gn", "gain to noise", 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, AF, "gtype" },
{ "ac", "AC gain", 0, AV_OPT_TYPE_CONST, {.i64=3}, 0, 0, AF, "gtype" },
{ "rms", "RMS gain", 0, AV_OPT_TYPE_CONST, {.i64=4}, 0, 0, AF, "gtype" },
{ "irgain", "set IR gain", OFFSET(ir_gain), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 1, AF }, { "irgain", "set IR gain", OFFSET(ir_gain), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 1, AF },
{ "irfmt", "set IR format", OFFSET(ir_format), AV_OPT_TYPE_INT, {.i64=1}, 0, 1, AF, "irfmt" }, { "irfmt", "set IR format", OFFSET(ir_format), AV_OPT_TYPE_INT, {.i64=1}, 0, 1, AF, "irfmt" },
{ "mono", "single channel", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, AF, "irfmt" }, { "mono", "single channel", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, AF, "irfmt" },

22
libavfilter/af_afir.h
View File

@@ -37,6 +37,8 @@ typedef struct AudioFIRSegment {
int input_size; int input_size;
int input_offset; int input_offset;
int *selir;
int *loading;
int *output_offset; int *output_offset;
int *part_index; int *part_index;
@@ -44,15 +46,20 @@ typedef struct AudioFIRSegment {
AVFrame *sumout; AVFrame *sumout;
AVFrame *blockin; AVFrame *blockin;
AVFrame *blockout; AVFrame *blockout;
AVFrame *tempin;
AVFrame *tempout;
AVFrame *buffer; AVFrame *buffer;
AVFrame *coeff; AVFrame *coeff;
AVFrame *input; AVFrame *input;
AVFrame *output; AVFrame *output;
AVFrame *loaded;
AVTXContext *ctx, **tx, **itx; AVTXContext **ctx, **tx, **itx;
av_tx_fn ctx_fn, tx_fn, itx_fn; av_tx_fn ctx_fn, tx_fn, itx_fn;
} AudioFIRSegment; } AudioFIRSegment;
#define MAX_IR_STREAMS 32
typedef struct AudioFIRContext { typedef struct AudioFIRContext {
const AVClass *class; const AVClass *class;
@@ -70,24 +77,23 @@ typedef struct AudioFIRContext {
int minp; int minp;
int maxp; int maxp;
int nb_irs; int nb_irs;
int prev_selir;
int selir; int selir;
int precision; int precision;
int format; int format;
double gain; int eof_coeffs[MAX_IR_STREAMS];
int have_coeffs[MAX_IR_STREAMS];
int eof_coeffs[32]; int nb_taps[MAX_IR_STREAMS];
int have_coeffs;
int nb_taps;
int nb_channels; int nb_channels;
int nb_coef_channels;
int one2many; int one2many;
AudioFIRSegment seg[1024]; AudioFIRSegment seg[1024];
int nb_segments; int nb_segments;
AVFrame *in; AVFrame *in;
AVFrame *ir[32]; AVFrame *ir[MAX_IR_STREAMS];
AVFrame *norm_ir;
AVFrame *video; AVFrame *video;
int min_part_size; int min_part_size;
int64_t pts; int64_t pts;

238
libavfilter/afir_template.c
View File

@@ -18,6 +18,7 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
#include "libavutil/tx.h"
#include "avfilter.h" #include "avfilter.h"
#include "formats.h" #include "formats.h"
#include "internal.h" #include "internal.h"
@@ -26,17 +27,23 @@
#undef ctype #undef ctype
#undef ftype #undef ftype
#undef SQRT #undef SQRT
#undef HYPOT
#undef SAMPLE_FORMAT #undef SAMPLE_FORMAT
#undef TX_TYPE
#if DEPTH == 32 #if DEPTH == 32
#define SAMPLE_FORMAT float #define SAMPLE_FORMAT float
#define SQRT sqrtf #define SQRT sqrtf
#define HYPOT hypotf
#define ctype AVComplexFloat #define ctype AVComplexFloat
#define ftype float #define ftype float
#define TX_TYPE AV_TX_FLOAT_RDFT
#else #else
#define SAMPLE_FORMAT double #define SAMPLE_FORMAT double
#define SQRT sqrt #define SQRT sqrt
#define HYPOT hypot
#define ctype AVComplexDouble #define ctype AVComplexDouble
#define ftype double #define ftype double
#define TX_TYPE AV_TX_DOUBLE_RDFT
#endif #endif
#define fn3(a,b) a##_##b #define fn3(a,b) a##_##b
@@ -66,7 +73,7 @@ static void fn(draw_response)(AVFilterContext *ctx, AVFrame *out)
double w = i * M_PI / (s->w - 1); double w = i * M_PI / (s->w - 1);
double div, real_num = 0., imag_num = 0., real = 0., imag = 0.; double div, real_num = 0., imag_num = 0., real = 0., imag = 0.;
for (x = 0; x < s->nb_taps; x++) { for (x = 0; x < s->nb_taps[s->selir]; x++) {
real += cos(-x * w) * src[x]; real += cos(-x * w) * src[x];
imag += sin(-x * w) * src[x]; imag += sin(-x * w) * src[x];
real_num += cos(-x * w) * src[x] * x; real_num += cos(-x * w) * src[x] * x;
@@ -132,111 +139,162 @@ end:
av_free(mag); av_free(mag);
} }
static void fn(convert_channels)(AVFilterContext *ctx, AudioFIRContext *s) static int fn(get_power)(AVFilterContext *ctx, AudioFIRContext *s,
int cur_nb_taps, int ch)
{ {
for (int ch = 0; ch < ctx->inputs[1 + s->selir]->ch_layout.nb_channels; ch++) { ftype ch_gain = 1;
ftype *time = (ftype *)s->ir[s->selir]->extended_data[!s->one2many * ch];
int toffset = 0;
for (int i = FFMAX(1, s->length * s->nb_taps); i < s->nb_taps; i++)
time[i] = 0;
av_log(ctx, AV_LOG_DEBUG, "channel: %d\n", ch);
for (int segment = 0; segment < s->nb_segments; segment++) {
AudioFIRSegment *seg = &s->seg[segment];
ftype *blockin = (ftype *)seg->blockin->extended_data[ch];
ftype *blockout = (ftype *)seg->blockout->extended_data[ch];
ctype *coeff = (ctype *)seg->coeff->extended_data[ch];
av_log(ctx, AV_LOG_DEBUG, "segment: %d\n", segment);
for (int i = 0; i < seg->nb_partitions; i++) {
const int coffset = i * seg->coeff_size;
const int remaining = s->nb_taps - toffset;
const int size = remaining >= seg->part_size ? seg->part_size : remaining;
memset(blockin, 0, sizeof(*blockin) * seg->fft_length);
memcpy(blockin, time + toffset, size * sizeof(*blockin));
seg->ctx_fn(seg->ctx, blockout, blockin, sizeof(ftype));
for (int n = 0; n < seg->part_size + 1; n++) {
coeff[coffset + n].re = blockout[2 * n];
coeff[coffset + n].im = blockout[2 * n + 1];
}
toffset += size;
}
av_log(ctx, AV_LOG_DEBUG, "nb_partitions: %d\n", seg->nb_partitions);
av_log(ctx, AV_LOG_DEBUG, "partition size: %d\n", seg->part_size);
av_log(ctx, AV_LOG_DEBUG, "block size: %d\n", seg->block_size);
av_log(ctx, AV_LOG_DEBUG, "fft_length: %d\n", seg->fft_length);
av_log(ctx, AV_LOG_DEBUG, "coeff_size: %d\n", seg->coeff_size);
av_log(ctx, AV_LOG_DEBUG, "input_size: %d\n", seg->input_size);
av_log(ctx, AV_LOG_DEBUG, "input_offset: %d\n", seg->input_offset);
}
}
}
static int fn(get_power)(AVFilterContext *ctx, AudioFIRContext *s, int cur_nb_taps)
{
ftype power = 0;
int ch;
switch (s->gtype) { switch (s->gtype) {
case -1: case -1:
/* nothing to do */ ch_gain = 1;
break; break;
case 0: case 0:
for (ch = 0; ch < ctx->inputs[1 + s->selir]->ch_layout.nb_channels; ch++) { {
ftype *time = (ftype *)s->ir[s->selir]->extended_data[!s->one2many * ch]; ftype *time = (ftype *)s->norm_ir->extended_data[ch];
ftype sum = 0;
for (int i = 0; i < cur_nb_taps; i++) for (int i = 0; i < cur_nb_taps; i++)
power += FFABS(time[i]); sum += FFABS(time[i]);
ch_gain = 1. / sum;
} }
s->gain = ctx->inputs[1 + s->selir]->ch_layout.nb_channels / power;
break; break;
case 1: case 1:
for (ch = 0; ch < ctx->inputs[1 + s->selir]->ch_layout.nb_channels; ch++) { {
ftype *time = (ftype *)s->ir[s->selir]->extended_data[!s->one2many * ch]; ftype *time = (ftype *)s->norm_ir->extended_data[ch];
ftype sum = 0;
for (int i = 0; i < cur_nb_taps; i++) for (int i = 0; i < cur_nb_taps; i++)
power += time[i]; sum += time[i];
ch_gain = 1. / sum;
} }
s->gain = ctx->inputs[1 + s->selir]->ch_layout.nb_channels / power;
break; break;
case 2: case 2:
for (ch = 0; ch < ctx->inputs[1 + s->selir]->ch_layout.nb_channels; ch++) { {
ftype *time = (ftype *)s->ir[s->selir]->extended_data[!s->one2many * ch]; ftype *time = (ftype *)s->norm_ir->extended_data[ch];
ftype sum = 0;
for (int i = 0; i < cur_nb_taps; i++) for (int i = 0; i < cur_nb_taps; i++)
power += time[i] * time[i]; sum += time[i] * time[i];
ch_gain = 1. / SQRT(sum);
}
break;
case 3:
case 4:
{
ftype *inc, *outc, scale;
AVTXContext *tx;
av_tx_fn tx_fn;
int ret, size;
size = 1 << av_ceil_log2_c(cur_nb_taps);
inc = av_calloc(size + 2, sizeof(SAMPLE_FORMAT));
outc = av_calloc(size + 2, sizeof(SAMPLE_FORMAT));
if (!inc || !outc) {
av_free(outc);
av_free(inc);
break;
}
scale = 1.;
ret = av_tx_init(&tx, &tx_fn, TX_TYPE, 0, size, &scale, 0);
if (ret < 0) {
av_free(outc);
av_free(inc);
break;
}
{
ftype power, *time = (ftype *)s->norm_ir->extended_data[ch];
memcpy(inc, time, cur_nb_taps * sizeof(SAMPLE_FORMAT));
tx_fn(tx, outc, inc, sizeof(SAMPLE_FORMAT));
power = 0;
if (s->gtype == 3) {
for (int i = 0; i < size / 2 + 1; i++)
power = FFMAX(power, HYPOT(outc[i * 2], outc[i * 2 + 1]));
} else {
ftype sum = 0;
for (int i = 0; i < size / 2 + 1; i++)
sum += HYPOT(outc[i * 2], outc[i * 2 + 1]);
power = SQRT(sum / (size / 2 + 1));
}
ch_gain = 1. / power;
}
av_tx_uninit(&tx);
av_free(outc);
av_free(inc);
} }
s->gain = SQRT(ch / power);
break; break;
default: default:
return AVERROR_BUG; return AVERROR_BUG;
} }
s->gain = FFMIN(s->gain * s->ir_gain, 1.); if (ch_gain != 1. || s->ir_gain != 1.) {
ftype *time = (ftype *)s->norm_ir->extended_data[ch];
av_log(ctx, AV_LOG_DEBUG, "power %f, gain %f\n", power, s->gain); ftype gain = ch_gain * s->ir_gain;
for (int ch = 0; ch < ctx->inputs[1 + s->selir]->ch_layout.nb_channels; ch++) {
ftype *time = (ftype *)s->ir[s->selir]->extended_data[!s->one2many * ch];
av_log(ctx, AV_LOG_DEBUG, "ch%d gain %f\n", ch, gain);
#if DEPTH == 32 #if DEPTH == 32
s->fdsp->vector_fmul_scalar(time, time, s->gain, FFALIGN(cur_nb_taps, 4)); s->fdsp->vector_fmul_scalar(time, time, gain, FFALIGN(cur_nb_taps, 4));
#else #else
s->fdsp->vector_dmul_scalar(time, time, s->gain, FFALIGN(cur_nb_taps, 8)); s->fdsp->vector_dmul_scalar(time, time, gain, FFALIGN(cur_nb_taps, 8));
#endif #endif
} }
return 0; return 0;
} }
static void fn(convert_channel)(AVFilterContext *ctx, AudioFIRContext *s, int ch,
AudioFIRSegment *seg)
{
const int coeff_partition = seg->loading[ch];
const int coffset = coeff_partition * seg->coeff_size;
const int selir = s->selir;
const int nb_taps = s->nb_taps[selir];
ftype *tsrc = (ftype *)s->ir[selir]->extended_data[!s->one2many * ch];
ftype *time = (ftype *)s->norm_ir->extended_data[ch];
ftype *tempin = (ftype *)seg->tempin->extended_data[ch];
ftype *tempout = (ftype *)seg->tempout->extended_data[ch];
ctype *coeff = (ctype *)seg->coeff->extended_data[ch];
int *loaded = (int *)seg->loaded->extended_data[ch];
const int remaining = nb_taps - (seg->input_offset + coeff_partition * seg->part_size);
const int size = remaining >= seg->part_size ? seg->part_size : remaining;
if (loaded[coeff_partition] == selir + 1)
return;
loaded[coeff_partition] = selir + 1;
memcpy(time, tsrc, sizeof(*time) * nb_taps);
for (int i = FFMAX(1, s->length * nb_taps); i < nb_taps; i++)
time[i] = 0;
#if DEPTH == 32
get_power_float(ctx, s, nb_taps, ch);
#else
get_power_double(ctx, s, nb_taps, ch);
#endif
av_log(ctx, AV_LOG_DEBUG, "channel: %d\n", ch);
memset(tempin, 0, sizeof(*tempin) * seg->fft_length);
memcpy(tempin, time + seg->input_offset + coeff_partition * seg->part_size,
size * sizeof(*tempin));
seg->ctx_fn(seg->ctx[ch], tempout, tempin, sizeof(*tempin));
memcpy(coeff + coffset, tempout, (seg->part_size + 1) * sizeof(*coeff));
av_log(ctx, AV_LOG_DEBUG, "nb_partitions: %d\n", seg->nb_partitions);
av_log(ctx, AV_LOG_DEBUG, "partition size: %d\n", seg->part_size);
av_log(ctx, AV_LOG_DEBUG, "block size: %d\n", seg->block_size);
av_log(ctx, AV_LOG_DEBUG, "fft_length: %d\n", seg->fft_length);
av_log(ctx, AV_LOG_DEBUG, "coeff_size: %d\n", seg->coeff_size);
av_log(ctx, AV_LOG_DEBUG, "input_size: %d\n", seg->input_size);
av_log(ctx, AV_LOG_DEBUG, "input_offset: %d\n", seg->input_offset);
}
static void fn(fir_fadd)(AudioFIRContext *s, ftype *dst, const ftype *src, int nb_samples) static void fn(fir_fadd)(AudioFIRContext *s, ftype *dst, const ftype *src, int nb_samples)
{ {
if ((nb_samples & 15) == 0 && nb_samples >= 8) { if ((nb_samples & 15) == 0 && nb_samples >= 8) {
@@ -256,11 +314,12 @@ static int fn(fir_quantum)(AVFilterContext *ctx, AVFrame *out, int ch, int offse
AudioFIRContext *s = ctx->priv; AudioFIRContext *s = ctx->priv;
const ftype *in = (const ftype *)s->in->extended_data[ch] + offset; const ftype *in = (const ftype *)s->in->extended_data[ch] + offset;
ftype *blockin, *blockout, *buf, *ptr = (ftype *)out->extended_data[ch] + offset; ftype *blockin, *blockout, *buf, *ptr = (ftype *)out->extended_data[ch] + offset;
const int nb_samples = FFMIN(s->min_part_size, out->nb_samples - offset);
const int min_part_size = s->min_part_size; const int min_part_size = s->min_part_size;
const int nb_samples = FFMIN(min_part_size, out->nb_samples - offset);
const int nb_segments = s->nb_segments;
const float dry_gain = s->dry_gain; const float dry_gain = s->dry_gain;
for (int segment = 0; segment < s->nb_segments; segment++) { for (int segment = 0; segment < nb_segments; segment++) {
AudioFIRSegment *seg = &s->seg[segment]; AudioFIRSegment *seg = &s->seg[segment];
ftype *src = (ftype *)seg->input->extended_data[ch]; ftype *src = (ftype *)seg->input->extended_data[ch];
ftype *dst = (ftype *)seg->output->extended_data[ch]; ftype *dst = (ftype *)seg->output->extended_data[ch];
@@ -272,6 +331,7 @@ static int fn(fir_quantum)(AVFilterContext *ctx, AVFrame *out, int ch, int offse
const int part_size = seg->part_size; const int part_size = seg->part_size;
int j; int j;
seg->part_index[ch] = seg->part_index[ch] % nb_partitions;;
if (min_part_size >= 8) { if (min_part_size >= 8) {
#if DEPTH == 32 #if DEPTH == 32
s->fdsp->vector_fmul_scalar(src + input_offset, in, dry_gain, FFALIGN(nb_samples, 4)); s->fdsp->vector_fmul_scalar(src + input_offset, in, dry_gain, FFALIGN(nb_samples, 4));
@@ -286,7 +346,7 @@ static int fn(fir_quantum)(AVFilterContext *ctx, AVFrame *out, int ch, int offse
} }
output_offset[0] += min_part_size; output_offset[0] += min_part_size;
if (output_offset[0] == part_size) { if (output_offset[0] >= part_size) {
output_offset[0] = 0; output_offset[0] = 0;
} else { } else {
memmove(src, src + min_part_size, (seg->input_size - min_part_size) * sizeof(*src)); memmove(src, src + min_part_size, (seg->input_size - min_part_size) * sizeof(*src));
@@ -300,26 +360,36 @@ static int fn(fir_quantum)(AVFilterContext *ctx, AVFrame *out, int ch, int offse
blockin = (ftype *)seg->blockin->extended_data[ch] + seg->part_index[ch] * seg->block_size; blockin = (ftype *)seg->blockin->extended_data[ch] + seg->part_index[ch] * seg->block_size;
blockout = (ftype *)seg->blockout->extended_data[ch] + seg->part_index[ch] * seg->block_size; blockout = (ftype *)seg->blockout->extended_data[ch] + seg->part_index[ch] * seg->block_size;
memset(blockin + part_size, 0, sizeof(*blockin) * (seg->fft_length - part_size)); memset(blockin + part_size, 0, sizeof(*blockin) * (seg->fft_length - part_size));
memcpy(blockin, src, sizeof(*src) * part_size); memcpy(blockin, src, sizeof(*src) * part_size);
seg->tx_fn(seg->tx[ch], blockout, blockin, sizeof(ftype)); seg->tx_fn(seg->tx[ch], blockout, blockin, sizeof(ftype));
j = seg->part_index[ch]; j = seg->part_index[ch];
if (seg->loading[ch] < nb_partitions) {
#if DEPTH == 32
convert_channel_float(ctx, s, ch, seg);
#else
convert_channel_double(ctx, s, ch, seg);
#endif
seg->loading[ch]++;
}
for (int i = 0; i < nb_partitions; i++) { for (int i = 0; i < nb_partitions; i++) {
const int coffset = j * seg->coeff_size; const int input_partition = i;
const ftype *blockout = (const ftype *)seg->blockout->extended_data[ch] + i * seg->block_size; const int coeff_partition = j;
const ctype *coeff = (const ctype *)seg->coeff->extended_data[ch * !s->one2many] + coffset; const int coffset = coeff_partition * seg->coeff_size;
const ftype *blockout = (const ftype *)seg->blockout->extended_data[ch] + input_partition * seg->block_size;
const ctype *coeff = ((const ctype *)seg->coeff->extended_data[ch]) + coffset;
if (j == 0)
j = nb_partitions;
j--;
#if DEPTH == 32 #if DEPTH == 32
s->afirdsp.fcmul_add(sumin, blockout, (const ftype *)coeff, part_size); s->afirdsp.fcmul_add(sumin, blockout, (const ftype *)coeff, part_size);
#else #else
s->afirdsp.dcmul_add(sumin, blockout, (const ftype *)coeff, part_size); s->afirdsp.dcmul_add(sumin, blockout, (const ftype *)coeff, part_size);
#endif #endif
if (j == 0)
j = nb_partitions;
j--;
} }
seg->itx_fn(seg->itx[ch], sumout, sumin, sizeof(ctype)); seg->itx_fn(seg->itx[ch], sumout, sumin, sizeof(ctype));
@@ -332,7 +402,7 @@ static int fn(fir_quantum)(AVFilterContext *ctx, AVFrame *out, int ch, int offse
buf = (ftype *)seg->buffer->extended_data[ch]; buf = (ftype *)seg->buffer->extended_data[ch];
memcpy(buf, sumout + part_size, part_size * sizeof(*buf)); memcpy(buf, sumout + part_size, part_size * sizeof(*buf));
seg->part_index[ch] = (seg->part_index[ch] + 1) % nb_partitions;; seg->part_index[ch] = (seg->part_index[ch] + 1) % nb_partitions;
memmove(src, src + min_part_size, (seg->input_size - min_part_size) * sizeof(*src)); memmove(src, src + min_part_size, (seg->input_size - min_part_size) * sizeof(*src));