Implement clamping of AudioParam time.

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 110 matching lines @@
                                            double duration,
                                            const DOMFloat32Array* curve,
                                            float initialValue,
                                            double callTime)
     : m_type(type),
       m_value(value),
       m_time(time),
       m_timeConstant(timeConstant),
       m_duration(duration),
       m_initialValue(initialValue),
-      m_callTime(callTime) {
+      m_callTime(callTime),
+      m_needsTimeClampCheck(true) {
   if (curve) {
     // Copy the curve data
     unsigned curveLength = curve->length();
     m_curve.resize(curveLength);
     memcpy(m_curve.data(), curve->data(), curveLength * sizeof(float));
   }
 }
 
 AudioParamTimeline::ParamEvent
 AudioParamTimeline::ParamEvent::createSetValueEvent(float value, double time) {
@@ skipping 307 matching lines @@
     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;
   }
 
-  // Optimize the case where the last event is in the past.
-  if (m_events.size() > 0) {
+  int numberOfEvents = m_events.size();
+
+  if (numberOfEvents > 0) {
+    double currentTime = startFrame / sampleRate;
+
+    // Look at all the events in the timeline and check to see if any needs
+    // to clamp the start time to the current time.
+    for (int k = 0; k < numberOfEvents; ++k) {
+      ParamEvent& event = m_events[k];
+
+      // We're examining the event for the first time and the event time is
+      // in the past so clamp the event time to the current time (start of
+      // the rendering quantum).
+      if (event.needsTimeClampCheck()) {
+        if (event.time() < currentTime)
+          event.setTime(currentTime);
+
+        // In all cases, we can clear the flag because the event is either
+        // in the future, or we've already checked it (just now).
+        event.clearTimeClampCheck();
+      }
+    }
+
+    // Optimize the case where the last event is in the past.
     ParamEvent& lastEvent = m_events[m_events.size() - 1];
     ParamEvent::Type lastEventType = lastEvent.getType();
     double lastEventTime = lastEvent.time();
-    double currentTime = startFrame / sampleRate;
 
     // If the last event is in the past and the event has ended, then we can
     // just propagate the same value.  Except for SetTarget which lasts
     // "forever".  SetValueCurve also has an explicit SetValue at the end of
     // the curve, so we don't need to worry that SetValueCurve time is a
     // start time, not an end time.
     if (lastEventTime < currentTime && lastEventType != ParamEvent::SetTarget) {
       // The event has finished, so just copy the default value out.
       // Since all events are now also in the past, we can just remove all
       // timeline events too because |defaultValue| has the expected
@@ skipping 27 matching lines @@
     for (; writeIndex < fillToFrame; ++writeIndex)
       values[writeIndex] = defaultValue;
 
     currentFrame += fillToFrame;
   }
 
   float value = defaultValue;
 
   // 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) {
+  for (int i = 0; i < numberOfEvents && writeIndex < numberOfValues; ++i) {
     ParamEvent& event = m_events[i];
-    ParamEvent* nextEvent = i < n - 1 ? &(m_events[i + 1]) : 0;
+    ParamEvent* nextEvent = i < numberOfEvents - 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.
     //
@@ skipping 66 matching lines @@
                     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;
       }
+
+      // Insert a SetValueEvent to mark the starting value and time.
+      // Clear the clamp check because this doesn't need it.
       m_events[i] =
           ParamEvent::createSetValueEvent(value, currentFrame / sampleRate);
+      m_events[i].clearTimeClampCheck();
     }
 
     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;
@@ skipping 432 matching lines @@
   // 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