diff options
Diffstat (limited to 'dom/media/webaudio/FFTBlock.h')
| -rw-r--r-- | dom/media/webaudio/FFTBlock.h | 346 |
1 files changed, 346 insertions, 0 deletions
diff --git a/dom/media/webaudio/FFTBlock.h b/dom/media/webaudio/FFTBlock.h new file mode 100644 index 0000000000..406c70b64d --- /dev/null +++ b/dom/media/webaudio/FFTBlock.h @@ -0,0 +1,346 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef FFTBlock_h_ +#define FFTBlock_h_ + +#ifdef BUILD_ARM_NEON +# include <cmath> +# include "mozilla/arm.h" +# include "dl/sp/api/omxSP.h" +#endif + +#include "AlignedTArray.h" +#include "AudioNodeEngine.h" +#if defined(MOZ_LIBAV_FFT) +# include "FFmpegRDFTTypes.h" +# include "FFVPXRuntimeLinker.h" +#else +# include "kiss_fft/kiss_fftr.h" +#endif + +namespace mozilla { + +// This class defines an FFT block, loosely modeled after Blink's FFTFrame +// class to make sharing code with Blink easy. +// Currently it's implemented on top of KissFFT on all platforms. +class FFTBlock final { + union ComplexU { +#if !defined(MOZ_LIBAV_FFT) + kiss_fft_cpx c; +#endif + float f[2]; + struct { + float r; + float i; + }; + }; + + public: + static void MainThreadInit() { +#ifdef MOZ_LIBAV_FFT + FFVPXRuntimeLinker::Init(); + if (!sRDFTFuncs.init) { + FFVPXRuntimeLinker::GetRDFTFuncs(&sRDFTFuncs); + } +#endif + } + + explicit FFTBlock(uint32_t aFFTSize) +#if defined(MOZ_LIBAV_FFT) + : mAvRDFT(nullptr), + mAvIRDFT(nullptr) +#else + : mKissFFT(nullptr), + mKissIFFT(nullptr) +# ifdef BUILD_ARM_NEON + , + mOmxFFT(nullptr), + mOmxIFFT(nullptr) +# endif +#endif + { + MOZ_COUNT_CTOR(FFTBlock); + SetFFTSize(aFFTSize); + } + ~FFTBlock() { + MOZ_COUNT_DTOR(FFTBlock); + Clear(); + } + + // Return a new FFTBlock with frequency components interpolated between + // |block0| and |block1| with |interp| between 0.0 and 1.0. + static FFTBlock* CreateInterpolatedBlock(const FFTBlock& block0, + const FFTBlock& block1, + double interp); + + // Transform FFTSize() points of aData and store the result internally. + void PerformFFT(const float* aData) { + if (!EnsureFFT()) { + return; + } + +#if defined(MOZ_LIBAV_FFT) + PodCopy(mOutputBuffer.Elements()->f, aData, mFFTSize); + sRDFTFuncs.calc(mAvRDFT, mOutputBuffer.Elements()->f); + // Recover packed Nyquist. + mOutputBuffer[mFFTSize / 2].r = mOutputBuffer[0].i; + mOutputBuffer[0].i = 0.0f; +#else +# ifdef BUILD_ARM_NEON + if (mozilla::supports_neon()) { + omxSP_FFTFwd_RToCCS_F32_Sfs(aData, mOutputBuffer.Elements()->f, mOmxFFT); + } else +# endif + { + kiss_fftr(mKissFFT, aData, &(mOutputBuffer.Elements()->c)); + } +#endif + } + // Inverse-transform internal data and store the resulting FFTSize() + // points in aDataOut. + void GetInverse(float* aDataOut) { + GetInverseWithoutScaling(aDataOut); + AudioBufferInPlaceScale(aDataOut, 1.0f / mFFTSize, mFFTSize); + } + + // Inverse-transform internal frequency data and store the resulting + // FFTSize() points in |aDataOut|. If frequency data has not already been + // scaled, then the output will need scaling by 1/FFTSize(). + void GetInverseWithoutScaling(float* aDataOut) { + if (!EnsureIFFT()) { + std::fill_n(aDataOut, mFFTSize, 0.0f); + return; + }; + +#if defined(MOZ_LIBAV_FFT) + { + // Even though this function doesn't scale, the libav forward transform + // gives a value that needs scaling by 2 in order for things to turn out + // similar to how we expect from kissfft/openmax. + AudioBufferCopyWithScale(mOutputBuffer.Elements()->f, 2.0f, aDataOut, + mFFTSize); + aDataOut[1] = 2.0f * mOutputBuffer[mFFTSize / 2].r; // Packed Nyquist + sRDFTFuncs.calc(mAvIRDFT, aDataOut); + } +#else +# ifdef BUILD_ARM_NEON + if (mozilla::supports_neon()) { + omxSP_FFTInv_CCSToR_F32_Sfs_unscaled(mOutputBuffer.Elements()->f, + aDataOut, mOmxIFFT); + } else +# endif + { + kiss_fftri(mKissIFFT, &(mOutputBuffer.Elements()->c), aDataOut); + } +#endif + } + + void Multiply(const FFTBlock& aFrame) { + uint32_t halfSize = mFFTSize / 2; + // DFTs are not packed. + MOZ_ASSERT(mOutputBuffer[0].i == 0); + MOZ_ASSERT(aFrame.mOutputBuffer[0].i == 0); + + BufferComplexMultiply(mOutputBuffer.Elements()->f, + aFrame.mOutputBuffer.Elements()->f, + mOutputBuffer.Elements()->f, halfSize); + mOutputBuffer[halfSize].r *= aFrame.mOutputBuffer[halfSize].r; + // This would have been set to NaN if either real component was NaN. + mOutputBuffer[0].i = 0.0f; + } + + // Perform a forward FFT on |aData|, assuming zeros after dataSize samples, + // and pre-scale the generated internal frequency domain coefficients so + // that GetInverseWithoutScaling() can be used to transform to the time + // domain. This is useful for convolution kernels. + void PadAndMakeScaledDFT(const float* aData, size_t dataSize) { + MOZ_ASSERT(dataSize <= FFTSize()); + AlignedTArray<float> paddedData; + paddedData.SetLength(FFTSize()); + AudioBufferCopyWithScale(aData, 1.0f / FFTSize(), paddedData.Elements(), + dataSize); + PodZero(paddedData.Elements() + dataSize, mFFTSize - dataSize); + PerformFFT(paddedData.Elements()); + } + + void SetFFTSize(uint32_t aSize) { + mFFTSize = aSize; + mOutputBuffer.SetLength(aSize / 2 + 1); + PodZero(mOutputBuffer.Elements(), aSize / 2 + 1); + Clear(); + } + + // Return the average group delay and removes this from the frequency data. + double ExtractAverageGroupDelay(); + + uint32_t FFTSize() const { return mFFTSize; } + float RealData(uint32_t aIndex) const { return mOutputBuffer[aIndex].r; } + float& RealData(uint32_t aIndex) { return mOutputBuffer[aIndex].r; } + float ImagData(uint32_t aIndex) const { return mOutputBuffer[aIndex].i; } + float& ImagData(uint32_t aIndex) { return mOutputBuffer[aIndex].i; } + + size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const { + size_t amount = 0; + +#if defined(MOZ_LIBAV_FFT) + auto ComputedSizeOfContextIfSet = [this](void* aContext) -> size_t { + if (!aContext) { + return 0; + } + // RDFTContext is only forward declared in public headers, but this is + // an estimate based on a value of 231 seen requested from + // _aligned_alloc on Win64. Don't use malloc_usable_size() because the + // context pointer is not necessarily from malloc. + size_t amount = 232; + // Add size of allocations performed in ff_fft_init(). + // The maximum FFT size used is 32768 = 2^15 and so revtab32 is not + // allocated. + MOZ_ASSERT(mFFTSize <= 32768); + amount += mFFTSize * (sizeof(uint16_t) + 2 * sizeof(float)); + + return amount; + }; + + amount += ComputedSizeOfContextIfSet(mAvRDFT); + amount += ComputedSizeOfContextIfSet(mAvIRDFT); +#else +# ifdef BUILD_ARM_NEON + amount += aMallocSizeOf(mOmxFFT); + amount += aMallocSizeOf(mOmxIFFT); +# endif +# ifdef USE_SIMD +# error kiss fft uses malloc only when USE_SIMD is not defined +# endif + amount += aMallocSizeOf(mKissFFT); + amount += aMallocSizeOf(mKissIFFT); +#endif + amount += mOutputBuffer.ShallowSizeOfExcludingThis(aMallocSizeOf); + return amount; + } + + size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const { + return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf); + } + + private: + FFTBlock(const FFTBlock& other) = delete; + void operator=(const FFTBlock& other) = delete; + + bool EnsureFFT() { +#if defined(MOZ_LIBAV_FFT) + if (!mAvRDFT) { + if (!sRDFTFuncs.init) { + return false; + } + + mAvRDFT = sRDFTFuncs.init(log((double)mFFTSize) / M_LN2, DFT_R2C); + } +#else +# ifdef BUILD_ARM_NEON + if (mozilla::supports_neon()) { + if (!mOmxFFT) { + mOmxFFT = createOmxFFT(mFFTSize); + } + } else +# endif + { + if (!mKissFFT) { + mKissFFT = kiss_fftr_alloc(mFFTSize, 0, nullptr, nullptr); + } + } +#endif + return true; + } + + bool EnsureIFFT() { +#if defined(MOZ_LIBAV_FFT) + if (!mAvIRDFT) { + if (!sRDFTFuncs.init) { + return false; + } + + mAvIRDFT = sRDFTFuncs.init(log((double)mFFTSize) / M_LN2, IDFT_C2R); + } +#else +# ifdef BUILD_ARM_NEON + if (mozilla::supports_neon()) { + if (!mOmxIFFT) { + mOmxIFFT = createOmxFFT(mFFTSize); + } + } else +# endif + { + if (!mKissIFFT) { + mKissIFFT = kiss_fftr_alloc(mFFTSize, 1, nullptr, nullptr); + } + } +#endif + return true; + } + +#ifdef BUILD_ARM_NEON + static OMXFFTSpec_R_F32* createOmxFFT(uint32_t aFFTSize) { + MOZ_ASSERT((aFFTSize & (aFFTSize - 1)) == 0); + OMX_INT bufSize; + OMX_INT order = log((double)aFFTSize) / M_LN2; + MOZ_ASSERT(aFFTSize >> order == 1); + OMXResult status = omxSP_FFTGetBufSize_R_F32(order, &bufSize); + if (status == OMX_Sts_NoErr) { + OMXFFTSpec_R_F32* context = + static_cast<OMXFFTSpec_R_F32*>(malloc(bufSize)); + if (omxSP_FFTInit_R_F32(context, order) != OMX_Sts_NoErr) { + return nullptr; + } + return context; + } + return nullptr; + } +#endif + + void Clear() { +#if defined(MOZ_LIBAV_FFT) + if (mAvRDFT) { + sRDFTFuncs.end(mAvRDFT); + mAvRDFT = nullptr; + } + if (mAvIRDFT) { + sRDFTFuncs.end(mAvIRDFT); + mAvIRDFT = nullptr; + } +#else +# ifdef BUILD_ARM_NEON + free(mOmxFFT); + free(mOmxIFFT); + mOmxFFT = mOmxIFFT = nullptr; +# endif + free(mKissFFT); + free(mKissIFFT); + mKissFFT = mKissIFFT = nullptr; +#endif + } + void AddConstantGroupDelay(double sampleFrameDelay); + void InterpolateFrequencyComponents(const FFTBlock& block0, + const FFTBlock& block1, double interp); +#if defined(MOZ_LIBAV_FFT) + static FFmpegRDFTFuncs sRDFTFuncs; + RDFTContext* mAvRDFT; + RDFTContext* mAvIRDFT; +#else + kiss_fftr_cfg mKissFFT; + kiss_fftr_cfg mKissIFFT; +# ifdef BUILD_ARM_NEON + OMXFFTSpec_R_F32* mOmxFFT; + OMXFFTSpec_R_F32* mOmxIFFT; +# endif +#endif + AlignedTArray<ComplexU> mOutputBuffer; + uint32_t mFFTSize; +}; + +} // namespace mozilla + +#endif |