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 "modules/webaudio/AudioParam.h"
31
32#include "platform/audio/AudioUtilities.h"
33#include "modules/webaudio/AudioNode.h"
34#include "modules/webaudio/AudioNodeOutput.h"
35#include "platform/FloatConversion.h"
36#include "wtf/MathExtras.h"
37
38namespace blink {
39
40const double AudioParam::DefaultSmoothingConstant = 0.05;
41const double AudioParam::SnapThreshold = 0.001;
42
43float 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
57void 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
65float AudioParam::smoothedValue()
66{
67    return narrowPrecisionToFloat(m_smoothedValue);
68}
69
70bool 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) * DefaultSmoothingConstant;
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
97float AudioParam::finalValue()
98{
99    float value = m_value;
100    calculateFinalValues(&value, 1, false);
101    return value;
102}
103
104void 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
114void 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 (unsigned i = 0; i < numberOfRenderingConnections(); ++i) {
143        AudioNodeOutput* output = renderingOutput(i);
144        ASSERT(output);
145
146        // Render audio from this output.
147        AudioBus* connectionBus = output->pull(0, AudioNode::ProcessingSizeInFrames);
148
149        // Sum, with unity-gain.
150        summingBus->sumFrom(*connectionBus);
151    }
152}
153
154void AudioParam::calculateTimelineValues(float* values, unsigned numberOfValues)
155{
156    // Calculate values for this render quantum.
157    // Normally numberOfValues will equal AudioNode::ProcessingSizeInFrames (the render quantum size).
158    double sampleRate = context()->sampleRate();
159    double startTime = context()->currentTime();
160    double endTime = startTime + numberOfValues / sampleRate;
161
162    // Note we're running control rate at the sample-rate.
163    // Pass in the current value as default value.
164    m_value = m_timeline.valuesForTimeRange(startTime, endTime, narrowPrecisionToFloat(m_value), values, numberOfValues, sampleRate, sampleRate);
165}
166
167void AudioParam::connect(AudioNodeOutput& output)
168{
169    ASSERT(context()->isGraphOwner());
170
171    if (m_outputs.contains(&output))
172        return;
173
174    output.addParam(*this);
175    m_outputs.add(&output);
176    changedOutputs();
177}
178
179void AudioParam::disconnect(AudioNodeOutput& output)
180{
181    ASSERT(context()->isGraphOwner());
182
183    if (m_outputs.contains(&output)) {
184        m_outputs.remove(&output);
185        changedOutputs();
186        output.removeParam(*this);
187    }
188}
189
190} // namespace blink
191
192#endif // ENABLE(WEB_AUDIO)
193