Remove all uses of PassRefPtr in WebCore/svg
[WebKit-https.git] / Source / WebCore / Modules / webaudio / ScriptProcessorNode.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 "ScriptProcessorNode.h"
30
31 #include "AudioBuffer.h"
32 #include "AudioBus.h"
33 #include "AudioContext.h"
34 #include "AudioNodeInput.h"
35 #include "AudioNodeOutput.h"
36 #include "AudioProcessingEvent.h"
37 #include "Document.h"
38 #include <runtime/Float32Array.h>
39 #include <wtf/MainThread.h>
40
41 namespace WebCore {
42
43 RefPtr<ScriptProcessorNode> ScriptProcessorNode::create(AudioContext* context, float sampleRate, size_t bufferSize, unsigned numberOfInputChannels, unsigned numberOfOutputChannels)
44 {
45     // Check for valid buffer size.
46     switch (bufferSize) {
47     case 256:
48     case 512:
49     case 1024:
50     case 2048:
51     case 4096:
52     case 8192:
53     case 16384:
54         break;
55     default:
56         return nullptr;
57     }
58
59     if (!numberOfInputChannels && !numberOfOutputChannels)
60         return nullptr;
61
62     if (numberOfInputChannels > AudioContext::maxNumberOfChannels())
63         return nullptr;
64
65     if (numberOfOutputChannels > AudioContext::maxNumberOfChannels())
66         return nullptr;
67
68     return adoptRef(*new ScriptProcessorNode(context, sampleRate, bufferSize, numberOfInputChannels, numberOfOutputChannels));
69 }
70
71 ScriptProcessorNode::ScriptProcessorNode(AudioContext* context, float sampleRate, size_t bufferSize, unsigned numberOfInputChannels, unsigned numberOfOutputChannels)
72     : AudioNode(context, sampleRate)
73     , m_doubleBufferIndex(0)
74     , m_doubleBufferIndexForEvent(0)
75     , m_bufferSize(bufferSize)
76     , m_bufferReadWriteIndex(0)
77     , m_isRequestOutstanding(false)
78     , m_numberOfInputChannels(numberOfInputChannels)
79     , m_numberOfOutputChannels(numberOfOutputChannels)
80     , m_internalInputBus(AudioBus::create(numberOfInputChannels, AudioNode::ProcessingSizeInFrames, false))
81     , m_hasAudioProcessListener(false)
82 {
83     // Regardless of the allowed buffer sizes, we still need to process at the granularity of the AudioNode.
84     if (m_bufferSize < AudioNode::ProcessingSizeInFrames)
85         m_bufferSize = AudioNode::ProcessingSizeInFrames;
86
87     ASSERT(numberOfInputChannels <= AudioContext::maxNumberOfChannels());
88
89     addInput(std::make_unique<AudioNodeInput>(this));
90     addOutput(std::make_unique<AudioNodeOutput>(this, numberOfOutputChannels));
91
92     setNodeType(NodeTypeJavaScript);
93
94     initialize();
95 }
96
97 ScriptProcessorNode::~ScriptProcessorNode()
98 {
99     uninitialize();
100 }
101
102 void ScriptProcessorNode::initialize()
103 {
104     if (isInitialized())
105         return;
106
107     float sampleRate = context()->sampleRate();
108
109     // Create double buffers on both the input and output sides.
110     // These AudioBuffers will be directly accessed in the main thread by JavaScript.
111     for (unsigned i = 0; i < 2; ++i) {
112         RefPtr<AudioBuffer> inputBuffer = m_numberOfInputChannels ? AudioBuffer::create(m_numberOfInputChannels, bufferSize(), sampleRate) : 0;
113         RefPtr<AudioBuffer> outputBuffer = m_numberOfOutputChannels ? AudioBuffer::create(m_numberOfOutputChannels, bufferSize(), sampleRate) : 0;
114
115         m_inputBuffers.append(inputBuffer);
116         m_outputBuffers.append(outputBuffer);
117     }
118
119     AudioNode::initialize();
120 }
121
122 void ScriptProcessorNode::uninitialize()
123 {
124     if (!isInitialized())
125         return;
126
127     m_inputBuffers.clear();
128     m_outputBuffers.clear();
129
130     AudioNode::uninitialize();
131 }
132
133 void ScriptProcessorNode::process(size_t framesToProcess)
134 {
135     // Discussion about inputs and outputs:
136     // As in other AudioNodes, ScriptProcessorNode uses an AudioBus for its input and output (see inputBus and outputBus below).
137     // Additionally, there is a double-buffering for input and output which is exposed directly to JavaScript (see inputBuffer and outputBuffer below).
138     // This node is the producer for inputBuffer and the consumer for outputBuffer.
139     // The JavaScript code is the consumer of inputBuffer and the producer for outputBuffer.
140
141     // Check if audioprocess listener is set.
142     if (!m_hasAudioProcessListener)
143         return;
144
145     // Get input and output busses.
146     AudioBus* inputBus = this->input(0)->bus();
147     AudioBus* outputBus = this->output(0)->bus();
148
149     // Get input and output buffers. We double-buffer both the input and output sides.
150     unsigned doubleBufferIndex = this->doubleBufferIndex();
151     bool isDoubleBufferIndexGood = doubleBufferIndex < 2 && doubleBufferIndex < m_inputBuffers.size() && doubleBufferIndex < m_outputBuffers.size();
152     ASSERT(isDoubleBufferIndexGood);
153     if (!isDoubleBufferIndexGood)
154         return;
155     
156     AudioBuffer* inputBuffer = m_inputBuffers[doubleBufferIndex].get();
157     AudioBuffer* outputBuffer = m_outputBuffers[doubleBufferIndex].get();
158
159     // Check the consistency of input and output buffers.
160     unsigned numberOfInputChannels = m_internalInputBus->numberOfChannels();
161     bool buffersAreGood = outputBuffer && bufferSize() == outputBuffer->length() && m_bufferReadWriteIndex + framesToProcess <= bufferSize();
162
163     // If the number of input channels is zero, it's ok to have inputBuffer = 0.
164     if (m_internalInputBus->numberOfChannels())
165         buffersAreGood = buffersAreGood && inputBuffer && bufferSize() == inputBuffer->length();
166
167     ASSERT(buffersAreGood);
168     if (!buffersAreGood)
169         return;
170
171     // We assume that bufferSize() is evenly divisible by framesToProcess - should always be true, but we should still check.
172     bool isFramesToProcessGood = framesToProcess && bufferSize() >= framesToProcess && !(bufferSize() % framesToProcess);
173     ASSERT(isFramesToProcessGood);
174     if (!isFramesToProcessGood)
175         return;
176
177     unsigned numberOfOutputChannels = outputBus->numberOfChannels();
178
179     bool channelsAreGood = (numberOfInputChannels == m_numberOfInputChannels) && (numberOfOutputChannels == m_numberOfOutputChannels);
180     ASSERT(channelsAreGood);
181     if (!channelsAreGood)
182         return;
183
184     for (unsigned i = 0; i < numberOfInputChannels; i++)
185         m_internalInputBus->setChannelMemory(i, inputBuffer->getChannelData(i)->data() + m_bufferReadWriteIndex, framesToProcess);
186
187     if (numberOfInputChannels)
188         m_internalInputBus->copyFrom(*inputBus);
189
190     // Copy from the output buffer to the output. 
191     for (unsigned i = 0; i < numberOfOutputChannels; ++i)
192         memcpy(outputBus->channel(i)->mutableData(), outputBuffer->getChannelData(i)->data() + m_bufferReadWriteIndex, sizeof(float) * framesToProcess);
193
194     // Update the buffering index.
195     m_bufferReadWriteIndex = (m_bufferReadWriteIndex + framesToProcess) % bufferSize();
196
197     // m_bufferReadWriteIndex will wrap back around to 0 when the current input and output buffers are full.
198     // When this happens, fire an event and swap buffers.
199     if (!m_bufferReadWriteIndex) {
200         // Avoid building up requests on the main thread to fire process events when they're not being handled.
201         // This could be a problem if the main thread is very busy doing other things and is being held up handling previous requests.
202         if (m_isRequestOutstanding) {
203             // We're late in handling the previous request. The main thread must be very busy.
204             // The best we can do is clear out the buffer ourself here.
205             outputBuffer->zero();            
206         } else {
207             // Reference ourself so we don't accidentally get deleted before fireProcessEvent() gets called.
208             ref();
209             
210             // Fire the event on the main thread, not this one (which is the realtime audio thread).
211             m_doubleBufferIndexForEvent = m_doubleBufferIndex;
212             m_isRequestOutstanding = true;
213
214             callOnMainThread([this] {
215                 fireProcessEvent();
216
217                 // De-reference to match the ref() call in process().
218                 deref();
219             });
220         }
221
222         swapBuffers();
223     }
224 }
225
226 void ScriptProcessorNode::fireProcessEvent()
227 {
228     ASSERT(isMainThread() && m_isRequestOutstanding);
229     
230     bool isIndexGood = m_doubleBufferIndexForEvent < 2;
231     ASSERT(isIndexGood);
232     if (!isIndexGood)
233         return;
234         
235     AudioBuffer* inputBuffer = m_inputBuffers[m_doubleBufferIndexForEvent].get();
236     AudioBuffer* outputBuffer = m_outputBuffers[m_doubleBufferIndexForEvent].get();
237     ASSERT(outputBuffer);
238     if (!outputBuffer)
239         return;
240
241     // Avoid firing the event if the document has already gone away.
242     if (context()->scriptExecutionContext()) {
243         // Let the audio thread know we've gotten to the point where it's OK for it to make another request.
244         m_isRequestOutstanding = false;
245
246         // Calculate playbackTime with the buffersize which needs to be processed each time when onaudioprocess is called.
247         // The outputBuffer being passed to JS will be played after exhausting previous outputBuffer by double-buffering.
248         double playbackTime = (context()->currentSampleFrame() + m_bufferSize) / static_cast<double>(context()->sampleRate());
249
250         // Call the JavaScript event handler which will do the audio processing.
251         dispatchEvent(AudioProcessingEvent::create(inputBuffer, outputBuffer, playbackTime));
252     }
253 }
254
255 void ScriptProcessorNode::reset()
256 {
257     m_bufferReadWriteIndex = 0;
258     m_doubleBufferIndex = 0;
259
260     for (unsigned i = 0; i < 2; ++i) {
261         m_inputBuffers[i]->zero();
262         m_outputBuffers[i]->zero();
263     }
264 }
265
266 double ScriptProcessorNode::tailTime() const
267 {
268     return std::numeric_limits<double>::infinity();
269 }
270
271 double ScriptProcessorNode::latencyTime() const
272 {
273     return std::numeric_limits<double>::infinity();
274 }
275
276 bool ScriptProcessorNode::addEventListener(const AtomicString& eventType, RefPtr<EventListener>&& listener, bool useCapture)
277 {
278     bool success = AudioNode::addEventListener(eventType, WTF::move(listener), useCapture);
279     if (success && eventType == eventNames().audioprocessEvent)
280         m_hasAudioProcessListener = hasEventListeners(eventNames().audioprocessEvent);
281     return success;
282 }
283
284 bool ScriptProcessorNode::removeEventListener(const AtomicString& eventType, EventListener* listener, bool useCapture)
285 {
286     bool success = AudioNode::removeEventListener(eventType, listener, useCapture);
287     if (success && eventType == eventNames().audioprocessEvent)
288         m_hasAudioProcessListener = hasEventListeners(eventNames().audioprocessEvent);
289     return success;
290 }
291
292 void ScriptProcessorNode::removeAllEventListeners()
293 {
294     m_hasAudioProcessListener = false;
295     AudioNode::removeAllEventListeners();
296 }
297
298 } // namespace WebCore
299
300 #endif // ENABLE(WEB_AUDIO)