#include "config.h"
#if ENABLE(WEB_AUDIO)
#include "AudioNode.h"
#include "AudioContext.h"
#include "AudioNodeInput.h"
#include "AudioNodeOutput.h"
#include "AudioParam.h"
#include "ExceptionCode.h"
#include <wtf/Atomics.h>
#include <wtf/MainThread.h>
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) , m_connectionRefCount(0)
, m_disabledRefCount(0)
, m_isMarkedForDeletion(false)
, m_isDisabled(false)
{
#if DEBUG_AUDIONODE_REFERENCES
if (!s_isNodeCountInitialized) {
s_isNodeCountInitialized = true;
atexit(AudioNode::printNodeCounts);
}
#endif
}
AudioNode::~AudioNode()
{
#if DEBUG_AUDIONODE_REFERENCES
--s_nodeCount[nodeType()];
printf("%p: %d: AudioNode::~AudioNode() %d %d %d\n", this, nodeType(), m_normalRefCount, m_connectionRefCount, m_disabledRefCount);
#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, ExceptionCode& ec)
{
ASSERT(isMainThread());
AudioContext::AutoLocker locker(context());
if (!destination) {
ec = SYNTAX_ERR;
return;
}
if (outputIndex >= numberOfOutputs()) {
ec = INDEX_SIZE_ERR;
return;
}
if (destination && inputIndex >= destination->numberOfInputs()) {
ec = INDEX_SIZE_ERR;
return;
}
if (context() != destination->context()) {
ec = SYNTAX_ERR;
return;
}
AudioNodeInput* input = destination->input(inputIndex);
AudioNodeOutput* output = this->output(outputIndex);
input->connect(output);
context()->incrementConnectionCount();
}
void AudioNode::connect(AudioParam* param, unsigned outputIndex, ExceptionCode& ec)
{
ASSERT(isMainThread());
AudioContext::AutoLocker locker(context());
if (!param) {
ec = SYNTAX_ERR;
return;
}
if (outputIndex >= numberOfOutputs()) {
ec = INDEX_SIZE_ERR;
return;
}
if (context() != param->context()) {
ec = SYNTAX_ERR;
return;
}
AudioNodeOutput* output = this->output(outputIndex);
param->connect(output);
}
void AudioNode::disconnect(unsigned outputIndex, ExceptionCode& ec)
{
ASSERT(isMainThread());
AudioContext::AutoLocker locker(context());
if (outputIndex >= numberOfOutputs()) {
ec = INDEX_SIZE_ERR;
return;
}
AudioNodeOutput* output = this->output(outputIndex);
output->disconnectAll();
}
void AudioNode::processIfNecessary(size_t framesToProcess)
{
ASSERT(context()->isAudioThread());
if (!isInitialized())
return;
double currentTime = context()->currentTime();
if (m_lastProcessingTime != currentTime) {
m_lastProcessingTime = currentTime;
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());
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::ref(RefType refType)
{
switch (refType) {
case RefTypeNormal:
atomicIncrement(&m_normalRefCount);
break;
case RefTypeConnection:
atomicIncrement(&m_connectionRefCount);
break;
case RefTypeDisabled:
atomicIncrement(&m_disabledRefCount);
break;
default:
ASSERT_NOT_REACHED();
}
#if DEBUG_AUDIONODE_REFERENCES
printf("%p: %d: AudioNode::ref(%d) %d %d %d\n", this, nodeType(), refType, m_normalRefCount, m_connectionRefCount, m_disabledRefCount);
#endif
if (m_isDisabled && m_connectionRefCount > 0 && refType == RefTypeConnection) {
ASSERT(isMainThread());
AudioContext::AutoLocker locker(context());
m_isDisabled = false;
for (unsigned i = 0; i < m_outputs.size(); ++i)
output(i)->enable();
}
}
void AudioNode::deref(RefType refType)
{
bool hasLock = false;
bool mustReleaseLock = false;
if (context()->isAudioThread()) {
hasLock = context()->tryLock(mustReleaseLock);
} else {
context()->lock(mustReleaseLock);
hasLock = true;
}
if (hasLock) {
finishDeref(refType);
if (mustReleaseLock)
context()->unlock();
} else {
ASSERT(context()->isAudioThread());
context()->addDeferredFinishDeref(this, refType);
}
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;
case RefTypeDisabled:
ASSERT(m_disabledRefCount > 0);
atomicDecrement(&m_disabledRefCount);
break;
default:
ASSERT_NOT_REACHED();
}
#if DEBUG_AUDIONODE_REFERENCES
printf("%p: %d: AudioNode::deref(%d) %d %d %d\n", this, nodeType(), refType, m_normalRefCount, m_connectionRefCount, m_disabledRefCount);
#endif
if (!m_connectionRefCount) {
if (!m_normalRefCount && !m_disabledRefCount) {
if (!m_isMarkedForDeletion) {
for (unsigned i = 0; i < m_outputs.size(); ++i)
output(i)->disconnectAll();
context()->markForDeletion(this);
m_isMarkedForDeletion = true;
}
} else if (refType == RefTypeConnection) {
if (!m_isDisabled) {
if (nodeType() != NodeTypeConvolver && nodeType() != NodeTypeDelay) {
m_isDisabled = true;
for (unsigned i = 0; i < m_outputs.size(); ++i)
output(i)->disable();
}
}
}
}
}
#if DEBUG_AUDIONODE_REFERENCES
bool AudioNode::s_isNodeCountInitialized = false;
int AudioNode::s_nodeCount[NodeTypeEnd];
void AudioNode::printNodeCounts()
{
printf("\n\n");
printf("===========================\n");
printf("AudioNode: reference counts\n");
printf("===========================\n");
for (unsigned i = 0; i < NodeTypeEnd; ++i)
printf("%d: %d\n", i, s_nodeCount[i]);
printf("===========================\n\n\n");
}
#endif // DEBUG_AUDIONODE_REFERENCES
}
#endif // ENABLE(WEB_AUDIO)