Source code
Revision control
Copy as Markdown
Other Tools
/* -*- 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
#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;
class EncodedFrame;
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 <typename T>
struct DurationTypeTrait {
using type = media::TimeUnit;
};
template <>
struct DurationTypeTrait<EncodedFrame> {
using type = uint64_t;
};
template <class T>
class MediaQueue : private nsRefPtrDeque<T> {
public:
explicit MediaQueue(bool aEnablePreciseDuration = false)
: nsRefPtrDeque<T>(),
mRecursiveMutex("mediaqueue"),
mEndOfStream(false),
mEnablePreciseDuration(aEnablePreciseDuration) {}
~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);
AddDurationToPreciseDuration(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));
AddDurationToPreciseDuration(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);
SubtractDurationFromPreciseDuration(rv);
mPopFrontEvent.Notify(RefPtr<T>(rv));
}
return rv.forget();
}
inline already_AddRefed<T> PopBack() {
RecursiveMutexAutoLock lock(mRecursiveMutex);
RefPtr<T> rv = nsRefPtrDeque<T>::Pop();
if (rv) {
MOZ_DIAGNOSTIC_ASSERT(rv->GetEndTime() >= rv->mTime);
SubtractDurationFromPreciseDuration(rv);
}
return rv.forget();
}
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;
ResetPreciseDuration();
}
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();
}
// Return a precise duration if the feature is enabled. Otherwise, return -1.
int64_t PreciseDuration() const {
RecursiveMutexAutoLock lock(mRecursiveMutex);
return GetPreciseDuration();
}
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;
inline void AddDurationToPreciseDuration(T* aItem) {
if (!mEnablePreciseDuration) {
return;
}
if constexpr (std::is_same_v<typename DurationTypeTrait<T>::type,
media::TimeUnit> ||
std::is_same_v<typename DurationTypeTrait<T>::type,
uint64_t>) {
mPreciseDuration += aItem->mDuration;
}
}
inline void SubtractDurationFromPreciseDuration(T* aItem) {
if (!mEnablePreciseDuration) {
return;
}
if constexpr (std::is_same_v<typename DurationTypeTrait<T>::type,
media::TimeUnit> ||
std::is_same_v<typename DurationTypeTrait<T>::type,
uint64_t>) {
mPreciseDuration -= aItem->mDuration;
}
}
inline void ResetPreciseDuration() {
if (!mEnablePreciseDuration) {
return;
}
if constexpr (std::is_same_v<typename DurationTypeTrait<T>::type,
media::TimeUnit>) {
mPreciseDuration = media::TimeUnit::Zero();
} else if constexpr (std::is_same_v<typename DurationTypeTrait<T>::type,
uint64_t>) {
mPreciseDuration = 0;
}
}
inline int64_t GetPreciseDuration() const {
if (mEnablePreciseDuration) {
if constexpr (std::is_same_v<typename DurationTypeTrait<T>::type,
media::TimeUnit>) {
return mPreciseDuration.ToMicroseconds();
} else if constexpr (std::is_same_v<typename DurationTypeTrait<T>::type,
uint64_t>) {
return mPreciseDuration;
}
}
return -1;
}
typename DurationTypeTrait<T>::type mPreciseDuration;
const bool mEnablePreciseDuration = false;
};
} // namespace mozilla
# undef QLOG
#endif