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/AudioInputSource.h | 127 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 127 insertions(+) create mode 100644 dom/media/AudioInputSource.h (limited to 'dom/media/AudioInputSource.h') diff --git a/dom/media/AudioInputSource.h b/dom/media/AudioInputSource.h new file mode 100644 index 0000000000..df5bd3fafb --- /dev/null +++ b/dom/media/AudioInputSource.h @@ -0,0 +1,127 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=2 et sw=2 tw=80: */ +/* 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 https://mozilla.org/MPL/2.0/. */ + +#ifndef DOM_MEDIA_AudioInputSource_H_ +#define DOM_MEDIA_AudioInputSource_H_ + +#include "AudioDriftCorrection.h" +#include "AudioSegment.h" +#include "CubebInputStream.h" +#include "CubebUtils.h" +#include "mozilla/ProfilerUtils.h" +#include "mozilla/RefPtr.h" +#include "mozilla/SPSCQueue.h" +#include "mozilla/SharedThreadPool.h" + +namespace mozilla { + +// This is an interface to operate an input-only audio stream within a +// cubeb-task thread on a specific thread. Once the class instance is created, +// all its operations must be called on the same thread. +// +// The audio data is periodically produced by the underlying audio stream on the +// stream's callback thread, and can be safely read by GetAudioSegment() on a +// specific thread. +class AudioInputSource : public CubebInputStream::Listener { + public: + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(AudioInputSource, override); + + using Id = uint32_t; + + class EventListener { + public: + NS_INLINE_DECL_PURE_VIRTUAL_REFCOUNTING; + + // This two events will be fired on main thread. + virtual void AudioDeviceChanged(Id aId) = 0; + enum class State { Started, Stopped, Drained, Error }; + virtual void AudioStateCallback(Id aId, State aState) = 0; + + protected: + EventListener() = default; + virtual ~EventListener() = default; + }; + + AudioInputSource(RefPtr&& aListener, Id aSourceId, + CubebUtils::AudioDeviceID aDeviceId, uint32_t aChannelCount, + bool aIsVoice, const PrincipalHandle& aPrincipalHandle, + TrackRate aSourceRate, TrackRate aTargetRate, + uint32_t aBufferMs); + + // The following functions should always be called in the same thread: They + // are always run on MediaTrackGraph's graph thread. + // Starts producing audio data. + void Start(); + // Stops producing audio data. + void Stop(); + // Returns the AudioSegment with aDuration of data inside. + // The graph thread can change behind the scene, e.g., cubeb stream reinit due + // to default output device changed). When this happens, we need to notify + // mSPSCQueue to change its data consumer. + enum class Consumer { Same, Changed }; + AudioSegment GetAudioSegment(TrackTime aDuration, Consumer aConsumer); + + // CubebInputStream::Listener interface: These are used only for the + // underlying audio stream. No user should call these APIs. + // This will be fired on audio callback thread. + long DataCallback(const void* aBuffer, long aFrames) override; + // This can be fired on any thread. + void StateCallback(cubeb_state aState) override; + // This can be fired on any thread. + void DeviceChangedCallback() override; + + // Any threads: + // The unique id of this source. + const Id mId; + // The id of this audio device producing the data. + const CubebUtils::AudioDeviceID mDeviceId; + // The channel count of audio data produced. + const uint32_t mChannelCount; + // The sample rate of the audio data produced. + const TrackRate mRate; + // Indicate whether the audio stream is for voice or not. + const bool mIsVoice; + // The principal of the audio data produced. + const PrincipalHandle mPrincipalHandle; + + protected: + ~AudioInputSource() = default; + + private: + // Underlying audio thread only. + bool CheckThreadIdChanged(); + + // Any thread. + const bool mSandboxed; + + // Thread id of the underlying audio thread. Underlying audio thread only. + std::atomic mAudioThreadId; + + // Forward the underlying event from main thread. + const RefPtr mEventListener; + + // Shared thread pool containing only one thread for cubeb operations. + // The cubeb operations: Start() and Stop() will be called on + // MediaTrackGraph's graph thread, which can be the cubeb stream's callback + // thread. Running cubeb operations within cubeb stream callback thread can + // cause the deadlock on Linux, so we dispatch those operations to the task + // thread. + const RefPtr mTaskThread; + + // Correct the drift between the underlying audio stream and its reader. + AudioDriftCorrection mDriftCorrector; + + // An input-only cubeb stream operated within mTaskThread. + UniquePtr mStream; + + // A single-producer-single-consumer lock-free queue whose data is produced by + // the audio callback thread and consumed by AudioInputSource's data reader. + SPSCQueue mSPSCQueue{30}; +}; + +} // namespace mozilla + +#endif // DOM_MEDIA_AudioInputSource_H_ -- cgit v1.2.3