Correctly propagate end value for exponential ramp

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 392 matching lines @@
             // unsigned and could be 0, so use currentFrame < eventFrame + 1 instead.
             if (!((event.type() == ParamEvent::SetValue
                 && (eventFrame <= currentFrame)
                 && (currentFrame < eventFrame + 1))))
                 continue;
         }
 
         float value1 = event.value();
         double time1 = event.time();
 
-        // If the current event is SetValue, set the default value too so that it appears as if
-        // SetValue were actually run for any corner caes where we want to use the default value.
-        if (event.type() == ParamEvent::SetValue)
-            value = value1;
-
         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
@@ skipping 37 matching lines @@
             for (; writeIndex < fillToFrame; ++writeIndex) {
                 float x = (currentFrame / sampleRate - time1) * k;
                 // value = (1 - x) * value1 + x * value2;
                 value = value1 + x * valueDelta;
                 values[writeIndex] = value;
                 ++currentFrame;
             }
         } else if (nextEventType == ParamEvent::ExponentialRampToValue) {
             if (value1 * value2 <= 0) {
                 // It's an error if value1 and value2 have opposite signs or if one of them is zero.
-                // Handle this by propagating the previous value.
+                // Handle this by propagating the previous value, and making it the default.
+                value = value1;
+
                 for (; writeIndex < fillToFrame; ++writeIndex)
                     values[writeIndex] = value;
             } else {
                 float numSampleFrames = deltaTime * sampleRate;
                 // The value goes exponentially from value1 to value2 in a duration of deltaTime
                 // seconds according to
                 //
                 //  v(t) = v1*(v2/v1)^((t-t1)/(t2-t1))
                 //
                 // Let c be currentFrame and F be the sampleRate.  Then we want to sample v(t)
@@ skipping 23 matching lines @@
                     values[writeIndex] = value;
                     value *= multiplier;
                     ++currentFrame;
                 }
             }
         } else {
             // Handle event types not requiring looking ahead to the next event.
             switch (event.type()) {
             case ParamEvent::SetValue:
             case ParamEvent::LinearRampToValue:
-            case ParamEvent::ExponentialRampToValue:
                 {
                     currentFrame = fillToEndFrame;
 
                     // Simply stay at a constant value.
                     value = event.value();
 
                     for (; writeIndex < fillToFrame; ++writeIndex)
                         values[writeIndex] = value;
 
                     break;
                 }
 
+            case ParamEvent::ExponentialRampToValue:
+                {
+                    currentFrame = fillToEndFrame;
+
+                    // 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));
@@ skipping 210 matching lines @@
     // to the end of the values buffer.
     for (; writeIndex < numberOfValues; ++writeIndex)
         values[writeIndex] = value;
 
     return value;
 }
 
 } // namespace blink
 
 #endif // ENABLE(WEB_AUDIO)