Compute tail time from Biquad coefficients

third_party/WebKit/Source/modules/webaudio/BiquadDSPKernel.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 13 matching lines @@
  */
 
 #include "modules/webaudio/BiquadDSPKernel.h"
 #include <limits.h>
 #include "platform/audio/AudioUtilities.h"
 #include "platform/wtf/MathExtras.h"
 #include "platform/wtf/Vector.h"
 
 namespace blink {
 
-// FIXME: As a recursive linear filter, depending on its parameters, a biquad
-// filter can have an infinite tailTime. In practice, Biquad filters do not
-// usually (except for very high resonance values) have a tailTime of longer
-// than approx. 200ms. This value could possibly be calculated based on the
-// settings of the Biquad.
-static const double kMaxBiquadDelayTime = 0.2;
-
 void BiquadDSPKernel::UpdateCoefficientsIfNecessary(int frames_to_process) {
   if (GetBiquadProcessor()->FilterCoefficientsDirty()) {
     float cutoff_frequency[AudioUtilities::kRenderQuantumFrames];
     float q[AudioUtilities::kRenderQuantumFrames];
     float gain[AudioUtilities::kRenderQuantumFrames];
     float detune[AudioUtilities::kRenderQuantumFrames];  // in Cents
 
     SECURITY_CHECK(static_cast<unsigned>(frames_to_process) <=
                    AudioUtilities::kRenderQuantumFrames);
 
@@ skipping 63 matching lines @@
 
       case BiquadProcessor::kNotch:
         biquad_.SetNotchParams(k, normalized_frequency, q[k]);
         break;
 
       case BiquadProcessor::kAllpass:
         biquad_.SetAllpassParams(k, normalized_frequency, q[k]);
         break;
     }
   }
+
+  UpdateTailTime(number_of_frames - 1);
+}
+
+void BiquadDSPKernel::UpdateTailTime(int coef_index) {
+  // A reasonable upper limit for the tail time.  While it's easy to
+  // create biquad filters whose tail time can be much larger than
+  // this, limit the maximum to this value so that we don't keep such
+  // nodes alive "forever".
+  // TODO: What is a reasonable upper limit?
+  const double kMaxTailTime = 30;
+
+  double sample_rate = SampleRate();
+  double tail =
+      biquad_.TailFrame(coef_index, kMaxTailTime * sample_rate) / sample_rate;
+
+  tail_time_ = clampTo(tail, 0.0, kMaxTailTime);
 }
 
 void BiquadDSPKernel::Process(const float* source,
                               float* destination,
                               size_t frames_to_process) {
   DCHECK(source);
   DCHECK(destination);
   DCHECK(GetBiquadProcessor());
 
   // Recompute filter coefficients if any of the parameters have changed.
@@ skipping 58 matching lines @@
     detune = GetBiquadProcessor()->Parameter4().Value();
   }
 
   UpdateCoefficients(1, &cutoff_frequency, &q, &gain, &detune);
 
   biquad_.GetFrequencyResponse(n_frequencies, frequency.data(), mag_response,
                                phase_response);
 }
 
 double BiquadDSPKernel::TailTime() const {
-  return kMaxBiquadDelayTime;
+  return tail_time_;
 }
 
 double BiquadDSPKernel::LatencyTime() const {
   return 0;
 }
 
 }  // namespace blink