mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-09-10 11:54:40 +00:00
416 lines
13 KiB
C++
416 lines
13 KiB
C++
/* -*- 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 "AudioNode.h"
|
|
#include "mozilla/ErrorResult.h"
|
|
#include "AudioNodeStream.h"
|
|
#include "AudioNodeEngine.h"
|
|
#include "mozilla/dom/AudioParam.h"
|
|
#include "mozilla/Services.h"
|
|
#include "nsIObserverService.h"
|
|
|
|
namespace mozilla {
|
|
namespace dom {
|
|
|
|
static const uint32_t INVALID_PORT = 0xffffffff;
|
|
static uint32_t gId = 0;
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CLASS(AudioNode)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(AudioNode, DOMEventTargetHelper)
|
|
tmp->DisconnectFromGraph();
|
|
if (tmp->mContext) {
|
|
tmp->mContext->UnregisterNode(tmp);
|
|
}
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mContext)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mOutputNodes)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mOutputParams)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(AudioNode,
|
|
DOMEventTargetHelper)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mContext)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mOutputNodes)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mOutputParams)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
|
|
|
|
NS_IMPL_ADDREF_INHERITED(AudioNode, DOMEventTargetHelper)
|
|
NS_IMPL_RELEASE_INHERITED(AudioNode, DOMEventTargetHelper)
|
|
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(AudioNode)
|
|
NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
|
|
NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
|
|
|
|
AudioNode::AudioNode(AudioContext* aContext,
|
|
uint32_t aChannelCount,
|
|
ChannelCountMode aChannelCountMode,
|
|
ChannelInterpretation aChannelInterpretation)
|
|
: DOMEventTargetHelper(aContext->GetParentObject())
|
|
, mContext(aContext)
|
|
, mChannelCount(aChannelCount)
|
|
, mChannelCountMode(aChannelCountMode)
|
|
, mChannelInterpretation(aChannelInterpretation)
|
|
, mId(gId++)
|
|
, mPassThrough(false)
|
|
{
|
|
MOZ_ASSERT(aContext);
|
|
DOMEventTargetHelper::BindToOwner(aContext->GetParentObject());
|
|
aContext->RegisterNode(this);
|
|
}
|
|
|
|
AudioNode::~AudioNode()
|
|
{
|
|
MOZ_ASSERT(mInputNodes.IsEmpty());
|
|
MOZ_ASSERT(mOutputNodes.IsEmpty());
|
|
MOZ_ASSERT(mOutputParams.IsEmpty());
|
|
MOZ_ASSERT(!mStream,
|
|
"The webaudio-node-demise notification must have been sent");
|
|
if (mContext) {
|
|
mContext->UnregisterNode(this);
|
|
}
|
|
}
|
|
|
|
size_t
|
|
AudioNode::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const
|
|
{
|
|
// Not owned:
|
|
// - mContext
|
|
// - mStream
|
|
size_t amount = 0;
|
|
|
|
amount += mInputNodes.ShallowSizeOfExcludingThis(aMallocSizeOf);
|
|
for (size_t i = 0; i < mInputNodes.Length(); i++) {
|
|
amount += mInputNodes[i].SizeOfExcludingThis(aMallocSizeOf);
|
|
}
|
|
|
|
// Just measure the array. The entire audio node graph is measured via the
|
|
// MediaStreamGraph's streams, so we don't want to double-count the elements.
|
|
amount += mOutputNodes.ShallowSizeOfExcludingThis(aMallocSizeOf);
|
|
|
|
amount += mOutputParams.ShallowSizeOfExcludingThis(aMallocSizeOf);
|
|
for (size_t i = 0; i < mOutputParams.Length(); i++) {
|
|
amount += mOutputParams[i]->SizeOfIncludingThis(aMallocSizeOf);
|
|
}
|
|
|
|
return amount;
|
|
}
|
|
|
|
size_t
|
|
AudioNode::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const
|
|
{
|
|
return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
|
|
}
|
|
|
|
template <class InputNode>
|
|
static size_t
|
|
FindIndexOfNode(const nsTArray<InputNode>& aInputNodes, const AudioNode* aNode)
|
|
{
|
|
for (size_t i = 0; i < aInputNodes.Length(); ++i) {
|
|
if (aInputNodes[i].mInputNode == aNode) {
|
|
return i;
|
|
}
|
|
}
|
|
return nsTArray<InputNode>::NoIndex;
|
|
}
|
|
|
|
template <class InputNode>
|
|
static size_t
|
|
FindIndexOfNodeWithPorts(const nsTArray<InputNode>& aInputNodes, const AudioNode* aNode,
|
|
uint32_t aInputPort, uint32_t aOutputPort)
|
|
{
|
|
for (size_t i = 0; i < aInputNodes.Length(); ++i) {
|
|
if (aInputNodes[i].mInputNode == aNode &&
|
|
aInputNodes[i].mInputPort == aInputPort &&
|
|
aInputNodes[i].mOutputPort == aOutputPort) {
|
|
return i;
|
|
}
|
|
}
|
|
return nsTArray<InputNode>::NoIndex;
|
|
}
|
|
|
|
void
|
|
AudioNode::DisconnectFromGraph()
|
|
{
|
|
MOZ_ASSERT(mRefCnt.get() > mInputNodes.Length(),
|
|
"Caller should be holding a reference");
|
|
|
|
// The idea here is that we remove connections one by one, and at each step
|
|
// the graph is in a valid state.
|
|
|
|
// Disconnect inputs. We don't need them anymore.
|
|
while (!mInputNodes.IsEmpty()) {
|
|
size_t i = mInputNodes.Length() - 1;
|
|
RefPtr<AudioNode> input = mInputNodes[i].mInputNode;
|
|
mInputNodes.RemoveElementAt(i);
|
|
input->mOutputNodes.RemoveElement(this);
|
|
}
|
|
|
|
while (!mOutputNodes.IsEmpty()) {
|
|
size_t i = mOutputNodes.Length() - 1;
|
|
RefPtr<AudioNode> output = mOutputNodes[i].forget();
|
|
mOutputNodes.RemoveElementAt(i);
|
|
size_t inputIndex = FindIndexOfNode(output->mInputNodes, this);
|
|
// It doesn't matter which one we remove, since we're going to remove all
|
|
// entries for this node anyway.
|
|
output->mInputNodes.RemoveElementAt(inputIndex);
|
|
// This effects of this connection will remain.
|
|
output->NotifyHasPhantomInput();
|
|
}
|
|
|
|
while (!mOutputParams.IsEmpty()) {
|
|
size_t i = mOutputParams.Length() - 1;
|
|
RefPtr<AudioParam> output = mOutputParams[i].forget();
|
|
mOutputParams.RemoveElementAt(i);
|
|
size_t inputIndex = FindIndexOfNode(output->InputNodes(), this);
|
|
// It doesn't matter which one we remove, since we're going to remove all
|
|
// entries for this node anyway.
|
|
output->RemoveInputNode(inputIndex);
|
|
}
|
|
|
|
DestroyMediaStream();
|
|
}
|
|
|
|
AudioNode*
|
|
AudioNode::Connect(AudioNode& aDestination, uint32_t aOutput,
|
|
uint32_t aInput, ErrorResult& aRv)
|
|
{
|
|
if (aOutput >= NumberOfOutputs() ||
|
|
aInput >= aDestination.NumberOfInputs()) {
|
|
aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
|
|
return nullptr;
|
|
}
|
|
|
|
if (Context() != aDestination.Context()) {
|
|
aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
|
|
return nullptr;
|
|
}
|
|
|
|
if (FindIndexOfNodeWithPorts(aDestination.mInputNodes, this, aInput, aOutput) !=
|
|
nsTArray<AudioNode::InputNode>::NoIndex) {
|
|
// connection already exists.
|
|
return &aDestination;
|
|
}
|
|
|
|
WEB_AUDIO_API_LOG("%f: %s %u Connect() to %s %u",
|
|
Context()->CurrentTime(), NodeType(), Id(),
|
|
aDestination.NodeType(), aDestination.Id());
|
|
|
|
// The MediaStreamGraph will handle cycle detection. We don't need to do it
|
|
// here.
|
|
|
|
mOutputNodes.AppendElement(&aDestination);
|
|
InputNode* input = aDestination.mInputNodes.AppendElement();
|
|
input->mInputNode = this;
|
|
input->mInputPort = aInput;
|
|
input->mOutputPort = aOutput;
|
|
AudioNodeStream* destinationStream = aDestination.mStream;
|
|
if (mStream && destinationStream) {
|
|
// Connect streams in the MediaStreamGraph
|
|
MOZ_ASSERT(aInput <= UINT16_MAX, "Unexpected large input port number");
|
|
MOZ_ASSERT(aOutput <= UINT16_MAX, "Unexpected large output port number");
|
|
input->mStreamPort = destinationStream->
|
|
AllocateInputPort(mStream, AudioNodeStream::AUDIO_TRACK,
|
|
static_cast<uint16_t>(aInput),
|
|
static_cast<uint16_t>(aOutput));
|
|
}
|
|
aDestination.NotifyInputsChanged();
|
|
|
|
// This connection may have connected a panner and a source.
|
|
Context()->UpdatePannerSource();
|
|
|
|
return &aDestination;
|
|
}
|
|
|
|
void
|
|
AudioNode::Connect(AudioParam& aDestination, uint32_t aOutput,
|
|
ErrorResult& aRv)
|
|
{
|
|
if (aOutput >= NumberOfOutputs()) {
|
|
aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
|
|
return;
|
|
}
|
|
|
|
if (Context() != aDestination.GetParentObject()) {
|
|
aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
|
|
return;
|
|
}
|
|
|
|
if (FindIndexOfNodeWithPorts(aDestination.InputNodes(), this, INVALID_PORT, aOutput) !=
|
|
nsTArray<AudioNode::InputNode>::NoIndex) {
|
|
// connection already exists.
|
|
return;
|
|
}
|
|
|
|
mOutputParams.AppendElement(&aDestination);
|
|
InputNode* input = aDestination.AppendInputNode();
|
|
input->mInputNode = this;
|
|
input->mInputPort = INVALID_PORT;
|
|
input->mOutputPort = aOutput;
|
|
|
|
MediaStream* stream = aDestination.Stream();
|
|
MOZ_ASSERT(stream->AsProcessedStream());
|
|
ProcessedMediaStream* ps = static_cast<ProcessedMediaStream*>(stream);
|
|
if (mStream) {
|
|
// Setup our stream as an input to the AudioParam's stream
|
|
MOZ_ASSERT(aOutput <= UINT16_MAX, "Unexpected large output port number");
|
|
input->mStreamPort =
|
|
ps->AllocateInputPort(mStream, AudioNodeStream::AUDIO_TRACK,
|
|
0, static_cast<uint16_t>(aOutput));
|
|
}
|
|
}
|
|
|
|
void
|
|
AudioNode::SendDoubleParameterToStream(uint32_t aIndex, double aValue)
|
|
{
|
|
MOZ_ASSERT(mStream, "How come we don't have a stream here?");
|
|
mStream->SetDoubleParameter(aIndex, aValue);
|
|
}
|
|
|
|
void
|
|
AudioNode::SendInt32ParameterToStream(uint32_t aIndex, int32_t aValue)
|
|
{
|
|
MOZ_ASSERT(mStream, "How come we don't have a stream here?");
|
|
mStream->SetInt32Parameter(aIndex, aValue);
|
|
}
|
|
|
|
void
|
|
AudioNode::SendThreeDPointParameterToStream(uint32_t aIndex, const ThreeDPoint& aValue)
|
|
{
|
|
MOZ_ASSERT(mStream, "How come we don't have a stream here?");
|
|
mStream->SetThreeDPointParameter(aIndex, aValue);
|
|
}
|
|
|
|
void
|
|
AudioNode::SendChannelMixingParametersToStream()
|
|
{
|
|
if (mStream) {
|
|
mStream->SetChannelMixingParameters(mChannelCount, mChannelCountMode,
|
|
mChannelInterpretation);
|
|
}
|
|
}
|
|
|
|
void
|
|
AudioNode::Disconnect(uint32_t aOutput, ErrorResult& aRv)
|
|
{
|
|
if (aOutput >= NumberOfOutputs()) {
|
|
aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
|
|
return;
|
|
}
|
|
|
|
WEB_AUDIO_API_LOG("%f: %s %u Disconnect()", Context()->CurrentTime(),
|
|
NodeType(), Id());
|
|
|
|
// An upstream node may be starting to play on the graph thread, and the
|
|
// engine for a downstream node may be sending a PlayingRefChangeHandler
|
|
// ADDREF message to this (main) thread. Wait for a round trip before
|
|
// releasing nodes, to give engines receiving sound now time to keep their
|
|
// nodes alive.
|
|
class RunnableRelease final : public nsRunnable
|
|
{
|
|
public:
|
|
explicit RunnableRelease(already_AddRefed<AudioNode> aNode)
|
|
: mNode(aNode) {}
|
|
|
|
NS_IMETHODIMP Run() override
|
|
{
|
|
mNode = nullptr;
|
|
return NS_OK;
|
|
}
|
|
private:
|
|
RefPtr<AudioNode> mNode;
|
|
};
|
|
|
|
for (int32_t i = mOutputNodes.Length() - 1; i >= 0; --i) {
|
|
AudioNode* dest = mOutputNodes[i];
|
|
for (int32_t j = dest->mInputNodes.Length() - 1; j >= 0; --j) {
|
|
InputNode& input = dest->mInputNodes[j];
|
|
if (input.mInputNode == this && input.mOutputPort == aOutput) {
|
|
// Destroying the InputNode here sends a message to the graph thread
|
|
// to disconnect the streams, which should be sent before the
|
|
// RunAfterPendingUpdates() call below.
|
|
dest->mInputNodes.RemoveElementAt(j);
|
|
// Remove one instance of 'dest' from mOutputNodes. There could be
|
|
// others, and it's not correct to remove them all since some of them
|
|
// could be for different output ports.
|
|
RefPtr<AudioNode> output = mOutputNodes[i].forget();
|
|
mOutputNodes.RemoveElementAt(i);
|
|
output->NotifyInputsChanged();
|
|
if (mStream) {
|
|
RefPtr<nsIRunnable> runnable = new RunnableRelease(output.forget());
|
|
mStream->RunAfterPendingUpdates(runnable.forget());
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int32_t i = mOutputParams.Length() - 1; i >= 0; --i) {
|
|
AudioParam* dest = mOutputParams[i];
|
|
for (int32_t j = dest->InputNodes().Length() - 1; j >= 0; --j) {
|
|
const InputNode& input = dest->InputNodes()[j];
|
|
if (input.mInputNode == this && input.mOutputPort == aOutput) {
|
|
dest->RemoveInputNode(j);
|
|
// Remove one instance of 'dest' from mOutputParams. There could be
|
|
// others, and it's not correct to remove them all since some of them
|
|
// could be for different output ports.
|
|
mOutputParams.RemoveElementAt(i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// This disconnection may have disconnected a panner and a source.
|
|
Context()->UpdatePannerSource();
|
|
}
|
|
|
|
void
|
|
AudioNode::DestroyMediaStream()
|
|
{
|
|
if (mStream) {
|
|
// Remove the node pointer on the engine.
|
|
AudioNodeStream* ns = mStream;
|
|
MOZ_ASSERT(ns, "How come we don't have a stream here?");
|
|
MOZ_ASSERT(ns->Engine()->NodeMainThread() == this,
|
|
"Invalid node reference");
|
|
ns->Engine()->ClearNode();
|
|
|
|
mStream->Destroy();
|
|
mStream = nullptr;
|
|
|
|
nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
|
|
if (obs) {
|
|
nsAutoString id;
|
|
id.AppendPrintf("%u", mId);
|
|
obs->NotifyObservers(nullptr, "webaudio-node-demise", id.get());
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
AudioNode::RemoveOutputParam(AudioParam* aParam)
|
|
{
|
|
mOutputParams.RemoveElement(aParam);
|
|
}
|
|
|
|
bool
|
|
AudioNode::PassThrough() const
|
|
{
|
|
MOZ_ASSERT(NumberOfInputs() <= 1 && NumberOfOutputs() == 1);
|
|
return mPassThrough;
|
|
}
|
|
|
|
void
|
|
AudioNode::SetPassThrough(bool aPassThrough)
|
|
{
|
|
MOZ_ASSERT(NumberOfInputs() <= 1 && NumberOfOutputs() == 1);
|
|
mPassThrough = aPassThrough;
|
|
if (mStream) {
|
|
mStream->SetPassThrough(mPassThrough);
|
|
}
|
|
}
|
|
|
|
} // namespace dom
|
|
} // namespace mozilla
|