summaryrefslogtreecommitdiffstats
path: root/dom/media/MediaQueue.h
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
commit26a029d407be480d791972afb5975cf62c9360a6 (patch)
treef435a8308119effd964b339f76abb83a57c29483 /dom/media/MediaQueue.h
parentInitial commit. (diff)
downloadfirefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz
firefox-26a029d407be480d791972afb5975cf62c9360a6.zip
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'dom/media/MediaQueue.h')
-rw-r--r--dom/media/MediaQueue.h277
1 files changed, 277 insertions, 0 deletions
diff --git a/dom/media/MediaQueue.h b/dom/media/MediaQueue.h
new file mode 100644
index 0000000000..4609493339
--- /dev/null
+++ b/dom/media/MediaQueue.h
@@ -0,0 +1,277 @@
+/* -*- 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(MediaQueue_h_)
+# define MediaQueue_h_
+
+# include <type_traits>
+
+# include "mozilla/RecursiveMutex.h"
+# include "mozilla/TaskQueue.h"
+
+# include "nsDeque.h"
+# include "MediaEventSource.h"
+# include "TimeUnits.h"
+
+namespace mozilla {
+
+extern LazyLogModule gMediaDecoderLog;
+
+# define QLOG(msg, ...) \
+ MOZ_LOG(gMediaDecoderLog, LogLevel::Debug, \
+ ("MediaQueue=%p " msg, this, ##__VA_ARGS__))
+
+class AudioData;
+class VideoData;
+
+template <typename T>
+struct TimestampAdjustmentTrait {
+ static const bool mValue = false;
+};
+
+template <>
+struct TimestampAdjustmentTrait<AudioData> {
+ static const bool mValue = true;
+};
+
+template <>
+struct TimestampAdjustmentTrait<VideoData> {
+ static const bool mValue = true;
+};
+
+template <typename T>
+struct NonTimestampAdjustmentTrait {
+ static const bool mValue = !TimestampAdjustmentTrait<T>::mValue;
+};
+
+template <class T>
+class MediaQueue : private nsRefPtrDeque<T> {
+ public:
+ MediaQueue()
+ : nsRefPtrDeque<T>(),
+ mRecursiveMutex("mediaqueue"),
+ mEndOfStream(false) {}
+
+ ~MediaQueue() { Reset(); }
+
+ inline size_t GetSize() const {
+ RecursiveMutexAutoLock lock(mRecursiveMutex);
+ return nsRefPtrDeque<T>::GetSize();
+ }
+
+ template <typename U,
+ std::enable_if_t<TimestampAdjustmentTrait<U>::mValue, bool> = true>
+ inline void AdjustTimeStampIfNeeded(U* aItem) {
+ static_assert(std::is_same_v<U, AudioData> || std::is_same_v<U, VideoData>);
+ if (mOffset != media::TimeUnit::Zero()) {
+ const auto prev = aItem->mTime, prevEndTime = aItem->GetEndTime();
+ aItem->mTime += mOffset;
+ if (!aItem->mTime.IsValid()) {
+ NS_WARNING("Reverting timestamp adjustment due to sample overflow!");
+ aItem->mTime = prev;
+ } else {
+ QLOG("adjusted %s sample [%" PRId64 ",%" PRId64 "] -> [%" PRId64
+ ",%" PRId64 "]",
+ std::is_same_v<U, AudioData> ? "audio" : "video",
+ prev.ToMicroseconds(), prevEndTime.ToMicroseconds(),
+ aItem->mTime.ToMicroseconds(),
+ aItem->GetEndTime().ToMicroseconds());
+ }
+ }
+ }
+
+ template <typename U, std::enable_if_t<NonTimestampAdjustmentTrait<U>::mValue,
+ bool> = true>
+ inline void AdjustTimeStampIfNeeded(U* aItem) {}
+
+ enum class TimestampAdjustment {
+ Enable,
+ Disable,
+ };
+ inline void PushFront(
+ T* aItem, TimestampAdjustment aIsEnabled = TimestampAdjustment::Enable) {
+ RecursiveMutexAutoLock lock(mRecursiveMutex);
+ if (aIsEnabled == TimestampAdjustment::Enable) {
+ AdjustTimeStampIfNeeded(aItem);
+ }
+ nsRefPtrDeque<T>::PushFront(aItem);
+ }
+
+ inline void Push(T* aItem) {
+ MOZ_DIAGNOSTIC_ASSERT(aItem);
+ Push(do_AddRef(aItem));
+ }
+
+ inline void Push(already_AddRefed<T> aItem) {
+ RecursiveMutexAutoLock lock(mRecursiveMutex);
+ T* item = aItem.take();
+
+ MOZ_DIAGNOSTIC_ASSERT(item);
+ MOZ_DIAGNOSTIC_ASSERT(item->GetEndTime() >= item->mTime);
+ AdjustTimeStampIfNeeded(item);
+ nsRefPtrDeque<T>::Push(dont_AddRef(item));
+ mPushEvent.Notify(RefPtr<T>(item));
+
+ // Pushing new data after queue has ended means that the stream is active
+ // again, so we should not mark it as ended.
+ if (mEndOfStream) {
+ mEndOfStream = false;
+ }
+ }
+
+ inline already_AddRefed<T> PopFront() {
+ RecursiveMutexAutoLock lock(mRecursiveMutex);
+ RefPtr<T> rv = nsRefPtrDeque<T>::PopFront();
+ if (rv) {
+ MOZ_DIAGNOSTIC_ASSERT(rv->GetEndTime() >= rv->mTime);
+ mPopFrontEvent.Notify(RefPtr<T>(rv));
+ }
+ return rv.forget();
+ }
+
+ inline already_AddRefed<T> PopBack() {
+ RecursiveMutexAutoLock lock(mRecursiveMutex);
+ return nsRefPtrDeque<T>::Pop();
+ }
+
+ inline RefPtr<T> PeekFront() const {
+ RecursiveMutexAutoLock lock(mRecursiveMutex);
+ return nsRefPtrDeque<T>::PeekFront();
+ }
+
+ inline RefPtr<T> PeekBack() const {
+ RecursiveMutexAutoLock lock(mRecursiveMutex);
+ return nsRefPtrDeque<T>::Peek();
+ }
+
+ void Reset() {
+ RecursiveMutexAutoLock lock(mRecursiveMutex);
+ nsRefPtrDeque<T>::Erase();
+ SetOffset(media::TimeUnit::Zero());
+ mEndOfStream = false;
+ }
+
+ bool AtEndOfStream() const {
+ RecursiveMutexAutoLock lock(mRecursiveMutex);
+ return GetSize() == 0 && mEndOfStream;
+ }
+
+ // Returns true if the media queue has had its last item added to it.
+ // This happens when the media stream has been completely decoded. Note this
+ // does not mean that the corresponding stream has finished playback.
+ bool IsFinished() const {
+ RecursiveMutexAutoLock lock(mRecursiveMutex);
+ return mEndOfStream;
+ }
+
+ // Informs the media queue that it won't be receiving any more items.
+ void Finish() {
+ RecursiveMutexAutoLock lock(mRecursiveMutex);
+ if (!mEndOfStream) {
+ mEndOfStream = true;
+ mFinishEvent.Notify();
+ }
+ }
+
+ // Returns the approximate number of microseconds of items in the queue.
+ int64_t Duration() const {
+ RecursiveMutexAutoLock lock(mRecursiveMutex);
+ if (GetSize() == 0) {
+ return 0;
+ }
+ T* last = nsRefPtrDeque<T>::Peek();
+ T* first = nsRefPtrDeque<T>::PeekFront();
+ return (last->GetEndTime() - first->mTime).ToMicroseconds();
+ }
+
+ void LockedForEach(nsDequeFunctor<T>& aFunctor) const {
+ RecursiveMutexAutoLock lock(mRecursiveMutex);
+ nsRefPtrDeque<T>::ForEach(aFunctor);
+ }
+
+ // Fill aResult with the elements which end later than the given time aTime.
+ void GetElementsAfter(const media::TimeUnit& aTime,
+ nsTArray<RefPtr<T>>* aResult) {
+ GetElementsAfterStrict(aTime.ToMicroseconds(), aResult);
+ }
+
+ void GetFirstElements(uint32_t aMaxElements, nsTArray<RefPtr<T>>* aResult) {
+ RecursiveMutexAutoLock lock(mRecursiveMutex);
+ for (size_t i = 0; i < aMaxElements && i < GetSize(); ++i) {
+ *aResult->AppendElement() = nsRefPtrDeque<T>::ObjectAt(i);
+ }
+ }
+
+ uint32_t AudioFramesCount() {
+ static_assert(std::is_same_v<T, AudioData>,
+ "Only usable with MediaQueue<AudioData>");
+ RecursiveMutexAutoLock lock(mRecursiveMutex);
+ uint32_t frames = 0;
+ for (size_t i = 0; i < GetSize(); ++i) {
+ T* v = nsRefPtrDeque<T>::ObjectAt(i);
+ frames += v->Frames();
+ }
+ return frames;
+ }
+
+ bool SetOffset(const media::TimeUnit& aOffset) {
+ if (!aOffset.IsValid()) {
+ QLOG("Invalid offset!");
+ return false;
+ }
+ RecursiveMutexAutoLock lock(mRecursiveMutex);
+ mOffset = aOffset;
+ QLOG("Set media queue offset %" PRId64, mOffset.ToMicroseconds());
+ return true;
+ }
+
+ media::TimeUnit GetOffset() const {
+ RecursiveMutexAutoLock lock(mRecursiveMutex);
+ return mOffset;
+ }
+
+ MediaEventSource<RefPtr<T>>& PopFrontEvent() { return mPopFrontEvent; }
+
+ MediaEventSource<RefPtr<T>>& PushEvent() { return mPushEvent; }
+
+ MediaEventSource<void>& FinishEvent() { return mFinishEvent; }
+
+ private:
+ // Extracts elements from the queue into aResult, in order.
+ // Elements whose end time is before or equal to aTime are ignored.
+ void GetElementsAfterStrict(int64_t aTime, nsTArray<RefPtr<T>>* aResult) {
+ RecursiveMutexAutoLock lock(mRecursiveMutex);
+ if (GetSize() == 0) return;
+ size_t i;
+ for (i = GetSize() - 1; i > 0; --i) {
+ T* v = nsRefPtrDeque<T>::ObjectAt(i);
+ if (v->GetEndTime().ToMicroseconds() < aTime) break;
+ }
+ for (; i < GetSize(); ++i) {
+ RefPtr<T> elem = nsRefPtrDeque<T>::ObjectAt(i);
+ if (elem->GetEndTime().ToMicroseconds() > aTime) {
+ aResult->AppendElement(elem);
+ }
+ }
+ }
+
+ mutable RecursiveMutex mRecursiveMutex MOZ_UNANNOTATED;
+ MediaEventProducer<RefPtr<T>> mPopFrontEvent;
+ MediaEventProducer<RefPtr<T>> mPushEvent;
+ MediaEventProducer<void> mFinishEvent;
+ // True when we've decoded the last frame of data in the
+ // bitstream for which we're queueing frame data.
+ bool mEndOfStream;
+ // This offset will be added to any data pushed into the queue. We use it when
+ // the media queue starts receiving looped data, which timestamp needs to be
+ // modified.
+ media::TimeUnit mOffset;
+};
+
+} // namespace mozilla
+
+# undef QLOG
+
+#endif