From 6bf0a5cb5034a7e684dcc3500e841785237ce2dd Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 19:32:43 +0200 Subject: Adding upstream version 1:115.7.0. Signed-off-by: Daniel Baumann --- dom/media/AudioStream.h | 394 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 394 insertions(+) create mode 100644 dom/media/AudioStream.h (limited to 'dom/media/AudioStream.h') diff --git a/dom/media/AudioStream.h b/dom/media/AudioStream.h new file mode 100644 index 0000000000..84984452e7 --- /dev/null +++ b/dom/media/AudioStream.h @@ -0,0 +1,394 @@ +/* -*- 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/. */ +#if !defined(AudioStream_h_) +# define AudioStream_h_ + +# include "AudioSampleFormat.h" +# include "CubebUtils.h" +# include "MediaInfo.h" +# include "MediaSink.h" +# include "mozilla/Atomics.h" +# include "mozilla/Monitor.h" +# include "mozilla/MozPromise.h" +# include "mozilla/ProfilerUtils.h" +# include "mozilla/RefPtr.h" +# include "mozilla/Result.h" +# include "mozilla/TimeStamp.h" +# include "mozilla/UniquePtr.h" +# include "mozilla/SPSCQueue.h" +# include "nsCOMPtr.h" +# include "nsThreadUtils.h" +# include "WavDumper.h" + +namespace soundtouch { +class MOZ_EXPORT SoundTouch; +} + +namespace mozilla { + +struct CubebDestroyPolicy { + void operator()(cubeb_stream* aStream) const { + cubeb_stream_destroy(aStream); + } +}; + +enum class ShutdownCause { + // Regular shutdown, signal the end of the audio stream. + Regular, + // Shutdown for muting, don't signal the end of the audio stream. + Muting +}; + +class AudioStream; +class FrameHistory; +class AudioConfig; + +// A struct that contains the number of frames serviced or underrun by a +// callback, alongside the sample-rate for this callback (in case of playback +// rate change, it can be variable). +struct CallbackInfo { + CallbackInfo() = default; + CallbackInfo(uint32_t aServiced, uint32_t aUnderrun, uint32_t aOutputRate) + : mServiced(aServiced), mUnderrun(aUnderrun), mOutputRate(aOutputRate) {} + uint32_t mServiced = 0; + uint32_t mUnderrun = 0; + uint32_t mOutputRate = 0; +}; + +class AudioClock { + public: + explicit AudioClock(uint32_t aInRate); + + // Update the number of samples that has been written in the audio backend. + // Called on the audio thread only. + void UpdateFrameHistory(uint32_t aServiced, uint32_t aUnderrun, + bool aAudioThreadChanged); + + /** + * @param aFrames The playback position in frames of the audio engine. + * @return The playback position in frames of the stream, + * adjusted by playback rate changes and underrun frames. + */ + int64_t GetPositionInFrames(int64_t aFrames); + + /** + * @param frames The playback position in frames of the audio engine. + * @return The playback position in microseconds of the stream, + * adjusted by playback rate changes and underrun frames. + */ + int64_t GetPosition(int64_t frames); + + // Set the playback rate. + // Called on the audio thread only. + void SetPlaybackRate(double aPlaybackRate); + // Get the current playback rate. + // Called on the audio thread only. + double GetPlaybackRate() const; + // Set if we are preserving the pitch. + // Called on the audio thread only. + void SetPreservesPitch(bool aPreservesPitch); + // Get the current pitch preservation state. + // Called on the audio thread only. + bool GetPreservesPitch() const; + + // Called on either thread. + uint32_t GetInputRate() const { return mInRate; } + uint32_t GetOutputRate() const { return mOutRate; } + + private: + // Output rate in Hz (characteristic of the playback rate). Written on the + // audio thread, read on either thread. + Atomic mOutRate; + // Input rate in Hz (characteristic of the media being played). + const uint32_t mInRate; + // True if the we are timestretching, false if we are resampling. Accessed on + // the audio thread only. + bool mPreservesPitch; + // The history of frames sent to the audio engine in each DataCallback. + // Only accessed from non-audio threads on macOS, accessed on both threads and + // protected by the AudioStream monitor on other platforms. + const UniquePtr mFrameHistory +# ifndef XP_MACOSX + MOZ_GUARDED_BY(mMutex) +# endif + ; +# ifdef XP_MACOSX + // Enqueued on the audio thread, dequeued from the other thread. The maximum + // size of this queue has been chosen empirically. + SPSCQueue mCallbackInfoQueue{100}; + // If it isn't possible to send the callback info to the non-audio thread, + // store them here until it's possible to send them. This is an unlikely + // fallback path. The size of this array has been chosen empirically. Only + // ever accessed on the audio thread. + AutoTArray mAudioThreadCallbackInfo; +# else + Mutex mMutex{"AudioClock"}; +# endif +}; + +/* + * A bookkeeping class to track the read/write position of an audio buffer. + */ +class AudioBufferCursor { + public: + AudioBufferCursor(Span aSpan, uint32_t aChannels, + uint32_t aFrames) + : mChannels(aChannels), mSpan(aSpan), mFrames(aFrames) {} + + // Advance the cursor to account for frames that are consumed. + uint32_t Advance(uint32_t aFrames) { + MOZ_DIAGNOSTIC_ASSERT(Contains(aFrames)); + MOZ_ASSERT(mFrames >= aFrames); + mFrames -= aFrames; + mOffset += mChannels * aFrames; + return aFrames; + } + + // The number of frames available for read/write in this buffer. + uint32_t Available() const { return mFrames; } + + // Return a pointer where read/write should begin. + AudioDataValue* Ptr() const { + MOZ_DIAGNOSTIC_ASSERT(mOffset <= mSpan.Length()); + return mSpan.Elements() + mOffset; + } + + protected: + bool Contains(uint32_t aFrames) const { + return mSpan.Length() >= mOffset + mChannels * aFrames; + } + const uint32_t mChannels; + + private: + const Span mSpan; + size_t mOffset = 0; + uint32_t mFrames; +}; + +/* + * A helper class to encapsulate pointer arithmetic and provide means to modify + * the underlying audio buffer. + */ +class AudioBufferWriter : public AudioBufferCursor { + public: + AudioBufferWriter(Span aSpan, uint32_t aChannels, + uint32_t aFrames) + : AudioBufferCursor(aSpan, aChannels, aFrames) {} + + uint32_t WriteZeros(uint32_t aFrames) { + MOZ_DIAGNOSTIC_ASSERT(Contains(aFrames)); + memset(Ptr(), 0, sizeof(AudioDataValue) * mChannels * aFrames); + return Advance(aFrames); + } + + uint32_t Write(const AudioDataValue* aPtr, uint32_t aFrames) { + MOZ_DIAGNOSTIC_ASSERT(Contains(aFrames)); + memcpy(Ptr(), aPtr, sizeof(AudioDataValue) * mChannels * aFrames); + return Advance(aFrames); + } + + // Provide a write fuction to update the audio buffer with the following + // signature: uint32_t(const AudioDataValue* aPtr, uint32_t aFrames) + // aPtr: Pointer to the audio buffer. + // aFrames: The number of frames available in the buffer. + // return: The number of frames actually written by the function. + template + uint32_t Write(const Function& aFunction, uint32_t aFrames) { + MOZ_DIAGNOSTIC_ASSERT(Contains(aFrames)); + return Advance(aFunction(Ptr(), aFrames)); + } + + using AudioBufferCursor::Available; +}; + +// Access to a single instance of this class must be synchronized by +// callers, or made from a single thread. One exception is that access to +// GetPosition, GetPositionInFrames, SetVolume, and Get{Rate,Channels}, +// SetMicrophoneActive is thread-safe without external synchronization. +class AudioStream final { + virtual ~AudioStream(); + + public: + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(AudioStream) + + class Chunk { + public: + // Return a pointer to the audio data. + virtual const AudioDataValue* Data() const = 0; + // Return the number of frames in this chunk. + virtual uint32_t Frames() const = 0; + // Return the number of audio channels. + virtual uint32_t Channels() const = 0; + // Return the sample rate of this chunk. + virtual uint32_t Rate() const = 0; + // Return a writable pointer for downmixing. + virtual AudioDataValue* GetWritable() const = 0; + virtual ~Chunk() = default; + }; + + class DataSource { + public: + // Attempt to acquire aFrames frames of audio, and returns the number of + // frames successfuly acquired. + virtual uint32_t PopFrames(AudioDataValue* aAudio, uint32_t aFrames, + bool aAudioThreadChanged) = 0; + // Return true if no more data will be added to the source. + virtual bool Ended() const = 0; + + protected: + virtual ~DataSource() = default; + }; + + // aOutputChannels is the number of audio channels (1 for mono, 2 for stereo, + // etc), aChannelMap is the indicator for channel layout(mono, stereo, 5.1 or + // 7.1 ). Initialize the audio stream.and aRate is the sample rate + // (22050Hz, 44100Hz, etc). + AudioStream(DataSource& aSource, uint32_t aInRate, uint32_t aOutputChannels, + AudioConfig::ChannelLayout::ChannelMap aChannelMap); + + nsresult Init(AudioDeviceInfo* aSinkInfo); + + // Closes the stream. All future use of the stream is an error. + Maybe> Shutdown( + ShutdownCause = ShutdownCause::Regular); + + void Reset(); + + // Set the current volume of the audio playback. This is a value from + // 0 (meaning muted) to 1 (meaning full volume). Thread-safe. + void SetVolume(double aVolume); + + void SetStreamName(const nsAString& aStreamName); + + // Start the stream. + nsresult Start(MozPromiseHolder& aEndedPromise); + + // Pause audio playback. + void Pause(); + + // Resume audio playback. + void Resume(); + + // Return the position in microseconds of the audio frame being played by + // the audio hardware, compensated for playback rate change. Thread-safe. + int64_t GetPosition(); + + // Return the position, measured in audio frames played since the stream + // was opened, of the audio hardware. Thread-safe. + int64_t GetPositionInFrames(); + + uint32_t GetOutChannels() const { return mOutChannels; } + + // Set playback rate as a multiple of the intrinsic playback rate. This is + // to be called only with aPlaybackRate > 0.0. + nsresult SetPlaybackRate(double aPlaybackRate); + // Switch between resampling (if false) and time stretching (if true, + // default). + nsresult SetPreservesPitch(bool aPreservesPitch); + + size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const; + + bool IsPlaybackCompleted() const; + + // Returns true if at least one DataCallback has been called. + bool CallbackStarted() const { return mCallbacksStarted; } + + protected: + friend class AudioClock; + + // Return the position, measured in audio frames played since the stream was + // opened, of the audio hardware, not adjusted for the changes of playback + // rate or underrun frames. + // Caller must own the monitor. + int64_t GetPositionInFramesUnlocked(); + + private: + nsresult OpenCubeb(cubeb* aContext, cubeb_stream_params& aParams, + TimeStamp aStartTime, bool aIsFirst); + + static long DataCallback_S(cubeb_stream*, void* aThis, + const void* /* aInputBuffer */, + void* aOutputBuffer, long aFrames) { + return static_cast(aThis)->DataCallback(aOutputBuffer, + aFrames); + } + + static void StateCallback_S(cubeb_stream*, void* aThis, cubeb_state aState) { + static_cast(aThis)->StateCallback(aState); + } + + long DataCallback(void* aBuffer, long aFrames); + void StateCallback(cubeb_state aState); + + // Audio thread only + nsresult EnsureTimeStretcherInitialized(); + void GetUnprocessed(AudioBufferWriter& aWriter); + void GetTimeStretched(AudioBufferWriter& aWriter); + void UpdatePlaybackRateIfNeeded(); + + // Return true if audio frames are valid (correct sampling rate and valid + // channel count) otherwise false. + bool IsValidAudioFormat(Chunk* aChunk) MOZ_REQUIRES(mMonitor); + + template + int InvokeCubeb(Function aFunction, Args&&... aArgs) MOZ_REQUIRES(mMonitor); + bool CheckThreadIdChanged(); + void AssertIsOnAudioThread() const; + + soundtouch::SoundTouch* mTimeStretcher; + + AudioClock mAudioClock; + + WavDumper mDumpFile; + + const AudioConfig::ChannelLayout::ChannelMap mChannelMap; + + // The monitor is held to protect all access to member variables below. + Monitor mMonitor MOZ_UNANNOTATED; + + const uint32_t mOutChannels; + + // Owning reference to a cubeb_stream. Set in Init(), cleared in Shutdown, so + // no lock is needed to access. + UniquePtr mCubebStream; + + enum StreamState { + INITIALIZED, // Initialized, playback has not begun. + STARTED, // cubeb started. + STOPPED, // Stopped by a call to Pause(). + DRAINED, // StateCallback has indicated that the drain is complete. + ERRORED, // Stream disabled due to an internal error. + SHUTDOWN // Shutdown has been called + }; + + std::atomic mState; + + // DataSource::PopFrames can never be called concurrently. + // DataSource::IsEnded uses only atomics. + DataSource& mDataSource; + + // The device info of the current sink. If null + // the default device is used. It is set + // during the Init() in decoder thread. + RefPtr mSinkInfo; + // Contains the id of the audio thread, from profiler_get_thread_id. + std::atomic mAudioThreadId; + const bool mSandboxed = false; + + MozPromiseHolder mEndedPromise + MOZ_GUARDED_BY(mMonitor); + std::atomic mPlaybackComplete; + // Both written on the MDSM thread, read on the audio thread. + std::atomic mPlaybackRate; + std::atomic mPreservesPitch; + // Audio thread only + bool mAudioThreadChanged = false; + Atomic mCallbacksStarted; +}; + +} // namespace mozilla + +#endif -- cgit v1.2.3