3264b5b1b5100160e7f88327fcb6515c2c6edcf0
[WebKit-https.git] / Source / WebCore / Modules / webaudio / AudioNode.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 "AudioNode.h"
30
31 #include "AudioContext.h"
32 #include "AudioNodeInput.h"
33 #include "AudioNodeOutput.h"
34 #include "AudioParam.h"
35 #include "ExceptionCode.h"
36 #include <wtf/Atomics.h>
37 #include <wtf/MainThread.h>
38
39 #if DEBUG_AUDIONODE_REFERENCES
40 #include <stdio.h>
41 #endif
42
43 namespace WebCore {
44
45 AudioNode::AudioNode(AudioContext* context, float sampleRate)
46     : m_isInitialized(false)
47     , m_nodeType(NodeTypeUnknown)
48     , m_context(context)
49     , m_sampleRate(sampleRate)
50     , m_lastProcessingTime(-1)
51     , m_lastNonSilentTime(-1)
52     , m_normalRefCount(1) // start out with normal refCount == 1 (like WTF::RefCounted class)
53     , m_connectionRefCount(0)
54     , m_isMarkedForDeletion(false)
55     , m_isDisabled(false)
56     , m_channelCount(2)
57     , m_channelCountMode(Max)
58     , m_channelInterpretation(AudioBus::Speakers)
59 {
60 #if DEBUG_AUDIONODE_REFERENCES
61     if (!s_isNodeCountInitialized) {
62         s_isNodeCountInitialized = true;
63         atexit(AudioNode::printNodeCounts);
64     }
65 #endif
66 }
67
68 AudioNode::~AudioNode()
69 {
70     ASSERT(isMainThread());
71 #if DEBUG_AUDIONODE_REFERENCES
72     --s_nodeCount[nodeType()];
73     fprintf(stderr, "%p: %d: AudioNode::~AudioNode() %d %d\n", this, nodeType(), m_normalRefCount.load(), m_connectionRefCount);
74 #endif
75 }
76
77 void AudioNode::initialize()
78 {
79     m_isInitialized = true;
80 }
81
82 void AudioNode::uninitialize()
83 {
84     m_isInitialized = false;
85 }
86
87 void AudioNode::setNodeType(NodeType type)
88 {
89     m_nodeType = type;
90
91 #if DEBUG_AUDIONODE_REFERENCES
92     ++s_nodeCount[type];
93 #endif
94 }
95
96 void AudioNode::lazyInitialize()
97 {
98     if (!isInitialized())
99         initialize();
100 }
101
102 void AudioNode::addInput(std::unique_ptr<AudioNodeInput> input)
103 {
104     m_inputs.append(WTF::move(input));
105 }
106
107 void AudioNode::addOutput(std::unique_ptr<AudioNodeOutput> output)
108 {
109     m_outputs.append(WTF::move(output));
110 }
111
112 AudioNodeInput* AudioNode::input(unsigned i)
113 {
114     if (i < m_inputs.size())
115         return m_inputs[i].get();
116     return nullptr;
117 }
118
119 AudioNodeOutput* AudioNode::output(unsigned i)
120 {
121     if (i < m_outputs.size())
122         return m_outputs[i].get();
123     return nullptr;
124 }
125
126 void AudioNode::connect(AudioNode* destination, unsigned outputIndex, unsigned inputIndex, ExceptionCode& ec)
127 {
128     ASSERT(isMainThread()); 
129     AudioContext::AutoLocker locker(*context());
130
131     if (!destination) {
132         ec = SYNTAX_ERR;
133         return;
134     }
135
136     // Sanity check input and output indices.
137     if (outputIndex >= numberOfOutputs()) {
138         ec = INDEX_SIZE_ERR;
139         return;
140     }
141
142     if (destination && inputIndex >= destination->numberOfInputs()) {
143         ec = INDEX_SIZE_ERR;
144         return;
145     }
146
147     if (context() != destination->context()) {
148         ec = SYNTAX_ERR;
149         return;
150     }
151
152     AudioNodeInput* input = destination->input(inputIndex);
153     AudioNodeOutput* output = this->output(outputIndex);
154     input->connect(output);
155
156     // Let context know that a connection has been made.
157     context()->incrementConnectionCount();
158 }
159
160 void AudioNode::connect(AudioParam* param, unsigned outputIndex, ExceptionCode& ec)
161 {
162     ASSERT(isMainThread());
163     AudioContext::AutoLocker locker(*context());
164
165     if (!param) {
166         ec = SYNTAX_ERR;
167         return;
168     }
169
170     if (outputIndex >= numberOfOutputs()) {
171         ec = INDEX_SIZE_ERR;
172         return;
173     }
174
175     if (context() != param->context()) {
176         ec = SYNTAX_ERR;
177         return;
178     }
179
180     AudioNodeOutput* output = this->output(outputIndex);
181     param->connect(output);
182 }
183
184 void AudioNode::disconnect(unsigned outputIndex, ExceptionCode& ec)
185 {
186     ASSERT(isMainThread());
187     AudioContext::AutoLocker locker(*context());
188
189     // Sanity check input and output indices.
190     if (outputIndex >= numberOfOutputs()) {
191         ec = INDEX_SIZE_ERR;
192         return;
193     }
194
195     AudioNodeOutput* output = this->output(outputIndex);
196     output->disconnectAll();
197 }
198
199 unsigned long AudioNode::channelCount()
200 {
201     return m_channelCount;
202 }
203
204 void AudioNode::setChannelCount(unsigned long channelCount, ExceptionCode& ec)
205 {
206     ASSERT(isMainThread());
207     AudioContext::AutoLocker locker(*context());
208
209     if (channelCount > 0 && channelCount <= AudioContext::maxNumberOfChannels()) {
210         if (m_channelCount != channelCount) {
211             m_channelCount = channelCount;
212             if (m_channelCountMode != Max)
213                 updateChannelsForInputs();
214         }
215     } else
216         ec = INVALID_STATE_ERR;
217 }
218
219 String AudioNode::channelCountMode()
220 {
221     switch (m_channelCountMode) {
222     case Max:
223         return "max";
224     case ClampedMax:
225         return "clamped-max";
226     case Explicit:
227         return "explicit";
228     }
229     ASSERT_NOT_REACHED();
230     return "";
231 }
232
233 void AudioNode::setChannelCountMode(const String& mode, ExceptionCode& ec)
234 {
235     ASSERT(isMainThread());
236     AudioContext::AutoLocker locker(*context());
237
238     ChannelCountMode oldMode = m_channelCountMode;
239
240     if (mode == "max")
241         m_channelCountMode = Max;
242     else if (mode == "clamped-max")
243         m_channelCountMode = ClampedMax;
244     else if (mode == "explicit")
245         m_channelCountMode = Explicit;
246     else
247         ec = INVALID_STATE_ERR;
248
249     if (m_channelCountMode != oldMode)
250         updateChannelsForInputs();
251 }
252
253 String AudioNode::channelInterpretation()
254 {
255     switch (m_channelInterpretation) {
256     case AudioBus::Speakers:
257         return "speakers";
258     case AudioBus::Discrete:
259         return "discrete";
260     }
261     ASSERT_NOT_REACHED();
262     return "";
263 }
264
265 void AudioNode::setChannelInterpretation(const String& interpretation, ExceptionCode& ec)
266 {
267     ASSERT(isMainThread());
268     AudioContext::AutoLocker locker(*context());
269
270     if (interpretation == "speakers")
271         m_channelInterpretation = AudioBus::Speakers;
272     else if (interpretation == "discrete")
273         m_channelInterpretation = AudioBus::Discrete;
274     else
275         ec = INVALID_STATE_ERR;
276 }
277
278 void AudioNode::updateChannelsForInputs()
279 {
280     for (unsigned i = 0; i < m_inputs.size(); ++i)
281         input(i)->changedOutputs();
282 }
283
284 EventTargetInterface AudioNode::eventTargetInterface() const
285 {
286     return AudioNodeEventTargetInterfaceType;
287 }
288
289 ScriptExecutionContext* AudioNode::scriptExecutionContext() const
290 {
291     return const_cast<AudioNode*>(this)->context()->scriptExecutionContext();
292 }
293
294 void AudioNode::processIfNecessary(size_t framesToProcess)
295 {
296     ASSERT(context()->isAudioThread());
297
298     if (!isInitialized())
299         return;
300
301     // Ensure that we only process once per rendering quantum.
302     // This handles the "fanout" problem where an output is connected to multiple inputs.
303     // The first time we're called during this time slice we process, but after that we don't want to re-process,
304     // instead our output(s) will already have the results cached in their bus;
305     double currentTime = context()->currentTime();
306     if (m_lastProcessingTime != currentTime) {
307         m_lastProcessingTime = currentTime; // important to first update this time because of feedback loops in the rendering graph
308
309         pullInputs(framesToProcess);
310
311         bool silentInputs = inputsAreSilent();
312         if (!silentInputs)
313             m_lastNonSilentTime = (context()->currentSampleFrame() + framesToProcess) / static_cast<double>(m_sampleRate);
314
315         if (silentInputs && propagatesSilence())
316             silenceOutputs();
317         else {
318             process(framesToProcess);
319             unsilenceOutputs();
320         }
321     }
322 }
323
324 void AudioNode::checkNumberOfChannelsForInput(AudioNodeInput* input)
325 {
326     ASSERT(context()->isAudioThread() && context()->isGraphOwner());
327
328     for (const std::unique_ptr<AudioNodeInput>& savedInput : m_inputs) {
329         if (input == savedInput.get()) {
330             input->updateInternalBus();
331             return;
332         }
333     }
334
335     ASSERT_NOT_REACHED();
336 }
337
338 bool AudioNode::propagatesSilence() const
339 {
340     return m_lastNonSilentTime + latencyTime() + tailTime() < context()->currentTime();
341 }
342
343 void AudioNode::pullInputs(size_t framesToProcess)
344 {
345     ASSERT(context()->isAudioThread());
346     
347     // Process all of the AudioNodes connected to our inputs.
348     for (unsigned i = 0; i < m_inputs.size(); ++i)
349         input(i)->pull(0, framesToProcess);
350 }
351
352 bool AudioNode::inputsAreSilent()
353 {
354     for (unsigned i = 0; i < m_inputs.size(); ++i) {
355         if (!input(i)->bus()->isSilent())
356             return false;
357     }
358     return true;
359 }
360
361 void AudioNode::silenceOutputs()
362 {
363     for (unsigned i = 0; i < m_outputs.size(); ++i)
364         output(i)->bus()->zero();
365 }
366
367 void AudioNode::unsilenceOutputs()
368 {
369     for (unsigned i = 0; i < m_outputs.size(); ++i)
370         output(i)->bus()->clearSilentFlag();
371 }
372
373 void AudioNode::enableOutputsIfNecessary()
374 {
375     if (m_isDisabled && m_connectionRefCount > 0) {
376         ASSERT(isMainThread());
377         AudioContext::AutoLocker locker(*context());
378
379         m_isDisabled = false;
380         for (unsigned i = 0; i < m_outputs.size(); ++i)
381             output(i)->enable();
382     }
383 }
384
385 void AudioNode::disableOutputsIfNecessary()
386 {
387     // Disable outputs if appropriate. We do this if the number of connections is 0 or 1. The case
388     // of 0 is from finishDeref() where there are no connections left. The case of 1 is from
389     // AudioNodeInput::disable() where we want to disable outputs when there's only one connection
390     // left because we're ready to go away, but can't quite yet.
391     if (m_connectionRefCount <= 1 && !m_isDisabled) {
392         // Still may have JavaScript references, but no more "active" connection references, so put all of our outputs in a "dormant" disabled state.
393         // Garbage collection may take a very long time after this time, so the "dormant" disabled nodes should not bog down the rendering...
394
395         // As far as JavaScript is concerned, our outputs must still appear to be connected.
396         // But internally our outputs should be disabled from the inputs they're connected to.
397         // disable() can recursively deref connections (and call disable()) down a whole chain of connected nodes.
398
399         // FIXME: we special case the convolver and delay since they have a significant tail-time and shouldn't be disconnected simply
400         // because they no longer have any input connections. This needs to be handled more generally where AudioNodes have
401         // a tailTime attribute. Then the AudioNode only needs to remain "active" for tailTime seconds after there are no
402         // longer any active connections.
403         if (nodeType() != NodeTypeConvolver && nodeType() != NodeTypeDelay) {
404             m_isDisabled = true;
405             for (unsigned i = 0; i < m_outputs.size(); ++i)
406                 output(i)->disable();
407         }
408     }
409 }
410
411 void AudioNode::ref(RefType refType)
412 {
413     switch (refType) {
414     case RefTypeNormal:
415         ++m_normalRefCount;
416         break;
417     case RefTypeConnection:
418         ++m_connectionRefCount;
419         break;
420     default:
421         ASSERT_NOT_REACHED();
422     }
423
424 #if DEBUG_AUDIONODE_REFERENCES
425     fprintf(stderr, "%p: %d: AudioNode::ref(%d) %d %d\n", this, nodeType(), refType, m_normalRefCount, m_connectionRefCount);
426 #endif
427
428     // See the disabling code in finishDeref() below. This handles the case where a node
429     // is being re-connected after being used at least once and disconnected.
430     // In this case, we need to re-enable.
431     if (refType == RefTypeConnection)
432         enableOutputsIfNecessary();
433 }
434
435 void AudioNode::deref(RefType refType)
436 {
437     // The actually work for deref happens completely within the audio context's graph lock.
438     // In the case of the audio thread, we must use a tryLock to avoid glitches.
439     bool hasLock = false;
440     bool mustReleaseLock = false;
441     
442     if (context()->isAudioThread()) {
443         // Real-time audio thread must not contend lock (to avoid glitches).
444         hasLock = context()->tryLock(mustReleaseLock);
445     } else {
446         context()->lock(mustReleaseLock);
447         hasLock = true;
448     }
449     
450     if (hasLock) {
451         // This is where the real deref work happens.
452         finishDeref(refType);
453
454         if (mustReleaseLock)
455             context()->unlock();
456     } else {
457         // We were unable to get the lock, so put this in a list to finish up later.
458         ASSERT(context()->isAudioThread());
459         ASSERT(refType == RefTypeConnection);
460         context()->addDeferredFinishDeref(this);
461     }
462
463     // Once AudioContext::uninitialize() is called there's no more chances for deleteMarkedNodes() to get called, so we call here.
464     // We can't call in AudioContext::~AudioContext() since it will never be called as long as any AudioNode is alive
465     // because AudioNodes keep a reference to the context.
466     if (context()->isAudioThreadFinished())
467         context()->deleteMarkedNodes();
468 }
469
470 void AudioNode::finishDeref(RefType refType)
471 {
472     ASSERT(context()->isGraphOwner());
473     
474     switch (refType) {
475     case RefTypeNormal:
476         ASSERT(m_normalRefCount > 0);
477         --m_normalRefCount;
478         break;
479     case RefTypeConnection:
480         ASSERT(m_connectionRefCount > 0);
481         --m_connectionRefCount;
482         break;
483     default:
484         ASSERT_NOT_REACHED();
485     }
486     
487 #if DEBUG_AUDIONODE_REFERENCES
488     fprintf(stderr, "%p: %d: AudioNode::deref(%d) %d %d\n", this, nodeType(), refType, m_normalRefCount, m_connectionRefCount);
489 #endif
490
491     if (!m_connectionRefCount) {
492         if (!m_normalRefCount) {
493             if (!m_isMarkedForDeletion) {
494                 // All references are gone - we need to go away.
495                 for (unsigned i = 0; i < m_outputs.size(); ++i)
496                     output(i)->disconnectAll(); // This will deref() nodes we're connected to.
497
498                 // Mark for deletion at end of each render quantum or when context shuts down.
499                 context()->markForDeletion(this);
500                 m_isMarkedForDeletion = true;
501             }
502         } else if (refType == RefTypeConnection)
503             disableOutputsIfNecessary();
504     }
505 }
506
507 #if DEBUG_AUDIONODE_REFERENCES
508
509 bool AudioNode::s_isNodeCountInitialized = false;
510 int AudioNode::s_nodeCount[NodeTypeEnd];
511
512 void AudioNode::printNodeCounts()
513 {
514     fprintf(stderr, "\n\n");
515     fprintf(stderr, "===========================\n");
516     fprintf(stderr, "AudioNode: reference counts\n");
517     fprintf(stderr, "===========================\n");
518
519     for (unsigned i = 0; i < NodeTypeEnd; ++i)
520         fprintf(stderr, "%d: %d\n", i, s_nodeCount[i]);
521
522     fprintf(stderr, "===========================\n\n\n");
523 }
524
525 #endif // DEBUG_AUDIONODE_REFERENCES
526
527 } // namespace WebCore
528
529 #endif // ENABLE(WEB_AUDIO)