setValueCurveAtTime has implicit setValueAtTime at end

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 207 matching lines @@
         exceptionState.throwDOMException(
             InvalidStateError,
             ExceptionMessages::indexExceedsMinimumBound(
                 "curve length",
                 curve->length(),
                 2U));
         return;
     }
 
     insertEvent(ParamEvent::createSetValueCurveEvent(curve, time, duration), exceptionState);
+
+    // Insert a setValueAtTime event too to establish an event so that all
+    // following events will process from the end of the curve instead of the
+    // beginning.
+    insertEvent(ParamEvent::createSetValueEvent(curve->data()[curve->length() - 1], time + duration), exceptionState);
 }
 
 void AudioParamTimeline::insertEvent(const ParamEvent& event, ExceptionState& exceptionState)
 {
     ASSERT(isMainThread());
 
     // Sanity check the event. Be super careful we're not getting infected with NaN or Inf. These
     // should have been handled by the caller.
     bool isValid = event.getType() < ParamEvent::LastType
         && std::isfinite(event.value())
@@ skipping 186 matching lines @@
 
     // Go through each event and render the value buffer where the times overlap,
     // stopping when we've rendered all the requested values.
     int n = m_events.size();
     int lastSkippedEventIndex = 0;
     for (int i = 0; i < n && writeIndex < numberOfValues; ++i) {
         ParamEvent& event = m_events[i];
         ParamEvent* nextEvent = i < n - 1 ? &(m_events[i + 1]) : 0;
 
         // Wait until we get a more recent event.
+        //
+        // WARNING: due to round-off it might happen that nextEvent->time() is
+        // just larger than currentFrame/sampleRate.  This means that we will end
+        // up running the |event| again.  The code below had better be prepared
+        // for this case!  What should happen is the fillToFrame should be 0 so
+        // that while the event is actually run again, nothing actually gets
+        // computed, and we move on to the next event.
+        //
+        // An example of this case is setValueCurveAtTime.  The time at which
+        // setValueCurveAtTime ends (and the setValueAtTime begins) might be
+        // just past currentTime/sampleRate.  Then setValueCurveAtTime will be
+        // processed again before advancing to setValueAtTime.  The number of
+        // frames to be processed should be zero in this case.
         if (nextEvent && nextEvent->time() < currentFrame / sampleRate) {
             // But if the current event is a SetValue event and the event time is between
             // currentFrame - 1 and curentFrame (in time). we don't want to skip it.  If we do skip
             // it, the SetValue event is completely skipped and not applied, which is wrong.  Other
             // events don't have this problem.  (Because currentFrame is unsigned, we do the time
             // check in this funny, but equivalent way.)
             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.
@@ skipping 424 matching lines @@
                     }
 
                     // 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.
                     if (writeIndex < nextEventFillToFrame)
                         value = curveData[numberOfCurvePoints - 1];
                     for (; writeIndex < nextEventFillToFrame; ++writeIndex)
                         values[writeIndex] = value;
 
                     // Re-adjust current time
-                    currentFrame = nextEventFillToFrame;
+                    currentFrame += nextEventFillToFrame;
 
                     break;
                 }
             case ParamEvent::LastType:
                 ASSERT_NOT_REACHED();
                 break;
             }
         }
     }
 
     // If we skipped over any events (because they are in the past), we can
     // remove them so we don't have to check them ever again.  (This MUST be
     // running with the m_events lock so we can safely modify the m_events
     // array.)
     if (lastSkippedEventIndex > 0)
         m_events.remove(0, lastSkippedEventIndex - 1);
 
     // 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.  it should be the last
     // computed value.
     return values[numberOfValues - 1];
 }
 
 } // namespace blink