summaryrefslogtreecommitdiffstats
path: root/dom/media/AudioInputSource.h
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
commit36d22d82aa202bb199967e9512281e9a53db42c9 (patch)
tree105e8c98ddea1c1e4784a60a5a6410fa416be2de /dom/media/AudioInputSource.h
parentInitial commit. (diff)
downloadfirefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz
firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip
Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'dom/media/AudioInputSource.h')
-rw-r--r--dom/media/AudioInputSource.h127
1 files changed, 127 insertions, 0 deletions
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<EventListener>&& 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<ProfilerThreadId> mAudioThreadId;
+
+ // Forward the underlying event from main thread.
+ const RefPtr<EventListener> 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<SharedThreadPool> mTaskThread;
+
+ // Correct the drift between the underlying audio stream and its reader.
+ AudioDriftCorrection mDriftCorrector;
+
+ // An input-only cubeb stream operated within mTaskThread.
+ UniquePtr<CubebInputStream> 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<AudioChunk> mSPSCQueue{30};
+};
+
+} // namespace mozilla
+
+#endif // DOM_MEDIA_AudioInputSource_H_