summaryrefslogtreecommitdiffstats
path: root/dom/media/webaudio/ConstantSourceNode.cpp
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--dom/media/webaudio/ConstantSourceNode.cpp279
1 files changed, 279 insertions, 0 deletions
diff --git a/dom/media/webaudio/ConstantSourceNode.cpp b/dom/media/webaudio/ConstantSourceNode.cpp
new file mode 100644
index 0000000000..01ee570722
--- /dev/null
+++ b/dom/media/webaudio/ConstantSourceNode.cpp
@@ -0,0 +1,279 @@
+/* -*- 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 "ConstantSourceNode.h"
+
+#include "AudioDestinationNode.h"
+#include "nsContentUtils.h"
+#include "AudioNodeEngine.h"
+#include "AudioNodeTrack.h"
+#include "Tracing.h"
+
+namespace mozilla::dom {
+
+NS_IMPL_CYCLE_COLLECTION_INHERITED(ConstantSourceNode, AudioScheduledSourceNode,
+ mOffset)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ConstantSourceNode)
+NS_INTERFACE_MAP_END_INHERITING(AudioScheduledSourceNode)
+
+NS_IMPL_ADDREF_INHERITED(ConstantSourceNode, AudioScheduledSourceNode)
+NS_IMPL_RELEASE_INHERITED(ConstantSourceNode, AudioScheduledSourceNode)
+
+class ConstantSourceNodeEngine final : public AudioNodeEngine {
+ public:
+ ConstantSourceNodeEngine(AudioNode* aNode, AudioDestinationNode* aDestination)
+ : AudioNodeEngine(aNode),
+ mSource(nullptr),
+ mDestination(aDestination->Track()),
+ mStart(-1),
+ mStop(TRACK_TIME_MAX)
+ // Keep the default values in sync with
+ // ConstantSourceNode::ConstantSourceNode.
+ ,
+ mOffset(1.0f) {
+ MOZ_ASSERT(NS_IsMainThread());
+ }
+
+ void SetSourceTrack(AudioNodeTrack* aSource) { mSource = aSource; }
+
+ enum Parameters {
+ OFFSET,
+ START,
+ STOP,
+ };
+ void RecvTimelineEvent(uint32_t aIndex, AudioTimelineEvent& aEvent) override {
+ MOZ_ASSERT(mDestination);
+
+ WebAudioUtils::ConvertAudioTimelineEventToTicks(aEvent, mDestination);
+
+ switch (aIndex) {
+ case OFFSET:
+ mOffset.InsertEvent<int64_t>(aEvent);
+ break;
+ default:
+ NS_ERROR("Bad ConstantSourceNodeEngine TimelineParameter");
+ }
+ }
+
+ void SetTrackTimeParameter(uint32_t aIndex, TrackTime aParam) override {
+ switch (aIndex) {
+ case START:
+ mStart = aParam;
+ mSource->SetActive();
+ break;
+ case STOP:
+ mStop = aParam;
+ break;
+ default:
+ NS_ERROR("Bad ConstantSourceNodeEngine TrackTimeParameter");
+ }
+ }
+
+ void ProcessBlock(AudioNodeTrack* aTrack, GraphTime aFrom,
+ const AudioBlock& aInput, AudioBlock* aOutput,
+ bool* aFinished) override {
+ MOZ_ASSERT(mSource == aTrack, "Invalid source track");
+ TRACE("ConstantSourceNodeEngine::ProcessBlock");
+
+ TrackTime ticks = mDestination->GraphTimeToTrackTime(aFrom);
+ if (mStart == -1) {
+ aOutput->SetNull(WEBAUDIO_BLOCK_SIZE);
+ return;
+ }
+
+ if (ticks + WEBAUDIO_BLOCK_SIZE <= mStart || ticks >= mStop ||
+ mStop <= mStart) {
+ aOutput->SetNull(WEBAUDIO_BLOCK_SIZE);
+ } else {
+ aOutput->AllocateChannels(1);
+ float* output = aOutput->ChannelFloatsForWrite(0);
+ uint32_t writeOffset = 0;
+
+ if (ticks < mStart) {
+ MOZ_ASSERT(mStart - ticks <= WEBAUDIO_BLOCK_SIZE);
+ uint32_t count = mStart - ticks;
+ std::fill_n(output, count, 0.0f);
+ writeOffset += count;
+ }
+
+ MOZ_ASSERT(ticks + writeOffset >= mStart);
+ MOZ_ASSERT(mStop - ticks >= writeOffset);
+ uint32_t count =
+ std::min<TrackTime>(WEBAUDIO_BLOCK_SIZE, mStop - ticks) - writeOffset;
+
+ if (mOffset.HasSimpleValue()) {
+ float value = mOffset.GetValueAtTime(ticks);
+ std::fill_n(output + writeOffset, count, value);
+ } else {
+ mOffset.GetValuesAtTime(ticks + writeOffset, output + writeOffset,
+ count);
+ }
+
+ writeOffset += count;
+
+ std::fill_n(output + writeOffset, WEBAUDIO_BLOCK_SIZE - writeOffset,
+ 0.0f);
+ }
+
+ if (ticks + WEBAUDIO_BLOCK_SIZE >= mStop) {
+ // We've finished playing.
+ *aFinished = true;
+ }
+ }
+
+ bool IsActive() const override {
+ // start() has been called.
+ return mStart != -1;
+ }
+
+ size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const override {
+ size_t amount = AudioNodeEngine::SizeOfExcludingThis(aMallocSizeOf);
+
+ // Not owned:
+ // - mSource
+ // - mDestination
+ // - mOffset (internal ref owned by node)
+
+ return amount;
+ }
+
+ size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const override {
+ return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+ }
+
+ // mSource deletes the engine in its destructor.
+ AudioNodeTrack* MOZ_NON_OWNING_REF mSource;
+ RefPtr<AudioNodeTrack> mDestination;
+ TrackTime mStart;
+ TrackTime mStop;
+ AudioParamTimeline mOffset;
+};
+
+ConstantSourceNode::ConstantSourceNode(AudioContext* aContext)
+ : AudioScheduledSourceNode(aContext, 2, ChannelCountMode::Max,
+ ChannelInterpretation::Speakers),
+ mStartCalled(false) {
+ mOffset =
+ CreateAudioParam(ConstantSourceNodeEngine::OFFSET, u"offset"_ns, 1.0f);
+ ConstantSourceNodeEngine* engine =
+ new ConstantSourceNodeEngine(this, aContext->Destination());
+ mTrack = AudioNodeTrack::Create(aContext, engine,
+ AudioNodeTrack::NEED_MAIN_THREAD_ENDED,
+ aContext->Graph());
+ engine->SetSourceTrack(mTrack);
+ mTrack->AddMainThreadListener(this);
+}
+
+ConstantSourceNode::~ConstantSourceNode() = default;
+
+size_t ConstantSourceNode::SizeOfExcludingThis(
+ MallocSizeOf aMallocSizeOf) const {
+ size_t amount = AudioNode::SizeOfExcludingThis(aMallocSizeOf);
+
+ amount += mOffset->SizeOfIncludingThis(aMallocSizeOf);
+ return amount;
+}
+
+size_t ConstantSourceNode::SizeOfIncludingThis(
+ MallocSizeOf aMallocSizeOf) const {
+ return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+}
+
+JSObject* ConstantSourceNode::WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) {
+ return ConstantSourceNode_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+already_AddRefed<ConstantSourceNode> ConstantSourceNode::Constructor(
+ const GlobalObject& aGlobal, AudioContext& aContext,
+ const ConstantSourceOptions& aOptions) {
+ RefPtr<ConstantSourceNode> object = new ConstantSourceNode(&aContext);
+ object->mOffset->SetInitialValue(aOptions.mOffset);
+ return object.forget();
+}
+
+void ConstantSourceNode::DestroyMediaTrack() {
+ if (mTrack) {
+ mTrack->RemoveMainThreadListener(this);
+ }
+ AudioNode::DestroyMediaTrack();
+}
+
+void ConstantSourceNode::Start(double aWhen, ErrorResult& aRv) {
+ if (!WebAudioUtils::IsTimeValid(aWhen)) {
+ aRv.ThrowRangeError<MSG_VALUE_OUT_OF_RANGE>("start time");
+ return;
+ }
+
+ if (mStartCalled) {
+ aRv.ThrowInvalidStateError("Can't call start() more than once");
+ return;
+ }
+ mStartCalled = true;
+
+ if (!mTrack) {
+ return;
+ }
+
+ mTrack->SetTrackTimeParameter(ConstantSourceNodeEngine::START, Context(),
+ aWhen);
+
+ MarkActive();
+ Context()->StartBlockedAudioContextIfAllowed();
+}
+
+void ConstantSourceNode::Stop(double aWhen, ErrorResult& aRv) {
+ if (!WebAudioUtils::IsTimeValid(aWhen)) {
+ aRv.ThrowRangeError<MSG_VALUE_OUT_OF_RANGE>("stop time");
+ return;
+ }
+
+ if (!mStartCalled) {
+ aRv.ThrowInvalidStateError("Can't call stop() without calling start()");
+ return;
+ }
+
+ if (!mTrack || !Context()) {
+ return;
+ }
+
+ mTrack->SetTrackTimeParameter(ConstantSourceNodeEngine::STOP, Context(),
+ std::max(0.0, aWhen));
+}
+
+void ConstantSourceNode::NotifyMainThreadTrackEnded() {
+ MOZ_ASSERT(mTrack->IsEnded());
+
+ class EndedEventDispatcher final : public Runnable {
+ public:
+ explicit EndedEventDispatcher(ConstantSourceNode* aNode)
+ : mozilla::Runnable("EndedEventDispatcher"), mNode(aNode) {}
+ NS_IMETHOD Run() override {
+ // If it's not safe to run scripts right now, schedule this to run later
+ if (!nsContentUtils::IsSafeToRunScript()) {
+ nsContentUtils::AddScriptRunner(this);
+ return NS_OK;
+ }
+
+ mNode->DispatchTrustedEvent(u"ended"_ns);
+ // Release track resources.
+ mNode->DestroyMediaTrack();
+ return NS_OK;
+ }
+
+ private:
+ RefPtr<ConstantSourceNode> mNode;
+ };
+
+ Context()->Dispatch(do_AddRef(new EndedEventDispatcher(this)));
+
+ // Drop the playing reference
+ // Warning: The below line might delete this.
+ MarkInactive();
+}
+
+} // namespace mozilla::dom