wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity

Bug 1163486 - Remove MP4Reader. r=jya

Browse Source
This commit is contained in:
Alfredo Yang 2015-07-20 19:25:00 +02:00
parent 30d4c98ce4
commit 9d9f2ec1dd
25 changed files with 22 additions and 1877 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
dom/media/DecoderTraits.cpp
View File

@ -66,7 +66,6 @@
#include "AppleMP3Reader.h"
#endif
#ifdef MOZ_FMP4
#include "MP4Reader.h"
#include "MP4Decoder.h"
#include "MP4Demuxer.h"
#endif
@ -654,9 +653,7 @@ MediaDecoderReader* DecoderTraits::CreateReader(const nsACString& aType, Abstrac
}
#ifdef MOZ_FMP4
if (IsMP4SupportedType(aType)) {
decoderReader = Preferences::GetBool("media.format-reader.mp4", true) ?
static_cast<MediaDecoderReader*>(new MediaFormatReader(aDecoder, new MP4Demuxer(aDecoder->GetResource()))) :
static_cast<MediaDecoderReader*>(new MP4Reader(aDecoder));
decoderReader = new MediaFormatReader(aDecoder, new MP4Demuxer(aDecoder->GetResource()));
} else
#endif
if (IsMP3SupportedType(aType)) {

11
dom/media/fmp4/MP4Decoder.cpp
View File

@ -5,7 +5,6 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "MP4Decoder.h"
#include "MP4Reader.h"
#include "MediaDecoderStateMachine.h"
#include "MediaFormatReader.h"
#include "MP4Demuxer.h"
@ -42,11 +41,7 @@ MP4Decoder::MP4Decoder()
MediaDecoderStateMachine* MP4Decoder::CreateStateMachine()
{
bool useFormatDecoder =
Preferences::GetBool("media.format-reader.mp4", true);
nsRefPtr<MediaDecoderReader> reader = useFormatDecoder ?
static_cast<MediaDecoderReader*>(new MediaFormatReader(this, new MP4Demuxer(GetResource()))) :
static_cast<MediaDecoderReader*>(new MP4Reader(this));
MediaDecoderReader* reader = new MediaFormatReader(this, new MP4Demuxer(GetResource()));
return new MediaDecoderStateMachine(this, reader);
}
@ -58,8 +53,8 @@ MP4Decoder::SetCDMProxy(CDMProxy* aProxy)
nsresult rv = MediaDecoder::SetCDMProxy(aProxy);
NS_ENSURE_SUCCESS(rv, rv);
if (aProxy) {
// The MP4Reader can't decrypt EME content until it has a CDMProxy,
// and the CDMProxy knows the capabilities of the CDM. The MP4Reader
// The MediaFormatReader can't decrypt EME content until it has a CDMProxy,
// and the CDMProxy knows the capabilities of the CDM. The MediaFormatReader
// remains in "waiting for resources" state until then.
CDMCaps::AutoLock caps(aProxy->Capabilites());
nsCOMPtr<nsIRunnable> task(

8
dom/media/fmp4/MP4Demuxer.cpp
View File

@ -20,6 +20,14 @@
#include "mp4_demuxer/AnnexB.h"
#include "mp4_demuxer/H264.h"
PRLogModuleInfo* GetDemuxerLog() {
static PRLogModuleInfo* log = nullptr;
if (!log) {
log = PR_NewLogModule("MP4Demuxer");
}
return log;
}
namespace mozilla {
// Returns true if no SPS was found and search for it should continue.

1136
dom/media/fmp4/MP4Reader.cpp
View File

File diff suppressed because it is too large Load Diff

280
dom/media/fmp4/MP4Reader.h
View File

@ -1,280 +0,0 @@
/* -*- 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(MP4Reader_h_)
#define MP4Reader_h_
#include "mozilla/Monitor.h"
#include "mozilla/TaskQueue.h"
#include "MediaDecoderReader.h"
#include "nsAutoPtr.h"
#include "PlatformDecoderModule.h"
#include "mp4_demuxer/mp4_demuxer.h"
#include "demuxer/TrackDemuxer.h"
#include <deque>
namespace mozilla {
typedef std::deque<nsRefPtr<MediaRawData>> MediaSampleQueue;
class MP4Stream;
class MP4Reader final : public MediaDecoderReader
{
typedef TrackInfo::TrackType TrackType;
public:
explicit MP4Reader(AbstractMediaDecoder* aDecoder, TaskQueue* aBorrowedTaskQueue = nullptr);
virtual ~MP4Reader();
virtual nsresult Init(MediaDecoderReader* aCloneDonor) override;
virtual size_t SizeOfVideoQueueInFrames() override;
virtual size_t SizeOfAudioQueueInFrames() override;
virtual nsRefPtr<VideoDataPromise>
RequestVideoData(bool aSkipToNextKeyframe, int64_t aTimeThreshold, bool aForceDecodeAhead) override;
virtual nsRefPtr<AudioDataPromise> RequestAudioData() override;
virtual bool HasAudio() override;
virtual bool HasVideo() override;
virtual nsresult ReadMetadata(MediaInfo* aInfo,
MetadataTags** aTags) override;
virtual void ReadUpdatedMetadata(MediaInfo* aInfo) override;
virtual nsRefPtr<SeekPromise>
Seek(int64_t aTime, int64_t aEndTime) override;
virtual bool IsMediaSeekable() override;
virtual int64_t GetEvictionOffset(double aTime) override;
protected:
virtual void NotifyDataArrivedInternal(uint32_t aLength, int64_t aOffset) override;
public:
virtual media::TimeIntervals GetBuffered() override;
// For Media Resource Management
virtual void SetIdle() override;
virtual void ReleaseMediaResources() override;
virtual void SetSharedDecoderManager(SharedDecoderManager* aManager)
override;
virtual nsresult ResetDecode() override;
virtual nsRefPtr<ShutdownPromise> Shutdown() override;
virtual bool IsAsync() const override { return true; }
virtual bool VideoIsHardwareAccelerated() const override;
virtual void DisableHardwareAcceleration() override;
private:
bool InitDemuxer();
void ReturnOutput(MediaData* aData, TrackType aTrack);
bool EnsureDecodersSetup();
// Sends input to decoder for aTrack, and output to the state machine,
// if necessary.
void Update(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 ExtractCryptoInitData(nsTArray<uint8_t>& aInitData);
// Initializes mLayersBackendType if possible.
void InitLayersBackendType();
// Blocks until the demuxer produces an sample of specified type.
// Returns nullptr on error on EOS. Caller must delete sample.
already_AddRefed<MediaRawData> PopSample(TrackType aTrack);
already_AddRefed<MediaRawData> PopSampleLocked(TrackType aTrack);
bool SkipVideoDemuxToNextKeyFrame(int64_t aTimeThreshold, uint32_t& parsed);
// 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);
void UpdateIndex();
bool IsSupportedAudioMimeType(const nsACString& aMimeType);
bool IsSupportedVideoMimeType(const nsACString& aMimeType);
virtual bool IsWaitingOnCDMResource() override;
mp4_demuxer::Microseconds GetNextKeyframeTime();
bool ShouldSkip(bool aSkipToNextKeyframe, int64_t aTimeThreshold);
size_t SizeOfQueue(TrackType aTrack);
nsRefPtr<MP4Stream> mStream;
nsRefPtr<mp4_demuxer::MP4Demuxer> mDemuxer;
nsRefPtr<PlatformDecoderModule> mPlatform;
mp4_demuxer::CryptoFile mCrypto;
class DecoderCallback : public MediaDataDecoderCallback {
public:
DecoderCallback(MP4Reader* aReader, TrackType aType)
: mReader(aReader)
, mType(aType)
{
}
virtual void Output(MediaData* aSample) override {
mReader->Output(mType, aSample);
}
virtual void InputExhausted() override {
mReader->InputExhausted(mType);
}
virtual void Error() override {
mReader->Error(mType);
}
virtual void DrainComplete() override {
mReader->DrainComplete(mType);
}
virtual void ReleaseMediaResources() override {
mReader->ReleaseMediaResources();
}
virtual bool OnReaderTaskQueue() override {
return mReader->OnTaskQueue();
}
private:
MP4Reader* mReader;
TrackType mType;
};
struct DecoderData {
DecoderData(MediaData::Type aType,
uint32_t aDecodeAhead)
: mType(aType)
, mMonitor(aType == MediaData::AUDIO_DATA ? "MP4 audio decoder data"
: "MP4 video decoder data")
, mNumSamplesInput(0)
, mNumSamplesOutput(0)
, mDecodeAhead(aDecodeAhead)
, mForceDecodeAhead(false)
, mActive(false)
, mInputExhausted(false)
, mError(false)
, mIsFlushing(false)
, mUpdateScheduled(false)
, mDemuxEOS(false)
, mDrainComplete(false)
, mDiscontinuity(false)
{
}
nsAutoPtr<TrackDemuxer> mTrackDemuxer;
// The platform decoder.
nsRefPtr<MediaDataDecoder> mDecoder;
// TaskQueue on which decoder can choose to decode.
// Only non-null up until the decoder is created.
nsRefPtr<FlushableTaskQueue> mTaskQueue;
// Callback that receives output and error notifications from the decoder.
nsAutoPtr<DecoderCallback> mCallback;
// Decoded samples returned my mDecoder awaiting being returned to
// state machine upon request.
nsTArray<nsRefPtr<MediaData> > mOutput;
// Disambiguate Audio vs Video.
MediaData::Type mType;
// These get overriden in the templated concrete class.
virtual bool HasPromise() = 0;
virtual void RejectPromise(MediaDecoderReader::NotDecodedReason aReason,
const char* aMethodName) = 0;
// Monitor that protects all non-threadsafe state; the primitives
// that follow.
Monitor mMonitor;
uint64_t mNumSamplesInput;
uint64_t mNumSamplesOutput;
uint32_t mDecodeAhead;
bool mForceDecodeAhead;
// Whether this stream exists in the media.
bool mActive;
bool mInputExhausted;
bool mError;
bool mIsFlushing;
bool mUpdateScheduled;
bool mDemuxEOS;
bool mDrainComplete;
bool mDiscontinuity;
};
template<typename PromiseType>
struct DecoderDataWithPromise : public DecoderData {
DecoderDataWithPromise(MediaData::Type aType, uint32_t aDecodeAhead) :
DecoderData(aType, aDecodeAhead)
{
mPromise.SetMonitor(&mMonitor);
}
MozPromiseHolder<PromiseType> mPromise;
bool HasPromise() override { return !mPromise.IsEmpty(); }
void RejectPromise(MediaDecoderReader::NotDecodedReason aReason,
const char* aMethodName) override
{
mPromise.Reject(aReason, aMethodName);
}
};
DecoderDataWithPromise<AudioDataPromise> mAudio;
DecoderDataWithPromise<VideoDataPromise> mVideo;
// Queued samples extracted by the demuxer, but not yet sent to the platform
// decoder.
nsRefPtr<MediaRawData> mQueuedVideoSample;
// Returns true when the decoder for this track needs input.
// aDecoder.mMonitor must be locked.
bool NeedInput(DecoderData& aDecoder);
// 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;
DecoderData& GetDecoderData(TrackType aTrack);
layers::LayersBackend mLayersBackendType;
// For use with InvokeAndRetry as an already_refed can't be converted to bool
nsRefPtr<MediaRawData> DemuxVideoSample();
nsRefPtr<MediaRawData> DemuxAudioSample();
// True if we've read the streams' metadata.
bool mDemuxerInitialized;
// True if we've gathered telemetry from an SPS.
bool mFoundSPSForTelemetry;
// Synchronized by decoder monitor.
bool mIsEncrypted;
bool mIndexReady;
int64_t mLastSeenEnd;
Monitor mDemuxerMonitor;
nsRefPtr<SharedDecoderManager> mSharedDecoderManager;
};
} // namespace mozilla
#endif

2
dom/media/fmp4/MP4Stream.h
View File

@ -7,7 +7,7 @@
#ifndef MP4_STREAM_H_
#define MP4_STREAM_H_
#include "mp4_demuxer/mp4_demuxer.h"
#include "mp4_demuxer/Stream.h"
#include "MediaResource.h"

2
dom/media/fmp4/moz.build
View File

@ -7,7 +7,6 @@
EXPORTS += [
'MP4Decoder.h',
'MP4Demuxer.h',
'MP4Reader.h',
'MP4Stream.h',
]
@ -18,7 +17,6 @@ UNIFIED_SOURCES += [
SOURCES += [
'MP4Demuxer.cpp',
'MP4Reader.cpp',
]
FINAL_LIBRARY = 'xul'

1
dom/media/gtest/moz.build
View File

@ -12,7 +12,6 @@ UNIFIED_SOURCES += [
'TestIntervalSet.cpp',
'TestMozPromise.cpp',
'TestMP3Demuxer.cpp',
'TestMP4Demuxer.cpp',
# 'TestMP4Reader.cpp', disabled so we can turn check tests back on (bug 1175752)
'TestTrackEncoder.cpp',
'TestVideoSegment.cpp',

10
dom/media/mediasource/MediaSourceReader.cpp
View File

@ -20,7 +20,6 @@
#include "SharedDecoderManager.h"
#include "MP4Decoder.h"
#include "MP4Demuxer.h"
#include "MP4Reader.h"
#endif
#ifdef MOZ_WEBM
@ -701,18 +700,15 @@ CreateReaderForType(const nsACString& aType, AbstractMediaDecoder* aDecoder,
TaskQueue* aBorrowedTaskQueue)
{
#ifdef MOZ_FMP4
// The MP4Reader that supports fragmented MP4 and uses
// The MediaFormatReader that supports fragmented MP4 and uses
// PlatformDecoderModules is hidden behind prefs for regular video
// elements, but we always want to use it for MSE, so instantiate it
// directly here.
if ((aType.LowerCaseEqualsLiteral("video/mp4") ||
aType.LowerCaseEqualsLiteral("audio/mp4")) &&
MP4Decoder::IsEnabled() && aDecoder) {
bool useFormatDecoder =
Preferences::GetBool("media.mediasource.format-reader.mp4", true);
MediaDecoderReader* reader = useFormatDecoder ?
static_cast<MediaDecoderReader*>(new MediaFormatReader(aDecoder, new MP4Demuxer(aDecoder->GetResource()), aBorrowedTaskQueue)) :
static_cast<MediaDecoderReader*>(new MP4Reader(aDecoder, aBorrowedTaskQueue));
MediaDecoderReader* reader =
new MediaFormatReader(aDecoder, new MP4Demuxer(aDecoder->GetResource()), aBorrowedTaskQueue);
return reader;
}
#endif

1
dom/media/platforms/apple/AppleATDecoder.cpp
View File

@ -5,7 +5,6 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "AppleUtils.h"
#include "MP4Reader.h"
#include "MP4Decoder.h"
#include "mp4_demuxer/Adts.h"
#include "MediaInfo.h"

1
dom/media/platforms/apple/AppleVDADecoder.h
View File

@ -9,7 +9,6 @@
#include "PlatformDecoderModule.h"
#include "mozilla/ReentrantMonitor.h"
#include "MP4Reader.h"
#include "MP4Decoder.h"
#include "nsIThread.h"
#include "ReorderQueue.h"

1
dom/media/platforms/ffmpeg/FFmpegDataDecoder.h
View File

@ -10,7 +10,6 @@
#include "PlatformDecoderModule.h"
#include "FFmpegLibs.h"
#include "mozilla/StaticMutex.h"
#include "mp4_demuxer/mp4_demuxer.h"
namespace mozilla
{

1
dom/media/platforms/wmf/WMFAudioMFTManager.h
View File

@ -8,7 +8,6 @@
#define WMFAudioOutputSource_h_
#include "WMF.h"
#include "MP4Reader.h"
#include "MFTDecoder.h"
#include "mozilla/RefPtr.h"
#include "WMFMediaDataDecoder.h"

2
dom/media/platforms/wmf/WMFMediaDataDecoder.h
View File

@ -9,9 +9,9 @@
#include "WMF.h"
#include "MP4Reader.h"
#include "MFTDecoder.h"
#include "mozilla/RefPtr.h"
#include "PlatformDecoderModule.h"
namespace mozilla {

1
dom/media/platforms/wmf/WMFVideoMFTManager.h
View File

@ -8,7 +8,6 @@
#define WMFVideoMFTManager_h_
#include "WMF.h"
#include "MP4Reader.h"
#include "MFTDecoder.h"
#include "nsRect.h"
#include "WMFMediaDataDecoder.h"

2
dom/media/webm/IntelWebMVideoDecoder.cpp
View File

@ -24,8 +24,6 @@
PRLogModuleInfo* GetDemuxerLog();
#define LOG(...) MOZ_LOG(GetDemuxerLog(), mozilla::LogLevel::Debug, (__VA_ARGS__))
using namespace mp4_demuxer;
namespace mozilla {
using layers::Image;

1
dom/media/webm/IntelWebMVideoDecoder.h
View File

@ -13,7 +13,6 @@
#include "PlatformDecoderModule.h"
#include "mozilla/Monitor.h"
#include "mp4_demuxer/mp4_demuxer.h"
#include "MediaInfo.h"
#include "MediaData.h"

2
media/libstagefright/binding/Box.cpp
View File

@ -5,7 +5,7 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "mp4_demuxer/Box.h"
#include "mp4_demuxer/mp4_demuxer.h"
#include "mp4_demuxer/Stream.h"
#include "mozilla/Endian.h"
#include <algorithm>

51
media/libstagefright/binding/MP4TrackDemuxer.cpp
View File

@ -1,51 +0,0 @@
/* -*- 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/. */
#include "mp4_demuxer/MP4TrackDemuxer.h"
using namespace mozilla;
namespace mp4_demuxer {
void
MP4AudioDemuxer::Seek(Microseconds aTime)
{
mDemuxer->SeekAudio(aTime);
}
already_AddRefed<MediaRawData>
MP4AudioDemuxer::DemuxSample()
{
nsRefPtr<MediaRawData> sample(mDemuxer->DemuxAudioSample());
return sample.forget();
}
Microseconds
MP4AudioDemuxer::GetNextKeyframeTime()
{
return -1;
}
void
MP4VideoDemuxer::Seek(Microseconds aTime)
{
mDemuxer->SeekVideo(aTime);
}
already_AddRefed<MediaRawData>
MP4VideoDemuxer::DemuxSample()
{
nsRefPtr<MediaRawData> sample(mDemuxer->DemuxVideoSample());
return sample.forget();
}
Microseconds
MP4VideoDemuxer::GetNextKeyframeTime()
{
return mDemuxer->GetNextKeyframeTime();
}
}

38
media/libstagefright/binding/include/mp4_demuxer/MP4TrackDemuxer.h
View File

@ -1,38 +0,0 @@
/* 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/. */
#ifndef MP4_TRACK_DEMUXER_H_
#define MP4_TRACK_DEMUXER_H_
#include "mozilla/Attributes.h"
#include "demuxer/TrackDemuxer.h"
namespace mp4_demuxer
{
class MP4AudioDemuxer : public mozilla::TrackDemuxer {
public:
explicit MP4AudioDemuxer(MP4Demuxer* aDemuxer) : mDemuxer(aDemuxer) {}
virtual void Seek(Microseconds aTime) override;
virtual already_AddRefed<mozilla::MediaRawData> DemuxSample() override;
virtual Microseconds GetNextKeyframeTime() override;
private:
nsRefPtr<MP4Demuxer> mDemuxer;
};
class MP4VideoDemuxer : public mozilla::TrackDemuxer {
public:
explicit MP4VideoDemuxer(MP4Demuxer* aDemuxer) : mDemuxer(aDemuxer) {}
virtual void Seek(Microseconds aTime) override;
virtual already_AddRefed<mozilla::MediaRawData> DemuxSample() override;
virtual Microseconds GetNextKeyframeTime() override;
private:
nsRefPtr<MP4Demuxer> mDemuxer;
};
}
#endif

5
media/libstagefright/binding/include/mp4_demuxer/MoofParser.h
View File

@ -5,13 +5,16 @@
#ifndef MOOF_PARSER_H_
#define MOOF_PARSER_H_
#include "mozilla/Monitor.h"
#include "mp4_demuxer/Atom.h"
#include "mp4_demuxer/AtomType.h"
#include "mp4_demuxer/mp4_demuxer.h"
#include "mp4_demuxer/SinfParser.h"
#include "mp4_demuxer/Interval.h"
#include "MediaResource.h"
namespace mp4_demuxer {
using mozilla::Monitor;
typedef int64_t Microseconds;
class Stream;
class Box;

84
media/libstagefright/binding/include/mp4_demuxer/mp4_demuxer.h
View File

@ -1,84 +0,0 @@
/* 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/. */
#ifndef MP4_DEMUXER_H_
#define MP4_DEMUXER_H_
#include "MediaInfo.h"
#include "MediaResource.h"
#include "mozilla/Monitor.h"
#include "mozilla/UniquePtr.h"
#include "mp4_demuxer/DecoderData.h"
#include "mp4_demuxer/Interval.h"
#include "mp4_demuxer/Stream.h"
#include "nsISupportsImpl.h"
#include "nsTArray.h"
namespace mp4_demuxer
{
class Index;
class MP4Metadata;
class SampleIterator;
using mozilla::Monitor;
typedef int64_t Microseconds;
class MP4Demuxer
{
public:
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(MP4Demuxer)
explicit MP4Demuxer(Stream* aSource, Monitor* aMonitor);
bool Init();
Microseconds Duration();
bool CanSeek();
bool HasValidAudio();
bool HasValidVideo();
void SeekAudio(Microseconds aTime);
void SeekVideo(Microseconds aTime);
// DemuxAudioSample and DemuxVideoSample functions
// return nullptr on end of stream or error.
already_AddRefed<mozilla::MediaRawData> DemuxAudioSample();
already_AddRefed<mozilla::MediaRawData> DemuxVideoSample();
const CryptoFile& Crypto() const;
const mozilla::AudioInfo& AudioConfig() const { return *mAudioConfig->GetAsAudioInfo(); }
const mozilla::VideoInfo& VideoConfig() const { return *mVideoConfig->GetAsVideoInfo(); }
void UpdateIndex(const nsTArray<mozilla::MediaByteRange>& aByteRanges);
void ConvertByteRangesToTime(
const nsTArray<mozilla::MediaByteRange>& aByteRanges,
nsTArray<Interval<Microseconds>>* aIntervals);
int64_t GetEvictionOffset(Microseconds aTime);
// Returns timestamp of next keyframe, or -1 if demuxer can't
// report this.
Microseconds GetNextKeyframeTime();
protected:
~MP4Demuxer();
private:
mozilla::UniquePtr<mozilla::TrackInfo> mAudioConfig;
mozilla::UniquePtr<mozilla::TrackInfo> mVideoConfig;
nsRefPtr<Stream> mSource;
nsTArray<mozilla::MediaByteRange> mCachedByteRanges;
nsTArray<Interval<Microseconds>> mCachedTimeRanges;
Monitor* mMonitor;
Microseconds mNextKeyframeTime;
mozilla::UniquePtr<MP4Metadata> mMetadata;
mozilla::UniquePtr<SampleIterator> mAudioIterator;
mozilla::UniquePtr<SampleIterator> mVideoIterator;
nsTArray<nsRefPtr<Index>> mIndexes;
};
} // namespace mp4_demuxer
#endif // MP4_DEMUXER_H_

245
media/libstagefright/binding/mp4_demuxer.cpp
View File

@ -1,245 +0,0 @@
/* 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 "mp4_demuxer/Index.h"
#include "mp4_demuxer/MP4Metadata.h"
#include "mp4_demuxer/mp4_demuxer.h"
#include <stdint.h>
#include <algorithm>
#include <limits>
namespace mp4_demuxer
{
MP4Demuxer::MP4Demuxer(Stream* source, Monitor* aMonitor)
: mSource(source)
, mMonitor(aMonitor)
, mNextKeyframeTime(-1)
{
}
MP4Demuxer::~MP4Demuxer()
{
}
bool
MP4Demuxer::Init()
{
mMonitor->AssertCurrentThreadOwns();
// Check that we have an entire moov before attempting any new reads to make
// the retry system work.
if (!MP4Metadata::HasCompleteMetadata(mSource)) {
return false;
}
mMetadata = mozilla::MakeUnique<MP4Metadata>(mSource);
if (!mMetadata->GetNumberTracks(mozilla::TrackInfo::kAudioTrack) &&
!mMetadata->GetNumberTracks(mozilla::TrackInfo::kVideoTrack)) {
return false;
}
auto audioInfo = mMetadata->GetTrackInfo(mozilla::TrackInfo::kAudioTrack, 0);
if (audioInfo) {
mAudioConfig = mozilla::Move(audioInfo);
FallibleTArray<Index::Indice> indices;
if (!mMetadata->ReadTrackIndex(indices, mAudioConfig->mTrackId)) {
return false;
}
nsRefPtr<Index> index =
new Index(indices,
mSource,
mAudioConfig->mTrackId,
/* aIsAudio = */ true,
mMonitor);
mIndexes.AppendElement(index);
mAudioIterator = mozilla::MakeUnique<SampleIterator>(index);
}
auto videoInfo = mMetadata->GetTrackInfo(mozilla::TrackInfo::kVideoTrack, 0);
if (videoInfo) {
mVideoConfig = mozilla::Move(videoInfo);
FallibleTArray<Index::Indice> indices;
if (!mMetadata->ReadTrackIndex(indices, mVideoConfig->mTrackId)) {
return false;
}
nsRefPtr<Index> index =
new Index(indices,
mSource,
mVideoConfig->mTrackId,
/* aIsAudio = */ false,
mMonitor);
mIndexes.AppendElement(index);
mVideoIterator = mozilla::MakeUnique<SampleIterator>(index);
}
return mAudioIterator || mVideoIterator;
}
bool
MP4Demuxer::HasValidAudio()
{
mMonitor->AssertCurrentThreadOwns();
return mAudioIterator && mAudioConfig && mAudioConfig->IsValid();
}
bool
MP4Demuxer::HasValidVideo()
{
mMonitor->AssertCurrentThreadOwns();
return mVideoIterator && mVideoConfig && mVideoConfig->IsValid();
}
Microseconds
MP4Demuxer::Duration()
{
mMonitor->AssertCurrentThreadOwns();
int64_t videoDuration = mVideoConfig ? mVideoConfig->mDuration : 0;
int64_t audioDuration = mAudioConfig ? mAudioConfig->mDuration : 0;
return std::max(videoDuration, audioDuration);
}
bool
MP4Demuxer::CanSeek()
{
mMonitor->AssertCurrentThreadOwns();
return mMetadata->CanSeek();
}
void
MP4Demuxer::SeekAudio(Microseconds aTime)
{
mMonitor->AssertCurrentThreadOwns();
MOZ_ASSERT(mAudioIterator);
mAudioIterator->Seek(aTime);
}
void
MP4Demuxer::SeekVideo(Microseconds aTime)
{
mMonitor->AssertCurrentThreadOwns();
MOZ_ASSERT(mVideoIterator);
mVideoIterator->Seek(aTime);
}
already_AddRefed<mozilla::MediaRawData>
MP4Demuxer::DemuxAudioSample()
{
mMonitor->AssertCurrentThreadOwns();
MOZ_ASSERT(mAudioIterator);
nsRefPtr<mozilla::MediaRawData> sample(mAudioIterator->GetNext());
if (sample) {
if (sample->mCrypto.mValid) {
nsAutoPtr<MediaRawDataWriter> writer(sample->CreateWriter());
writer->mCrypto.mMode = mAudioConfig->mCrypto.mMode;
writer->mCrypto.mIVSize = mAudioConfig->mCrypto.mIVSize;
writer->mCrypto.mKeyId.AppendElements(mAudioConfig->mCrypto.mKeyId);
}
}
return sample.forget();
}
already_AddRefed<MediaRawData>
MP4Demuxer::DemuxVideoSample()
{
mMonitor->AssertCurrentThreadOwns();
MOZ_ASSERT(mVideoIterator);
nsRefPtr<mozilla::MediaRawData> sample(mVideoIterator->GetNext());
if (sample) {
sample->mExtraData = mVideoConfig->GetAsVideoInfo()->mExtraData;
if (sample->mCrypto.mValid) {
nsAutoPtr<MediaRawDataWriter> writer(sample->CreateWriter());
writer->mCrypto.mMode = mVideoConfig->mCrypto.mMode;
writer->mCrypto.mKeyId.AppendElements(mVideoConfig->mCrypto.mKeyId);
}
if (sample->mTime >= mNextKeyframeTime) {
mNextKeyframeTime = mVideoIterator->GetNextKeyframeTime();
}
}
return sample.forget();
}
void
MP4Demuxer::UpdateIndex(const nsTArray<mozilla::MediaByteRange>& aByteRanges)
{
mMonitor->AssertCurrentThreadOwns();
for (int i = 0; i < mIndexes.Length(); i++) {
mIndexes[i]->UpdateMoofIndex(aByteRanges);
}
}
void
MP4Demuxer::ConvertByteRangesToTime(
const nsTArray<mozilla::MediaByteRange>& aByteRanges,
nsTArray<Interval<Microseconds>>* aIntervals)
{
mMonitor->AssertCurrentThreadOwns();
if (mIndexes.IsEmpty()) {
return;
}
Microseconds lastComposition = 0;
nsTArray<Microseconds> endCompositions;
for (int i = 0; i < mIndexes.Length(); i++) {
Microseconds endComposition =
mIndexes[i]->GetEndCompositionIfBuffered(aByteRanges);
endCompositions.AppendElement(endComposition);
lastComposition = std::max(lastComposition, endComposition);
}
if (aByteRanges != mCachedByteRanges) {
mCachedByteRanges = aByteRanges;
mCachedTimeRanges.Clear();
for (int i = 0; i < mIndexes.Length(); i++) {
nsTArray<Interval<Microseconds>> ranges;
mIndexes[i]->ConvertByteRangesToTimeRanges(aByteRanges, &ranges);
if (lastComposition && endCompositions[i]) {
Interval<Microseconds>::SemiNormalAppend(
ranges, Interval<Microseconds>(endCompositions[i], lastComposition));
}
if (i) {
nsTArray<Interval<Microseconds>> intersection;
Interval<Microseconds>::Intersection(mCachedTimeRanges, ranges, &intersection);
mCachedTimeRanges = intersection;
} else {
mCachedTimeRanges = ranges;
}
}
}
aIntervals->AppendElements(mCachedTimeRanges);
}
int64_t
MP4Demuxer::GetEvictionOffset(Microseconds aTime)
{
mMonitor->AssertCurrentThreadOwns();
if (mIndexes.IsEmpty()) {
return 0;
}
uint64_t offset = std::numeric_limits<uint64_t>::max();
for (int i = 0; i < mIndexes.Length(); i++) {
offset = std::min(offset, mIndexes[i]->GetEvictionOffset(aTime));
}
return offset == std::numeric_limits<uint64_t>::max() ? 0 : offset;
}
Microseconds
MP4Demuxer::GetNextKeyframeTime()
{
mMonitor->AssertCurrentThreadOwns();
return mNextKeyframeTime;
}
const CryptoFile&
MP4Demuxer::Crypto() const
{
return mMetadata->Crypto();
}
} // namespace mp4_demuxer

4
media/libstagefright/moz.build
View File

@ -60,9 +60,7 @@ EXPORTS.mp4_demuxer += [
'binding/include/mp4_demuxer/Index.h',
'binding/include/mp4_demuxer/Interval.h',
'binding/include/mp4_demuxer/MoofParser.h',
'binding/include/mp4_demuxer/mp4_demuxer.h',
'binding/include/mp4_demuxer/MP4Metadata.h',
'binding/include/mp4_demuxer/MP4TrackDemuxer.h',
'binding/include/mp4_demuxer/ResourceStream.h',
'binding/include/mp4_demuxer/SinfParser.h',
'binding/include/mp4_demuxer/Stream.h',
@ -95,9 +93,7 @@ UNIFIED_SOURCES += [
'binding/H264.cpp',
'binding/Index.cpp',
'binding/MoofParser.cpp',
'binding/mp4_demuxer.cpp',
'binding/MP4Metadata.cpp',
'binding/MP4TrackDemuxer.cpp',
'binding/ResourceStream.cpp',
'binding/SinfParser.cpp',
'frameworks/av/media/libstagefright/DataSource.cpp',

5
modules/libpref/init/all.js
View File

@ -474,11 +474,6 @@ pref("media.mediasource.webm.enabled", false);
// Enable new MediaSource architecture.
pref("media.mediasource.format-reader", false);
// Enable new MediaFormatReader architecture for mp4 in MSE
pref("media.mediasource.format-reader.mp4", true);
// Enable new MediaFormatReader architecture for plain mp4.
pref("media.format-reader.mp4", true);
// Enable new MediaFormatReader architecture for webm in MSE
pref("media.mediasource.format-reader.webm", false);
// Enable new MediaFormatReader architecture for plain webm.