Home | History | Annotate | Download | only in webaudio 
      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 "modules/webaudio/ScriptProcessorNode.h"
     30 
     31 #include "core/dom/CrossThreadTask.h"
     32 #include "core/dom/ExecutionContext.h"
     33 #include "modules/webaudio/AudioBuffer.h"
     34 #include "modules/webaudio/AudioContext.h"
     35 #include "modules/webaudio/AudioNodeInput.h"
     36 #include "modules/webaudio/AudioNodeOutput.h"
     37 #include "modules/webaudio/AudioProcessingEvent.h"
     38 #include "public/platform/Platform.h"
     39 #include "wtf/Float32Array.h"
     40 
     41 namespace blink {
     42 
     43 static size_t chooseBufferSize()
     44 {
     45     // Choose a buffer size based on the audio hardware buffer size. Arbitarily make it a power of
     46     // two that is 4 times greater than the hardware buffer size.
     47     // FIXME: What is the best way to choose this?
     48     size_t hardwareBufferSize = Platform::current()->audioHardwareBufferSize();
     49     size_t bufferSize = 1 << static_cast<unsigned>(log2(4 * hardwareBufferSize) + 0.5);
     50 
     51     if (bufferSize < 256)
     52         return 256;
     53     if (bufferSize > 16384)
     54         return 16384;
     55 
     56     return bufferSize;
     57 }
     58 
     59 ScriptProcessorNode* ScriptProcessorNode::create(AudioContext* context, float sampleRate, size_t bufferSize, unsigned numberOfInputChannels, unsigned numberOfOutputChannels)
     60 {
     61     // Check for valid buffer size.
     62     switch (bufferSize) {
     63     case 0:
     64         bufferSize = chooseBufferSize();
     65         break;
     66     case 256:
     67     case 512:
     68     case 1024:
     69     case 2048:
     70     case 4096:
     71     case 8192:
     72     case 16384:
     73         break;
     74     default:
     75         return 0;
     76     }
     77 
     78     if (!numberOfInputChannels && !numberOfOutputChannels)
     79         return 0;
     80 
     81     if (numberOfInputChannels > AudioContext::maxNumberOfChannels())
     82         return 0;
     83 
     84     if (numberOfOutputChannels > AudioContext::maxNumberOfChannels())
     85         return 0;
     86 
     87     return adoptRefCountedGarbageCollectedWillBeNoop(new ScriptProcessorNode(context, sampleRate, bufferSize, numberOfInputChannels, numberOfOutputChannels));
     88 }
     89 
     90 ScriptProcessorNode::ScriptProcessorNode(AudioContext* context, float sampleRate, size_t bufferSize, unsigned numberOfInputChannels, unsigned numberOfOutputChannels)
     91     : AudioNode(context, sampleRate)
     92     , m_doubleBufferIndex(0)
     93     , m_doubleBufferIndexForEvent(0)
     94     , m_bufferSize(bufferSize)
     95     , m_bufferReadWriteIndex(0)
     96     , m_numberOfInputChannels(numberOfInputChannels)
     97     , m_numberOfOutputChannels(numberOfOutputChannels)
     98     , m_internalInputBus(AudioBus::create(numberOfInputChannels, AudioNode::ProcessingSizeInFrames, false))
     99 {
    100     // Regardless of the allowed buffer sizes, we still need to process at the granularity of the AudioNode.
    101     if (m_bufferSize < AudioNode::ProcessingSizeInFrames)
    102         m_bufferSize = AudioNode::ProcessingSizeInFrames;
    103 
    104     ASSERT(numberOfInputChannels <= AudioContext::maxNumberOfChannels());
    105 
    106     addInput();
    107     addOutput(AudioNodeOutput::create(this, numberOfOutputChannels));
    108 
    109     setNodeType(NodeTypeJavaScript);
    110 
    111     initialize();
    112 }
    113 
    114 ScriptProcessorNode::~ScriptProcessorNode()
    115 {
    116     ASSERT(!isInitialized());
    117 }
    118 
    119 void ScriptProcessorNode::dispose()
    120 {
    121     uninitialize();
    122     AudioNode::dispose();
    123 }
    124 
    125 void ScriptProcessorNode::initialize()
    126 {
    127     if (isInitialized())
    128         return;
    129 
    130     float sampleRate = context()->sampleRate();
    131 
    132     // Create double buffers on both the input and output sides.
    133     // These AudioBuffers will be directly accessed in the main thread by JavaScript.
    134     for (unsigned i = 0; i < 2; ++i) {
    135         AudioBuffer* inputBuffer = m_numberOfInputChannels ? AudioBuffer::create(m_numberOfInputChannels, bufferSize(), sampleRate) : 0;
    136         AudioBuffer* outputBuffer = m_numberOfOutputChannels ? AudioBuffer::create(m_numberOfOutputChannels, bufferSize(), sampleRate) : 0;
    137 
    138         m_inputBuffers.append(inputBuffer);
    139         m_outputBuffers.append(outputBuffer);
    140     }
    141 
    142     AudioNode::initialize();
    143 }
    144 
    145 void ScriptProcessorNode::uninitialize()
    146 {
    147     if (!isInitialized())
    148         return;
    149 
    150     m_inputBuffers.clear();
    151     m_outputBuffers.clear();
    152 
    153     AudioNode::uninitialize();
    154 }
    155 
    156 void ScriptProcessorNode::process(size_t framesToProcess)
    157 {
    158     // Discussion about inputs and outputs:
    159     // As in other AudioNodes, ScriptProcessorNode uses an AudioBus for its input and output (see inputBus and outputBus below).
    160     // Additionally, there is a double-buffering for input and output which is exposed directly to JavaScript (see inputBuffer and outputBuffer below).
    161     // This node is the producer for inputBuffer and the consumer for outputBuffer.
    162     // The JavaScript code is the consumer of inputBuffer and the producer for outputBuffer.
    163 
    164     // Get input and output busses.
    165     AudioBus* inputBus = this->input(0)->bus();
    166     AudioBus* outputBus = this->output(0)->bus();
    167 
    168     // Get input and output buffers. We double-buffer both the input and output sides.
    169     unsigned doubleBufferIndex = this->doubleBufferIndex();
    170     bool isDoubleBufferIndexGood = doubleBufferIndex < 2 && doubleBufferIndex < m_inputBuffers.size() && doubleBufferIndex < m_outputBuffers.size();
    171     ASSERT(isDoubleBufferIndexGood);
    172     if (!isDoubleBufferIndexGood)
    173         return;
    174 
    175     AudioBuffer* inputBuffer = m_inputBuffers[doubleBufferIndex].get();
    176     AudioBuffer* outputBuffer = m_outputBuffers[doubleBufferIndex].get();
    177 
    178     // Check the consistency of input and output buffers.
    179     unsigned numberOfInputChannels = m_internalInputBus->numberOfChannels();
    180     bool buffersAreGood = outputBuffer && bufferSize() == outputBuffer->length() && m_bufferReadWriteIndex + framesToProcess <= bufferSize();
    181 
    182     // If the number of input channels is zero, it's ok to have inputBuffer = 0.
    183     if (m_internalInputBus->numberOfChannels())
    184         buffersAreGood = buffersAreGood && inputBuffer && bufferSize() == inputBuffer->length();
    185 
    186     ASSERT(buffersAreGood);
    187     if (!buffersAreGood)
    188         return;
    189 
    190     // We assume that bufferSize() is evenly divisible by framesToProcess - should always be true, but we should still check.
    191     bool isFramesToProcessGood = framesToProcess && bufferSize() >= framesToProcess && !(bufferSize() % framesToProcess);
    192     ASSERT(isFramesToProcessGood);
    193     if (!isFramesToProcessGood)
    194         return;
    195 
    196     unsigned numberOfOutputChannels = outputBus->numberOfChannels();
    197 
    198     bool channelsAreGood = (numberOfInputChannels == m_numberOfInputChannels) && (numberOfOutputChannels == m_numberOfOutputChannels);
    199     ASSERT(channelsAreGood);
    200     if (!channelsAreGood)
    201         return;
    202 
    203     for (unsigned i = 0; i < numberOfInputChannels; i++)
    204         m_internalInputBus->setChannelMemory(i, inputBuffer->getChannelData(i)->data() + m_bufferReadWriteIndex, framesToProcess);
    205 
    206     if (numberOfInputChannels)
    207         m_internalInputBus->copyFrom(*inputBus);
    208 
    209     // Copy from the output buffer to the output.
    210     for (unsigned i = 0; i < numberOfOutputChannels; ++i)
    211         memcpy(outputBus->channel(i)->mutableData(), outputBuffer->getChannelData(i)->data() + m_bufferReadWriteIndex, sizeof(float) * framesToProcess);
    212 
    213     // Update the buffering index.
    214     m_bufferReadWriteIndex = (m_bufferReadWriteIndex + framesToProcess) % bufferSize();
    215 
    216     // m_bufferReadWriteIndex will wrap back around to 0 when the current input and output buffers are full.
    217     // When this happens, fire an event and swap buffers.
    218     if (!m_bufferReadWriteIndex) {
    219         // Avoid building up requests on the main thread to fire process events when they're not being handled.
    220         // This could be a problem if the main thread is very busy doing other things and is being held up handling previous requests.
    221         // The audio thread can't block on this lock, so we call tryLock() instead.
    222         MutexTryLocker tryLocker(m_processEventLock);
    223         if (!tryLocker.locked()) {
    224             // We're late in handling the previous request. The main thread must be very busy.
    225             // The best we can do is clear out the buffer ourself here.
    226             outputBuffer->zero();
    227         } else if (context()->executionContext()) {
    228             // Fire the event on the main thread, not this one (which is the realtime audio thread).
    229             m_doubleBufferIndexForEvent = m_doubleBufferIndex;
    230             context()->executionContext()->postTask(createCrossThreadTask(&ScriptProcessorNode::fireProcessEvent, this));
    231         }
    232 
    233         swapBuffers();
    234     }
    235 }
    236 
    237 void ScriptProcessorNode::fireProcessEvent()
    238 {
    239     ASSERT(isMainThread());
    240 
    241     bool isIndexGood = m_doubleBufferIndexForEvent < 2;
    242     ASSERT(isIndexGood);
    243     if (!isIndexGood)
    244         return;
    245 
    246     AudioBuffer* inputBuffer = m_inputBuffers[m_doubleBufferIndexForEvent].get();
    247     AudioBuffer* outputBuffer = m_outputBuffers[m_doubleBufferIndexForEvent].get();
    248     ASSERT(outputBuffer);
    249     if (!outputBuffer)
    250         return;
    251 
    252     // Avoid firing the event if the document has already gone away.
    253     if (context()->executionContext()) {
    254         // This synchronizes with process().
    255         MutexLocker processLocker(m_processEventLock);
    256 
    257         // Calculate a playbackTime with the buffersize which needs to be processed each time onaudioprocess is called.
    258         // The outputBuffer being passed to JS will be played after exhuasting previous outputBuffer by double-buffering.
    259         double playbackTime = (context()->currentSampleFrame() + m_bufferSize) / static_cast<double>(context()->sampleRate());
    260 
    261         // Call the JavaScript event handler which will do the audio processing.
    262         dispatchEvent(AudioProcessingEvent::create(inputBuffer, outputBuffer, playbackTime));
    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 void ScriptProcessorNode::trace(Visitor* visitor)
    277 {
    278     visitor->trace(m_inputBuffers);
    279     visitor->trace(m_outputBuffers);
    280     AudioNode::trace(visitor);
    281 }
    282 
    283 } // namespace blink
    284 
    285 #endif // ENABLE(WEB_AUDIO)
    286