Refactor valuesForFrameRangeImpl

third_party/WebKit/Source/modules/webaudio/AudioParamTimeline.h

Index: third_party/WebKit/Source/modules/webaudio/AudioParamTimeline.h
diff --git a/third_party/WebKit/Source/modules/webaudio/AudioParamTimeline.h b/third_party/WebKit/Source/modules/webaudio/AudioParamTimeline.h
index 6e6ef7b831dbfb1769f81ae43a9687f88630a709..5882ffe1ce7d15957b8ae8cee4d24cc7e803507e 100644
--- a/third_party/WebKit/Source/modules/webaudio/AudioParamTimeline.h
+++ b/third_party/WebKit/Source/modules/webaudio/AudioParamTimeline.h
@@ -36,6 +36,8 @@
 #include "wtf/Threading.h"
 #include "wtf/Vector.h"
 
+#include <tuple>
+
 namespace blink {
 
 class AudioParamTimeline {
@@ -158,6 +160,7 @@ class AudioParamTimeline {
     void setTime(double newTime) { m_time = newTime; }
     double timeConstant() const { return m_timeConstant; }
     double duration() const { return m_duration; }
+    const Vector<float>& curve() const { return m_curve; }

[hongchan, 2017/02/10 23:37:29]

What is the benefit of this pattern? A const getter and a writable getter with
the same name seem to be confusing - do we really need this?

[Raymond Toy, 2017/02/10 23:52:36]

Not sure about the pattern, but a few other bits of webaudio code do this.  (But
other places have foo->data() and foo->mutableData().)

A const function is needed because AutomationState has a const ParamEvent* and
processSetValueCurve needs access to it.  Without this, the compiler complains
that curve() isn't a const function.

     Vector<float>& curve() { return m_curve; }
     float initialValue() const { return m_initialValue; }
     double callTime() const { return m_callTime; }
@@ -261,6 +264,38 @@ class AudioParamTimeline {
     bool m_hasDefaultCancelledValue;
   };
 
+  // State of the timeline for the current event.
+  struct AutomationState {
+    // Parameters for the current automation request.

[hongchan, 2017/02/10 23:37:29]

Merge this comment with l.267?

[Raymond Toy, 2017/02/14 19:55:52]

Done.

+
+    // Number of values to be computed for the automation request
+    const unsigned numberOfValues;
+    // Start and end frames for this automation request
+    const size_t startFrame;
+    const size_t endFrame;
+
+    // Sample rate and control rate for this request
+    const double sampleRate;
+    const double controlRate;
+
+    // Parameters needed for processing the current event.
+

[hongchan, 2017/02/10 23:37:29]

An extra empty line.

[Raymond Toy, 2017/02/14 19:55:52]

Done.

+    const size_t fillToFrame;
+    const size_t fillToEndFrame;
+
+    // Value and time for the current event
+    const float value1;
+    const double time1;
+
+    // Value and time for the next event, if any.
+    const float value2;
+    const double time2;
+
+    // The current event, and it's index in the event vector.
+    const ParamEvent* event;
+    const int eventIndex;
+  };
+
   void insertEvent(std::unique_ptr<ParamEvent>, ExceptionState&);
   float valuesForFrameRangeImpl(size_t startFrame,
                                 size_t endFrame,
@@ -296,6 +331,120 @@ class AudioParamTimeline {
                          const float* curveData,
                          unsigned curveLength);
 
+  // Handles the special case where the first event in the timeline
+  // starts after |startFrame|.  These initial values are filled using
+  // |defaultValue|.  The updated |currentFrame| and |writeIndex| is
+  // returned.
+  std::tuple<size_t, unsigned> handleFirstEvent(float* values,
+                                                float defaultValue,
+                                                unsigned numberOfValues,
+                                                size_t startFrame,
+                                                size_t endFrame,
+                                                double sampleRate,
+                                                size_t currentFrame,
+                                                unsigned writeIndex);
+
+  // Return true if |currentEvent| starts after |currentFrame|, but
+  // also takes into account the |nextEvent| if any.
+  bool isEventCurrent(const ParamEvent* currentEvent,
+                      const ParamEvent* nextEvent,
+                      size_t currentFrame,
+                      double sampleRate);
+
+  // Clamp event times to current time, if needed.
+  void clampToCurrentTime(int numberOfEvents,
+                          size_t startFrame,
+                          double sampleRate);
+
+  // Handle the case where the last event in the timeline is in the
+  // past.  Returns false if any event is not in the past. Otherwise,
+  // return true and also fill in |values| with |defaultValue|.
+  bool handleAllEventsInThePast(double currentTime,
+                                double sampleRate,
+                                float defaultValue,
+                                unsigned numberOfValues,
+                                float* values);
+
+  // Handle processing of CancelValue event. If cancellation happens, value2,
+  // time2, and nextEventType will be updated with the new value due to
+  // cancellation.  The
+  std::tuple<float, double, ParamEvent::Type> handleCancelValues(
+      const ParamEvent* currentEvent,
+      ParamEvent* nextEvent,
+      float value2,
+      double time2);
+
+  // Process a SetTarget event and the next event is a
+  // LinearRampToValue or ExponentialRampToValue event.  This requires
+  // special handling because the ramp should start at whatever value
+  // the SetTarget event has reached at this time, instead of using
+  // the value of the SetTarget event.
+  void processSetTargetFollowedByRamp(int eventIndex,
+                                      ParamEvent*& currentEvent,
+                                      ParamEvent::Type nextEventType,
+                                      size_t currentFrame,
+                                      double sampleRate,
+                                      double controlRate,
+                                      float& value);
+
+  // Handle processing of linearRampEvent, writing the appropriate
+  // values to |values|.  Returns the updated |currentFrame|, last
+  // computed |value|, and the updated \writeIndex|.

[hongchan, 2017/02/10 23:37:29]

\writeIndex| => |writeIndex|

+ and all the following instances.

[Raymond Toy, 2017/02/14 19:55:52]

Done.

+  std::tuple<size_t, float, unsigned> processLinearRamp(
+      const AutomationState& currentState,
+      float* values,
+      size_t currentFrame,
+      float value,
+      unsigned writeIndex);
+
+  // Handle processing of exponentialRampEvent, writing the appropriate
+  // values to |values|.  Returns the updated |currentFrame|, last
+  // computed |value|, and the updated \writeIndex|.
+  std::tuple<size_t, float, unsigned> processExponentialRamp(
+      const AutomationState& currentState,
+      float* values,
+      size_t currentFrame,
+      float value,
+      unsigned writeIndex);
+
+  // Handle processing of SetTargetEvent, writing the appropriate
+  // values to |values|.  Returns the updated |currentFrame|, last
+  // computed |value|, and the updated \writeIndex|.
+  std::tuple<size_t, float, unsigned> processSetTarget(
+      const AutomationState& currentState,
+      float* values,
+      size_t currentFrame,
+      float value,
+      unsigned writeIndex);
+
+  // Handle processing of SetValueCurveEvent, writing the appropriate
+  // values to |values|.  Returns the updated |currentFrame|, last
+  // computed |value|, and the updated \writeIndex|.
+  std::tuple<size_t, float, unsigned> processSetValueCurve(
+      const AutomationState& currentState,
+      float* values,
+      size_t currentFrame,
+      float value,
+      unsigned writeIndex);
+
+  // Handle processing of CancelValuesEvent, writing the appropriate
+  // values to |values|.  Returns the updated |currentFrame|, last
+  // computed |value|, and the updated \writeIndex|.
+  std::tuple<size_t, float, unsigned> processCancelValues(
+      const AutomationState& currentState,
+      float* values,
+      size_t currentFrame,
+      float value,
+      unsigned writeIndex);
+
+  // Fill the output vector |values| with the value |defaultValue|,
+  // starting at |writeIndex| and continuing up to |endFrame|
+  // (exclusive).  |writeIndex| is updated with the new index.
+  unsigned fillWithDefault(float* values,
+                           float defaultValue,
+                           size_t endFrame,
+                           unsigned writeIndex);
+
   // Vector of all automation events for the AudioParam.  Access must
   // be locked via m_eventsLock.
   Vector<std::unique_ptr<ParamEvent>> m_events;