Make setTarget followed by linear or exponential ramp continuous.

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

 /*
  * Copyright (C) 2011 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 402 matching lines @@
             double eventFrame = event.time() * sampleRate;
 
             // Condition is currentFrame - 1 < eventFrame <= currentFrame, but currentFrame is
             // unsigned and could be 0, so use currentFrame < eventFrame + 1 instead.
             if (!((event.getType() == ParamEvent::SetValue
                 && (eventFrame <= currentFrame)
                 && (currentFrame < eventFrame + 1))))
                 continue;
         }
 
+        // If there's no next event, set nextEventType to LastType to indicate that.
+        ParamEvent::Type nextEventType = nextEvent ? static_cast<ParamEvent::Type>(nextEvent->getType()) : ParamEvent::LastType;
+
+        // If the current event is SetTarget and the next event is a LinearRampToValue or
+        // ExponentialRampToValue, special handling is needed.  In this case, the linear and
+        // exponential ramp should start at wherever the SetTarget processing has reached.
+        if (event.getType() == ParamEvent::SetTarget
+            && (nextEventType == ParamEvent::LinearRampToValue
+                || nextEventType == ParamEvent::ExponentialRampToValue)) {
+            // Replace the SetTarget with a SetValue to set the starting time and value for the ramp
+            // using the current frame.  We need to update |value| appropriately depending on
+            // whether the ramp has started or not.
+            //
+            // If SetTarget starts somewhere between currentFrame - 1 and currentFrame, we directly
+            // compute the value it would have at currentFrame.  If not, we update the value from
+            // the value from currentFrame - 1.
+            //
+            // Can't use the condition currentFrame - 1 <= t0 * sampleRate <= currentFrame because
+            // currentFrame is unsigned and could be 0.  Instead, compute the condition this way,
+            // where f = currentFrame and Fs = sampleRate:
+            //
+            //    f - 1 <= t0 * Fs <= f
+            //    2 * f - 2 <= 2 * Fs * t0 <= 2 * f
+            //    -2 <= 2 * Fs * t0 - 2 * f <= 0
+            //    -1 <= 2 * Fs * t0 - 2 * f + 1 <= 1
+            //     abs(2 * Fs * t0 - 2 * f + 1) <= 1
+            if (fabs(2 * sampleRate * event.time() - 2 * currentFrame + 1) <= 1) {
+                // SetTarget is starting somewhere between currentFrame - 1 and
+                // currentFrame. Compute the value the SetTarget would have at the currentFrame.
+                value = event.value() + (value - event.value()) * exp(-(currentFrame / sampleRate - event.time()) / event.timeConstant());
+            } else {
+                // SetTarget has already started.  Update |value| one frame because it's the value from
+                // the previous frame.
+                float discreteTimeConstant = static_cast<float>(AudioUtilities::discreteTimeConstantForSampleRate(
+                    event.timeConstant(), controlRate));
+                value += (event.value() - value) * discreteTimeConstant;
+            }
+            m_events[i] = ParamEvent::createSetValueEvent(value, currentFrame / sampleRate);
+        }
+
         float value1 = event.value();
         double time1 = event.time();
 
         float value2 = nextEvent ? nextEvent->value() : value1;
         double time2 = nextEvent ? nextEvent->time() : endFrame / sampleRate + 1;
 
         double deltaTime = time2 - time1;
         float k = deltaTime > 0 ? 1 / deltaTime : 0;
 
         // |fillToEndFrame| is the exclusive upper bound of the last frame to be computed for this
         // event.  It's either the last desired frame (|endFrame|) or derived from the end time of
         // the next event (time2). We compute ceil(time2*sampleRate) because fillToEndFrame is the
         // exclusive upper bound.  Consider the case where |startFrame| = 128 and time2 = 128.1
         // (assuming sampleRate = 1).  Since time2 is greater than 128, we want to output a value
         // for frame 128.  This requires that fillToEndFrame be at least 129.  This is achieved by
         // ceil(time2).
         //
         // However, time2 can be very large, so compute this carefully in the case where time2
         // exceeds the size of a size_t.
 
         size_t fillToEndFrame = endFrame;
         if (endFrame > time2 * sampleRate)
             fillToEndFrame = static_cast<size_t>(ceil(time2 * sampleRate));
 
         ASSERT(fillToEndFrame >= startFrame);
         size_t fillToFrame = fillToEndFrame - startFrame;
         fillToFrame = std::min(fillToFrame, static_cast<size_t>(numberOfValues));
 
-        ParamEvent::Type nextEventType = nextEvent ? static_cast<ParamEvent::Type>(nextEvent->getType()) : ParamEvent::LastType /* unknown */;
-
         // First handle linear and exponential ramps which require looking ahead to the next event.
         if (nextEventType == ParamEvent::LinearRampToValue) {
             const float valueDelta = value2 - value1;
 #if CPU(X86) || CPU(X86_64)
             // Minimize in-loop operations. Calculate starting value and increment. Next step: value += inc.
             //  value = value1 + (currentFrame/sampleRate - time1) * k * (value2 - value1);
             //  inc = 4 / sampleRate * k * (value2 - value1);
             // Resolve recursion by expanding constants to achieve a 4-step loop unrolling.
             //  value = value1 + ((currentFrame/sampleRate - time1) + i * sampleFrameTimeIncr) * k * (value2 -value1), i in 0..3
             __m128 vValue = _mm_mul_ps(_mm_set_ps1(1 / sampleRate), _mm_set_ps(3, 2, 1, 0));
@@ skipping 66 matching lines @@
 
                 for (; writeIndex < fillToFrame; ++writeIndex) {
                     values[writeIndex] = value;
                     value *= multiplier;
                     ++currentFrame;
                 }
                 // |value| got updated one extra time in the above loop.  Restore it to the last
                 // computed value.
                 if (writeIndex >= 1)
                     value /= multiplier;
+
+                // Due to roundoff it's possible that value exceeds value2.  Clip value to value2 if
+                // we are within 1/2 frame of time2.
+                if (currentFrame > time2 * sampleRate - 0.5)
+                    value = value2;
             }
         } else {
             // Handle event types not requiring looking ahead to the next event.
             switch (event.getType()) {
             case ParamEvent::SetValue:
             case ParamEvent::LinearRampToValue:
                 {
                     currentFrame = fillToEndFrame;
 
                     // Simply stay at a constant value.
@@ skipping 266 matching lines @@
     for (; writeIndex < numberOfValues; ++writeIndex)
         values[writeIndex] = value;
 
     // This value is used to set the .value attribute of the AudioParam.  it should be the last
     // computed value.
     return values[numberOfValues - 1];
 }
 
 } // namespace blink