summaryrefslogtreecommitdiffstats
path: root/dom/media/MediaStreamGraphImpl.h
diff options
context:
space:
mode:
Diffstat (limited to 'dom/media/MediaStreamGraphImpl.h')
-rw-r--r--dom/media/MediaStreamGraphImpl.h863
1 files changed, 863 insertions, 0 deletions
diff --git a/dom/media/MediaStreamGraphImpl.h b/dom/media/MediaStreamGraphImpl.h
new file mode 100644
index 000000000..c71975493
--- /dev/null
+++ b/dom/media/MediaStreamGraphImpl.h
@@ -0,0 +1,863 @@
+/* -*- 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_MEDIASTREAMGRAPHIMPL_H_
+#define MOZILLA_MEDIASTREAMGRAPHIMPL_H_
+
+#include "MediaStreamGraph.h"
+
+#include "nsDataHashtable.h"
+
+#include "nsITimer.h"
+#include "mozilla/Monitor.h"
+#include "mozilla/TimeStamp.h"
+#include "nsIMemoryReporter.h"
+#include "nsIThread.h"
+#include "nsIRunnable.h"
+#include "nsIAsyncShutdown.h"
+#include "Latency.h"
+#include "mozilla/Services.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/WeakPtr.h"
+#include "GraphDriver.h"
+#include "AudioMixer.h"
+
+namespace mozilla {
+
+template <typename T>
+class LinkedList;
+#ifdef MOZ_WEBRTC
+class AudioOutputObserver;
+#endif
+
+/**
+ * A per-stream update message passed from the media graph thread to the
+ * main thread.
+ */
+struct StreamUpdate
+{
+ RefPtr<MediaStream> mStream;
+ StreamTime mNextMainThreadCurrentTime;
+ bool mNextMainThreadFinished;
+};
+
+/**
+ * This represents a message run on the graph thread to modify stream or graph
+ * state. These are passed from main thread to graph thread through
+ * AppendMessage(), or scheduled on the graph thread with
+ * RunMessageAfterProcessing(). A ControlMessage
+ * always has a weak reference to a particular affected stream.
+ */
+class ControlMessage
+{
+public:
+ explicit ControlMessage(MediaStream* aStream) : mStream(aStream)
+ {
+ MOZ_COUNT_CTOR(ControlMessage);
+ }
+ // All these run on the graph thread
+ virtual ~ControlMessage()
+ {
+ MOZ_COUNT_DTOR(ControlMessage);
+ }
+ // Do the action of this message on the MediaStreamGraph thread. Any actions
+ // affecting graph processing should take effect at mProcessedTime.
+ // All stream data for times < mProcessedTime has already been
+ // computed.
+ virtual void Run() = 0;
+ // RunDuringShutdown() is only relevant to messages generated on the main
+ // thread (for AppendMessage()).
+ // When we're shutting down the application, most messages are ignored but
+ // some cleanup messages should still be processed (on the main thread).
+ // This must not add new control messages to the graph.
+ virtual void RunDuringShutdown() {}
+ MediaStream* GetStream() { return mStream; }
+
+protected:
+ // We do not hold a reference to mStream. The graph will be holding
+ // a reference to the stream until the Destroy message is processed. The
+ // last message referencing a stream is the Destroy message for that stream.
+ MediaStream* mStream;
+};
+
+class MessageBlock
+{
+public:
+ nsTArray<UniquePtr<ControlMessage>> mMessages;
+};
+
+/**
+ * The implementation of a media stream graph. This class is private to this
+ * file. It's not in the anonymous namespace because MediaStream needs to
+ * be able to friend it.
+ *
+ * There can be multiple MediaStreamGraph per process: one per AudioChannel.
+ * Additionaly, each OfflineAudioContext object creates its own MediaStreamGraph
+ * object too.
+ */
+class MediaStreamGraphImpl : public MediaStreamGraph,
+ public nsIMemoryReporter,
+ public nsITimerCallback
+{
+public:
+ NS_DECL_THREADSAFE_ISUPPORTS
+ NS_DECL_NSIMEMORYREPORTER
+ NS_DECL_NSITIMERCALLBACK
+
+ /**
+ * Use aGraphDriverRequested with SYSTEM_THREAD_DRIVER or AUDIO_THREAD_DRIVER
+ * to create a MediaStreamGraph which provides support for real-time audio
+ * and/or video. Set it to OFFLINE_THREAD_DRIVER in order to create a
+ * non-realtime instance which just churns through its inputs and produces
+ * output. Those objects currently only support audio, and are used to
+ * implement OfflineAudioContext. They do not support MediaStream inputs.
+ */
+ explicit MediaStreamGraphImpl(GraphDriverType aGraphDriverRequested,
+ TrackRate aSampleRate,
+ dom::AudioChannel aChannel);
+
+ /**
+ * Unregisters memory reporting and deletes this instance. This should be
+ * called instead of calling the destructor directly.
+ */
+ void Destroy();
+
+ // Main thread only.
+ /**
+ * This runs every time we need to sync state from the media graph thread
+ * to the main thread while the main thread is not in the middle
+ * of a script. It runs during a "stable state" (per HTML5) or during
+ * an event posted to the main thread.
+ * The boolean affects which boolean controlling runnable dispatch is cleared
+ */
+ void RunInStableState(bool aSourceIsMSG);
+ /**
+ * Ensure a runnable to run RunInStableState is posted to the appshell to
+ * run at the next stable state (per HTML5).
+ * See EnsureStableStateEventPosted.
+ */
+ void EnsureRunInStableState();
+ /**
+ * Called to apply a StreamUpdate to its stream.
+ */
+ void ApplyStreamUpdate(StreamUpdate* aUpdate);
+ /**
+ * Append a ControlMessage to the message queue. This queue is drained
+ * during RunInStableState; the messages will run on the graph thread.
+ */
+ void AppendMessage(UniquePtr<ControlMessage> aMessage);
+
+ // Shutdown helpers.
+
+ static already_AddRefed<nsIAsyncShutdownClient>
+ GetShutdownBarrier()
+ {
+ nsCOMPtr<nsIAsyncShutdownService> svc = services::GetAsyncShutdown();
+ MOZ_RELEASE_ASSERT(svc);
+
+ nsCOMPtr<nsIAsyncShutdownClient> barrier;
+ nsresult rv = svc->GetProfileBeforeChange(getter_AddRefs(barrier));
+ if (!barrier) {
+ // We are probably in a content process. We need to do cleanup at
+ // XPCOM shutdown in leakchecking builds.
+ rv = svc->GetXpcomWillShutdown(getter_AddRefs(barrier));
+ }
+ MOZ_RELEASE_ASSERT(NS_SUCCEEDED(rv));
+ MOZ_RELEASE_ASSERT(barrier);
+ return barrier.forget();
+ }
+
+ class ShutdownTicket final
+ {
+ public:
+ explicit ShutdownTicket(nsIAsyncShutdownBlocker* aBlocker) : mBlocker(aBlocker) {}
+ NS_INLINE_DECL_REFCOUNTING(ShutdownTicket)
+ private:
+ ~ShutdownTicket()
+ {
+ nsCOMPtr<nsIAsyncShutdownClient> barrier = GetShutdownBarrier();
+ barrier->RemoveBlocker(mBlocker);
+ }
+
+ nsCOMPtr<nsIAsyncShutdownBlocker> mBlocker;
+ };
+
+ /**
+ * Make this MediaStreamGraph enter forced-shutdown state. This state
+ * will be noticed by the media graph thread, which will shut down all streams
+ * and other state controlled by the media graph thread.
+ * This is called during application shutdown.
+ */
+ void ForceShutDown(ShutdownTicket* aShutdownTicket);
+
+ /**
+ * Called before the thread runs.
+ */
+ void Init();
+
+ /**
+ * Respond to CollectReports with sizes collected on the graph thread.
+ */
+ static void
+ FinishCollectReports(nsIHandleReportCallback* aHandleReport,
+ nsISupports* aData,
+ const nsTArray<AudioNodeSizes>& aAudioStreamSizes);
+
+ // The following methods run on the graph thread (or possibly the main thread
+ // if mLifecycleState > LIFECYCLE_RUNNING)
+ void CollectSizesForMemoryReport(
+ already_AddRefed<nsIHandleReportCallback> aHandleReport,
+ already_AddRefed<nsISupports> aHandlerData);
+
+ /**
+ * Returns true if this MediaStreamGraph should keep running
+ */
+ bool UpdateMainThreadState();
+
+ /**
+ * Returns true if this MediaStreamGraph should keep running
+ */
+ bool OneIteration(GraphTime aStateEnd);
+
+ /**
+ * Called from the driver, when the graph thread is about to stop, to tell
+ * the main thread to attempt to begin cleanup. The main thread may either
+ * shutdown or revive the graph depending on whether it receives new
+ * messages.
+ */
+ void SignalMainThreadCleanup();
+
+ bool Running() const
+ {
+ mMonitor.AssertCurrentThreadOwns();
+ return mLifecycleState == LIFECYCLE_RUNNING;
+ }
+
+ /* This is the end of the current iteration, that is, the current time of the
+ * graph. */
+ GraphTime IterationEnd() const;
+
+ /**
+ * Ensure there is an event posted to the main thread to run RunInStableState.
+ * mMonitor must be held.
+ * See EnsureRunInStableState
+ */
+ void EnsureStableStateEventPosted();
+ /**
+ * Generate messages to the main thread to update it for all state changes.
+ * mMonitor must be held.
+ */
+ void PrepareUpdatesToMainThreadState(bool aFinalUpdate);
+ /**
+ * Returns false if there is any stream that has finished but not yet finished
+ * playing out.
+ */
+ bool AllFinishedStreamsNotified();
+ /**
+ * If we are rendering in non-realtime mode, we don't want to send messages to
+ * the main thread at each iteration for performance reasons. We instead
+ * notify the main thread at the same rate
+ */
+ bool ShouldUpdateMainThread();
+ // The following methods are the various stages of RunThread processing.
+ /**
+ * Advance all stream state to mStateComputedTime.
+ */
+ void UpdateCurrentTimeForStreams(GraphTime aPrevCurrentTime);
+ /**
+ * Process chunks for all streams and raise events for properties that have
+ * changed, such as principalId.
+ */
+ void ProcessChunkMetadata(GraphTime aPrevCurrentTime);
+ /**
+ * Process chunks for the given stream and interval, and raise events for
+ * properties that have changed, such as principalId.
+ */
+ template<typename C, typename Chunk>
+ void ProcessChunkMetadataForInterval(MediaStream* aStream,
+ TrackID aTrackID,
+ C& aSegment,
+ StreamTime aStart,
+ StreamTime aEnd);
+ /**
+ * Process graph messages in mFrontMessageQueue.
+ */
+ void RunMessagesInQueue();
+ /**
+ * Update stream processing order and recompute stream blocking until
+ * aEndBlockingDecisions.
+ */
+ void UpdateGraph(GraphTime aEndBlockingDecisions);
+
+ void SwapMessageQueues()
+ {
+ MOZ_ASSERT(CurrentDriver()->OnThread());
+ MOZ_ASSERT(mFrontMessageQueue.IsEmpty());
+ mMonitor.AssertCurrentThreadOwns();
+ mFrontMessageQueue.SwapElements(mBackMessageQueue);
+ }
+ /**
+ * Do all the processing and play the audio and video, from
+ * mProcessedTime to mStateComputedTime.
+ */
+ void Process();
+ /**
+ * Extract any state updates pending in aStream, and apply them.
+ */
+ void ExtractPendingInput(SourceMediaStream* aStream,
+ GraphTime aDesiredUpToTime,
+ bool* aEnsureNextIteration);
+
+ /**
+ * For use during ProcessedMediaStream::ProcessInput() or
+ * MediaStreamListener callbacks, when graph state cannot be changed.
+ * Schedules |aMessage| to run after processing, at a time when graph state
+ * can be changed. Graph thread.
+ */
+ void RunMessageAfterProcessing(UniquePtr<ControlMessage> aMessage);
+
+ /**
+ * Called when a suspend/resume/close operation has been completed, on the
+ * graph thread.
+ */
+ void AudioContextOperationCompleted(MediaStream* aStream,
+ void* aPromise,
+ dom::AudioContextOperation aOperation);
+
+ /**
+ * Apply and AudioContext operation (suspend/resume/closed), on the graph
+ * thread.
+ */
+ void ApplyAudioContextOperationImpl(MediaStream* aDestinationStream,
+ const nsTArray<MediaStream*>& aStreams,
+ dom::AudioContextOperation aOperation,
+ void* aPromise);
+
+ /**
+ * Increment suspend count on aStream and move it to mSuspendedStreams if
+ * necessary.
+ */
+ void IncrementSuspendCount(MediaStream* aStream);
+ /**
+ * Increment suspend count on aStream and move it to mStreams if
+ * necessary.
+ */
+ void DecrementSuspendCount(MediaStream* aStream);
+
+ /*
+ * Move streams from the mStreams to mSuspendedStream if suspending/closing an
+ * AudioContext, or the inverse when resuming an AudioContext.
+ */
+ void SuspendOrResumeStreams(dom::AudioContextOperation aAudioContextOperation,
+ const nsTArray<MediaStream*>& aStreamSet);
+
+ /**
+ * Determine if we have any audio tracks, or are about to add any audiotracks.
+ * Also checks if we'll need the AEC running (i.e. microphone input tracks)
+ */
+ bool AudioTrackPresent(bool& aNeedsAEC);
+
+ /**
+ * Sort mStreams so that every stream not in a cycle is after any streams
+ * it depends on, and every stream in a cycle is marked as being in a cycle.
+ * Also sets mIsConsumed on every stream.
+ */
+ void UpdateStreamOrder();
+
+ /**
+ * Returns smallest value of t such that t is a multiple of
+ * WEBAUDIO_BLOCK_SIZE and t > aTime.
+ */
+ GraphTime RoundUpToNextAudioBlock(GraphTime aTime);
+ /**
+ * Produce data for all streams >= aStreamIndex for the current time interval.
+ * Advances block by block, each iteration producing data for all streams
+ * for a single block.
+ * This is called whenever we have an AudioNodeStream in the graph.
+ */
+ void ProduceDataForStreamsBlockByBlock(uint32_t aStreamIndex,
+ TrackRate aSampleRate);
+ /**
+ * If aStream will underrun between aTime, and aEndBlockingDecisions, returns
+ * the time at which the underrun will start. Otherwise return
+ * aEndBlockingDecisions.
+ */
+ GraphTime WillUnderrun(MediaStream* aStream, GraphTime aEndBlockingDecisions);
+
+ /**
+ * Given a graph time aTime, convert it to a stream time taking into
+ * account the time during which aStream is scheduled to be blocked.
+ */
+ StreamTime GraphTimeToStreamTimeWithBlocking(MediaStream* aStream, GraphTime aTime);
+
+ /**
+ * Call NotifyHaveCurrentData on aStream's listeners.
+ */
+ void NotifyHasCurrentData(MediaStream* aStream);
+ /**
+ * If aStream needs an audio stream but doesn't have one, create it.
+ * If aStream doesn't need an audio stream but has one, destroy it.
+ */
+ void CreateOrDestroyAudioStreams(MediaStream* aStream);
+ /**
+ * Queue audio (mix of stream audio and silence for blocked intervals)
+ * to the audio output stream. Returns the number of frames played.
+ */
+ StreamTime PlayAudio(MediaStream* aStream);
+ /**
+ * No more data will be forthcoming for aStream. The stream will end
+ * at the current buffer end point. The StreamTracks's tracks must be
+ * explicitly set to finished by the caller.
+ */
+ void OpenAudioInputImpl(int aID,
+ AudioDataListener *aListener);
+ virtual nsresult OpenAudioInput(int aID,
+ AudioDataListener *aListener) override;
+ void CloseAudioInputImpl(AudioDataListener *aListener);
+ virtual void CloseAudioInput(AudioDataListener *aListener) override;
+
+ void FinishStream(MediaStream* aStream);
+ /**
+ * Compute how much stream data we would like to buffer for aStream.
+ */
+ StreamTime GetDesiredBufferEnd(MediaStream* aStream);
+ /**
+ * Returns true when there are no active streams.
+ */
+ bool IsEmpty() const
+ {
+ return mStreams.IsEmpty() && mSuspendedStreams.IsEmpty() && mPortCount == 0;
+ }
+
+ /**
+ * Add aStream to the graph and initializes its graph-specific state.
+ */
+ void AddStreamGraphThread(MediaStream* aStream);
+ /**
+ * Remove aStream from the graph. Ensures that pending messages about the
+ * stream back to the main thread are flushed.
+ */
+ void RemoveStreamGraphThread(MediaStream* aStream);
+ /**
+ * Remove aPort from the graph and release it.
+ */
+ void DestroyPort(MediaInputPort* aPort);
+ /**
+ * Mark the media stream order as dirty.
+ */
+ void SetStreamOrderDirty()
+ {
+ mStreamOrderDirty = true;
+ }
+
+ // Always stereo for now.
+ uint32_t AudioChannelCount() const { return 2; }
+
+ double MediaTimeToSeconds(GraphTime aTime) const
+ {
+ NS_ASSERTION(aTime > -STREAM_TIME_MAX && aTime <= STREAM_TIME_MAX,
+ "Bad time");
+ return static_cast<double>(aTime)/GraphRate();
+ }
+
+ GraphTime SecondsToMediaTime(double aS) const
+ {
+ NS_ASSERTION(0 <= aS && aS <= TRACK_TICKS_MAX/TRACK_RATE_MAX,
+ "Bad seconds");
+ return GraphRate() * aS;
+ }
+
+ GraphTime MillisecondsToMediaTime(int32_t aMS) const
+ {
+ return RateConvertTicksRoundDown(GraphRate(), 1000, aMS);
+ }
+
+ /**
+ * Signal to the graph that the thread has paused indefinitly,
+ * or resumed.
+ */
+ void PausedIndefinitly();
+ void ResumedFromPaused();
+
+ /**
+ * Not safe to call off the MediaStreamGraph thread unless monitor is held!
+ */
+ GraphDriver* CurrentDriver() const
+ {
+ AssertOnGraphThreadOrNotRunning();
+ return mDriver;
+ }
+
+ bool RemoveMixerCallback(MixerCallbackReceiver* aReceiver)
+ {
+ return mMixer.RemoveCallback(aReceiver);
+ }
+
+ /**
+ * Effectively set the new driver, while we are switching.
+ * It is only safe to call this at the very end of an iteration, when there
+ * has been a SwitchAtNextIteration call during the iteration. The driver
+ * should return and pass the control to the new driver shortly after.
+ * We can also switch from Revive() (on MainThread), in which case the
+ * monitor is held
+ */
+ void SetCurrentDriver(GraphDriver* aDriver)
+ {
+ AssertOnGraphThreadOrNotRunning();
+ mDriver = aDriver;
+ }
+
+ Monitor& GetMonitor()
+ {
+ return mMonitor;
+ }
+
+ void EnsureNextIteration()
+ {
+ mNeedAnotherIteration = true; // atomic
+ // Note: GraphDriver must ensure that there's no race on setting
+ // mNeedAnotherIteration and mGraphDriverAsleep -- see WaitForNextIteration()
+ if (mGraphDriverAsleep) { // atomic
+ MonitorAutoLock mon(mMonitor);
+ CurrentDriver()->WakeUp(); // Might not be the same driver; might have woken already
+ }
+ }
+
+ void EnsureNextIterationLocked()
+ {
+ mNeedAnotherIteration = true; // atomic
+ if (mGraphDriverAsleep) { // atomic
+ CurrentDriver()->WakeUp(); // Might not be the same driver; might have woken already
+ }
+ }
+
+ // Capture Stream API. This allows to get a mixed-down output for a window.
+ void RegisterCaptureStreamForWindow(uint64_t aWindowId,
+ ProcessedMediaStream* aCaptureStream);
+ void UnregisterCaptureStreamForWindow(uint64_t aWindowId);
+ already_AddRefed<MediaInputPort>
+ ConnectToCaptureStream(uint64_t aWindowId, MediaStream* aMediaStream);
+
+ class StreamSet {
+ public:
+ class iterator {
+ public:
+ explicit iterator(MediaStreamGraphImpl& aGraph)
+ : mGraph(&aGraph), mArrayNum(-1), mArrayIndex(0)
+ {
+ ++(*this);
+ }
+ iterator() : mGraph(nullptr), mArrayNum(2), mArrayIndex(0) {}
+ MediaStream* operator*()
+ {
+ return Array()->ElementAt(mArrayIndex);
+ }
+ iterator operator++()
+ {
+ ++mArrayIndex;
+ while (mArrayNum < 2 &&
+ (mArrayNum < 0 || mArrayIndex >= Array()->Length())) {
+ ++mArrayNum;
+ mArrayIndex = 0;
+ }
+ return *this;
+ }
+ bool operator==(const iterator& aOther) const
+ {
+ return mArrayNum == aOther.mArrayNum && mArrayIndex == aOther.mArrayIndex;
+ }
+ bool operator!=(const iterator& aOther) const
+ {
+ return !(*this == aOther);
+ }
+ private:
+ nsTArray<MediaStream*>* Array()
+ {
+ return mArrayNum == 0 ? &mGraph->mStreams : &mGraph->mSuspendedStreams;
+ }
+ MediaStreamGraphImpl* mGraph;
+ int mArrayNum;
+ uint32_t mArrayIndex;
+ };
+
+ explicit StreamSet(MediaStreamGraphImpl& aGraph) : mGraph(aGraph) {}
+ iterator begin() { return iterator(mGraph); }
+ iterator end() { return iterator(); }
+ private:
+ MediaStreamGraphImpl& mGraph;
+ };
+ StreamSet AllStreams() { return StreamSet(*this); }
+
+ // Data members
+ //
+ /**
+ * Graphs own owning references to their driver, until shutdown. When a driver
+ * switch occur, previous driver is either deleted, or it's ownership is
+ * passed to a event that will take care of the asynchronous cleanup, as
+ * audio stream can take some time to shut down.
+ */
+ RefPtr<GraphDriver> mDriver;
+
+ // The following state is managed on the graph thread only, unless
+ // mLifecycleState > LIFECYCLE_RUNNING in which case the graph thread
+ // is not running and this state can be used from the main thread.
+
+ /**
+ * The graph keeps a reference to each stream.
+ * References are maintained manually to simplify reordering without
+ * unnecessary thread-safe refcount changes.
+ */
+ nsTArray<MediaStream*> mStreams;
+ /**
+ * This stores MediaStreams that are part of suspended AudioContexts.
+ * mStreams and mSuspendStream are disjoint sets: a stream is either suspended
+ * or not suspended. Suspended streams are not ordered in UpdateStreamOrder,
+ * and are therefore not doing any processing.
+ */
+ nsTArray<MediaStream*> mSuspendedStreams;
+ /**
+ * Suspended AudioContext IDs
+ */
+ nsTHashtable<nsUint64HashKey> mSuspendedContexts;
+ /**
+ * Streams from mFirstCycleBreaker to the end of mStreams produce output
+ * before they receive input. They correspond to DelayNodes that are in
+ * cycles.
+ */
+ uint32_t mFirstCycleBreaker;
+ /**
+ * Blocking decisions have been computed up to this time.
+ * Between each iteration, this is the same as mProcessedTime.
+ */
+ GraphTime mStateComputedTime = 0;
+ /**
+ * All stream contents have been computed up to this time.
+ * The next batch of updates from the main thread will be processed
+ * at this time. This is behind mStateComputedTime during processing.
+ */
+ GraphTime mProcessedTime = 0;
+ /**
+ * Date of the last time we updated the main thread with the graph state.
+ */
+ TimeStamp mLastMainThreadUpdate;
+ /**
+ * Number of active MediaInputPorts
+ */
+ int32_t mPortCount;
+
+ /**
+ * Devices to use for cubeb input & output, or NULL for no input (void*),
+ * and boolean to control if we want input/output
+ */
+ bool mInputWanted;
+ int mInputDeviceID;
+ bool mOutputWanted;
+ int mOutputDeviceID;
+ // Maps AudioDataListeners to a usecount of streams using the listener
+ // so we can know when it's no longer in use.
+ nsDataHashtable<nsPtrHashKey<AudioDataListener>, uint32_t> mInputDeviceUsers;
+
+ // True if the graph needs another iteration after the current iteration.
+ Atomic<bool> mNeedAnotherIteration;
+ // GraphDriver may need a WakeUp() if something changes
+ Atomic<bool> mGraphDriverAsleep;
+
+ // mMonitor guards the data below.
+ // MediaStreamGraph normally does its work without holding mMonitor, so it is
+ // not safe to just grab mMonitor from some thread and start monkeying with
+ // the graph. Instead, communicate with the graph thread using provided
+ // mechanisms such as the ControlMessage queue.
+ Monitor mMonitor;
+
+ // Data guarded by mMonitor (must always be accessed with mMonitor held,
+ // regardless of the value of mLifecycleState).
+
+ /**
+ * State to copy to main thread
+ */
+ nsTArray<StreamUpdate> mStreamUpdates;
+ /**
+ * Runnables to run after the next update to main thread state.
+ */
+ nsTArray<nsCOMPtr<nsIRunnable> > mUpdateRunnables;
+ /**
+ * A list of batches of messages to process. Each batch is processed
+ * as an atomic unit.
+ */
+ /*
+ * Message queue processed by the MSG thread during an iteration.
+ * Accessed on graph thread only.
+ */
+ nsTArray<MessageBlock> mFrontMessageQueue;
+ /*
+ * Message queue in which the main thread appends messages.
+ * Access guarded by mMonitor.
+ */
+ nsTArray<MessageBlock> mBackMessageQueue;
+
+ /* True if there will messages to process if we swap the message queues. */
+ bool MessagesQueued() const
+ {
+ mMonitor.AssertCurrentThreadOwns();
+ return !mBackMessageQueue.IsEmpty();
+ }
+ /**
+ * This enum specifies where this graph is in its lifecycle. This is used
+ * to control shutdown.
+ * Shutdown is tricky because it can happen in two different ways:
+ * 1) Shutdown due to inactivity. RunThread() detects that it has no
+ * pending messages and no streams, and exits. The next RunInStableState()
+ * checks if there are new pending messages from the main thread (true only
+ * if new stream creation raced with shutdown); if there are, it revives
+ * RunThread(), otherwise it commits to shutting down the graph. New stream
+ * creation after this point will create a new graph. An async event is
+ * dispatched to Shutdown() the graph's threads and then delete the graph
+ * object.
+ * 2) Forced shutdown at application shutdown, or completion of a
+ * non-realtime graph. A flag is set, RunThread() detects the flag and
+ * exits, the next RunInStableState() detects the flag, and dispatches the
+ * async event to Shutdown() the graph's threads. However the graph object
+ * is not deleted. New messages for the graph are processed synchronously on
+ * the main thread if necessary. When the last stream is destroyed, the
+ * graph object is deleted.
+ *
+ * This should be kept in sync with the LifecycleState_str array in
+ * MediaStreamGraph.cpp
+ */
+ enum LifecycleState
+ {
+ // The graph thread hasn't started yet.
+ LIFECYCLE_THREAD_NOT_STARTED,
+ // RunThread() is running normally.
+ LIFECYCLE_RUNNING,
+ // In the following states, the graph thread is not running so
+ // all "graph thread only" state in this class can be used safely
+ // on the main thread.
+ // RunThread() has exited and we're waiting for the next
+ // RunInStableState(), at which point we can clean up the main-thread
+ // side of the graph.
+ LIFECYCLE_WAITING_FOR_MAIN_THREAD_CLEANUP,
+ // RunInStableState() posted a ShutdownRunnable, and we're waiting for it
+ // to shut down the graph thread(s).
+ LIFECYCLE_WAITING_FOR_THREAD_SHUTDOWN,
+ // Graph threads have shut down but we're waiting for remaining streams
+ // to be destroyed. Only happens during application shutdown and on
+ // completed non-realtime graphs, since normally we'd only shut down a
+ // realtime graph when it has no streams.
+ LIFECYCLE_WAITING_FOR_STREAM_DESTRUCTION
+ };
+ /**
+ * Modified only in mMonitor. Transitions to
+ * LIFECYCLE_WAITING_FOR_MAIN_THREAD_CLEANUP occur on the graph thread at
+ * the end of an iteration. All other transitions occur on the main thread.
+ */
+ LifecycleState mLifecycleState;
+ /**
+ * The graph should stop processing at or after this time.
+ */
+ GraphTime mEndTime;
+
+ /**
+ * True when we need to do a forced shutdown during application shutdown.
+ */
+ bool mForceShutDown;
+
+ /**
+ * Drop this reference during shutdown to unblock shutdown.
+ **/
+ RefPtr<ShutdownTicket> mForceShutdownTicket;
+
+ /**
+ * True when we have posted an event to the main thread to run
+ * RunInStableState() and the event hasn't run yet.
+ */
+ bool mPostedRunInStableStateEvent;
+
+ // Main thread only
+
+ /**
+ * Messages posted by the current event loop task. These are forwarded to
+ * the media graph thread during RunInStableState. We can't forward them
+ * immediately because we want all messages between stable states to be
+ * processed as an atomic batch.
+ */
+ nsTArray<UniquePtr<ControlMessage>> mCurrentTaskMessageQueue;
+ /**
+ * True when RunInStableState has determined that mLifecycleState is >
+ * LIFECYCLE_RUNNING. Since only the main thread can reset mLifecycleState to
+ * LIFECYCLE_RUNNING, this can be relied on to not change unexpectedly.
+ */
+ bool mDetectedNotRunning;
+ /**
+ * True when a stable state runner has been posted to the appshell to run
+ * RunInStableState at the next stable state.
+ */
+ bool mPostedRunInStableState;
+ /**
+ * True when processing real-time audio/video. False when processing non-realtime
+ * audio.
+ */
+ bool mRealtime;
+ /**
+ * True when a non-realtime MediaStreamGraph has started to process input. This
+ * value is only accessed on the main thread.
+ */
+ bool mNonRealtimeProcessing;
+ /**
+ * True when a change has happened which requires us to recompute the stream
+ * blocking order.
+ */
+ bool mStreamOrderDirty;
+ /**
+ * Hold a ref to the Latency logger
+ */
+ RefPtr<AsyncLatencyLogger> mLatencyLog;
+ AudioMixer mMixer;
+#ifdef MOZ_WEBRTC
+ RefPtr<AudioOutputObserver> mFarendObserverRef;
+#endif
+
+ dom::AudioChannel AudioChannel() const { return mAudioChannel; }
+
+ // used to limit graph shutdown time
+ nsCOMPtr<nsITimer> mShutdownTimer;
+
+private:
+ virtual ~MediaStreamGraphImpl();
+
+ MOZ_DEFINE_MALLOC_SIZE_OF(MallocSizeOf)
+
+ /**
+ * This class uses manual memory management, and all pointers to it are raw
+ * pointers. However, in order for it to implement nsIMemoryReporter, it needs
+ * to implement nsISupports and so be ref-counted. So it maintains a single
+ * nsRefPtr to itself, giving it a ref-count of 1 during its entire lifetime,
+ * and Destroy() nulls this self-reference in order to trigger self-deletion.
+ */
+ RefPtr<MediaStreamGraphImpl> mSelfRef;
+
+ struct WindowAndStream
+ {
+ uint64_t mWindowId;
+ RefPtr<ProcessedMediaStream> mCaptureStreamSink;
+ };
+ /**
+ * Stream for window audio capture.
+ */
+ nsTArray<WindowAndStream> mWindowCaptureStreams;
+
+#ifdef DEBUG
+ /**
+ * Used to assert when AppendMessage() runs ControlMessages synchronously.
+ */
+ bool mCanRunMessagesSynchronously;
+#endif
+
+ dom::AudioChannel mAudioChannel;
+};
+
+} // namespace mozilla
+
+#endif /* MEDIASTREAMGRAPHIMPL_H_ */