Avoid slow AudioParam automation path when possible

third_party/WebKit/Source/platform/audio/Biquad.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
@@ skipping 56 matching lines @@
 
     reset(); // clear filter memory
 }
 
 Biquad::~Biquad()
 {
 }
 
 void Biquad::process(const float* sourceP, float* destP, size_t framesToProcess)
 {
+    // WARNING: sourceP and destP may be pointing to the same area of memory!
+    // Be sure to read from sourceP before writing to destP!
     if (hasSampleAccurateValues()) {
         int n = framesToProcess;
 
         // Create local copies of member variables
         double x1 = m_x1;
         double x2 = m_x2;
         double y1 = m_y1;
         double y2 = m_y2;
 
         const double* b0 = m_b0.data();
@@ skipping 26 matching lines @@
         // There is an assumption here that once we have sample accurate values we can never go back
         // to not having sample accurate values.  This is currently true in the way
         // AudioParamTimline is implemented: once an event is inserted, sample accurate processing
         // is always enabled.
         //
         // If so, then we never have to update the state variables for the MACOSX path.  The
         // structure of the state variable in these cases aren't well documented so it's not clear
         // how to update them anyway.
     } else {
 #if OS(MACOSX)
+        double* inputP = m_inputBuffer.data();
+        double* outputP = m_outputBuffer.data();
+
+        // Set up filter state.  This is needed in case we're switching from
+        // filtering with variable coefficients (i.e., with automations) to
+        // fixed coefficients (without automations).
+        inputP[0] = m_x2;
+        inputP[1] = m_x1;
+        outputP[0] = m_y2;
+        outputP[1] = m_y1;
+
         // Use vecLib if available
         processFast(sourceP, destP, framesToProcess);
 
-        // Copy the last inputs and outputs to the filter memory variables.  This is needed because
-        // the next rendering quantum might be an automation which needs the history to continue
-        // correctly.
-        m_x1 = sourceP[framesToProcess - 1];
-        m_x2 = sourceP[framesToProcess - 2];
+        // Copy the last inputs and outputs to the filter memory variables.
+        // This is needed because the next rendering quantum might be an
+        // automation which needs the history to continue correctly.  Because
+        // sourceP and destP can be the same block of memory, we can't read from
+        // sourceP to get the last inputs.  Fortunately, processFast has put the
+        // last inputs in input[0] and input[1].
+        m_x1 = inputP[1];
+        m_x2 = inputP[0];
         m_y1 = destP[framesToProcess - 1];
         m_y2 = destP[framesToProcess - 2];
 
 #else
         int n = framesToProcess;
 
         // Create local copies of member variables
         double x1 = m_x1;
         double x2 = m_x2;
         double y1 = m_y1;
@@ skipping 466 matching lines @@
         std::complex<double> denominator =
             std::complex<double>(1, 0) + (a1 + a2 * z) * z;
         std::complex<double> response = numerator / denominator;
         magResponse[k] = static_cast<float>(abs(response));
         phaseResponse[k] = static_cast<float>(atan2(imag(response), real(response)));
     }
 }
 
 } // namespace blink