The Tor Browser: comparison content/media/webaudio/AudioNode.h

--1:000000000000
+:7f64f4d4cbef
+/* -*- 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 AudioNode_h_
+#define AudioNode_h_
+#include "mozilla/DOMEventTargetHelper.h"
+#include "mozilla/dom/AudioNodeBinding.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsAutoPtr.h"
+#include "nsTArray.h"
+#include "AudioContext.h"
+#include "MediaStreamGraph.h"
+#include "WebAudioUtils.h"
+#include "mozilla/MemoryReporting.h"
+namespace mozilla {
+namespace dom {
+class AudioContext;
+class AudioBufferSourceNode;
+class AudioParam;
+class AudioParamTimeline;
+struct ThreeDPoint;
+template<class T>
+class SelfReference {
+public:
+SelfReference() : mHeld(false) {}
+~SelfReference()
+{
+NS_ASSERTION(!mHeld, "Forgot to drop the self reference?");
+}
+void Take(T* t)
+{
+if (!mHeld) {
+mHeld = true;
+t->AddRef();
+}
+}
+void Drop(T* t)
+{
+if (mHeld) {
+mHeld = false;
+t->Release();
+}
+}
+operator bool() const { return mHeld; }
+private:
+bool mHeld;
+};
+/**
+* The DOM object representing a Web Audio AudioNode.
+*
+* Each AudioNode has a MediaStream representing the actual
+* real-time processing and output of this AudioNode.
+*
+* We track the incoming and outgoing connections to other AudioNodes.
+* Outgoing connections have strong ownership.  Also, AudioNodes that will
+* produce sound on their output even when they have silent or no input ask
+* the AudioContext to keep playing or tail-time references to keep them alive
+* until the context is finished.
+*
+* Explicit disconnections will only remove references from output nodes after
+* the graph is notified and the main thread receives a reply.  Similarly,
+* nodes with playing or tail-time references release these references only
+* after receiving notification from their engine on the graph thread that
+* playing has stopped.  Engines notifying the main thread that they have
+* finished do so strictly *after* producing and returning their last block.
+* In this way, an engine that receives non-null input knows that the input
+* comes from nodes that are still alive and will keep their output nodes
+* alive for at least as long as it takes to process messages from the graph
+* thread.  i.e. the engine receiving non-null input knows that its node is
+* still alive, and will still be alive when it receives a message from the
+* engine.
+*/
+class AudioNode : public DOMEventTargetHelper
+{
+protected:
+// You can only use refcounting to delete this object
+virtual ~AudioNode();
+public:
+AudioNode(AudioContext* aContext,
+uint32_t aChannelCount,
+ChannelCountMode aChannelCountMode,
+ChannelInterpretation aChannelInterpretation);
+// This should be idempotent (safe to call multiple times).
+virtual void DestroyMediaStream();
+NS_DECL_ISUPPORTS_INHERITED
+NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(AudioNode,
+DOMEventTargetHelper)
+virtual AudioBufferSourceNode* AsAudioBufferSourceNode() {
+return nullptr;
+}
+virtual const DelayNode* AsDelayNode() const {
+return nullptr;
+}
+AudioContext* GetParentObject() const
+{
+return mContext;
+}
+AudioContext* Context() const
+{
+return mContext;
+}
+virtual void Connect(AudioNode& aDestination, uint32_t aOutput,
+uint32_t aInput, ErrorResult& aRv);
+virtual void Connect(AudioParam& aDestination, uint32_t aOutput,
+ErrorResult& aRv);
+virtual void Disconnect(uint32_t aOutput, ErrorResult& aRv);
+// The following two virtual methods must be implemented by each node type
+// to provide their number of input and output ports. These numbers are
+// constant for the lifetime of the node. Both default to 1.
+virtual uint16_t NumberOfInputs() const { return 1; }
+virtual uint16_t NumberOfOutputs() const { return 1; }
+uint32_t ChannelCount() const { return mChannelCount; }
+virtual void SetChannelCount(uint32_t aChannelCount, ErrorResult& aRv)
+{
+if (aChannelCount == 0 ||
+aChannelCount > WebAudioUtils::MaxChannelCount) {
+aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
+return;
+}
+mChannelCount = aChannelCount;
+SendChannelMixingParametersToStream();
+}
+ChannelCountMode ChannelCountModeValue() const
+{
+return mChannelCountMode;
+}
+virtual void SetChannelCountModeValue(ChannelCountMode aMode, ErrorResult& aRv)
+{
+mChannelCountMode = aMode;
+SendChannelMixingParametersToStream();
+}
+ChannelInterpretation ChannelInterpretationValue() const
+{
+return mChannelInterpretation;
+}
+void SetChannelInterpretationValue(ChannelInterpretation aMode)
+{
+mChannelInterpretation = aMode;
+SendChannelMixingParametersToStream();
+}
+struct InputNode {
+~InputNode()
+{
+if (mStreamPort) {
+mStreamPort->Destroy();
+}
+}
+size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const
+{
+size_t amount = 0;
+if (mStreamPort) {
+amount += mStreamPort->SizeOfIncludingThis(aMallocSizeOf);
+}
+return amount;
+}
+// Weak reference.
+AudioNode* mInputNode;
+nsRefPtr<MediaInputPort> mStreamPort;
+// The index of the input port this node feeds into.
+// This is not used for connections to AudioParams.
+uint32_t mInputPort;
+// The index of the output port this node comes out of.
+uint32_t mOutputPort;
+};
+MediaStream* Stream() { return mStream; }
+const nsTArray<InputNode>& InputNodes() const
+{
+return mInputNodes;
+}
+const nsTArray<nsRefPtr<AudioNode> >& OutputNodes() const
+{
+return mOutputNodes;
+}
+const nsTArray<nsRefPtr<AudioParam> >& OutputParams() const
+{
+return mOutputParams;
+}
+void RemoveOutputParam(AudioParam* aParam);
+// MarkActive() asks the context to keep the AudioNode alive until the
+// context is finished.  This takes care of "playing" references and
+// "tail-time" references.
+void MarkActive() { Context()->RegisterActiveNode(this); }
+// Active nodes call MarkInactive() when they have finished producing sound
+// for the foreseeable future.
+// Do not call MarkInactive from a node destructor.  If the destructor is
+// called, then the node is already inactive.
+// MarkInactive() may delete |this|.
+void MarkInactive() { Context()->UnregisterActiveNode(this); }
+virtual size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const;
+virtual size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const;
+virtual const char* NodeType() const = 0;
+private:
+friend class AudioBufferSourceNode;
+// This could possibly delete 'this'.
+void DisconnectFromGraph();
+protected:
+static void Callback(AudioNode* aNode) { /* not implemented */ }
+// Helpers for sending different value types to streams
+void SendDoubleParameterToStream(uint32_t aIndex, double aValue);
+void SendInt32ParameterToStream(uint32_t aIndex, int32_t aValue);
+void SendThreeDPointParameterToStream(uint32_t aIndex, const ThreeDPoint& aValue);
+void SendChannelMixingParametersToStream();
+static void SendTimelineParameterToStream(AudioNode* aNode, uint32_t aIndex,
+const AudioParamTimeline& aValue);
+private:
+nsRefPtr<AudioContext> mContext;
+protected:
+// Must be set in the constructor. Must not be null.
+// If MaxNumberOfInputs() is > 0, then mStream must be a ProcessedMediaStream.
+nsRefPtr<MediaStream> mStream;
+private:
+// For every InputNode, there is a corresponding entry in mOutputNodes of the
+// InputNode's mInputNode.
+nsTArray<InputNode> mInputNodes;
+// For every mOutputNode entry, there is a corresponding entry in mInputNodes
+// of the mOutputNode entry. We won't necessarily be able to identify the
+// exact matching entry, since mOutputNodes doesn't include the port
+// identifiers and the same node could be connected on multiple ports.
+nsTArray<nsRefPtr<AudioNode> > mOutputNodes;
+// For every mOutputParams entry, there is a corresponding entry in
+// AudioParam::mInputNodes of the mOutputParams entry. We won't necessarily be
+// able to identify the exact matching entry, since mOutputParams doesn't
+// include the port identifiers and the same node could be connected on
+// multiple ports.
+nsTArray<nsRefPtr<AudioParam> > mOutputParams;
+uint32_t mChannelCount;
+ChannelCountMode mChannelCountMode;
+ChannelInterpretation mChannelInterpretation;
+};
+}
+}
+#endif

The Tor Browser / file comparison

comparison: content/media/webaudio/AudioNode.h

content/media/webaudio/AudioNode.h