mirror of
https://github.com/mozilla/gecko-dev.git
synced 2025-02-26 12:20:56 +00:00

Differential Revision: https://phabricator.services.mozilla.com/D32792 --HG-- extra : moz-landing-system : lando
347 lines
11 KiB
C++
347 lines
11 KiB
C++
/* -*- 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 "MediaSourceDecoder.h"
|
|
|
|
#include "mozilla/Logging.h"
|
|
#include "MediaDecoderStateMachine.h"
|
|
#include "MediaShutdownManager.h"
|
|
#include "MediaSource.h"
|
|
#include "MediaSourceDemuxer.h"
|
|
#include "MediaSourceUtils.h"
|
|
#include "SourceBuffer.h"
|
|
#include "SourceBufferList.h"
|
|
#include "VideoUtils.h"
|
|
#include <algorithm>
|
|
|
|
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__)
|
|
|
|
using namespace mozilla::media;
|
|
|
|
namespace mozilla {
|
|
|
|
MediaSourceDecoder::MediaSourceDecoder(MediaDecoderInit& aInit)
|
|
: MediaDecoder(aInit), mMediaSource(nullptr), mEnded(false) {
|
|
mExplicitDuration.emplace(UnspecifiedNaN<double>());
|
|
}
|
|
|
|
MediaDecoderStateMachine* MediaSourceDecoder::CreateStateMachine() {
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
mDemuxer = new MediaSourceDemuxer(AbstractMainThread());
|
|
MediaFormatReaderInit init;
|
|
init.mVideoFrameContainer = GetVideoFrameContainer();
|
|
init.mKnowsCompositor = GetCompositor();
|
|
init.mCrashHelper = GetOwner()->CreateGMPCrashHelper();
|
|
init.mFrameStats = mFrameStats;
|
|
init.mMediaDecoderOwnerID = mOwner;
|
|
mReader = new MediaFormatReader(init, mDemuxer);
|
|
return new MediaDecoderStateMachine(this, mReader);
|
|
}
|
|
|
|
nsresult MediaSourceDecoder::Load(nsIPrincipal* aPrincipal) {
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MOZ_ASSERT(!GetStateMachine());
|
|
AbstractThread::AutoEnter context(AbstractMainThread());
|
|
|
|
mPrincipal = aPrincipal;
|
|
|
|
nsresult rv = MediaShutdownManager::Instance().Register(this);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
SetStateMachine(CreateStateMachine());
|
|
if (!GetStateMachine()) {
|
|
NS_WARNING("Failed to create state machine!");
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
rv = GetStateMachine()->Init(this);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
GetStateMachine()->DispatchIsLiveStream(!mEnded);
|
|
SetStateMachineParameters();
|
|
return NS_OK;
|
|
}
|
|
|
|
media::TimeIntervals MediaSourceDecoder::GetSeekable() {
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
AbstractThread::AutoEnter context(AbstractMainThread());
|
|
if (!mMediaSource) {
|
|
NS_WARNING("MediaSource element isn't attached");
|
|
return media::TimeIntervals::Invalid();
|
|
}
|
|
|
|
media::TimeIntervals seekable;
|
|
double duration = mMediaSource->Duration();
|
|
if (IsNaN(duration)) {
|
|
// Return empty range.
|
|
} else if (duration > 0 && mozilla::IsInfinite(duration)) {
|
|
media::TimeIntervals buffered = GetBuffered();
|
|
|
|
// 1. If live seekable range is not empty:
|
|
if (mMediaSource->HasLiveSeekableRange()) {
|
|
// 1. Let union ranges be the union of live seekable range and the
|
|
// HTMLMediaElement.buffered attribute.
|
|
media::TimeIntervals unionRanges =
|
|
buffered + mMediaSource->LiveSeekableRange();
|
|
// 2. Return a single range with a start time equal to the earliest start
|
|
// time in union ranges and an end time equal to the highest end time in
|
|
// union ranges and abort these steps.
|
|
seekable +=
|
|
media::TimeInterval(unionRanges.GetStart(), unionRanges.GetEnd());
|
|
return seekable;
|
|
}
|
|
|
|
if (buffered.Length()) {
|
|
seekable += media::TimeInterval(TimeUnit::Zero(), buffered.GetEnd());
|
|
}
|
|
} else {
|
|
seekable +=
|
|
media::TimeInterval(TimeUnit::Zero(), TimeUnit::FromSeconds(duration));
|
|
}
|
|
MSE_DEBUG("ranges=%s", DumpTimeRanges(seekable).get());
|
|
return seekable;
|
|
}
|
|
|
|
media::TimeIntervals MediaSourceDecoder::GetBuffered() {
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
AbstractThread::AutoEnter context(AbstractMainThread());
|
|
|
|
if (!mMediaSource) {
|
|
NS_WARNING("MediaSource element isn't attached");
|
|
return media::TimeIntervals::Invalid();
|
|
}
|
|
dom::SourceBufferList* sourceBuffers = mMediaSource->ActiveSourceBuffers();
|
|
if (!sourceBuffers) {
|
|
// Media source object is shutting down.
|
|
return TimeIntervals();
|
|
}
|
|
TimeUnit highestEndTime;
|
|
nsTArray<media::TimeIntervals> activeRanges;
|
|
media::TimeIntervals buffered;
|
|
|
|
for (uint32_t i = 0; i < sourceBuffers->Length(); i++) {
|
|
bool found;
|
|
dom::SourceBuffer* sb = sourceBuffers->IndexedGetter(i, found);
|
|
MOZ_ASSERT(found);
|
|
|
|
activeRanges.AppendElement(sb->GetTimeIntervals());
|
|
highestEndTime =
|
|
std::max(highestEndTime, activeRanges.LastElement().GetEnd());
|
|
}
|
|
|
|
buffered += media::TimeInterval(TimeUnit::Zero(), highestEndTime);
|
|
|
|
for (auto& range : activeRanges) {
|
|
if (mEnded && range.Length()) {
|
|
// Set the end time on the last range to highestEndTime by adding a
|
|
// new range spanning the current end time to highestEndTime, which
|
|
// Normalize() will then merge with the old last range.
|
|
range += media::TimeInterval(range.GetEnd(), highestEndTime);
|
|
}
|
|
buffered.Intersection(range);
|
|
}
|
|
|
|
MSE_DEBUG("ranges=%s", DumpTimeRanges(buffered).get());
|
|
return buffered;
|
|
}
|
|
|
|
void MediaSourceDecoder::Shutdown() {
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
AbstractThread::AutoEnter context(AbstractMainThread());
|
|
MSE_DEBUG("Shutdown");
|
|
// Detach first so that TrackBuffers are unused on the main thread when
|
|
// shut down on the decode task queue.
|
|
if (mMediaSource) {
|
|
mMediaSource->Detach();
|
|
}
|
|
mDemuxer = nullptr;
|
|
|
|
MediaDecoder::Shutdown();
|
|
}
|
|
|
|
void MediaSourceDecoder::AttachMediaSource(dom::MediaSource* aMediaSource) {
|
|
MOZ_ASSERT(!mMediaSource && !GetStateMachine() && NS_IsMainThread());
|
|
mMediaSource = aMediaSource;
|
|
DDLINKCHILD("mediasource", aMediaSource);
|
|
}
|
|
|
|
void MediaSourceDecoder::DetachMediaSource() {
|
|
MOZ_ASSERT(mMediaSource && NS_IsMainThread());
|
|
DDUNLINKCHILD(mMediaSource);
|
|
mMediaSource = nullptr;
|
|
}
|
|
|
|
void MediaSourceDecoder::Ended(bool aEnded) {
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
AbstractThread::AutoEnter context(AbstractMainThread());
|
|
if (aEnded) {
|
|
// We want the MediaSourceReader to refresh its buffered range as it may
|
|
// have been modified (end lined up).
|
|
NotifyDataArrived();
|
|
}
|
|
mEnded = aEnded;
|
|
GetStateMachine()->DispatchIsLiveStream(!mEnded);
|
|
}
|
|
|
|
void MediaSourceDecoder::AddSizeOfResources(ResourceSizes* aSizes) {
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
AbstractThread::AutoEnter context(AbstractMainThread());
|
|
if (GetDemuxer()) {
|
|
GetDemuxer()->AddSizeOfResources(aSizes);
|
|
}
|
|
}
|
|
|
|
void MediaSourceDecoder::SetInitialDuration(int64_t aDuration) {
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
AbstractThread::AutoEnter context(AbstractMainThread());
|
|
// Only use the decoded duration if one wasn't already
|
|
// set.
|
|
if (!mMediaSource || !IsNaN(ExplicitDuration())) {
|
|
return;
|
|
}
|
|
double duration = aDuration;
|
|
// A duration of -1 is +Infinity.
|
|
if (aDuration >= 0) {
|
|
duration /= USECS_PER_S;
|
|
}
|
|
SetMediaSourceDuration(duration);
|
|
}
|
|
|
|
void MediaSourceDecoder::SetMediaSourceDuration(double aDuration) {
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
AbstractThread::AutoEnter context(AbstractMainThread());
|
|
MOZ_ASSERT(!IsShutdown());
|
|
if (aDuration >= 0) {
|
|
int64_t checkedDuration;
|
|
if (NS_FAILED(SecondsToUsecs(aDuration, checkedDuration))) {
|
|
// INT64_MAX is used as infinity by the state machine.
|
|
// We want a very bigger number, but not infinity.
|
|
checkedDuration = INT64_MAX - 1;
|
|
}
|
|
SetExplicitDuration(aDuration);
|
|
} else {
|
|
SetExplicitDuration(PositiveInfinity<double>());
|
|
}
|
|
}
|
|
|
|
void MediaSourceDecoder::GetDebugInfo(dom::MediaSourceDecoderDebugInfo& aInfo) {
|
|
if (mReader && mDemuxer) {
|
|
mReader->GetDebugInfo(aInfo.mReader);
|
|
mDemuxer->GetDebugInfo(aInfo.mDemuxer);
|
|
}
|
|
}
|
|
|
|
double MediaSourceDecoder::GetDuration() {
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
AbstractThread::AutoEnter context(AbstractMainThread());
|
|
return ExplicitDuration();
|
|
}
|
|
|
|
MediaDecoderOwner::NextFrameStatus
|
|
MediaSourceDecoder::NextFrameBufferedStatus() {
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
AbstractThread::AutoEnter context(AbstractMainThread());
|
|
|
|
if (!mMediaSource ||
|
|
mMediaSource->ReadyState() == dom::MediaSourceReadyState::Closed) {
|
|
return MediaDecoderOwner::NEXT_FRAME_UNAVAILABLE;
|
|
}
|
|
|
|
// Next frame hasn't been decoded yet.
|
|
// Use the buffered range to consider if we have the next frame available.
|
|
auto currentPosition = CurrentPosition();
|
|
TimeIntervals buffered = GetBuffered();
|
|
buffered.SetFuzz(MediaSourceDemuxer::EOS_FUZZ / 2);
|
|
TimeInterval interval(
|
|
currentPosition, currentPosition + DEFAULT_NEXT_FRAME_AVAILABLE_BUFFERED);
|
|
return buffered.ContainsWithStrictEnd(ClampIntervalToEnd(interval))
|
|
? MediaDecoderOwner::NEXT_FRAME_AVAILABLE
|
|
: MediaDecoderOwner::NEXT_FRAME_UNAVAILABLE;
|
|
}
|
|
|
|
bool MediaSourceDecoder::CanPlayThroughImpl() {
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
AbstractThread::AutoEnter context(AbstractMainThread());
|
|
|
|
if (NextFrameBufferedStatus() == MediaDecoderOwner::NEXT_FRAME_UNAVAILABLE) {
|
|
return false;
|
|
}
|
|
|
|
if (IsNaN(mMediaSource->Duration())) {
|
|
// Don't have any data yet.
|
|
return false;
|
|
}
|
|
TimeUnit duration = TimeUnit::FromSeconds(mMediaSource->Duration());
|
|
auto currentPosition = CurrentPosition();
|
|
if (duration <= currentPosition) {
|
|
return true;
|
|
}
|
|
// If we have data up to the mediasource's duration or 3s ahead, we can
|
|
// assume that we can play without interruption.
|
|
TimeIntervals buffered = GetBuffered();
|
|
buffered.SetFuzz(MediaSourceDemuxer::EOS_FUZZ / 2);
|
|
TimeUnit timeAhead =
|
|
std::min(duration, currentPosition + TimeUnit::FromSeconds(3));
|
|
TimeInterval interval(currentPosition, timeAhead);
|
|
return buffered.ContainsWithStrictEnd(ClampIntervalToEnd(interval));
|
|
}
|
|
|
|
TimeInterval MediaSourceDecoder::ClampIntervalToEnd(
|
|
const TimeInterval& aInterval) {
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
AbstractThread::AutoEnter context(AbstractMainThread());
|
|
|
|
if (!mEnded) {
|
|
return aInterval;
|
|
}
|
|
TimeUnit duration = TimeUnit::FromSeconds(GetDuration());
|
|
if (duration < aInterval.mStart) {
|
|
return aInterval;
|
|
}
|
|
return TimeInterval(aInterval.mStart, std::min(aInterval.mEnd, duration),
|
|
aInterval.mFuzz);
|
|
}
|
|
|
|
void MediaSourceDecoder::NotifyInitDataArrived() {
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
AbstractThread::AutoEnter context(AbstractMainThread());
|
|
|
|
if (mDemuxer) {
|
|
mDemuxer->NotifyInitDataArrived();
|
|
}
|
|
}
|
|
|
|
void MediaSourceDecoder::NotifyDataArrived() {
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MOZ_DIAGNOSTIC_ASSERT(!IsShutdown());
|
|
AbstractThread::AutoEnter context(AbstractMainThread());
|
|
NotifyReaderDataArrived();
|
|
GetOwner()->DownloadProgressed();
|
|
}
|
|
|
|
already_AddRefed<nsIPrincipal> MediaSourceDecoder::GetCurrentPrincipal() {
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
return do_AddRef(mPrincipal);
|
|
}
|
|
|
|
bool MediaSourceDecoder::HadCrossOriginRedirects() {
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
return false;
|
|
}
|
|
|
|
#undef MSE_DEBUG
|
|
#undef MSE_DEBUGV
|
|
|
|
} // namespace mozilla
|