ScriptProcessorNode.cpp [plain text]
#include "config.h"
#if ENABLE(WEB_AUDIO)
#include "ScriptProcessorNode.h"
#include "AudioBuffer.h"
#include "AudioBus.h"
#include "AudioContext.h"
#include "AudioNodeInput.h"
#include "AudioNodeOutput.h"
#include "AudioProcessingEvent.h"
#include "Document.h"
#include "EventNames.h"
#include <JavaScriptCore/Float32Array.h>
#include <wtf/IsoMallocInlines.h>
#include <wtf/MainThread.h>
#include <wtf/threads/BinarySemaphore.h>
namespace WebCore {
WTF_MAKE_ISO_ALLOCATED_IMPL(ScriptProcessorNode);
Ref<ScriptProcessorNode> ScriptProcessorNode::create(BaseAudioContext& context, size_t bufferSize, unsigned numberOfInputChannels, unsigned numberOfOutputChannels)
{
return adoptRef(*new ScriptProcessorNode(context, bufferSize, numberOfInputChannels, numberOfOutputChannels));
}
ScriptProcessorNode::ScriptProcessorNode(BaseAudioContext& context, size_t bufferSize, unsigned numberOfInputChannels, unsigned numberOfOutputChannels)
: AudioNode(context)
, ActiveDOMObject(context.scriptExecutionContext())
, m_doubleBufferIndex(0)
, m_doubleBufferIndexForEvent(0)
, m_bufferSize(bufferSize)
, m_bufferReadWriteIndex(0)
, m_isRequestOutstanding(false)
, m_numberOfInputChannels(numberOfInputChannels)
, m_numberOfOutputChannels(numberOfOutputChannels)
, m_internalInputBus(AudioBus::create(numberOfInputChannels, AudioNode::ProcessingSizeInFrames, false))
{
if (m_bufferSize < AudioNode::ProcessingSizeInFrames)
m_bufferSize = AudioNode::ProcessingSizeInFrames;
ASSERT(numberOfInputChannels <= AudioContext::maxNumberOfChannels());
setNodeType(NodeTypeJavaScript);
initializeDefaultNodeOptions(numberOfInputChannels, ChannelCountMode::Explicit, ChannelInterpretation::Speakers);
addInput(makeUnique<AudioNodeInput>(this));
addOutput(makeUnique<AudioNodeOutput>(this, numberOfOutputChannels));
initialize();
suspendIfNeeded();
m_pendingActivity = makePendingActivity(*this);
}
ScriptProcessorNode::~ScriptProcessorNode()
{
ASSERT(!hasPendingActivity());
uninitialize();
}
void ScriptProcessorNode::initialize()
{
if (isInitialized())
return;
float sampleRate = context().sampleRate();
for (unsigned i = 0; i < 2; ++i) {
auto inputBuffer = m_numberOfInputChannels ? AudioBuffer::create(m_numberOfInputChannels, bufferSize(), sampleRate) : 0;
auto outputBuffer = m_numberOfOutputChannels ? AudioBuffer::create(m_numberOfOutputChannels, bufferSize(), sampleRate) : 0;
m_inputBuffers.append(inputBuffer);
m_outputBuffers.append(outputBuffer);
}
AudioNode::initialize();
}
void ScriptProcessorNode::uninitialize()
{
if (!isInitialized())
return;
m_inputBuffers.clear();
m_outputBuffers.clear();
AudioNode::uninitialize();
}
void ScriptProcessorNode::didBecomeMarkedForDeletion()
{
ASSERT(context().isGraphOwner());
m_pendingActivity = nullptr;
ASSERT(!hasPendingActivity());
}
void ScriptProcessorNode::process(size_t framesToProcess)
{
AudioBus* inputBus = this->input(0)->bus();
AudioBus* outputBus = this->output(0)->bus();
unsigned doubleBufferIndex = this->doubleBufferIndex();
bool isDoubleBufferIndexGood = doubleBufferIndex < 2 && doubleBufferIndex < m_inputBuffers.size() && doubleBufferIndex < m_outputBuffers.size();
ASSERT(isDoubleBufferIndexGood);
if (!isDoubleBufferIndexGood)
return;
AudioBuffer* inputBuffer = m_inputBuffers[doubleBufferIndex].get();
AudioBuffer* outputBuffer = m_outputBuffers[doubleBufferIndex].get();
unsigned numberOfInputChannels = m_internalInputBus->numberOfChannels();
bool buffersAreGood = outputBuffer && bufferSize() == outputBuffer->length() && m_bufferReadWriteIndex + framesToProcess <= bufferSize();
if (m_internalInputBus->numberOfChannels())
buffersAreGood = buffersAreGood && inputBuffer && bufferSize() == inputBuffer->length();
ASSERT(buffersAreGood);
if (!buffersAreGood)
return;
bool isFramesToProcessGood = framesToProcess && bufferSize() >= framesToProcess && !(bufferSize() % framesToProcess);
ASSERT(isFramesToProcessGood);
if (!isFramesToProcessGood)
return;
unsigned numberOfOutputChannels = outputBus->numberOfChannels();
bool channelsAreGood = (numberOfInputChannels == m_numberOfInputChannels) && (numberOfOutputChannels == m_numberOfOutputChannels);
ASSERT(channelsAreGood);
if (!channelsAreGood)
return;
for (unsigned i = 0; i < numberOfInputChannels; i++)
m_internalInputBus->setChannelMemory(i, inputBuffer->channelData(i)->data() + m_bufferReadWriteIndex, framesToProcess);
if (numberOfInputChannels)
m_internalInputBus->copyFrom(*inputBus);
for (unsigned i = 0; i < numberOfOutputChannels; ++i)
memcpy(outputBus->channel(i)->mutableData(), outputBuffer->channelData(i)->data() + m_bufferReadWriteIndex, sizeof(float) * framesToProcess);
m_bufferReadWriteIndex = (m_bufferReadWriteIndex + framesToProcess) % bufferSize();
if (!m_bufferReadWriteIndex) {
if (m_isRequestOutstanding) {
outputBuffer->zero();
} else {
ref();
m_doubleBufferIndexForEvent = m_doubleBufferIndex;
m_isRequestOutstanding = true;
if (context().isOfflineContext()) {
BinarySemaphore semaphore;
callOnMainThread([this, &semaphore] {
fireProcessEvent();
semaphore.signal();
});
semaphore.wait();
deref();
} else {
callOnMainThread([this] {
fireProcessEvent();
deref();
});
}
}
swapBuffers();
}
}
void ScriptProcessorNode::fireProcessEvent()
{
ASSERT(isMainThread() && m_isRequestOutstanding);
bool isIndexGood = m_doubleBufferIndexForEvent < 2;
ASSERT(isIndexGood);
if (!isIndexGood)
return;
AudioBuffer* inputBuffer = m_inputBuffers[m_doubleBufferIndexForEvent].get();
AudioBuffer* outputBuffer = m_outputBuffers[m_doubleBufferIndexForEvent].get();
ASSERT(outputBuffer);
if (!outputBuffer)
return;
if (!context().isStopped()) {
m_isRequestOutstanding = false;
double playbackTime = (context().currentSampleFrame() + m_bufferSize) / static_cast<double>(context().sampleRate());
dispatchEvent(AudioProcessingEvent::create(inputBuffer, outputBuffer, playbackTime));
}
}
void ScriptProcessorNode::reset()
{
m_bufferReadWriteIndex = 0;
m_doubleBufferIndex = 0;
for (unsigned i = 0; i < 2; ++i) {
m_inputBuffers[i]->zero();
m_outputBuffers[i]->zero();
}
}
double ScriptProcessorNode::tailTime() const
{
return std::numeric_limits<double>::infinity();
}
double ScriptProcessorNode::latencyTime() const
{
return std::numeric_limits<double>::infinity();
}
}
#endif // ENABLE(WEB_AUDIO)