Update the AudioParam value attribute correctly from timelines.

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 330 matching lines @@
 float AudioParamTimeline::valuesForFrameRangeImpl(
     size_t startFrame,
     size_t endFrame,
     float defaultValue,
     float* values,
     unsigned numberOfValues,
     double sampleRate,
     double controlRate)
 {
     ASSERT(values);
-    if (!values)
+    ASSERT(numberOfValues >= 1);
+    if (!values || !(numberOfValues >= 1))
         return defaultValue;
 
     // Return default value if there are no events matching the desired time range.
     if (!m_events.size() || (endFrame / sampleRate <= m_events[0].time())) {
         for (unsigned i = 0; i < numberOfValues; ++i)
             values[i] = defaultValue;
         return defaultValue;
     }
 
     // Maintain a running time (frame) and index for writing the values buffer.
@@ skipping 153 matching lines @@
                 float multiplier = powf(value2 / value1, 1 / numSampleFrames);
                 // Set the starting value of the exponential ramp.
                 value = value1 * powf(value2 / value1,
                     (currentFrame / sampleRate - time1) / deltaTime);
 
                 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;
             }
         } else {
             // Handle event types not requiring looking ahead to the next event.
             switch (event.type()) {
             case ParamEvent::SetValue:
             case ParamEvent::LinearRampToValue:
                 {
                     currentFrame = fillToEndFrame;
 
                     // Simply stay at a constant value.
                     value = event.value();
 
                     for (; writeIndex < fillToFrame; ++writeIndex)
                         values[writeIndex] = value;
 
                     break;
                 }
 
             case ParamEvent::ExponentialRampToValue:
                 {
                     currentFrame = fillToEndFrame;
 
+                    // If we're here, we've reached the end of the ramp.  If we can (because the
+                    // start and end values have the same sign, and neither is 0), use the actual
+                    // end value.  If not, we have to propagate whatever we have.
+                    if (i >= 1 && ((m_events[i - 1].value() * event.value()) > 0))
+                        value = event.value();
+
                     // Simply stay at a constant value from the last time.  We don't want to use the
                     // value of the event in case value1 * value2 < 0.  In this case we should
                     // propagate the previous value, which is in |value|.
                     for (; writeIndex < fillToFrame; ++writeIndex)
                         values[writeIndex] = value;
 
                     break;
                 }
 
             case ParamEvent::SetTarget:
                 {
                     // Exponential approach to target value with given time constant.
                     //
                     //   v(t) = v2 + (v1 - v2)*exp(-(t-t1/tau))
                     //
 
                     float target = event.value();
                     float timeConstant = event.timeConstant();
                     float discreteTimeConstant = static_cast<float>(AudioUtilities::discreteTimeConstantForSampleRate(timeConstant, controlRate));
 
                     // Set the starting value correctly.  This is only needed when the current time
                     // is "equal" to the start time of this event.  This is to get the sampling
                     // correct if the start time of this automation isn't on a frame boundary.
                     // Otherwise, we can just continue from where we left off from the previous
                     // rendering quantum.
-
                     {
                         double rampStartFrame = time1 * sampleRate;
                         // Condition is c - 1 < r <= c where c = currentFrame and r =
                         // rampStartFrame.  Compute it this way because currentFrame is unsigned and
                         // could be 0.
-                        if (rampStartFrame <= currentFrame && currentFrame < rampStartFrame + 1)
+                        if (rampStartFrame <= currentFrame && currentFrame < rampStartFrame + 1) {
                             value = target + (value - target) * exp(-(currentFrame / sampleRate - time1) / timeConstant);
+                        } else {
+                            // Otherwise, need to compute a new value bacause |value| is the last
+                            // computed value of SetTarget.  Time has progressed by one frame, so we
+                            // need to update the value for the new frame.
+                            value += (target - value) * discreteTimeConstant;
+                        }
                     }
 
                     // If the value is close enough to the target, just fill in the data with the
                     // target value.
                     if (fabs(value - target) < kSetTargetThreshold * fabs(target)
                         || (!target && fabs(value) < kSetTargetZeroThreshold)) {
                         for (; writeIndex < fillToFrame; ++writeIndex)
                             values[writeIndex] = target;
                     } else {
 #if CPU(X86) || CPU(X86_64)
@@ skipping 25 matching lines @@
 
                             // Update value for next iteration.
                             value += delta * c3;
                         }
 #endif
                         // Serially process remaining values
                         for (; writeIndex < fillToFrame; ++writeIndex) {
                             values[writeIndex] = value;
                             value += (target - value) * discreteTimeConstant;
                         }
-
+                        // The previous loops may have updated |value| one extra time.  Reset it to
+                        // the last computed value.
+                        if (writeIndex >= 1)
+                            value = values[writeIndex - 1];
                         currentFrame = fillToEndFrame;
                     }
                     break;
                 }
 
             case ParamEvent::SetValueCurve:
                 {
                     DOMFloat32Array* curve = event.curve();
                     float* curveData = curve ? curve->data() : 0;
                     unsigned numberOfCurvePoints = curve ? curve->length() : 0;
@@ skipping 122 matching lines @@
                         float c1 = curveData[curveIndex1];
                         double delta = std::min(currentVirtualIndex - curveIndex0, 1.0);
 
                         value = c0 + (c1 - c0) * delta;
 
                         values[writeIndex] = value;
                     }
 
                     // If there's any time left after the duration of this event and the start
                     // of the next, then just propagate the last value of the curveData.
-                    value = curveData[numberOfCurvePoints - 1];
+                    if (writeIndex < nextEventFillToFrame)
+                        value = curveData[numberOfCurvePoints - 1];
                     for (; writeIndex < nextEventFillToFrame; ++writeIndex)
                         values[writeIndex] = value;
 
                     // Re-adjust current time
                     currentFrame = nextEventFillToFrame;
 
                     break;
                 }
             case ParamEvent::LastType:
                 ASSERT_NOT_REACHED();
                 break;
             }
         }
     }
 
     // If there's any time left after processing the last event then just propagate the last value
     // to the end of the values buffer.
     for (; writeIndex < numberOfValues; ++writeIndex)
         values[writeIndex] = value;
 
-    // This value is used to set the .value attribute of the AudioParam.
-    return 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