| /* |
| * Copyright (c) 2019 Paul B Mahol |
| * |
| * 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/audio_fifo.h" |
| #include "libavutil/channel_layout.h" |
| #include "libavutil/common.h" |
| #include "libavutil/opt.h" |
| |
| #include "audio.h" |
| #include "avfilter.h" |
| #include "filters.h" |
| #include "internal.h" |
| |
| typedef struct AudioXCorrelateContext { |
| const AVClass *class; |
| |
| int size; |
| int algo; |
| int64_t pts; |
| |
| AVAudioFifo *fifo[2]; |
| AVFrame *cache[2]; |
| AVFrame *mean_sum[2]; |
| AVFrame *num_sum; |
| AVFrame *den_sum[2]; |
| int used; |
| int eof; |
| |
| int (*xcorrelate)(AVFilterContext *ctx, AVFrame *out, int available); |
| } AudioXCorrelateContext; |
| |
| #define MEAN_SUM(suffix, type, zero) \ |
| static type mean_sum_##suffix(const type *in, \ |
| int size) \ |
| { \ |
| type mean_sum = zero; \ |
| \ |
| for (int i = 0; i < size; i++) \ |
| mean_sum += in[i]; \ |
| \ |
| return mean_sum; \ |
| } |
| |
| MEAN_SUM(f, float, 0.f) |
| MEAN_SUM(d, double, 0.0) |
| |
| #define SQUARE_SUM(suffix, type, zero) \ |
| static type square_sum_##suffix(const type *x, \ |
| const type *y, \ |
| int size) \ |
| { \ |
| type square_sum = zero; \ |
| \ |
| for (int i = 0; i < size; i++) \ |
| square_sum += x[i] * y[i]; \ |
| \ |
| return square_sum; \ |
| } |
| |
| SQUARE_SUM(f, float, 0.f) |
| SQUARE_SUM(d, double, 0.0) |
| |
| #define XCORRELATE(suffix, type, zero, small, sqrtfun)\ |
| static type xcorrelate_##suffix(const type *x, \ |
| const type *y, \ |
| type sumx, \ |
| type sumy, int size) \ |
| { \ |
| const type xm = sumx / size, ym = sumy / size; \ |
| type num = zero, den, den0 = zero, den1 = zero; \ |
| \ |
| for (int i = 0; i < size; i++) { \ |
| type xd = x[i] - xm; \ |
| type yd = y[i] - ym; \ |
| \ |
| num += xd * yd; \ |
| den0 += xd * xd; \ |
| den1 += yd * yd; \ |
| } \ |
| \ |
| num /= size; \ |
| den = sqrtfun((den0 * den1) / size / size); \ |
| \ |
| return den <= small ? zero : num / den; \ |
| } |
| |
| XCORRELATE(f, float, 0.f, 1e-6f, sqrtf) |
| XCORRELATE(d, double, 0.0, 1e-9, sqrt) |
| |
| #define XCORRELATE_SLOW(suffix, type) \ |
| static int xcorrelate_slow_##suffix(AVFilterContext *ctx, \ |
| AVFrame *out, int available) \ |
| { \ |
| AudioXCorrelateContext *s = ctx->priv; \ |
| const int size = s->size; \ |
| int used; \ |
| \ |
| for (int ch = 0; ch < out->ch_layout.nb_channels; ch++) { \ |
| const type *x = (const type *)s->cache[0]->extended_data[ch]; \ |
| const type *y = (const type *)s->cache[1]->extended_data[ch]; \ |
| type *sumx = (type *)s->mean_sum[0]->extended_data[ch]; \ |
| type *sumy = (type *)s->mean_sum[1]->extended_data[ch]; \ |
| type *dst = (type *)out->extended_data[ch]; \ |
| \ |
| used = s->used; \ |
| if (!used) { \ |
| sumx[0] = mean_sum_##suffix(x, size); \ |
| sumy[0] = mean_sum_##suffix(y, size); \ |
| used = 1; \ |
| } \ |
| \ |
| for (int n = 0; n < out->nb_samples; n++) { \ |
| const int idx = n + size; \ |
| \ |
| dst[n] = xcorrelate_##suffix(x + n, y + n, \ |
| sumx[0], sumy[0],\ |
| size); \ |
| \ |
| sumx[0] -= x[n]; \ |
| sumx[0] += x[idx]; \ |
| sumy[0] -= y[n]; \ |
| sumy[0] += y[idx]; \ |
| } \ |
| } \ |
| \ |
| return used; \ |
| } |
| |
| XCORRELATE_SLOW(f, float) |
| XCORRELATE_SLOW(d, double) |
| |
| #define clipf(x) (av_clipf(x, -1.f, 1.f)) |
| #define clipd(x) (av_clipd(x, -1.0, 1.0)) |
| |
| #define XCORRELATE_FAST(suffix, type, zero, small, sqrtfun, CLIP) \ |
| static int xcorrelate_fast_##suffix(AVFilterContext *ctx, AVFrame *out, \ |
| int available) \ |
| { \ |
| AudioXCorrelateContext *s = ctx->priv; \ |
| const int size = s->size; \ |
| int used; \ |
| \ |
| for (int ch = 0; ch < out->ch_layout.nb_channels; ch++) { \ |
| const type *x = (const type *)s->cache[0]->extended_data[ch]; \ |
| const type *y = (const type *)s->cache[1]->extended_data[ch]; \ |
| type *num_sum = (type *)s->num_sum->extended_data[ch]; \ |
| type *den_sumx = (type *)s->den_sum[0]->extended_data[ch]; \ |
| type *den_sumy = (type *)s->den_sum[1]->extended_data[ch]; \ |
| type *dst = (type *)out->extended_data[ch]; \ |
| \ |
| used = s->used; \ |
| if (!used) { \ |
| num_sum[0] = square_sum_##suffix(x, y, size); \ |
| den_sumx[0] = square_sum_##suffix(x, x, size); \ |
| den_sumy[0] = square_sum_##suffix(y, y, size); \ |
| used = 1; \ |
| } \ |
| \ |
| for (int n = 0; n < out->nb_samples; n++) { \ |
| const int idx = n + size; \ |
| type num, den; \ |
| \ |
| num = num_sum[0] / size; \ |
| den = sqrtfun((den_sumx[0] * den_sumy[0]) / size / size); \ |
| \ |
| dst[n] = den <= small ? zero : CLIP(num / den); \ |
| \ |
| num_sum[0] -= x[n] * y[n]; \ |
| num_sum[0] += x[idx] * y[idx]; \ |
| den_sumx[0] -= x[n] * x[n]; \ |
| den_sumx[0] += x[idx] * x[idx]; \ |
| den_sumx[0] = FFMAX(den_sumx[0], zero); \ |
| den_sumy[0] -= y[n] * y[n]; \ |
| den_sumy[0] += y[idx] * y[idx]; \ |
| den_sumy[0] = FFMAX(den_sumy[0], zero); \ |
| } \ |
| } \ |
| \ |
| return used; \ |
| } |
| |
| XCORRELATE_FAST(f, float, 0.f, 1e-6f, sqrtf, clipf) |
| XCORRELATE_FAST(d, double, 0.0, 1e-9, sqrt, clipd) |
| |
| #define XCORRELATE_BEST(suffix, type, zero, small, sqrtfun, FMAX, CLIP) \ |
| static int xcorrelate_best_##suffix(AVFilterContext *ctx, AVFrame *out, \ |
| int available) \ |
| { \ |
| AudioXCorrelateContext *s = ctx->priv; \ |
| const int size = s->size; \ |
| int used; \ |
| \ |
| for (int ch = 0; ch < out->ch_layout.nb_channels; ch++) { \ |
| const type *x = (const type *)s->cache[0]->extended_data[ch]; \ |
| const type *y = (const type *)s->cache[1]->extended_data[ch]; \ |
| type *mean_sumx = (type *)s->mean_sum[0]->extended_data[ch]; \ |
| type *mean_sumy = (type *)s->mean_sum[1]->extended_data[ch]; \ |
| type *num_sum = (type *)s->num_sum->extended_data[ch]; \ |
| type *den_sumx = (type *)s->den_sum[0]->extended_data[ch]; \ |
| type *den_sumy = (type *)s->den_sum[1]->extended_data[ch]; \ |
| type *dst = (type *)out->extended_data[ch]; \ |
| \ |
| used = s->used; \ |
| if (!used) { \ |
| num_sum[0] = square_sum_##suffix(x, y, size); \ |
| den_sumx[0] = square_sum_##suffix(x, x, size); \ |
| den_sumy[0] = square_sum_##suffix(y, y, size); \ |
| mean_sumx[0] = mean_sum_##suffix(x, size); \ |
| mean_sumy[0] = mean_sum_##suffix(y, size); \ |
| used = 1; \ |
| } \ |
| \ |
| for (int n = 0; n < out->nb_samples; n++) { \ |
| const int idx = n + size; \ |
| type num, den, xm, ym; \ |
| \ |
| xm = mean_sumx[0] / size; \ |
| ym = mean_sumy[0] / size; \ |
| num = num_sum[0] - size * xm * ym; \ |
| den = sqrtfun(FMAX(den_sumx[0] - size * xm * xm, zero)) * \ |
| sqrtfun(FMAX(den_sumy[0] - size * ym * ym, zero)); \ |
| \ |
| dst[n] = den <= small ? zero : CLIP(num / den); \ |
| \ |
| mean_sumx[0]-= x[n]; \ |
| mean_sumx[0]+= x[idx]; \ |
| mean_sumy[0]-= y[n]; \ |
| mean_sumy[0]+= y[idx]; \ |
| num_sum[0] -= x[n] * y[n]; \ |
| num_sum[0] += x[idx] * y[idx]; \ |
| den_sumx[0] -= x[n] * x[n]; \ |
| den_sumx[0] += x[idx] * x[idx]; \ |
| den_sumx[0] = FMAX(den_sumx[0], zero); \ |
| den_sumy[0] -= y[n] * y[n]; \ |
| den_sumy[0] += y[idx] * y[idx]; \ |
| den_sumy[0] = FMAX(den_sumy[0], zero); \ |
| } \ |
| } \ |
| \ |
| return used; \ |
| } |
| |
| XCORRELATE_BEST(f, float, 0.f, 1e-6f, sqrtf, fmaxf, clipf) |
| XCORRELATE_BEST(d, double, 0.0, 1e-9, sqrt, fmax, clipd) |
| |
| static int activate(AVFilterContext *ctx) |
| { |
| AudioXCorrelateContext *s = ctx->priv; |
| AVFilterLink *outlink = ctx->outputs[0]; |
| AVFrame *frame = NULL; |
| int ret, status; |
| int available; |
| int64_t pts; |
| |
| FF_FILTER_FORWARD_STATUS_BACK_ALL(outlink, ctx); |
| |
| for (int i = 0; i < 2 && !s->eof; i++) { |
| ret = ff_inlink_consume_frame(ctx->inputs[i], &frame); |
| if (ret > 0) { |
| if (s->pts == AV_NOPTS_VALUE) |
| s->pts = frame->pts; |
| ret = av_audio_fifo_write(s->fifo[i], (void **)frame->extended_data, |
| frame->nb_samples); |
| av_frame_free(&frame); |
| if (ret < 0) |
| return ret; |
| } |
| } |
| |
| available = FFMIN(av_audio_fifo_size(s->fifo[0]), av_audio_fifo_size(s->fifo[1])); |
| if (available > s->size) { |
| const int out_samples = available - s->size; |
| AVFrame *out; |
| |
| if (!s->cache[0] || s->cache[0]->nb_samples < available) { |
| av_frame_free(&s->cache[0]); |
| s->cache[0] = ff_get_audio_buffer(outlink, available); |
| if (!s->cache[0]) |
| return AVERROR(ENOMEM); |
| } |
| |
| if (!s->cache[1] || s->cache[1]->nb_samples < available) { |
| av_frame_free(&s->cache[1]); |
| s->cache[1] = ff_get_audio_buffer(outlink, available); |
| if (!s->cache[1]) |
| return AVERROR(ENOMEM); |
| } |
| |
| ret = av_audio_fifo_peek(s->fifo[0], (void **)s->cache[0]->extended_data, available); |
| if (ret < 0) |
| return ret; |
| |
| ret = av_audio_fifo_peek(s->fifo[1], (void **)s->cache[1]->extended_data, available); |
| if (ret < 0) |
| return ret; |
| |
| out = ff_get_audio_buffer(outlink, out_samples); |
| if (!out) |
| return AVERROR(ENOMEM); |
| |
| s->used = s->xcorrelate(ctx, out, available); |
| |
| out->pts = s->pts; |
| s->pts += out_samples; |
| |
| av_audio_fifo_drain(s->fifo[0], out_samples); |
| av_audio_fifo_drain(s->fifo[1], out_samples); |
| |
| return ff_filter_frame(outlink, out); |
| } |
| |
| for (int i = 0; i < 2 && !s->eof; i++) { |
| if (ff_inlink_acknowledge_status(ctx->inputs[i], &status, &pts)) { |
| AVFrame *silence = ff_get_audio_buffer(outlink, s->size); |
| |
| s->eof = 1; |
| if (!silence) |
| return AVERROR(ENOMEM); |
| |
| av_audio_fifo_write(s->fifo[0], (void **)silence->extended_data, |
| silence->nb_samples); |
| |
| av_audio_fifo_write(s->fifo[1], (void **)silence->extended_data, |
| silence->nb_samples); |
| |
| av_frame_free(&silence); |
| } |
| } |
| |
| if (s->eof && |
| (av_audio_fifo_size(s->fifo[0]) <= s->size || |
| av_audio_fifo_size(s->fifo[1]) <= s->size)) { |
| ff_outlink_set_status(outlink, AVERROR_EOF, s->pts); |
| return 0; |
| } |
| |
| if ((av_audio_fifo_size(s->fifo[0]) > s->size && |
| av_audio_fifo_size(s->fifo[1]) > s->size) || s->eof) { |
| ff_filter_set_ready(ctx, 10); |
| return 0; |
| } |
| |
| if (ff_outlink_frame_wanted(outlink) && !s->eof) { |
| for (int i = 0; i < 2; i++) { |
| if (av_audio_fifo_size(s->fifo[i]) > s->size) |
| continue; |
| ff_inlink_request_frame(ctx->inputs[i]); |
| return 0; |
| } |
| } |
| |
| return FFERROR_NOT_READY; |
| } |
| |
| static int config_output(AVFilterLink *outlink) |
| { |
| AVFilterContext *ctx = outlink->src; |
| AudioXCorrelateContext *s = ctx->priv; |
| |
| s->pts = AV_NOPTS_VALUE; |
| |
| s->fifo[0] = av_audio_fifo_alloc(outlink->format, outlink->ch_layout.nb_channels, s->size); |
| s->fifo[1] = av_audio_fifo_alloc(outlink->format, outlink->ch_layout.nb_channels, s->size); |
| if (!s->fifo[0] || !s->fifo[1]) |
| return AVERROR(ENOMEM); |
| |
| s->mean_sum[0] = ff_get_audio_buffer(outlink, 1); |
| s->mean_sum[1] = ff_get_audio_buffer(outlink, 1); |
| s->num_sum = ff_get_audio_buffer(outlink, 1); |
| s->den_sum[0] = ff_get_audio_buffer(outlink, 1); |
| s->den_sum[1] = ff_get_audio_buffer(outlink, 1); |
| if (!s->mean_sum[0] || !s->mean_sum[1] || !s->num_sum || |
| !s->den_sum[0] || !s->den_sum[1]) |
| return AVERROR(ENOMEM); |
| |
| switch (s->algo) { |
| case 0: s->xcorrelate = xcorrelate_slow_f; break; |
| case 1: s->xcorrelate = xcorrelate_fast_f; break; |
| case 2: s->xcorrelate = xcorrelate_best_f; break; |
| } |
| |
| if (outlink->format == AV_SAMPLE_FMT_DBLP) { |
| switch (s->algo) { |
| case 0: s->xcorrelate = xcorrelate_slow_d; break; |
| case 1: s->xcorrelate = xcorrelate_fast_d; break; |
| case 2: s->xcorrelate = xcorrelate_best_d; break; |
| } |
| } |
| |
| return 0; |
| } |
| |
| static av_cold void uninit(AVFilterContext *ctx) |
| { |
| AudioXCorrelateContext *s = ctx->priv; |
| |
| av_audio_fifo_free(s->fifo[0]); |
| av_audio_fifo_free(s->fifo[1]); |
| av_frame_free(&s->cache[0]); |
| av_frame_free(&s->cache[1]); |
| av_frame_free(&s->mean_sum[0]); |
| av_frame_free(&s->mean_sum[1]); |
| av_frame_free(&s->num_sum); |
| av_frame_free(&s->den_sum[0]); |
| av_frame_free(&s->den_sum[1]); |
| } |
| |
| static const AVFilterPad inputs[] = { |
| { |
| .name = "axcorrelate0", |
| .type = AVMEDIA_TYPE_AUDIO, |
| }, |
| { |
| .name = "axcorrelate1", |
| .type = AVMEDIA_TYPE_AUDIO, |
| }, |
| }; |
| |
| static const AVFilterPad outputs[] = { |
| { |
| .name = "default", |
| .type = AVMEDIA_TYPE_AUDIO, |
| .config_props = config_output, |
| }, |
| }; |
| |
| #define AF AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM |
| #define OFFSET(x) offsetof(AudioXCorrelateContext, x) |
| |
| static const AVOption axcorrelate_options[] = { |
| { "size", "set the segment size", OFFSET(size), AV_OPT_TYPE_INT, {.i64=256}, 2, 131072, AF }, |
| { "algo", "set the algorithm", OFFSET(algo), AV_OPT_TYPE_INT, {.i64=2}, 0, 2, AF, .unit = "algo" }, |
| { "slow", "slow algorithm", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, AF, .unit = "algo" }, |
| { "fast", "fast algorithm", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, AF, .unit = "algo" }, |
| { "best", "best algorithm", 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, AF, .unit = "algo" }, |
| { NULL } |
| }; |
| |
| AVFILTER_DEFINE_CLASS(axcorrelate); |
| |
| const AVFilter ff_af_axcorrelate = { |
| .name = "axcorrelate", |
| .description = NULL_IF_CONFIG_SMALL("Cross-correlate two audio streams."), |
| .priv_size = sizeof(AudioXCorrelateContext), |
| .priv_class = &axcorrelate_class, |
| .activate = activate, |
| .uninit = uninit, |
| FILTER_INPUTS(inputs), |
| FILTER_OUTPUTS(outputs), |
| FILTER_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_DBLP), |
| }; |