root/AudioNode.cpp
/* [<][>][^][v][top][bottom][index][help] */
DEFINITIONS
This source file includes following definitions.
- m_channelInterpretation
- initialize
- uninitialize
- setNodeType
- lazyInitialize
- addInput
- addOutput
- input
- output
- connect
- connect
- disconnect
- channelCount
- setChannelCount
- channelCountMode
- setChannelCountMode
- channelInterpretation
- setChannelInterpretation
- updateChannelsForInputs
- interfaceName
- scriptExecutionContext
- processIfNecessary
- checkNumberOfChannelsForInput
- propagatesSilence
- pullInputs
- inputsAreSilent
- silenceOutputs
- unsilenceOutputs
- enableOutputsIfNecessary
- disableOutputsIfNecessary
- ref
- deref
- finishDeref
- printNodeCounts
/*
* Copyright (C) 2010, Google Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#if ENABLE(WEB_AUDIO)
#include "modules/webaudio/AudioNode.h"
#include "bindings/v8/ExceptionState.h"
#include "core/dom/ExceptionCode.h"
#include "modules/webaudio/AudioContext.h"
#include "modules/webaudio/AudioNodeInput.h"
#include "modules/webaudio/AudioNodeOutput.h"
#include "modules/webaudio/AudioParam.h"
#include "wtf/Atomics.h"
#include "wtf/MainThread.h"
#if DEBUG_AUDIONODE_REFERENCES
#include <stdio.h>
#endif
namespace WebCore {
AudioNode::AudioNode(AudioContext* context, float sampleRate)
: m_isInitialized(false)
, m_nodeType(NodeTypeUnknown)
, m_context(context)
, m_sampleRate(sampleRate)
, m_lastProcessingTime(-1)
, m_lastNonSilentTime(-1)
, m_normalRefCount(1) // start out with normal refCount == 1 (like WTF::RefCounted class)
, m_connectionRefCount(0)
, m_isMarkedForDeletion(false)
, m_isDisabled(false)
, m_channelCount(2)
, m_channelCountMode(Max)
, m_channelInterpretation(AudioBus::Speakers)
{
ScriptWrappable::init(this);
#if DEBUG_AUDIONODE_REFERENCES
if (!s_isNodeCountInitialized) {
s_isNodeCountInitialized = true;
atexit(AudioNode::printNodeCounts);
}
#endif
}
AudioNode::~AudioNode()
{
#if DEBUG_AUDIONODE_REFERENCES
--s_nodeCount[nodeType()];
fprintf(stderr, "%p: %d: AudioNode::~AudioNode() %d %d\n", this, nodeType(), m_normalRefCount, m_connectionRefCount);
#endif
}
void AudioNode::initialize()
{
m_isInitialized = true;
}
void AudioNode::uninitialize()
{
m_isInitialized = false;
}
void AudioNode::setNodeType(NodeType type)
{
m_nodeType = type;
#if DEBUG_AUDIONODE_REFERENCES
++s_nodeCount[type];
#endif
}
void AudioNode::lazyInitialize()
{
if (!isInitialized())
initialize();
}
void AudioNode::addInput(PassOwnPtr<AudioNodeInput> input)
{
m_inputs.append(input);
}
void AudioNode::addOutput(PassOwnPtr<AudioNodeOutput> output)
{
m_outputs.append(output);
}
AudioNodeInput* AudioNode::input(unsigned i)
{
if (i < m_inputs.size())
return m_inputs[i].get();
return 0;
}
AudioNodeOutput* AudioNode::output(unsigned i)
{
if (i < m_outputs.size())
return m_outputs[i].get();
return 0;
}
void AudioNode::connect(AudioNode* destination, unsigned outputIndex, unsigned inputIndex, ExceptionState& es)
{
ASSERT(isMainThread());
AudioContext::AutoLocker locker(context());
if (!destination) {
es.throwDOMException(SyntaxError);
return;
}
// Sanity check input and output indices.
if (outputIndex >= numberOfOutputs()) {
es.throwDOMException(IndexSizeError);
return;
}
if (destination && inputIndex >= destination->numberOfInputs()) {
es.throwDOMException(IndexSizeError);
return;
}
if (context() != destination->context()) {
es.throwDOMException(SyntaxError);
return;
}
AudioNodeInput* input = destination->input(inputIndex);
AudioNodeOutput* output = this->output(outputIndex);
input->connect(output);
// Let context know that a connection has been made.
context()->incrementConnectionCount();
}
void AudioNode::connect(AudioParam* param, unsigned outputIndex, ExceptionState& es)
{
ASSERT(isMainThread());
AudioContext::AutoLocker locker(context());
if (!param) {
es.throwDOMException(SyntaxError);
return;
}
if (outputIndex >= numberOfOutputs()) {
es.throwDOMException(IndexSizeError);
return;
}
if (context() != param->context()) {
es.throwDOMException(SyntaxError);
return;
}
AudioNodeOutput* output = this->output(outputIndex);
param->connect(output);
}
void AudioNode::disconnect(unsigned outputIndex, ExceptionState& es)
{
ASSERT(isMainThread());
AudioContext::AutoLocker locker(context());
// Sanity check input and output indices.
if (outputIndex >= numberOfOutputs()) {
es.throwDOMException(IndexSizeError);
return;
}
AudioNodeOutput* output = this->output(outputIndex);
output->disconnectAll();
}
unsigned long AudioNode::channelCount()
{
return m_channelCount;
}
void AudioNode::setChannelCount(unsigned long channelCount, ExceptionState& es)
{
ASSERT(isMainThread());
AudioContext::AutoLocker locker(context());
if (channelCount > 0 && channelCount <= AudioContext::maxNumberOfChannels()) {
if (m_channelCount != channelCount) {
m_channelCount = channelCount;
if (m_channelCountMode != Max)
updateChannelsForInputs();
}
} else {
es.throwDOMException(InvalidStateError);
}
}
String AudioNode::channelCountMode()
{
switch (m_channelCountMode) {
case Max:
return "max";
case ClampedMax:
return "clamped-max";
case Explicit:
return "explicit";
}
ASSERT_NOT_REACHED();
return "";
}
void AudioNode::setChannelCountMode(const String& mode, ExceptionState& es)
{
ASSERT(isMainThread());
AudioContext::AutoLocker locker(context());
ChannelCountMode oldMode = m_channelCountMode;
if (mode == "max")
m_channelCountMode = Max;
else if (mode == "clamped-max")
m_channelCountMode = ClampedMax;
else if (mode == "explicit")
m_channelCountMode = Explicit;
else
es.throwDOMException(InvalidStateError);
if (m_channelCountMode != oldMode)
updateChannelsForInputs();
}
String AudioNode::channelInterpretation()
{
switch (m_channelInterpretation) {
case AudioBus::Speakers:
return "speakers";
case AudioBus::Discrete:
return "discrete";
}
ASSERT_NOT_REACHED();
return "";
}
void AudioNode::setChannelInterpretation(const String& interpretation, ExceptionState& es)
{
ASSERT(isMainThread());
AudioContext::AutoLocker locker(context());
if (interpretation == "speakers")
m_channelInterpretation = AudioBus::Speakers;
else if (interpretation == "discrete")
m_channelInterpretation = AudioBus::Discrete;
else
es.throwDOMException(InvalidStateError);
}
void AudioNode::updateChannelsForInputs()
{
for (unsigned i = 0; i < m_inputs.size(); ++i)
input(i)->changedOutputs();
}
const AtomicString& AudioNode::interfaceName() const
{
return eventNames().interfaceForAudioNode;
}
ScriptExecutionContext* AudioNode::scriptExecutionContext() const
{
return const_cast<AudioNode*>(this)->context()->scriptExecutionContext();
}
void AudioNode::processIfNecessary(size_t framesToProcess)
{
ASSERT(context()->isAudioThread());
if (!isInitialized())
return;
// Ensure that we only process once per rendering quantum.
// This handles the "fanout" problem where an output is connected to multiple inputs.
// The first time we're called during this time slice we process, but after that we don't want to re-process,
// instead our output(s) will already have the results cached in their bus;
double currentTime = context()->currentTime();
if (m_lastProcessingTime != currentTime) {
m_lastProcessingTime = currentTime; // important to first update this time because of feedback loops in the rendering graph
pullInputs(framesToProcess);
bool silentInputs = inputsAreSilent();
if (!silentInputs)
m_lastNonSilentTime = (context()->currentSampleFrame() + framesToProcess) / static_cast<double>(m_sampleRate);
if (silentInputs && propagatesSilence())
silenceOutputs();
else {
process(framesToProcess);
unsilenceOutputs();
}
}
}
void AudioNode::checkNumberOfChannelsForInput(AudioNodeInput* input)
{
ASSERT(context()->isAudioThread() && context()->isGraphOwner());
ASSERT(m_inputs.contains(input));
if (!m_inputs.contains(input))
return;
input->updateInternalBus();
}
bool AudioNode::propagatesSilence() const
{
return m_lastNonSilentTime + latencyTime() + tailTime() < context()->currentTime();
}
void AudioNode::pullInputs(size_t framesToProcess)
{
ASSERT(context()->isAudioThread());
// Process all of the AudioNodes connected to our inputs.
for (unsigned i = 0; i < m_inputs.size(); ++i)
input(i)->pull(0, framesToProcess);
}
bool AudioNode::inputsAreSilent()
{
for (unsigned i = 0; i < m_inputs.size(); ++i) {
if (!input(i)->bus()->isSilent())
return false;
}
return true;
}
void AudioNode::silenceOutputs()
{
for (unsigned i = 0; i < m_outputs.size(); ++i)
output(i)->bus()->zero();
}
void AudioNode::unsilenceOutputs()
{
for (unsigned i = 0; i < m_outputs.size(); ++i)
output(i)->bus()->clearSilentFlag();
}
void AudioNode::enableOutputsIfNecessary()
{
if (m_isDisabled && m_connectionRefCount > 0) {
ASSERT(isMainThread());
AudioContext::AutoLocker locker(context());
m_isDisabled = false;
for (unsigned i = 0; i < m_outputs.size(); ++i)
output(i)->enable();
}
}
void AudioNode::disableOutputsIfNecessary()
{
// Disable outputs if appropriate. We do this if the number of connections is 0 or 1. The case
// of 0 is from finishDeref() where there are no connections left. The case of 1 is from
// AudioNodeInput::disable() where we want to disable outputs when there's only one connection
// left because we're ready to go away, but can't quite yet.
if (m_connectionRefCount <= 1 && !m_isDisabled) {
// Still may have JavaScript references, but no more "active" connection references, so put all of our outputs in a "dormant" disabled state.
// Garbage collection may take a very long time after this time, so the "dormant" disabled nodes should not bog down the rendering...
// As far as JavaScript is concerned, our outputs must still appear to be connected.
// But internally our outputs should be disabled from the inputs they're connected to.
// disable() can recursively deref connections (and call disable()) down a whole chain of connected nodes.
// FIXME: we special case the convolver and delay since they have a significant tail-time and shouldn't be disconnected simply
// because they no longer have any input connections. This needs to be handled more generally where AudioNodes have
// a tailTime attribute. Then the AudioNode only needs to remain "active" for tailTime seconds after there are no
// longer any active connections.
if (nodeType() != NodeTypeConvolver && nodeType() != NodeTypeDelay) {
m_isDisabled = true;
for (unsigned i = 0; i < m_outputs.size(); ++i)
output(i)->disable();
}
}
}
void AudioNode::ref(RefType refType)
{
switch (refType) {
case RefTypeNormal:
atomicIncrement(&m_normalRefCount);
break;
case RefTypeConnection:
atomicIncrement(&m_connectionRefCount);
break;
default:
ASSERT_NOT_REACHED();
}
#if DEBUG_AUDIONODE_REFERENCES
fprintf(stderr, "%p: %d: AudioNode::ref(%d) %d %d\n", this, nodeType(), refType, m_normalRefCount, m_connectionRefCount);
#endif
// See the disabling code in finishDeref() below. This handles the case where a node
// is being re-connected after being used at least once and disconnected.
// In this case, we need to re-enable.
if (refType == RefTypeConnection)
enableOutputsIfNecessary();
}
void AudioNode::deref(RefType refType)
{
// The actually work for deref happens completely within the audio context's graph lock.
// In the case of the audio thread, we must use a tryLock to avoid glitches.
bool hasLock = false;
bool mustReleaseLock = false;
if (context()->isAudioThread()) {
// Real-time audio thread must not contend lock (to avoid glitches).
hasLock = context()->tryLock(mustReleaseLock);
} else {
context()->lock(mustReleaseLock);
hasLock = true;
}
if (hasLock) {
// This is where the real deref work happens.
finishDeref(refType);
if (mustReleaseLock)
context()->unlock();
} else {
// We were unable to get the lock, so put this in a list to finish up later.
ASSERT(context()->isAudioThread());
ASSERT(refType == RefTypeConnection);
context()->addDeferredFinishDeref(this);
}
// Once AudioContext::uninitialize() is called there's no more chances for deleteMarkedNodes() to get called, so we call here.
// We can't call in AudioContext::~AudioContext() since it will never be called as long as any AudioNode is alive
// because AudioNodes keep a reference to the context.
if (context()->isAudioThreadFinished())
context()->deleteMarkedNodes();
}
void AudioNode::finishDeref(RefType refType)
{
ASSERT(context()->isGraphOwner());
switch (refType) {
case RefTypeNormal:
ASSERT(m_normalRefCount > 0);
atomicDecrement(&m_normalRefCount);
break;
case RefTypeConnection:
ASSERT(m_connectionRefCount > 0);
atomicDecrement(&m_connectionRefCount);
break;
default:
ASSERT_NOT_REACHED();
}
#if DEBUG_AUDIONODE_REFERENCES
fprintf(stderr, "%p: %d: AudioNode::deref(%d) %d %d\n", this, nodeType(), refType, m_normalRefCount, m_connectionRefCount);
#endif
if (!m_connectionRefCount) {
if (!m_normalRefCount) {
if (!m_isMarkedForDeletion) {
// All references are gone - we need to go away.
for (unsigned i = 0; i < m_outputs.size(); ++i)
output(i)->disconnectAll(); // This will deref() nodes we're connected to.
// Mark for deletion at end of each render quantum or when context shuts down.
context()->markForDeletion(this);
m_isMarkedForDeletion = true;
}
} else if (refType == RefTypeConnection)
disableOutputsIfNecessary();
}
}
#if DEBUG_AUDIONODE_REFERENCES
bool AudioNode::s_isNodeCountInitialized = false;
int AudioNode::s_nodeCount[NodeTypeEnd];
void AudioNode::printNodeCounts()
{
fprintf(stderr, "\n\n");
fprintf(stderr, "===========================\n");
fprintf(stderr, "AudioNode: reference counts\n");
fprintf(stderr, "===========================\n");
for (unsigned i = 0; i < NodeTypeEnd; ++i)
fprintf(stderr, "%d: %d\n", i, s_nodeCount[i]);
fprintf(stderr, "===========================\n\n\n");
}
#endif // DEBUG_AUDIONODE_REFERENCES
} // namespace WebCore
#endif // ENABLE(WEB_AUDIO)