Implement tail processing for AudioNodes

third_party/WebKit/Source/modules/webaudio/AudioNode.h

 /*
  * Copyright (C) 2010, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1.  Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 19 matching lines @@
 #include "modules/EventTargetModules.h"
 #include "modules/ModulesExport.h"
 #include "platform/audio/AudioBus.h"
 #include "platform/audio/AudioUtilities.h"
 #include "platform/wtf/Forward.h"
 #include "platform/wtf/RefPtr.h"
 #include "platform/wtf/ThreadSafeRefCounted.h"
 #include "platform/wtf/Vector.h"
 #include "platform/wtf/build_config.h"
 
+// Higher values produce more debugging output.
 #define DEBUG_AUDIONODE_REFERENCES 0
 
 namespace blink {
 
 class BaseAudioContext;
 class AudioNode;
 class AudioNodeOptions;
 class AudioNodeInput;
 class AudioNodeOutput;
 class AudioParam;
@@ skipping 95 matching lines @@
   // Like process(), but only causes the automations to process; the
   // normal processing of the node is bypassed.  By default, we assume
   // no AudioParams need to be updated.
   virtual void ProcessOnlyAudioParams(size_t frames_to_process){};
 
   // No significant resources should be allocated until initialize() is called.
   // Processing may not occur until a node is initialized.
   virtual void Initialize();
   virtual void Uninitialize();
 
-  // Clear internal state when the node is disabled. When a node is disabled,
-  // it is no longer pulled so any internal state is never updated. But some
-  // nodes (DynamicsCompressorNode) have internal state that is still
-  // accessible by the user. Update the internal state as if the node were
-  // still connected but processing all zeroes. This gives a consistent view
-  // to the user.
-  virtual void ClearInternalStateWhenDisabled();
-
   bool IsInitialized() const { return is_initialized_; }
 
   unsigned NumberOfInputs() const { return inputs_.size(); }
   unsigned NumberOfOutputs() const { return outputs_.size(); }
 
   // Number of output channels.  This only matters for ScriptProcessorNodes.
   virtual unsigned NumberOfOutputChannels() const;
 
   // The argument must be less than numberOfInputs().
   AudioNodeInput& Input(unsigned);
   // The argument must be less than numberOfOutputs().
   AudioNodeOutput& Output(unsigned);
 
   // processIfNecessary() is called by our output(s) when the rendering graph
   // needs this AudioNode to process.  This method ensures that the AudioNode
   // will only process once per rendering time quantum even if it's called
   // repeatedly.  This handles the case of "fanout" where an output is connected
   // to multiple AudioNode inputs.  Called from context's audio thread.
   void ProcessIfNecessary(size_t frames_to_process);
 
   // Called when a new connection has been made to one of our inputs or the
   // connection number of channels has changed.  This potentially gives us
   // enough information to perform a lazy initialization or, if necessary, a
   // re-initialization.  Called from main thread.
   virtual void CheckNumberOfChannelsForInput(AudioNodeInput*);
 
 #if DEBUG_AUDIONODE_REFERENCES
   static void PrintNodeCounts();
 #endif
+#if DEBUG_AUDIONODE_REFERENCES > 1
+  void TailProcessingDebug(const char* note);
+  void AddTailProcessingDebug();
+  void RemoveTailProcessingDebug();
+#endif
+
+  // True if the node has a tail time or latency time that requires
+  // special tail processing to behave properly.  Ideally, this can be
+  // checked using TailTime and LatencyTime, but these aren't
+  // available on the main thread, and the tail processing check can
+  // happen on the main thread.
+  virtual bool RequiresTailProcessing() const = 0;
 
   // TailTime() is the length of time (not counting latency time) where
   // non-zero output may occur after continuous silent input.
   virtual double TailTime() const = 0;
 
   // LatencyTime() is the length of time it takes for non-zero output to
   // appear after non-zero input is provided. This only applies to processing
   // delay which is an artifact of the processing algorithm chosen and is
   // *not* part of the intrinsic desired effect. For example, a "delay" effect
   // is expected to delay the signal, and thus would not be considered
   // latency.
   virtual double LatencyTime() const = 0;
 
   // PropagatesSilence() should return true if the node will generate silent
   // output when given silent input. By default, AudioNode will take TailTime()
   // and LatencyTime() into account when determining whether the node will
   // propagate silence.
   virtual bool PropagatesSilence() const;
   bool InputsAreSilent();
   void SilenceOutputs();
   void UnsilenceOutputs();
 
   void EnableOutputsIfNecessary();
   void DisableOutputsIfNecessary();
+  void ReallyDisableOutputs();
 
   unsigned long ChannelCount();
   virtual void SetChannelCount(unsigned long, ExceptionState&);
 
   String GetChannelCountMode();
   virtual void SetChannelCountMode(const String&, ExceptionState&);
 
   String ChannelInterpretation();
   void SetChannelInterpretation(const String&, ExceptionState&);
 
@@ skipping 147 matching lines @@
   HeapVector<Member<HeapHashSet<Member<AudioNode>>>> connected_nodes_;
   // Represents audio node graph with Oilpan references. N-th HeapHashSet
   // represents a set of AudioParam objects connected to this AudioNode's N-th
   // output.
   HeapVector<Member<HeapHashSet<Member<AudioParam>>>> connected_params_;
 };
 
 }  // namespace blink
 
 #endif  // AudioNode_h