mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-21 01:05:45 +00:00
2be9a949c6
MediaDecoderStateMachine's EnqueueFIrstFrameLoadedEvent would previously call into MediaDecoderReader to update MDR's buffered ranges and enqueue the frame loaded event. This commit aims to instead have the buffered update take place, and only afterwards enqueue the event. This should remove the possibility that the event will be fired and handled before the update of the buffered ranges has taken place. MozReview-Commit-ID: GP8w2nF4xmj --HG-- extra : transplant_source : %A0m%13%95%E3Gs%ACMd%1F%F4%25%B9qE%28J%21R
497 lines
15 KiB
C++
497 lines
15 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim:set ts=2 sw=2 sts=2 et cindent: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#if !defined(MediaFormatReader_h_)
|
|
#define MediaFormatReader_h_
|
|
|
|
#include "mozilla/Atomics.h"
|
|
#include "mozilla/Maybe.h"
|
|
#include "mozilla/TaskQueue.h"
|
|
#include "mozilla/Monitor.h"
|
|
|
|
#include "MediaDataDemuxer.h"
|
|
#include "MediaDecoderReader.h"
|
|
#include "PDMFactory.h"
|
|
|
|
namespace mozilla {
|
|
|
|
class CDMProxy;
|
|
|
|
class MediaFormatReader final : public MediaDecoderReader
|
|
{
|
|
typedef TrackInfo::TrackType TrackType;
|
|
|
|
public:
|
|
MediaFormatReader(AbstractMediaDecoder* aDecoder,
|
|
MediaDataDemuxer* aDemuxer,
|
|
VideoFrameContainer* aVideoFrameContainer = nullptr,
|
|
layers::LayersBackend aLayersBackend = layers::LayersBackend::LAYERS_NONE);
|
|
|
|
virtual ~MediaFormatReader();
|
|
|
|
nsresult Init() override;
|
|
|
|
size_t SizeOfVideoQueueInFrames() override;
|
|
size_t SizeOfAudioQueueInFrames() override;
|
|
|
|
RefPtr<VideoDataPromise>
|
|
RequestVideoData(bool aSkipToNextKeyframe, int64_t aTimeThreshold) override;
|
|
|
|
RefPtr<AudioDataPromise> RequestAudioData() override;
|
|
|
|
RefPtr<MetadataPromise> AsyncReadMetadata() override;
|
|
|
|
void ReadUpdatedMetadata(MediaInfo* aInfo) override;
|
|
|
|
RefPtr<SeekPromise>
|
|
Seek(SeekTarget aTarget, int64_t aUnused) override;
|
|
|
|
protected:
|
|
void NotifyDataArrivedInternal() override;
|
|
|
|
public:
|
|
media::TimeIntervals GetBuffered() override;
|
|
|
|
RefPtr<BufferedUpdatePromise> UpdateBufferedWithPromise() override;
|
|
|
|
bool ForceZeroStartTime() const override;
|
|
|
|
// For Media Resource Management
|
|
void ReleaseMediaResources() override;
|
|
|
|
nsresult ResetDecode() override;
|
|
|
|
RefPtr<ShutdownPromise> Shutdown() override;
|
|
|
|
bool IsAsync() const override { return true; }
|
|
|
|
bool VideoIsHardwareAccelerated() const override;
|
|
|
|
void DisableHardwareAcceleration() override;
|
|
|
|
bool IsWaitForDataSupported() override { return true; }
|
|
RefPtr<WaitForDataPromise> WaitForData(MediaData::Type aType) override;
|
|
|
|
// MediaFormatReader supports demuxed-only mode.
|
|
bool IsDemuxOnlySupported() const override { return true; }
|
|
|
|
void SetDemuxOnly(bool aDemuxedOnly) override
|
|
{
|
|
if (OnTaskQueue()) {
|
|
mDemuxOnly = aDemuxedOnly;
|
|
return;
|
|
}
|
|
nsCOMPtr<nsIRunnable> r = NS_NewRunnableMethodWithArg<bool>(
|
|
this, &MediaDecoderReader::SetDemuxOnly, aDemuxedOnly);
|
|
OwnerThread()->Dispatch(r.forget());
|
|
}
|
|
|
|
bool UseBufferingHeuristics() override
|
|
{
|
|
return mTrackDemuxersMayBlock;
|
|
}
|
|
|
|
#ifdef MOZ_EME
|
|
void SetCDMProxy(CDMProxy* aProxy) override;
|
|
#endif
|
|
|
|
// Returns a string describing the state of the decoder data.
|
|
// Used for debugging purposes.
|
|
void GetMozDebugReaderData(nsAString& aString);
|
|
|
|
private:
|
|
bool HasVideo() { return mVideo.mTrackDemuxer; }
|
|
bool HasAudio() { return mAudio.mTrackDemuxer; }
|
|
|
|
bool IsWaitingOnCDMResource();
|
|
|
|
bool InitDemuxer();
|
|
// Notify the demuxer that new data has been received.
|
|
// The next queued task calling GetBuffered() is guaranteed to have up to date
|
|
// buffered ranges.
|
|
void NotifyDemuxer();
|
|
void ReturnOutput(MediaData* aData, TrackType aTrack);
|
|
|
|
bool EnsureDecoderCreated(TrackType aTrack);
|
|
bool EnsureDecoderInitialized(TrackType aTrack);
|
|
|
|
// Enqueues a task to call Update(aTrack) on the decoder task queue.
|
|
// Lock for corresponding track must be held.
|
|
void ScheduleUpdate(TrackType aTrack);
|
|
void Update(TrackType aTrack);
|
|
// Handle actions should more data be received.
|
|
// Returns true if no more action is required.
|
|
bool UpdateReceivedNewData(TrackType aTrack);
|
|
// Called when new samples need to be demuxed.
|
|
void RequestDemuxSamples(TrackType aTrack);
|
|
// Handle demuxed samples by the input behavior.
|
|
void HandleDemuxedSamples(TrackType aTrack,
|
|
AbstractMediaDecoder::AutoNotifyDecoded& aA);
|
|
// Decode any pending already demuxed samples.
|
|
bool DecodeDemuxedSamples(TrackType aTrack,
|
|
MediaRawData* aSample);
|
|
|
|
struct InternalSeekTarget {
|
|
InternalSeekTarget(const media::TimeUnit& aTime, bool aDropTarget)
|
|
: mTime(aTime)
|
|
, mDropTarget(aDropTarget)
|
|
, mWaiting(false)
|
|
{}
|
|
|
|
media::TimeUnit mTime;
|
|
bool mDropTarget;
|
|
bool mWaiting;
|
|
};
|
|
// Perform an internal seek to aTime. If aDropTarget is true then
|
|
// the first sample past the target will be dropped.
|
|
void InternalSeek(TrackType aTrack, const InternalSeekTarget& aTarget);
|
|
|
|
// Drain the current decoder.
|
|
void DrainDecoder(TrackType aTrack);
|
|
void NotifyNewOutput(TrackType aTrack, MediaData* aSample);
|
|
void NotifyInputExhausted(TrackType aTrack);
|
|
void NotifyDrainComplete(TrackType aTrack);
|
|
void NotifyError(TrackType aTrack);
|
|
void NotifyWaitingForData(TrackType aTrack);
|
|
void NotifyEndOfStream(TrackType aTrack);
|
|
void NotifyDecodingRequested(TrackType aTrack);
|
|
|
|
void ExtractCryptoInitData(nsTArray<uint8_t>& aInitData);
|
|
|
|
// Initializes mLayersBackendType if possible.
|
|
void InitLayersBackendType();
|
|
|
|
// DecoderCallback proxies the MediaDataDecoderCallback calls to these
|
|
// functions.
|
|
void Output(TrackType aType, MediaData* aSample);
|
|
void InputExhausted(TrackType aTrack);
|
|
void Error(TrackType aTrack);
|
|
void Flush(TrackType aTrack);
|
|
void DrainComplete(TrackType aTrack);
|
|
|
|
bool ShouldSkip(bool aSkipToNextKeyframe, media::TimeUnit aTimeThreshold);
|
|
|
|
size_t SizeOfQueue(TrackType aTrack);
|
|
|
|
RefPtr<PDMFactory> mPlatform;
|
|
|
|
class DecoderCallback : public MediaDataDecoderCallback {
|
|
public:
|
|
DecoderCallback(MediaFormatReader* aReader, TrackType aType)
|
|
: mReader(aReader)
|
|
, mType(aType)
|
|
{
|
|
}
|
|
void Output(MediaData* aSample) override {
|
|
mReader->Output(mType, aSample);
|
|
}
|
|
void InputExhausted() override {
|
|
mReader->InputExhausted(mType);
|
|
}
|
|
void Error() override {
|
|
mReader->Error(mType);
|
|
}
|
|
void DrainComplete() override {
|
|
mReader->DrainComplete(mType);
|
|
}
|
|
void ReleaseMediaResources() override {
|
|
mReader->ReleaseMediaResources();
|
|
}
|
|
bool OnReaderTaskQueue() override {
|
|
return mReader->OnTaskQueue();
|
|
}
|
|
|
|
private:
|
|
MediaFormatReader* mReader;
|
|
TrackType mType;
|
|
};
|
|
|
|
struct DecoderData {
|
|
DecoderData(MediaFormatReader* aOwner,
|
|
MediaData::Type aType,
|
|
uint32_t aDecodeAhead)
|
|
: mOwner(aOwner)
|
|
, mType(aType)
|
|
, mMonitor("DecoderData")
|
|
, mDescription("shutdown")
|
|
, mDecodeAhead(aDecodeAhead)
|
|
, mUpdateScheduled(false)
|
|
, mDemuxEOS(false)
|
|
, mWaitingForData(false)
|
|
, mReceivedNewData(false)
|
|
, mDiscontinuity(true)
|
|
, mDecoderInitialized(false)
|
|
, mDecodingRequested(false)
|
|
, mOutputRequested(false)
|
|
, mInputExhausted(false)
|
|
, mError(false)
|
|
, mNeedDraining(false)
|
|
, mDraining(false)
|
|
, mDrainComplete(false)
|
|
, mNumSamplesInput(0)
|
|
, mNumSamplesOutput(0)
|
|
, mNumSamplesOutputTotal(0)
|
|
, mNumSamplesSkippedTotal(0)
|
|
, mNumSamplesOutputTotalSinceTelemetry(0)
|
|
, mNumSamplesSkippedTotalSinceTelemetry(0)
|
|
, mSizeOfQueue(0)
|
|
, mIsHardwareAccelerated(false)
|
|
, mLastStreamSourceID(UINT32_MAX)
|
|
{}
|
|
|
|
MediaFormatReader* mOwner;
|
|
// Disambiguate Audio vs Video.
|
|
MediaData::Type mType;
|
|
RefPtr<MediaTrackDemuxer> mTrackDemuxer;
|
|
// TaskQueue on which decoder can choose to decode.
|
|
// Only non-null up until the decoder is created.
|
|
RefPtr<FlushableTaskQueue> mTaskQueue;
|
|
// Callback that receives output and error notifications from the decoder.
|
|
nsAutoPtr<DecoderCallback> mCallback;
|
|
|
|
// Monitor protecting mDescription and mDecoder.
|
|
Monitor mMonitor;
|
|
// The platform decoder.
|
|
RefPtr<MediaDataDecoder> mDecoder;
|
|
const char* mDescription;
|
|
void ShutdownDecoder()
|
|
{
|
|
MonitorAutoLock mon(mMonitor);
|
|
if (mDecoder) {
|
|
mDecoder->Shutdown();
|
|
}
|
|
mDescription = "shutdown";
|
|
mDecoder = nullptr;
|
|
}
|
|
|
|
// Only accessed from reader's task queue.
|
|
uint32_t mDecodeAhead;
|
|
bool mUpdateScheduled;
|
|
bool mDemuxEOS;
|
|
bool mWaitingForData;
|
|
bool mReceivedNewData;
|
|
bool mDiscontinuity;
|
|
|
|
// Pending seek.
|
|
MozPromiseRequestHolder<MediaTrackDemuxer::SeekPromise> mSeekRequest;
|
|
|
|
// Queued demux samples waiting to be decoded.
|
|
nsTArray<RefPtr<MediaRawData>> mQueuedSamples;
|
|
MozPromiseRequestHolder<MediaTrackDemuxer::SamplesPromise> mDemuxRequest;
|
|
MozPromiseHolder<WaitForDataPromise> mWaitingPromise;
|
|
bool HasWaitingPromise()
|
|
{
|
|
MOZ_ASSERT(mOwner->OnTaskQueue());
|
|
return !mWaitingPromise.IsEmpty();
|
|
}
|
|
|
|
// MediaDataDecoder handler's variables.
|
|
// Decoder initialization promise holder.
|
|
MozPromiseRequestHolder<MediaDataDecoder::InitPromise> mInitPromise;
|
|
// False when decoder is created. True when decoder Init() promise is resolved.
|
|
bool mDecoderInitialized;
|
|
bool mDecodingRequested;
|
|
bool mOutputRequested;
|
|
bool mInputExhausted;
|
|
bool mError;
|
|
bool mNeedDraining;
|
|
bool mDraining;
|
|
bool mDrainComplete;
|
|
// If set, all decoded samples prior mTimeThreshold will be dropped.
|
|
// Used for internal seeking when a change of stream is detected or when
|
|
// encountering data discontinuity.
|
|
Maybe<InternalSeekTarget> mTimeThreshold;
|
|
// Time of last sample returned.
|
|
Maybe<media::TimeUnit> mLastSampleTime;
|
|
|
|
// Decoded samples returned my mDecoder awaiting being returned to
|
|
// state machine upon request.
|
|
nsTArray<RefPtr<MediaData>> mOutput;
|
|
uint64_t mNumSamplesInput;
|
|
uint64_t mNumSamplesOutput;
|
|
uint64_t mNumSamplesOutputTotal;
|
|
uint64_t mNumSamplesSkippedTotal;
|
|
|
|
uint64_t mNumSamplesOutputTotalSinceTelemetry;
|
|
uint64_t mNumSamplesSkippedTotalSinceTelemetry;
|
|
|
|
// These get overriden in the templated concrete class.
|
|
// Indicate if we have a pending promise for decoded frame.
|
|
// Rejecting the promise will stop the reader from decoding ahead.
|
|
virtual bool HasPromise() = 0;
|
|
virtual void RejectPromise(MediaDecoderReader::NotDecodedReason aReason,
|
|
const char* aMethodName) = 0;
|
|
|
|
void ResetDemuxer()
|
|
{
|
|
// Clear demuxer related data.
|
|
mDemuxRequest.DisconnectIfExists();
|
|
mTrackDemuxer->Reset();
|
|
}
|
|
|
|
void ResetState()
|
|
{
|
|
MOZ_ASSERT(mOwner->OnTaskQueue());
|
|
mDemuxEOS = false;
|
|
mWaitingForData = false;
|
|
mReceivedNewData = false;
|
|
mDiscontinuity = true;
|
|
mQueuedSamples.Clear();
|
|
mDecodingRequested = false;
|
|
mOutputRequested = false;
|
|
mInputExhausted = false;
|
|
mNeedDraining = false;
|
|
mDraining = false;
|
|
mDrainComplete = false;
|
|
mTimeThreshold.reset();
|
|
mLastSampleTime.reset();
|
|
mOutput.Clear();
|
|
mNumSamplesInput = 0;
|
|
mNumSamplesOutput = 0;
|
|
mSizeOfQueue = 0;
|
|
mNextStreamSourceID.reset();
|
|
}
|
|
|
|
// Used by the MDSM for logging purposes.
|
|
Atomic<size_t> mSizeOfQueue;
|
|
// Used by the MDSM to determine if video decoding is hardware accelerated.
|
|
// This value is updated after a frame is successfully decoded.
|
|
Atomic<bool> mIsHardwareAccelerated;
|
|
// Sample format monitoring.
|
|
uint32_t mLastStreamSourceID;
|
|
Maybe<uint32_t> mNextStreamSourceID;
|
|
media::TimeIntervals mTimeRanges;
|
|
Maybe<media::TimeUnit> mLastTimeRangesEnd;
|
|
RefPtr<SharedTrackInfo> mInfo;
|
|
};
|
|
|
|
template<typename PromiseType>
|
|
struct DecoderDataWithPromise : public DecoderData {
|
|
DecoderDataWithPromise(MediaFormatReader* aOwner,
|
|
MediaData::Type aType,
|
|
uint32_t aDecodeAhead) :
|
|
DecoderData(aOwner, aType, aDecodeAhead)
|
|
{}
|
|
|
|
MozPromiseHolder<PromiseType> mPromise;
|
|
|
|
bool HasPromise() override
|
|
{
|
|
MOZ_ASSERT(mOwner->OnTaskQueue());
|
|
return !mPromise.IsEmpty();
|
|
}
|
|
|
|
void RejectPromise(MediaDecoderReader::NotDecodedReason aReason,
|
|
const char* aMethodName) override
|
|
{
|
|
MOZ_ASSERT(mOwner->OnTaskQueue());
|
|
mPromise.Reject(aReason, aMethodName);
|
|
mDecodingRequested = false;
|
|
}
|
|
};
|
|
|
|
DecoderDataWithPromise<AudioDataPromise> mAudio;
|
|
DecoderDataWithPromise<VideoDataPromise> mVideo;
|
|
|
|
// Returns true when the decoder for this track needs input.
|
|
bool NeedInput(DecoderData& aDecoder);
|
|
|
|
DecoderData& GetDecoderData(TrackType aTrack);
|
|
|
|
// Demuxer objects.
|
|
RefPtr<MediaDataDemuxer> mDemuxer;
|
|
bool mDemuxerInitDone;
|
|
void OnDemuxerInitDone(nsresult);
|
|
void OnDemuxerInitFailed(DemuxerFailureReason aFailure);
|
|
MozPromiseRequestHolder<MediaDataDemuxer::InitPromise> mDemuxerInitRequest;
|
|
void OnDemuxFailed(TrackType aTrack, DemuxerFailureReason aFailure);
|
|
|
|
void DoDemuxVideo();
|
|
void OnVideoDemuxCompleted(RefPtr<MediaTrackDemuxer::SamplesHolder> aSamples);
|
|
void OnVideoDemuxFailed(DemuxerFailureReason aFailure)
|
|
{
|
|
OnDemuxFailed(TrackType::kVideoTrack, aFailure);
|
|
}
|
|
|
|
void DoDemuxAudio();
|
|
void OnAudioDemuxCompleted(RefPtr<MediaTrackDemuxer::SamplesHolder> aSamples);
|
|
void OnAudioDemuxFailed(DemuxerFailureReason aFailure)
|
|
{
|
|
OnDemuxFailed(TrackType::kAudioTrack, aFailure);
|
|
}
|
|
|
|
void SkipVideoDemuxToNextKeyFrame(media::TimeUnit aTimeThreshold);
|
|
MozPromiseRequestHolder<MediaTrackDemuxer::SkipAccessPointPromise> mSkipRequest;
|
|
void OnVideoSkipCompleted(uint32_t aSkipped);
|
|
void OnVideoSkipFailed(MediaTrackDemuxer::SkipFailureHolder aFailure);
|
|
|
|
// The last number of decoded output frames that we've reported to
|
|
// MediaDecoder::NotifyDecoded(). We diff the number of output video
|
|
// frames every time that DecodeVideoData() is called, and report the
|
|
// delta there.
|
|
uint64_t mLastReportedNumDecodedFrames;
|
|
|
|
layers::LayersBackend mLayersBackendType;
|
|
|
|
// Metadata objects
|
|
// True if we've read the streams' metadata.
|
|
bool mInitDone;
|
|
MozPromiseHolder<MetadataPromise> mMetadataPromise;
|
|
bool IsEncrypted()
|
|
{
|
|
return mIsEncrypted;
|
|
}
|
|
bool mIsEncrypted;
|
|
|
|
// Set to true if any of our track buffers may be blocking.
|
|
bool mTrackDemuxersMayBlock;
|
|
|
|
bool mHardwareAccelerationDisabled;
|
|
|
|
// Set the demuxed-only flag.
|
|
Atomic<bool> mDemuxOnly;
|
|
|
|
// Seeking objects.
|
|
bool IsSeeking() const { return mPendingSeekTime.isSome(); }
|
|
void AttemptSeek();
|
|
void OnSeekFailed(TrackType aTrack, DemuxerFailureReason aFailure);
|
|
void DoVideoSeek();
|
|
void OnVideoSeekCompleted(media::TimeUnit aTime);
|
|
void OnVideoSeekFailed(DemuxerFailureReason aFailure)
|
|
{
|
|
OnSeekFailed(TrackType::kVideoTrack, aFailure);
|
|
}
|
|
|
|
void DoAudioSeek();
|
|
void OnAudioSeekCompleted(media::TimeUnit aTime);
|
|
void OnAudioSeekFailed(DemuxerFailureReason aFailure)
|
|
{
|
|
OnSeekFailed(TrackType::kAudioTrack, aFailure);
|
|
}
|
|
|
|
void ReportDroppedFramesTelemetry();
|
|
|
|
// Temporary seek information while we wait for the data
|
|
Maybe<SeekTarget> mOriginalSeekTarget;
|
|
Maybe<media::TimeUnit> mPendingSeekTime;
|
|
MozPromiseHolder<SeekPromise> mSeekPromise;
|
|
|
|
RefPtr<VideoFrameContainer> mVideoFrameContainer;
|
|
layers::ImageContainer* GetImageContainer();
|
|
|
|
#ifdef MOZ_EME
|
|
RefPtr<CDMProxy> mCDMProxy;
|
|
#endif
|
|
|
|
#if defined(READER_DORMANT_HEURISTIC)
|
|
const bool mDormantEnabled;
|
|
#endif
|
|
};
|
|
|
|
} // namespace mozilla
|
|
|
|
#endif
|