The Tor Browser: comparison content/media/webaudio/FFTBlock.h

--1:000000000000
+:1218598abf95
+/* -*- 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_
+#include "nsTArray.h"
+#include "AudioNodeEngine.h"
+#include "kiss_fft/kiss_fftr.h"
+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 {
+public:
+explicit FFTBlock(uint32_t aFFTSize)
+: mFFT(nullptr)
+, mIFFT(nullptr)
+, mFFTSize(aFFTSize)
+{
+MOZ_COUNT_CTOR(FFTBlock);
+mOutputBuffer.SetLength(aFFTSize / 2 + 1);
+PodZero(mOutputBuffer.Elements(), aFFTSize / 2 + 1);
+}
+~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)
+{
+EnsureFFT();
+kiss_fftr(mFFT, aData, mOutputBuffer.Elements());
+}
+// Inverse-transform internal data and store the resulting FFTSize()
+// points in aData.
+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)
+{
+EnsureIFFT();
+kiss_fftri(mIFFT, mOutputBuffer.Elements(), aDataOut);
+}
+// Inverse-transform the FFTSize()/2+1 points of data in each
+// of aRealDataIn and aImagDataIn and store the resulting
+// FFTSize() points in aRealDataOut.
+void PerformInverseFFT(float* aRealDataIn,
+float *aImagDataIn,
+float *aRealDataOut)
+{
+EnsureIFFT();
+const uint32_t inputSize = mFFTSize / 2 + 1;
+nsTArray<kiss_fft_cpx> inputBuffer;
+inputBuffer.SetLength(inputSize);
+for (uint32_t i = 0; i < inputSize; ++i) {
+inputBuffer[i].r = aRealDataIn[i];
+inputBuffer[i].i = aImagDataIn[i];
+}
+kiss_fftri(mIFFT, inputBuffer.Elements(), aRealDataOut);
+for (uint32_t i = 0; i < mFFTSize; ++i) {
+aRealDataOut[i] /= mFFTSize;
+}
+}
+void Multiply(const FFTBlock& aFrame)
+{
+BufferComplexMultiply(reinterpret_cast<const float*>(mOutputBuffer.Elements()),
+reinterpret_cast<const float*>(aFrame.mOutputBuffer.Elements()),
+reinterpret_cast<float*>(mOutputBuffer.Elements()),
+mFFTSize / 2 + 1);
+}
+// 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());
+nsTArray<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 ImagData(uint32_t aIndex) const
+{
+return mOutputBuffer[aIndex].i;
+}
+size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const
+{
+size_t amount = 0;
+amount += aMallocSizeOf(mFFT);
+amount += aMallocSizeOf(mIFFT);
+amount += mOutputBuffer.SizeOfExcludingThis(aMallocSizeOf);
+return amount;
+}
+size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const
+{
+return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+}
+private:
+FFTBlock(const FFTBlock& other) MOZ_DELETE;
+void operator=(const FFTBlock& other) MOZ_DELETE;
+void EnsureFFT()
+{
+if (!mFFT) {
+mFFT = kiss_fftr_alloc(mFFTSize, 0, nullptr, nullptr);
+}
+}
+void EnsureIFFT()
+{
+if (!mIFFT) {
+mIFFT = kiss_fftr_alloc(mFFTSize, 1, nullptr, nullptr);
+}
+}
+void Clear()
+{
+free(mFFT);
+free(mIFFT);
+mFFT = mIFFT = nullptr;
+}
+void AddConstantGroupDelay(double sampleFrameDelay);
+void InterpolateFrequencyComponents(const FFTBlock& block0,
+const FFTBlock& block1, double interp);
+kiss_fftr_cfg mFFT, mIFFT;
+nsTArray<kiss_fft_cpx> mOutputBuffer;
+uint32_t mFFTSize;
+};
+}
+#endif

The Tor Browser / file comparison

comparison: content/media/webaudio/FFTBlock.h

content/media/webaudio/FFTBlock.h