Use modern for-loops in WebCore/Modules - 2
[WebKit-https.git] / Source / WebCore / Modules / webaudio / AudioParam.cpp
1 /*
2  * Copyright (C) 2010 Google Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer.
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
16  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
18  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
19  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
20  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
21  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27
28 #if ENABLE(WEB_AUDIO)
29
30 #include "AudioParam.h"
31
32 #include "AudioNode.h"
33 #include "AudioNodeOutput.h"
34 #include "AudioUtilities.h"
35 #include "FloatConversion.h"
36 #include <wtf/MathExtras.h>
37
38 namespace WebCore {
39
40 const double AudioParam::DefaultSmoothingConstant = 0.05;
41 const double AudioParam::SnapThreshold = 0.001;
42
43 float AudioParam::value()
44 {
45     // Update value for timeline.
46     if (context() && context()->isAudioThread()) {
47         bool hasValue;
48         float timelineValue = m_timeline.valueForContextTime(context(), narrowPrecisionToFloat(m_value), hasValue);
49
50         if (hasValue)
51             m_value = timelineValue;
52     }
53
54     return narrowPrecisionToFloat(m_value);
55 }
56
57 void AudioParam::setValue(float value)
58 {
59     // Check against JavaScript giving us bogus floating-point values.
60     // Don't ASSERT, since this can happen if somebody writes bad JS.
61     if (!std::isnan(value) && !std::isinf(value))
62         m_value = value;
63 }
64
65 float AudioParam::smoothedValue()
66 {
67     return narrowPrecisionToFloat(m_smoothedValue);
68 }
69
70 bool AudioParam::smooth()
71 {
72     // If values have been explicitly scheduled on the timeline, then use the exact value.
73     // Smoothing effectively is performed by the timeline.
74     bool useTimelineValue = false;
75     if (context())
76         m_value = m_timeline.valueForContextTime(context(), narrowPrecisionToFloat(m_value), useTimelineValue);
77     
78     if (m_smoothedValue == m_value) {
79         // Smoothed value has already approached and snapped to value.
80         return true;
81     }
82     
83     if (useTimelineValue)
84         m_smoothedValue = m_value;
85     else {
86         // Dezipper - exponential approach.
87         m_smoothedValue += (m_value - m_smoothedValue) * m_smoothingConstant;
88
89         // If we get close enough then snap to actual value.
90         if (fabs(m_smoothedValue - m_value) < SnapThreshold) // FIXME: the threshold needs to be adjustable depending on range - but this is OK general purpose value.
91             m_smoothedValue = m_value;
92     }
93
94     return false;
95 }
96
97 float AudioParam::finalValue()
98 {
99     float value;
100     calculateFinalValues(&value, 1, false);
101     return value;
102 }
103
104 void AudioParam::calculateSampleAccurateValues(float* values, unsigned numberOfValues)
105 {
106     bool isSafe = context() && context()->isAudioThread() && values && numberOfValues;
107     ASSERT(isSafe);
108     if (!isSafe)
109         return;
110
111     calculateFinalValues(values, numberOfValues, true);
112 }
113
114 void AudioParam::calculateFinalValues(float* values, unsigned numberOfValues, bool sampleAccurate)
115 {
116     bool isGood = context() && context()->isAudioThread() && values && numberOfValues;
117     ASSERT(isGood);
118     if (!isGood)
119         return;
120
121     // The calculated result will be the "intrinsic" value summed with all audio-rate connections.
122
123     if (sampleAccurate) {
124         // Calculate sample-accurate (a-rate) intrinsic values.
125         calculateTimelineValues(values, numberOfValues);
126     } else {
127         // Calculate control-rate (k-rate) intrinsic value.
128         bool hasValue;
129         float timelineValue = m_timeline.valueForContextTime(context(), narrowPrecisionToFloat(m_value), hasValue);
130
131         if (hasValue)
132             m_value = timelineValue;
133
134         values[0] = narrowPrecisionToFloat(m_value);
135     }
136
137     // Now sum all of the audio-rate connections together (unity-gain summing junction).
138     // Note that connections would normally be mono, but we mix down to mono if necessary.
139     RefPtr<AudioBus> summingBus = AudioBus::create(1, numberOfValues, false);
140     summingBus->setChannelMemory(0, values, numberOfValues);
141
142     for (auto& output : m_renderingOutputs) {
143         ASSERT(output);
144
145         // Render audio from this output.
146         AudioBus* connectionBus = output->pull(0, AudioNode::ProcessingSizeInFrames);
147
148         // Sum, with unity-gain.
149         summingBus->sumFrom(*connectionBus);
150     }
151 }
152
153 void AudioParam::calculateTimelineValues(float* values, unsigned numberOfValues)
154 {
155     // Calculate values for this render quantum.
156     // Normally numberOfValues will equal AudioNode::ProcessingSizeInFrames (the render quantum size).
157     double sampleRate = context()->sampleRate();
158     double startTime = context()->currentTime();
159     double endTime = startTime + numberOfValues / sampleRate;
160
161     // Note we're running control rate at the sample-rate.
162     // Pass in the current value as default value.
163     m_value = m_timeline.valuesForTimeRange(startTime, endTime, narrowPrecisionToFloat(m_value), values, numberOfValues, sampleRate, sampleRate);
164 }
165
166 void AudioParam::connect(AudioNodeOutput* output)
167 {
168     ASSERT(context()->isGraphOwner());
169
170     ASSERT(output);
171     if (!output)
172         return;
173
174     if (!m_outputs.add(output).isNewEntry)
175         return;
176
177     output->addParam(this);
178     changedOutputs();
179 }
180
181 void AudioParam::disconnect(AudioNodeOutput* output)
182 {
183     ASSERT(context()->isGraphOwner());
184
185     ASSERT(output);
186     if (!output)
187         return;
188
189     if (m_outputs.remove(output)) {
190         changedOutputs();
191         output->removeParam(this);
192     }
193 }
194
195 } // namespace WebCore
196
197 #endif // ENABLE(WEB_AUDIO)