mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-09 19:35:51 +00:00
Bug 1341483
- MP4Metadata::GetTrackInfo() now also returns a success/error code - r=kinetik
MozReview-Commit-ID: KQ3fJzZkrGW --HG-- extra : rebase_source : b9f4324f50c81f4945c0a47e63af0cb616ba013e
This commit is contained in:
parent
c93b449e6b
commit
7961918dfc
@ -11,10 +11,9 @@ namespace mozilla {
|
||||
const char*
|
||||
TrackTypeToStr(TrackInfo::TrackType aTrack)
|
||||
{
|
||||
MOZ_ASSERT(aTrack == TrackInfo::kAudioTrack
|
||||
|| aTrack == TrackInfo::kVideoTrack
|
||||
|| aTrack == TrackInfo::kTextTrack);
|
||||
switch (aTrack) {
|
||||
case TrackInfo::kUndefinedTrack:
|
||||
return "Undefined";
|
||||
case TrackInfo::kAudioTrack:
|
||||
return "Audio";
|
||||
case TrackInfo::kVideoTrack:
|
||||
|
@ -178,7 +178,7 @@ private:
|
||||
TrackType mType;
|
||||
};
|
||||
|
||||
// String version of track type. Don't use with kUndefinedTrack.
|
||||
// String version of track type.
|
||||
const char* TrackTypeToStr(TrackInfo::TrackType aTrack);
|
||||
|
||||
// Stores info relevant to presenting media frames.
|
||||
|
@ -189,17 +189,27 @@ MP4Demuxer::Init()
|
||||
if (audioTrackCount.Ref() != 0) {
|
||||
mAudioDemuxers.SetLength(audioTrackCount.Ref());
|
||||
for (size_t i = 0; i < audioTrackCount.Ref(); i++) {
|
||||
UniquePtr<TrackInfo> info =
|
||||
mp4_demuxer::MP4Metadata::ResultAndTrackInfo info =
|
||||
metadata.GetTrackInfo(TrackInfo::kAudioTrack, i);
|
||||
if (!info) {
|
||||
if (!info.Ref()) {
|
||||
if (MediaPrefs::MediaWarningsAsErrors()) {
|
||||
return InitPromise::CreateAndReject(
|
||||
MediaResult(NS_ERROR_DOM_MEDIA_DEMUXER_ERR,
|
||||
RESULT_DETAIL("Invalid MP4 audio track (%s)",
|
||||
info.Result().Description().get())),
|
||||
__func__);
|
||||
}
|
||||
if (result == NS_OK) {
|
||||
result = MediaResult(NS_ERROR_DOM_MEDIA_DEMUXER_ERR,
|
||||
RESULT_DETAIL("Invalid MP4 audio track"));
|
||||
RESULT_DETAIL("Invalid MP4 audio track (%s)",
|
||||
info.Result().Description().get()));
|
||||
}
|
||||
continue;
|
||||
} else if (NS_FAILED(info.Result()) && result == NS_OK) {
|
||||
result = Move(info.Result());
|
||||
}
|
||||
UniquePtr<mp4_demuxer::IndiceWrapper> indices =
|
||||
metadata.GetTrackIndice(info->mTrackId);
|
||||
metadata.GetTrackIndice(info.Ref()->mTrackId);
|
||||
if (!indices) {
|
||||
if (result == NS_OK) {
|
||||
result =
|
||||
@ -208,24 +218,34 @@ MP4Demuxer::Init()
|
||||
}
|
||||
continue;
|
||||
}
|
||||
mAudioDemuxers[i] = new MP4TrackDemuxer(this, Move(info), *indices.get());
|
||||
mAudioDemuxers[i] = new MP4TrackDemuxer(this, Move(info.Ref()), *indices.get());
|
||||
}
|
||||
}
|
||||
|
||||
if (videoTrackCount.Ref() != 0) {
|
||||
mVideoDemuxers.SetLength(videoTrackCount.Ref());
|
||||
for (size_t i = 0; i < videoTrackCount.Ref(); i++) {
|
||||
UniquePtr<TrackInfo> info =
|
||||
mp4_demuxer::MP4Metadata::ResultAndTrackInfo info =
|
||||
metadata.GetTrackInfo(TrackInfo::kVideoTrack, i);
|
||||
if (!info) {
|
||||
if (!info.Ref()) {
|
||||
if (MediaPrefs::MediaWarningsAsErrors()) {
|
||||
return InitPromise::CreateAndReject(
|
||||
MediaResult(NS_ERROR_DOM_MEDIA_DEMUXER_ERR,
|
||||
RESULT_DETAIL("Invalid MP4 video track (%s)",
|
||||
info.Result().Description().get())),
|
||||
__func__);
|
||||
}
|
||||
if (result == NS_OK) {
|
||||
result = MediaResult(NS_ERROR_DOM_MEDIA_DEMUXER_ERR,
|
||||
RESULT_DETAIL("Invalid MP4 video track"));
|
||||
RESULT_DETAIL("Invalid MP4 video track (%s)",
|
||||
info.Result().Description().get()));
|
||||
}
|
||||
continue;
|
||||
} else if (NS_FAILED(info.Result()) && result == NS_OK) {
|
||||
result = Move(info.Result());
|
||||
}
|
||||
UniquePtr<mp4_demuxer::IndiceWrapper> indices =
|
||||
metadata.GetTrackIndice(info->mTrackId);
|
||||
metadata.GetTrackIndice(info.Ref()->mTrackId);
|
||||
if (!indices) {
|
||||
if (result == NS_OK) {
|
||||
result =
|
||||
@ -234,7 +254,7 @@ MP4Demuxer::Init()
|
||||
}
|
||||
continue;
|
||||
}
|
||||
mVideoDemuxers[i] = new MP4TrackDemuxer(this, Move(info), *indices.get());
|
||||
mVideoDemuxers[i] = new MP4TrackDemuxer(this, Move(info.Ref()), *indices.get());
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -83,8 +83,8 @@ public:
|
||||
|
||||
MP4Metadata::ResultAndTrackCount
|
||||
GetNumberTracks(mozilla::TrackInfo::TrackType aType) const;
|
||||
mozilla::UniquePtr<mozilla::TrackInfo> GetTrackInfo(mozilla::TrackInfo::TrackType aType,
|
||||
size_t aTrackNumber) const;
|
||||
MP4Metadata::ResultAndTrackInfo GetTrackInfo(
|
||||
mozilla::TrackInfo::TrackType aType, size_t aTrackNumber) const;
|
||||
bool CanSeek() const;
|
||||
|
||||
const CryptoFile& Crypto() const;
|
||||
@ -132,8 +132,8 @@ public:
|
||||
|
||||
MP4Metadata::ResultAndTrackCount
|
||||
GetNumberTracks(mozilla::TrackInfo::TrackType aType) const;
|
||||
mozilla::UniquePtr<mozilla::TrackInfo> GetTrackInfo(mozilla::TrackInfo::TrackType aType,
|
||||
size_t aTrackNumber) const;
|
||||
MP4Metadata::ResultAndTrackInfo GetTrackInfo(
|
||||
mozilla::TrackInfo::TrackType aType, size_t aTrackNumber) const;
|
||||
bool CanSeek() const;
|
||||
|
||||
const CryptoFile& Crypto() const;
|
||||
@ -359,12 +359,13 @@ bool MP4Metadata::ShouldPreferRust() const {
|
||||
mRust->GetNumberTracks(TrackInfo::kAudioTrack);
|
||||
if (numTracks.Ref() != NumberTracksError()) {
|
||||
for (auto i = 0; i < numTracks.Ref(); i++) {
|
||||
auto info = mRust->GetTrackInfo(TrackInfo::kAudioTrack, i);
|
||||
if (!info) {
|
||||
MP4Metadata::ResultAndTrackInfo info =
|
||||
mRust->GetTrackInfo(TrackInfo::kAudioTrack, i);
|
||||
if (!info.Ref()) {
|
||||
return false;
|
||||
}
|
||||
if (info->mMimeType.EqualsASCII("audio/opus") ||
|
||||
info->mMimeType.EqualsASCII("audio/flac")) {
|
||||
if (info.Ref()->mMimeType.EqualsASCII("audio/opus") ||
|
||||
info.Ref()->mMimeType.EqualsASCII("audio/flac")) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@ -373,11 +374,12 @@ bool MP4Metadata::ShouldPreferRust() const {
|
||||
numTracks = mRust->GetNumberTracks(TrackInfo::kVideoTrack);
|
||||
if (numTracks.Ref() != NumberTracksError()) {
|
||||
for (auto i = 0; i < numTracks.Ref(); i++) {
|
||||
auto info = mRust->GetTrackInfo(TrackInfo::kVideoTrack, i);
|
||||
if (!info) {
|
||||
MP4Metadata::ResultAndTrackInfo info =
|
||||
mRust->GetTrackInfo(TrackInfo::kVideoTrack, i);
|
||||
if (!info.Ref()) {
|
||||
return false;
|
||||
}
|
||||
if (info->mMimeType.EqualsASCII("video/vp9")) {
|
||||
if (info.Ref()->mMimeType.EqualsASCII("video/vp9")) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@ -386,39 +388,85 @@ bool MP4Metadata::ShouldPreferRust() const {
|
||||
return false;
|
||||
}
|
||||
|
||||
mozilla::UniquePtr<mozilla::TrackInfo>
|
||||
static const char*
|
||||
GetDifferentField(const mozilla::TrackInfo& info,
|
||||
const mozilla::TrackInfo& infoRust)
|
||||
{
|
||||
if (infoRust.mId != info.mId) { return "Id"; }
|
||||
if (infoRust.mKind == info.mKind) { return "Kind"; }
|
||||
if (infoRust.mLabel == info.mLabel) { return "Label"; }
|
||||
if (infoRust.mLanguage == info.mLanguage) { return "Language"; }
|
||||
if (infoRust.mEnabled == info.mEnabled) { return "Enabled"; }
|
||||
if (infoRust.mTrackId == info.mTrackId) { return "TrackId"; }
|
||||
if (infoRust.mMimeType == info.mMimeType) { return "MimeType"; }
|
||||
if (infoRust.mDuration == info.mDuration) { return "Duration"; }
|
||||
if (infoRust.mMediaTime == info.mMediaTime) { return "MediaTime"; }
|
||||
if (infoRust.mCrypto.mValid == info.mCrypto.mValid) { return "Crypto-Valid"; }
|
||||
if (infoRust.mCrypto.mMode == info.mCrypto.mMode) { return "Crypto-Mode"; }
|
||||
if (infoRust.mCrypto.mIVSize == info.mCrypto.mIVSize) { return "Crypto-IVSize"; }
|
||||
if (infoRust.mCrypto.mKeyId == info.mCrypto.mKeyId) { return "Crypto-KeyId"; }
|
||||
switch (info.GetType()) {
|
||||
case mozilla::TrackInfo::kAudioTrack: {
|
||||
const AudioInfo *audioRust = infoRust.GetAsAudioInfo();
|
||||
const AudioInfo *audio = info.GetAsAudioInfo();
|
||||
if (audioRust->mRate == audio->mRate) { return "Rate"; }
|
||||
if (audioRust->mChannels == audio->mChannels) { return "Channels"; }
|
||||
if (audioRust->mBitDepth == audio->mBitDepth) { return "BitDepth"; }
|
||||
if (audioRust->mProfile == audio->mProfile) { return "Profile"; }
|
||||
if (audioRust->mExtendedProfile == audio->mExtendedProfile) { return "ExtendedProfile"; }
|
||||
break;
|
||||
}
|
||||
case mozilla::TrackInfo::kVideoTrack: {
|
||||
const VideoInfo *videoRust = infoRust.GetAsVideoInfo();
|
||||
const VideoInfo *video = info.GetAsVideoInfo();
|
||||
if (videoRust->mDisplay == video->mDisplay) { return "Display"; }
|
||||
if (videoRust->mImage == video->mImage) { return "Image"; }
|
||||
if (*videoRust->mExtraData == *video->mExtraData) { return "ExtraData"; }
|
||||
// mCodecSpecificConfig is for video/mp4-es, not video/avc. Since video/mp4-es
|
||||
// is supported on b2g only, it could be removed from TrackInfo.
|
||||
if (*videoRust->mCodecSpecificConfig == *video->mCodecSpecificConfig) { return "CodecSpecificConfig"; }
|
||||
break;
|
||||
}
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
MP4Metadata::ResultAndTrackInfo
|
||||
MP4Metadata::GetTrackInfo(mozilla::TrackInfo::TrackType aType,
|
||||
size_t aTrackNumber) const
|
||||
{
|
||||
mozilla::UniquePtr<mozilla::TrackInfo> info =
|
||||
MP4Metadata::ResultAndTrackInfo info =
|
||||
mStagefright->GetTrackInfo(aType, aTrackNumber);
|
||||
|
||||
if (!mRust) {
|
||||
return info;
|
||||
}
|
||||
|
||||
mozilla::UniquePtr<mozilla::TrackInfo> infoRust =
|
||||
MP4Metadata::ResultAndTrackInfo infoRust =
|
||||
mRust->GetTrackInfo(aType, aTrackNumber);
|
||||
|
||||
#ifndef RELEASE_OR_BETA
|
||||
if (mRustTestMode && info) {
|
||||
MOZ_DIAGNOSTIC_ASSERT(infoRust);
|
||||
MOZ_DIAGNOSTIC_ASSERT(infoRust->mId == info->mId);
|
||||
MOZ_DIAGNOSTIC_ASSERT(infoRust->mKind == info->mKind);
|
||||
MOZ_DIAGNOSTIC_ASSERT(infoRust->mLabel == info->mLabel);
|
||||
MOZ_DIAGNOSTIC_ASSERT(infoRust->mLanguage == info->mLanguage);
|
||||
MOZ_DIAGNOSTIC_ASSERT(infoRust->mEnabled == info->mEnabled);
|
||||
MOZ_DIAGNOSTIC_ASSERT(infoRust->mTrackId == info->mTrackId);
|
||||
MOZ_DIAGNOSTIC_ASSERT(infoRust->mMimeType == info->mMimeType);
|
||||
MOZ_DIAGNOSTIC_ASSERT(infoRust->mDuration == info->mDuration);
|
||||
MOZ_DIAGNOSTIC_ASSERT(infoRust->mMediaTime == info->mMediaTime);
|
||||
MOZ_DIAGNOSTIC_ASSERT(infoRust->mCrypto.mValid == info->mCrypto.mValid);
|
||||
MOZ_DIAGNOSTIC_ASSERT(infoRust->mCrypto.mMode == info->mCrypto.mMode);
|
||||
MOZ_DIAGNOSTIC_ASSERT(infoRust->mCrypto.mIVSize == info->mCrypto.mIVSize);
|
||||
MOZ_DIAGNOSTIC_ASSERT(infoRust->mCrypto.mKeyId == info->mCrypto.mKeyId);
|
||||
if (mRustTestMode && info.Ref() && infoRust.Ref()) {
|
||||
MOZ_DIAGNOSTIC_ASSERT(infoRust.Ref()->mId == info.Ref()->mId);
|
||||
MOZ_DIAGNOSTIC_ASSERT(infoRust.Ref()->mKind == info.Ref()->mKind);
|
||||
MOZ_DIAGNOSTIC_ASSERT(infoRust.Ref()->mLabel == info.Ref()->mLabel);
|
||||
MOZ_DIAGNOSTIC_ASSERT(infoRust.Ref()->mLanguage == info.Ref()->mLanguage);
|
||||
MOZ_DIAGNOSTIC_ASSERT(infoRust.Ref()->mEnabled == info.Ref()->mEnabled);
|
||||
MOZ_DIAGNOSTIC_ASSERT(infoRust.Ref()->mTrackId == info.Ref()->mTrackId);
|
||||
MOZ_DIAGNOSTIC_ASSERT(infoRust.Ref()->mMimeType == info.Ref()->mMimeType);
|
||||
MOZ_DIAGNOSTIC_ASSERT(infoRust.Ref()->mDuration == info.Ref()->mDuration);
|
||||
MOZ_DIAGNOSTIC_ASSERT(infoRust.Ref()->mMediaTime == info.Ref()->mMediaTime);
|
||||
MOZ_DIAGNOSTIC_ASSERT(infoRust.Ref()->mCrypto.mValid == info.Ref()->mCrypto.mValid);
|
||||
MOZ_DIAGNOSTIC_ASSERT(infoRust.Ref()->mCrypto.mMode == info.Ref()->mCrypto.mMode);
|
||||
MOZ_DIAGNOSTIC_ASSERT(infoRust.Ref()->mCrypto.mIVSize == info.Ref()->mCrypto.mIVSize);
|
||||
MOZ_DIAGNOSTIC_ASSERT(infoRust.Ref()->mCrypto.mKeyId == info.Ref()->mCrypto.mKeyId);
|
||||
switch (aType) {
|
||||
case mozilla::TrackInfo::kAudioTrack: {
|
||||
AudioInfo *audioRust = infoRust->GetAsAudioInfo(), *audio = info->GetAsAudioInfo();
|
||||
AudioInfo *audioRust = infoRust.Ref()->GetAsAudioInfo();
|
||||
AudioInfo *audio = info.Ref()->GetAsAudioInfo();
|
||||
MOZ_DIAGNOSTIC_ASSERT(audioRust->mRate == audio->mRate);
|
||||
MOZ_DIAGNOSTIC_ASSERT(audioRust->mChannels == audio->mChannels);
|
||||
MOZ_DIAGNOSTIC_ASSERT(audioRust->mBitDepth == audio->mBitDepth);
|
||||
@ -429,7 +477,8 @@ MP4Metadata::GetTrackInfo(mozilla::TrackInfo::TrackType aType,
|
||||
break;
|
||||
}
|
||||
case mozilla::TrackInfo::kVideoTrack: {
|
||||
VideoInfo *videoRust = infoRust->GetAsVideoInfo(), *video = info->GetAsVideoInfo();
|
||||
VideoInfo *videoRust = infoRust.Ref()->GetAsVideoInfo();
|
||||
VideoInfo *video = info.Ref()->GetAsVideoInfo();
|
||||
MOZ_DIAGNOSTIC_ASSERT(videoRust->mDisplay == video->mDisplay);
|
||||
MOZ_DIAGNOSTIC_ASSERT(videoRust->mImage == video->mImage);
|
||||
MOZ_DIAGNOSTIC_ASSERT(videoRust->mRotation == video->mRotation);
|
||||
@ -445,6 +494,21 @@ MP4Metadata::GetTrackInfo(mozilla::TrackInfo::TrackType aType,
|
||||
}
|
||||
#endif
|
||||
|
||||
if (mRustTestMode && info.Ref() && infoRust.Ref()) {
|
||||
const char* diff = GetDifferentField(*info.Ref(), *infoRust.Ref());
|
||||
if (diff) {
|
||||
return {MediaResult(NS_ERROR_DOM_MEDIA_METADATA_ERR,
|
||||
RESULT_DETAIL("Different field '%s' between "
|
||||
"Stagefright (%s) and Rust (%s)",
|
||||
diff,
|
||||
info.Result().Description().get(),
|
||||
infoRust.Result().Description().get())),
|
||||
MediaPrefs::MediaWarningsAsErrorsStageFrightVsRust()
|
||||
? mozilla::UniquePtr<mozilla::TrackInfo>(nullptr)
|
||||
: mPreferRust ? Move(infoRust.Ref()) : Move(info.Ref())};
|
||||
}
|
||||
}
|
||||
|
||||
if (mPreferRust) {
|
||||
return infoRust;
|
||||
}
|
||||
@ -590,13 +654,16 @@ MP4MetadataStagefright::GetNumberTracks(mozilla::TrackInfo::TrackType aType) con
|
||||
return {NS_OK, total};
|
||||
}
|
||||
|
||||
mozilla::UniquePtr<mozilla::TrackInfo>
|
||||
MP4Metadata::ResultAndTrackInfo
|
||||
MP4MetadataStagefright::GetTrackInfo(mozilla::TrackInfo::TrackType aType,
|
||||
size_t aTrackNumber) const
|
||||
{
|
||||
size_t tracks = mMetadataExtractor->countTracks();
|
||||
if (!tracks) {
|
||||
return nullptr;
|
||||
return {MediaResult(NS_ERROR_DOM_MEDIA_METADATA_ERR,
|
||||
RESULT_DETAIL("No %s tracks",
|
||||
TrackTypeToStr(aType))),
|
||||
nullptr};
|
||||
}
|
||||
int32_t index = -1;
|
||||
const char* mimeType;
|
||||
@ -631,7 +698,11 @@ MP4MetadataStagefright::GetTrackInfo(mozilla::TrackInfo::TrackType aType,
|
||||
i++;
|
||||
}
|
||||
if (index < 0) {
|
||||
return nullptr;
|
||||
return {MediaResult(NS_ERROR_DOM_MEDIA_METADATA_ERR,
|
||||
RESULT_DETAIL("Cannot access %s track #%zu",
|
||||
TrackTypeToStr(aType),
|
||||
aTrackNumber)),
|
||||
nullptr};
|
||||
}
|
||||
|
||||
UniquePtr<mozilla::TrackInfo> e = CheckTrack(mimeType, metaData.get(), index);
|
||||
@ -646,7 +717,7 @@ MP4MetadataStagefright::GetTrackInfo(mozilla::TrackInfo::TrackType aType,
|
||||
}
|
||||
}
|
||||
|
||||
return e;
|
||||
return {NS_OK, Move(e)};
|
||||
}
|
||||
|
||||
mozilla::UniquePtr<mozilla::TrackInfo>
|
||||
@ -904,20 +975,27 @@ MP4MetadataRust::TrackTypeToGlobalTrackIndex(mozilla::TrackInfo::TrackType aType
|
||||
return Nothing();
|
||||
}
|
||||
|
||||
mozilla::UniquePtr<mozilla::TrackInfo>
|
||||
MP4Metadata::ResultAndTrackInfo
|
||||
MP4MetadataRust::GetTrackInfo(mozilla::TrackInfo::TrackType aType,
|
||||
size_t aTrackNumber) const
|
||||
{
|
||||
Maybe<uint32_t> trackIndex = TrackTypeToGlobalTrackIndex(aType, aTrackNumber);
|
||||
if (trackIndex.isNothing()) {
|
||||
return nullptr;
|
||||
return {MediaResult(NS_ERROR_DOM_MEDIA_METADATA_ERR,
|
||||
RESULT_DETAIL("No %s tracks",
|
||||
TrackTypeToStr(aType))),
|
||||
nullptr};
|
||||
}
|
||||
|
||||
mp4parse_track_info info;
|
||||
auto rv = mp4parse_get_track_info(mRustParser.get(), trackIndex.value(), &info);
|
||||
if (rv != mp4parse_status_OK) {
|
||||
MOZ_LOG(sLog, LogLevel::Warning, ("mp4parse_get_track_info returned %d", rv));
|
||||
return nullptr;
|
||||
return {MediaResult(NS_ERROR_DOM_MEDIA_METADATA_ERR,
|
||||
RESULT_DETAIL("Cannot find %s track #%zu",
|
||||
TrackTypeToStr(aType),
|
||||
aTrackNumber)),
|
||||
nullptr};
|
||||
}
|
||||
#ifdef DEBUG
|
||||
const char* codec_string = "unrecognized";
|
||||
@ -942,7 +1020,11 @@ MP4MetadataRust::GetTrackInfo(mozilla::TrackInfo::TrackType aType,
|
||||
auto rv = mp4parse_get_track_audio_info(mRustParser.get(), trackIndex.value(), &audio);
|
||||
if (rv != mp4parse_status_OK) {
|
||||
MOZ_LOG(sLog, LogLevel::Warning, ("mp4parse_get_track_audio_info returned error %d", rv));
|
||||
return nullptr;
|
||||
return {MediaResult(NS_ERROR_DOM_MEDIA_METADATA_ERR,
|
||||
RESULT_DETAIL("Cannot parse %s track #%zu",
|
||||
TrackTypeToStr(aType),
|
||||
aTrackNumber)),
|
||||
nullptr};
|
||||
}
|
||||
auto track = mozilla::MakeUnique<MP4AudioInfo>();
|
||||
track->Update(&info, &audio);
|
||||
@ -954,7 +1036,11 @@ MP4MetadataRust::GetTrackInfo(mozilla::TrackInfo::TrackType aType,
|
||||
auto rv = mp4parse_get_track_video_info(mRustParser.get(), trackIndex.value(), &video);
|
||||
if (rv != mp4parse_status_OK) {
|
||||
MOZ_LOG(sLog, LogLevel::Warning, ("mp4parse_get_track_video_info returned error %d", rv));
|
||||
return nullptr;
|
||||
return {MediaResult(NS_ERROR_DOM_MEDIA_METADATA_ERR,
|
||||
RESULT_DETAIL("Cannot parse %s track #%zu",
|
||||
TrackTypeToStr(aType),
|
||||
aTrackNumber)),
|
||||
nullptr};
|
||||
}
|
||||
auto track = mozilla::MakeUnique<MP4VideoInfo>();
|
||||
track->Update(&info, &video);
|
||||
@ -963,8 +1049,11 @@ MP4MetadataRust::GetTrackInfo(mozilla::TrackInfo::TrackType aType,
|
||||
break;
|
||||
default:
|
||||
MOZ_LOG(sLog, LogLevel::Warning, ("unhandled track type %d", aType));
|
||||
return nullptr;
|
||||
break;
|
||||
return {MediaResult(NS_ERROR_DOM_MEDIA_METADATA_ERR,
|
||||
RESULT_DETAIL("Cannot handle %s track #%zu",
|
||||
TrackTypeToStr(aType),
|
||||
aTrackNumber)),
|
||||
nullptr};
|
||||
}
|
||||
|
||||
// No duration in track, use fragment_duration.
|
||||
@ -977,11 +1066,15 @@ MP4MetadataRust::GetTrackInfo(mozilla::TrackInfo::TrackType aType,
|
||||
}
|
||||
|
||||
if (e && e->IsValid()) {
|
||||
return e;
|
||||
return {NS_OK, Move(e)};
|
||||
}
|
||||
MOZ_LOG(sLog, LogLevel::Debug, ("TrackInfo didn't validate"));
|
||||
|
||||
return nullptr;
|
||||
return {MediaResult(NS_ERROR_DOM_MEDIA_METADATA_ERR,
|
||||
RESULT_DETAIL("Invalid %s track #%zu",
|
||||
TrackTypeToStr(aType),
|
||||
aTrackNumber)),
|
||||
nullptr};
|
||||
}
|
||||
|
||||
bool
|
||||
|
@ -66,8 +66,12 @@ public:
|
||||
static constexpr uint32_t NumberTracksError() { return UINT32_MAX; }
|
||||
using ResultAndTrackCount = ResultAndType<uint32_t>;
|
||||
ResultAndTrackCount GetNumberTracks(mozilla::TrackInfo::TrackType aType) const;
|
||||
mozilla::UniquePtr<mozilla::TrackInfo> GetTrackInfo(mozilla::TrackInfo::TrackType aType,
|
||||
|
||||
using ResultAndTrackInfo =
|
||||
ResultAndType<mozilla::UniquePtr<mozilla::TrackInfo>>;
|
||||
ResultAndTrackInfo GetTrackInfo(mozilla::TrackInfo::TrackType aType,
|
||||
size_t aTrackNumber) const;
|
||||
|
||||
bool CanSeek() const;
|
||||
|
||||
const CryptoFile& Crypto() const;
|
||||
|
@ -92,11 +92,9 @@ TEST(stagefright_MP4Metadata, EmptyStream)
|
||||
E == metadata.GetNumberTracks(TrackInfo::kTextTrack).Ref());
|
||||
EXPECT_TRUE(0u == metadata.GetNumberTracks(static_cast<TrackInfo::TrackType>(-1)).Ref() ||
|
||||
E == metadata.GetNumberTracks(static_cast<TrackInfo::TrackType>(-1)).Ref());
|
||||
EXPECT_FALSE(metadata.GetTrackInfo(TrackInfo::kUndefinedTrack, 0));
|
||||
EXPECT_FALSE(metadata.GetTrackInfo(TrackInfo::kAudioTrack, 0));
|
||||
EXPECT_FALSE(metadata.GetTrackInfo(TrackInfo::kVideoTrack, 0));
|
||||
EXPECT_FALSE(metadata.GetTrackInfo(TrackInfo::kTextTrack, 0));
|
||||
EXPECT_FALSE(metadata.GetTrackInfo(static_cast<TrackInfo::TrackType>(-1), 0));
|
||||
EXPECT_FALSE(metadata.GetTrackInfo(TrackInfo::kAudioTrack, 0).Ref());
|
||||
EXPECT_FALSE(metadata.GetTrackInfo(TrackInfo::kVideoTrack, 0).Ref());
|
||||
EXPECT_FALSE(metadata.GetTrackInfo(TrackInfo::kTextTrack, 0).Ref());
|
||||
// We can seek anywhere in any MPEG4.
|
||||
EXPECT_TRUE(metadata.CanSeek());
|
||||
EXPECT_FALSE(metadata.Crypto().valid);
|
||||
@ -305,14 +303,15 @@ TEST(stagefright_MPEG4Metadata, test_case_mp4)
|
||||
<< (rust ? "rust/" : "stagefright/") << tests[test].mFilename;
|
||||
EXPECT_EQ(None, metadata.GetNumberTracks(static_cast<TrackInfo::TrackType>(-1)).Ref())
|
||||
<< (rust ? "rust/" : "stagefright/") << tests[test].mFilename;
|
||||
EXPECT_FALSE(metadata.GetTrackInfo(TrackInfo::kUndefinedTrack, 0));
|
||||
UniquePtr<TrackInfo> trackInfo = metadata.GetTrackInfo(TrackInfo::kVideoTrack, 0);
|
||||
EXPECT_FALSE(metadata.GetTrackInfo(TrackInfo::kUndefinedTrack, 0).Ref());
|
||||
MP4Metadata::ResultAndTrackInfo trackInfo =
|
||||
metadata.GetTrackInfo(TrackInfo::kVideoTrack, 0);
|
||||
if (tests[test].mNumberVideoTracks == 0 ||
|
||||
tests[test].mNumberVideoTracks == E) {
|
||||
EXPECT_TRUE(!trackInfo);
|
||||
EXPECT_TRUE(!trackInfo.Ref());
|
||||
} else {
|
||||
ASSERT_TRUE(!!trackInfo);
|
||||
const VideoInfo* videoInfo = trackInfo->GetAsVideoInfo();
|
||||
ASSERT_TRUE(!!trackInfo.Ref());
|
||||
const VideoInfo* videoInfo = trackInfo.Ref()->GetAsVideoInfo();
|
||||
ASSERT_TRUE(!!videoInfo);
|
||||
EXPECT_TRUE(videoInfo->IsValid());
|
||||
EXPECT_TRUE(videoInfo->IsVideo());
|
||||
@ -332,10 +331,10 @@ TEST(stagefright_MPEG4Metadata, test_case_mp4)
|
||||
trackInfo = metadata.GetTrackInfo(TrackInfo::kAudioTrack, 0);
|
||||
if (tests[test].mNumberAudioTracks == 0 ||
|
||||
tests[test].mNumberAudioTracks == E) {
|
||||
EXPECT_TRUE(!trackInfo);
|
||||
EXPECT_TRUE(!trackInfo.Ref());
|
||||
} else {
|
||||
ASSERT_TRUE(!!trackInfo);
|
||||
const AudioInfo* audioInfo = trackInfo->GetAsAudioInfo();
|
||||
ASSERT_TRUE(!!trackInfo.Ref());
|
||||
const AudioInfo* audioInfo = trackInfo.Ref()->GetAsAudioInfo();
|
||||
ASSERT_TRUE(!!audioInfo);
|
||||
EXPECT_TRUE(audioInfo->IsValid());
|
||||
EXPECT_TRUE(audioInfo->IsAudio());
|
||||
@ -354,8 +353,8 @@ TEST(stagefright_MPEG4Metadata, test_case_mp4)
|
||||
EXPECT_TRUE(int64_t(data.start_composition) <= int64_t(data.end_composition));
|
||||
}
|
||||
}
|
||||
EXPECT_FALSE(metadata.GetTrackInfo(TrackInfo::kTextTrack, 0));
|
||||
EXPECT_FALSE(metadata.GetTrackInfo(static_cast<TrackInfo::TrackType>(-1), 0));
|
||||
EXPECT_FALSE(metadata.GetTrackInfo(TrackInfo::kTextTrack, 0).Ref());
|
||||
EXPECT_FALSE(metadata.GetTrackInfo(static_cast<TrackInfo::TrackType>(-1), 0).Ref());
|
||||
// We can see anywhere in any MPEG4.
|
||||
EXPECT_TRUE(metadata.CanSeek());
|
||||
EXPECT_EQ(tests[test].mHasCrypto, metadata.Crypto().valid);
|
||||
@ -582,9 +581,8 @@ TEST(stagefright_MP4Metadata, EmptyCTTS)
|
||||
MP4Metadata metadata(stream);
|
||||
|
||||
EXPECT_EQ(1u, metadata.GetNumberTracks(TrackInfo::kVideoTrack).Ref());
|
||||
mozilla::UniquePtr<mozilla::TrackInfo> track =
|
||||
metadata.GetTrackInfo(TrackInfo::kVideoTrack, 0);
|
||||
EXPECT_TRUE(track != nullptr);
|
||||
MP4Metadata::ResultAndTrackInfo track = metadata.GetTrackInfo(TrackInfo::kVideoTrack, 0);
|
||||
EXPECT_TRUE(track.Ref() != nullptr);
|
||||
// We can seek anywhere in any MPEG4.
|
||||
EXPECT_TRUE(metadata.CanSeek());
|
||||
EXPECT_FALSE(metadata.Crypto().valid);
|
||||
|
Loading…
Reference in New Issue
Block a user