summaryrefslogtreecommitdiffstats
path: root/dom/media/webaudio/AudioNodeTrack.h
diff options
context:
space:
mode:
Diffstat (limited to 'dom/media/webaudio/AudioNodeTrack.h')
-rw-r--r--dom/media/webaudio/AudioNodeTrack.h233
1 files changed, 233 insertions, 0 deletions
diff --git a/dom/media/webaudio/AudioNodeTrack.h b/dom/media/webaudio/AudioNodeTrack.h
new file mode 100644
index 0000000000..505ea96718
--- /dev/null
+++ b/dom/media/webaudio/AudioNodeTrack.h
@@ -0,0 +1,233 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-*/
+/* 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_AUDIONODETRACK_H_
+#define MOZILLA_AUDIONODETRACK_H_
+
+#include "MediaTrackGraph.h"
+#include "mozilla/dom/AudioNodeBinding.h"
+#include "AlignedTArray.h"
+#include "AudioBlock.h"
+#include "AudioSegment.h"
+
+namespace WebCore {
+class Reverb;
+} // namespace WebCore
+
+namespace mozilla {
+
+namespace dom {
+struct ThreeDPoint;
+struct AudioParamEvent;
+class AudioContext;
+} // namespace dom
+
+class AbstractThread;
+class ThreadSharedFloatArrayBufferList;
+class AudioNodeEngine;
+
+typedef AlignedAutoTArray<float, GUESS_AUDIO_CHANNELS * WEBAUDIO_BLOCK_SIZE, 16>
+ DownmixBufferType;
+
+/**
+ * An AudioNodeTrack produces one audio track with ID AUDIO_TRACK.
+ * The start time of the AudioTrack is aligned to the start time of the
+ * AudioContext's destination node track, plus some multiple of BLOCK_SIZE
+ * samples.
+ *
+ * An AudioNodeTrack has an AudioNodeEngine plugged into it that does the
+ * actual audio processing. AudioNodeTrack contains the glue code that
+ * integrates audio processing with the MediaTrackGraph.
+ */
+class AudioNodeTrack : public ProcessedMediaTrack {
+ typedef dom::ChannelCountMode ChannelCountMode;
+ typedef dom::ChannelInterpretation ChannelInterpretation;
+
+ public:
+ typedef mozilla::dom::AudioContext AudioContext;
+
+ enum { AUDIO_TRACK = 1 };
+
+ typedef AutoTArray<AudioBlock, 1> OutputChunks;
+
+ // Flags re main thread updates and track output.
+ typedef unsigned Flags;
+ enum : Flags {
+ NO_TRACK_FLAGS = 0U,
+ NEED_MAIN_THREAD_ENDED = 1U << 0,
+ NEED_MAIN_THREAD_CURRENT_TIME = 1U << 1,
+ // Internal AudioNodeTracks can only pass their output to another
+ // AudioNode, whereas external AudioNodeTracks can pass their output
+ // to other ProcessedMediaTracks or hardware audio output.
+ EXTERNAL_OUTPUT = 1U << 2,
+ };
+ /**
+ * Create a track that will process audio for an AudioNode.
+ * Takes ownership of aEngine.
+ * aGraph is required and equals the graph of aCtx in most cases. An exception
+ * is AudioDestinationNode where the context's graph hasn't been set up yet.
+ */
+ static already_AddRefed<AudioNodeTrack> Create(AudioContext* aCtx,
+ AudioNodeEngine* aEngine,
+ Flags aKind,
+ MediaTrackGraph* aGraph);
+
+ protected:
+ /**
+ * Transfers ownership of aEngine to the new AudioNodeTrack.
+ */
+ AudioNodeTrack(AudioNodeEngine* aEngine, Flags aFlags, TrackRate aSampleRate);
+
+ ~AudioNodeTrack();
+
+ public:
+ // Control API
+ /**
+ * Sets a parameter that's a time relative to some track's played time.
+ * This time is converted to a time relative to this track when it's set.
+ */
+ void SetTrackTimeParameter(uint32_t aIndex, AudioContext* aContext,
+ double aTrackTime);
+ void SetDoubleParameter(uint32_t aIndex, double aValue);
+ void SetInt32Parameter(uint32_t aIndex, int32_t aValue);
+ void SetThreeDPointParameter(uint32_t aIndex, const dom::ThreeDPoint& aValue);
+ void SetBuffer(AudioChunk&& aBuffer);
+ void SetReverb(WebCore::Reverb* aReverb, uint32_t aImpulseChannelCount);
+ // This sends a single event to the timeline on the MTG thread side.
+ void SendTimelineEvent(uint32_t aIndex, const dom::AudioParamEvent& aEvent);
+ // This consumes the contents of aData. aData will be emptied after this
+ // returns.
+ void SetRawArrayData(nsTArray<float>&& aData);
+ void SetChannelMixingParameters(uint32_t aNumberOfChannels,
+ ChannelCountMode aChannelCountMoe,
+ ChannelInterpretation aChannelInterpretation);
+ void SetPassThrough(bool aPassThrough);
+ void SendRunnable(already_AddRefed<nsIRunnable> aRunnable);
+ ChannelInterpretation GetChannelInterpretation() {
+ return mChannelInterpretation;
+ }
+
+ void SetAudioParamHelperTrack() {
+ MOZ_ASSERT(!mAudioParamTrack, "Can only do this once");
+ mAudioParamTrack = true;
+ }
+ // The value for channelCount on an AudioNode, but on the audio thread side.
+ uint32_t NumberOfChannels() const override;
+
+ /*
+ * Resume track after updating its concept of current time by aAdvance.
+ * Main thread. Used only from AudioDestinationNode when resuming a track
+ * suspended to save running the MediaTrackGraph when there are no other
+ * nodes in the AudioContext.
+ */
+ void AdvanceAndResume(TrackTime aAdvance);
+
+ AudioNodeTrack* AsAudioNodeTrack() override { return this; }
+ void AddInput(MediaInputPort* aPort) override;
+ void RemoveInput(MediaInputPort* aPort) override;
+
+ // Graph thread only
+ void SetTrackTimeParameterImpl(uint32_t aIndex, MediaTrack* aRelativeToTrack,
+ double aTrackTime);
+ void SetChannelMixingParametersImpl(
+ uint32_t aNumberOfChannels, ChannelCountMode aChannelCountMoe,
+ ChannelInterpretation aChannelInterpretation);
+ void ProcessInput(GraphTime aFrom, GraphTime aTo, uint32_t aFlags) override;
+ /**
+ * Produce the next block of output, before input is provided.
+ * ProcessInput() will be called later, and it then should not change
+ * the output. This is used only for DelayNodeEngine in a feedback loop.
+ */
+ void ProduceOutputBeforeInput(GraphTime aFrom);
+ bool IsAudioParamTrack() const { return mAudioParamTrack; }
+
+ const OutputChunks& LastChunks() const { return mLastChunks; }
+ bool MainThreadNeedsUpdates() const override {
+ return ((mFlags & NEED_MAIN_THREAD_ENDED) && mEnded) ||
+ (mFlags & NEED_MAIN_THREAD_CURRENT_TIME);
+ }
+
+ // Any thread
+ AudioNodeEngine* Engine() { return mEngine.get(); }
+
+ size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const override;
+ size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const override;
+
+ void SizeOfAudioNodesIncludingThis(MallocSizeOf aMallocSizeOf,
+ AudioNodeSizes& aUsage) const;
+
+ /*
+ * SetActive() is called when either an active input is added or the engine
+ * for a source node transitions from inactive to active. This is not
+ * called from engines for processing nodes because they only become active
+ * when there are active input tracks, in which case this track is already
+ * active.
+ */
+ void SetActive();
+ /*
+ * ScheduleCheckForInactive() is called during track processing when the
+ * engine transitions from active to inactive, or the track finishes. It
+ * schedules a call to CheckForInactive() after track processing.
+ */
+ void ScheduleCheckForInactive();
+
+ protected:
+ void OnGraphThreadDone() override;
+ void DestroyImpl() override;
+
+ /*
+ * CheckForInactive() is called when the engine transitions from active to
+ * inactive, or an active input is removed, or the track finishes. If the
+ * track is now inactive, then mInputChunks will be cleared and mLastChunks
+ * will be set to null. ProcessBlock() will not be called on the engine
+ * again until SetActive() is called.
+ */
+ void CheckForInactive();
+
+ void AdvanceOutputSegment();
+ void FinishOutput();
+ void AccumulateInputChunk(uint32_t aInputIndex, const AudioBlock& aChunk,
+ AudioBlock* aBlock,
+ DownmixBufferType* aDownmixBuffer);
+ void UpMixDownMixChunk(const AudioBlock* aChunk, uint32_t aOutputChannelCount,
+ nsTArray<const float*>& aOutputChannels,
+ DownmixBufferType& aDownmixBuffer);
+
+ uint32_t ComputedNumberOfChannels(uint32_t aInputChannelCount);
+ void ObtainInputBlock(AudioBlock& aTmpChunk, uint32_t aPortIndex);
+ void IncrementActiveInputCount();
+ void DecrementActiveInputCount();
+
+ // The engine that will generate output for this node.
+ const UniquePtr<AudioNodeEngine> mEngine;
+ // The mixed input blocks are kept from iteration to iteration to avoid
+ // reallocating channel data arrays and any buffers for mixing.
+ OutputChunks mInputChunks;
+ // The last block produced by this node.
+ OutputChunks mLastChunks;
+ // Whether this is an internal or external track
+ const Flags mFlags;
+ // The number of input tracks that may provide non-silent input.
+ uint32_t mActiveInputCount = 0;
+ // The number of input channels that this track requires. 0 means don't care.
+ uint32_t mNumberOfInputChannels;
+ // The mixing modes
+ ChannelCountMode mChannelCountMode;
+ ChannelInterpretation mChannelInterpretation;
+ // Tracks are considered active if the track has not finished and either
+ // the engine is active or there are active input tracks.
+ bool mIsActive;
+ // Whether the track should be marked as ended as soon
+ // as the current time range has been computed block by block.
+ bool mMarkAsEndedAfterThisBlock;
+ // Whether the track is an AudioParamHelper track.
+ bool mAudioParamTrack;
+ // Whether the track just passes its input through.
+ bool mPassThrough;
+};
+
+} // namespace mozilla
+
+#endif /* MOZILLA_AUDIONODETRACK_H_ */