312499b910a1f47a828709187de8bc846111b693
[WebKit-https.git] / Source / WebCore / Modules / webaudio / PannerNode.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  * 1.  Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2.  Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
15  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
16  * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
17  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
18  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
19  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
20  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
21  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
22  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23  */
24
25 #include "config.h"
26
27 #if ENABLE(WEB_AUDIO)
28
29 #include "PannerNode.h"
30
31 #include "AudioBufferSourceNode.h"
32 #include "AudioBus.h"
33 #include "AudioContext.h"
34 #include "AudioNodeInput.h"
35 #include "AudioNodeOutput.h"
36 #include "ExceptionCode.h"
37 #include "HRTFPanner.h"
38 #include "ScriptExecutionContext.h"
39 #include <wtf/MathExtras.h>
40
41 using namespace std;
42
43 namespace WebCore {
44
45 static void fixNANs(double &x)
46 {
47     if (isnan(x) || isinf(x))
48         x = 0.0;
49 }
50
51 PannerNode::PannerNode(AudioContext* context, float sampleRate)
52     : AudioNode(context, sampleRate)
53     , m_panningModel(Panner::PanningModelHRTF)
54     , m_lastGain(-1.0)
55     , m_connectionCount(0)
56 {
57     addInput(adoptPtr(new AudioNodeInput(this)));
58     addOutput(adoptPtr(new AudioNodeOutput(this, 2)));
59     
60     m_distanceGain = AudioGain::create(context, "distanceGain", 1.0, 0.0, 1.0);
61     m_coneGain = AudioGain::create(context, "coneGain", 1.0, 0.0, 1.0);
62
63     m_position = FloatPoint3D(0, 0, 0);
64     m_orientation = FloatPoint3D(1, 0, 0);
65     m_velocity = FloatPoint3D(0, 0, 0);
66     
67     setNodeType(NodeTypePanner);
68
69     initialize();
70 }
71
72 PannerNode::~PannerNode()
73 {
74     uninitialize();
75 }
76
77 void PannerNode::pullInputs(size_t framesToProcess)
78 {
79     // We override pullInputs(), so we can detect new AudioSourceNodes which have connected to us when new connections are made.
80     // These AudioSourceNodes need to be made aware of our existence in order to handle doppler shift pitch changes.
81     if (m_connectionCount != context()->connectionCount()) {
82         m_connectionCount = context()->connectionCount();
83
84         // Recursively go through all nodes connected to us.
85         notifyAudioSourcesConnectedToNode(this);
86     }
87     
88     AudioNode::pullInputs(framesToProcess);
89 }
90
91 void PannerNode::process(size_t framesToProcess)
92 {
93     AudioBus* destination = output(0)->bus();
94
95     if (!isInitialized() || !input(0)->isConnected() || !m_panner.get()) {
96         destination->zero();
97         return;
98     }
99
100     AudioBus* source = input(0)->bus();
101
102     if (!source) {
103         destination->zero();
104         return;
105     }
106
107     // Apply the panning effect.
108     double azimuth;
109     double elevation;
110     getAzimuthElevation(&azimuth, &elevation);
111     m_panner->pan(azimuth, elevation, source, destination, framesToProcess);
112
113     // Get the distance and cone gain.
114     double totalGain = distanceConeGain();
115
116     // Snap to desired gain at the beginning.
117     if (m_lastGain == -1.0)
118         m_lastGain = totalGain;
119         
120     // Apply gain in-place with de-zippering.
121     destination->copyWithGainFrom(*destination, &m_lastGain, totalGain);
122 }
123
124 void PannerNode::reset()
125 {
126     m_lastGain = -1.0; // force to snap to initial gain
127     if (m_panner.get())
128         m_panner->reset();
129 }
130
131 void PannerNode::initialize()
132 {
133     if (isInitialized())
134         return;
135         
136     m_panner = Panner::create(m_panningModel, sampleRate());
137
138     AudioNode::initialize();
139 }
140
141 void PannerNode::uninitialize()
142 {
143     if (!isInitialized())
144         return;
145         
146     m_panner.clear();
147     AudioNode::uninitialize();
148 }
149
150 AudioListener* PannerNode::listener()
151 {
152     return context()->listener();
153 }
154
155 String PannerNode::panningModel() const
156 {
157     switch (m_panningModel) {
158     case EQUALPOWER:
159         return "equalpower";
160     case HRTF:
161         return "HRTF";
162     case SOUNDFIELD:
163         return "soundfield";
164     default:
165         ASSERT_NOT_REACHED();
166         return "HRTF";
167     }
168 }
169
170 void PannerNode::setPanningModel(const String& model)
171 {
172     if (model == "equalpower")
173         setPanningModel(EQUALPOWER);
174     else if (model == "HRTF")
175         setPanningModel(HRTF);
176     else if (model == "soundfield")
177         setPanningModel(SOUNDFIELD);
178     else
179         ASSERT_NOT_REACHED();
180 }
181
182 bool PannerNode::setPanningModel(unsigned model)
183 {
184     switch (model) {
185     case EQUALPOWER:
186     case HRTF:
187         if (!m_panner.get() || model != m_panningModel) {
188             OwnPtr<Panner> newPanner = Panner::create(model, sampleRate());
189             m_panner = newPanner.release();
190             m_panningModel = model;
191         }
192         break;
193     case SOUNDFIELD:
194         // FIXME: Implement sound field model. See // https://bugs.webkit.org/show_bug.cgi?id=77367.
195         context()->scriptExecutionContext()->addConsoleMessage(JSMessageSource, WarningMessageLevel, "'soundfield' panning model not implemented.");
196         break;
197     default:
198         return false;
199     }
200     
201     return true;
202 }
203
204 String PannerNode::distanceModel() const
205 {
206     switch (const_cast<PannerNode*>(this)->m_distanceEffect.model()) {
207     case DistanceEffect::ModelLinear:
208         return "linear";
209     case DistanceEffect::ModelInverse:
210         return "inverse";
211     case DistanceEffect::ModelExponential:
212         return "exponential";
213     default:
214         ASSERT_NOT_REACHED();
215         return "inverse";
216     }
217 }
218
219 void PannerNode::setDistanceModel(const String& model)
220 {
221     if (model == "linear")
222         setDistanceModel(DistanceEffect::ModelLinear);
223     else if (model == "inverse")
224         setDistanceModel(DistanceEffect::ModelInverse);
225     else if (model == "exponential")
226         setDistanceModel(DistanceEffect::ModelExponential);
227     else
228         ASSERT_NOT_REACHED();
229 }
230
231 bool PannerNode::setDistanceModel(unsigned model)
232 {
233     switch (model) {
234     case DistanceEffect::ModelLinear:
235     case DistanceEffect::ModelInverse:
236     case DistanceEffect::ModelExponential:
237         m_distanceEffect.setModel(static_cast<DistanceEffect::ModelType>(model), true);
238         break;
239     default:
240         return false;
241     }
242
243     return true;
244 }
245
246 void PannerNode::getAzimuthElevation(double* outAzimuth, double* outElevation)
247 {
248     // FIXME: we should cache azimuth and elevation (if possible), so we only re-calculate if a change has been made.
249
250     double azimuth = 0.0;
251
252     // Calculate the source-listener vector
253     FloatPoint3D listenerPosition = listener()->position();
254     FloatPoint3D sourceListener = m_position - listenerPosition;
255
256     if (sourceListener.isZero()) {
257         // degenerate case if source and listener are at the same point
258         *outAzimuth = 0.0;
259         *outElevation = 0.0;
260         return;
261     }
262
263     sourceListener.normalize();
264
265     // Align axes
266     FloatPoint3D listenerFront = listener()->orientation();
267     FloatPoint3D listenerUp = listener()->upVector();
268     FloatPoint3D listenerRight = listenerFront.cross(listenerUp);
269     listenerRight.normalize();
270
271     FloatPoint3D listenerFrontNorm = listenerFront;
272     listenerFrontNorm.normalize();
273
274     FloatPoint3D up = listenerRight.cross(listenerFrontNorm);
275
276     float upProjection = sourceListener.dot(up);
277
278     FloatPoint3D projectedSource = sourceListener - upProjection * up;
279     projectedSource.normalize();
280
281     azimuth = 180.0 * acos(projectedSource.dot(listenerRight)) / piDouble;
282     fixNANs(azimuth); // avoid illegal values
283
284     // Source  in front or behind the listener
285     double frontBack = projectedSource.dot(listenerFrontNorm);
286     if (frontBack < 0.0)
287         azimuth = 360.0 - azimuth;
288
289     // Make azimuth relative to "front" and not "right" listener vector
290     if ((azimuth >= 0.0) && (azimuth <= 270.0))
291         azimuth = 90.0 - azimuth;
292     else
293         azimuth = 450.0 - azimuth;
294
295     // Elevation
296     double elevation = 90.0 - 180.0 * acos(sourceListener.dot(up)) / piDouble;
297     fixNANs(elevation); // avoid illegal values
298
299     if (elevation > 90.0)
300         elevation = 180.0 - elevation;
301     else if (elevation < -90.0)
302         elevation = -180.0 - elevation;
303
304     if (outAzimuth)
305         *outAzimuth = azimuth;
306     if (outElevation)
307         *outElevation = elevation;
308 }
309
310 float PannerNode::dopplerRate()
311 {
312     double dopplerShift = 1.0;
313
314     // FIXME: optimize for case when neither source nor listener has changed...
315     double dopplerFactor = listener()->dopplerFactor();
316
317     if (dopplerFactor > 0.0) {
318         double speedOfSound = listener()->speedOfSound();
319
320         const FloatPoint3D &sourceVelocity = m_velocity;
321         const FloatPoint3D &listenerVelocity = listener()->velocity();
322
323         // Don't bother if both source and listener have no velocity
324         bool sourceHasVelocity = !sourceVelocity.isZero();
325         bool listenerHasVelocity = !listenerVelocity.isZero();
326
327         if (sourceHasVelocity || listenerHasVelocity) {
328             // Calculate the source to listener vector
329             FloatPoint3D listenerPosition = listener()->position();
330             FloatPoint3D sourceToListener = m_position - listenerPosition;
331
332             double sourceListenerMagnitude = sourceToListener.length();
333
334             double listenerProjection = sourceToListener.dot(listenerVelocity) / sourceListenerMagnitude;
335             double sourceProjection = sourceToListener.dot(sourceVelocity) / sourceListenerMagnitude;
336
337             listenerProjection = -listenerProjection;
338             sourceProjection = -sourceProjection;
339
340             double scaledSpeedOfSound = speedOfSound / dopplerFactor;
341             listenerProjection = min(listenerProjection, scaledSpeedOfSound);
342             sourceProjection = min(sourceProjection, scaledSpeedOfSound);
343
344             dopplerShift = ((speedOfSound - dopplerFactor * listenerProjection) / (speedOfSound - dopplerFactor * sourceProjection));
345             fixNANs(dopplerShift); // avoid illegal values
346
347             // Limit the pitch shifting to 4 octaves up and 3 octaves down.
348             if (dopplerShift > 16.0)
349                 dopplerShift = 16.0;
350             else if (dopplerShift < 0.125)
351                 dopplerShift = 0.125;   
352         }
353     }
354
355     return static_cast<float>(dopplerShift);
356 }
357
358 float PannerNode::distanceConeGain()
359 {
360     FloatPoint3D listenerPosition = listener()->position();
361
362     double listenerDistance = m_position.distanceTo(listenerPosition);
363     double distanceGain = m_distanceEffect.gain(listenerDistance);
364     
365     m_distanceGain->setValue(static_cast<float>(distanceGain));
366
367     // FIXME: could optimize by caching coneGain
368     double coneGain = m_coneEffect.gain(m_position, m_orientation, listenerPosition);
369     
370     m_coneGain->setValue(static_cast<float>(coneGain));
371
372     return float(distanceGain * coneGain);
373 }
374
375 void PannerNode::notifyAudioSourcesConnectedToNode(AudioNode* node)
376 {
377     ASSERT(node);
378     if (!node)
379         return;
380         
381     // First check if this node is an AudioBufferSourceNode. If so, let it know about us so that doppler shift pitch can be taken into account.
382     if (node->nodeType() == NodeTypeAudioBufferSource) {
383         AudioBufferSourceNode* bufferSourceNode = reinterpret_cast<AudioBufferSourceNode*>(node);
384         bufferSourceNode->setPannerNode(this);
385     } else {    
386         // Go through all inputs to this node.
387         for (unsigned i = 0; i < node->numberOfInputs(); ++i) {
388             AudioNodeInput* input = node->input(i);
389
390             // For each input, go through all of its connections, looking for AudioBufferSourceNodes.
391             for (unsigned j = 0; j < input->numberOfRenderingConnections(); ++j) {
392                 AudioNodeOutput* connectedOutput = input->renderingOutput(j);
393                 AudioNode* connectedNode = connectedOutput->node();
394                 notifyAudioSourcesConnectedToNode(connectedNode); // recurse
395             }
396         }
397     }
398 }
399
400 } // namespace WebCore
401
402 #endif // ENABLE(WEB_AUDIO)