From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Fri, 2 Feb 2018 04:16:08 -0500 Subject: Add m-esr52 at 52.6.0 --- dom/media/webaudio/AnalyserNode.cpp | 387 ++++++++++++++++++++++++++++++++++++ 1 file changed, 387 insertions(+) create mode 100644 dom/media/webaudio/AnalyserNode.cpp (limited to 'dom/media/webaudio/AnalyserNode.cpp') diff --git a/dom/media/webaudio/AnalyserNode.cpp b/dom/media/webaudio/AnalyserNode.cpp new file mode 100644 index 000000000..64c3cf4da --- /dev/null +++ b/dom/media/webaudio/AnalyserNode.cpp @@ -0,0 +1,387 @@ +/* -*- 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/. */ + +#include "mozilla/dom/AnalyserNode.h" +#include "mozilla/dom/AnalyserNodeBinding.h" +#include "AudioNodeEngine.h" +#include "AudioNodeStream.h" +#include "mozilla/Mutex.h" +#include "mozilla/PodOperations.h" + +namespace mozilla { + +static const uint32_t MAX_FFT_SIZE = 32768; +static const size_t CHUNK_COUNT = MAX_FFT_SIZE >> WEBAUDIO_BLOCK_SIZE_BITS; +static_assert(MAX_FFT_SIZE == CHUNK_COUNT * WEBAUDIO_BLOCK_SIZE, + "MAX_FFT_SIZE must be a multiple of WEBAUDIO_BLOCK_SIZE"); +static_assert((CHUNK_COUNT & (CHUNK_COUNT - 1)) == 0, + "CHUNK_COUNT must be power of 2 for remainder behavior"); + +namespace dom { + +NS_IMPL_ISUPPORTS_INHERITED0(AnalyserNode, AudioNode) + +class AnalyserNodeEngine final : public AudioNodeEngine +{ + class TransferBuffer final : public Runnable + { + public: + TransferBuffer(AudioNodeStream* aStream, + const AudioChunk& aChunk) + : mStream(aStream) + , mChunk(aChunk) + { + } + + NS_IMETHOD Run() override + { + RefPtr node = + static_cast(mStream->Engine()->NodeMainThread()); + if (node) { + node->AppendChunk(mChunk); + } + return NS_OK; + } + + private: + RefPtr mStream; + AudioChunk mChunk; + }; + +public: + explicit AnalyserNodeEngine(AnalyserNode* aNode) + : AudioNodeEngine(aNode) + { + MOZ_ASSERT(NS_IsMainThread()); + } + + virtual void ProcessBlock(AudioNodeStream* aStream, + GraphTime aFrom, + const AudioBlock& aInput, + AudioBlock* aOutput, + bool* aFinished) override + { + *aOutput = aInput; + + if (aInput.IsNull()) { + // If AnalyserNode::mChunks has only null chunks, then there is no need + // to send further null chunks. + if (mChunksToProcess == 0) { + return; + } + + --mChunksToProcess; + if (mChunksToProcess == 0) { + aStream->ScheduleCheckForInactive(); + } + + } else { + // This many null chunks will be required to empty AnalyserNode::mChunks. + mChunksToProcess = CHUNK_COUNT; + } + + RefPtr transfer = + new TransferBuffer(aStream, aInput.AsAudioChunk()); + NS_DispatchToMainThread(transfer); + } + + virtual bool IsActive() const override + { + return mChunksToProcess != 0; + } + + virtual size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const override + { + return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf); + } + + uint32_t mChunksToProcess = 0; +}; + +AnalyserNode::AnalyserNode(AudioContext* aContext) + : AudioNode(aContext, + 1, + ChannelCountMode::Max, + ChannelInterpretation::Speakers) + , mAnalysisBlock(2048) + , mMinDecibels(-100.) + , mMaxDecibels(-30.) + , mSmoothingTimeConstant(.8) +{ + mStream = AudioNodeStream::Create(aContext, + new AnalyserNodeEngine(this), + AudioNodeStream::NO_STREAM_FLAGS, + aContext->Graph()); + + // Enough chunks must be recorded to handle the case of fftSize being + // increased to maximum immediately before getFloatTimeDomainData() is + // called, for example. + Unused << mChunks.SetLength(CHUNK_COUNT, fallible); + + AllocateBuffer(); +} + +size_t +AnalyserNode::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const +{ + size_t amount = AudioNode::SizeOfExcludingThis(aMallocSizeOf); + amount += mAnalysisBlock.SizeOfExcludingThis(aMallocSizeOf); + amount += mChunks.ShallowSizeOfExcludingThis(aMallocSizeOf); + amount += mOutputBuffer.ShallowSizeOfExcludingThis(aMallocSizeOf); + return amount; +} + +size_t +AnalyserNode::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const +{ + return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf); +} + +JSObject* +AnalyserNode::WrapObject(JSContext* aCx, JS::Handle aGivenProto) +{ + return AnalyserNodeBinding::Wrap(aCx, this, aGivenProto); +} + +void +AnalyserNode::SetFftSize(uint32_t aValue, ErrorResult& aRv) +{ + // Disallow values that are not a power of 2 and outside the [32,32768] range + if (aValue < 32 || + aValue > MAX_FFT_SIZE || + (aValue & (aValue - 1)) != 0) { + aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR); + return; + } + if (FftSize() != aValue) { + mAnalysisBlock.SetFFTSize(aValue); + AllocateBuffer(); + } +} + +void +AnalyserNode::SetMinDecibels(double aValue, ErrorResult& aRv) +{ + if (aValue >= mMaxDecibels) { + aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR); + return; + } + mMinDecibels = aValue; +} + +void +AnalyserNode::SetMaxDecibels(double aValue, ErrorResult& aRv) +{ + if (aValue <= mMinDecibels) { + aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR); + return; + } + mMaxDecibels = aValue; +} + +void +AnalyserNode::SetSmoothingTimeConstant(double aValue, ErrorResult& aRv) +{ + if (aValue < 0 || aValue > 1) { + aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR); + return; + } + mSmoothingTimeConstant = aValue; +} + +void +AnalyserNode::GetFloatFrequencyData(const Float32Array& aArray) +{ + if (!FFTAnalysis()) { + // Might fail to allocate memory + return; + } + + aArray.ComputeLengthAndData(); + + float* buffer = aArray.Data(); + size_t length = std::min(size_t(aArray.Length()), mOutputBuffer.Length()); + + for (size_t i = 0; i < length; ++i) { + buffer[i] = WebAudioUtils::ConvertLinearToDecibels(mOutputBuffer[i], mMinDecibels); + } +} + +void +AnalyserNode::GetByteFrequencyData(const Uint8Array& aArray) +{ + if (!FFTAnalysis()) { + // Might fail to allocate memory + return; + } + + const double rangeScaleFactor = 1.0 / (mMaxDecibels - mMinDecibels); + + aArray.ComputeLengthAndData(); + + unsigned char* buffer = aArray.Data(); + size_t length = std::min(size_t(aArray.Length()), mOutputBuffer.Length()); + + for (size_t i = 0; i < length; ++i) { + const double decibels = WebAudioUtils::ConvertLinearToDecibels(mOutputBuffer[i], mMinDecibels); + // scale down the value to the range of [0, UCHAR_MAX] + const double scaled = std::max(0.0, std::min(double(UCHAR_MAX), + UCHAR_MAX * (decibels - mMinDecibels) * rangeScaleFactor)); + buffer[i] = static_cast(scaled); + } +} + +void +AnalyserNode::GetFloatTimeDomainData(const Float32Array& aArray) +{ + aArray.ComputeLengthAndData(); + + float* buffer = aArray.Data(); + size_t length = std::min(aArray.Length(), FftSize()); + + GetTimeDomainData(buffer, length); +} + +void +AnalyserNode::GetByteTimeDomainData(const Uint8Array& aArray) +{ + aArray.ComputeLengthAndData(); + + size_t length = std::min(aArray.Length(), FftSize()); + + AlignedTArray tmpBuffer; + if (!tmpBuffer.SetLength(length, fallible)) { + return; + } + + GetTimeDomainData(tmpBuffer.Elements(), length); + + unsigned char* buffer = aArray.Data(); + for (size_t i = 0; i < length; ++i) { + const float value = tmpBuffer[i]; + // scale the value to the range of [0, UCHAR_MAX] + const float scaled = std::max(0.0f, std::min(float(UCHAR_MAX), + 128.0f * (value + 1.0f))); + buffer[i] = static_cast(scaled); + } +} + +bool +AnalyserNode::FFTAnalysis() +{ + AlignedTArray tmpBuffer; + size_t fftSize = FftSize(); + if (!tmpBuffer.SetLength(fftSize, fallible)) { + return false; + } + + float* inputBuffer = tmpBuffer.Elements(); + GetTimeDomainData(inputBuffer, fftSize); + ApplyBlackmanWindow(inputBuffer, fftSize); + mAnalysisBlock.PerformFFT(inputBuffer); + + // Normalize so than an input sine wave at 0dBfs registers as 0dBfs (undo FFT scaling factor). + const double magnitudeScale = 1.0 / fftSize; + + for (uint32_t i = 0; i < mOutputBuffer.Length(); ++i) { + double scalarMagnitude = NS_hypot(mAnalysisBlock.RealData(i), + mAnalysisBlock.ImagData(i)) * + magnitudeScale; + mOutputBuffer[i] = mSmoothingTimeConstant * mOutputBuffer[i] + + (1.0 - mSmoothingTimeConstant) * scalarMagnitude; + } + + return true; +} + +void +AnalyserNode::ApplyBlackmanWindow(float* aBuffer, uint32_t aSize) +{ + double alpha = 0.16; + double a0 = 0.5 * (1.0 - alpha); + double a1 = 0.5; + double a2 = 0.5 * alpha; + + for (uint32_t i = 0; i < aSize; ++i) { + double x = double(i) / aSize; + double window = a0 - a1 * cos(2 * M_PI * x) + a2 * cos(4 * M_PI * x); + aBuffer[i] *= window; + } +} + +bool +AnalyserNode::AllocateBuffer() +{ + bool result = true; + if (mOutputBuffer.Length() != FrequencyBinCount()) { + if (!mOutputBuffer.SetLength(FrequencyBinCount(), fallible)) { + return false; + } + memset(mOutputBuffer.Elements(), 0, sizeof(float) * FrequencyBinCount()); + } + return result; +} + +void +AnalyserNode::AppendChunk(const AudioChunk& aChunk) +{ + if (mChunks.Length() == 0) { + return; + } + + ++mCurrentChunk; + mChunks[mCurrentChunk & (CHUNK_COUNT - 1)] = aChunk; +} + +// Reads into aData the oldest aLength samples of the fftSize most recent +// samples. +void +AnalyserNode::GetTimeDomainData(float* aData, size_t aLength) +{ + size_t fftSize = FftSize(); + MOZ_ASSERT(aLength <= fftSize); + + if (mChunks.Length() == 0) { + PodZero(aData, aLength); + return; + } + + size_t readChunk = + mCurrentChunk - ((fftSize - 1) >> WEBAUDIO_BLOCK_SIZE_BITS); + size_t readIndex = (0 - fftSize) & (WEBAUDIO_BLOCK_SIZE - 1); + MOZ_ASSERT(readIndex == 0 || readIndex + fftSize == WEBAUDIO_BLOCK_SIZE); + + for (size_t writeIndex = 0; writeIndex < aLength; ) { + const AudioChunk& chunk = mChunks[readChunk & (CHUNK_COUNT - 1)]; + const size_t channelCount = chunk.ChannelCount(); + size_t copyLength = + std::min(aLength - writeIndex, WEBAUDIO_BLOCK_SIZE); + float* dataOut = &aData[writeIndex]; + + if (channelCount == 0) { + PodZero(dataOut, copyLength); + } else { + float scale = chunk.mVolume / channelCount; + { // channel 0 + auto channelData = + static_cast(chunk.mChannelData[0]) + readIndex; + AudioBufferCopyWithScale(channelData, scale, dataOut, copyLength); + } + for (uint32_t i = 1; i < channelCount; ++i) { + auto channelData = + static_cast(chunk.mChannelData[i]) + readIndex; + AudioBufferAddWithScale(channelData, scale, dataOut, copyLength); + } + } + + readChunk++; + writeIndex += copyLength; + } +} + +} // namespace dom +} // namespace mozilla + -- cgit v1.2.3