The Tor Browser: comparison content/media/webaudio/ScriptProcessorNode.cpp

--1:000000000000
+:6f40e0983af2
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include "ScriptProcessorNode.h"
+#include "mozilla/dom/ScriptProcessorNodeBinding.h"
+#include "AudioBuffer.h"
+#include "AudioDestinationNode.h"
+#include "AudioNodeEngine.h"
+#include "AudioNodeStream.h"
+#include "AudioProcessingEvent.h"
+#include "WebAudioUtils.h"
+#include "nsCxPusher.h"
+#include "mozilla/Mutex.h"
+#include "mozilla/PodOperations.h"
+#include <deque>
+namespace mozilla {
+namespace dom {
+// The maximum latency, in seconds, that we can live with before dropping
+// buffers.
+static const float MAX_LATENCY_S = 0.5;
+NS_IMPL_ISUPPORTS_INHERITED0(ScriptProcessorNode, AudioNode)
+// This class manages a queue of output buffers shared between
+// the main thread and the Media Stream Graph thread.
+class SharedBuffers
+{
+private:
+class OutputQueue
+{
+public:
+explicit OutputQueue(const char* aName)
+: mMutex(aName)
+{}
+size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const
+{
+mMutex.AssertCurrentThreadOwns();
+size_t amount = 0;
+for (size_t i = 0; i < mBufferList.size(); i++) {
+amount += mBufferList[i].SizeOfExcludingThis(aMallocSizeOf, false);
+}
+return amount;
+}
+Mutex& Lock() const { return const_cast<OutputQueue*>(this)->mMutex; }
+size_t ReadyToConsume() const
+{
+mMutex.AssertCurrentThreadOwns();
+MOZ_ASSERT(!NS_IsMainThread());
+return mBufferList.size();
+}
+// Produce one buffer
+AudioChunk& Produce()
+{
+mMutex.AssertCurrentThreadOwns();
+MOZ_ASSERT(NS_IsMainThread());
+mBufferList.push_back(AudioChunk());
+return mBufferList.back();
+}
+// Consumes one buffer.
+AudioChunk Consume()
+{
+mMutex.AssertCurrentThreadOwns();
+MOZ_ASSERT(!NS_IsMainThread());
+MOZ_ASSERT(ReadyToConsume() > 0);
+AudioChunk front = mBufferList.front();
+mBufferList.pop_front();
+return front;
+}
+// Empties the buffer queue.
+void Clear()
+{
+mMutex.AssertCurrentThreadOwns();
+mBufferList.clear();
+}
+private:
+typedef std::deque<AudioChunk> BufferList;
+// Synchronizes access to mBufferList.  Note that it's the responsibility
+// of the callers to perform the required locking, and we assert that every
+// time we access mBufferList.
+Mutex mMutex;
+// The list representing the queue.
+BufferList mBufferList;
+};
+public:
+SharedBuffers(float aSampleRate)
+: mOutputQueue("SharedBuffers::outputQueue")
+, mDelaySoFar(TRACK_TICKS_MAX)
+, mSampleRate(aSampleRate)
+, mLatency(0.0)
+, mDroppingBuffers(false)
+{
+}
+size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const
+{
+size_t amount = aMallocSizeOf(this);
+{
+MutexAutoLock lock(mOutputQueue.Lock());
+amount += mOutputQueue.SizeOfExcludingThis(aMallocSizeOf);
+}
+return amount;
+}
+// main thread
+void FinishProducingOutputBuffer(ThreadSharedFloatArrayBufferList* aBuffer,
+uint32_t aBufferSize)
+{
+MOZ_ASSERT(NS_IsMainThread());
+TimeStamp now = TimeStamp::Now();
+if (mLastEventTime.IsNull()) {
+mLastEventTime = now;
+} else {
+// When the main thread is blocked, and all the event are processed in a
+// burst after the main thread unblocks, the |(now - mLastEventTime)|
+// interval will be very short. |latency - bufferDuration| will be
+// negative, effectively moving back mLatency to a smaller and smaller
+// value, until it crosses zero, at which point we stop dropping buffers
+// and resume normal operation. This does not work if at the same time,
+// the MSG thread was also slowed down, so if the latency on the MSG
+// thread is normal, and we are still dropping buffers, and mLatency is
+// still more than twice the duration of a buffer, we reset it and stop
+// dropping buffers.
+float latency = (now - mLastEventTime).ToSeconds();
+float bufferDuration = aBufferSize / mSampleRate;
+mLatency += latency - bufferDuration;
+mLastEventTime = now;
+if (mLatency > MAX_LATENCY_S ||
+(mDroppingBuffers && mLatency > 0.0 &&
+fabs(latency - bufferDuration) < bufferDuration)) {
+mDroppingBuffers = true;
+return;
+} else {
+if (mDroppingBuffers) {
+mLatency = 0;
+}
+mDroppingBuffers = false;
+}
+}
+MutexAutoLock lock(mOutputQueue.Lock());
+for (uint32_t offset = 0; offset < aBufferSize; offset += WEBAUDIO_BLOCK_SIZE) {
+AudioChunk& chunk = mOutputQueue.Produce();
+if (aBuffer) {
+chunk.mDuration = WEBAUDIO_BLOCK_SIZE;
+chunk.mBuffer = aBuffer;
+chunk.mChannelData.SetLength(aBuffer->GetChannels());
+for (uint32_t i = 0; i < aBuffer->GetChannels(); ++i) {
+chunk.mChannelData[i] = aBuffer->GetData(i) + offset;
+}
+chunk.mVolume = 1.0f;
+chunk.mBufferFormat = AUDIO_FORMAT_FLOAT32;
+} else {
+chunk.SetNull(WEBAUDIO_BLOCK_SIZE);
+}
+}
+}
+// graph thread
+AudioChunk GetOutputBuffer()
+{
+MOZ_ASSERT(!NS_IsMainThread());
+AudioChunk buffer;
+{
+MutexAutoLock lock(mOutputQueue.Lock());
+if (mOutputQueue.ReadyToConsume() > 0) {
+if (mDelaySoFar == TRACK_TICKS_MAX) {
+mDelaySoFar = 0;
+}
+buffer = mOutputQueue.Consume();
+} else {
+// If we're out of buffers to consume, just output silence
+buffer.SetNull(WEBAUDIO_BLOCK_SIZE);
+if (mDelaySoFar != TRACK_TICKS_MAX) {
+// Remember the delay that we just hit
+mDelaySoFar += WEBAUDIO_BLOCK_SIZE;
+}
+}
+}
+return buffer;
+}
+TrackTicks DelaySoFar() const
+{
+MOZ_ASSERT(!NS_IsMainThread());
+return mDelaySoFar == TRACK_TICKS_MAX ? 0 : mDelaySoFar;
+}
+void Reset()
+{
+MOZ_ASSERT(!NS_IsMainThread());
+mDelaySoFar = TRACK_TICKS_MAX;
+mLatency = 0.0f;
+{
+MutexAutoLock lock(mOutputQueue.Lock());
+mOutputQueue.Clear();
+}
+mLastEventTime = TimeStamp();
+}
+private:
+OutputQueue mOutputQueue;
+// How much delay we've seen so far.  This measures the amount of delay
+// caused by the main thread lagging behind in producing output buffers.
+// TRACK_TICKS_MAX means that we have not received our first buffer yet.
+TrackTicks mDelaySoFar;
+// The samplerate of the context.
+float mSampleRate;
+// This is the latency caused by the buffering. If this grows too high, we
+// will drop buffers until it is acceptable.
+float mLatency;
+// This is the time at which we last produced a buffer, to detect if the main
+// thread has been blocked.
+TimeStamp mLastEventTime;
+// True if we should be dropping buffers.
+bool mDroppingBuffers;
+};
+class ScriptProcessorNodeEngine : public AudioNodeEngine
+{
+public:
+typedef nsAutoTArray<nsAutoArrayPtr<float>, 2> InputChannels;
+ScriptProcessorNodeEngine(ScriptProcessorNode* aNode,
+AudioDestinationNode* aDestination,
+uint32_t aBufferSize,
+uint32_t aNumberOfInputChannels)
+: AudioNodeEngine(aNode)
+, mSharedBuffers(aNode->GetSharedBuffers())
+, mSource(nullptr)
+, mDestination(static_cast<AudioNodeStream*> (aDestination->Stream()))
+, mBufferSize(aBufferSize)
+, mInputWriteIndex(0)
+, mSeenNonSilenceInput(false)
+{
+mInputChannels.SetLength(aNumberOfInputChannels);
+AllocateInputBlock();
+}
+void SetSourceStream(AudioNodeStream* aSource)
+{
+mSource = aSource;
+}
+virtual void ProcessBlock(AudioNodeStream* aStream,
+const AudioChunk& aInput,
+AudioChunk* aOutput,
+bool* aFinished) MOZ_OVERRIDE
+{
+MutexAutoLock lock(NodeMutex());
+// If our node is dead, just output silence.
+if (!Node()) {
+aOutput->SetNull(WEBAUDIO_BLOCK_SIZE);
+return;
+}
+// This node is not connected to anything. Per spec, we don't fire the
+// onaudioprocess event. We also want to clear out the input and output
+// buffer queue, and output a null buffer.
+if (!(aStream->ConsumerCount() ||
+aStream->AsProcessedStream()->InputPortCount())) {
+aOutput->SetNull(WEBAUDIO_BLOCK_SIZE);
+mSharedBuffers->Reset();
+mSeenNonSilenceInput = false;
+mInputWriteIndex = 0;
+return;
+}
+// First, record our input buffer
+for (uint32_t i = 0; i < mInputChannels.Length(); ++i) {
+if (aInput.IsNull()) {
+PodZero(mInputChannels[i] + mInputWriteIndex,
+aInput.GetDuration());
+} else {
+mSeenNonSilenceInput = true;
+MOZ_ASSERT(aInput.GetDuration() == WEBAUDIO_BLOCK_SIZE, "sanity check");
+MOZ_ASSERT(aInput.mChannelData.Length() == mInputChannels.Length());
+AudioBlockCopyChannelWithScale(static_cast<const float*>(aInput.mChannelData[i]),
+aInput.mVolume,
+mInputChannels[i] + mInputWriteIndex);
+}
+}
+mInputWriteIndex += aInput.GetDuration();
+// Now, see if we have data to output
+// Note that we need to do this before sending the buffer to the main
+// thread so that our delay time is updated.
+*aOutput = mSharedBuffers->GetOutputBuffer();
+if (mInputWriteIndex >= mBufferSize) {
+SendBuffersToMainThread(aStream);
+mInputWriteIndex -= mBufferSize;
+mSeenNonSilenceInput = false;
+AllocateInputBlock();
+}
+}
+virtual size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE
+{
+// Not owned:
+// - mSharedBuffers
+// - mSource (probably)
+// - mDestination (probably)
+size_t amount = AudioNodeEngine::SizeOfExcludingThis(aMallocSizeOf);
+amount += mInputChannels.SizeOfExcludingThis(aMallocSizeOf);
+for (size_t i = 0; i < mInputChannels.Length(); i++) {
+amount += mInputChannels[i].SizeOfExcludingThis(aMallocSizeOf);
+}
+return amount;
+}
+virtual size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE
+{
+return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+}
+private:
+void AllocateInputBlock()
+{
+for (unsigned i = 0; i < mInputChannels.Length(); ++i) {
+if (!mInputChannels[i]) {
+mInputChannels[i] = new float[mBufferSize];
+}
+}
+}
+void SendBuffersToMainThread(AudioNodeStream* aStream)
+{
+MOZ_ASSERT(!NS_IsMainThread());
+// we now have a full input buffer ready to be sent to the main thread.
+TrackTicks playbackTick = mSource->GetCurrentPosition();
+// Add the duration of the current sample
+playbackTick += WEBAUDIO_BLOCK_SIZE;
+// Add the delay caused by the main thread
+playbackTick += mSharedBuffers->DelaySoFar();
+// Compute the playback time in the coordinate system of the destination
+// FIXME: bug 970773
+double playbackTime =
+mSource->DestinationTimeFromTicks(mDestination, playbackTick);
+class Command : public nsRunnable
+{
+public:
+Command(AudioNodeStream* aStream,
+InputChannels& aInputChannels,
+double aPlaybackTime,
+bool aNullInput)
+: mStream(aStream)
+, mPlaybackTime(aPlaybackTime)
+, mNullInput(aNullInput)
+{
+mInputChannels.SetLength(aInputChannels.Length());
+if (!aNullInput) {
+for (uint32_t i = 0; i < mInputChannels.Length(); ++i) {
+mInputChannels[i] = aInputChannels[i].forget();
+}
+}
+}
+NS_IMETHODIMP Run()
+{
+// If it's not safe to run scripts right now, schedule this to run later
+if (!nsContentUtils::IsSafeToRunScript()) {
+nsContentUtils::AddScriptRunner(this);
+return NS_OK;
+}
+nsRefPtr<ScriptProcessorNode> node;
+{
+// No need to keep holding the lock for the whole duration of this
+// function, since we're holding a strong reference to it, so if
+// we can obtain the reference, we will hold the node alive in
+// this function.
+MutexAutoLock lock(mStream->Engine()->NodeMutex());
+node = static_cast<ScriptProcessorNode*>(mStream->Engine()->Node());
+}
+if (!node || !node->Context()) {
+return NS_OK;
+}
+AutoPushJSContext cx(node->Context()->GetJSContext());
+if (cx) {
+// Create the input buffer
+nsRefPtr<AudioBuffer> inputBuffer;
+if (!mNullInput) {
+ErrorResult rv;
+inputBuffer =
+AudioBuffer::Create(node->Context(), mInputChannels.Length(),
+node->BufferSize(),
+node->Context()->SampleRate(), cx, rv);
+if (rv.Failed()) {
+return NS_OK;
+}
+// Put the channel data inside it
+for (uint32_t i = 0; i < mInputChannels.Length(); ++i) {
+inputBuffer->SetRawChannelContents(cx, i, mInputChannels[i]);
+}
+}
+// Ask content to produce data in the output buffer
+// Note that we always avoid creating the output buffer here, and we try to
+// avoid creating the input buffer as well.  The AudioProcessingEvent class
+// knows how to lazily create them if needed once the script tries to access
+// them.  Otherwise, we may be able to get away without creating them!
+nsRefPtr<AudioProcessingEvent> event = new AudioProcessingEvent(node, nullptr, nullptr);
+event->InitEvent(inputBuffer,
+mInputChannels.Length(),
+mPlaybackTime);
+node->DispatchTrustedEvent(event);
+// Steal the output buffers if they have been set.  Don't create a
+// buffer if it hasn't been used to return output;
+// FinishProducingOutputBuffer() will optimize output = null.
+// GetThreadSharedChannelsForRate() may also return null after OOM.
+nsRefPtr<ThreadSharedFloatArrayBufferList> output;
+if (event->HasOutputBuffer()) {
+ErrorResult rv;
+AudioBuffer* buffer = event->GetOutputBuffer(rv);
+// HasOutputBuffer() returning true means that GetOutputBuffer()
+// will not fail.
+MOZ_ASSERT(!rv.Failed());
+output = buffer->GetThreadSharedChannelsForRate(cx);
+}
+// Append it to our output buffer queue
+node->GetSharedBuffers()->FinishProducingOutputBuffer(output, node->BufferSize());
+}
+return NS_OK;
+}
+private:
+nsRefPtr<AudioNodeStream> mStream;
+InputChannels mInputChannels;
+double mPlaybackTime;
+bool mNullInput;
+};
+NS_DispatchToMainThread(new Command(aStream, mInputChannels,
+playbackTime,
+!mSeenNonSilenceInput));
+}
+friend class ScriptProcessorNode;
+SharedBuffers* mSharedBuffers;
+AudioNodeStream* mSource;
+AudioNodeStream* mDestination;
+InputChannels mInputChannels;
+const uint32_t mBufferSize;
+// The write index into the current input buffer
+uint32_t mInputWriteIndex;
+bool mSeenNonSilenceInput;
+};
+ScriptProcessorNode::ScriptProcessorNode(AudioContext* aContext,
+uint32_t aBufferSize,
+uint32_t aNumberOfInputChannels,
+uint32_t aNumberOfOutputChannels)
+: AudioNode(aContext,
+aNumberOfInputChannels,
+mozilla::dom::ChannelCountMode::Explicit,
+mozilla::dom::ChannelInterpretation::Speakers)
+, mSharedBuffers(new SharedBuffers(aContext->SampleRate()))
+, mBufferSize(aBufferSize ?
+aBufferSize : // respect what the web developer requested
+4096)         // choose our own buffer size -- 4KB for now
+, mNumberOfOutputChannels(aNumberOfOutputChannels)
+{
+MOZ_ASSERT(BufferSize() % WEBAUDIO_BLOCK_SIZE == 0, "Invalid buffer size");
+ScriptProcessorNodeEngine* engine =
+new ScriptProcessorNodeEngine(this,
+aContext->Destination(),
+BufferSize(),
+aNumberOfInputChannels);
+mStream = aContext->Graph()->CreateAudioNodeStream(engine, MediaStreamGraph::INTERNAL_STREAM);
+engine->SetSourceStream(static_cast<AudioNodeStream*> (mStream.get()));
+}
+ScriptProcessorNode::~ScriptProcessorNode()
+{
+}
+size_t
+ScriptProcessorNode::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const
+{
+size_t amount = AudioNode::SizeOfExcludingThis(aMallocSizeOf);
+amount += mSharedBuffers->SizeOfIncludingThis(aMallocSizeOf);
+return amount;
+}
+size_t
+ScriptProcessorNode::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const
+{
+return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+}
+JSObject*
+ScriptProcessorNode::WrapObject(JSContext* aCx)
+{
+return ScriptProcessorNodeBinding::Wrap(aCx, this);
+}
+}
+}

The Tor Browser / file comparison

comparison: content/media/webaudio/ScriptProcessorNode.cpp

content/media/webaudio/ScriptProcessorNode.cpp