summaryrefslogtreecommitdiffstats
path: root/dom/media/webaudio/AudioNodeEngine.h
diff options
context:
space:
mode:
Diffstat (limited to 'dom/media/webaudio/AudioNodeEngine.h')
-rw-r--r--dom/media/webaudio/AudioNodeEngine.h410
1 files changed, 410 insertions, 0 deletions
diff --git a/dom/media/webaudio/AudioNodeEngine.h b/dom/media/webaudio/AudioNodeEngine.h
new file mode 100644
index 000000000..d49b5c906
--- /dev/null
+++ b/dom/media/webaudio/AudioNodeEngine.h
@@ -0,0 +1,410 @@
+/* -*- 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 MOZILLA_AUDIONODEENGINE_H_
+#define MOZILLA_AUDIONODEENGINE_H_
+
+#include "AudioSegment.h"
+#include "mozilla/dom/AudioNode.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/Mutex.h"
+
+namespace mozilla {
+
+namespace dom {
+struct ThreeDPoint;
+class AudioParamTimeline;
+class DelayNodeEngine;
+struct AudioTimelineEvent;
+} // namespace dom
+
+class AudioBlock;
+class AudioNodeStream;
+
+/**
+ * This class holds onto a set of immutable channel buffers. The storage
+ * for the buffers must be malloced, but the buffer pointers and the malloc
+ * pointers can be different (e.g. if the buffers are contained inside
+ * some malloced object).
+ */
+class ThreadSharedFloatArrayBufferList final : public ThreadSharedObject
+{
+public:
+ /**
+ * Construct with null channel data pointers.
+ */
+ explicit ThreadSharedFloatArrayBufferList(uint32_t aCount)
+ {
+ mContents.SetLength(aCount);
+ }
+ /**
+ * Create with buffers suitable for transfer to
+ * JS_NewArrayBufferWithContents(). The buffer contents are uninitialized
+ * and so should be set using GetDataForWrite().
+ */
+ static already_AddRefed<ThreadSharedFloatArrayBufferList>
+ Create(uint32_t aChannelCount, size_t aLength, const mozilla::fallible_t&);
+
+ struct Storage final
+ {
+ Storage() :
+ mDataToFree(nullptr),
+ mFree(nullptr),
+ mSampleData(nullptr)
+ {}
+ ~Storage() {
+ if (mFree) {
+ mFree(mDataToFree);
+ } else { MOZ_ASSERT(!mDataToFree); }
+ }
+ size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const
+ {
+ // NB: mSampleData might not be owned, if it is it just points to
+ // mDataToFree.
+ return aMallocSizeOf(mDataToFree);
+ }
+ void* mDataToFree;
+ void (*mFree)(void*);
+ float* mSampleData;
+ };
+
+ /**
+ * This can be called on any thread.
+ */
+ uint32_t GetChannels() const { return mContents.Length(); }
+ /**
+ * This can be called on any thread.
+ */
+ const float* GetData(uint32_t aIndex) const { return mContents[aIndex].mSampleData; }
+ /**
+ * This can be called on any thread, but only when the calling thread is the
+ * only owner.
+ */
+ float* GetDataForWrite(uint32_t aIndex)
+ {
+ MOZ_ASSERT(!IsShared());
+ return mContents[aIndex].mSampleData;
+ }
+
+ /**
+ * Call this only during initialization, before the object is handed to
+ * any other thread.
+ */
+ void SetData(uint32_t aIndex, void* aDataToFree, void (*aFreeFunc)(void*), float* aData)
+ {
+ Storage* s = &mContents[aIndex];
+ if (s->mFree) {
+ s->mFree(s->mDataToFree);
+ } else {
+ MOZ_ASSERT(!s->mDataToFree);
+ }
+
+ s->mDataToFree = aDataToFree;
+ s->mFree = aFreeFunc;
+ s->mSampleData = aData;
+ }
+
+ /**
+ * Put this object into an error state where there are no channels.
+ */
+ void Clear() { mContents.Clear(); }
+
+ size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const override
+ {
+ size_t amount = ThreadSharedObject::SizeOfExcludingThis(aMallocSizeOf);
+ amount += mContents.ShallowSizeOfExcludingThis(aMallocSizeOf);
+ for (size_t i = 0; i < mContents.Length(); i++) {
+ amount += mContents[i].SizeOfExcludingThis(aMallocSizeOf);
+ }
+
+ return amount;
+ }
+
+ size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const override
+ {
+ return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+ }
+
+private:
+ AutoTArray<Storage, 2> mContents;
+};
+
+/**
+ * aChunk must have been allocated by AllocateAudioBlock.
+ */
+void WriteZeroesToAudioBlock(AudioBlock* aChunk, uint32_t aStart,
+ uint32_t aLength);
+
+/**
+ * Copy with scale. aScale == 1.0f should be optimized.
+ */
+void AudioBufferCopyWithScale(const float* aInput,
+ float aScale,
+ float* aOutput,
+ uint32_t aSize);
+
+/**
+ * Pointwise multiply-add operation. aScale == 1.0f should be optimized.
+ */
+void AudioBufferAddWithScale(const float* aInput,
+ float aScale,
+ float* aOutput,
+ uint32_t aSize);
+
+/**
+ * Pointwise multiply-add operation. aScale == 1.0f should be optimized.
+ */
+void AudioBlockAddChannelWithScale(const float aInput[WEBAUDIO_BLOCK_SIZE],
+ float aScale,
+ float aOutput[WEBAUDIO_BLOCK_SIZE]);
+
+/**
+ * Pointwise copy-scaled operation. aScale == 1.0f should be optimized.
+ *
+ * Buffer size is implicitly assumed to be WEBAUDIO_BLOCK_SIZE.
+ */
+void AudioBlockCopyChannelWithScale(const float* aInput,
+ float aScale,
+ float* aOutput);
+
+/**
+ * Vector copy-scaled operation.
+ */
+void AudioBlockCopyChannelWithScale(const float aInput[WEBAUDIO_BLOCK_SIZE],
+ const float aScale[WEBAUDIO_BLOCK_SIZE],
+ float aOutput[WEBAUDIO_BLOCK_SIZE]);
+
+/**
+ * Vector complex multiplication on arbitrary sized buffers.
+ */
+void BufferComplexMultiply(const float* aInput,
+ const float* aScale,
+ float* aOutput,
+ uint32_t aSize);
+
+/**
+ * Vector maximum element magnitude ( max(abs(aInput)) ).
+ */
+float AudioBufferPeakValue(const float* aInput, uint32_t aSize);
+
+/**
+ * In place gain. aScale == 1.0f should be optimized.
+ */
+void AudioBlockInPlaceScale(float aBlock[WEBAUDIO_BLOCK_SIZE],
+ float aScale);
+
+/**
+ * In place gain. aScale == 1.0f should be optimized.
+ */
+void AudioBufferInPlaceScale(float* aBlock,
+ float aScale,
+ uint32_t aSize);
+
+/**
+ * Upmix a mono input to a stereo output, scaling the two output channels by two
+ * different gain value.
+ * This algorithm is specified in the WebAudio spec.
+ */
+void
+AudioBlockPanMonoToStereo(const float aInput[WEBAUDIO_BLOCK_SIZE],
+ float aGainL, float aGainR,
+ float aOutputL[WEBAUDIO_BLOCK_SIZE],
+ float aOutputR[WEBAUDIO_BLOCK_SIZE]);
+
+void
+AudioBlockPanMonoToStereo(const float aInput[WEBAUDIO_BLOCK_SIZE],
+ float aGainL[WEBAUDIO_BLOCK_SIZE],
+ float aGainR[WEBAUDIO_BLOCK_SIZE],
+ float aOutputL[WEBAUDIO_BLOCK_SIZE],
+ float aOutputR[WEBAUDIO_BLOCK_SIZE]);
+/**
+ * Pan a stereo source according to right and left gain, and the position
+ * (whether the listener is on the left of the source or not).
+ * This algorithm is specified in the WebAudio spec.
+ */
+void
+AudioBlockPanStereoToStereo(const float aInputL[WEBAUDIO_BLOCK_SIZE],
+ const float aInputR[WEBAUDIO_BLOCK_SIZE],
+ float aGainL, float aGainR, bool aIsOnTheLeft,
+ float aOutputL[WEBAUDIO_BLOCK_SIZE],
+ float aOutputR[WEBAUDIO_BLOCK_SIZE]);
+void
+AudioBlockPanStereoToStereo(const float aInputL[WEBAUDIO_BLOCK_SIZE],
+ const float aInputR[WEBAUDIO_BLOCK_SIZE],
+ float aGainL[WEBAUDIO_BLOCK_SIZE],
+ float aGainR[WEBAUDIO_BLOCK_SIZE],
+ bool aIsOnTheLeft[WEBAUDIO_BLOCK_SIZE],
+ float aOutputL[WEBAUDIO_BLOCK_SIZE],
+ float aOutputR[WEBAUDIO_BLOCK_SIZE]);
+
+/**
+ * Return the sum of squares of all of the samples in the input.
+ */
+float
+AudioBufferSumOfSquares(const float* aInput, uint32_t aLength);
+
+/**
+ * All methods of this class and its subclasses are called on the
+ * MediaStreamGraph thread.
+ */
+class AudioNodeEngine
+{
+public:
+ // This should be compatible with AudioNodeStream::OutputChunks.
+ typedef AutoTArray<AudioBlock, 1> OutputChunks;
+
+ explicit AudioNodeEngine(dom::AudioNode* aNode)
+ : mNode(aNode)
+ , mNodeType(aNode ? aNode->NodeType() : nullptr)
+ , mInputCount(aNode ? aNode->NumberOfInputs() : 1)
+ , mOutputCount(aNode ? aNode->NumberOfOutputs() : 0)
+ {
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_COUNT_CTOR(AudioNodeEngine);
+ }
+ virtual ~AudioNodeEngine()
+ {
+ MOZ_ASSERT(!mNode, "The node reference must be already cleared");
+ MOZ_COUNT_DTOR(AudioNodeEngine);
+ }
+
+ virtual dom::DelayNodeEngine* AsDelayNodeEngine() { return nullptr; }
+
+ virtual void SetStreamTimeParameter(uint32_t aIndex, StreamTime aParam)
+ {
+ NS_ERROR("Invalid SetStreamTimeParameter index");
+ }
+ virtual void SetDoubleParameter(uint32_t aIndex, double aParam)
+ {
+ NS_ERROR("Invalid SetDoubleParameter index");
+ }
+ virtual void SetInt32Parameter(uint32_t aIndex, int32_t aParam)
+ {
+ NS_ERROR("Invalid SetInt32Parameter index");
+ }
+ virtual void RecvTimelineEvent(uint32_t aIndex,
+ dom::AudioTimelineEvent& aValue)
+ {
+ NS_ERROR("Invalid RecvTimelineEvent index");
+ }
+ virtual void SetThreeDPointParameter(uint32_t aIndex,
+ const dom::ThreeDPoint& aValue)
+ {
+ NS_ERROR("Invalid SetThreeDPointParameter index");
+ }
+ virtual void SetBuffer(already_AddRefed<ThreadSharedFloatArrayBufferList> aBuffer)
+ {
+ NS_ERROR("SetBuffer called on engine that doesn't support it");
+ }
+ // This consumes the contents of aData. aData will be emptied after this returns.
+ virtual void SetRawArrayData(nsTArray<float>& aData)
+ {
+ NS_ERROR("SetRawArrayData called on an engine that doesn't support it");
+ }
+
+ /**
+ * Produce the next block of audio samples, given input samples aInput
+ * (the mixed data for input 0).
+ * aInput is guaranteed to have float sample format (if it has samples at all)
+ * and to have been resampled to the sampling rate for the stream, and to have
+ * exactly WEBAUDIO_BLOCK_SIZE samples.
+ * *aFinished is set to false by the caller. The callee must not set this to
+ * true unless silent output is produced. If set to true, we'll finish the
+ * stream, consider this input inactive on any downstream nodes, and not
+ * call this again.
+ */
+ virtual void ProcessBlock(AudioNodeStream* aStream,
+ GraphTime aFrom,
+ const AudioBlock& aInput,
+ AudioBlock* aOutput,
+ bool* aFinished);
+ /**
+ * Produce the next block of audio samples, before input is provided.
+ * ProcessBlock() will be called later, and it then should not change
+ * aOutput. This is used only for DelayNodeEngine in a feedback loop.
+ */
+ virtual void ProduceBlockBeforeInput(AudioNodeStream* aStream,
+ GraphTime aFrom,
+ AudioBlock* aOutput)
+ {
+ NS_NOTREACHED("ProduceBlockBeforeInput called on wrong engine\n");
+ }
+
+ /**
+ * Produce the next block of audio samples, given input samples in the aInput
+ * array. There is one input sample per active port in aInput, in order.
+ * This is the multi-input/output version of ProcessBlock. Only one kind
+ * of ProcessBlock is called on each node, depending on whether the
+ * number of inputs and outputs are both 1 or not.
+ *
+ * aInput is always guaranteed to not contain more input AudioChunks than the
+ * maximum number of inputs for the node. It is the responsibility of the
+ * overrides of this function to make sure they will only add a maximum number
+ * of AudioChunks to aOutput as advertized by the AudioNode implementation.
+ * An engine may choose to produce fewer inputs than advertizes by the
+ * corresponding AudioNode, in which case it will be interpreted as a channel
+ * of silence.
+ */
+ virtual void ProcessBlocksOnPorts(AudioNodeStream* aStream,
+ const OutputChunks& aInput,
+ OutputChunks& aOutput,
+ bool* aFinished);
+
+ // IsActive() returns true if the engine needs to continue processing an
+ // unfinished stream even when it has silent or no input connections. This
+ // includes tail-times and when sources have been scheduled to start. If
+ // returning false, then the stream can be suspended.
+ virtual bool IsActive() const { return false; }
+
+ bool HasNode() const
+ {
+ MOZ_ASSERT(NS_IsMainThread());
+ return !!mNode;
+ }
+
+ dom::AudioNode* NodeMainThread() const
+ {
+ MOZ_ASSERT(NS_IsMainThread());
+ return mNode;
+ }
+
+ void ClearNode()
+ {
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(mNode != nullptr);
+ mNode = nullptr;
+ }
+
+ uint16_t InputCount() const { return mInputCount; }
+ uint16_t OutputCount() const { return mOutputCount; }
+
+ virtual size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const
+ {
+ // NB: |mNode| is tracked separately so it is excluded here.
+ return 0;
+ }
+
+ virtual size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const
+ {
+ return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+ }
+
+ void SizeOfIncludingThis(MallocSizeOf aMallocSizeOf,
+ AudioNodeSizes& aUsage) const
+ {
+ aUsage.mEngine = SizeOfIncludingThis(aMallocSizeOf);
+ aUsage.mNodeType = mNodeType;
+ }
+
+private:
+ dom::AudioNode* mNode; // main thread only
+ const char* const mNodeType;
+ const uint16_t mInputCount;
+ const uint16_t mOutputCount;
+};
+
+} // namespace mozilla
+
+#endif /* MOZILLA_AUDIONODEENGINE_H_ */