corysanin/tubestation
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
current
tubestation/dom/media/mediasource/TrackBuffersManager.cpp

3408 lines
135 KiB
C++
Raw Permalink Blame History

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=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 http://mozilla.org/MPL/2.0/. */
#include "TrackBuffersManager.h"
#include <limits>
#include "ContainerParser.h"
#include "MP4Demuxer.h"
#include "MediaInfo.h"
#include "MediaSourceDemuxer.h"
#include "MediaSourceUtils.h"
#include "SourceBuffer.h"
#include "SourceBufferResource.h"
#include "SourceBufferTask.h"
#include "WebMDemuxer.h"
#include "mozilla/ErrorResult.h"
#include "mozilla/Preferences.h"
#include "mozilla/ProfilerLabels.h"
#include "mozilla/ProfilerMarkers.h"
#include "mozilla/StaticPrefs_media.h"
#include "nsMimeTypes.h"
extern mozilla::LogModule* GetMediaSourceLog();
#define MSE_DEBUG(arg, ...) \
DDMOZ_LOG(GetMediaSourceLog(), mozilla::LogLevel::Debug, "::%s: " arg, \
__func__, ##__VA_ARGS__)
#define MSE_DEBUGV(arg, ...) \
DDMOZ_LOG(GetMediaSourceLog(), mozilla::LogLevel::Verbose, "::%s: " arg, \
__func__, ##__VA_ARGS__)
mozilla::LogModule* GetMediaSourceSamplesLog() {
static mozilla::LazyLogModule sLogModule("MediaSourceSamples");
return sLogModule;
}
#define SAMPLE_DEBUG(arg, ...) \
DDMOZ_LOG(GetMediaSourceSamplesLog(), mozilla::LogLevel::Debug, \
"::%s: " arg, __func__, ##__VA_ARGS__)
#define SAMPLE_DEBUGV(arg, ...) \
DDMOZ_LOG(GetMediaSourceSamplesLog(), mozilla::LogLevel::Verbose, \
"::%s: " arg, __func__, ##__VA_ARGS__)
namespace mozilla {
using dom::SourceBufferAppendMode;
using media::Interval;
using media::TimeInterval;
using media::TimeIntervals;
using media::TimeUnit;
using AppendBufferResult = SourceBufferTask::AppendBufferResult;
using AppendState = SourceBufferAttributes::AppendState;
static Atomic<uint32_t> sStreamSourceID(0u);
class DispatchKeyNeededEvent : public Runnable {
public:
DispatchKeyNeededEvent(MediaSourceDecoder* aDecoder,
const nsTArray<uint8_t>& aInitData,
const nsString& aInitDataType)
: Runnable("DispatchKeyNeededEvent"),
mDecoder(aDecoder),
mInitData(aInitData.Clone()),
mInitDataType(aInitDataType) {}
NS_IMETHOD Run() override {
// Note: Null check the owner, as the decoder could have been shutdown
// since this event was dispatched.
MediaDecoderOwner* owner = mDecoder->GetOwner();
if (owner) {
owner->DispatchEncrypted(mInitData, mInitDataType);
}
mDecoder = nullptr;
return NS_OK;
}
private:
RefPtr<MediaSourceDecoder> mDecoder;
nsTArray<uint8_t> mInitData;
nsString mInitDataType;
};
TrackBuffersManager::TrackBuffersManager(MediaSourceDecoder* aParentDecoder,
const MediaContainerType& aType)
: mBufferFull(false),
mFirstInitializationSegmentReceived(false),
mChangeTypeReceived(false),
mNewMediaSegmentStarted(false),
mActiveTrack(false),
mType(aType),
mParser(ContainerParser::CreateForMIMEType(aType)),
mProcessedInput(0),
mParentDecoder(new nsMainThreadPtrHolder<MediaSourceDecoder>(
"TrackBuffersManager::mParentDecoder", aParentDecoder,
false /* strict */)),
mAbstractMainThread(aParentDecoder->AbstractMainThread()),
mVideoEvictionThreshold(Preferences::GetUint(
"media.mediasource.eviction_threshold.video", 150 * 1024 * 1024)),
mAudioEvictionThreshold(Preferences::GetUint(
"media.mediasource.eviction_threshold.audio", 20 * 1024 * 1024)),
mEvictionBufferWatermarkRatio(0.9),
mEvictionState(EvictionState::NO_EVICTION_NEEDED),
mMutex("TrackBuffersManager"),
mTaskQueue(aParentDecoder->GetDemuxer()->GetTaskQueue()),
mTaskQueueCapability(Some(EventTargetCapability{mTaskQueue.get()})) {
MOZ_ASSERT(NS_IsMainThread(), "Must be instanciated on the main thread");
DDLINKCHILD("parser", mParser.get());
}
TrackBuffersManager::~TrackBuffersManager() { ShutdownDemuxers(); }
RefPtr<TrackBuffersManager::AppendPromise> TrackBuffersManager::AppendData(
already_AddRefed<MediaByteBuffer> aData,
const SourceBufferAttributes& aAttributes) {
MOZ_ASSERT(NS_IsMainThread());
RefPtr<MediaByteBuffer> data(aData);
MSE_DEBUG("Appending %zu bytes", data->Length());
Reopen();
return InvokeAsync(static_cast<AbstractThread*>(GetTaskQueueSafe().get()),
this, __func__, &TrackBuffersManager::DoAppendData,
data.forget(), aAttributes);
}
RefPtr<TrackBuffersManager::AppendPromise> TrackBuffersManager::DoAppendData(
already_AddRefed<MediaByteBuffer> aData,
const SourceBufferAttributes& aAttributes) {
RefPtr<AppendBufferTask> task =
new AppendBufferTask(std::move(aData), aAttributes);
RefPtr<AppendPromise> p = task->mPromise.Ensure(__func__);
QueueTask(task);
return p;
}
void TrackBuffersManager::QueueTask(SourceBufferTask* aTask) {
// The source buffer is a wrapped native, it would be unlinked twice and so
// the TrackBuffersManager::Detach() would also be called twice. Since the
// detach task has been done before, we could ignore this task.
RefPtr<TaskQueue> taskQueue = GetTaskQueueSafe();
if (!taskQueue) {
MOZ_ASSERT(aTask->GetType() == SourceBufferTask::Type::Detach,
"only detach task could happen here!");
MSE_DEBUG("Could not queue the task '%s' without task queue",
aTask->GetTypeName());
return;
}
if (!taskQueue->IsCurrentThreadIn()) {
nsresult rv =
taskQueue->Dispatch(NewRunnableMethod<RefPtr<SourceBufferTask>>(
"TrackBuffersManager::QueueTask", this,
&TrackBuffersManager::QueueTask, aTask));
MOZ_DIAGNOSTIC_ASSERT(NS_SUCCEEDED(rv));
Unused << rv;
return;
}
mQueue.Push(aTask);
ProcessTasks();
}
void TrackBuffersManager::ProcessTasks() {
// ProcessTask is always called OnTaskQueue, however it is possible that it is
// called once again after a first Detach task has run, in which case
// mTaskQueue would be null.
// This can happen under two conditions:
// 1- Two Detach tasks were queued in a row due to a double cycle collection.
// 2- An call to ProcessTasks() had queued another run of ProcessTasks while
// a Detach task is pending.
// We handle these two cases by aborting early.
// A second Detach task was queued, prior the first one running, ignore it.
if (!mTaskQueue) {
RefPtr<SourceBufferTask> task = mQueue.Pop();
if (!task) {
return;
}
MOZ_RELEASE_ASSERT(task->GetType() == SourceBufferTask::Type::Detach,
"only detach task could happen here!");
MSE_DEBUG("Could not process the task '%s' after detached",
task->GetTypeName());
return;
}
mTaskQueueCapability->AssertOnCurrentThread();
typedef SourceBufferTask::Type Type;
if (mCurrentTask) {
// Already have a task pending. ProcessTask will be scheduled once the
// current task complete.
return;
}
RefPtr<SourceBufferTask> task = mQueue.Pop();
if (!task) {
// nothing to do.
return;
}
MSE_DEBUG("Process task '%s'", task->GetTypeName());
switch (task->GetType()) {
case Type::AppendBuffer:
mCurrentTask = task;
if (!mInputBuffer || mInputBuffer->IsEmpty()) {
// Note: we reset mInputBuffer here to ensure it doesn't grow unbounded.
mInputBuffer.reset();
mInputBuffer = Some(MediaSpan(task->As<AppendBufferTask>()->mBuffer));
} else {
// mInputBuffer wasn't empty, so we can't just reset it, but we move
// the data into a new buffer to clear out data no longer in the span.
MSE_DEBUG(
"mInputBuffer not empty during append -- data will be copied to "
"new buffer. mInputBuffer->Length()=%zu "
"mInputBuffer->Buffer()->Length()=%zu",
mInputBuffer->Length(), mInputBuffer->Buffer()->Length());
const RefPtr<MediaByteBuffer> newBuffer{new MediaByteBuffer()};
// Set capacity outside of ctor to let us explicitly handle OOM.
const size_t newCapacity =
mInputBuffer->Length() +
task->As<AppendBufferTask>()->mBuffer->Length();
if (!newBuffer->SetCapacity(newCapacity, fallible)) {
RejectAppend(NS_ERROR_OUT_OF_MEMORY, __func__);
return;
}
// Use infallible appends as we've already set capacity above.
newBuffer->AppendElements(mInputBuffer->Elements(),
mInputBuffer->Length());
newBuffer->AppendElements(*task->As<AppendBufferTask>()->mBuffer);
mInputBuffer = Some(MediaSpan(newBuffer));
}
mSourceBufferAttributes = MakeUnique<SourceBufferAttributes>(
task->As<AppendBufferTask>()->mAttributes);
mAppendWindow =
Interval<double>(mSourceBufferAttributes->GetAppendWindowStart(),
mSourceBufferAttributes->GetAppendWindowEnd());
ScheduleSegmentParserLoop();
break;
case Type::RangeRemoval: {
bool rv = CodedFrameRemoval(task->As<RangeRemovalTask>()->mRange);
task->As<RangeRemovalTask>()->mPromise.Resolve(rv, __func__);
break;
}
case Type::EvictData:
DoEvictData(task->As<EvictDataTask>()->mPlaybackTime,
task->As<EvictDataTask>()->mSizeToEvict);
break;
case Type::Abort:
// not handled yet, and probably never.
break;
case Type::Reset:
CompleteResetParserState();
break;
case Type::Detach:
mCurrentInputBuffer = nullptr;
MOZ_DIAGNOSTIC_ASSERT(mQueue.Length() == 0,
"Detach task must be the last");
mVideoTracks.Reset();
mAudioTracks.Reset();
ShutdownDemuxers();
ResetTaskQueue();
return;
case Type::ChangeType:
MOZ_RELEASE_ASSERT(!mCurrentTask);
MSE_DEBUG("Processing type change from %s -> %s",
mType.OriginalString().get(),
task->As<ChangeTypeTask>()->mType.OriginalString().get());
mType = task->As<ChangeTypeTask>()->mType;
mChangeTypeReceived = true;
mInitData = nullptr;
// A new input buffer will be created once we receive a new init segment.
// The first segment received after a changeType call must be an init
// segment.
mCurrentInputBuffer = nullptr;
CompleteResetParserState();
break;
default:
NS_WARNING("Invalid Task");
}
TaskQueueFromTaskQueue()->Dispatch(
NewRunnableMethod("TrackBuffersManager::ProcessTasks", this,
&TrackBuffersManager::ProcessTasks));
}
// The MSE spec requires that we abort the current SegmentParserLoop
// which is then followed by a call to ResetParserState.
// However due to our asynchronous design this causes inherent difficulties.
// As the spec behaviour is non deterministic anyway, we instead process all
// pending frames found in the input buffer.
void TrackBuffersManager::AbortAppendData() {
MOZ_ASSERT(NS_IsMainThread());
MSE_DEBUG("");
QueueTask(new AbortTask());
}
void TrackBuffersManager::ResetParserState(
SourceBufferAttributes& aAttributes) {
MOZ_ASSERT(NS_IsMainThread());
MSE_DEBUG("");
// Spec states:
// 1. If the append state equals PARSING_MEDIA_SEGMENT and the input buffer
// contains some complete coded frames, then run the coded frame processing
// algorithm until all of these complete coded frames have been processed.
// However, we will wait until all coded frames have been processed regardless
// of the value of append state.
QueueTask(new ResetTask());
// ResetParserState has some synchronous steps that much be performed now.
// The remaining steps will be performed once the ResetTask gets executed.
// 6. If the mode attribute equals "sequence", then set the group start
// timestamp to the group end timestamp
if (aAttributes.GetAppendMode() == SourceBufferAppendMode::Sequence) {
aAttributes.SetGroupStartTimestamp(aAttributes.GetGroupEndTimestamp());
}
// 8. Set append state to WAITING_FOR_SEGMENT.
aAttributes.SetAppendState(AppendState::WAITING_FOR_SEGMENT);
}
RefPtr<TrackBuffersManager::RangeRemovalPromise>
TrackBuffersManager::RangeRemoval(TimeUnit aStart, TimeUnit aEnd) {
MOZ_ASSERT(NS_IsMainThread());
MSE_DEBUG("From %.2f to %.2f", aStart.ToSeconds(), aEnd.ToSeconds());
Reopen();
return InvokeAsync(static_cast<AbstractThread*>(GetTaskQueueSafe().get()),
this, __func__,
&TrackBuffersManager::CodedFrameRemovalWithPromise,
TimeInterval(aStart, aEnd));
}
TrackBuffersManager::EvictDataResult TrackBuffersManager::EvictData(
const TimeUnit& aPlaybackTime, int64_t aSize, TrackType aType) {
MOZ_ASSERT(NS_IsMainThread());
if (aSize > EvictionThreshold(aType)) {
// We're adding more data than we can hold.
return EvictDataResult::BUFFER_FULL;
}
const int64_t toEvict = GetSize() + aSize - EvictionThreshold(aType);
const uint32_t canEvict =
Evictable(HasVideo() ? TrackInfo::kVideoTrack : TrackInfo::kAudioTrack);
MSE_DEBUG("currentTime=%" PRId64 " buffered=%" PRId64
"kB, eviction threshold=%" PRId64
"kB, "
"evict=%" PRId64 "kB canevict=%" PRIu32 "kB",
aPlaybackTime.ToMicroseconds(), GetSize() / 1024,
EvictionThreshold(aType) / 1024, toEvict / 1024, canEvict / 1024);
if (toEvict <= 0) {
mEvictionState = EvictionState::NO_EVICTION_NEEDED;
return EvictDataResult::NO_DATA_EVICTED;
}
EvictDataResult result;
if (mBufferFull && mEvictionState == EvictionState::EVICTION_COMPLETED &&
canEvict < uint32_t(toEvict)) {
// Our buffer is currently full. We will make another eviction attempt.
// However, the current appendBuffer will fail as we can't know ahead of
// time if the eviction will later succeed.
result = EvictDataResult::BUFFER_FULL;
} else {
mEvictionState = EvictionState::EVICTION_NEEDED;
result = EvictDataResult::NO_DATA_EVICTED;
}
MSE_DEBUG("Reached our size limit, schedule eviction of %" PRId64
" bytes (%s)",
toEvict,
result == EvictDataResult::BUFFER_FULL ? "buffer full"
: "no data evicted");
QueueTask(new EvictDataTask(aPlaybackTime, toEvict));
return result;
}
void TrackBuffersManager::EvictDataWithoutSize(TrackType aType,
const media::TimeUnit& aTarget) {
MOZ_ASSERT(OnTaskQueue());
auto& track = GetTracksData(aType);
const auto bufferedSz = track.mSizeBuffer;
const auto evictionSize = EvictionThreshold(aType);
const double watermarkRatio = bufferedSz / (double)(evictionSize); // can > 1
MSE_DEBUG(
"EvictDataWithoutSize, track=%s, buffered=%u"
"kB, eviction threshold=%" PRId64 "kB, wRatio=%f, target=%" PRId64
", bufferedRange=%s",
TrackTypeToStr(aType), bufferedSz / 1024, evictionSize / 1024,
watermarkRatio, aTarget.ToMicroseconds(),
DumpTimeRanges(track.mBufferedRanges).get());
// This type of eviction MUST only be used when the target is not in the
// current buffered range, which means all data are evictable. Otherwise, we
// have to calculate the amount of evictable data.
MOZ_ASSERT(track.mBufferedRanges.Find(aTarget) == TimeIntervals::NoIndex);
// This type of eviction is introduced to mitigate the pressure of the buffer
// nearly being full. If the buffer is still far from being full, we do
// nothing.
if (watermarkRatio < mEvictionBufferWatermarkRatio) {
return;
}
MSE_DEBUG("Queued EvictDataTask to evict size automatically");
QueueTask(new EvictDataTask(aTarget));
}
void TrackBuffersManager::ChangeType(const MediaContainerType& aType) {
MOZ_ASSERT(NS_IsMainThread());
QueueTask(new ChangeTypeTask(aType));
}
TimeIntervals TrackBuffersManager::Buffered() const {
MSE_DEBUG("");
// http://w3c.github.io/media-source/index.html#widl-SourceBuffer-buffered
MutexAutoLock mut(mMutex);
nsTArray<const TimeIntervals*> tracks;
if (HasVideo()) {
tracks.AppendElement(&mVideoBufferedRanges);
}
if (HasAudio()) {
tracks.AppendElement(&mAudioBufferedRanges);
}
// 2. Let highest end time be the largest track buffer ranges end time across
// all the track buffers managed by this SourceBuffer object.
TimeUnit highestEndTime = HighestEndTime(tracks);
// 3. Let intersection ranges equal a TimeRange object containing a single
// range from 0 to highest end time.
TimeIntervals intersection{
TimeInterval(TimeUnit::FromSeconds(0), highestEndTime)};
// 4. For each track buffer managed by this SourceBuffer, run the following
// steps:
// 1. Let track ranges equal the track buffer ranges for the current track
// buffer.
for (const TimeIntervals* trackRanges : tracks) {
// 2. If readyState is "ended", then set the end time on the last range in
// track ranges to highest end time.
// 3. Let new intersection ranges equal the intersection between the
// intersection ranges and the track ranges.
if (mEnded) {
TimeIntervals tR = *trackRanges;
tR.Add(TimeInterval(tR.GetEnd(), highestEndTime));
intersection.Intersection(tR);
} else {
intersection.Intersection(*trackRanges);
}
}
return intersection;
}
int64_t TrackBuffersManager::GetSize() const { return mSizeSourceBuffer; }
void TrackBuffersManager::SetEnded(
const dom::Optional<dom::MediaSourceEndOfStreamError>& aError) {
MOZ_ASSERT(NS_IsMainThread());
MutexAutoLock lock(mMutex);
if (!aError.WasPassed()) {
// error is not set.
// Notify the media element that it now has all of the media data.
// https://w3c.github.io/media-source/#dfn-end-of-stream
mHaveAllData = true;
}
mEnded = true;
}
void TrackBuffersManager::Reopen() {
MOZ_ASSERT(NS_IsMainThread());
MutexAutoLock lock(mMutex);
mHaveAllData = false;
mEnded = false;
}
void TrackBuffersManager::Detach() {
MOZ_ASSERT(NS_IsMainThread());
MSE_DEBUG("");
QueueTask(new DetachTask());
}
void TrackBuffersManager::CompleteResetParserState() {
mTaskQueueCapability->AssertOnCurrentThread();
AUTO_PROFILER_LABEL("TrackBuffersManager::CompleteResetParserState",
MEDIA_PLAYBACK);
MSE_DEBUG("");
// We shouldn't change mInputDemuxer while a demuxer init/reset request is
// being processed. See bug 1239983.
MOZ_DIAGNOSTIC_ASSERT(!mDemuxerInitRequest.Exists(),
"Previous AppendBuffer didn't complete");
for (auto& track : GetTracksList()) {
// 2. Unset the last decode timestamp on all track buffers.
// 3. Unset the last frame duration on all track buffers.
// 4. Unset the highest end timestamp on all track buffers.
// 5. Set the need random access point flag on all track buffers to true.
track->ResetAppendState();
// if we have been aborted, we may have pending frames that we are going
// to discard now.
track->mQueuedSamples.Clear();
}
// 7. Remove all bytes from the input buffer.
mPendingInputBuffer.reset();
mInputBuffer.reset();
if (mCurrentInputBuffer) {
mCurrentInputBuffer->EvictAll();
// The demuxer will be recreated during the next run of SegmentParserLoop.
// As such we don't need to notify it that data has been removed.
mCurrentInputBuffer = new SourceBufferResource();
}
// We could be left with a demuxer in an unusable state. It needs to be
// recreated. Unless we have a pending changeType operation, we store in the
// InputBuffer an init segment which will be parsed during the next Segment
// Parser Loop and a new demuxer will be created and initialized.
// If we are in the middle of a changeType operation, then we do not have an
// init segment yet. The next appendBuffer operation will need to provide such
// init segment.
if (mFirstInitializationSegmentReceived && !mChangeTypeReceived) {
MOZ_ASSERT(mInitData && mInitData->Length(),
"we must have an init segment");
// The aim here is really to destroy our current demuxer.
CreateDemuxerforMIMEType();
// Recreate our input buffer. We can't directly assign the initData buffer
// to mInputBuffer as it will get modified in the Segment Parser Loop.
mInputBuffer = Some(MediaSpan::WithCopyOf(mInitData));
RecreateParser(true);
} else {
RecreateParser(false);
}
}
int64_t TrackBuffersManager::EvictionThreshold(
TrackInfo::TrackType aType) const {
MOZ_ASSERT(aType != TrackInfo::kTextTrack);
if (aType == TrackInfo::kVideoTrack ||
(aType == TrackInfo::kUndefinedTrack && HasVideo())) {
return mVideoEvictionThreshold;
}
return mAudioEvictionThreshold;
}
void TrackBuffersManager::DoEvictData(const TimeUnit& aPlaybackTime,
Maybe<int64_t> aSizeToEvict) {
mTaskQueueCapability->AssertOnCurrentThread();
AUTO_PROFILER_LABEL("TrackBuffersManager::DoEvictData", MEDIA_PLAYBACK);
MSE_DEBUG("DoEvictData, time=%" PRId64, aPlaybackTime.ToMicroseconds());
mEvictionState = EvictionState::EVICTION_COMPLETED;
// Video is what takes the most space, only evict there if we have video.
auto& track = HasVideo() ? mVideoTracks : mAudioTracks;
const auto& buffer = track.GetTrackBuffer();
if (buffer.IsEmpty()) {
// Buffer has been emptied while the eviction was queued, nothing to do.
return;
}
if (track.mBufferedRanges.IsEmpty()) {
MSE_DEBUG(
"DoEvictData running with no buffered ranges. 0 duration data likely "
"present in our buffer(s). Evicting all data!");
// We have no buffered ranges, but may still have data. This happens if the
// buffer is full of 0 duration data. Normal removal procedures don't clear
// 0 duration data, so blow away all our data.
RemoveAllCodedFrames();
return;
}
// The targeted playback time isn't in the buffered range yet, we're waiting
// for the data so all data in current buffered range are evictable.
if (!aSizeToEvict) {
// If the targeted time has been appended to our buffer range, then we need
// to recalculate which part of data is evictable. We will only perform
// following eviction when all data in the buffer range are evictable.
if (track.mBufferedRanges.Find(aPlaybackTime) != TimeIntervals::NoIndex) {
return;
}
// Evict data until the size falls below the threshold we set.
const int64_t sizeToEvict =
GetSize() - static_cast<int64_t>(EvictionThreshold() *
mEvictionBufferWatermarkRatio);
// Another eviction or frame removal has been executed before this task.
if (sizeToEvict <= 0) {
return;
}
int64_t toEvict = sizeToEvict;
// We need to evict data from a place which is the furthest from the
// playback time, otherwise we might incorrectly evict the data which should
// have stayed in the buffer in order to decode the frame at the targeted
// playback time. Eg. targeted time is X, and we might need a key frame from
// X-5. Therefore, we should evict data from a place which is far from X
// (maybe X±100)
const TimeUnit start = track.mBufferedRanges.GetStart();
const TimeUnit end = track.mBufferedRanges.GetEnd();
MSE_DEBUG("PlaybackTime=%" PRId64 ", extents=[%" PRId64 ", %" PRId64 "]",
aPlaybackTime.ToMicroseconds(), start.ToMicroseconds(),
end.ToMicroseconds());
if (end - aPlaybackTime > aPlaybackTime - start) {
size_t evictedFramesStartIndex = buffer.Length();
while (evictedFramesStartIndex > 0 && toEvict > 0) {
--evictedFramesStartIndex;
toEvict -= AssertedCast<int64_t>(
buffer[evictedFramesStartIndex]->ComputedSizeOfIncludingThis());
}
MSE_DEBUG("Auto evicting %" PRId64 " bytes [%" PRId64 ", inf] from tail",
sizeToEvict - toEvict,
buffer[evictedFramesStartIndex]->mTime.ToMicroseconds());
CodedFrameRemoval(TimeInterval(buffer[evictedFramesStartIndex]->mTime,
TimeUnit::FromInfinity()));
} else {
uint32_t lastKeyFrameIndex = 0;
int64_t partialEvict = 0;
for (uint32_t i = 0; i < buffer.Length(); i++) {
const auto& frame = buffer[i];
if (frame->mKeyframe) {
lastKeyFrameIndex = i;
toEvict -= partialEvict;
if (toEvict <= 0) {
break;
}
partialEvict = 0;
}
partialEvict +=
AssertedCast<int64_t>(frame->ComputedSizeOfIncludingThis());
}
TimeUnit start = track.mBufferedRanges[0].mStart;
TimeUnit end =
buffer[lastKeyFrameIndex]->mTime - TimeUnit::FromMicroseconds(1);
MSE_DEBUG("Auto evicting %" PRId64 " bytes [%" PRId64 ", %" PRId64
"] from head",
sizeToEvict - toEvict, start.ToMicroseconds(),
end.ToMicroseconds());
if (end > start) {
CodedFrameRemoval(TimeInterval(start, end));
}
}
return;
}
// Remove any data we've already played, or before the next sample to be
// demuxed whichever is lowest.
TimeUnit lowerLimit = std::min(track.mNextSampleTime, aPlaybackTime);
uint32_t lastKeyFrameIndex = 0;
int64_t sizeToEvict = *aSizeToEvict;
int64_t toEvict = sizeToEvict;
int64_t partialEvict = 0;
for (uint32_t i = 0; i < buffer.Length(); i++) {
const auto& frame = buffer[i];
if (frame->mKeyframe) {
lastKeyFrameIndex = i;
toEvict -= partialEvict;
if (toEvict <= 0) {
break;
}
partialEvict = 0;
}
if (frame->GetEndTime() >= lowerLimit) {
break;
}
partialEvict += AssertedCast<int64_t>(frame->ComputedSizeOfIncludingThis());
}
const int64_t finalSize = mSizeSourceBuffer - sizeToEvict;
if (lastKeyFrameIndex > 0) {
MSE_DEBUG("Step1. Evicting %" PRId64 " bytes prior currentTime",
sizeToEvict - toEvict);
TimeUnit start = track.mBufferedRanges[0].mStart;
TimeUnit end =
buffer[lastKeyFrameIndex]->mTime - TimeUnit::FromMicroseconds(1);
if (end > start) {
CodedFrameRemoval(TimeInterval(start, end));
}
}
if (mSizeSourceBuffer <= finalSize) {
MSE_DEBUG("Total buffer size is already smaller than final size");
return;
}
toEvict = mSizeSourceBuffer - finalSize;
// See if we can evict data into the future.
// We do not evict data from the currently used buffered interval.
TimeUnit currentPosition = std::max(aPlaybackTime, track.mNextSampleTime);
TimeIntervals futureBuffered(
TimeInterval(currentPosition, TimeUnit::FromInfinity()));
futureBuffered.Intersection(track.mBufferedRanges);
futureBuffered.SetFuzz(MediaSourceDemuxer::EOS_FUZZ / 2);
if (futureBuffered.Length() <= 1) {
// We have one continuous segment ahead of us:
MSE_DEBUG("Nothing in future can be evicted");
return;
}
// Don't evict before the end of the current segment
TimeUnit upperLimit = futureBuffered[0].mEnd;
uint32_t evictedFramesStartIndex = buffer.Length();
for (uint32_t i = buffer.Length(); i-- > 0;) {
const auto& frame = buffer[i];
if (frame->mTime <= upperLimit || toEvict <= 0) {
// We've reached a frame that shouldn't be evicted -> Evict after it ->
// i+1. Or the previous loop reached the eviction threshold -> Evict from
// it -> i+1.
evictedFramesStartIndex = i + 1;
break;
}
toEvict -= AssertedCast<int64_t>(frame->ComputedSizeOfIncludingThis());
}
if (evictedFramesStartIndex < buffer.Length()) {
MSE_DEBUG("Step2. Evicting %" PRId64 " bytes from trailing data",
mSizeSourceBuffer - finalSize - toEvict);
CodedFrameRemoval(TimeInterval(buffer[evictedFramesStartIndex]->mTime,
TimeUnit::FromInfinity()));
}
}
RefPtr<TrackBuffersManager::RangeRemovalPromise>
TrackBuffersManager::CodedFrameRemovalWithPromise(
const TimeInterval& aInterval) {
mTaskQueueCapability->AssertOnCurrentThread();
RefPtr<RangeRemovalTask> task = new RangeRemovalTask(aInterval);
RefPtr<RangeRemovalPromise> p = task->mPromise.Ensure(__func__);
QueueTask(task);
return p;
}
bool TrackBuffersManager::CodedFrameRemoval(const TimeInterval& aInterval) {
MOZ_ASSERT(OnTaskQueue());
AUTO_PROFILER_LABEL("TrackBuffersManager::CodedFrameRemoval", MEDIA_PLAYBACK);
MSE_DEBUG("From %.2fs to %.2f", aInterval.mStart.ToSeconds(),
aInterval.mEnd.ToSeconds());
#if DEBUG
if (HasVideo()) {
MSE_DEBUG("before video ranges=%s",
DumpTimeRangesRaw(mVideoTracks.mBufferedRanges).get());
}
if (HasAudio()) {
MSE_DEBUG("before audio ranges=%s",
DumpTimeRangesRaw(mAudioTracks.mBufferedRanges).get());
}
#endif
// 1. Let start be the starting presentation timestamp for the removal range.
TimeUnit start = aInterval.mStart;
// 2. Let end be the end presentation timestamp for the removal range.
TimeUnit end = aInterval.mEnd;
bool dataRemoved = false;
// 3. For each track buffer in this source buffer, run the following steps:
for (auto* track : GetTracksList()) {
MSE_DEBUGV("Processing %s track", track->mInfo->mMimeType.get());
// 1. Let remove end timestamp be the current value of duration
// See bug: https://www.w3.org/Bugs/Public/show_bug.cgi?id=28727
// At worse we will remove all frames until the end, unless a key frame is
// found between the current interval's end and the trackbuffer's end.
TimeUnit removeEndTimestamp = track->mBufferedRanges.GetEnd();
if (start > removeEndTimestamp) {
// Nothing to remove.
continue;
}
// 2. If this track buffer has a random access point timestamp that is
// greater than or equal to end, then update remove end timestamp to that
// random access point timestamp.
if (end < track->mBufferedRanges.GetEnd()) {
for (auto& frame : track->GetTrackBuffer()) {
if (frame->mKeyframe && frame->mTime >= end) {
removeEndTimestamp = frame->mTime;
break;
}
}
}
// 3. Remove all media data, from this track buffer, that contain starting
// timestamps greater than or equal to start and less than the remove end
// timestamp.
// 4. Remove decoding dependencies of the coded frames removed in the
// previous step: Remove all coded frames between the coded frames removed
// in the previous step and the next random access point after those removed
// frames.
TimeIntervals removedInterval{TimeInterval(start, removeEndTimestamp)};
RemoveFrames(removedInterval, *track, 0, RemovalMode::kRemoveFrame);
// 5. If this object is in activeSourceBuffers, the current playback
// position is greater than or equal to start and less than the remove end
// timestamp, and HTMLMediaElement.readyState is greater than HAVE_METADATA,
// then set the HTMLMediaElement.readyState attribute to HAVE_METADATA and
// stall playback. This will be done by the MDSM during playback.
// TODO properly, so it works even if paused.
}
UpdateBufferedRanges();
// Update our reported total size.
mSizeSourceBuffer = mVideoTracks.mSizeBuffer + mAudioTracks.mSizeBuffer;
// 4. If buffer full flag equals true and this object is ready to accept more
// bytes, then set the buffer full flag to false.
if (mBufferFull && mSizeSourceBuffer < EvictionThreshold()) {
mBufferFull = false;
}
return dataRemoved;
}
void TrackBuffersManager::RemoveAllCodedFrames() {
// This is similar to RemoveCodedFrames, but will attempt to remove ALL
// the frames. This is not to spec, as explained below at step 3.1. Steps
// below coincide with Remove Coded Frames algorithm from the spec.
MSE_DEBUG("RemoveAllCodedFrames called.");
MOZ_ASSERT(OnTaskQueue());
AUTO_PROFILER_LABEL("TrackBuffersManager::RemoveAllCodedFrames",
MEDIA_PLAYBACK);
// 1. Let start be the starting presentation timestamp for the removal range.
TimeUnit start{};
// 2. Let end be the end presentation timestamp for the removal range.
TimeUnit end = TimeUnit::FromMicroseconds(1);
// Find an end time such that our range will include every frame in every
// track. We do this by setting the end of our interval to the largest end
// time seen + 1 microsecond.
for (TrackData* track : GetTracksList()) {
for (auto& frame : track->GetTrackBuffer()) {
MOZ_ASSERT(frame->mTime >= start,
"Shouldn't have frame at negative time!");
TimeUnit frameEnd = frame->mTime + frame->mDuration;
if (frameEnd > end) {
end = frameEnd + TimeUnit::FromMicroseconds(1);
}
}
}
// 3. For each track buffer in this source buffer, run the following steps:
TimeIntervals removedInterval{TimeInterval(start, end)};
for (TrackData* track : GetTracksList()) {
// 1. Let remove end timestamp be the current value of duration
// ^ It's off spec, but we ignore this in order to clear 0 duration frames.
// If we don't ignore this rule and our buffer is full of 0 duration frames
// at timestamp n, we get an eviction range of [0, n). When we get to step
// 3.3 below, the 0 duration frames will not be evicted because their
// timestamp is not less than remove end timestamp -- it will in fact be
// equal to remove end timestamp.
//
// 2. If this track buffer has a random access point timestamp that is
// greater than or equal to end, then update remove end timestamp to that
// random access point timestamp.
// ^ We've made sure end > any sample's timestamp, so can skip this.
//
// 3. Remove all media data, from this track buffer, that contain starting
// timestamps greater than or equal to start and less than the remove end
// timestamp.
// 4. Remove decoding dependencies of the coded frames removed in the
// previous step: Remove all coded frames between the coded frames removed
// in the previous step and the next random access point after those removed
// frames.
// This should remove every frame in the track because removedInterval was
// constructed such that every frame in any track falls into that interval.
RemoveFrames(removedInterval, *track, 0, RemovalMode::kRemoveFrame);
// 5. If this object is in activeSourceBuffers, the current playback
// position is greater than or equal to start and less than the remove end
// timestamp, and HTMLMediaElement.readyState is greater than HAVE_METADATA,
// then set the HTMLMediaElement.readyState attribute to HAVE_METADATA and
// stall playback. This will be done by the MDSM during playback.
// TODO properly, so it works even if paused.
}
UpdateBufferedRanges();
#ifdef DEBUG
{
MutexAutoLock lock(mMutex);
MOZ_ASSERT(
mAudioBufferedRanges.IsEmpty(),
"Should have no buffered video ranges after evicting everything.");
MOZ_ASSERT(
mVideoBufferedRanges.IsEmpty(),
"Should have no buffered video ranges after evicting everything.");
}
#endif
mSizeSourceBuffer = mVideoTracks.mSizeBuffer + mAudioTracks.mSizeBuffer;
MOZ_ASSERT(mSizeSourceBuffer == 0,
"Buffer should be empty after evicting everything!");
if (mBufferFull && mSizeSourceBuffer < EvictionThreshold()) {
mBufferFull = false;
}
}
void TrackBuffersManager::UpdateBufferedRanges() {
MutexAutoLock mut(mMutex);
mVideoBufferedRanges = mVideoTracks.mSanitizedBufferedRanges;
mAudioBufferedRanges = mAudioTracks.mSanitizedBufferedRanges;
#if DEBUG
if (HasVideo()) {
MSE_DEBUG("after video ranges=%s",
DumpTimeRangesRaw(mVideoTracks.mBufferedRanges).get());
}
if (HasAudio()) {
MSE_DEBUG("after audio ranges=%s",
DumpTimeRangesRaw(mAudioTracks.mBufferedRanges).get());
}
#endif
if (profiler_thread_is_being_profiled_for_markers()) {
nsPrintfCString msg("buffered, ");
if (HasVideo()) {
msg += "video="_ns;
msg += DumpTimeRangesRaw(mVideoTracks.mBufferedRanges);
}
if (HasAudio()) {
msg += "audio="_ns;
msg += DumpTimeRangesRaw(mAudioTracks.mBufferedRanges);
}
PROFILER_MARKER_TEXT("UpdateBufferedRanges", MEDIA_PLAYBACK, {}, msg);
}
}
void TrackBuffersManager::SegmentParserLoop() {
MOZ_ASSERT(OnTaskQueue());
AUTO_PROFILER_LABEL("TrackBuffersManager::SegmentParserLoop", MEDIA_PLAYBACK);
while (true) {
// 1. If the input buffer is empty, then jump to the need more data step
// below.
if (!mInputBuffer || mInputBuffer->IsEmpty()) {
NeedMoreData();
return;
}
// 2. If the input buffer contains bytes that violate the SourceBuffer
// byte stream format specification, then run the append error algorithm
// with the decode error parameter set to true and abort this algorithm.
// TODO
// 3. Remove any bytes that the byte stream format specifications say must
// be ignored from the start of the input buffer. We do not remove bytes
// from our input buffer. Instead we enforce that our ContainerParser is
// able to skip over all data that is supposed to be ignored.
// 4. If the append state equals WAITING_FOR_SEGMENT, then run the following
// steps:
if (mSourceBufferAttributes->GetAppendState() ==
AppendState::WAITING_FOR_SEGMENT) {
MediaResult haveInitSegment =
mParser->IsInitSegmentPresent(*mInputBuffer);
if (NS_SUCCEEDED(haveInitSegment)) {
SetAppendState(AppendState::PARSING_INIT_SEGMENT);
if (mFirstInitializationSegmentReceived && !mChangeTypeReceived) {
// This is a new initialization segment. Obsolete the old one.
RecreateParser(false);
}
continue;
}
MediaResult haveMediaSegment =
mParser->IsMediaSegmentPresent(*mInputBuffer);
if (NS_SUCCEEDED(haveMediaSegment)) {
SetAppendState(AppendState::PARSING_MEDIA_SEGMENT);
mNewMediaSegmentStarted = true;
continue;
}
// We have neither an init segment nor a media segment.
// Check if it was invalid data.
if (haveInitSegment != NS_ERROR_NOT_AVAILABLE) {
MSE_DEBUG("Found invalid data.");
RejectAppend(haveInitSegment, __func__);
return;
}
if (haveMediaSegment != NS_ERROR_NOT_AVAILABLE) {
MSE_DEBUG("Found invalid data.");
RejectAppend(haveMediaSegment, __func__);
return;
}
MSE_DEBUG("Found incomplete data.");
NeedMoreData();
return;
}
MOZ_ASSERT(mSourceBufferAttributes->GetAppendState() ==
AppendState::PARSING_INIT_SEGMENT ||
mSourceBufferAttributes->GetAppendState() ==
AppendState::PARSING_MEDIA_SEGMENT);
TimeUnit start, end;
MediaResult newData = NS_ERROR_NOT_AVAILABLE;
if (mSourceBufferAttributes->GetAppendState() ==
AppendState::PARSING_INIT_SEGMENT ||
(mSourceBufferAttributes->GetAppendState() ==
AppendState::PARSING_MEDIA_SEGMENT &&
mFirstInitializationSegmentReceived && !mChangeTypeReceived)) {
newData = mParser->ParseStartAndEndTimestamps(*mInputBuffer, start, end);
if (NS_FAILED(newData) && newData.Code() != NS_ERROR_NOT_AVAILABLE) {
RejectAppend(newData, __func__);
return;
}
mProcessedInput += mInputBuffer->Length();
}
// 5. If the append state equals PARSING_INIT_SEGMENT, then run the
// following steps:
if (mSourceBufferAttributes->GetAppendState() ==
AppendState::PARSING_INIT_SEGMENT) {
if (mParser->InitSegmentRange().IsEmpty()) {
mInputBuffer.reset();
NeedMoreData();
return;
}
InitializationSegmentReceived();
return;
}
if (mSourceBufferAttributes->GetAppendState() ==
AppendState::PARSING_MEDIA_SEGMENT) {
// 1. If the first initialization segment received flag is false, then run
// the append error algorithm with the decode error parameter set to
// true and abort this algorithm.
// Or we are in the process of changeType, in which case we must first
// get an init segment before getting a media segment.
if (!mFirstInitializationSegmentReceived || mChangeTypeReceived) {
RejectAppend(NS_ERROR_FAILURE, __func__);
return;
}
// We can't feed some demuxers (WebMDemuxer) with data that do not have
// monotonizally increasing timestamps. So we check if we have a
// discontinuity from the previous segment parsed.
// If so, recreate a new demuxer to ensure that the demuxer is only fed
// monotonically increasing data.
if (mNewMediaSegmentStarted) {
if (NS_SUCCEEDED(newData) && mLastParsedEndTime.isSome() &&
start < mLastParsedEndTime.ref()) {
nsPrintfCString msg(
"Re-creating demuxer, new start (%" PRId64
") is smaller than last parsed end time (%" PRId64 ")",
start.ToMicroseconds(), mLastParsedEndTime->ToMicroseconds());
if (profiler_thread_is_being_profiled_for_markers()) {
PROFILER_MARKER_TEXT("Re-create demuxer", MEDIA_PLAYBACK, {}, msg);
}
MSE_DEBUG("%s", msg.get());
mFrameEndTimeBeforeRecreateDemuxer = Some(end);
ResetDemuxingState();
return;
}
if (NS_SUCCEEDED(newData) || !mParser->MediaSegmentRange().IsEmpty()) {
if (mPendingInputBuffer) {
// We now have a complete media segment header. We can resume
// parsing the data.
AppendDataToCurrentInputBuffer(*mPendingInputBuffer);
mPendingInputBuffer.reset();
}
mNewMediaSegmentStarted = false;
} else {
// We don't have any data to demux yet, stash aside the data.
// This also handles the case:
// 2. If the input buffer does not contain a complete media segment
// header yet, then jump to the need more data step below.
if (!mPendingInputBuffer) {
mPendingInputBuffer = Some(MediaSpan(*mInputBuffer));
} else {
// Note we reset mInputBuffer below, so this won't end up appending
// the contents of mInputBuffer to itself.
mPendingInputBuffer->Append(*mInputBuffer);
}
mInputBuffer.reset();
NeedMoreData();
return;
}
}
// 3. If the input buffer contains one or more complete coded frames, then
// run the coded frame processing algorithm.
RefPtr<TrackBuffersManager> self = this;
CodedFrameProcessing()
->Then(
TaskQueueFromTaskQueue(), __func__,
[self](bool aNeedMoreData) {
self->mTaskQueueCapability->AssertOnCurrentThread();
self->mProcessingRequest.Complete();
if (aNeedMoreData) {
self->NeedMoreData();
} else {
self->ScheduleSegmentParserLoop();
}
},
[self](const MediaResult& aRejectValue) {
self->mTaskQueueCapability->AssertOnCurrentThread();
self->mProcessingRequest.Complete();
self->RejectAppend(aRejectValue, __func__);
})
->Track(mProcessingRequest);
return;
}
}
}
void TrackBuffersManager::NeedMoreData() {
MSE_DEBUG("");
MOZ_DIAGNOSTIC_ASSERT(mCurrentTask &&
mCurrentTask->GetType() ==
SourceBufferTask::Type::AppendBuffer);
MOZ_DIAGNOSTIC_ASSERT(mSourceBufferAttributes);
mCurrentTask->As<AppendBufferTask>()->mPromise.Resolve(
SourceBufferTask::AppendBufferResult(mActiveTrack,
*mSourceBufferAttributes),
__func__);
mSourceBufferAttributes = nullptr;
mCurrentTask = nullptr;
ProcessTasks();
}
void TrackBuffersManager::RejectAppend(const MediaResult& aRejectValue,
const char* aName) {
MSE_DEBUG("rv=%" PRIu32, static_cast<uint32_t>(aRejectValue.Code()));
MOZ_DIAGNOSTIC_ASSERT(mCurrentTask &&
mCurrentTask->GetType() ==
SourceBufferTask::Type::AppendBuffer);
mCurrentTask->As<AppendBufferTask>()->mPromise.Reject(aRejectValue, __func__);
mSourceBufferAttributes = nullptr;
mCurrentTask = nullptr;
ProcessTasks();
}
void TrackBuffersManager::ScheduleSegmentParserLoop() {
MOZ_ASSERT(OnTaskQueue());
TaskQueueFromTaskQueue()->Dispatch(
NewRunnableMethod("TrackBuffersManager::SegmentParserLoop", this,
&TrackBuffersManager::SegmentParserLoop));
}
void TrackBuffersManager::ShutdownDemuxers() {
if (profiler_thread_is_being_profiled_for_markers()) {
PROFILER_MARKER_UNTYPED("ShutdownDemuxers", MEDIA_PLAYBACK);
}
if (mVideoTracks.mDemuxer) {
mVideoTracks.mDemuxer->BreakCycles();
mVideoTracks.mDemuxer = nullptr;
}
if (mAudioTracks.mDemuxer) {
mAudioTracks.mDemuxer->BreakCycles();
mAudioTracks.mDemuxer = nullptr;
}
// We shouldn't change mInputDemuxer while a demuxer init/reset request is
// being processed. See bug 1239983.
MOZ_DIAGNOSTIC_ASSERT(!mDemuxerInitRequest.Exists());
mInputDemuxer = nullptr;
mLastParsedEndTime.reset();
}
void TrackBuffersManager::CreateDemuxerforMIMEType() {
mTaskQueueCapability->AssertOnCurrentThread();
MSE_DEBUG("mType.OriginalString=%s", mType.OriginalString().get());
ShutdownDemuxers();
if (mType.Type() == MEDIAMIMETYPE(VIDEO_WEBM) ||
mType.Type() == MEDIAMIMETYPE(AUDIO_WEBM)) {
if (mFrameEndTimeBeforeRecreateDemuxer) {
MSE_DEBUG(
"CreateDemuxerFromMimeType: "
"mFrameEndTimeBeforeRecreateDemuxer=%" PRId64,
mFrameEndTimeBeforeRecreateDemuxer->ToMicroseconds());
}
mInputDemuxer = new WebMDemuxer(mCurrentInputBuffer, true,
mFrameEndTimeBeforeRecreateDemuxer);
mFrameEndTimeBeforeRecreateDemuxer.reset();
DDLINKCHILD("demuxer", mInputDemuxer.get());
return;
}
if (mType.Type() == MEDIAMIMETYPE(VIDEO_MP4) ||
mType.Type() == MEDIAMIMETYPE(AUDIO_MP4)) {
mInputDemuxer = new MP4Demuxer(mCurrentInputBuffer);
mFrameEndTimeBeforeRecreateDemuxer.reset();
DDLINKCHILD("demuxer", mInputDemuxer.get());
return;
}
NS_WARNING("Not supported (yet)");
}
// We reset the demuxer by creating a new one and initializing it.
void TrackBuffersManager::ResetDemuxingState() {
MOZ_ASSERT(OnTaskQueue());
MOZ_ASSERT(mParser && mParser->HasInitData());
AUTO_PROFILER_LABEL("TrackBuffersManager::ResetDemuxingState",
MEDIA_PLAYBACK);
if (profiler_thread_is_being_profiled_for_markers()) {
PROFILER_MARKER_UNTYPED("ResetDemuxingState", MEDIA_PLAYBACK);
}
RecreateParser(true);
mCurrentInputBuffer = new SourceBufferResource();
// The demuxer isn't initialized yet ; we don't want to notify it
// that data has been appended yet ; so we simply append the init segment
// to the resource.
mCurrentInputBuffer->AppendData(mParser->InitData());
CreateDemuxerforMIMEType();
if (!mInputDemuxer) {
RejectAppend(NS_ERROR_FAILURE, __func__);
return;
}
mInputDemuxer->Init()
->Then(TaskQueueFromTaskQueue(), __func__, this,
&TrackBuffersManager::OnDemuxerResetDone,
&TrackBuffersManager::OnDemuxerInitFailed)
->Track(mDemuxerInitRequest);
}
void TrackBuffersManager::OnDemuxerResetDone(const MediaResult& aResult) {
MOZ_ASSERT(OnTaskQueue());
mDemuxerInitRequest.Complete();
if (NS_FAILED(aResult) && StaticPrefs::media_playback_warnings_as_errors()) {
RejectAppend(aResult, __func__);
return;
}
// mInputDemuxer shouldn't have been destroyed while a demuxer init/reset
// request was being processed. See bug 1239983.
MOZ_DIAGNOSTIC_ASSERT(mInputDemuxer);
if (aResult != NS_OK && mParentDecoder) {
RefPtr<TrackBuffersManager> self = this;
mAbstractMainThread->Dispatch(NS_NewRunnableFunction(
"TrackBuffersManager::OnDemuxerResetDone", [self, aResult]() {
if (self->mParentDecoder && self->mParentDecoder->GetOwner()) {
self->mParentDecoder->GetOwner()->DecodeWarning(aResult);
}
}));
}
// Recreate track demuxers.
uint32_t numVideos = mInputDemuxer->GetNumberTracks(TrackInfo::kVideoTrack);
if (numVideos) {
// We currently only handle the first video track.
mVideoTracks.mDemuxer =
mInputDemuxer->GetTrackDemuxer(TrackInfo::kVideoTrack, 0);
MOZ_ASSERT(mVideoTracks.mDemuxer);
DDLINKCHILD("video demuxer", mVideoTracks.mDemuxer.get());
}
uint32_t numAudios = mInputDemuxer->GetNumberTracks(TrackInfo::kAudioTrack);
if (numAudios) {
// We currently only handle the first audio track.
mAudioTracks.mDemuxer =
mInputDemuxer->GetTrackDemuxer(TrackInfo::kAudioTrack, 0);
MOZ_ASSERT(mAudioTracks.mDemuxer);
DDLINKCHILD("audio demuxer", mAudioTracks.mDemuxer.get());
}
if (mPendingInputBuffer) {
// We had a partial media segment header stashed aside.
// Reparse its content so we can continue parsing the current input buffer.
TimeUnit start, end;
mParser->ParseStartAndEndTimestamps(*mPendingInputBuffer, start, end);
mProcessedInput += mPendingInputBuffer->Length();
}
SegmentParserLoop();
}
void TrackBuffersManager::AppendDataToCurrentInputBuffer(
const MediaSpan& aData) {
MOZ_ASSERT(mCurrentInputBuffer);
mCurrentInputBuffer->AppendData(aData);
mInputDemuxer->NotifyDataArrived();
}
void TrackBuffersManager::InitializationSegmentReceived() {
MOZ_ASSERT(OnTaskQueue());
MOZ_ASSERT(mParser->HasCompleteInitData());
AUTO_PROFILER_LABEL("TrackBuffersManager::InitializationSegmentReceived",
MEDIA_PLAYBACK);
if (profiler_thread_is_being_profiled_for_markers()) {
PROFILER_MARKER_UNTYPED("InitializationSegmentReceived", MEDIA_PLAYBACK);
}
int64_t endInit = mParser->InitSegmentRange().mEnd;
if (mInputBuffer->Length() > mProcessedInput ||
int64_t(mProcessedInput - mInputBuffer->Length()) > endInit) {
// Something is not quite right with the data appended. Refuse it.
RejectAppend(MediaResult(NS_ERROR_FAILURE,
"Invalid state following initialization segment"),
__func__);
return;
}
mCurrentInputBuffer = new SourceBufferResource();
// The demuxer isn't initialized yet ; we don't want to notify it
// that data has been appended yet ; so we simply append the init segment
// to the resource.
mCurrentInputBuffer->AppendData(mParser->InitData());
uint32_t length = endInit - (mProcessedInput - mInputBuffer->Length());
MOZ_RELEASE_ASSERT(length <= mInputBuffer->Length());
mInputBuffer->RemoveFront(length);
CreateDemuxerforMIMEType();
if (!mInputDemuxer) {
NS_WARNING("TODO type not supported");
RejectAppend(NS_ERROR_DOM_NOT_SUPPORTED_ERR, __func__);
return;
}
mInputDemuxer->Init()
->Then(TaskQueueFromTaskQueue(), __func__, this,
&TrackBuffersManager::OnDemuxerInitDone,
&TrackBuffersManager::OnDemuxerInitFailed)
->Track(mDemuxerInitRequest);
}
bool TrackBuffersManager::IsRepeatInitData(
const MediaInfo& aNewMediaInfo) const {
MOZ_ASSERT(OnTaskQueue());
if (!mInitData) {
// There is no previous init data, so this cannot be a repeat.
return false;
}
if (mChangeTypeReceived) {
// If we're received change type we want to reprocess init data.
return false;
}
MOZ_DIAGNOSTIC_ASSERT(mInitData, "Init data should be non-null");
if (*mInitData == *mParser->InitData()) {
// We have previous init data, and it's the same binary data as we've just
// parsed.
return true;
}
// At this point the binary data doesn't match, but it's possible to have the
// different binary representations for the same logical init data. These
// checks can be revised as we encounter such cases in the wild.
bool audioInfoIsRepeat = false;
if (aNewMediaInfo.HasAudio()) {
if (!mAudioTracks.mLastInfo) {
// There is no old audio info, so this can't be a repeat.
return false;
}
audioInfoIsRepeat =
*mAudioTracks.mLastInfo->GetAsAudioInfo() == aNewMediaInfo.mAudio;
if (!aNewMediaInfo.HasVideo()) {
// Only have audio.
return audioInfoIsRepeat;
}
}
bool videoInfoIsRepeat = false;
if (aNewMediaInfo.HasVideo()) {
if (!mVideoTracks.mLastInfo) {
// There is no old video info, so this can't be a repeat.
return false;
}
videoInfoIsRepeat =
*mVideoTracks.mLastInfo->GetAsVideoInfo() == aNewMediaInfo.mVideo;
if (!aNewMediaInfo.HasAudio()) {
// Only have video.
return videoInfoIsRepeat;
}
}
if (audioInfoIsRepeat && videoInfoIsRepeat) {
MOZ_DIAGNOSTIC_ASSERT(
aNewMediaInfo.HasVideo() && aNewMediaInfo.HasAudio(),
"This should only be reachable if audio and video are present");
// Video + audio are present and both have the same init data.
return true;
}
return false;
}
void TrackBuffersManager::OnDemuxerInitDone(const MediaResult& aResult) {
mTaskQueueCapability->AssertOnCurrentThread();
MOZ_DIAGNOSTIC_ASSERT(mInputDemuxer, "mInputDemuxer has been destroyed");
AUTO_PROFILER_LABEL("TrackBuffersManager::OnDemuxerInitDone", MEDIA_PLAYBACK);
mDemuxerInitRequest.Complete();
if (NS_FAILED(aResult) && StaticPrefs::media_playback_warnings_as_errors()) {
RejectAppend(aResult, __func__);
return;
}
MediaInfo info;
uint32_t numVideos = mInputDemuxer->GetNumberTracks(TrackInfo::kVideoTrack);
if (numVideos) {
// We currently only handle the first video track.
mVideoTracks.mDemuxer =
mInputDemuxer->GetTrackDemuxer(TrackInfo::kVideoTrack, 0);
MOZ_ASSERT(mVideoTracks.mDemuxer);
DDLINKCHILD("video demuxer", mVideoTracks.mDemuxer.get());
info.mVideo = *mVideoTracks.mDemuxer->GetInfo()->GetAsVideoInfo();
info.mVideo.mTrackId = 2;
}
uint32_t numAudios = mInputDemuxer->GetNumberTracks(TrackInfo::kAudioTrack);
if (numAudios) {
// We currently only handle the first audio track.
mAudioTracks.mDemuxer =
mInputDemuxer->GetTrackDemuxer(TrackInfo::kAudioTrack, 0);
MOZ_ASSERT(mAudioTracks.mDemuxer);
DDLINKCHILD("audio demuxer", mAudioTracks.mDemuxer.get());
info.mAudio = *mAudioTracks.mDemuxer->GetInfo()->GetAsAudioInfo();
info.mAudio.mTrackId = 1;
}
TimeUnit videoDuration = numVideos ? info.mVideo.mDuration : TimeUnit::Zero();
TimeUnit audioDuration = numAudios ? info.mAudio.mDuration : TimeUnit::Zero();
TimeUnit duration = std::max(videoDuration, audioDuration);
// 1. Update the duration attribute if it currently equals NaN.
// Those steps are performed by the MediaSourceDecoder::SetInitialDuration
mAbstractMainThread->Dispatch(NewRunnableMethod<TimeUnit>(
"MediaSourceDecoder::SetInitialDuration", mParentDecoder.get(),
&MediaSourceDecoder::SetInitialDuration,
!duration.IsZero() ? duration : TimeUnit::FromInfinity()));
// 2. If the initialization segment has no audio, video, or text tracks, then
// run the append error algorithm with the decode error parameter set to true
// and abort these steps.
if (!numVideos && !numAudios) {
RejectAppend(NS_ERROR_FAILURE, __func__);
return;
}
// 3. If the first initialization segment received flag is true, then run the
// following steps:
if (mFirstInitializationSegmentReceived) {
if (numVideos != mVideoTracks.mNumTracks ||
numAudios != mAudioTracks.mNumTracks) {
RejectAppend(NS_ERROR_FAILURE, __func__);
return;
}
// 1. If more than one track for a single type are present (ie 2 audio
// tracks), then the Track IDs match the ones in the first initialization
// segment.
// TODO
// 2. Add the appropriate track descriptions from this initialization
// segment to each of the track buffers.
// TODO
// 3. Set the need random access point flag on all track buffers to true.
mVideoTracks.mNeedRandomAccessPoint = true;
mAudioTracks.mNeedRandomAccessPoint = true;
}
// Check if we've received the same init data again. Some streams will
// resend the same data. In these cases we don't need to change the stream
// id as it's the same stream. Doing so would recreate decoders, possibly
// leading to gaps in audio and/or video (see bug 1450952).
bool isRepeatInitData = IsRepeatInitData(info);
MOZ_ASSERT(mFirstInitializationSegmentReceived || !isRepeatInitData,
"Should never detect repeat init data for first segment!");
// If we have new init data we configure and set track info as needed. If we
// have repeat init data we carry forward our existing track info.
if (!isRepeatInitData) {
// Increase our stream id.
uint32_t streamID = sStreamSourceID++;
// 4. Let active track flag equal false.
bool activeTrack = false;
// 5. If the first initialization segment received flag is false, then run
// the following steps:
if (!mFirstInitializationSegmentReceived) {
MSE_DEBUG("Get first init data");
mAudioTracks.mNumTracks = numAudios;
// TODO:
// 1. If the initialization segment contains tracks with codecs the user
// agent does not support, then run the append error algorithm with the
// decode error parameter set to true and abort these steps.
// 2. For each audio track in the initialization segment, run following
// steps: for (uint32_t i = 0; i < numAudios; i++) {
if (numAudios) {
// 1. Let audio byte stream track ID be the Track ID for the current
// track being processed.
// 2. Let audio language be a BCP 47 language tag for the language
// specified in the initialization segment for this track or an empty
// string if no language info is present.
// 3. If audio language equals an empty string or the 'und' BCP 47
// value, then run the default track language algorithm with
// byteStreamTrackID set to audio byte stream track ID and type set to
// "audio" and assign the value returned by the algorithm to audio
// language.
// 4. Let audio label be a label specified in the initialization segment
// for this track or an empty string if no label info is present.
// 5. If audio label equals an empty string, then run the default track
// label algorithm with byteStreamTrackID set to audio byte stream track
// ID and type set to "audio" and assign the value returned by the
// algorithm to audio label.
// 6. Let audio kinds be an array of kind strings specified in the
// initialization segment for this track or an empty array if no kind
// information is provided.
// 7. If audio kinds equals an empty array, then run the default track
// kinds algorithm with byteStreamTrackID set to audio byte stream track
// ID and type set to "audio" and assign the value returned by the
// algorithm to audio kinds.
// 8. For each value in audio kinds, run the following steps:
// 1. Let current audio kind equal the value from audio kinds for this
// iteration of the loop.
// 2. Let new audio track be a new AudioTrack object.
// 3. Generate a unique ID and assign it to the id property on new
// audio track.
// 4. Assign audio language to the language property on new audio
// track.
// 5. Assign audio label to the label property on new audio track.
// 6. Assign current audio kind to the kind property on new audio
// track.
// 7. If audioTracks.length equals 0, then run the following steps:
// 1. Set the enabled property on new audio track to true.
// 2. Set active track flag to true.
activeTrack = true;
// 8. Add new audio track to the audioTracks attribute on this
// SourceBuffer object.
// 9. Queue a task to fire a trusted event named addtrack, that does
// not bubble and is not cancelable, and that uses the TrackEvent
// interface, at the AudioTrackList object referenced by the
// audioTracks attribute on this SourceBuffer object.
// 10. Add new audio track to the audioTracks attribute on the
// HTMLMediaElement.
// 11. Queue a task to fire a trusted event named addtrack, that does
// not bubble and is not cancelable, and that uses the TrackEvent
// interface, at the AudioTrackList object referenced by the
// audioTracks attribute on the HTMLMediaElement.
mAudioTracks.mBuffers.AppendElement(TrackBuffer());
// 10. Add the track description for this track to the track buffer.
mAudioTracks.mInfo = new TrackInfoSharedPtr(info.mAudio, streamID);
mAudioTracks.mLastInfo = mAudioTracks.mInfo;
}
mVideoTracks.mNumTracks = numVideos;
// 3. For each video track in the initialization segment, run following
// steps: for (uint32_t i = 0; i < numVideos; i++) {
if (numVideos) {
// 1. Let video byte stream track ID be the Track ID for the current
// track being processed.
// 2. Let video language be a BCP 47 language tag for the language
// specified in the initialization segment for this track or an empty
// string if no language info is present.
// 3. If video language equals an empty string or the 'und' BCP 47
// value, then run the default track language algorithm with
// byteStreamTrackID set to video byte stream track ID and type set to
// "video" and assign the value returned by the algorithm to video
// language.
// 4. Let video label be a label specified in the initialization segment
// for this track or an empty string if no label info is present.
// 5. If video label equals an empty string, then run the default track
// label algorithm with byteStreamTrackID set to video byte stream track
// ID and type set to "video" and assign the value returned by the
// algorithm to video label.
// 6. Let video kinds be an array of kind strings specified in the
// initialization segment for this track or an empty array if no kind
// information is provided.
// 7. If video kinds equals an empty array, then run the default track
// kinds algorithm with byteStreamTrackID set to video byte stream track
// ID and type set to "video" and assign the value returned by the
// algorithm to video kinds.
// 8. For each value in video kinds, run the following steps:
// 1. Let current video kind equal the value from video kinds for this
// iteration of the loop.
// 2. Let new video track be a new VideoTrack object.
// 3. Generate a unique ID and assign it to the id property on new
// video track.
// 4. Assign video language to the language property on new video
// track.
// 5. Assign video label to the label property on new video track.
// 6. Assign current video kind to the kind property on new video
// track.
// 7. If videoTracks.length equals 0, then run the following steps:
// 1. Set the selected property on new video track to true.
// 2. Set active track flag to true.
activeTrack = true;
// 8. Add new video track to the videoTracks attribute on this
// SourceBuffer object.
// 9. Queue a task to fire a trusted event named addtrack, that does
// not bubble and is not cancelable, and that uses the TrackEvent
// interface, at the VideoTrackList object referenced by the
// videoTracks attribute on this SourceBuffer object.
// 10. Add new video track to the videoTracks attribute on the
// HTMLMediaElement.
// 11. Queue a task to fire a trusted event named addtrack, that does
// not bubble and is not cancelable, and that uses the TrackEvent
// interface, at the VideoTrackList object referenced by the
// videoTracks attribute on the HTMLMediaElement.
mVideoTracks.mBuffers.AppendElement(TrackBuffer());
// 10. Add the track description for this track to the track buffer.
mVideoTracks.mInfo = new TrackInfoSharedPtr(info.mVideo, streamID);
mVideoTracks.mLastInfo = mVideoTracks.mInfo;
}
// 4. For each text track in the initialization segment, run following
// steps:
// 5. If active track flag equals true, then run the following steps:
// This is handled by SourceBuffer once the promise is resolved.
if (activeTrack) {
mActiveTrack = true;
}
// 6. Set first initialization segment received flag to true.
mFirstInitializationSegmentReceived = true;
} else {
MSE_DEBUG("Get new init data");
mAudioTracks.mLastInfo = new TrackInfoSharedPtr(info.mAudio, streamID);
mVideoTracks.mLastInfo = new TrackInfoSharedPtr(info.mVideo, streamID);
}
UniquePtr<EncryptionInfo> crypto = mInputDemuxer->GetCrypto();
if (crypto && crypto->IsEncrypted()) {
// Try and dispatch 'encrypted'. Won't go if ready state still
// HAVE_NOTHING.
for (uint32_t i = 0; i < crypto->mInitDatas.Length(); i++) {
nsCOMPtr<nsIRunnable> r = new DispatchKeyNeededEvent(
mParentDecoder, crypto->mInitDatas[i].mInitData,
crypto->mInitDatas[i].mType);
mAbstractMainThread->Dispatch(r.forget());
}
info.mCrypto = *crypto;
// We clear our crypto init data array, so the MediaFormatReader will
// not emit an encrypted event for the same init data again.
info.mCrypto.mInitDatas.Clear();
}
{
MutexAutoLock mut(mMutex);
mInfo = info;
}
}
// We now have a valid init data ; we can store it for later use.
mInitData = mParser->InitData();
// We have now completed the changeType operation.
mChangeTypeReceived = false;
// 3. Remove the initialization segment bytes from the beginning of the input
// buffer. This step has already been done in InitializationSegmentReceived
// when we transferred the content into mCurrentInputBuffer.
mCurrentInputBuffer->EvictAll();
mInputDemuxer->NotifyDataRemoved();
RecreateParser(true);
// 4. Set append state to WAITING_FOR_SEGMENT.
SetAppendState(AppendState::WAITING_FOR_SEGMENT);
// 5. Jump to the loop top step above.
ScheduleSegmentParserLoop();
if (aResult != NS_OK && mParentDecoder) {
RefPtr<TrackBuffersManager> self = this;
mAbstractMainThread->Dispatch(NS_NewRunnableFunction(
"TrackBuffersManager::OnDemuxerInitDone", [self, aResult]() {
if (self->mParentDecoder && self->mParentDecoder->GetOwner()) {
self->mParentDecoder->GetOwner()->DecodeWarning(aResult);
}
}));
}
}
void TrackBuffersManager::OnDemuxerInitFailed(const MediaResult& aError) {
mTaskQueueCapability->AssertOnCurrentThread();
MSE_DEBUG("");
MOZ_ASSERT(aError != NS_ERROR_DOM_MEDIA_WAITING_FOR_DATA);
mDemuxerInitRequest.Complete();
RejectAppend(aError, __func__);
}
RefPtr<TrackBuffersManager::CodedFrameProcessingPromise>
TrackBuffersManager::CodedFrameProcessing() {
MOZ_ASSERT(OnTaskQueue());
MOZ_ASSERT(mProcessingPromise.IsEmpty());
AUTO_PROFILER_LABEL("TrackBuffersManager::CodedFrameProcessing",
MEDIA_PLAYBACK);
MediaByteRange mediaRange = mParser->MediaSegmentRange();
if (mediaRange.IsEmpty()) {
AppendDataToCurrentInputBuffer(*mInputBuffer);
mInputBuffer.reset();
} else {
MOZ_ASSERT(mProcessedInput >= mInputBuffer->Length());
if (int64_t(mProcessedInput - mInputBuffer->Length()) > mediaRange.mEnd) {
// Something is not quite right with the data appended. Refuse it.
// This would typically happen if the previous media segment was partial
// yet a new complete media segment was added.
return CodedFrameProcessingPromise::CreateAndReject(NS_ERROR_FAILURE,
__func__);
}
// The mediaRange is offset by the init segment position previously added.
uint32_t length =
mediaRange.mEnd - (mProcessedInput - mInputBuffer->Length());
if (!length) {
// We've completed our earlier media segment and no new data is to be
// processed. This happens with some containers that can't detect that a
// media segment is ending until a new one starts.
RefPtr<CodedFrameProcessingPromise> p =
mProcessingPromise.Ensure(__func__);
CompleteCodedFrameProcessing();
return p;
}
AppendDataToCurrentInputBuffer(mInputBuffer->To(length));
mInputBuffer->RemoveFront(length);
}
RefPtr<CodedFrameProcessingPromise> p = mProcessingPromise.Ensure(__func__);
DoDemuxVideo();
return p;
}
void TrackBuffersManager::OnDemuxFailed(TrackType aTrack,
const MediaResult& aError) {
MOZ_ASSERT(OnTaskQueue());
MSE_DEBUG("Failed to demux %s, failure:%s",
aTrack == TrackType::kVideoTrack ? "video" : "audio",
aError.ErrorName().get());
switch (aError.Code()) {
case NS_ERROR_DOM_MEDIA_END_OF_STREAM:
case NS_ERROR_DOM_MEDIA_WAITING_FOR_DATA:
if (aTrack == TrackType::kVideoTrack) {
DoDemuxAudio();
} else {
CompleteCodedFrameProcessing();
}
break;
default:
RejectProcessing(aError, __func__);
break;
}
}
void TrackBuffersManager::DoDemuxVideo() {
MOZ_ASSERT(OnTaskQueue());
if (!HasVideo()) {
DoDemuxAudio();
return;
}
mVideoTracks.mDemuxer->GetSamples(-1)
->Then(TaskQueueFromTaskQueue(), __func__, this,
&TrackBuffersManager::OnVideoDemuxCompleted,
&TrackBuffersManager::OnVideoDemuxFailed)
->Track(mVideoTracks.mDemuxRequest);
}
void TrackBuffersManager::MaybeDispatchEncryptedEvent(
const nsTArray<RefPtr<MediaRawData>>& aSamples) {
// Try and dispatch 'encrypted'. Won't go if ready state still HAVE_NOTHING.
for (const RefPtr<MediaRawData>& sample : aSamples) {
for (const nsTArray<uint8_t>& initData : sample->mCrypto.mInitDatas) {
nsCOMPtr<nsIRunnable> r = new DispatchKeyNeededEvent(
mParentDecoder, initData, sample->mCrypto.mInitDataType);
mAbstractMainThread->Dispatch(r.forget());
}
}
}
void TrackBuffersManager::OnVideoDemuxCompleted(
const RefPtr<MediaTrackDemuxer::SamplesHolder>& aSamples) {
mTaskQueueCapability->AssertOnCurrentThread();
mVideoTracks.mDemuxRequest.Complete();
mVideoTracks.mQueuedSamples.AppendElements(aSamples->GetSamples());
MSE_DEBUG("%zu video samples demuxed, queued-sz=%zu",
aSamples->GetSamples().Length(),
mVideoTracks.mQueuedSamples.Length());
MaybeDispatchEncryptedEvent(aSamples->GetSamples());
DoDemuxAudio();
}
void TrackBuffersManager::DoDemuxAudio() {
MOZ_ASSERT(OnTaskQueue());
if (!HasAudio()) {
CompleteCodedFrameProcessing();
return;
}
mAudioTracks.mDemuxer->GetSamples(-1)
->Then(TaskQueueFromTaskQueue(), __func__, this,
&TrackBuffersManager::OnAudioDemuxCompleted,
&TrackBuffersManager::OnAudioDemuxFailed)
->Track(mAudioTracks.mDemuxRequest);
}
void TrackBuffersManager::OnAudioDemuxCompleted(
const RefPtr<MediaTrackDemuxer::SamplesHolder>& aSamples) {
mTaskQueueCapability->AssertOnCurrentThread();
MSE_DEBUG("%zu audio samples demuxed", aSamples->GetSamples().Length());
// When using MSE, it's possible for each fragments to have their own
// duration, with a duration that is incorrectly rounded. Ignore the trimming
// information set by the demuxer to ensure a continous playback.
for (const auto& sample : aSamples->GetSamples()) {
sample->mOriginalPresentationWindow = Nothing();
}
mAudioTracks.mDemuxRequest.Complete();
mAudioTracks.mQueuedSamples.AppendElements(aSamples->GetSamples());
CompleteCodedFrameProcessing();
MaybeDispatchEncryptedEvent(aSamples->GetSamples());
}
void TrackBuffersManager::CompleteCodedFrameProcessing() {
MOZ_ASSERT(OnTaskQueue());
AUTO_PROFILER_LABEL("TrackBuffersManager::CompleteCodedFrameProcessing",
MEDIA_PLAYBACK);
// 1. For each coded frame in the media segment run the following steps:
// Coded Frame Processing steps 1.1 to 1.21.
if (mSourceBufferAttributes->GetAppendMode() ==
SourceBufferAppendMode::Sequence &&
mVideoTracks.mQueuedSamples.Length() &&
mAudioTracks.mQueuedSamples.Length()) {
// When we are in sequence mode, the order in which we process the frames is
// important as it determines the future value of timestampOffset.
// So we process the earliest sample first. See bug 1293576.
TimeInterval videoInterval =
PresentationInterval(mVideoTracks.mQueuedSamples);
TimeInterval audioInterval =
PresentationInterval(mAudioTracks.mQueuedSamples);
if (audioInterval.mStart < videoInterval.mStart) {
ProcessFrames(mAudioTracks.mQueuedSamples, mAudioTracks);
ProcessFrames(mVideoTracks.mQueuedSamples, mVideoTracks);
} else {
ProcessFrames(mVideoTracks.mQueuedSamples, mVideoTracks);
ProcessFrames(mAudioTracks.mQueuedSamples, mAudioTracks);
}
} else {
ProcessFrames(mVideoTracks.mQueuedSamples, mVideoTracks);
ProcessFrames(mAudioTracks.mQueuedSamples, mAudioTracks);
}
#if defined(DEBUG)
if (HasVideo()) {
const auto& track = mVideoTracks.GetTrackBuffer();
MOZ_ASSERT(track.IsEmpty() || track[0]->mKeyframe);
for (uint32_t i = 1; i < track.Length(); i++) {
MOZ_ASSERT(
(track[i - 1]->mTrackInfo->GetID() == track[i]->mTrackInfo->GetID() &&
track[i - 1]->mTimecode <= track[i]->mTimecode) ||
track[i]->mKeyframe);
}
}
if (HasAudio()) {
const auto& track = mAudioTracks.GetTrackBuffer();
MOZ_ASSERT(track.IsEmpty() || track[0]->mKeyframe);
for (uint32_t i = 1; i < track.Length(); i++) {
MOZ_ASSERT(
(track[i - 1]->mTrackInfo->GetID() == track[i]->mTrackInfo->GetID() &&
track[i - 1]->mTimecode <= track[i]->mTimecode) ||
track[i]->mKeyframe);
}
}
#endif
mVideoTracks.mQueuedSamples.Clear();
mAudioTracks.mQueuedSamples.Clear();
UpdateBufferedRanges();
// Update our reported total size.
mSizeSourceBuffer = mVideoTracks.mSizeBuffer + mAudioTracks.mSizeBuffer;
// Return to step 6.4 of Segment Parser Loop algorithm
// 4. If this SourceBuffer is full and cannot accept more media data, then set
// the buffer full flag to true.
if (mSizeSourceBuffer >= EvictionThreshold()) {
mBufferFull = true;
}
// 5. If the input buffer does not contain a complete media segment, then jump
// to the need more data step below.
if (mParser->MediaSegmentRange().IsEmpty()) {
ResolveProcessing(true, __func__);
return;
}
mLastParsedEndTime = Some(std::max(mAudioTracks.mLastParsedEndTime,
mVideoTracks.mLastParsedEndTime));
// 6. Remove the media segment bytes from the beginning of the input buffer.
// Clear our demuxer from any already processed data.
int64_t safeToEvict =
std::min(HasVideo() ? mVideoTracks.mDemuxer->GetEvictionOffset(
mVideoTracks.mLastParsedEndTime)
: INT64_MAX,
HasAudio() ? mAudioTracks.mDemuxer->GetEvictionOffset(
mAudioTracks.mLastParsedEndTime)
: INT64_MAX);
mCurrentInputBuffer->EvictBefore(safeToEvict);
mInputDemuxer->NotifyDataRemoved();
RecreateParser(true);
// 7. Set append state to WAITING_FOR_SEGMENT.
SetAppendState(AppendState::WAITING_FOR_SEGMENT);
// 8. Jump to the loop top step above.
ResolveProcessing(false, __func__);
}
void TrackBuffersManager::RejectProcessing(const MediaResult& aRejectValue,
const char* aName) {
mProcessingPromise.RejectIfExists(aRejectValue, __func__);
}
void TrackBuffersManager::ResolveProcessing(bool aResolveValue,
const char* aName) {
mProcessingPromise.ResolveIfExists(aResolveValue, __func__);
}
void TrackBuffersManager::CheckSequenceDiscontinuity(
const TimeUnit& aPresentationTime) {
if (mSourceBufferAttributes->GetAppendMode() ==
SourceBufferAppendMode::Sequence &&
mSourceBufferAttributes->HaveGroupStartTimestamp()) {
mSourceBufferAttributes->SetTimestampOffset(
mSourceBufferAttributes->GetGroupStartTimestamp() - aPresentationTime);
mSourceBufferAttributes->SetGroupEndTimestamp(
mSourceBufferAttributes->GetGroupStartTimestamp());
mVideoTracks.mNeedRandomAccessPoint = true;
mAudioTracks.mNeedRandomAccessPoint = true;
mSourceBufferAttributes->ResetGroupStartTimestamp();
}
}
TimeInterval TrackBuffersManager::PresentationInterval(
const TrackBuffer& aSamples) const {
TimeInterval presentationInterval =
TimeInterval(aSamples[0]->mTime, aSamples[0]->GetEndTime());
for (uint32_t i = 1; i < aSamples.Length(); i++) {
const auto& sample = aSamples[i];
presentationInterval = presentationInterval.Span(
TimeInterval(sample->mTime, sample->GetEndTime()));
}
return presentationInterval;
}
void TrackBuffersManager::ProcessFrames(TrackBuffer& aSamples,
TrackData& aTrackData) {
AUTO_PROFILER_LABEL("TrackBuffersManager::ProcessFrames", MEDIA_PLAYBACK);
if (!aSamples.Length()) {
return;
}
// 1. If generate timestamps flag equals true
// Let presentation timestamp equal 0.
// Otherwise
// Let presentation timestamp be a double precision floating point
// representation of the coded frame's presentation timestamp in seconds.
TimeUnit presentationTimestamp = mSourceBufferAttributes->mGenerateTimestamps
? TimeUnit::Zero()
: aSamples[0]->mTime;
// 3. If mode equals "sequence" and group start timestamp is set, then run the
// following steps:
CheckSequenceDiscontinuity(presentationTimestamp);
// 5. Let track buffer equal the track buffer that the coded frame will be
// added to.
auto& trackBuffer = aTrackData;
TimeIntervals samplesRange;
uint32_t sizeNewSamples = 0;
TrackBuffer samples; // array that will contain the frames to be added
// to our track buffer.
// We assume that no frames are contiguous within a media segment and as such
// don't need to check for discontinuity except for the first frame and should
// a frame be ignored due to the target window.
bool needDiscontinuityCheck = true;
// Highest presentation time seen in samples block.
TimeUnit highestSampleTime;
if (aSamples.Length()) {
aTrackData.mLastParsedEndTime = TimeUnit();
}
auto addToSamples = [&](MediaRawData* aSample,
const TimeInterval& aInterval) {
aSample->mTime = aInterval.mStart;
aSample->mDuration = aInterval.Length();
aSample->mTrackInfo = trackBuffer.mLastInfo;
SAMPLE_DEBUGV(
"Add sample [%" PRId64 "%s,%" PRId64 "%s] by interval %s",
aSample->mTime.ToMicroseconds(), aSample->mTime.ToString().get(),
aSample->GetEndTime().ToMicroseconds(),
aSample->GetEndTime().ToString().get(), aInterval.ToString().get());
MOZ_DIAGNOSTIC_ASSERT(aSample->HasValidTime());
MOZ_DIAGNOSTIC_ASSERT(TimeInterval(aSample->mTime, aSample->GetEndTime()) ==
aInterval);
#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
auto oldRangeEnd = samplesRange.GetEnd();
#endif
samplesRange += aInterval;
// For debug purpose, if the sample range grows, it should match the
// sample's end time.
MOZ_DIAGNOSTIC_ASSERT_IF(samplesRange.GetEnd() > oldRangeEnd,
samplesRange.GetEnd() == aSample->GetEndTime());
sizeNewSamples += aSample->ComputedSizeOfIncludingThis();
samples.AppendElement(aSample);
};
// Will be set to the last frame dropped due to being outside mAppendWindow.
// It will be added prior the first following frame which can be added to the
// track buffer.
// This sample will be set with a duration of only 1us which will cause it to
// be dropped once returned by the decoder.
// This sample is required to "prime" the decoder so that the following frame
// can be fully decoded.
RefPtr<MediaRawData> previouslyDroppedSample;
for (auto& sample : aSamples) {
const TimeUnit sampleEndTime = sample->GetEndTime();
if (sampleEndTime > aTrackData.mLastParsedEndTime) {
aTrackData.mLastParsedEndTime = sampleEndTime;
}
// We perform step 10 right away as we can't do anything should a keyframe
// be needed until we have one.
// 10. If the need random access point flag on track buffer equals true,
// then run the following steps:
if (trackBuffer.mNeedRandomAccessPoint) {
// 1. If the coded frame is not a random access point, then drop the coded
// frame and jump to the top of the loop to start processing the next
// coded frame.
if (!sample->mKeyframe) {
previouslyDroppedSample = nullptr;
nsPrintfCString msg("skipping sample [%" PRId64 ",%" PRId64 "]",
sample->mTime.ToMicroseconds(),
sample->GetEndTime().ToMicroseconds());
if (profiler_thread_is_being_profiled_for_markers()) {
PROFILER_MARKER_TEXT("Skipping Frame", MEDIA_PLAYBACK, {}, msg);
}
SAMPLE_DEBUGV("%s", msg.get());
continue;
}
// 2. Set the need random access point flag on track buffer to false.
trackBuffer.mNeedRandomAccessPoint = false;
}
// We perform step 1,2 and 4 at once:
// 1. If generate timestamps flag equals true:
// Let presentation timestamp equal 0.
// Let decode timestamp equal 0.
// Otherwise:
// Let presentation timestamp be a double precision floating point
// representation of the coded frame's presentation timestamp in seconds.
// Let decode timestamp be a double precision floating point
// representation of the coded frame's decode timestamp in seconds.
// 2. Let frame duration be a double precision floating point representation
// of the coded frame's duration in seconds. Step 3 is performed earlier or
// when a discontinuity has been detected.
// 4. If timestampOffset is not 0, then run the following steps:
TimeUnit sampleTime = sample->mTime;
TimeUnit sampleTimecode = sample->mTimecode;
TimeUnit sampleDuration = sample->mDuration;
// Keep the timestamp, set by js, in the time base of the container.
TimeUnit timestampOffset =
mSourceBufferAttributes->GetTimestampOffset().ToBase(sample->mTime);
TimeInterval sampleInterval =
mSourceBufferAttributes->mGenerateTimestamps
? TimeInterval(timestampOffset, timestampOffset + sampleDuration)
: TimeInterval(timestampOffset + sampleTime,
timestampOffset + sampleTime + sampleDuration);
TimeUnit decodeTimestamp = mSourceBufferAttributes->mGenerateTimestamps
? timestampOffset
: timestampOffset + sampleTimecode;
SAMPLE_DEBUG(
"Processing %s frame [%" PRId64 "%s,%" PRId64 "%s] (adjusted:[%" PRId64
"%s,%" PRId64 "%s]), dts:%" PRId64 ", duration:%" PRId64 ", kf:%d)",
aTrackData.mInfo->mMimeType.get(), sample->mTime.ToMicroseconds(),
sample->mTime.ToString().get(), sample->GetEndTime().ToMicroseconds(),
sample->GetEndTime().ToString().get(),
sampleInterval.mStart.ToMicroseconds(),
sampleInterval.mStart.ToString().get(),
sampleInterval.mEnd.ToMicroseconds(),
sampleInterval.mEnd.ToString().get(),
sample->mTimecode.ToMicroseconds(), sample->mDuration.ToMicroseconds(),
sample->mKeyframe);
// 6. If last decode timestamp for track buffer is set and decode timestamp
// is less than last decode timestamp: OR If last decode timestamp for track
// buffer is set and the difference between decode timestamp and last decode
// timestamp is greater than 2 times last frame duration:
if (needDiscontinuityCheck && trackBuffer.mLastDecodeTimestamp.isSome() &&
(decodeTimestamp < trackBuffer.mLastDecodeTimestamp.ref() ||
(decodeTimestamp - trackBuffer.mLastDecodeTimestamp.ref() >
trackBuffer.mLongestFrameDuration * 2))) {
if (profiler_thread_is_being_profiled_for_markers()) {
PROFILER_MARKER_UNTYPED("Discontinuity detected", MEDIA_PLAYBACK);
}
MSE_DEBUG("Discontinuity detected.");
SourceBufferAppendMode appendMode =
mSourceBufferAttributes->GetAppendMode();
// 1a. If mode equals "segments":
if (appendMode == SourceBufferAppendMode::Segments) {
// Set group end timestamp to presentation timestamp.
mSourceBufferAttributes->SetGroupEndTimestamp(sampleInterval.mStart);
}
// 1b. If mode equals "sequence":
if (appendMode == SourceBufferAppendMode::Sequence) {
// Set group start timestamp equal to the group end timestamp.
mSourceBufferAttributes->SetGroupStartTimestamp(
mSourceBufferAttributes->GetGroupEndTimestamp());
}
for (auto& track : GetTracksList()) {
// 2. Unset the last decode timestamp on all track buffers.
// 3. Unset the last frame duration on all track buffers.
// 4. Unset the highest end timestamp on all track buffers.
// 5. Set the need random access point flag on all track buffers to
// true.
MSE_DEBUG("Resetting append state");
track->ResetAppendState();
}
// 6. Jump to the Loop Top step above to restart processing of the current
// coded frame. Rather that restarting the process for the frame, we run
// the first steps again instead.
// 3. If mode equals "sequence" and group start timestamp is set, then run
// the following steps:
TimeUnit presentationTimestamp =
mSourceBufferAttributes->mGenerateTimestamps ? TimeUnit()
: sampleTime;
CheckSequenceDiscontinuity(presentationTimestamp);
if (!sample->mKeyframe) {
previouslyDroppedSample = nullptr;
continue;
}
if (appendMode == SourceBufferAppendMode::Sequence) {
// mSourceBufferAttributes->GetTimestampOffset() was modified during
// CheckSequenceDiscontinuity. We need to update our variables.
timestampOffset =
mSourceBufferAttributes->GetTimestampOffset().ToBase(sample->mTime);
sampleInterval =
mSourceBufferAttributes->mGenerateTimestamps
? TimeInterval(timestampOffset,
timestampOffset + sampleDuration)
: TimeInterval(timestampOffset + sampleTime,
timestampOffset + sampleTime + sampleDuration);
decodeTimestamp = mSourceBufferAttributes->mGenerateTimestamps
? timestampOffset
: timestampOffset + sampleTimecode;
}
trackBuffer.mNeedRandomAccessPoint = false;
needDiscontinuityCheck = false;
}
// 7. Let frame end timestamp equal the sum of presentation timestamp and
// frame duration.
// "presentation timestamp" and "frame duration" are double precision
// representations.
Interval<double> frameStartAndEnd(
sampleInterval.mStart.ToSeconds(),
sampleInterval.mStart.ToSeconds() + sampleDuration.ToSeconds());
// 8. If presentation timestamp is less than appendWindowStart, then set the
// need random access point flag to true, drop the coded frame, and jump to
// the top of the loop to start processing the next coded frame.
// 9. If frame end timestamp is greater than appendWindowEnd, then set the
// need random access point flag to true, drop the coded frame, and jump to
// the top of the loop to start processing the next coded frame.
if (!mAppendWindow.ContainsStrict(frameStartAndEnd)) {
// Calculate the intersection using the same denominator as will be used
// for the sample time and duration so that a truncated sample is
// collected only if its truncated duration would be non-zero.
TimeInterval appendWindow(
TimeUnit::FromSecondsWithBaseOf(mAppendWindow.mStart, sampleTime),
TimeUnit::FromSecondsWithBaseOf(mAppendWindow.mEnd, sampleTime));
if (appendWindow.IntersectsStrict(sampleInterval)) {
// 8. Note: Some implementations MAY choose to collect some of these
// coded frames with presentation timestamp less than
// appendWindowStart and use them to generate a splice at the first
// coded frame that has a presentation timestamp greater than or
// equal to appendWindowStart even if that frame is not a random
// access point. Supporting this requires multiple decoders or faster
// than real-time decoding so for now this behavior will not be a
// normative requirement.
// 9. Note: Some implementations MAY choose to collect coded frames with
// presentation timestamp less than appendWindowEnd and frame end
// timestamp greater than appendWindowEnd and use them to generate a
// splice across the portion of the collected coded frames within the
// append window at time of collection, and the beginning portion of
// later processed frames which only partially overlap the end of the
// collected coded frames. Supporting this requires multiple decoders
// or faster than real-time decoding so for now this behavior will
// not be a normative requirement. In conjunction with collecting
// coded frames that span appendWindowStart, implementations MAY thus
// support gapless audio splicing.
TimeInterval intersection = appendWindow.Intersection(sampleInterval);
sample->mOriginalPresentationWindow = Some(sampleInterval);
MSE_DEBUGV("will truncate frame from [%" PRId64 "%s,%" PRId64
"%s] to [%" PRId64 "%s,%" PRId64 "%s]",
sampleInterval.mStart.ToMicroseconds(),
sampleInterval.mStart.ToString().get(),
sampleInterval.mEnd.ToMicroseconds(),
sampleInterval.mEnd.ToString().get(),
intersection.mStart.ToMicroseconds(),
intersection.mStart.ToString().get(),
intersection.mEnd.ToMicroseconds(),
intersection.mEnd.ToString().get());
sampleInterval = intersection;
} else {
sample->mOriginalPresentationWindow = Some(sampleInterval);
sample->mTimecode = decodeTimestamp;
previouslyDroppedSample = sample;
MSE_DEBUGV("frame [%" PRId64 "%s,%" PRId64
"%s] outside appendWindow [%f.6%s,%f.6%s] dropping",
sampleInterval.mStart.ToMicroseconds(),
sampleInterval.mStart.ToString().get(),
sampleInterval.mEnd.ToMicroseconds(),
sampleInterval.mEnd.ToString().get(), mAppendWindow.mStart,
appendWindow.mStart.ToString().get(), mAppendWindow.mEnd,
appendWindow.mEnd.ToString().get());
if (samples.Length()) {
// We are creating a discontinuity in the samples.
// Insert the samples processed so far.
InsertFrames(samples, samplesRange, trackBuffer);
samples.Clear();
samplesRange = TimeIntervals();
trackBuffer.mSizeBuffer += sizeNewSamples;
sizeNewSamples = 0;
UpdateHighestTimestamp(trackBuffer, highestSampleTime);
}
trackBuffer.mNeedRandomAccessPoint = true;
needDiscontinuityCheck = true;
continue;
}
}
if (previouslyDroppedSample) {
MSE_DEBUGV("Adding silent frame");
// This "silent" sample will be added so that it starts exactly before the
// first usable one. The duration of the actual sample will be adjusted so
// that the total duration stay the same. This sample will be dropped
// after decoding by the AudioTrimmer (if audio).
TimeInterval previouslyDroppedSampleInterval =
TimeInterval(sampleInterval.mStart, sampleInterval.mStart);
addToSamples(previouslyDroppedSample, previouslyDroppedSampleInterval);
previouslyDroppedSample = nullptr;
sampleInterval.mStart += previouslyDroppedSampleInterval.Length();
}
sample->mTimecode = decodeTimestamp;
addToSamples(sample, sampleInterval);
// Steps 11,12,13,14, 15 and 16 will be done in one block in InsertFrames.
trackBuffer.mLongestFrameDuration =
trackBuffer.mLastFrameDuration.isSome()
? sample->mKeyframe
? sampleDuration
: std::max(sampleDuration, trackBuffer.mLongestFrameDuration)
: sampleDuration;
// 17. Set last decode timestamp for track buffer to decode timestamp.
trackBuffer.mLastDecodeTimestamp = Some(decodeTimestamp);
// 18. Set last frame duration for track buffer to frame duration.
trackBuffer.mLastFrameDuration = Some(sampleDuration);
// 19. If highest end timestamp for track buffer is unset or frame end
// timestamp is greater than highest end timestamp, then set highest end
// timestamp for track buffer to frame end timestamp.
if (trackBuffer.mHighestEndTimestamp.isNothing() ||
sampleInterval.mEnd > trackBuffer.mHighestEndTimestamp.ref()) {
trackBuffer.mHighestEndTimestamp = Some(sampleInterval.mEnd);
}
if (sampleInterval.mStart > highestSampleTime) {
highestSampleTime = sampleInterval.mStart;
}
// 20. If frame end timestamp is greater than group end timestamp, then set
// group end timestamp equal to frame end timestamp.
if (sampleInterval.mEnd > mSourceBufferAttributes->GetGroupEndTimestamp()) {
mSourceBufferAttributes->SetGroupEndTimestamp(sampleInterval.mEnd);
}
// 21. If generate timestamps flag equals true, then set timestampOffset
// equal to frame end timestamp.
if (mSourceBufferAttributes->mGenerateTimestamps) {
mSourceBufferAttributes->SetTimestampOffset(sampleInterval.mEnd);
}
}
if (samples.Length()) {
InsertFrames(samples, samplesRange, trackBuffer);
trackBuffer.mSizeBuffer += sizeNewSamples;
UpdateHighestTimestamp(trackBuffer, highestSampleTime);
}
}
bool TrackBuffersManager::CheckNextInsertionIndex(TrackData& aTrackData,
const TimeUnit& aSampleTime) {
if (aTrackData.mNextInsertionIndex.isSome()) {
return true;
}
const TrackBuffer& data = aTrackData.GetTrackBuffer();
if (data.IsEmpty() || aSampleTime < aTrackData.mBufferedRanges.GetStart()) {
aTrackData.mNextInsertionIndex = Some(0u);
return true;
}
// Find which discontinuity we should insert the frame before.
TimeInterval target;
for (const auto& interval : aTrackData.mBufferedRanges) {
if (aSampleTime < interval.mStart) {
target = interval;
break;
}
}
if (target.IsEmpty()) {
// No target found, it will be added at the end of the track buffer.
aTrackData.mNextInsertionIndex = Some(uint32_t(data.Length()));
return true;
}
// We now need to find the first frame of the searched interval.
// We will insert our new frames right before.
for (uint32_t i = 0; i < data.Length(); i++) {
const RefPtr<MediaRawData>& sample = data[i];
if (sample->mTime >= target.mStart ||
sample->GetEndTime() > target.mStart) {
aTrackData.mNextInsertionIndex = Some(i);
return true;
}
}
NS_ASSERTION(false, "Insertion Index Not Found");
return false;
}
void TrackBuffersManager::InsertFrames(TrackBuffer& aSamples,
const TimeIntervals& aIntervals,
TrackData& aTrackData) {
AUTO_PROFILER_LABEL("TrackBuffersManager::InsertFrames", MEDIA_PLAYBACK);
// 5. Let track buffer equal the track buffer that the coded frame will be
// added to.
auto& trackBuffer = aTrackData;
MSE_DEBUGV("Processing %zu %s frames(start:%" PRId64 " end:%" PRId64 ")",
aSamples.Length(), aTrackData.mInfo->mMimeType.get(),
aIntervals.GetStart().ToMicroseconds(),
aIntervals.GetEnd().ToMicroseconds());
PROFILER_MARKER_FMT("InsertFrames", MEDIA_PLAYBACK, {},
"Processing {} {}frames(start:{} end:{})",
aSamples.Length(), aTrackData.mInfo->mMimeType.get(),
aIntervals.GetStart().ToMicroseconds(),
aIntervals.GetEnd().ToMicroseconds());
// 11. Let spliced audio frame be an unset variable for holding audio splice
// information
// 12. Let spliced timed text frame be an unset variable for holding timed
// text splice information
// 13. If last decode timestamp for track buffer is unset and presentation
// timestamp falls within the presentation interval of a coded frame in track
// buffer,then run the following steps: For now we only handle replacing
// existing frames with the new ones. So we skip this step.
// 14. Remove existing coded frames in track buffer:
// a) If highest end timestamp for track buffer is not set:
// Remove all coded frames from track buffer that have a presentation
// timestamp greater than or equal to presentation timestamp and less
// than frame end timestamp.
// b) If highest end timestamp for track buffer is set and less than or
// equal to presentation timestamp:
// Remove all coded frames from track buffer that have a presentation
// timestamp greater than or equal to highest end timestamp and less than
// frame end timestamp
// There is an ambiguity on how to remove frames, which was lodged with:
// https://www.w3.org/Bugs/Public/show_bug.cgi?id=28710, implementing as per
// bug description.
// 15. Remove decoding dependencies of the coded frames removed in the
// previous step: Remove all coded frames between the coded frames removed in
// the previous step and the next random access point after those removed
// frames.
if (trackBuffer.mBufferedRanges.IntersectsStrict(aIntervals)) {
if (aSamples[0]->mKeyframe &&
(mType.Type() == MEDIAMIMETYPE("video/webm") ||
mType.Type() == MEDIAMIMETYPE("audio/webm"))) {
// We are starting a new GOP, we do not have to worry about breaking an
// existing current coded frame group. Reset the next insertion index
// so the search for when to start our frames removal can be exhaustive.
// This is a workaround for bug 1276184 and only until either bug 1277733
// or bug 1209386 is fixed.
// With the webm container, we can't always properly determine the
// duration of the last frame, which may cause the last frame of a cluster
// to overlap the following frame.
trackBuffer.mNextInsertionIndex.reset();
}
uint32_t index = RemoveFrames(aIntervals, trackBuffer,
trackBuffer.mNextInsertionIndex.refOr(0),
RemovalMode::kTruncateFrame);
if (index) {
trackBuffer.mNextInsertionIndex = Some(index);
}
}
// 16. Add the coded frame with the presentation timestamp, decode timestamp,
// and frame duration to the track buffer.
if (!CheckNextInsertionIndex(aTrackData, aSamples[0]->mTime)) {
RejectProcessing(NS_ERROR_FAILURE, __func__);
return;
}
// Adjust our demuxing index if necessary.
if (trackBuffer.mNextGetSampleIndex.isSome()) {
if (trackBuffer.mNextInsertionIndex.ref() ==
trackBuffer.mNextGetSampleIndex.ref() &&
aIntervals.GetEnd() >= trackBuffer.mNextSampleTime) {
MSE_DEBUG("Next sample to be played got overwritten");
trackBuffer.mNextGetSampleIndex.reset();
ResetEvictionIndex(trackBuffer);
} else if (trackBuffer.mNextInsertionIndex.ref() <=
trackBuffer.mNextGetSampleIndex.ref()) {
trackBuffer.mNextGetSampleIndex.ref() += aSamples.Length();
// We could adjust the eviction index so that the new data gets added to
// the evictable amount (as it is prior currentTime). However, considering
// new data is being added prior the current playback, it's likely that
// this data will be played next, and as such we probably don't want to
// have it evicted too early. So instead reset the eviction index instead.
ResetEvictionIndex(trackBuffer);
}
}
TrackBuffer& data = trackBuffer.GetTrackBuffer();
data.InsertElementsAt(trackBuffer.mNextInsertionIndex.ref(), aSamples);
trackBuffer.mNextInsertionIndex.ref() += aSamples.Length();
// Update our buffered range with new sample interval.
trackBuffer.mBufferedRanges += aIntervals;
MSE_DEBUG("Inserted %s frame:%s, buffered-range:%s, mHighestEndTimestamp=%s",
aTrackData.mInfo->mMimeType.get(), DumpTimeRanges(aIntervals).get(),
DumpTimeRanges(trackBuffer.mBufferedRanges).get(),
trackBuffer.mHighestEndTimestamp
? trackBuffer.mHighestEndTimestamp->ToString().get()
: "none");
// We allow a fuzz factor in our interval of half a frame length,
// as fuzz is +/- value, giving an effective leeway of a full frame
// length.
if (!aIntervals.IsEmpty()) {
TimeIntervals range(aIntervals);
range.SetFuzz(trackBuffer.mLongestFrameDuration / 2);
trackBuffer.mSanitizedBufferedRanges += range;
}
}
void TrackBuffersManager::UpdateHighestTimestamp(
TrackData& aTrackData, const media::TimeUnit& aHighestTime) {
if (aHighestTime > aTrackData.mHighestStartTimestamp) {
MutexAutoLock mut(mMutex);
aTrackData.mHighestStartTimestamp = aHighestTime;
}
}
uint32_t TrackBuffersManager::RemoveFrames(const TimeIntervals& aIntervals,
TrackData& aTrackData,
uint32_t aStartIndex,
RemovalMode aMode) {
AUTO_PROFILER_LABEL("TrackBuffersManager::RemoveFrames", MEDIA_PLAYBACK);
TrackBuffer& data = aTrackData.GetTrackBuffer();
Maybe<uint32_t> firstRemovedIndex;
uint32_t lastRemovedIndex = 0;
TimeIntervals intervals =
aIntervals.ToBase(aTrackData.mHighestStartTimestamp);
// We loop from aStartIndex to avoid removing frames that we inserted earlier
// and part of the current coded frame group. This is allows to handle step
// 14 of the coded frame processing algorithm without having to check the
// value of highest end timestamp: "Remove existing coded frames in track
// buffer:
// If highest end timestamp for track buffer is not set:
// Remove all coded frames from track buffer that have a presentation
// timestamp greater than or equal to presentation timestamp and less than
// frame end timestamp.
// If highest end timestamp for track buffer is set and less than or equal to
// presentation timestamp:
// Remove all coded frames from track buffer that have a presentation
// timestamp greater than or equal to highest end timestamp and less than
// frame end timestamp.
TimeUnit intervalsEnd = intervals.GetEnd();
for (uint32_t i = aStartIndex; i < data.Length(); i++) {
RefPtr<MediaRawData>& sample = data[i];
if (intervals.ContainsStrict(sample->mTime)) {
// The start of this existing frame will be overwritten, we drop that
// entire frame.
MSE_DEBUGV("overriding start of frame [%" PRId64 ",%" PRId64
"] with [%" PRId64 ",%" PRId64 "] dropping",
sample->mTime.ToMicroseconds(),
sample->GetEndTime().ToMicroseconds(),
intervals.GetStart().ToMicroseconds(),
intervals.GetEnd().ToMicroseconds());
if (firstRemovedIndex.isNothing()) {
firstRemovedIndex = Some(i);
}
lastRemovedIndex = i;
continue;
}
TimeInterval sampleInterval(sample->mTime, sample->GetEndTime());
if (aMode == RemovalMode::kTruncateFrame &&
intervals.IntersectsStrict(sampleInterval)) {
// The sample to be overwritten is only partially covered.
TimeIntervals intersection =
Intersection(intervals, TimeIntervals(sampleInterval));
bool found = false;
TimeUnit startTime = intersection.GetStart(&found);
MOZ_DIAGNOSTIC_ASSERT(found, "Must intersect with added coded frames");
Unused << found;
// Signal that this frame should be truncated when decoded.
if (!sample->mOriginalPresentationWindow) {
sample->mOriginalPresentationWindow = Some(sampleInterval);
}
MOZ_ASSERT(startTime > sample->mTime);
sample->mDuration = startTime - sample->mTime;
MOZ_DIAGNOSTIC_ASSERT(sample->mDuration.IsValid());
MSE_DEBUGV("partial overwrite of frame [%" PRId64 ",%" PRId64
"] with [%" PRId64 ",%" PRId64
"] trim to "
"[%" PRId64 ",%" PRId64 "]",
sampleInterval.mStart.ToMicroseconds(),
sampleInterval.mEnd.ToMicroseconds(),
intervals.GetStart().ToMicroseconds(),
intervals.GetEnd().ToMicroseconds(),
sample->mTime.ToMicroseconds(),
sample->GetEndTime().ToMicroseconds());
continue;
}
if (sample->mTime >= intervalsEnd) {
// We can break the loop now. All frames up to the next keyframe will be
// removed during the next step.
break;
}
}
if (firstRemovedIndex.isNothing()) {
return 0;
}
// Remove decoding dependencies of the coded frames removed in the previous
// step: Remove all coded frames between the coded frames removed in the
// previous step and the next random access point after those removed frames.
for (uint32_t i = lastRemovedIndex + 1; i < data.Length(); i++) {
const RefPtr<MediaRawData>& sample = data[i];
if (sample->mKeyframe) {
break;
}
lastRemovedIndex = i;
}
uint32_t sizeRemoved = 0;
TimeIntervals removedIntervals;
for (uint32_t i = firstRemovedIndex.ref(); i <= lastRemovedIndex; i++) {
const RefPtr<MediaRawData> sample = data[i];
TimeInterval sampleInterval =
TimeInterval(sample->mTime, sample->GetEndTime());
removedIntervals += sampleInterval;
sizeRemoved += sample->ComputedSizeOfIncludingThis();
}
aTrackData.mSizeBuffer -= sizeRemoved;
nsPrintfCString msg("Removing frames from:%u for %s (frames:%u) ([%f, %f))",
firstRemovedIndex.ref(),
aTrackData.mInfo->mMimeType.get(),
lastRemovedIndex - firstRemovedIndex.ref() + 1,
removedIntervals.GetStart().ToSeconds(),
removedIntervals.GetEnd().ToSeconds());
MSE_DEBUG("%s", msg.get());
if (profiler_thread_is_being_profiled_for_markers()) {
PROFILER_MARKER_TEXT("RemoveFrames", MEDIA_PLAYBACK, {}, msg);
}
if (aTrackData.mNextGetSampleIndex.isSome()) {
if (aTrackData.mNextGetSampleIndex.ref() >= firstRemovedIndex.ref() &&
aTrackData.mNextGetSampleIndex.ref() <= lastRemovedIndex) {
MSE_DEBUG("Next sample to be played got evicted");
aTrackData.mNextGetSampleIndex.reset();
ResetEvictionIndex(aTrackData);
} else if (aTrackData.mNextGetSampleIndex.ref() > lastRemovedIndex) {
uint32_t samplesRemoved = lastRemovedIndex - firstRemovedIndex.ref() + 1;
aTrackData.mNextGetSampleIndex.ref() -= samplesRemoved;
if (aTrackData.mEvictionIndex.mLastIndex > lastRemovedIndex) {
MOZ_DIAGNOSTIC_ASSERT(
aTrackData.mEvictionIndex.mLastIndex >= samplesRemoved &&
aTrackData.mEvictionIndex.mEvictable >= sizeRemoved,
"Invalid eviction index");
MutexAutoLock mut(mMutex);
aTrackData.mEvictionIndex.mLastIndex -= samplesRemoved;
aTrackData.mEvictionIndex.mEvictable -= sizeRemoved;
} else {
ResetEvictionIndex(aTrackData);
}
}
}
if (aTrackData.mNextInsertionIndex.isSome()) {
if (aTrackData.mNextInsertionIndex.ref() > firstRemovedIndex.ref() &&
aTrackData.mNextInsertionIndex.ref() <= lastRemovedIndex + 1) {
aTrackData.ResetAppendState();
MSE_DEBUG("NextInsertionIndex got reset.");
} else if (aTrackData.mNextInsertionIndex.ref() > lastRemovedIndex + 1) {
aTrackData.mNextInsertionIndex.ref() -=
lastRemovedIndex - firstRemovedIndex.ref() + 1;
}
}
// Update our buffered range to exclude the range just removed.
MSE_DEBUG("Removing %s from bufferedRange %s",
DumpTimeRanges(removedIntervals).get(),
DumpTimeRanges(aTrackData.mBufferedRanges).get());
aTrackData.mBufferedRanges -= removedIntervals;
// Update sanitized buffered ranges. As well as subtracting intervals for
// the removed samples, adjacent gaps between samples that were filled in
// through Interval fuzz also need to be removed. Calculate the complete
// gaps left due to frame removal by comparing the remaining buffered
// intervals with the removed intervals, and then subtract these gaps from
// mSanitizedBufferedRanges.
TimeIntervals gaps;
// If the earliest buffered interval was removed then a leading interval will
// be removed from mSanitizedBufferedRanges.
Maybe<TimeUnit> gapStart =
Some(aTrackData.mSanitizedBufferedRanges.GetStart());
for (auto removedInterval = removedIntervals.cbegin(),
bufferedInterval = aTrackData.mBufferedRanges.cbegin();
removedInterval < removedIntervals.cend();) {
if (bufferedInterval == aTrackData.mBufferedRanges.cend()) {
// No more buffered intervals. The rest has been removed.
// gapStart has always been set here, either before the loop or when
// bufferedInterval was incremented.
gaps += TimeInterval(gapStart.value(),
aTrackData.mSanitizedBufferedRanges.GetEnd());
break;
}
if (bufferedInterval->mEnd <= removedInterval->mStart) {
gapStart = Some(bufferedInterval->mEnd);
++bufferedInterval;
continue;
}
MOZ_ASSERT(removedInterval->mEnd <= bufferedInterval->mStart);
// If gapStart is not set then gaps already includes the gap up to
// bufferedInterval.
if (gapStart) {
gaps += TimeInterval(gapStart.value(), bufferedInterval->mStart);
gapStart.reset();
}
++removedInterval;
}
MSE_DEBUG("Removing %s from mSanitizedBufferedRanges %s",
DumpTimeRanges(gaps).get(),
DumpTimeRanges(aTrackData.mSanitizedBufferedRanges).get());
aTrackData.mSanitizedBufferedRanges -= gaps;
data.RemoveElementsAt(firstRemovedIndex.ref(),
lastRemovedIndex - firstRemovedIndex.ref() + 1);
if (removedIntervals.GetEnd() >= aTrackData.mHighestStartTimestamp &&
removedIntervals.GetStart() <= aTrackData.mHighestStartTimestamp) {
// The sample with the highest presentation time got removed.
// Rescan the trackbuffer to determine the new one.
TimeUnit highestStartTime;
for (const auto& sample : data) {
if (sample->mTime > highestStartTime) {
highestStartTime = sample->mTime;
}
}
MutexAutoLock mut(mMutex);
aTrackData.mHighestStartTimestamp = highestStartTime;
}
MSE_DEBUG(
"After removing frames, %s data sz=%zu, highestStartTimestamp=% " PRId64
", bufferedRange=%s, sanitizedBufferedRanges=%s",
aTrackData.mInfo->mMimeType.get(), data.Length(),
aTrackData.mHighestStartTimestamp.ToMicroseconds(),
DumpTimeRanges(aTrackData.mBufferedRanges).get(),
DumpTimeRanges(aTrackData.mSanitizedBufferedRanges).get());
// If all frames are removed, both buffer and buffered range should be empty.
if (data.IsEmpty()) {
MOZ_ASSERT(aTrackData.mBufferedRanges.IsEmpty());
// We still can't figure out why above assertion would fail, so we keep it
// on debug build, and do a workaround for other builds to ensure that
// buffered range should match the data.
if (!aTrackData.mBufferedRanges.IsEmpty()) {
NS_WARNING(
nsPrintfCString("Empty data but has non-empty buffered range %s ?!",
DumpTimeRanges(aTrackData.mBufferedRanges).get())
.get());
aTrackData.mBufferedRanges.Clear();
}
}
if (aTrackData.mBufferedRanges.IsEmpty()) {
TimeIntervals sampleIntervals;
for (const auto& sample : data) {
sampleIntervals += TimeInterval(sample->mTime, sample->GetEndTime());
}
MOZ_ASSERT(sampleIntervals.IsEmpty());
// We still can't figure out why above assertion would fail, so we keep it
// on debug build, and do a workaround for other builds to ensure that
// buffered range should match the data.
if (!sampleIntervals.IsEmpty()) {
NS_WARNING(
nsPrintfCString(
"Empty buffer range but has non-empty sample intervals %s ?!",
DumpTimeRanges(sampleIntervals).get())
.get());
aTrackData.mBufferedRanges += sampleIntervals;
TimeIntervals range(sampleIntervals);
range.SetFuzz(aTrackData.mLongestFrameDuration / 2);
aTrackData.mSanitizedBufferedRanges += range;
}
}
return firstRemovedIndex.ref();
}
void TrackBuffersManager::RecreateParser(bool aReuseInitData) {
MOZ_ASSERT(OnTaskQueue());
// Recreate our parser for only the data remaining. This is required
// as it has parsed the entire InputBuffer provided.
// Once the old TrackBuffer/MediaSource implementation is removed
// we can optimize this part. TODO
if (mParser) {
DDUNLINKCHILD(mParser.get());
}
mParser = ContainerParser::CreateForMIMEType(mType);
DDLINKCHILD("parser", mParser.get());
if (aReuseInitData && mInitData) {
MSE_DEBUG("Using existing init data to reset parser");
TimeUnit start, end;
mParser->ParseStartAndEndTimestamps(MediaSpan(mInitData), start, end);
mProcessedInput = mInitData->Length();
} else {
MSE_DEBUG("Resetting parser, not reusing init data");
mProcessedInput = 0;
}
}
nsTArray<TrackBuffersManager::TrackData*> TrackBuffersManager::GetTracksList() {
nsTArray<TrackData*> tracks;
if (HasVideo()) {
tracks.AppendElement(&mVideoTracks);
}
if (HasAudio()) {
tracks.AppendElement(&mAudioTracks);
}
return tracks;
}
nsTArray<const TrackBuffersManager::TrackData*>
TrackBuffersManager::GetTracksList() const {
nsTArray<const TrackData*> tracks;
if (HasVideo()) {
tracks.AppendElement(&mVideoTracks);
}
if (HasAudio()) {
tracks.AppendElement(&mAudioTracks);
}
return tracks;
}
void TrackBuffersManager::SetAppendState(AppendState aAppendState) {
MSE_DEBUG("AppendState changed from %s to %s",
SourceBufferAttributes::EnumValueToString(
mSourceBufferAttributes->GetAppendState()),
SourceBufferAttributes::EnumValueToString(aAppendState));
mSourceBufferAttributes->SetAppendState(aAppendState);
}
MediaInfo TrackBuffersManager::GetMetadata() const {
MutexAutoLock mut(mMutex);
return mInfo;
}
const TimeIntervals& TrackBuffersManager::Buffered(
TrackInfo::TrackType aTrack) const {
MOZ_ASSERT(OnTaskQueue());
return GetTracksData(aTrack).mBufferedRanges;
}
const media::TimeUnit& TrackBuffersManager::HighestStartTime(
TrackInfo::TrackType aTrack) const {
MOZ_ASSERT(OnTaskQueue());
return GetTracksData(aTrack).mHighestStartTimestamp;
}
TimeIntervals TrackBuffersManager::SafeBuffered(
TrackInfo::TrackType aTrack) const {
MutexAutoLock mut(mMutex);
return aTrack == TrackInfo::kVideoTrack ? mVideoBufferedRanges
: mAudioBufferedRanges;
}
TimeUnit TrackBuffersManager::HighestStartTime() const {
MutexAutoLock mut(mMutex);
TimeUnit highestStartTime;
for (auto& track : GetTracksList()) {
highestStartTime =
std::max(track->mHighestStartTimestamp, highestStartTime);
}
return highestStartTime;
}
TimeUnit TrackBuffersManager::HighestEndTime() const {
MutexAutoLock mut(mMutex);
nsTArray<const TimeIntervals*> tracks;
if (HasVideo()) {
tracks.AppendElement(&mVideoBufferedRanges);
}
if (HasAudio()) {
tracks.AppendElement(&mAudioBufferedRanges);
}
return HighestEndTime(tracks);
}
TimeUnit TrackBuffersManager::HighestEndTime(
nsTArray<const TimeIntervals*>& aTracks) const {
mMutex.AssertCurrentThreadOwns();
TimeUnit highestEndTime;
for (const auto& trackRanges : aTracks) {
highestEndTime = std::max(trackRanges->GetEnd(), highestEndTime);
}
return highestEndTime;
}
void TrackBuffersManager::ResetEvictionIndex(TrackData& aTrackData) {
MutexAutoLock mut(mMutex);
MSE_DEBUG("ResetEvictionIndex for %s", aTrackData.mInfo->mMimeType.get());
aTrackData.mEvictionIndex.Reset();
}
void TrackBuffersManager::UpdateEvictionIndex(TrackData& aTrackData,
uint32_t currentIndex) {
uint32_t evictable = 0;
TrackBuffer& data = aTrackData.GetTrackBuffer();
MOZ_DIAGNOSTIC_ASSERT(currentIndex >= aTrackData.mEvictionIndex.mLastIndex,
"Invalid call");
MOZ_DIAGNOSTIC_ASSERT(
currentIndex == data.Length() || data[currentIndex]->mKeyframe,
"Must stop at keyframe");
for (uint32_t i = aTrackData.mEvictionIndex.mLastIndex; i < currentIndex;
i++) {
evictable += data[i]->ComputedSizeOfIncludingThis();
}
aTrackData.mEvictionIndex.mLastIndex = currentIndex;
MutexAutoLock mut(mMutex);
aTrackData.mEvictionIndex.mEvictable += evictable;
MSE_DEBUG("UpdateEvictionIndex for %s (idx=%u, evictable=%u)",
aTrackData.mInfo->mMimeType.get(),
aTrackData.mEvictionIndex.mLastIndex,
aTrackData.mEvictionIndex.mEvictable);
}
const TrackBuffersManager::TrackBuffer& TrackBuffersManager::GetTrackBuffer(
TrackInfo::TrackType aTrack) const {
MOZ_ASSERT(OnTaskQueue());
return GetTracksData(aTrack).GetTrackBuffer();
}
uint32_t TrackBuffersManager::FindSampleIndex(const TrackBuffer& aTrackBuffer,
const TimeInterval& aInterval) {
TimeUnit target = aInterval.mStart - aInterval.mFuzz;
for (uint32_t i = 0; i < aTrackBuffer.Length(); i++) {
const RefPtr<MediaRawData>& sample = aTrackBuffer[i];
if (sample->mTime >= target || sample->GetEndTime() > target) {
return i;
}
}
MOZ_ASSERT(false, "FindSampleIndex called with invalid arguments");
return 0;
}
TimeUnit TrackBuffersManager::Seek(TrackInfo::TrackType aTrack,
const TimeUnit& aTime,
const TimeUnit& aFuzz) {
MOZ_ASSERT(OnTaskQueue());
AUTO_PROFILER_LABEL("TrackBuffersManager::Seek", MEDIA_PLAYBACK);
auto& trackBuffer = GetTracksData(aTrack);
const TrackBuffersManager::TrackBuffer& track = GetTrackBuffer(aTrack);
MSE_DEBUG("Seek, track=%s, target=%" PRId64, TrackTypeToStr(aTrack),
aTime.ToMicroseconds());
if (!track.Length()) {
// This a reset. It will be followed by another valid seek.
trackBuffer.mNextGetSampleIndex = Some(uint32_t(0));
trackBuffer.mNextSampleTimecode = TimeUnit();
trackBuffer.mNextSampleTime = TimeUnit();
ResetEvictionIndex(trackBuffer);
return TimeUnit();
}
uint32_t i = 0;
if (aTime != TimeUnit()) {
// Determine the interval of samples we're attempting to seek to.
TimeIntervals buffered = trackBuffer.mBufferedRanges;
// Fuzz factor is +/- aFuzz; as we want to only eliminate gaps
// that are less than aFuzz wide, we set a fuzz factor aFuzz/2.
buffered.SetFuzz(aFuzz / 2);
TimeIntervals::IndexType index = buffered.Find(aTime);
MOZ_ASSERT(index != TimeIntervals::NoIndex,
"We shouldn't be called if aTime isn't buffered");
TimeInterval target = buffered[index];
target.mFuzz = aFuzz;
i = FindSampleIndex(track, target);
}
Maybe<TimeUnit> lastKeyFrameTime;
TimeUnit lastKeyFrameTimecode;
uint32_t lastKeyFrameIndex = 0;
for (; i < track.Length(); i++) {
const RefPtr<MediaRawData>& sample = track[i];
TimeUnit sampleTime = sample->mTime;
if (sampleTime > aTime && lastKeyFrameTime.isSome()) {
break;
}
if (sample->mKeyframe) {
lastKeyFrameTimecode = sample->mTimecode;
lastKeyFrameTime = Some(sampleTime);
lastKeyFrameIndex = i;
}
if (sampleTime == aTime ||
(sampleTime > aTime && lastKeyFrameTime.isSome())) {
break;
}
}
MSE_DEBUG("Keyframe %s found at %" PRId64 " @ %u",
lastKeyFrameTime.isSome() ? "" : "not",
lastKeyFrameTime.refOr(TimeUnit()).ToMicroseconds(),
lastKeyFrameIndex);
trackBuffer.mNextGetSampleIndex = Some(lastKeyFrameIndex);
trackBuffer.mNextSampleTimecode = lastKeyFrameTimecode;
trackBuffer.mNextSampleTime = lastKeyFrameTime.refOr(TimeUnit());
ResetEvictionIndex(trackBuffer);
UpdateEvictionIndex(trackBuffer, lastKeyFrameIndex);
return lastKeyFrameTime.refOr(TimeUnit());
}
uint32_t TrackBuffersManager::SkipToNextRandomAccessPoint(
TrackInfo::TrackType aTrack, const TimeUnit& aTimeThreadshold,
const media::TimeUnit& aFuzz, bool& aFound) {
mTaskQueueCapability->AssertOnCurrentThread();
AUTO_PROFILER_LABEL("TrackBuffersManager::SkipToNextRandomAccessPoint",
MEDIA_PLAYBACK);
uint32_t parsed = 0;
auto& trackData = GetTracksData(aTrack);
const TrackBuffer& track = GetTrackBuffer(aTrack);
aFound = false;
// SkipToNextRandomAccessPoint can only be called if aTimeThreadshold is known
// to be buffered.
if (NS_FAILED(SetNextGetSampleIndexIfNeeded(aTrack, aFuzz))) {
return 0;
}
TimeUnit nextSampleTimecode = trackData.mNextSampleTimecode;
TimeUnit nextSampleTime = trackData.mNextSampleTime;
uint32_t i = trackData.mNextGetSampleIndex.ref();
uint32_t originalPos = i;
for (; i < track.Length(); i++) {
const MediaRawData* sample =
GetSample(aTrack, i, nextSampleTimecode, nextSampleTime, aFuzz);
if (!sample) {
break;
}
if (sample->mKeyframe && sample->mTime >= aTimeThreadshold) {
aFound = true;
break;
}
nextSampleTimecode = sample->GetEndTimecode();
nextSampleTime = sample->GetEndTime();
parsed++;
}
// Adjust the next demux time and index so that the next call to
// SkipToNextRandomAccessPoint will not count again the parsed sample as
// skipped.
if (aFound) {
trackData.mNextSampleTimecode = track[i]->mTimecode;
trackData.mNextSampleTime = track[i]->mTime;
trackData.mNextGetSampleIndex = Some(i);
} else if (i > 0) {
// Go back to the previous keyframe or the original position so the next
// demux can succeed and be decoded.
for (uint32_t j = i; j-- > originalPos;) {
const RefPtr<MediaRawData>& sample = track[j];
if (sample->mKeyframe) {
trackData.mNextSampleTimecode = sample->mTimecode;
trackData.mNextSampleTime = sample->mTime;
trackData.mNextGetSampleIndex = Some(uint32_t(j));
// We are unable to skip to a keyframe past aTimeThreshold, however
// we are speeding up decoding by dropping the unplayable frames.
// So we can mark aFound as true.
aFound = true;
break;
}
parsed--;
}
}
if (aFound) {
UpdateEvictionIndex(trackData, trackData.mNextGetSampleIndex.ref());
}
return parsed;
}
const MediaRawData* TrackBuffersManager::GetSample(TrackInfo::TrackType aTrack,
uint32_t aIndex,
const TimeUnit& aExpectedDts,
const TimeUnit& aExpectedPts,
const TimeUnit& aFuzz) {
MOZ_ASSERT(OnTaskQueue());
const TrackBuffer& track = GetTrackBuffer(aTrack);
if (aIndex >= track.Length()) {
MSE_DEBUGV(
"Can't get sample due to reaching to the end, index=%u, "
"length=%zu",
aIndex, track.Length());
// reached the end.
return nullptr;
}
if (!(aExpectedDts + aFuzz).IsValid() || !(aExpectedPts + aFuzz).IsValid()) {
// Time overflow, it seems like we also reached the end.
MSE_DEBUGV("Can't get sample due to time overflow, expectedPts=%" PRId64
", aExpectedDts=%" PRId64 ", fuzz=%" PRId64,
aExpectedPts.ToMicroseconds(), aExpectedPts.ToMicroseconds(),
aFuzz.ToMicroseconds());
return nullptr;
}
const RefPtr<MediaRawData>& sample = track[aIndex];
if (!aIndex || sample->mTimecode <= aExpectedDts + aFuzz ||
sample->mTime <= aExpectedPts + aFuzz) {
MOZ_DIAGNOSTIC_ASSERT(sample->HasValidTime());
return sample;
}
MSE_DEBUGV("Can't get sample due to big gap, sample=%" PRId64
", expectedPts=%" PRId64 ", aExpectedDts=%" PRId64
", fuzz=%" PRId64,
sample->mTime.ToMicroseconds(), aExpectedPts.ToMicroseconds(),
aExpectedPts.ToMicroseconds(), aFuzz.ToMicroseconds());
// Gap is too big. End of Stream or Waiting for Data.
// TODO, check that we have continuous data based on the sanitized buffered
// range instead.
return nullptr;
}
already_AddRefed<MediaRawData> TrackBuffersManager::GetSample(
TrackInfo::TrackType aTrack, const TimeUnit& aFuzz, MediaResult& aResult) {
mTaskQueueCapability->AssertOnCurrentThread();
AUTO_PROFILER_LABEL("TrackBuffersManager::GetSample", MEDIA_PLAYBACK);
auto& trackData = GetTracksData(aTrack);
const TrackBuffer& track = GetTrackBuffer(aTrack);
aResult = NS_ERROR_DOM_MEDIA_WAITING_FOR_DATA;
if (trackData.mNextGetSampleIndex.isSome()) {
if (trackData.mNextGetSampleIndex.ref() >= track.Length()) {
aResult = NS_ERROR_DOM_MEDIA_END_OF_STREAM;
return nullptr;
}
const MediaRawData* sample = GetSample(
aTrack, trackData.mNextGetSampleIndex.ref(),
trackData.mNextSampleTimecode, trackData.mNextSampleTime, aFuzz);
if (!sample) {
return nullptr;
}
RefPtr<MediaRawData> p = sample->Clone();
if (!p) {
aResult = MediaResult(NS_ERROR_OUT_OF_MEMORY, __func__);
return nullptr;
}
if (p->mKeyframe) {
UpdateEvictionIndex(trackData, trackData.mNextGetSampleIndex.ref());
}
trackData.mNextGetSampleIndex.ref()++;
// Estimate decode timestamp and timestamp of the next sample.
TimeUnit nextSampleTimecode = sample->GetEndTimecode();
TimeUnit nextSampleTime = sample->GetEndTime();
const MediaRawData* nextSample =
GetSample(aTrack, trackData.mNextGetSampleIndex.ref(),
nextSampleTimecode, nextSampleTime, aFuzz);
if (nextSample) {
// We have a valid next sample, can use exact values.
trackData.mNextSampleTimecode = nextSample->mTimecode;
trackData.mNextSampleTime = nextSample->mTime;
} else {
// Next sample isn't available yet. Use estimates.
trackData.mNextSampleTimecode = nextSampleTimecode;
trackData.mNextSampleTime = nextSampleTime;
}
aResult = NS_OK;
return p.forget();
}
aResult = SetNextGetSampleIndexIfNeeded(aTrack, aFuzz);
if (NS_FAILED(aResult)) {
return nullptr;
}
MOZ_RELEASE_ASSERT(trackData.mNextGetSampleIndex.isSome() &&
trackData.mNextGetSampleIndex.ref() < track.Length());
const RefPtr<MediaRawData>& sample =
track[trackData.mNextGetSampleIndex.ref()];
RefPtr<MediaRawData> p = sample->Clone();
if (!p) {
// OOM
aResult = MediaResult(NS_ERROR_OUT_OF_MEMORY, __func__);
return nullptr;
}
MOZ_DIAGNOSTIC_ASSERT(p->HasValidTime());
// Find the previous keyframe to calculate the evictable amount.
uint32_t i = trackData.mNextGetSampleIndex.ref();
for (; !track[i]->mKeyframe; i--) {
}
UpdateEvictionIndex(trackData, i);
trackData.mNextGetSampleIndex.ref()++;
trackData.mNextSampleTimecode = sample->GetEndTimecode();
trackData.mNextSampleTime = sample->GetEndTime();
return p.forget();
}
int32_t TrackBuffersManager::FindCurrentPosition(TrackInfo::TrackType aTrack,
const TimeUnit& aFuzz) const {
MOZ_ASSERT(OnTaskQueue());
const auto& trackData = GetTracksData(aTrack);
const TrackBuffer& track = GetTrackBuffer(aTrack);
int32_t trackLength = AssertedCast<int32_t>(track.Length());
// Perform an exact search first.
for (int32_t i = 0; i < trackLength; i++) {
const RefPtr<MediaRawData>& sample = track[i];
TimeInterval sampleInterval{sample->mTimecode, sample->GetEndTimecode()};
if (sampleInterval.ContainsStrict(trackData.mNextSampleTimecode)) {
return i;
}
if (sampleInterval.mStart > trackData.mNextSampleTimecode) {
// Samples are ordered by timecode. There's no need to search
// any further.
break;
}
}
for (int32_t i = 0; i < trackLength; i++) {
const RefPtr<MediaRawData>& sample = track[i];
TimeInterval sampleInterval{sample->mTimecode, sample->GetEndTimecode(),
aFuzz};
if (sampleInterval.ContainsWithStrictEnd(trackData.mNextSampleTimecode)) {
return i;
}
if (sampleInterval.mStart - aFuzz > trackData.mNextSampleTimecode) {
// Samples are ordered by timecode. There's no need to search
// any further.
break;
}
}
// We couldn't find our sample by decode timestamp. Attempt to find it using
// presentation timestamp. There will likely be small jerkiness.
for (int32_t i = 0; i < trackLength; i++) {
const RefPtr<MediaRawData>& sample = track[i];
TimeInterval sampleInterval{sample->mTime, sample->GetEndTime(), aFuzz};
if (sampleInterval.ContainsWithStrictEnd(trackData.mNextSampleTimecode)) {
return i;
}
}
// Still not found.
return -1;
}
uint32_t TrackBuffersManager::Evictable(TrackInfo::TrackType aTrack) const {
MutexAutoLock mut(mMutex);
return GetTracksData(aTrack).mEvictionIndex.mEvictable;
}
TimeUnit TrackBuffersManager::GetNextRandomAccessPoint(
TrackInfo::TrackType aTrack, const TimeUnit& aFuzz) {
mTaskQueueCapability->AssertOnCurrentThread();
// So first determine the current position in the track buffer if necessary.
if (NS_FAILED(SetNextGetSampleIndexIfNeeded(aTrack, aFuzz))) {
return TimeUnit::FromInfinity();
}
auto& trackData = GetTracksData(aTrack);
const TrackBuffersManager::TrackBuffer& track = GetTrackBuffer(aTrack);
uint32_t i = trackData.mNextGetSampleIndex.ref();
TimeUnit nextSampleTimecode = trackData.mNextSampleTimecode;
TimeUnit nextSampleTime = trackData.mNextSampleTime;
for (; i < track.Length(); i++) {
const MediaRawData* sample =
GetSample(aTrack, i, nextSampleTimecode, nextSampleTime, aFuzz);
if (!sample) {
break;
}
if (sample->mKeyframe) {
return sample->mTime;
}
nextSampleTimecode = sample->GetEndTimecode();
nextSampleTime = sample->GetEndTime();
}
return TimeUnit::FromInfinity();
}
nsresult TrackBuffersManager::SetNextGetSampleIndexIfNeeded(
TrackInfo::TrackType aTrack, const TimeUnit& aFuzz) {
MOZ_ASSERT(OnTaskQueue());
auto& trackData = GetTracksData(aTrack);
const TrackBuffer& track = GetTrackBuffer(aTrack);
if (trackData.mNextGetSampleIndex.isSome()) {
// We already know the next GetSample index.
return NS_OK;
}
if (!track.Length()) {
// There's nothing to find yet.
return NS_ERROR_DOM_MEDIA_END_OF_STREAM;
}
if (trackData.mNextSampleTimecode == TimeUnit()) {
// First demux, get first sample.
trackData.mNextGetSampleIndex = Some(0u);
return NS_OK;
}
if (trackData.mNextSampleTimecode > track.LastElement()->GetEndTimecode()) {
// The next element is past our last sample. We're done.
trackData.mNextGetSampleIndex = Some(uint32_t(track.Length()));
return NS_ERROR_DOM_MEDIA_END_OF_STREAM;
}
int32_t pos = FindCurrentPosition(aTrack, aFuzz);
if (pos < 0) {
// Not found, must wait for more data.
MSE_DEBUG("Couldn't find sample (pts:%" PRId64 " dts:%" PRId64 ")",
trackData.mNextSampleTime.ToMicroseconds(),
trackData.mNextSampleTimecode.ToMicroseconds());
return NS_ERROR_DOM_MEDIA_WAITING_FOR_DATA;
}
trackData.mNextGetSampleIndex = Some(uint32_t(pos));
return NS_OK;
}
void TrackBuffersManager::TrackData::AddSizeOfResources(
MediaSourceDecoder::ResourceSizes* aSizes) const {
for (const TrackBuffer& buffer : mBuffers) {
for (const MediaRawData* data : buffer) {
aSizes->mByteSize += data->SizeOfIncludingThis(aSizes->mMallocSizeOf);
}
}
}
RefPtr<GenericPromise> TrackBuffersManager::RequestDebugInfo(
dom::TrackBuffersManagerDebugInfo& aInfo) const {
const RefPtr<TaskQueue> taskQueue = GetTaskQueueSafe();
if (!taskQueue) {
return GenericPromise::CreateAndResolve(true, __func__);
}
if (!taskQueue->IsCurrentThreadIn()) {
// Run the request on the task queue if it's not already.
return InvokeAsync(taskQueue.get(), __func__,
[this, self = RefPtr{this}, &aInfo] {
return RequestDebugInfo(aInfo);
});
}
mTaskQueueCapability->AssertOnCurrentThread();
GetDebugInfo(aInfo);
return GenericPromise::CreateAndResolve(true, __func__);
}
void TrackBuffersManager::GetDebugInfo(
dom::TrackBuffersManagerDebugInfo& aInfo) const {
MOZ_ASSERT(OnTaskQueue(),
"This shouldn't be called off the task queue because we're about "
"to touch a lot of data that is used on the task queue");
CopyUTF8toUTF16(mType.Type().AsString(), aInfo.mType);
if (HasAudio()) {
aInfo.mNextSampleTime = mAudioTracks.mNextSampleTime.ToSeconds();
aInfo.mNumSamples =
AssertedCast<int32_t>(mAudioTracks.mBuffers[0].Length());
aInfo.mBufferSize = AssertedCast<int32_t>(mAudioTracks.mSizeBuffer);
aInfo.mEvictable = AssertedCast<int32_t>(Evictable(TrackInfo::kAudioTrack));
aInfo.mNextGetSampleIndex =
AssertedCast<int32_t>(mAudioTracks.mNextGetSampleIndex.valueOr(-1));
aInfo.mNextInsertionIndex =
AssertedCast<int32_t>(mAudioTracks.mNextInsertionIndex.valueOr(-1));
media::TimeIntervals ranges = SafeBuffered(TrackInfo::kAudioTrack);
dom::Sequence<dom::BufferRange> items;
for (uint32_t i = 0; i < ranges.Length(); ++i) {
// dom::Sequence is a FallibleTArray
dom::BufferRange* range = items.AppendElement(fallible);
if (!range) {
break;
}
range->mStart = ranges.Start(i).ToSeconds();
range->mEnd = ranges.End(i).ToSeconds();
}
aInfo.mRanges = std::move(items);
} else if (HasVideo()) {
aInfo.mNextSampleTime = mVideoTracks.mNextSampleTime.ToSeconds();
aInfo.mNumSamples =
AssertedCast<int32_t>(mVideoTracks.mBuffers[0].Length());
aInfo.mBufferSize = AssertedCast<int32_t>(mVideoTracks.mSizeBuffer);
aInfo.mEvictable = AssertedCast<int32_t>(Evictable(TrackInfo::kVideoTrack));
aInfo.mNextGetSampleIndex =
AssertedCast<int32_t>(mVideoTracks.mNextGetSampleIndex.valueOr(-1));
aInfo.mNextInsertionIndex =
AssertedCast<int32_t>(mVideoTracks.mNextInsertionIndex.valueOr(-1));
media::TimeIntervals ranges = SafeBuffered(TrackInfo::kVideoTrack);
dom::Sequence<dom::BufferRange> items;
for (uint32_t i = 0; i < ranges.Length(); ++i) {
// dom::Sequence is a FallibleTArray
dom::BufferRange* range = items.AppendElement(fallible);
if (!range) {
break;
}
range->mStart = ranges.Start(i).ToSeconds();
range->mEnd = ranges.End(i).ToSeconds();
}
aInfo.mRanges = std::move(items);
}
}
void TrackBuffersManager::AddSizeOfResources(
MediaSourceDecoder::ResourceSizes* aSizes) const {
mTaskQueueCapability->AssertOnCurrentThread();
if (mInputBuffer.isSome() && mInputBuffer->Buffer()) {
// mInputBuffer should be the sole owner of the underlying buffer, so this
// won't double count.
aSizes->mByteSize += mInputBuffer->Buffer()->ShallowSizeOfIncludingThis(
aSizes->mMallocSizeOf);
}
if (mInitData) {
aSizes->mByteSize +=
mInitData->ShallowSizeOfIncludingThis(aSizes->mMallocSizeOf);
}
if (mPendingInputBuffer.isSome() && mPendingInputBuffer->Buffer()) {
// mPendingInputBuffer should be the sole owner of the underlying buffer, so
// this won't double count.
aSizes->mByteSize +=
mPendingInputBuffer->Buffer()->ShallowSizeOfIncludingThis(
aSizes->mMallocSizeOf);
}
mVideoTracks.AddSizeOfResources(aSizes);
mAudioTracks.AddSizeOfResources(aSizes);
}
} // namespace mozilla
#undef MSE_DEBUG
#undef MSE_DEBUGV
#undef SAMPLE_DEBUG
#undef SAMPLE_DEBUGV
Reference in New Issue View Git Blame Copy Permalink