The Tor Browser: comparison content/media/AudioNodeStream.h

--1:000000000000
+:c18cf1e3604a
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-*/
+/* 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/. */
+#ifndef MOZILLA_AUDIONODESTREAM_H_
+#define MOZILLA_AUDIONODESTREAM_H_
+#include "MediaStreamGraph.h"
+#include "mozilla/dom/AudioNodeBinding.h"
+#include "AudioSegment.h"
+namespace mozilla {
+namespace dom {
+struct ThreeDPoint;
+class AudioParamTimeline;
+class DelayNodeEngine;
+class AudioContext;
+}
+class ThreadSharedFloatArrayBufferList;
+class AudioNodeEngine;
+/**
+* An AudioNodeStream produces one audio track with ID AUDIO_TRACK.
+* The start time of the AudioTrack is aligned to the start time of the
+* AudioContext's destination node stream, plus some multiple of BLOCK_SIZE
+* samples.
+*
+* An AudioNodeStream has an AudioNodeEngine plugged into it that does the
+* actual audio processing. AudioNodeStream contains the glue code that
+* integrates audio processing with the MediaStreamGraph.
+*/
+class AudioNodeStream : public ProcessedMediaStream {
+typedef dom::ChannelCountMode ChannelCountMode;
+typedef dom::ChannelInterpretation ChannelInterpretation;
+public:
+typedef mozilla::dom::AudioContext AudioContext;
+enum { AUDIO_TRACK = 1 };
+typedef nsAutoTArray<AudioChunk, 1> OutputChunks;
+/**
+* Transfers ownership of aEngine to the new AudioNodeStream.
+*/
+AudioNodeStream(AudioNodeEngine* aEngine,
+MediaStreamGraph::AudioNodeStreamKind aKind,
+TrackRate aSampleRate)
+: ProcessedMediaStream(nullptr),
+mEngine(aEngine),
+mSampleRate(aSampleRate),
+mKind(aKind),
+mNumberOfInputChannels(2),
+mMarkAsFinishedAfterThisBlock(false),
+mAudioParamStream(false),
+mMuted(false)
+{
+MOZ_ASSERT(NS_IsMainThread());
+mChannelCountMode = ChannelCountMode::Max;
+mChannelInterpretation = ChannelInterpretation::Speakers;
+// AudioNodes are always producing data
+mHasCurrentData = true;
+MOZ_COUNT_CTOR(AudioNodeStream);
+}
+~AudioNodeStream();
+// Control API
+/**
+* Sets a parameter that's a time relative to some stream's played time.
+* This time is converted to a time relative to this stream when it's set.
+*/
+void SetStreamTimeParameter(uint32_t aIndex, AudioContext* aContext,
+double aStreamTime);
+void SetDoubleParameter(uint32_t aIndex, double aValue);
+void SetInt32Parameter(uint32_t aIndex, int32_t aValue);
+void SetTimelineParameter(uint32_t aIndex, const dom::AudioParamTimeline& aValue);
+void SetThreeDPointParameter(uint32_t aIndex, const dom::ThreeDPoint& aValue);
+void SetBuffer(already_AddRefed<ThreadSharedFloatArrayBufferList>&& aBuffer);
+// This consumes the contents of aData.  aData will be emptied after this returns.
+void SetRawArrayData(nsTArray<float>& aData);
+void SetChannelMixingParameters(uint32_t aNumberOfChannels,
+ChannelCountMode aChannelCountMoe,
+ChannelInterpretation aChannelInterpretation);
+ChannelInterpretation GetChannelInterpretation()
+{
+return mChannelInterpretation;
+}
+void SetAudioParamHelperStream()
+{
+MOZ_ASSERT(!mAudioParamStream, "Can only do this once");
+mAudioParamStream = true;
+}
+virtual AudioNodeStream* AsAudioNodeStream() MOZ_OVERRIDE { return this; }
+// Graph thread only
+void SetStreamTimeParameterImpl(uint32_t aIndex, MediaStream* aRelativeToStream,
+double aStreamTime);
+void SetChannelMixingParametersImpl(uint32_t aNumberOfChannels,
+ChannelCountMode aChannelCountMoe,
+ChannelInterpretation aChannelInterpretation);
+virtual void ProcessInput(GraphTime aFrom, GraphTime aTo, uint32_t aFlags) MOZ_OVERRIDE;
+TrackTicks GetCurrentPosition();
+bool IsAudioParamStream() const
+{
+return mAudioParamStream;
+}
+void Mute() {
+mMuted = true;
+}
+void Unmute() {
+mMuted = false;
+}
+const OutputChunks& LastChunks() const
+{
+return mLastChunks;
+}
+virtual bool MainThreadNeedsUpdates() const MOZ_OVERRIDE
+{
+// Only source and external streams need updates on the main thread.
+return (mKind == MediaStreamGraph::SOURCE_STREAM && mFinished) ||
+mKind == MediaStreamGraph::EXTERNAL_STREAM;
+}
+virtual bool IsIntrinsicallyConsumed() const MOZ_OVERRIDE
+{
+return true;
+}
+// Any thread
+AudioNodeEngine* Engine() { return mEngine; }
+TrackRate SampleRate() const { return mSampleRate; }
+/**
+* Convert a time in seconds on the destination stream to seconds
+* on this stream.
+*/
+double TimeFromDestinationTime(AudioNodeStream* aDestination,
+double aSeconds);
+/**
+* Convert a time in seconds on the destination stream to TrackTicks
+* on this stream.
+*/
+TrackTicks TicksFromDestinationTime(MediaStream* aDestination,
+double aSeconds);
+/**
+* Get the destination stream time in seconds corresponding to a position on
+* this stream.
+*/
+double DestinationTimeFromTicks(AudioNodeStream* aDestination,
+TrackTicks aPosition);
+size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE;
+size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE;
+void SizeOfAudioNodesIncludingThis(MallocSizeOf aMallocSizeOf,
+AudioNodeSizes& aUsage) const;
+protected:
+void AdvanceOutputSegment();
+void FinishOutput();
+void AccumulateInputChunk(uint32_t aInputIndex, const AudioChunk& aChunk,
+AudioChunk* aBlock,
+nsTArray<float>* aDownmixBuffer);
+void UpMixDownMixChunk(const AudioChunk* aChunk, uint32_t aOutputChannelCount,
+nsTArray<const void*>& aOutputChannels,
+nsTArray<float>& aDownmixBuffer);
+uint32_t ComputedNumberOfChannels(uint32_t aInputChannelCount);
+void ObtainInputBlock(AudioChunk& aTmpChunk, uint32_t aPortIndex);
+// The engine that will generate output for this node.
+nsAutoPtr<AudioNodeEngine> mEngine;
+// The last block produced by this node.
+OutputChunks mLastChunks;
+// The stream's sampling rate
+const TrackRate mSampleRate;
+// Whether this is an internal or external stream
+MediaStreamGraph::AudioNodeStreamKind mKind;
+// The number of input channels that this stream requires. 0 means don't care.
+uint32_t mNumberOfInputChannels;
+// The mixing modes
+ChannelCountMode mChannelCountMode;
+ChannelInterpretation mChannelInterpretation;
+// Whether the stream should be marked as finished as soon
+// as the current time range has been computed block by block.
+bool mMarkAsFinishedAfterThisBlock;
+// Whether the stream is an AudioParamHelper stream.
+bool mAudioParamStream;
+// Whether the stream is muted. Access only on the MediaStreamGraph thread.
+bool mMuted;
+};
+}
+#endif /* MOZILLA_AUDIONODESTREAM_H_ */

The Tor Browser / file comparison

comparison: content/media/AudioNodeStream.h

content/media/AudioNodeStream.h