summaryrefslogtreecommitdiffstats
path: root/dom/media/webaudio/DelayBuffer.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /dom/media/webaudio/DelayBuffer.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'dom/media/webaudio/DelayBuffer.cpp')
-rw-r--r--dom/media/webaudio/DelayBuffer.cpp263
1 files changed, 263 insertions, 0 deletions
diff --git a/dom/media/webaudio/DelayBuffer.cpp b/dom/media/webaudio/DelayBuffer.cpp
new file mode 100644
index 000000000..c7f7198c9
--- /dev/null
+++ b/dom/media/webaudio/DelayBuffer.cpp
@@ -0,0 +1,263 @@
+/* -*- 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 "DelayBuffer.h"
+
+#include "mozilla/PodOperations.h"
+#include "AudioChannelFormat.h"
+#include "AudioNodeEngine.h"
+
+namespace mozilla {
+
+size_t
+DelayBuffer::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const
+{
+ size_t amount = 0;
+ amount += mChunks.ShallowSizeOfExcludingThis(aMallocSizeOf);
+ for (size_t i = 0; i < mChunks.Length(); i++) {
+ amount += mChunks[i].SizeOfExcludingThis(aMallocSizeOf, false);
+ }
+
+ amount += mUpmixChannels.ShallowSizeOfExcludingThis(aMallocSizeOf);
+ return amount;
+}
+
+void
+DelayBuffer::Write(const AudioBlock& aInputChunk)
+{
+ // We must have a reference to the buffer if there are channels
+ MOZ_ASSERT(aInputChunk.IsNull() == !aInputChunk.ChannelCount());
+#ifdef DEBUG
+ MOZ_ASSERT(!mHaveWrittenBlock);
+ mHaveWrittenBlock = true;
+#endif
+
+ if (!EnsureBuffer()) {
+ return;
+ }
+
+ if (mCurrentChunk == mLastReadChunk) {
+ mLastReadChunk = -1; // invalidate cache
+ }
+ mChunks[mCurrentChunk] = aInputChunk.AsAudioChunk();
+}
+
+void
+DelayBuffer::Read(const double aPerFrameDelays[WEBAUDIO_BLOCK_SIZE],
+ AudioBlock* aOutputChunk,
+ ChannelInterpretation aChannelInterpretation)
+{
+ int chunkCount = mChunks.Length();
+ if (!chunkCount) {
+ aOutputChunk->SetNull(WEBAUDIO_BLOCK_SIZE);
+ return;
+ }
+
+ // Find the maximum number of contributing channels to determine the output
+ // channel count that retains all signal information. Buffered blocks will
+ // be upmixed if necessary.
+ //
+ // First find the range of "delay" offsets backwards from the current
+ // position. Note that these may be negative for frames that are after the
+ // current position (including i).
+ double minDelay = aPerFrameDelays[0];
+ double maxDelay = minDelay;
+ for (unsigned i = 1; i < WEBAUDIO_BLOCK_SIZE; ++i) {
+ minDelay = std::min(minDelay, aPerFrameDelays[i] - i);
+ maxDelay = std::max(maxDelay, aPerFrameDelays[i] - i);
+ }
+
+ // Now find the chunks touched by this range and check their channel counts.
+ int oldestChunk = ChunkForDelay(int(maxDelay) + 1);
+ int youngestChunk = ChunkForDelay(minDelay);
+
+ uint32_t channelCount = 0;
+ for (int i = oldestChunk; true; i = (i + 1) % chunkCount) {
+ channelCount = GetAudioChannelsSuperset(channelCount,
+ mChunks[i].ChannelCount());
+ if (i == youngestChunk) {
+ break;
+ }
+ }
+
+ if (channelCount) {
+ aOutputChunk->AllocateChannels(channelCount);
+ ReadChannels(aPerFrameDelays, aOutputChunk,
+ 0, channelCount, aChannelInterpretation);
+ } else {
+ aOutputChunk->SetNull(WEBAUDIO_BLOCK_SIZE);
+ }
+
+ // Remember currentDelayFrames for the next ProcessBlock call
+ mCurrentDelay = aPerFrameDelays[WEBAUDIO_BLOCK_SIZE - 1];
+}
+
+void
+DelayBuffer::ReadChannel(const double aPerFrameDelays[WEBAUDIO_BLOCK_SIZE],
+ AudioBlock* aOutputChunk, uint32_t aChannel,
+ ChannelInterpretation aChannelInterpretation)
+{
+ if (!mChunks.Length()) {
+ float* outputChannel = aOutputChunk->ChannelFloatsForWrite(aChannel);
+ PodZero(outputChannel, WEBAUDIO_BLOCK_SIZE);
+ return;
+ }
+
+ ReadChannels(aPerFrameDelays, aOutputChunk,
+ aChannel, 1, aChannelInterpretation);
+}
+
+void
+DelayBuffer::ReadChannels(const double aPerFrameDelays[WEBAUDIO_BLOCK_SIZE],
+ AudioBlock* aOutputChunk,
+ uint32_t aFirstChannel, uint32_t aNumChannelsToRead,
+ ChannelInterpretation aChannelInterpretation)
+{
+ uint32_t totalChannelCount = aOutputChunk->ChannelCount();
+ uint32_t readChannelsEnd = aFirstChannel + aNumChannelsToRead;
+ MOZ_ASSERT(readChannelsEnd <= totalChannelCount);
+
+ if (mUpmixChannels.Length() != totalChannelCount) {
+ mLastReadChunk = -1; // invalidate cache
+ }
+
+ for (uint32_t channel = aFirstChannel;
+ channel < readChannelsEnd; ++channel) {
+ PodZero(aOutputChunk->ChannelFloatsForWrite(channel), WEBAUDIO_BLOCK_SIZE);
+ }
+
+ for (unsigned i = 0; i < WEBAUDIO_BLOCK_SIZE; ++i) {
+ double currentDelay = aPerFrameDelays[i];
+ MOZ_ASSERT(currentDelay >= 0.0);
+ MOZ_ASSERT(currentDelay <= (mChunks.Length() - 1) * WEBAUDIO_BLOCK_SIZE);
+
+ // Interpolate two input frames in case the read position does not match
+ // an integer index.
+ // Use the larger delay, for the older frame, first, as this is more
+ // likely to use the cached upmixed channel arrays.
+ int floorDelay = int(currentDelay);
+ double interpolationFactor = currentDelay - floorDelay;
+ int positions[2];
+ positions[1] = PositionForDelay(floorDelay) + i;
+ positions[0] = positions[1] - 1;
+
+ for (unsigned tick = 0; tick < ArrayLength(positions); ++tick) {
+ int readChunk = ChunkForPosition(positions[tick]);
+ // mVolume is not set on default initialized chunks so handle null
+ // chunks specially.
+ if (!mChunks[readChunk].IsNull()) {
+ int readOffset = OffsetForPosition(positions[tick]);
+ UpdateUpmixChannels(readChunk, totalChannelCount,
+ aChannelInterpretation);
+ double multiplier = interpolationFactor * mChunks[readChunk].mVolume;
+ for (uint32_t channel = aFirstChannel;
+ channel < readChannelsEnd; ++channel) {
+ aOutputChunk->ChannelFloatsForWrite(channel)[i] += multiplier *
+ mUpmixChannels[channel][readOffset];
+ }
+ }
+
+ interpolationFactor = 1.0 - interpolationFactor;
+ }
+ }
+}
+
+void
+DelayBuffer::Read(double aDelayTicks, AudioBlock* aOutputChunk,
+ ChannelInterpretation aChannelInterpretation)
+{
+ const bool firstTime = mCurrentDelay < 0.0;
+ double currentDelay = firstTime ? aDelayTicks : mCurrentDelay;
+
+ double computedDelay[WEBAUDIO_BLOCK_SIZE];
+
+ for (unsigned i = 0; i < WEBAUDIO_BLOCK_SIZE; ++i) {
+ // If the value has changed, smoothly approach it
+ currentDelay += (aDelayTicks - currentDelay) * mSmoothingRate;
+ computedDelay[i] = currentDelay;
+ }
+
+ Read(computedDelay, aOutputChunk, aChannelInterpretation);
+}
+
+bool
+DelayBuffer::EnsureBuffer()
+{
+ if (mChunks.Length() == 0) {
+ // The length of the buffer is at least one block greater than the maximum
+ // delay so that writing an input block does not overwrite the block that
+ // would subsequently be read at maximum delay. Also round up to the next
+ // block size, so that no block of writes will need to wrap.
+ const int chunkCount = (mMaxDelayTicks + 2 * WEBAUDIO_BLOCK_SIZE - 1) >>
+ WEBAUDIO_BLOCK_SIZE_BITS;
+ if (!mChunks.SetLength(chunkCount, fallible)) {
+ return false;
+ }
+
+ mLastReadChunk = -1;
+ }
+ return true;
+}
+
+int
+DelayBuffer::PositionForDelay(int aDelay) {
+ // Adding mChunks.Length() keeps integers positive for defined and
+ // appropriate bitshift, remainder, and bitwise operations.
+ return ((mCurrentChunk + mChunks.Length()) * WEBAUDIO_BLOCK_SIZE) - aDelay;
+}
+
+int
+DelayBuffer::ChunkForPosition(int aPosition)
+{
+ MOZ_ASSERT(aPosition >= 0);
+ return (aPosition >> WEBAUDIO_BLOCK_SIZE_BITS) % mChunks.Length();
+}
+
+int
+DelayBuffer::OffsetForPosition(int aPosition)
+{
+ MOZ_ASSERT(aPosition >= 0);
+ return aPosition & (WEBAUDIO_BLOCK_SIZE - 1);
+}
+
+int
+DelayBuffer::ChunkForDelay(int aDelay)
+{
+ return ChunkForPosition(PositionForDelay(aDelay));
+}
+
+void
+DelayBuffer::UpdateUpmixChannels(int aNewReadChunk, uint32_t aChannelCount,
+ ChannelInterpretation aChannelInterpretation)
+{
+ if (aNewReadChunk == mLastReadChunk) {
+ MOZ_ASSERT(mUpmixChannels.Length() == aChannelCount);
+ return;
+ }
+
+ NS_WARNING_ASSERTION(mHaveWrittenBlock || aNewReadChunk != mCurrentChunk,
+ "Smoothing is making feedback delay too small.");
+
+ mLastReadChunk = aNewReadChunk;
+ mUpmixChannels = mChunks[aNewReadChunk].ChannelData<float>();
+ MOZ_ASSERT(mUpmixChannels.Length() <= aChannelCount);
+ if (mUpmixChannels.Length() < aChannelCount) {
+ if (aChannelInterpretation == ChannelInterpretation::Speakers) {
+ AudioChannelsUpMix(&mUpmixChannels,
+ aChannelCount, SilentChannel::ZeroChannel<float>());
+ MOZ_ASSERT(mUpmixChannels.Length() == aChannelCount,
+ "We called GetAudioChannelsSuperset to avoid this");
+ } else {
+ // Fill up the remaining channels with zeros
+ for (uint32_t channel = mUpmixChannels.Length();
+ channel < aChannelCount; ++channel) {
+ mUpmixChannels.AppendElement(SilentChannel::ZeroChannel<float>());
+ }
+ }
+ }
+}
+
+} // namespace mozilla