Implement tail processing for AudioNodes

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

 /*
  * 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 72 matching lines @@
   DCHECK_EQ(new_channel_count_mode_, channel_count_mode_);
   DCHECK_EQ(new_channel_interpretation_, channel_interpretation_);
 
   is_initialized_ = true;
 }
 
 void AudioHandler::Uninitialize() {
   is_initialized_ = false;
 }
 
-void AudioHandler::ClearInternalStateWhenDisabled() {}
-
 void AudioHandler::Dispose() {
   DCHECK(IsMainThread());
   DCHECK(Context()->IsGraphOwner());
 
   Context()->GetDeferredTaskHandler().RemoveChangedChannelCountMode(this);
   Context()->GetDeferredTaskHandler().RemoveChangedChannelInterpretation(this);
   Context()->GetDeferredTaskHandler().RemoveAutomaticPullNode(this);
   for (auto& output : outputs_)
     output->Dispose();
   node_ = nullptr;
@@ skipping 213 matching lines @@
   // have the results cached in their bus;
   double current_time = Context()->currentTime();
   if (last_processing_time_ != current_time) {
     // important to first update this time because of feedback loops in the
     // rendering graph.
     last_processing_time_ = current_time;
 
     PullInputs(frames_to_process);
 
     bool silent_inputs = InputsAreSilent();
-    if (!silent_inputs) {
-      last_non_silent_time_ =
-          (Context()->CurrentSampleFrame() + frames_to_process) /
-          static_cast<double>(Context()->sampleRate());
-    }
-
     if (silent_inputs && PropagatesSilence()) {
       SilenceOutputs();
       // AudioParams still need to be processed so that the value can be updated
       // if there are automations or so that the upstream nodes get pulled if
       // any are connected to the AudioParam.
       ProcessOnlyAudioParams(frames_to_process);
     } else {
       // Unsilence the outputs first because the processing of the node may
       // cause the outputs to go silent and we want to propagate that hint to
       // the downstream nodes.  (For example, a Gain node with a gain of 0 will
       // want to silence its output.)
       UnsilenceOutputs();
       Process(frames_to_process);
     }
+
+    if (!silent_inputs) {
+      // Update last_non_silent_time AFTER processing this block.
+      // Doing it before causes PropagateSilence to be one render
+      // quantum longer than necessary.
+      last_non_silent_time_ =
+          (Context()->CurrentSampleFrame() + frames_to_process) /
+          static_cast<double>(Context()->sampleRate());
+    }
   }
 }
 
 void AudioHandler::CheckNumberOfChannelsForInput(AudioNodeInput* input) {
   DCHECK(Context()->IsAudioThread());
   DCHECK(Context()->IsGraphOwner());
 
   DCHECK(inputs_.Contains(input));
   if (!inputs_.Contains(input))
     return;
@@ skipping 37 matching lines @@
     DCHECK(IsMainThread());
     BaseAudioContext::AutoLocker locker(Context());
 
     is_disabled_ = false;
     for (auto& output : outputs_)
       output->Enable();
   }
 }
 
 void AudioHandler::DisableOutputsIfNecessary() {
+  // This function calls other functions that require graph ownership,
+  // so assert that this needs graph ownership too.
+  DCHECK(Context()->IsGraphOwner());
+
   // Disable outputs if appropriate. We do this if the number of connections is
   // 0 or 1. The case of 0 is from deref() where there are no connections left.
   // The case of 1 is from AudioNodeInput::disable() where we want to disable
   // outputs when there's only one connection left because we're ready to go
   // away, but can't quite yet.
   if (connection_ref_count_ <= 1 && !is_disabled_) {
     // Still may have JavaScript references, but no more "active" connection
     // references, so put all of our outputs in a "dormant" disabled state.
     // Garbage collection may take a very long time after this time, so the
     // "dormant" disabled nodes should not bog down the rendering...
 
     // As far as JavaScript is concerned, our outputs must still appear to be
     // connected.  But internally our outputs should be disabled from the inputs
     // they're connected to.  disable() can recursively deref connections (and
     // call disable()) down a whole chain of connected nodes.
 
-    // TODO(rtoy,hongchan): we need special cases the convolver, delay, biquad,
-    // and IIR since they have a significant tail-time and shouldn't be
-    // disconnected simply because they no longer have any input connections.
-    // This needs to be handled more generally where AudioNodes have a tailTime
-    // attribute. Then the AudioNode only needs to remain "active" for tailTime
-    // seconds after there are no longer any active connections.
-    //
-    // The analyser node also requires special handling because we
-    // need the internal state to be updated for the time and FFT data
-    // even if it has no connections.
-    if (GetNodeType() != kNodeTypeConvolver &&
-        GetNodeType() != kNodeTypeDelay &&
-        GetNodeType() != kNodeTypeBiquadFilter &&
-        GetNodeType() != kNodeTypeIIRFilter &&
-        GetNodeType() != kNodeTypeAnalyser) {
-      is_disabled_ = true;
-      ClearInternalStateWhenDisabled();
-      for (auto& output : outputs_)
-        output->Disable();
+    // If a node requires tail processing, we defer the disabling of
+    // the outputs so that the tail for the node can be output.
+    // Otherwise, we can disable the outputs right away.
+    if (RequiresTailProcessing()) {
+      if (Context()->ContextState() !=
+          BaseAudioContext::AudioContextState::kClosed) {
+        Context()->GetDeferredTaskHandler().AddTailProcessingNode(this);
+      }
+    } else {
+      ReallyDisableOutputs();
     }
   }
 }
 
+void AudioHandler::ReallyDisableOutputs() {
+  is_disabled_ = true;
+  for (auto& output : outputs_)
+    output->Disable();
+}
+
 void AudioHandler::MakeConnection() {
   AtomicIncrement(&connection_ref_count_);
 
+  Context()->GetDeferredTaskHandler().RemoveTailProcessingNode(this);
+
 #if DEBUG_AUDIONODE_REFERENCES
-  fprintf(stderr, "[%16p]: %16p: %2d: AudioHandler::ref   %3d [%3d]\n",
+  fprintf(stderr, "[%16p]: %16p: %2d: AudioHandler::ref   %3d [%3d] @%.15g\n",
           Context(), this, GetNodeType(), connection_ref_count_,
-          node_count_[GetNodeType()]);
+          node_count_[GetNodeType()], Context()->currentTime());
 #endif
   // See the disabling code in disableOutputsIfNecessary(). This handles
   // the case where a node is being re-connected after being used at least
   // once and disconnected. In this case, we need to re-enable.
   EnableOutputsIfNecessary();
 }
 
 void AudioHandler::BreakConnection() {
   // The actual work for deref happens completely within the audio context's
   // graph lock. In the case of the audio thread, we must use a tryLock to
@@ skipping 15 matching lines @@
     // later.
     DCHECK(Context()->IsAudioThread());
     Context()->GetDeferredTaskHandler().AddDeferredBreakConnection(*this);
   }
 }
 
 void AudioHandler::BreakConnectionWithLock() {
   AtomicDecrement(&connection_ref_count_);
 
 #if DEBUG_AUDIONODE_REFERENCES
-  fprintf(stderr, "[%16p]: %16p: %2d: AudioHandler::deref %3d [%3d]\n",
+  fprintf(stderr, "[%16p]: %16p: %2d: AudioHandler::deref %3d [%3d] @%.15g\n",
           Context(), this, GetNodeType(), connection_ref_count_,
-          node_count_[GetNodeType()]);
+          node_count_[GetNodeType()], Context()->currentTime());
 #endif
 
   if (!connection_ref_count_)
     DisableOutputsIfNecessary();
 }
 
 #if DEBUG_AUDIONODE_REFERENCES
 
 bool AudioHandler::is_node_count_initialized_ = false;
 int AudioHandler::node_count_[kNodeTypeEnd];
 
 void AudioHandler::PrintNodeCounts() {
   fprintf(stderr, "\n\n");
   fprintf(stderr, "===========================\n");
   fprintf(stderr, "AudioNode: reference counts\n");
   fprintf(stderr, "===========================\n");
 
   for (unsigned i = 0; i < kNodeTypeEnd; ++i)
     fprintf(stderr, "%2d: %d\n", i, node_count_[i]);
 
   fprintf(stderr, "===========================\n\n\n");
 }
 
 #endif  // DEBUG_AUDIONODE_REFERENCES
 
+#if DEBUG_AUDIONODE_REFERENCES > 1
+void AudioHandler::TailProcessingDebug(const char* note) {
+  fprintf(stderr, "[%16p]: %16p: %2d: %s %d @%.15g", Context(), this,
+          GetNodeType(), note, connection_ref_count_, Context()->currentTime());
+
+  // If we're on the audio thread, we can print out the tail and
+  // latency times (because these methods can only be called from the
+  // audio thread.)
+  if (Context()->IsAudioThread()) {
+    fprintf(stderr, ", tail=%.15g + %.15g, last=%.15g\n", TailTime(),
+            LatencyTime(), last_non_silent_time_);
+  }
+
+  fprintf(stderr, "\n");
+}
+
+void AudioHandler::AddTailProcessingDebug() {
+  TailProcessingDebug("addTail");
+}
+
+void AudioHandler::RemoveTailProcessingDebug() {
+  TailProcessingDebug("remTail");
+}
+#endif  // DEBUG_AUDIONODE_REFERENCES > 1
+
 void AudioHandler::UpdateChannelCountMode() {
   channel_count_mode_ = new_channel_count_mode_;
   UpdateChannelsForInputs();
 }
 
 void AudioHandler::UpdateChannelInterpretation() {
   channel_interpretation_ = new_channel_interpretation_;
 }
 
 unsigned AudioHandler::NumberOfOutputChannels() const {
@@ skipping 437 matching lines @@
 }
 
 void AudioNode::DidAddOutput(unsigned number_of_outputs) {
   connected_nodes_.push_back(nullptr);
   DCHECK_EQ(number_of_outputs, connected_nodes_.size());
   connected_params_.push_back(nullptr);
   DCHECK_EQ(number_of_outputs, connected_params_.size());
 }
 
 }  // namespace blink