AudioScheduledSourceNode.cpp [plain text]
#include "config.h"
#if ENABLE(WEB_AUDIO)
#include "AudioScheduledSourceNode.h"
#include "AudioContext.h"
#include "AudioUtilities.h"
#include "Event.h"
#include "ScriptController.h"
#include <algorithm>
#include <wtf/MathExtras.h>
#if PLATFORM(IOS)
#include "ScriptController.h"
#endif
namespace WebCore {
const double AudioScheduledSourceNode::UnknownTime = -1;
AudioScheduledSourceNode::AudioScheduledSourceNode(AudioContext* context, float sampleRate)
: AudioNode(context, sampleRate)
, m_playbackState(UNSCHEDULED_STATE)
, m_startTime(0)
, m_endTime(UnknownTime)
, m_hasEndedListener(false)
{
}
void AudioScheduledSourceNode::updateSchedulingInfo(size_t quantumFrameSize,
AudioBus* outputBus,
size_t& quantumFrameOffset,
size_t& nonSilentFramesToProcess)
{
ASSERT(outputBus);
if (!outputBus)
return;
ASSERT(quantumFrameSize == AudioNode::ProcessingSizeInFrames);
if (quantumFrameSize != AudioNode::ProcessingSizeInFrames)
return;
double sampleRate = this->sampleRate();
size_t quantumStartFrame = context()->currentSampleFrame();
size_t quantumEndFrame = quantumStartFrame + quantumFrameSize;
size_t startFrame = AudioUtilities::timeToSampleFrame(m_startTime, sampleRate);
size_t endFrame = m_endTime == UnknownTime ? 0 : AudioUtilities::timeToSampleFrame(m_endTime, sampleRate);
if (m_endTime != UnknownTime && endFrame <= quantumStartFrame)
finish();
if (m_playbackState == UNSCHEDULED_STATE || m_playbackState == FINISHED_STATE || startFrame >= quantumEndFrame) {
outputBus->zero();
nonSilentFramesToProcess = 0;
return;
}
if (m_playbackState == SCHEDULED_STATE) {
m_playbackState = PLAYING_STATE;
context()->incrementActiveSourceCount();
}
quantumFrameOffset = startFrame > quantumStartFrame ? startFrame - quantumStartFrame : 0;
quantumFrameOffset = std::min(quantumFrameOffset, quantumFrameSize); nonSilentFramesToProcess = quantumFrameSize - quantumFrameOffset;
if (!nonSilentFramesToProcess) {
outputBus->zero();
return;
}
if (quantumFrameOffset) {
for (unsigned i = 0; i < outputBus->numberOfChannels(); ++i)
memset(outputBus->channel(i)->mutableData(), 0, sizeof(float) * quantumFrameOffset);
}
if (m_endTime != UnknownTime && endFrame >= quantumStartFrame && endFrame < quantumEndFrame) {
size_t zeroStartFrame = endFrame - quantumStartFrame;
size_t framesToZero = quantumFrameSize - zeroStartFrame;
bool isSafe = zeroStartFrame < quantumFrameSize && framesToZero <= quantumFrameSize && zeroStartFrame + framesToZero <= quantumFrameSize;
ASSERT(isSafe);
if (isSafe) {
if (framesToZero > nonSilentFramesToProcess)
nonSilentFramesToProcess = 0;
else
nonSilentFramesToProcess -= framesToZero;
for (unsigned i = 0; i < outputBus->numberOfChannels(); ++i)
memset(outputBus->channel(i)->mutableData() + zeroStartFrame, 0, sizeof(float) * framesToZero);
}
finish();
}
return;
}
void AudioScheduledSourceNode::start(double when, ExceptionCode& ec)
{
ASSERT(isMainThread());
if (ScriptController::processingUserGesture())
context()->removeBehaviorRestriction(AudioContext::RequireUserGestureForAudioStartRestriction);
if (m_playbackState != UNSCHEDULED_STATE) {
ec = INVALID_STATE_ERR;
return;
}
m_startTime = when;
m_playbackState = SCHEDULED_STATE;
}
void AudioScheduledSourceNode::stop(double when, ExceptionCode& ec)
{
ASSERT(isMainThread());
if ((m_playbackState == UNSCHEDULED_STATE) || (m_endTime != UnknownTime)) {
ec = INVALID_STATE_ERR;
return;
}
when = std::max<double>(0, when);
m_endTime = when;
}
#if ENABLE(LEGACY_WEB_AUDIO)
void AudioScheduledSourceNode::noteOn(double when, ExceptionCode& ec)
{
start(when, ec);
}
void AudioScheduledSourceNode::noteOff(double when, ExceptionCode& ec)
{
stop(when, ec);
}
#endif
void AudioScheduledSourceNode::setOnended(PassRefPtr<EventListener> listener)
{
m_hasEndedListener = listener;
setAttributeEventListener(eventNames().endedEvent, listener);
}
void AudioScheduledSourceNode::finish()
{
if (m_playbackState != FINISHED_STATE) {
context()->notifyNodeFinishedProcessing(this);
m_playbackState = FINISHED_STATE;
context()->decrementActiveSourceCount();
}
if (m_hasEndedListener)
callOnMainThread(&AudioScheduledSourceNode::notifyEndedDispatch, this);
}
void AudioScheduledSourceNode::notifyEndedDispatch(void* userData)
{
static_cast<AudioScheduledSourceNode*>(userData)->notifyEnded();
}
void AudioScheduledSourceNode::notifyEnded()
{
EventListener* listener = onended();
if (!listener)
return;
RefPtr<Event> event = Event::create(eventNames().endedEvent, FALSE, FALSE);
event->setTarget(this);
listener->handleEvent(context()->scriptExecutionContext(), event.get());
}
}
#endif // ENABLE(WEB_AUDIO)