| /* |
| * 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 "bindings/core/v8/ExceptionMessages.h" |
| #include "bindings/core/v8/ExceptionState.h" |
| #include "core/dom/ExceptionCode.h" |
| #include "core/frame/UseCounter.h" |
| #include "modules/webaudio/AudioBufferSourceNode.h" |
| #include "modules/webaudio/AudioBufferSourceOptions.h" |
| #include "modules/webaudio/AudioNodeOutput.h" |
| #include "modules/webaudio/BaseAudioContext.h" |
| #include "platform/audio/AudioUtilities.h" |
| #include "wtf/MathExtras.h" |
| #include "wtf/PtrUtil.h" |
| #include <algorithm> |
| |
| namespace blink { |
| |
| const double DefaultGrainDuration = 0.020; // 20ms |
| |
| // Arbitrary upper limit on playback rate. |
| // Higher than expected rates can be useful when playing back oversampled buffers |
| // to minimize linear interpolation aliasing. |
| const double MaxRate = 1024; |
| |
| // Number of extra frames to use when determining if a source node can be stopped. This should be |
| // at least one rendering quantum, but we add one more quantum for good measure. This doesn't need |
| // to be extra precise, just more than one rendering quantum. See |handleStoppableSourceNode()|. |
| // FIXME: Expose the rendering quantum somehow instead of hardwiring a value here. |
| const int kExtraStopFrames = 256; |
| |
| AudioBufferSourceHandler::AudioBufferSourceHandler( |
| AudioNode& node, |
| float sampleRate, |
| AudioParamHandler& playbackRate, |
| AudioParamHandler& detune) |
| : AudioScheduledSourceHandler(NodeTypeAudioBufferSource, node, sampleRate), |
| m_buffer(nullptr), |
| m_playbackRate(playbackRate), |
| m_detune(detune), |
| m_isLooping(false), |
| m_didSetLooping(false), |
| m_loopStart(0), |
| m_loopEnd(0), |
| m_virtualReadIndex(0), |
| m_isGrain(false), |
| m_grainOffset(0.0), |
| m_grainDuration(DefaultGrainDuration), |
| m_minPlaybackRate(1.0) { |
| // Default to mono. A call to setBuffer() will set the number of output |
| // channels to that of the buffer. |
| addOutput(1); |
| |
| initialize(); |
| } |
| |
| PassRefPtr<AudioBufferSourceHandler> AudioBufferSourceHandler::create( |
| AudioNode& node, |
| float sampleRate, |
| AudioParamHandler& playbackRate, |
| AudioParamHandler& detune) { |
| return adoptRef( |
| new AudioBufferSourceHandler(node, sampleRate, playbackRate, detune)); |
| } |
| |
| AudioBufferSourceHandler::~AudioBufferSourceHandler() { |
| uninitialize(); |
| } |
| |
| void AudioBufferSourceHandler::process(size_t framesToProcess) { |
| AudioBus* outputBus = output(0).bus(); |
| |
| if (!isInitialized()) { |
| outputBus->zero(); |
| return; |
| } |
| |
| // The audio thread can't block on this lock, so we call tryLock() instead. |
| MutexTryLocker tryLocker(m_processLock); |
| if (tryLocker.locked()) { |
| if (!buffer()) { |
| outputBus->zero(); |
| return; |
| } |
| |
| // After calling setBuffer() with a buffer having a different number of channels, there can in rare cases be a slight delay |
| // before the output bus is updated to the new number of channels because of use of tryLocks() in the context's updating system. |
| // In this case, if the the buffer has just been changed and we're not quite ready yet, then just output silence. |
| if (numberOfChannels() != buffer()->numberOfChannels()) { |
| outputBus->zero(); |
| return; |
| } |
| |
| size_t quantumFrameOffset; |
| size_t bufferFramesToProcess; |
| |
| updateSchedulingInfo(framesToProcess, outputBus, quantumFrameOffset, |
| bufferFramesToProcess); |
| |
| if (!bufferFramesToProcess) { |
| outputBus->zero(); |
| return; |
| } |
| |
| for (unsigned i = 0; i < outputBus->numberOfChannels(); ++i) |
| m_destinationChannels[i] = outputBus->channel(i)->mutableData(); |
| |
| // Render by reading directly from the buffer. |
| if (!renderFromBuffer(outputBus, quantumFrameOffset, |
| bufferFramesToProcess)) { |
| outputBus->zero(); |
| return; |
| } |
| |
| outputBus->clearSilentFlag(); |
| } else { |
| // Too bad - the tryLock() failed. We must be in the middle of changing buffers and were already outputting silence anyway. |
| outputBus->zero(); |
| } |
| } |
| |
| // Returns true if we're finished. |
| bool AudioBufferSourceHandler::renderSilenceAndFinishIfNotLooping( |
| AudioBus*, |
| unsigned index, |
| size_t framesToProcess) { |
| if (!loop()) { |
| // If we're not looping, then stop playing when we get to the end. |
| |
| if (framesToProcess > 0) { |
| // We're not looping and we've reached the end of the sample data, but we still need to provide more output, |
| // so generate silence for the remaining. |
| for (unsigned i = 0; i < numberOfChannels(); ++i) |
| memset(m_destinationChannels[i] + index, 0, |
| sizeof(float) * framesToProcess); |
| } |
| |
| finish(); |
| return true; |
| } |
| return false; |
| } |
| |
| bool AudioBufferSourceHandler::renderFromBuffer(AudioBus* bus, |
| unsigned destinationFrameOffset, |
| size_t numberOfFrames) { |
| DCHECK(context()->isAudioThread()); |
| |
| // Basic sanity checking |
| DCHECK(bus); |
| DCHECK(buffer()); |
| if (!bus || !buffer()) |
| return false; |
| |
| unsigned numberOfChannels = this->numberOfChannels(); |
| unsigned busNumberOfChannels = bus->numberOfChannels(); |
| |
| bool channelCountGood = |
| numberOfChannels && numberOfChannels == busNumberOfChannels; |
| DCHECK(channelCountGood); |
| if (!channelCountGood) |
| return false; |
| |
| // Sanity check destinationFrameOffset, numberOfFrames. |
| size_t destinationLength = bus->length(); |
| |
| bool isLengthGood = |
| destinationLength <= AudioUtilities::kRenderQuantumFrames && |
| numberOfFrames <= AudioUtilities::kRenderQuantumFrames; |
| DCHECK(isLengthGood); |
| if (!isLengthGood) |
| return false; |
| |
| bool isOffsetGood = |
| destinationFrameOffset <= destinationLength && |
| destinationFrameOffset + numberOfFrames <= destinationLength; |
| DCHECK(isOffsetGood); |
| if (!isOffsetGood) |
| return false; |
| |
| // Potentially zero out initial frames leading up to the offset. |
| if (destinationFrameOffset) { |
| for (unsigned i = 0; i < numberOfChannels; ++i) |
| memset(m_destinationChannels[i], 0, |
| sizeof(float) * destinationFrameOffset); |
| } |
| |
| // Offset the pointers to the correct offset frame. |
| unsigned writeIndex = destinationFrameOffset; |
| |
| size_t bufferLength = buffer()->length(); |
| double bufferSampleRate = buffer()->sampleRate(); |
| |
| // Avoid converting from time to sample-frames twice by computing |
| // the grain end time first before computing the sample frame. |
| unsigned endFrame = |
| m_isGrain ? AudioUtilities::timeToSampleFrame( |
| m_grainOffset + m_grainDuration, bufferSampleRate) |
| : bufferLength; |
| |
| // This is a HACK to allow for HRTF tail-time - avoids glitch at end. |
| // FIXME: implement tailTime for each AudioNode for a more general solution to this problem. |
| // https://bugs.webkit.org/show_bug.cgi?id=77224 |
| if (m_isGrain) |
| endFrame += 512; |
| |
| // Do some sanity checking. |
| if (endFrame > bufferLength) |
| endFrame = bufferLength; |
| |
| // If the .loop attribute is true, then values of m_loopStart == 0 && m_loopEnd == 0 implies |
| // that we should use the entire buffer as the loop, otherwise use the loop values in m_loopStart and m_loopEnd. |
| double virtualEndFrame = endFrame; |
| double virtualDeltaFrames = endFrame; |
| |
| if (loop() && (m_loopStart || m_loopEnd) && m_loopStart >= 0 && |
| m_loopEnd > 0 && m_loopStart < m_loopEnd) { |
| // Convert from seconds to sample-frames. |
| double loopStartFrame = m_loopStart * buffer()->sampleRate(); |
| double loopEndFrame = m_loopEnd * buffer()->sampleRate(); |
| |
| virtualEndFrame = std::min(loopEndFrame, virtualEndFrame); |
| virtualDeltaFrames = virtualEndFrame - loopStartFrame; |
| } |
| |
| // If we're looping and the offset (virtualReadIndex) is past the end of the loop, wrap back to |
| // the beginning of the loop. For other cases, nothing needs to be done. |
| if (loop() && m_virtualReadIndex >= virtualEndFrame) { |
| m_virtualReadIndex = |
| (m_loopStart < 0) ? 0 : (m_loopStart * buffer()->sampleRate()); |
| m_virtualReadIndex = |
| std::min(m_virtualReadIndex, static_cast<double>(bufferLength - 1)); |
| } |
| |
| double computedPlaybackRate = computePlaybackRate(); |
| |
| // Sanity check that our playback rate isn't larger than the loop size. |
| if (computedPlaybackRate > virtualDeltaFrames) |
| return false; |
| |
| // Get local copy. |
| double virtualReadIndex = m_virtualReadIndex; |
| |
| // Render loop - reading from the source buffer to the destination using linear interpolation. |
| int framesToProcess = numberOfFrames; |
| |
| const float** sourceChannels = m_sourceChannels.get(); |
| float** destinationChannels = m_destinationChannels.get(); |
| |
| DCHECK_GE(virtualReadIndex, 0); |
| DCHECK_GE(virtualDeltaFrames, 0); |
| DCHECK_GE(virtualEndFrame, 0); |
| |
| // Optimize for the very common case of playing back with computedPlaybackRate == 1. |
| // We can avoid the linear interpolation. |
| if (computedPlaybackRate == 1 && |
| virtualReadIndex == floor(virtualReadIndex) && |
| virtualDeltaFrames == floor(virtualDeltaFrames) && |
| virtualEndFrame == floor(virtualEndFrame)) { |
| unsigned readIndex = static_cast<unsigned>(virtualReadIndex); |
| unsigned deltaFrames = static_cast<unsigned>(virtualDeltaFrames); |
| endFrame = static_cast<unsigned>(virtualEndFrame); |
| while (framesToProcess > 0) { |
| int framesToEnd = endFrame - readIndex; |
| int framesThisTime = std::min(framesToProcess, framesToEnd); |
| framesThisTime = std::max(0, framesThisTime); |
| |
| DCHECK_LE(writeIndex + framesThisTime, destinationLength); |
| DCHECK_LE(readIndex + framesThisTime, bufferLength); |
| |
| for (unsigned i = 0; i < numberOfChannels; ++i) |
| memcpy(destinationChannels[i] + writeIndex, |
| sourceChannels[i] + readIndex, sizeof(float) * framesThisTime); |
| |
| writeIndex += framesThisTime; |
| readIndex += framesThisTime; |
| framesToProcess -= framesThisTime; |
| |
| // It can happen that framesThisTime is 0. DCHECK that we will actually exit the loop in |
| // this case. framesThisTime is 0 only if readIndex >= endFrame; |
| DCHECK(framesThisTime ? true : readIndex >= endFrame); |
| |
| // Wrap-around. |
| if (readIndex >= endFrame) { |
| readIndex -= deltaFrames; |
| if (renderSilenceAndFinishIfNotLooping(bus, writeIndex, |
| framesToProcess)) |
| break; |
| } |
| } |
| virtualReadIndex = readIndex; |
| } else { |
| while (framesToProcess--) { |
| unsigned readIndex = static_cast<unsigned>(virtualReadIndex); |
| double interpolationFactor = virtualReadIndex - readIndex; |
| |
| // For linear interpolation we need the next sample-frame too. |
| unsigned readIndex2 = readIndex + 1; |
| if (readIndex2 >= bufferLength) { |
| if (loop()) { |
| // Make sure to wrap around at the end of the buffer. |
| readIndex2 = |
| static_cast<unsigned>(virtualReadIndex + 1 - virtualDeltaFrames); |
| } else { |
| readIndex2 = readIndex; |
| } |
| } |
| |
| // Final sanity check on buffer access. |
| // FIXME: as an optimization, try to get rid of this inner-loop check and put assertions and guards before the loop. |
| if (readIndex >= bufferLength || readIndex2 >= bufferLength) |
| break; |
| |
| // Linear interpolation. |
| for (unsigned i = 0; i < numberOfChannels; ++i) { |
| float* destination = destinationChannels[i]; |
| const float* source = sourceChannels[i]; |
| |
| double sample1 = source[readIndex]; |
| double sample2 = source[readIndex2]; |
| double sample = (1.0 - interpolationFactor) * sample1 + |
| interpolationFactor * sample2; |
| |
| destination[writeIndex] = clampTo<float>(sample); |
| } |
| writeIndex++; |
| |
| virtualReadIndex += computedPlaybackRate; |
| |
| // Wrap-around, retaining sub-sample position since virtualReadIndex is floating-point. |
| if (virtualReadIndex >= virtualEndFrame) { |
| virtualReadIndex -= virtualDeltaFrames; |
| if (renderSilenceAndFinishIfNotLooping(bus, writeIndex, |
| framesToProcess)) |
| break; |
| } |
| } |
| } |
| |
| bus->clearSilentFlag(); |
| |
| m_virtualReadIndex = virtualReadIndex; |
| |
| return true; |
| } |
| |
| void AudioBufferSourceHandler::setBuffer(AudioBuffer* buffer, |
| ExceptionState& exceptionState) { |
| DCHECK(isMainThread()); |
| |
| if (m_buffer) { |
| exceptionState.throwDOMException( |
| InvalidStateError, |
| "Cannot set buffer after it has been already been set"); |
| return; |
| } |
| |
| // The context must be locked since changing the buffer can re-configure the number of channels that are output. |
| BaseAudioContext::AutoLocker contextLocker(context()); |
| |
| // This synchronizes with process(). |
| MutexLocker processLocker(m_processLock); |
| |
| if (buffer) { |
| // Do any necesssary re-configuration to the buffer's number of channels. |
| unsigned numberOfChannels = buffer->numberOfChannels(); |
| |
| // This should not be possible since AudioBuffers can't be created with too many channels |
| // either. |
| if (numberOfChannels > BaseAudioContext::maxNumberOfChannels()) { |
| exceptionState.throwDOMException( |
| NotSupportedError, ExceptionMessages::indexOutsideRange( |
| "number of input channels", numberOfChannels, |
| 1u, ExceptionMessages::InclusiveBound, |
| BaseAudioContext::maxNumberOfChannels(), |
| ExceptionMessages::InclusiveBound)); |
| return; |
| } |
| |
| output(0).setNumberOfChannels(numberOfChannels); |
| |
| m_sourceChannels = wrapArrayUnique(new const float*[numberOfChannels]); |
| m_destinationChannels = wrapArrayUnique(new float*[numberOfChannels]); |
| |
| for (unsigned i = 0; i < numberOfChannels; ++i) |
| m_sourceChannels[i] = buffer->getChannelData(i)->data(); |
| |
| // If this is a grain (as set by a previous call to start()), validate the grain parameters |
| // now since it wasn't validated when start was called (because there was no buffer then). |
| if (m_isGrain) |
| clampGrainParameters(buffer); |
| } |
| |
| m_virtualReadIndex = 0; |
| m_buffer = buffer; |
| } |
| |
| unsigned AudioBufferSourceHandler::numberOfChannels() { |
| return output(0).numberOfChannels(); |
| } |
| |
| void AudioBufferSourceHandler::clampGrainParameters(const AudioBuffer* buffer) { |
| DCHECK(buffer); |
| |
| // We have a buffer so we can clip the offset and duration to lie within the buffer. |
| double bufferDuration = buffer->duration(); |
| |
| m_grainOffset = clampTo(m_grainOffset, 0.0, bufferDuration); |
| |
| // If the duration was not explicitly given, use the buffer duration to set the grain |
| // duration. Otherwise, we want to use the user-specified value, of course. |
| if (!m_isDurationGiven) |
| m_grainDuration = bufferDuration - m_grainOffset; |
| |
| if (m_isDurationGiven && loop()) { |
| // We're looping a grain with a grain duration specified. Schedule the loop to stop after |
| // grainDuration seconds after starting, possibly running the loop multiple times if |
| // grainDuration is larger than the buffer duration. The net effect is as if the user called |
| // stop(when + grainDuration). |
| m_grainDuration = |
| clampTo(m_grainDuration, 0.0, std::numeric_limits<double>::infinity()); |
| m_endTime = m_startTime + m_grainDuration; |
| } else { |
| m_grainDuration = |
| clampTo(m_grainDuration, 0.0, bufferDuration - m_grainOffset); |
| } |
| |
| // We call timeToSampleFrame here since at playbackRate == 1 we don't want to go through |
| // linear interpolation at a sub-sample position since it will degrade the quality. When |
| // aligned to the sample-frame the playback will be identical to the PCM data stored in the |
| // buffer. Since playbackRate == 1 is very common, it's worth considering quality. |
| m_virtualReadIndex = |
| AudioUtilities::timeToSampleFrame(m_grainOffset, buffer->sampleRate()); |
| } |
| |
| void AudioBufferSourceHandler::start(double when, |
| ExceptionState& exceptionState) { |
| AudioScheduledSourceHandler::start(when, exceptionState); |
| } |
| |
| void AudioBufferSourceHandler::start(double when, |
| double grainOffset, |
| ExceptionState& exceptionState) { |
| startSource(when, grainOffset, buffer() ? buffer()->duration() : 0, false, |
| exceptionState); |
| } |
| |
| void AudioBufferSourceHandler::start(double when, |
| double grainOffset, |
| double grainDuration, |
| ExceptionState& exceptionState) { |
| startSource(when, grainOffset, grainDuration, true, exceptionState); |
| } |
| |
| void AudioBufferSourceHandler::startSource(double when, |
| double grainOffset, |
| double grainDuration, |
| bool isDurationGiven, |
| ExceptionState& exceptionState) { |
| DCHECK(isMainThread()); |
| |
| // TODO(mlamouri): record when this is called with a user gesture and could |
| // have started the AudioContext if following Safari iOS rules. |
| |
| if (playbackState() != UNSCHEDULED_STATE) { |
| exceptionState.throwDOMException(InvalidStateError, |
| "cannot call start more than once."); |
| return; |
| } |
| |
| if (when < 0) { |
| exceptionState.throwDOMException( |
| InvalidStateError, |
| ExceptionMessages::indexExceedsMinimumBound("start time", when, 0.0)); |
| return; |
| } |
| |
| if (grainOffset < 0) { |
| exceptionState.throwDOMException( |
| InvalidStateError, ExceptionMessages::indexExceedsMinimumBound( |
| "offset", grainOffset, 0.0)); |
| return; |
| } |
| |
| if (grainDuration < 0) { |
| exceptionState.throwDOMException( |
| InvalidStateError, ExceptionMessages::indexExceedsMinimumBound( |
| "duration", grainDuration, 0.0)); |
| return; |
| } |
| |
| // The node is started. Add a reference to keep us alive so that audio |
| // will eventually get played even if Javascript should drop all references |
| // to this node. The reference will get dropped when the source has finished |
| // playing. |
| context()->notifySourceNodeStartedProcessing(node()); |
| |
| // This synchronizes with process(). updateSchedulingInfo will read some of the variables being |
| // set here. |
| MutexLocker processLocker(m_processLock); |
| |
| m_isDurationGiven = isDurationGiven; |
| m_isGrain = true; |
| m_grainOffset = grainOffset; |
| m_grainDuration = grainDuration; |
| |
| // If |when| < currentTime, the source must start now according to the spec. |
| // So just set startTime to currentTime in this case to start the source now. |
| m_startTime = std::max(when, context()->currentTime()); |
| |
| if (buffer()) |
| clampGrainParameters(buffer()); |
| |
| setPlaybackState(SCHEDULED_STATE); |
| } |
| |
| double AudioBufferSourceHandler::computePlaybackRate() { |
| // Incorporate buffer's sample-rate versus BaseAudioContext's sample-rate. |
| // Normally it's not an issue because buffers are loaded at the |
| // BaseAudioContext's sample-rate, but we can handle it in any case. |
| double sampleRateFactor = 1.0; |
| if (buffer()) { |
| // Use doubles to compute this to full accuracy. |
| sampleRateFactor = |
| buffer()->sampleRate() / static_cast<double>(sampleRate()); |
| } |
| |
| // Use finalValue() to incorporate changes of AudioParamTimeline and |
| // AudioSummingJunction from m_playbackRate AudioParam. |
| double basePlaybackRate = m_playbackRate->finalValue(); |
| |
| double finalPlaybackRate = sampleRateFactor * basePlaybackRate; |
| |
| // Take the detune value into account for the final playback rate. |
| finalPlaybackRate *= pow(2, m_detune->finalValue() / 1200); |
| |
| // Sanity check the total rate. It's very important that the resampler not |
| // get any bad rate values. |
| finalPlaybackRate = clampTo(finalPlaybackRate, 0.0, MaxRate); |
| |
| bool isPlaybackRateValid = |
| !std::isnan(finalPlaybackRate) && !std::isinf(finalPlaybackRate); |
| DCHECK(isPlaybackRateValid); |
| |
| if (!isPlaybackRateValid) |
| finalPlaybackRate = 1.0; |
| |
| // Record the minimum playback rate for use by handleStoppableSourceNode. |
| m_minPlaybackRate = std::min(finalPlaybackRate, m_minPlaybackRate); |
| |
| return finalPlaybackRate; |
| } |
| |
| bool AudioBufferSourceHandler::propagatesSilence() const { |
| return !isPlayingOrScheduled() || hasFinished() || !m_buffer; |
| } |
| |
| void AudioBufferSourceHandler::handleStoppableSourceNode() { |
| // If the source node is not looping, and we have a buffer, we can determine when the source |
| // would stop playing. This is intended to handle the (uncommon) scenario where start() has |
| // been called but is never connected to the destination (directly or indirectly). By stopping |
| // the node, the node can be collected. Otherwise, the node will never get collected, leaking |
| // memory. |
| // |
| // If looping was ever done (m_didSetLooping = true), give up. We can't easily determine how |
| // long we looped so we don't know the actual duration thus far, so don't try to do anything |
| // fancy. |
| if (!m_didSetLooping && buffer() && isPlayingOrScheduled() && |
| m_minPlaybackRate > 0) { |
| // Adjust the duration to include the playback rate. Only need to account for rate < 1 |
| // which makes the sound last longer. For rate >= 1, the source stops sooner, but that's |
| // ok. |
| double actualDuration = buffer()->duration() / m_minPlaybackRate; |
| |
| double stopTime = m_startTime + actualDuration; |
| |
| // See crbug.com/478301. If a source node is started via start(), the source may not start |
| // at that time but one quantum (128 frames) later. But we compute the stop time based on |
| // the start time and the duration, so we end up stopping one quantum early. Thus, add a |
| // little extra time; we just need to stop the source sometime after it should have stopped |
| // if it hadn't already. We don't need to be super precise on when to stop. |
| double extraStopTime = |
| kExtraStopFrames / static_cast<double>(context()->sampleRate()); |
| |
| stopTime += extraStopTime; |
| if (context()->currentTime() > stopTime) { |
| // The context time has passed the time when the source nodes should have stopped |
| // playing. Stop the node now and deref it. (But don't run the onEnded event because the |
| // source never actually played.) |
| finishWithoutOnEnded(); |
| } |
| } |
| } |
| |
| // ---------------------------------------------------------------- |
| AudioBufferSourceNode::AudioBufferSourceNode(BaseAudioContext& context) |
| : AudioScheduledSourceNode(context), |
| m_playbackRate(AudioParam::create(context, |
| ParamTypeAudioBufferSourcePlaybackRate, |
| 1.0)), |
| m_detune( |
| AudioParam::create(context, ParamTypeAudioBufferSourceDetune, 0.0)) { |
| setHandler(AudioBufferSourceHandler::create(*this, context.sampleRate(), |
| m_playbackRate->handler(), |
| m_detune->handler())); |
| } |
| |
| AudioBufferSourceNode* AudioBufferSourceNode::create( |
| BaseAudioContext& context, |
| ExceptionState& exceptionState) { |
| DCHECK(isMainThread()); |
| |
| if (context.isContextClosed()) { |
| context.throwExceptionForClosedState(exceptionState); |
| return nullptr; |
| } |
| |
| return new AudioBufferSourceNode(context); |
| } |
| |
| AudioBufferSourceNode* AudioBufferSourceNode::create( |
| BaseAudioContext* context, |
| AudioBufferSourceOptions& options, |
| ExceptionState& exceptionState) { |
| DCHECK(isMainThread()); |
| |
| AudioBufferSourceNode* node = create(*context, exceptionState); |
| |
| if (!node) |
| return nullptr; |
| |
| if (options.hasBuffer()) |
| node->setBuffer(options.buffer(), exceptionState); |
| if (options.hasDetune()) |
| node->detune()->setValue(options.detune()); |
| if (options.hasLoop()) |
| node->setLoop(options.loop()); |
| if (options.hasLoopEnd()) |
| node->setLoopEnd(options.loopEnd()); |
| if (options.hasLoopStart()) |
| node->setLoopStart(options.loopStart()); |
| if (options.hasPlaybackRate()) |
| node->playbackRate()->setValue(options.playbackRate()); |
| |
| return node; |
| } |
| |
| DEFINE_TRACE(AudioBufferSourceNode) { |
| visitor->trace(m_playbackRate); |
| visitor->trace(m_detune); |
| AudioScheduledSourceNode::trace(visitor); |
| } |
| |
| AudioBufferSourceHandler& AudioBufferSourceNode::audioBufferSourceHandler() |
| const { |
| return static_cast<AudioBufferSourceHandler&>(handler()); |
| } |
| |
| AudioBuffer* AudioBufferSourceNode::buffer() const { |
| return audioBufferSourceHandler().buffer(); |
| } |
| |
| void AudioBufferSourceNode::setBuffer(AudioBuffer* newBuffer, |
| ExceptionState& exceptionState) { |
| audioBufferSourceHandler().setBuffer(newBuffer, exceptionState); |
| } |
| |
| AudioParam* AudioBufferSourceNode::playbackRate() const { |
| return m_playbackRate; |
| } |
| |
| AudioParam* AudioBufferSourceNode::detune() const { |
| return m_detune; |
| } |
| |
| bool AudioBufferSourceNode::loop() const { |
| return audioBufferSourceHandler().loop(); |
| } |
| |
| void AudioBufferSourceNode::setLoop(bool loop) { |
| audioBufferSourceHandler().setLoop(loop); |
| } |
| |
| double AudioBufferSourceNode::loopStart() const { |
| return audioBufferSourceHandler().loopStart(); |
| } |
| |
| void AudioBufferSourceNode::setLoopStart(double loopStart) { |
| audioBufferSourceHandler().setLoopStart(loopStart); |
| } |
| |
| double AudioBufferSourceNode::loopEnd() const { |
| return audioBufferSourceHandler().loopEnd(); |
| } |
| |
| void AudioBufferSourceNode::setLoopEnd(double loopEnd) { |
| audioBufferSourceHandler().setLoopEnd(loopEnd); |
| } |
| |
| void AudioBufferSourceNode::start(ExceptionState& exceptionState) { |
| audioBufferSourceHandler().start(0, exceptionState); |
| } |
| |
| void AudioBufferSourceNode::start(double when, ExceptionState& exceptionState) { |
| audioBufferSourceHandler().start(when, exceptionState); |
| } |
| |
| void AudioBufferSourceNode::start(double when, |
| double grainOffset, |
| ExceptionState& exceptionState) { |
| audioBufferSourceHandler().start(when, grainOffset, exceptionState); |
| } |
| |
| void AudioBufferSourceNode::start(double when, |
| double grainOffset, |
| double grainDuration, |
| ExceptionState& exceptionState) { |
| audioBufferSourceHandler().start(when, grainOffset, grainDuration, |
| exceptionState); |
| } |
| |
| } // namespace blink |
