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 387 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.type() == ParamEvent::SetValue
                 && (eventFrame <= currentFrame)
                 && (currentFrame < eventFrame + 1))))
                 continue;
         }
 
+        ParamEvent::Type nextEventType = nextEvent ? static_cast<ParamEvent::Type>(nextEvent->type()) : ParamEvent::LastType /* unknown */;

[hongchan, 2016/04/27 21:40:09]

Are we okay with the comment style here? I've never seen something like this
before.

[Raymond Toy, 2016/04/27 21:43:15]

Don't know.  I just basically moved this line up from line 438 below, without
changing anything.

[Raymond Toy, 2016/04/27 22:57:03]

It means a nextEventType equal to LastType indicates an unknown eventType. 
Because there is no nextEvent.

I'll remove that and add a better comment.

+
+        // 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.type() == 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 and value.
+            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->type()) : 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
@@ skipping 63 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;
                 }
+                // 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.type()) {
             case ParamEvent::SetValue:
             case ParamEvent::LinearRampToValue:
                 {
                     currentFrame = fillToEndFrame;
 
                     // Simply stay at a constant value.
@@ skipping 241 matching lines @@
     // 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;
 }
 
 } // namespace blink