#include "config.h"
#include "SourceBuffer.h"
#if ENABLE(MEDIA_SOURCE)
#include "AudioTrackList.h"
#include "Event.h"
#include "EventNames.h"
#include "ExceptionCodePlaceholder.h"
#include "GenericEventQueue.h"
#include "HTMLMediaElement.h"
#include "InbandTextTrack.h"
#include "Logging.h"
#include "MediaDescription.h"
#include "MediaSample.h"
#include "MediaSource.h"
#include "SampleMap.h"
#include "SourceBufferPrivate.h"
#include "TextTrackList.h"
#include "TimeRanges.h"
#include "VideoTrackList.h"
#include <limits>
#include <map>
#include <runtime/JSCInlines.h>
#include <runtime/JSLock.h>
#include <runtime/VM.h>
#include <wtf/CurrentTime.h>
#include <wtf/NeverDestroyed.h>
#if !LOG_DISABLED
#include <wtf/text/StringBuilder.h>
#endif
namespace WebCore {
static const double ExponentialMovingAverageCoefficient = 0.1;
static const MediaTime& currentTimeFudgeFactor()
{
static NeverDestroyed<MediaTime> fudgeFactor(2002, 24000);
return fudgeFactor;
}
struct SourceBuffer::TrackBuffer {
MediaTime lastDecodeTimestamp;
MediaTime lastFrameDuration;
MediaTime highestPresentationTimestamp;
MediaTime lastEnqueuedPresentationTime;
MediaTime lastEnqueuedDecodeEndTime;
bool needRandomAccessFlag { true };
bool enabled { false };
bool needsReenqueueing { false };
SampleMap samples;
DecodeOrderSampleMap::MapType decodeQueue;
RefPtr<MediaDescription> description;
TrackBuffer()
: lastDecodeTimestamp(MediaTime::invalidTime())
, lastFrameDuration(MediaTime::invalidTime())
, highestPresentationTimestamp(MediaTime::invalidTime())
, lastEnqueuedPresentationTime(MediaTime::invalidTime())
, lastEnqueuedDecodeEndTime(MediaTime::invalidTime())
{
}
};
Ref<SourceBuffer> SourceBuffer::create(Ref<SourceBufferPrivate>&& sourceBufferPrivate, MediaSource* source)
{
auto sourceBuffer = adoptRef(*new SourceBuffer(WTFMove(sourceBufferPrivate), source));
sourceBuffer->suspendIfNeeded();
return sourceBuffer;
}
SourceBuffer::SourceBuffer(Ref<SourceBufferPrivate>&& sourceBufferPrivate, MediaSource* source)
: ActiveDOMObject(source->scriptExecutionContext())
, m_private(WTFMove(sourceBufferPrivate))
, m_source(source)
, m_asyncEventQueue(*this)
, m_appendBufferTimer(*this, &SourceBuffer::appendBufferTimerFired)
, m_appendWindowStart(MediaTime::zeroTime())
, m_appendWindowEnd(MediaTime::positiveInfiniteTime())
, m_groupStartTimestamp(MediaTime::invalidTime())
, m_groupEndTimestamp(MediaTime::zeroTime())
, m_buffered(TimeRanges::create())
, m_appendState(WaitingForSegment)
, m_timeOfBufferingMonitor(monotonicallyIncreasingTime())
, m_pendingRemoveStart(MediaTime::invalidTime())
, m_pendingRemoveEnd(MediaTime::invalidTime())
, m_removeTimer(*this, &SourceBuffer::removeTimerFired)
{
ASSERT(m_source);
m_private->setClient(this);
}
SourceBuffer::~SourceBuffer()
{
ASSERT(isRemoved());
m_private->setClient(nullptr);
}
RefPtr<TimeRanges> SourceBuffer::buffered(ExceptionCode& ec) const
{
if (isRemoved()) {
ec = INVALID_STATE_ERR;
return nullptr;
}
return m_buffered->copy();
}
const RefPtr<TimeRanges>& SourceBuffer::buffered() const
{
return m_buffered;
}
double SourceBuffer::timestampOffset() const
{
return m_timestampOffset.toDouble();
}
void SourceBuffer::setTimestampOffset(double offset, ExceptionCode& ec)
{
if (isRemoved() || m_updating) {
ec = INVALID_STATE_ERR;
return;
}
m_source->openIfInEndedState();
if (m_appendState == ParsingMediaSegment) {
ec = INVALID_STATE_ERR;
return;
}
MediaTime newTimestampOffset = MediaTime::createWithDouble(offset);
if (m_mode == AppendMode::Sequence)
m_groupStartTimestamp = newTimestampOffset;
m_timestampOffset = newTimestampOffset;
}
double SourceBuffer::appendWindowStart() const
{
return m_appendWindowStart.toDouble();
};
void SourceBuffer::setAppendWindowStart(double newValue, ExceptionCode& ec)
{
if (isRemoved() || m_updating) {
ec = INVALID_STATE_ERR;
return;
}
if (newValue < 0 || newValue >= m_appendWindowEnd.toDouble()) {
ec = INVALID_ACCESS_ERR;
return;
}
m_appendWindowStart = MediaTime::createWithDouble(newValue);
}
double SourceBuffer::appendWindowEnd() const
{
return m_appendWindowEnd.toDouble();
};
void SourceBuffer::setAppendWindowEnd(double newValue, ExceptionCode& ec)
{
if (isRemoved() || m_updating) {
ec = INVALID_STATE_ERR;
return;
}
if (std::isnan(newValue) || newValue <= m_appendWindowStart.toDouble()) {
ec = INVALID_ACCESS_ERR;
return;
}
m_appendWindowEnd = MediaTime::createWithDouble(newValue);
}
void SourceBuffer::appendBuffer(ArrayBuffer& data, ExceptionCode& ec)
{
appendBufferInternal(static_cast<unsigned char*>(data.data()), data.byteLength(), ec);
}
void SourceBuffer::appendBuffer(ArrayBufferView& data, ExceptionCode& ec)
{
appendBufferInternal(static_cast<unsigned char*>(data.baseAddress()), data.byteLength(), ec);
}
void SourceBuffer::resetParserState()
{
for (auto& trackBufferPair : m_trackBufferMap.values()) {
trackBufferPair.lastDecodeTimestamp = MediaTime::invalidTime();
trackBufferPair.lastFrameDuration = MediaTime::invalidTime();
trackBufferPair.highestPresentationTimestamp = MediaTime::invalidTime();
trackBufferPair.needRandomAccessFlag = true;
}
m_appendState = WaitingForSegment;
m_private->abort();
}
void SourceBuffer::abort(ExceptionCode& ec)
{
if (isRemoved() || !m_source->isOpen()) {
ec = INVALID_STATE_ERR;
return;
}
abortIfUpdating();
resetParserState();
m_appendWindowStart = MediaTime::zeroTime();
m_appendWindowEnd = MediaTime::positiveInfiniteTime();
}
void SourceBuffer::remove(double start, double end, ExceptionCode& ec)
{
remove(MediaTime::createWithDouble(start), MediaTime::createWithDouble(end), ec);
}
void SourceBuffer::remove(const MediaTime& start, const MediaTime& end, ExceptionCode& ec)
{
LOG(MediaSource, "SourceBuffer::remove(%p) - start(%lf), end(%lf)", this, start.toDouble(), end.toDouble());
if ((m_source && m_source->duration().isInvalid())
|| start < MediaTime::zeroTime() || (m_source && start > m_source->duration())
|| end <= start) {
ec = INVALID_ACCESS_ERR;
return;
}
if (isRemoved() || m_updating) {
ec = INVALID_STATE_ERR;
return;
}
m_source->openIfInEndedState();
rangeRemoval(start, end);
}
void SourceBuffer::rangeRemoval(const MediaTime& start, const MediaTime& end)
{
m_updating = true;
scheduleEvent(eventNames().updatestartEvent);
m_pendingRemoveStart = start;
m_pendingRemoveEnd = end;
m_removeTimer.startOneShot(0);
}
void SourceBuffer::abortIfUpdating()
{
if (!m_updating)
return;
m_appendBufferTimer.stop();
m_pendingAppendData.clear();
m_removeTimer.stop();
m_pendingRemoveStart = MediaTime::invalidTime();
m_pendingRemoveEnd = MediaTime::invalidTime();
m_updating = false;
scheduleEvent(eventNames().abortEvent);
scheduleEvent(eventNames().updateendEvent);
}
void SourceBuffer::removedFromMediaSource()
{
if (isRemoved())
return;
abortIfUpdating();
for (auto& trackBufferPair : m_trackBufferMap.values()) {
trackBufferPair.samples.clear();
trackBufferPair.decodeQueue.clear();
}
m_private->removedFromMediaSource();
m_source = nullptr;
}
void SourceBuffer::seekToTime(const MediaTime& time)
{
LOG(MediaSource, "SourceBuffer::seekToTime(%p) - time(%s)", this, toString(time).utf8().data());
for (auto& trackBufferPair : m_trackBufferMap) {
TrackBuffer& trackBuffer = trackBufferPair.value;
const AtomicString& trackID = trackBufferPair.key;
trackBuffer.needsReenqueueing = true;
reenqueueMediaForTime(trackBuffer, trackID, time);
}
}
MediaTime SourceBuffer::sourceBufferPrivateFastSeekTimeForMediaTime(SourceBufferPrivate*, const MediaTime& targetTime, const MediaTime& negativeThreshold, const MediaTime& positiveThreshold)
{
MediaTime seekTime = targetTime;
MediaTime lowerBoundTime = targetTime - negativeThreshold;
MediaTime upperBoundTime = targetTime + positiveThreshold;
for (auto& trackBuffer : m_trackBufferMap.values()) {
auto futureSyncSampleIterator = trackBuffer.samples.decodeOrder().findSyncSampleAfterPresentationTime(targetTime, positiveThreshold);
auto pastSyncSampleIterator = trackBuffer.samples.decodeOrder().findSyncSamplePriorToPresentationTime(targetTime, negativeThreshold);
auto upperBound = trackBuffer.samples.decodeOrder().end();
auto lowerBound = trackBuffer.samples.decodeOrder().rend();
if (futureSyncSampleIterator == upperBound && pastSyncSampleIterator == lowerBound)
continue;
MediaTime futureSeekTime = MediaTime::positiveInfiniteTime();
if (futureSyncSampleIterator != upperBound) {
RefPtr<MediaSample>& sample = futureSyncSampleIterator->second;
futureSeekTime = sample->presentationTime();
}
MediaTime pastSeekTime = MediaTime::negativeInfiniteTime();
if (pastSyncSampleIterator != lowerBound) {
RefPtr<MediaSample>& sample = pastSyncSampleIterator->second;
pastSeekTime = sample->presentationTime();
}
MediaTime trackSeekTime = abs(targetTime - futureSeekTime) < abs(targetTime - pastSeekTime) ? futureSeekTime : pastSeekTime;
if (abs(targetTime - trackSeekTime) > abs(targetTime - seekTime))
seekTime = trackSeekTime;
}
return seekTime;
}
bool SourceBuffer::hasPendingActivity() const
{
return m_source || m_asyncEventQueue.hasPendingEvents();
}
void SourceBuffer::stop()
{
m_appendBufferTimer.stop();
m_removeTimer.stop();
}
bool SourceBuffer::canSuspendForDocumentSuspension() const
{
return !hasPendingActivity();
}
const char* SourceBuffer::activeDOMObjectName() const
{
return "SourceBuffer";
}
bool SourceBuffer::isRemoved() const
{
return !m_source;
}
void SourceBuffer::scheduleEvent(const AtomicString& eventName)
{
auto event = Event::create(eventName, false, false);
event->setTarget(this);
m_asyncEventQueue.enqueueEvent(WTFMove(event));
}
void SourceBuffer::appendBufferInternal(unsigned char* data, unsigned size, ExceptionCode& ec)
{
if (isRemoved() || m_updating) {
ec = INVALID_STATE_ERR;
return;
}
m_source->openIfInEndedState();
evictCodedFrames(size);
#if 0
if (m_bufferFull) {
LOG(MediaSource, "SourceBuffer::appendBufferInternal(%p) - buffer full, failing with QUOTA_EXCEEDED_ERR error", this);
ec = QUOTA_EXCEEDED_ERR;
return;
}
#endif
m_pendingAppendData.append(data, size);
m_updating = true;
scheduleEvent(eventNames().updatestartEvent);
m_appendBufferTimer.startOneShot(0);
reportExtraMemoryAllocated();
}
void SourceBuffer::appendBufferTimerFired()
{
if (isRemoved())
return;
ASSERT(m_updating);
size_t appendSize = m_pendingAppendData.size();
if (!appendSize) {
m_pendingAppendData.resize(1);
}
if (!m_pendingAppendData.size()) {
sourceBufferPrivateAppendComplete(&m_private.get(), AppendSucceeded);
return;
}
m_private->append(m_pendingAppendData.data(), appendSize);
m_pendingAppendData.clear();
}
void SourceBuffer::sourceBufferPrivateAppendComplete(SourceBufferPrivate*, AppendResult result)
{
if (isRemoved())
return;
if (result == ParsingFailed) {
LOG(MediaSource, "SourceBuffer::sourceBufferPrivateAppendComplete(%p) - result = ParsingFailed", this);
appendError(true);
return;
}
if (result != AppendSucceeded)
return;
m_updating = false;
scheduleEvent(eventNames().updateEvent);
scheduleEvent(eventNames().updateendEvent);
if (m_source)
m_source->monitorSourceBuffers();
MediaTime currentMediaTime = m_source->currentTime();
for (auto& trackBufferPair : m_trackBufferMap) {
TrackBuffer& trackBuffer = trackBufferPair.value;
const AtomicString& trackID = trackBufferPair.key;
if (trackBuffer.needsReenqueueing) {
LOG(MediaSource, "SourceBuffer::sourceBufferPrivateAppendComplete(%p) - reenqueuing at time (%s)", this, toString(currentMediaTime).utf8().data());
reenqueueMediaForTime(trackBuffer, trackID, currentMediaTime);
} else
provideMediaData(trackBuffer, trackID);
}
reportExtraMemoryAllocated();
if (extraMemoryCost() > this->maximumBufferSize())
m_bufferFull = true;
LOG(Media, "SourceBuffer::sourceBufferPrivateAppendComplete(%p) - buffered = %s", this, toString(m_buffered->ranges()).utf8().data());
}
void SourceBuffer::sourceBufferPrivateDidReceiveRenderingError(SourceBufferPrivate*, int error)
{
#if LOG_DISABLED
UNUSED_PARAM(error);
#endif
LOG(MediaSource, "SourceBuffer::sourceBufferPrivateDidReceiveRenderingError(%p) - result = %i", this, error);
if (!isRemoved())
m_source->streamEndedWithError(MediaSource::EndOfStreamError::Decode);
}
static bool decodeTimeComparator(const PresentationOrderSampleMap::MapType::value_type& a, const PresentationOrderSampleMap::MapType::value_type& b)
{
return a.second->decodeTime() < b.second->decodeTime();
}
static PlatformTimeRanges removeSamplesFromTrackBuffer(const DecodeOrderSampleMap::MapType& samples, SourceBuffer::TrackBuffer& trackBuffer, const SourceBuffer* buffer, const char* logPrefix)
{
#if !LOG_DISABLED
MediaTime earliestSample = MediaTime::positiveInfiniteTime();
MediaTime latestSample = MediaTime::zeroTime();
size_t bytesRemoved = 0;
#else
UNUSED_PARAM(logPrefix);
UNUSED_PARAM(buffer);
#endif
PlatformTimeRanges erasedRanges;
for (auto sampleIt : samples) {
const DecodeOrderSampleMap::KeyType& decodeKey = sampleIt.first;
#if !LOG_DISABLED
size_t startBufferSize = trackBuffer.samples.sizeInBytes();
#endif
RefPtr<MediaSample>& sample = sampleIt.second;
LOG(MediaSource, "SourceBuffer::%s(%p) - removing sample(%s)", logPrefix, buffer, toString(*sampleIt.second).utf8().data());
trackBuffer.samples.removeSample(sample.get());
trackBuffer.decodeQueue.erase(decodeKey);
auto startTime = sample->presentationTime();
auto endTime = startTime + sample->duration();
erasedRanges.add(startTime, endTime);
#if !LOG_DISABLED
bytesRemoved += startBufferSize - trackBuffer.samples.sizeInBytes();
if (startTime < earliestSample)
earliestSample = startTime;
if (endTime > latestSample)
latestSample = endTime;
#endif
}
PlatformTimeRanges additionalErasedRanges;
for (unsigned i = 0; i < erasedRanges.length(); ++i) {
auto erasedStart = erasedRanges.start(i);
auto erasedEnd = erasedRanges.end(i);
auto startIterator = trackBuffer.samples.presentationOrder().reverseFindSampleBeforePresentationTime(erasedStart);
if (startIterator == trackBuffer.samples.presentationOrder().rend())
additionalErasedRanges.add(MediaTime::zeroTime(), erasedStart);
else {
auto& previousSample = *startIterator->second;
if (previousSample.presentationTime() + previousSample.duration() < erasedStart)
additionalErasedRanges.add(previousSample.presentationTime() + previousSample.duration(), erasedStart);
}
auto endIterator = trackBuffer.samples.presentationOrder().findSampleOnOrAfterPresentationTime(erasedEnd);
if (endIterator == trackBuffer.samples.presentationOrder().end())
additionalErasedRanges.add(erasedEnd, MediaTime::positiveInfiniteTime());
else {
auto& nextSample = *endIterator->second;
if (nextSample.presentationTime() > erasedEnd)
additionalErasedRanges.add(erasedEnd, nextSample.presentationTime());
}
}
if (additionalErasedRanges.length())
erasedRanges.unionWith(additionalErasedRanges);
#if !LOG_DISABLED
if (bytesRemoved)
LOG(MediaSource, "SourceBuffer::%s(%p) removed %zu bytes, start(%lf), end(%lf)", logPrefix, buffer, bytesRemoved, earliestSample.toDouble(), latestSample.toDouble());
#endif
return erasedRanges;
}
void SourceBuffer::removeCodedFrames(const MediaTime& start, const MediaTime& end)
{
LOG(MediaSource, "SourceBuffer::removeCodedFrames(%p) - start(%s), end(%s)", this, toString(start).utf8().data(), toString(end).utf8().data());
MediaTime durationMediaTime = m_source->duration();
MediaTime currentMediaTime = m_source->currentTime();
for (auto& iter : m_trackBufferMap) {
TrackBuffer& trackBuffer = iter.value;
DecodeOrderSampleMap::iterator removeDecodeEnd = trackBuffer.samples.decodeOrder().findSyncSampleAfterPresentationTime(end);
PresentationOrderSampleMap::iterator removePresentationEnd;
if (removeDecodeEnd == trackBuffer.samples.decodeOrder().end())
removePresentationEnd = trackBuffer.samples.presentationOrder().end();
else
removePresentationEnd = trackBuffer.samples.presentationOrder().findSampleWithPresentationTime(removeDecodeEnd->second->presentationTime());
PresentationOrderSampleMap::iterator removePresentationStart = trackBuffer.samples.presentationOrder().findSampleOnOrAfterPresentationTime(start);
if (removePresentationStart == removePresentationEnd)
continue;
PresentationOrderSampleMap::iterator minDecodeTimeIter = std::min_element(removePresentationStart, removePresentationEnd, decodeTimeComparator);
DecodeOrderSampleMap::KeyType decodeKey(minDecodeTimeIter->second->decodeTime(), minDecodeTimeIter->second->presentationTime());
DecodeOrderSampleMap::iterator removeDecodeStart = trackBuffer.samples.decodeOrder().findSampleWithDecodeKey(decodeKey);
DecodeOrderSampleMap::MapType erasedSamples(removeDecodeStart, removeDecodeEnd);
PlatformTimeRanges erasedRanges = removeSamplesFromTrackBuffer(erasedSamples, trackBuffer, this, "removeCodedFrames");
if (currentMediaTime < trackBuffer.lastEnqueuedPresentationTime) {
PlatformTimeRanges possiblyEnqueuedRanges(currentMediaTime, trackBuffer.lastEnqueuedPresentationTime);
possiblyEnqueuedRanges.intersectWith(erasedRanges);
if (possiblyEnqueuedRanges.length())
trackBuffer.needsReenqueueing = true;
}
erasedRanges.invert();
m_buffered->ranges().intersectWith(erasedRanges);
setBufferedDirty(true);
if (m_active && currentMediaTime >= start && currentMediaTime < end && m_private->readyState() > MediaPlayer::HaveMetadata)
m_private->setReadyState(MediaPlayer::HaveMetadata);
}
LOG(Media, "SourceBuffer::removeCodedFrames(%p) - buffered = %s", this, toString(m_buffered->ranges()).utf8().data());
}
void SourceBuffer::removeTimerFired()
{
ASSERT(m_updating);
ASSERT(m_pendingRemoveStart.isValid());
ASSERT(m_pendingRemoveStart < m_pendingRemoveEnd);
removeCodedFrames(m_pendingRemoveStart, m_pendingRemoveEnd);
m_updating = false;
m_pendingRemoveStart = MediaTime::invalidTime();
m_pendingRemoveEnd = MediaTime::invalidTime();
scheduleEvent(eventNames().updateEvent);
scheduleEvent(eventNames().updateendEvent);
}
void SourceBuffer::evictCodedFrames(size_t newDataSize)
{
if (isRemoved())
return;
if (!m_bufferFull)
return;
size_t maximumBufferSize = this->maximumBufferSize();
MediaTime thirtySeconds = MediaTime(30, 1);
MediaTime currentTime = m_source->currentTime();
MediaTime maximumRangeEnd = currentTime - thirtySeconds;
#if !LOG_DISABLED
LOG(MediaSource, "SourceBuffer::evictCodedFrames(%p) - currentTime = %lf, require %zu bytes, maximum buffer size is %zu", this, m_source->currentTime().toDouble(), extraMemoryCost() + newDataSize, maximumBufferSize);
size_t initialBufferedSize = extraMemoryCost();
#endif
MediaTime rangeStart = MediaTime::zeroTime();
MediaTime rangeEnd = rangeStart + thirtySeconds;
while (rangeStart < maximumRangeEnd) {
removeCodedFrames(rangeStart, std::min(rangeEnd, maximumRangeEnd));
if (extraMemoryCost() + newDataSize < maximumBufferSize) {
m_bufferFull = false;
break;
}
rangeStart += thirtySeconds;
rangeEnd += thirtySeconds;
}
if (!m_bufferFull) {
LOG(MediaSource, "SourceBuffer::evictCodedFrames(%p) - evicted %zu bytes", this, initialBufferedSize - extraMemoryCost());
return;
}
auto buffered = m_buffered->ranges();
size_t currentTimeRange = buffered.find(currentTime);
if (currentTimeRange == notFound || currentTimeRange == buffered.length() - 1) {
LOG(MediaSource, "SourceBuffer::evictCodedFrames(%p) - evicted %zu bytes but FAILED to free enough", this, initialBufferedSize - extraMemoryCost());
return;
}
MediaTime minimumRangeStart = currentTime + thirtySeconds;
rangeEnd = m_source->duration();
rangeStart = rangeEnd - thirtySeconds;
while (rangeStart > minimumRangeStart) {
size_t startTimeRange = buffered.find(rangeStart);
if (startTimeRange == currentTimeRange) {
size_t endTimeRange = buffered.find(rangeEnd);
if (endTimeRange == currentTimeRange)
break;
rangeEnd = buffered.start(endTimeRange);
}
removeCodedFrames(std::max(minimumRangeStart, rangeStart), rangeEnd);
if (extraMemoryCost() + newDataSize < maximumBufferSize) {
m_bufferFull = false;
break;
}
rangeStart -= thirtySeconds;
rangeEnd -= thirtySeconds;
}
LOG(MediaSource, "SourceBuffer::evictCodedFrames(%p) - evicted %zu bytes%s", this, initialBufferedSize - extraMemoryCost(), m_bufferFull ? "" : " but FAILED to free enough");
}
size_t SourceBuffer::maximumBufferSize() const
{
if (isRemoved())
return 0;
HTMLMediaElement* element = m_source->mediaElement();
if (!element)
return 0;
return element->maximumSourceBufferSize(*this);
}
VideoTrackList* SourceBuffer::videoTracks()
{
if (!m_source || !m_source->mediaElement())
return nullptr;
if (!m_videoTracks)
m_videoTracks = VideoTrackList::create(m_source->mediaElement(), ActiveDOMObject::scriptExecutionContext());
return m_videoTracks.get();
}
AudioTrackList* SourceBuffer::audioTracks()
{
if (!m_source || !m_source->mediaElement())
return nullptr;
if (!m_audioTracks)
m_audioTracks = AudioTrackList::create(m_source->mediaElement(), ActiveDOMObject::scriptExecutionContext());
return m_audioTracks.get();
}
TextTrackList* SourceBuffer::textTracks()
{
if (!m_source || !m_source->mediaElement())
return nullptr;
if (!m_textTracks)
m_textTracks = TextTrackList::create(m_source->mediaElement(), ActiveDOMObject::scriptExecutionContext());
return m_textTracks.get();
}
void SourceBuffer::setActive(bool active)
{
if (m_active == active)
return;
m_active = active;
m_private->setActive(active);
if (!isRemoved())
m_source->sourceBufferDidChangeActiveState(*this, active);
}
void SourceBuffer::sourceBufferPrivateDidReceiveInitializationSegment(SourceBufferPrivate*, const InitializationSegment& segment)
{
if (isRemoved())
return;
LOG(MediaSource, "SourceBuffer::sourceBufferPrivateDidReceiveInitializationSegment(%p)", this);
if (m_source->duration().isInvalid()) {
MediaTime newDuration = segment.duration.isValid() ? segment.duration : MediaTime::positiveInfiniteTime();
m_source->setDurationInternal(newDuration);
}
if (segment.audioTracks.isEmpty() && segment.videoTracks.isEmpty() && segment.textTracks.isEmpty()) {
appendError(true);
return;
}
if (m_receivedFirstInitializationSegment) {
if (!validateInitializationSegment(segment)) {
appendError(true);
return;
}
ASSERT(segment.audioTracks.size() == audioTracks()->length());
for (auto& audioTrackInfo : segment.audioTracks) {
if (audioTracks()->length() == 1) {
audioTracks()->item(0)->setPrivate(audioTrackInfo.track);
break;
}
auto audioTrack = audioTracks()->getTrackById(audioTrackInfo.track->id());
ASSERT(audioTrack);
audioTrack->setPrivate(audioTrackInfo.track);
}
ASSERT(segment.videoTracks.size() == videoTracks()->length());
for (auto& videoTrackInfo : segment.videoTracks) {
if (videoTracks()->length() == 1) {
videoTracks()->item(0)->setPrivate(videoTrackInfo.track);
break;
}
auto videoTrack = videoTracks()->getTrackById(videoTrackInfo.track->id());
ASSERT(videoTrack);
videoTrack->setPrivate(videoTrackInfo.track);
}
ASSERT(segment.textTracks.size() == textTracks()->length());
for (auto& textTrackInfo : segment.textTracks) {
if (textTracks()->length() == 1) {
downcast<InbandTextTrack>(*textTracks()->item(0)).setPrivate(textTrackInfo.track);
break;
}
auto textTrack = textTracks()->getTrackById(textTrackInfo.track->id());
ASSERT(textTrack);
downcast<InbandTextTrack>(*textTrack).setPrivate(textTrackInfo.track);
}
for (auto& trackBuffer : m_trackBufferMap.values())
trackBuffer.needRandomAccessFlag = true;
}
bool activeTrackFlag = false;
if (!m_receivedFirstInitializationSegment) {
for (auto& audioTrackInfo : segment.audioTracks) {
AudioTrackPrivate* audioTrackPrivate = audioTrackInfo.track.get();
auto newAudioTrack = AudioTrack::create(this, audioTrackPrivate);
newAudioTrack->setSourceBuffer(this);
if (!audioTracks()->length()) {
newAudioTrack->setEnabled(true);
activeTrackFlag = true;
}
audioTracks()->append(newAudioTrack.copyRef());
m_source->mediaElement()->audioTracks().append(newAudioTrack.copyRef());
ASSERT(!m_trackBufferMap.contains(newAudioTrack->id()));
TrackBuffer& trackBuffer = m_trackBufferMap.add(newAudioTrack->id(), TrackBuffer()).iterator->value;
trackBuffer.description = audioTrackInfo.description;
m_audioCodecs.append(trackBuffer.description->codec());
}
for (auto& videoTrackInfo : segment.videoTracks) {
VideoTrackPrivate* videoTrackPrivate = videoTrackInfo.track.get();
auto newVideoTrack = VideoTrack::create(this, videoTrackPrivate);
newVideoTrack->setSourceBuffer(this);
if (!videoTracks()->length()) {
newVideoTrack->setSelected(true);
activeTrackFlag = true;
}
videoTracks()->append(newVideoTrack.copyRef());
m_source->mediaElement()->videoTracks().append(newVideoTrack.copyRef());
ASSERT(!m_trackBufferMap.contains(newVideoTrack->id()));
TrackBuffer& trackBuffer = m_trackBufferMap.add(newVideoTrack->id(), TrackBuffer()).iterator->value;
trackBuffer.description = videoTrackInfo.description;
m_videoCodecs.append(trackBuffer.description->codec());
}
for (auto& textTrackInfo : segment.textTracks) {
InbandTextTrackPrivate* textTrackPrivate = textTrackInfo.track.get();
RefPtr<InbandTextTrack> newTextTrack = InbandTextTrack::create(scriptExecutionContext(), this, textTrackPrivate);
if (textTrackPrivate->mode() != InbandTextTrackPrivate::Disabled)
activeTrackFlag = true;
textTracks()->append(*newTextTrack);
m_source->mediaElement()->textTracks().append(newTextTrack.releaseNonNull());
ASSERT(!m_trackBufferMap.contains(textTrackPrivate->id()));
TrackBuffer& trackBuffer = m_trackBufferMap.add(textTrackPrivate->id(), TrackBuffer()).iterator->value;
trackBuffer.description = textTrackInfo.description;
m_textCodecs.append(trackBuffer.description->codec());
}
if (activeTrackFlag) {
setActive(true);
}
m_receivedFirstInitializationSegment = true;
}
if (m_private->readyState() == MediaPlayer::HaveNothing) {
for (auto& sourceBuffer : *m_source->sourceBuffers()) {
if (!sourceBuffer->m_receivedFirstInitializationSegment)
return;
}
m_private->setReadyState(MediaPlayer::HaveMetadata);
}
if (activeTrackFlag && m_private->readyState() > MediaPlayer::HaveCurrentData)
m_private->setReadyState(MediaPlayer::HaveMetadata);
}
bool SourceBuffer::validateInitializationSegment(const InitializationSegment& segment)
{
if (segment.audioTracks.size() != audioTracks()->length()
|| segment.videoTracks.size() != videoTracks()->length()
|| segment.textTracks.size() != textTracks()->length())
return false;
for (auto& audioTrackInfo : segment.audioTracks) {
if (!m_audioCodecs.contains(audioTrackInfo.description->codec()))
return false;
}
for (auto& videoTrackInfo : segment.videoTracks) {
if (!m_videoCodecs.contains(videoTrackInfo.description->codec()))
return false;
}
for (auto& textTrackInfo : segment.textTracks) {
if (!m_textCodecs.contains(textTrackInfo.description->codec()))
return false;
}
if (segment.audioTracks.size() >= 2) {
for (auto& audioTrackInfo : segment.audioTracks) {
if (!m_trackBufferMap.contains(audioTrackInfo.track->id()))
return false;
}
}
if (segment.videoTracks.size() >= 2) {
for (auto& videoTrackInfo : segment.videoTracks) {
if (!m_trackBufferMap.contains(videoTrackInfo.track->id()))
return false;
}
}
if (segment.textTracks.size() >= 2) {
for (auto& textTrackInfo : segment.videoTracks) {
if (!m_trackBufferMap.contains(textTrackInfo.track->id()))
return false;
}
}
return true;
}
class SampleLessThanComparator {
public:
bool operator()(std::pair<MediaTime, RefPtr<MediaSample>> value1, std::pair<MediaTime, RefPtr<MediaSample>> value2)
{
return value1.first < value2.first;
}
bool operator()(MediaTime value1, std::pair<MediaTime, RefPtr<MediaSample>> value2)
{
return value1 < value2.first;
}
bool operator()(std::pair<MediaTime, RefPtr<MediaSample>> value1, MediaTime value2)
{
return value1.first < value2;
}
};
void SourceBuffer::appendError(bool decodeErrorParam)
{
ASSERT(m_updating);
resetParserState();
m_updating = false;
scheduleEvent(eventNames().errorEvent);
scheduleEvent(eventNames().updateendEvent);
if (decodeErrorParam)
m_source->streamEndedWithError(MediaSource::EndOfStreamError::Decode);
}
void SourceBuffer::sourceBufferPrivateDidReceiveSample(SourceBufferPrivate*, PassRefPtr<MediaSample> prpSample)
{
if (isRemoved())
return;
if (!m_receivedFirstInitializationSegment) {
appendError(true);
return;
}
RefPtr<MediaSample> sample = prpSample;
do {
MediaTime presentationTimestamp;
MediaTime decodeTimestamp;
if (m_shouldGenerateTimestamps) {
presentationTimestamp = MediaTime::zeroTime();
decodeTimestamp = MediaTime::zeroTime();
} else {
presentationTimestamp = sample->presentationTime();
decodeTimestamp = sample->decodeTime();
}
MediaTime frameDuration = sample->duration();
if (m_mode == AppendMode::Sequence && m_groupStartTimestamp.isValid()) {
m_timestampOffset = m_groupStartTimestamp;
m_groupEndTimestamp = m_groupStartTimestamp;
for (auto& trackBuffer : m_trackBufferMap.values())
trackBuffer.needRandomAccessFlag = true;
m_groupStartTimestamp = MediaTime::invalidTime();
}
if (m_timestampOffset) {
presentationTimestamp += m_timestampOffset;
decodeTimestamp += m_timestampOffset;
}
AtomicString trackID = sample->trackID();
auto it = m_trackBufferMap.find(trackID);
if (it == m_trackBufferMap.end())
it = m_trackBufferMap.add(trackID, TrackBuffer()).iterator;
TrackBuffer& trackBuffer = it->value;
if (trackBuffer.lastDecodeTimestamp.isValid() && (decodeTimestamp < trackBuffer.lastDecodeTimestamp
|| abs(decodeTimestamp - trackBuffer.lastDecodeTimestamp) > (trackBuffer.lastFrameDuration * 2))) {
if (m_mode == AppendMode::Segments) {
m_groupEndTimestamp = presentationTimestamp;
} else {
m_groupStartTimestamp = m_groupEndTimestamp;
}
for (auto& trackBuffer : m_trackBufferMap.values()) {
trackBuffer.lastDecodeTimestamp = MediaTime::invalidTime();
trackBuffer.lastFrameDuration = MediaTime::invalidTime();
trackBuffer.highestPresentationTimestamp = MediaTime::invalidTime();
trackBuffer.needRandomAccessFlag = true;
}
continue;
}
if (m_mode == AppendMode::Sequence) {
sample->setTimestamps(presentationTimestamp, decodeTimestamp);
} else if (m_timestampOffset) {
sample->offsetTimestampsBy(m_timestampOffset);
}
MediaTime frameEndTimestamp = presentationTimestamp + frameDuration;
if (presentationTimestamp < m_appendWindowStart || frameEndTimestamp > m_appendWindowEnd) {
trackBuffer.needRandomAccessFlag = true;
didDropSample();
return;
}
MediaTime presentationStartTime = MediaTime::zeroTime();
if (presentationTimestamp < presentationStartTime) {
LOG(MediaSource, "SourceBuffer::sourceBufferPrivateDidReceiveSample(%p) - failing because presentationTimestamp < presentationStartTime", this);
m_source->streamEndedWithError(MediaSource::EndOfStreamError::Decode);
return;
}
if (trackBuffer.needRandomAccessFlag) {
if (!sample->isSync()) {
didDropSample();
return;
}
trackBuffer.needRandomAccessFlag = false;
}
SampleMap erasedSamples;
MediaTime microsecond(1, 1000000);
if (trackBuffer.lastDecodeTimestamp.isInvalid()) {
auto iter = trackBuffer.samples.presentationOrder().findSampleContainingPresentationTime(presentationTimestamp);
if (iter != trackBuffer.samples.presentationOrder().end()) {
RefPtr<MediaSample> overlappedFrame = iter->second;
if (trackBuffer.description->isVideo()) {
MediaTime overlappedFramePresentationTimestamp = overlappedFrame->presentationTime();
MediaTime removeWindowTimestamp = overlappedFramePresentationTimestamp + microsecond;
if (presentationTimestamp < removeWindowTimestamp)
erasedSamples.addSample(iter->second);
}
}
}
if (trackBuffer.highestPresentationTimestamp.isInvalid()) {
auto iter_pair = trackBuffer.samples.presentationOrder().findSamplesBetweenPresentationTimes(presentationTimestamp, frameEndTimestamp);
if (iter_pair.first != trackBuffer.samples.presentationOrder().end())
erasedSamples.addRange(iter_pair.first, iter_pair.second);
}
if (trackBuffer.highestPresentationTimestamp.isValid() && trackBuffer.highestPresentationTimestamp <= presentationTimestamp) {
do {
if (!m_buffered)
break;
unsigned bufferedLength = m_buffered->ranges().length();
if (!bufferedLength)
break;
MediaTime highestBufferedTime = m_buffered->ranges().maximumBufferedTime();
PresentationOrderSampleMap::iterator_range range;
if (highestBufferedTime - trackBuffer.highestPresentationTimestamp < trackBuffer.lastFrameDuration)
range = trackBuffer.samples.presentationOrder().findSamplesWithinPresentationRangeFromEnd(trackBuffer.highestPresentationTimestamp, frameEndTimestamp);
else
range = trackBuffer.samples.presentationOrder().findSamplesWithinPresentationRange(trackBuffer.highestPresentationTimestamp, frameEndTimestamp);
if (range.first != trackBuffer.samples.presentationOrder().end())
erasedSamples.addRange(range.first, range.second);
} while(false);
}
DecodeOrderSampleMap::MapType dependentSamples;
if (!erasedSamples.empty()) {
auto firstDecodeIter = trackBuffer.samples.decodeOrder().findSampleWithDecodeKey(erasedSamples.decodeOrder().begin()->first);
auto lastDecodeIter = trackBuffer.samples.decodeOrder().findSampleWithDecodeKey(erasedSamples.decodeOrder().rbegin()->first);
auto nextSyncIter = trackBuffer.samples.decodeOrder().findSyncSampleAfterDecodeIterator(lastDecodeIter);
dependentSamples.insert(firstDecodeIter, nextSyncIter);
PlatformTimeRanges erasedRanges = removeSamplesFromTrackBuffer(dependentSamples, trackBuffer, this, "sourceBufferPrivateDidReceiveSample");
MediaTime currentMediaTime = m_source->currentTime();
if (currentMediaTime < trackBuffer.lastEnqueuedPresentationTime) {
PlatformTimeRanges possiblyEnqueuedRanges(currentMediaTime, trackBuffer.lastEnqueuedPresentationTime);
possiblyEnqueuedRanges.intersectWith(erasedRanges);
if (possiblyEnqueuedRanges.length())
trackBuffer.needsReenqueueing = true;
}
erasedRanges.invert();
m_buffered->ranges().intersectWith(erasedRanges);
setBufferedDirty(true);
}
trackBuffer.samples.addSample(sample);
if (trackBuffer.lastEnqueuedDecodeEndTime.isInvalid() || decodeTimestamp >= trackBuffer.lastEnqueuedDecodeEndTime) {
DecodeOrderSampleMap::KeyType decodeKey(decodeTimestamp, presentationTimestamp);
trackBuffer.decodeQueue.insert(DecodeOrderSampleMap::MapType::value_type(decodeKey, sample));
}
trackBuffer.lastDecodeTimestamp = decodeTimestamp;
trackBuffer.lastFrameDuration = frameDuration;
if (trackBuffer.highestPresentationTimestamp.isInvalid() || frameEndTimestamp > trackBuffer.highestPresentationTimestamp)
trackBuffer.highestPresentationTimestamp = frameEndTimestamp;
if (m_groupEndTimestamp.isInvalid() || frameEndTimestamp > m_groupEndTimestamp)
m_groupEndTimestamp = frameEndTimestamp;
if (m_shouldGenerateTimestamps)
m_timestampOffset = frameEndTimestamp;
auto presentationEndTime = presentationTimestamp + frameDuration;
auto nearestToPresentationStartTime = m_buffered->ranges().nearest(presentationTimestamp);
if ((presentationTimestamp - nearestToPresentationStartTime).isBetween(MediaTime::zeroTime(), currentTimeFudgeFactor()))
presentationTimestamp = nearestToPresentationStartTime;
auto nearestToPresentationEndTime = m_buffered->ranges().nearest(presentationEndTime);
if ((nearestToPresentationEndTime - presentationEndTime).isBetween(MediaTime::zeroTime(), currentTimeFudgeFactor()))
presentationEndTime = nearestToPresentationEndTime;
m_buffered->ranges().add(presentationTimestamp, presentationEndTime);
m_bufferedSinceLastMonitor += frameDuration.toDouble();
setBufferedDirty(true);
break;
} while (1);
if (m_groupEndTimestamp > m_source->duration())
m_source->setDurationInternal(m_groupEndTimestamp);
}
bool SourceBuffer::hasAudio() const
{
return m_audioTracks && m_audioTracks->length();
}
bool SourceBuffer::hasVideo() const
{
return m_videoTracks && m_videoTracks->length();
}
bool SourceBuffer::sourceBufferPrivateHasAudio(const SourceBufferPrivate*) const
{
return hasAudio();
}
bool SourceBuffer::sourceBufferPrivateHasVideo(const SourceBufferPrivate*) const
{
return hasVideo();
}
void SourceBuffer::videoTrackSelectedChanged(VideoTrack* track)
{
if (track->selected()
&& (!m_videoTracks || !m_videoTracks->isAnyTrackEnabled())
&& (!m_audioTracks || !m_audioTracks->isAnyTrackEnabled())
&& (!m_textTracks || !m_textTracks->isAnyTrackEnabled())) {
setActive(false);
} else if (!track->selected()) {
setActive(true);
}
if (!isRemoved())
m_source->mediaElement()->videoTrackSelectedChanged(track);
}
void SourceBuffer::audioTrackEnabledChanged(AudioTrack* track)
{
if (track->enabled()
&& (!m_videoTracks || !m_videoTracks->isAnyTrackEnabled())
&& (!m_audioTracks || !m_audioTracks->isAnyTrackEnabled())
&& (!m_textTracks || !m_textTracks->isAnyTrackEnabled())) {
setActive(false);
} else if (!track->enabled()) {
setActive(true);
}
if (!isRemoved())
m_source->mediaElement()->audioTrackEnabledChanged(track);
}
void SourceBuffer::textTrackModeChanged(TextTrack* track)
{
if (track->mode() == TextTrack::Mode::Disabled
&& (!m_videoTracks || !m_videoTracks->isAnyTrackEnabled())
&& (!m_audioTracks || !m_audioTracks->isAnyTrackEnabled())
&& (!m_textTracks || !m_textTracks->isAnyTrackEnabled())) {
setActive(false);
} else {
setActive(true);
}
if (!isRemoved())
m_source->mediaElement()->textTrackModeChanged(track);
}
void SourceBuffer::textTrackAddCue(TextTrack* track, WTF::PassRefPtr<TextTrackCue> cue)
{
if (!isRemoved())
m_source->mediaElement()->textTrackAddCue(track, cue);
}
void SourceBuffer::textTrackAddCues(TextTrack* track, TextTrackCueList const* cueList)
{
if (!isRemoved())
m_source->mediaElement()->textTrackAddCues(track, cueList);
}
void SourceBuffer::textTrackRemoveCue(TextTrack* track, WTF::PassRefPtr<TextTrackCue> cue)
{
if (!isRemoved())
m_source->mediaElement()->textTrackRemoveCue(track, cue);
}
void SourceBuffer::textTrackRemoveCues(TextTrack* track, TextTrackCueList const* cueList)
{
if (!isRemoved())
m_source->mediaElement()->textTrackRemoveCues(track, cueList);
}
void SourceBuffer::textTrackKindChanged(TextTrack* track)
{
if (!isRemoved())
m_source->mediaElement()->textTrackKindChanged(track);
}
void SourceBuffer::sourceBufferPrivateDidBecomeReadyForMoreSamples(SourceBufferPrivate*, AtomicString trackID)
{
LOG(MediaSource, "SourceBuffer::sourceBufferPrivateDidBecomeReadyForMoreSamples(%p)", this);
auto it = m_trackBufferMap.find(trackID);
if (it == m_trackBufferMap.end())
return;
TrackBuffer& trackBuffer = it->value;
if (!trackBuffer.needsReenqueueing && !m_source->isSeeking())
provideMediaData(trackBuffer, trackID);
}
void SourceBuffer::provideMediaData(TrackBuffer& trackBuffer, AtomicString trackID)
{
#if !LOG_DISABLED
unsigned enqueuedSamples = 0;
#endif
while (!trackBuffer.decodeQueue.empty()) {
if (!m_private->isReadyForMoreSamples(trackID)) {
m_private->notifyClientWhenReadyForMoreSamples(trackID);
break;
}
auto sample = trackBuffer.decodeQueue.begin()->second;
trackBuffer.decodeQueue.erase(trackBuffer.decodeQueue.begin());
MediaTime oneSecond(1, 1);
if (trackBuffer.lastEnqueuedDecodeEndTime.isValid() && sample->decodeTime() - trackBuffer.lastEnqueuedDecodeEndTime > oneSecond)
break;
trackBuffer.lastEnqueuedPresentationTime = sample->presentationTime();
trackBuffer.lastEnqueuedDecodeEndTime = sample->decodeTime() + sample->duration();
m_private->enqueueSample(WTFMove(sample), trackID);
#if !LOG_DISABLED
++enqueuedSamples;
#endif
}
LOG(MediaSource, "SourceBuffer::provideMediaData(%p) - Enqueued %u samples", this, enqueuedSamples);
}
void SourceBuffer::reenqueueMediaForTime(TrackBuffer& trackBuffer, AtomicString trackID, const MediaTime& time)
{
auto currentSamplePTSIterator = trackBuffer.samples.presentationOrder().findSampleContainingPresentationTime(time);
if (currentSamplePTSIterator == trackBuffer.samples.presentationOrder().end()) {
trackBuffer.decodeQueue.clear();
m_private->flushAndEnqueueNonDisplayingSamples(Vector<RefPtr<MediaSample>>(), trackID);
return;
}
DecodeOrderSampleMap::KeyType decodeKey(currentSamplePTSIterator->second->decodeTime(), currentSamplePTSIterator->second->presentationTime());
auto currentSampleDTSIterator = trackBuffer.samples.decodeOrder().findSampleWithDecodeKey(decodeKey);
ASSERT(currentSampleDTSIterator != trackBuffer.samples.decodeOrder().end());
auto reverseCurrentSampleIter = --DecodeOrderSampleMap::reverse_iterator(currentSampleDTSIterator);
auto reverseLastSyncSampleIter = trackBuffer.samples.decodeOrder().findSyncSamplePriorToDecodeIterator(reverseCurrentSampleIter);
if (reverseLastSyncSampleIter == trackBuffer.samples.decodeOrder().rend()) {
trackBuffer.decodeQueue.clear();
m_private->flushAndEnqueueNonDisplayingSamples(Vector<RefPtr<MediaSample>>(), trackID);
return;
}
Vector<RefPtr<MediaSample>> nonDisplayingSamples;
for (auto iter = reverseLastSyncSampleIter; iter != reverseCurrentSampleIter; --iter)
nonDisplayingSamples.append(iter->second);
m_private->flushAndEnqueueNonDisplayingSamples(nonDisplayingSamples, trackID);
if (!nonDisplayingSamples.isEmpty()) {
trackBuffer.lastEnqueuedPresentationTime = nonDisplayingSamples.last()->presentationTime();
trackBuffer.lastEnqueuedDecodeEndTime = nonDisplayingSamples.last()->decodeTime();
} else {
trackBuffer.lastEnqueuedPresentationTime = MediaTime::invalidTime();
trackBuffer.lastEnqueuedDecodeEndTime = MediaTime::invalidTime();
}
trackBuffer.decodeQueue.clear();
for (auto iter = currentSampleDTSIterator; iter != trackBuffer.samples.decodeOrder().end(); ++iter)
trackBuffer.decodeQueue.insert(*iter);
provideMediaData(trackBuffer, trackID);
trackBuffer.needsReenqueueing = false;
}
void SourceBuffer::didDropSample()
{
if (!isRemoved())
m_source->mediaElement()->incrementDroppedFrameCount();
}
void SourceBuffer::monitorBufferingRate()
{
if (!m_bufferedSinceLastMonitor)
return;
double now = monotonicallyIncreasingTime();
double interval = now - m_timeOfBufferingMonitor;
double rateSinceLastMonitor = m_bufferedSinceLastMonitor / interval;
m_timeOfBufferingMonitor = now;
m_bufferedSinceLastMonitor = 0;
m_averageBufferRate = m_averageBufferRate * (1 - ExponentialMovingAverageCoefficient) + rateSinceLastMonitor * ExponentialMovingAverageCoefficient;
LOG(MediaSource, "SourceBuffer::monitorBufferingRate(%p) - m_avegareBufferRate: %lf", this, m_averageBufferRate);
}
std::unique_ptr<PlatformTimeRanges> SourceBuffer::bufferedAccountingForEndOfStream() const
{
auto virtualRanges = std::make_unique<PlatformTimeRanges>(m_buffered->ranges());
if (m_source->isEnded()) {
MediaTime start = virtualRanges->maximumBufferedTime();
MediaTime end = m_source->duration();
if (start <= end)
virtualRanges->add(start, end);
}
return virtualRanges;
}
bool SourceBuffer::hasCurrentTime() const
{
if (isRemoved() || !m_buffered->length())
return false;
MediaTime currentTime = m_source->currentTime();
MediaTime duration = m_source->duration();
if (currentTime >= duration)
return true;
std::unique_ptr<PlatformTimeRanges> ranges = bufferedAccountingForEndOfStream();
return abs(ranges->nearest(currentTime) - currentTime) <= currentTimeFudgeFactor();
}
bool SourceBuffer::hasFutureTime() const
{
if (isRemoved())
return false;
std::unique_ptr<PlatformTimeRanges> ranges = bufferedAccountingForEndOfStream();
if (!ranges->length())
return false;
MediaTime currentTime = m_source->currentTime();
MediaTime duration = m_source->duration();
if (currentTime >= duration)
return true;
MediaTime nearest = ranges->nearest(currentTime);
if (abs(nearest - currentTime) > currentTimeFudgeFactor())
return false;
size_t found = ranges->find(nearest);
if (found == notFound)
return false;
MediaTime localEnd = ranges->end(found);
if (localEnd == duration)
return true;
return localEnd - currentTime > currentTimeFudgeFactor();
}
bool SourceBuffer::canPlayThrough()
{
if (isRemoved())
return false;
monitorBufferingRate();
if (m_averageBufferRate > 1)
return true;
MediaTime currentTime = m_source->currentTime();
MediaTime duration = m_source->duration();
std::unique_ptr<PlatformTimeRanges> unbufferedRanges = bufferedAccountingForEndOfStream();
unbufferedRanges->invert();
unbufferedRanges->intersectWith(PlatformTimeRanges(currentTime, std::max(currentTime, duration)));
MediaTime unbufferedTime = unbufferedRanges->totalDuration();
if (!unbufferedTime.isValid())
return true;
MediaTime timeRemaining = duration - currentTime;
return unbufferedTime.toDouble() / m_averageBufferRate < timeRemaining.toDouble();
}
size_t SourceBuffer::extraMemoryCost() const
{
size_t extraMemoryCost = m_pendingAppendData.capacity();
for (auto& trackBuffer : m_trackBufferMap.values())
extraMemoryCost += trackBuffer.samples.sizeInBytes();
return extraMemoryCost;
}
void SourceBuffer::reportExtraMemoryAllocated()
{
size_t extraMemoryCost = this->extraMemoryCost();
if (extraMemoryCost <= m_reportedExtraMemoryCost)
return;
size_t extraMemoryCostDelta = extraMemoryCost - m_reportedExtraMemoryCost;
m_reportedExtraMemoryCost = extraMemoryCost;
JSC::JSLockHolder lock(scriptExecutionContext()->vm());
scriptExecutionContext()->vm().heap.deprecatedReportExtraMemory(extraMemoryCostDelta);
}
Vector<String> SourceBuffer::bufferedSamplesForTrackID(const AtomicString& trackID)
{
auto it = m_trackBufferMap.find(trackID);
if (it == m_trackBufferMap.end())
return Vector<String>();
TrackBuffer& trackBuffer = it->value;
Vector<String> sampleDescriptions;
for (auto& pair : trackBuffer.samples.decodeOrder())
sampleDescriptions.append(toString(*pair.second));
return sampleDescriptions;
}
Document& SourceBuffer::document() const
{
ASSERT(scriptExecutionContext());
return downcast<Document>(*scriptExecutionContext());
}
void SourceBuffer::setMode(AppendMode newMode, ExceptionCode& ec)
{
if (m_shouldGenerateTimestamps && newMode == AppendMode::Segments) {
ec = INVALID_ACCESS_ERR;
return;
}
if (isRemoved() || m_updating) {
ec = INVALID_STATE_ERR;
return;
}
if (m_source->readyState() == MediaSource::endedKeyword()) {
m_source->openIfInEndedState();
}
if (m_appendState == ParsingMediaSegment) {
ec = INVALID_STATE_ERR;
return;
}
if (newMode == AppendMode::Sequence)
m_groupStartTimestamp = m_groupEndTimestamp;
m_mode = newMode;
}
}
#endif