static av_cold void uninit(AVFilterContext *ctx)
{
AFFTFiltContext *s = ctx->priv;
int i;
av_fft_end(s->fft);
av_fft_end(s->ifft);
for (i = 0; i < s->nb_exprs; i++) {
if (s->fft_data)
av_freep(&s->fft_data[i]);
}
av_freep(&s->fft_data);
for (i = 0; i < s->nb_exprs; i++) {
av_expr_free(s->real[i]);
av_expr_free(s->imag[i]);
}
av_freep(&s->real);
av_freep(&s->imag);
av_frame_free(&s->buffer);
av_freep(&s->window_func_lut);
av_audio_fifo_free(s->fifo);
}
static inline void fft_end(FFTContext *s)
{
#if AVFFT
av_fft_end(s);
#else
ff_fft_end(s);
#endif
}
void fft_delete(const fft_cfg cfg) {
#ifdef KISS_FFT
KISS_FFT_FREE(cfg);
#elif defined(LIBAVCODEC_FFT)
av_fft_end(cfg->context);
free(cfg);
#else
#error FFT engine was not defined
#endif
}
void Equalizer::alloc( bool b )
{
mutex.lock();
if ( !b && ( fftIn || fftOut ) )
{
canFilter = false;
FFT_NBITS = FFT_SIZE = FFT_SIZE_2 = 0;
av_fft_end( fftIn );
av_fft_end( fftOut );
fftIn = NULL;
fftOut = NULL;
av_free( complex );
complex = NULL;
input.clear();
last_samples.clear();
wind_f.clear();
f.clear();
}
else if ( b )
{
if ( !fftIn || !fftOut )
{
FFT_NBITS = sets().getInt( "Equalizer/nbits" );
FFT_SIZE = 1 << FFT_NBITS;
FFT_SIZE_2 = FFT_SIZE / 2;
fftIn = av_fft_init( FFT_NBITS, false );
fftOut = av_fft_init( FFT_NBITS, true );
complex = ( FFTComplex * )av_malloc( FFT_SIZE * sizeof( FFTComplex ) );
input.resize( chn );
last_samples.resize( chn );
wind_f.resize( FFT_SIZE );
for ( int i = 0 ; i < FFT_SIZE ; ++i )
wind_f[ i ] = 0.5f - 0.5f * cos( 2.0f * M_PI * i / ( FFT_SIZE - 1 ) );
}
interpolateFilterCurve();
canFilter = true;
}
mutex.unlock();
}
// destructor
~decoder_impl() {
#ifdef USE_FFTW3
// clean up the FFTW stuff
fftwf_destroy_plan(store);
fftwf_destroy_plan(loadR);
fftwf_destroy_plan(loadL);
fftwf_free(src);
fftwf_free(dftR);
fftwf_free(dftL);
fftwf_free(dst);
fftwf_free(rt);
fftwf_free(lt);
#else
av_fft_end(fftContextForward);
av_fft_end(fftContextReverse);
av_free(src);
av_free(dftR);
av_free(dftL);
av_free(rt);
av_free(lt);
av_free(fftContextForward);
av_free(fftContextReverse);
#endif
}
static av_cold void uninit(AVFilterContext *ctx)
{
ShowFreqsContext *s = ctx->priv;
int i;
av_fft_end(s->fft);
for (i = 0; i < s->nb_channels; i++) {
av_freep(&s->fft_data[i]);
av_freep(&s->avg_data[i]);
}
av_freep(&s->fft_data);
av_freep(&s->avg_data);
av_freep(&s->window_func_lut);
av_audio_fifo_free(s->fifo);
}
static av_cold void uninit(AVFilterContext *ctx)
{
SpectrumSynthContext *s = ctx->priv;
int i;
av_frame_free(&s->magnitude);
av_frame_free(&s->phase);
av_frame_free(&s->buffer);
av_fft_end(s->fft);
if (s->fft_data) {
for (i = 0; i < s->channels; i++)
av_freep(&s->fft_data[i]);
}
av_freep(&s->fft_data);
av_freep(&s->window_func_lut);
}
static int config_output(AVFilterLink *outlink)
{
AVFilterContext *ctx = outlink->src;
AVFilterLink *inlink = ctx->inputs[0];
ShowFreqsContext *s = ctx->priv;
float overlap;
int i;
s->nb_freq = 1 << (s->fft_bits - 1);
s->win_size = s->nb_freq << 1;
av_audio_fifo_free(s->fifo);
av_fft_end(s->fft);
s->fft = av_fft_init(s->fft_bits, 0);
if (!s->fft) {
av_log(ctx, AV_LOG_ERROR, "Unable to create FFT context. "
"The window size might be too high.\n");
return AVERROR(ENOMEM);
}
/* FFT buffers: x2 for each (display) channel buffer.
* Note: we use free and malloc instead of a realloc-like function to
* make sure the buffer is aligned in memory for the FFT functions. */
for (i = 0; i < s->nb_channels; i++) {
av_freep(&s->fft_data[i]);
av_freep(&s->avg_data[i]);
}
av_freep(&s->fft_data);
av_freep(&s->avg_data);
s->nb_channels = inlink->channels;
s->fft_data = av_calloc(s->nb_channels, sizeof(*s->fft_data));
if (!s->fft_data)
return AVERROR(ENOMEM);
s->avg_data = av_calloc(s->nb_channels, sizeof(*s->avg_data));
if (!s->fft_data)
return AVERROR(ENOMEM);
for (i = 0; i < s->nb_channels; i++) {
s->fft_data[i] = av_calloc(s->win_size, sizeof(**s->fft_data));
s->avg_data[i] = av_calloc(s->nb_freq, sizeof(**s->avg_data));
if (!s->fft_data[i] || !s->avg_data[i])
return AVERROR(ENOMEM);
}
/* pre-calc windowing function */
s->window_func_lut = av_realloc_f(s->window_func_lut, s->win_size,
sizeof(*s->window_func_lut));
if (!s->window_func_lut)
return AVERROR(ENOMEM);
ff_generate_window_func(s->window_func_lut, s->win_size, s->win_func, &overlap);
if (s->overlap == 1.)
s->overlap = overlap;
s->skip_samples = (1. - s->overlap) * s->win_size;
if (s->skip_samples < 1) {
av_log(ctx, AV_LOG_ERROR, "overlap %f too big\n", s->overlap);
return AVERROR(EINVAL);
}
for (s->scale = 0, i = 0; i < s->win_size; i++) {
s->scale += s->window_func_lut[i] * s->window_func_lut[i];
}
outlink->frame_rate = av_make_q(inlink->sample_rate, s->win_size * (1.-s->overlap));
outlink->sample_aspect_ratio = (AVRational){1,1};
outlink->w = s->w;
outlink->h = s->h;
s->fifo = av_audio_fifo_alloc(inlink->format, inlink->channels, s->win_size);
if (!s->fifo)
return AVERROR(ENOMEM);
return 0;
}
