diff -r 000000000000 -r 6474c204b198 content/media/webaudio/AudioNode.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/content/media/webaudio/AudioNode.h	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,274 @@
+/* -*- 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