--- a/dom/media/gmp/ChromiumCDMParent.cpp
+++ b/dom/media/gmp/ChromiumCDMParent.cpp
@@ -916,18 +916,18 @@ ChromiumCDMParent::InitializeVideoDecode
return MediaDataDecoder::InitPromise::CreateAndReject(
MediaResult(NS_ERROR_DOM_MEDIA_FATAL_ERR,
RESULT_DETAIL("Failed to send init video decoder to CDM")),
__func__);
}
mMaxRefFrames =
(aConfig.mCodec() == cdm::VideoDecoderConfig::kCodecH264)
- ? mp4_demuxer::H264::HasSPS(aInfo.mExtraData)
- ? mp4_demuxer::H264::ComputeMaxRefFrames(aInfo.mExtraData)
+ ? H264::HasSPS(aInfo.mExtraData)
+ ? H264::ComputeMaxRefFrames(aInfo.mExtraData)
: 16
: 0;
mVideoDecoderInitialized = true;
mImageContainer = aImageContainer;
mVideoInfo = aInfo;
mVideoFrameBufferSize = bufferSize;
--- a/dom/media/mp4/MP4Demuxer.cpp
+++ b/dom/media/mp4/MP4Demuxer.cpp
@@ -78,18 +78,18 @@ private:
bool mIsH264 = false;
};
// Returns true if no SPS was found and search for it should continue.
bool
AccumulateSPSTelemetry(const MediaByteBuffer* aExtradata)
{
- mp4_demuxer::SPSData spsdata;
- if (mp4_demuxer::H264::DecodeSPSFromExtraData(aExtradata, spsdata)) {
+ SPSData spsdata;
+ if (H264::DecodeSPSFromExtraData(aExtradata, spsdata)) {
uint8_t constraints = (spsdata.constraint_set0_flag ? (1 << 0) : 0)
| (spsdata.constraint_set1_flag ? (1 << 1) : 0)
| (spsdata.constraint_set2_flag ? (1 << 2) : 0)
| (spsdata.constraint_set3_flag ? (1 << 3) : 0)
| (spsdata.constraint_set4_flag ? (1 << 4) : 0)
| (spsdata.constraint_set5_flag ? (1 << 5) : 0);
Telemetry::Accumulate(Telemetry::VIDEO_DECODED_H264_SPS_CONSTRAINT_SET_FLAG,
constraints);
@@ -364,20 +364,20 @@ MP4TrackDemuxer::MP4TrackDemuxer(MP4Demu
VideoInfo* videoInfo = mInfo->GetAsVideoInfo();
// Collect telemetry from h264 AVCC SPS.
if (videoInfo && (mInfo->mMimeType.EqualsLiteral("video/mp4") ||
mInfo->mMimeType.EqualsLiteral("video/avc"))) {
mIsH264 = true;
RefPtr<MediaByteBuffer> extraData = videoInfo->mExtraData;
mNeedSPSForTelemetry = AccumulateSPSTelemetry(extraData);
- mp4_demuxer::SPSData spsdata;
- if (mp4_demuxer::H264::DecodeSPSFromExtraData(extraData, spsdata) &&
+ SPSData spsdata;
+ if (H264::DecodeSPSFromExtraData(extraData, spsdata) &&
spsdata.pic_width > 0 && spsdata.pic_height > 0 &&
- mp4_demuxer::H264::EnsureSPSIsSane(spsdata)) {
+ H264::EnsureSPSIsSane(spsdata)) {
videoInfo->mImage.width = spsdata.pic_width;
videoInfo->mImage.height = spsdata.pic_height;
videoInfo->mDisplay.width = spsdata.display_width;
videoInfo->mDisplay.height = spsdata.display_height;
}
} else {
// No SPS to be found.
mNeedSPSForTelemetry = false;
@@ -441,37 +441,36 @@ MP4TrackDemuxer::GetNextSample()
{
RefPtr<MediaRawData> sample = mIterator->GetNext();
if (!sample) {
return nullptr;
}
if (mInfo->GetAsVideoInfo()) {
sample->mExtraData = mInfo->GetAsVideoInfo()->mExtraData;
if (mIsH264 && !sample->mCrypto.mValid) {
- mp4_demuxer::H264::FrameType type =
- mp4_demuxer::H264::GetFrameType(sample);
+ H264::FrameType type = H264::GetFrameType(sample);
switch (type) {
- case mp4_demuxer::H264::FrameType::I_FRAME: MOZ_FALLTHROUGH;
- case mp4_demuxer::H264::FrameType::OTHER:
+ case H264::FrameType::I_FRAME: MOZ_FALLTHROUGH;
+ case H264::FrameType::OTHER:
{
- bool keyframe = type == mp4_demuxer::H264::FrameType::I_FRAME;
+ bool keyframe = type == H264::FrameType::I_FRAME;
if (sample->mKeyframe != keyframe) {
NS_WARNING(nsPrintfCString("Frame incorrectly marked as %skeyframe "
"@ pts:%" PRId64 " dur:%" PRId64
" dts:%" PRId64,
keyframe ? "" : "non-",
sample->mTime.ToMicroseconds(),
sample->mDuration.ToMicroseconds(),
sample->mTimecode.ToMicroseconds())
.get());
sample->mKeyframe = keyframe;
}
break;
}
- case mp4_demuxer::H264::FrameType::INVALID:
+ case H264::FrameType::INVALID:
NS_WARNING(
nsPrintfCString("Invalid H264 frame @ pts:%" PRId64 " dur:%" PRId64
" dts:%" PRId64,
sample->mTime.ToMicroseconds(),
sample->mDuration.ToMicroseconds(),
sample->mTimecode.ToMicroseconds())
.get());
// We could reject the sample now, however demuxer errors are fatal.
@@ -525,22 +524,22 @@ MP4TrackDemuxer::GetSamples(int32_t aNum
if (samples->mSamples.IsEmpty()) {
return SamplesPromise::CreateAndReject(NS_ERROR_DOM_MEDIA_END_OF_STREAM,
__func__);
}
for (const auto& sample : samples->mSamples) {
// Collect telemetry from h264 Annex B SPS.
if (mNeedSPSForTelemetry && mIsH264 &&
- mp4_demuxer::AnnexB::IsAVCC(sample)) {
+ AnnexB::IsAVCC(sample)) {
RefPtr<MediaByteBuffer> extradata =
- mp4_demuxer::H264::ExtractExtraData(sample);
- if (mp4_demuxer::H264::HasSPS(extradata)) {
+ H264::ExtractExtraData(sample);
+ if (H264::HasSPS(extradata)) {
RefPtr<MediaByteBuffer> extradata =
- mp4_demuxer::H264::ExtractExtraData(sample);
+ H264::ExtractExtraData(sample);
mNeedSPSForTelemetry = AccumulateSPSTelemetry(extradata);
}
}
}
if (mNextKeyframeTime.isNothing() ||
samples->mSamples.LastElement()->mTime >= mNextKeyframeTime.value()) {
SetNextKeyFrameTime();
--- a/dom/media/platforms/PDMFactory.cpp
+++ b/dom/media/platforms/PDMFactory.cpp
@@ -114,21 +114,21 @@ public:
AddMediaFormatChecker(const TrackInfo& aTrackConfig)
{
if (aTrackConfig.IsVideo()) {
auto mimeType = aTrackConfig.GetAsVideoInfo()->mMimeType;
RefPtr<MediaByteBuffer> extraData =
aTrackConfig.GetAsVideoInfo()->mExtraData;
AddToCheckList([mimeType, extraData]() {
if (MP4Decoder::IsH264(mimeType)) {
- mp4_demuxer::SPSData spsdata;
+ SPSData spsdata;
// WMF H.264 Video Decoder and Apple ATDecoder
// do not support YUV444 format.
// For consistency, all decoders should be checked.
- if (mp4_demuxer::H264::DecodeSPSFromExtraData(extraData, spsdata) &&
+ if (H264::DecodeSPSFromExtraData(extraData, spsdata) &&
(spsdata.profile_idc == 244 /* Hi444PP */ ||
spsdata.chroma_format_idc == PDMFactory::kYUV444)) {
return CheckResult(
SupportChecker::Reason::kVideoFormatNotSupported,
MediaResult(NS_ERROR_DOM_MEDIA_FATAL_ERR,
RESULT_DETAIL("Decoder may not have the capability "
"to handle the requested video format "
"with YUV444 chroma subsampling.")));
--- a/dom/media/platforms/agnostic/DummyMediaDataDecoder.cpp
+++ b/dom/media/platforms/agnostic/DummyMediaDataDecoder.cpp
@@ -15,18 +15,18 @@ DummyDataCreator::~DummyDataCreator() {}
DummyMediaDataDecoder::DummyMediaDataDecoder(UniquePtr<DummyDataCreator>&& aCreator,
const nsACString& aDescription,
const CreateDecoderParams& aParams)
: mCreator(Move(aCreator))
, mIsH264(MP4Decoder::IsH264(aParams.mConfig.mMimeType))
, mMaxRefFrames(
mIsH264
- ? mp4_demuxer::H264::HasSPS(aParams.VideoConfig().mExtraData)
- ? mp4_demuxer::H264::ComputeMaxRefFrames(aParams.VideoConfig().mExtraData)
+ ? H264::HasSPS(aParams.VideoConfig().mExtraData)
+ ? H264::ComputeMaxRefFrames(aParams.VideoConfig().mExtraData)
: 16
: 0)
, mType(aParams.mConfig.GetType())
, mDescription(aDescription)
{
}
RefPtr<MediaDataDecoder::InitPromise>
--- a/dom/media/platforms/agnostic/bytestreams/Adts.cpp
+++ b/dom/media/platforms/agnostic/bytestreams/Adts.cpp
@@ -3,19 +3,17 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "Adts.h"
#include "MediaData.h"
#include "mozilla/Array.h"
#include "mozilla/ArrayUtils.h"
#include "nsAutoPtr.h"
-using namespace mozilla;
-
-namespace mp4_demuxer
+namespace mozilla
{
int8_t
Adts::GetFrequencyIndex(uint32_t aSamplesPerSecond)
{
static const uint32_t freq_lookup[] = { 96000, 88200, 64000, 48000, 44100,
32000, 24000, 22050, 16000, 12000,
11025, 8000, 7350, 0};
--- a/dom/media/platforms/agnostic/bytestreams/Adts.h
+++ b/dom/media/platforms/agnostic/bytestreams/Adts.h
@@ -4,20 +4,16 @@
#ifndef ADTS_H_
#define ADTS_H_
#include <stdint.h>
namespace mozilla {
class MediaRawData;
-}
-
-namespace mp4_demuxer
-{
class Adts
{
public:
static int8_t GetFrequencyIndex(uint32_t aSamplesPerSecond);
static bool ConvertSample(uint16_t aChannelCount, int8_t aFrequencyIndex,
int8_t aProfile, mozilla::MediaRawData* aSample);
};
--- a/dom/media/platforms/agnostic/bytestreams/AnnexB.cpp
+++ b/dom/media/platforms/agnostic/bytestreams/AnnexB.cpp
@@ -7,19 +7,17 @@
#include "mozilla/ResultExtensions.h"
#include "mozilla/Unused.h"
#include "AnnexB.h"
#include "BufferReader.h"
#include "ByteWriter.h"
#include "MediaData.h"
#include "nsAutoPtr.h"
-using namespace mozilla;
-
-namespace mp4_demuxer
+namespace mozilla
{
static const uint8_t kAnnexBDelimiter[] = { 0, 0, 0, 1 };
Result<Ok, nsresult>
AnnexB::ConvertSampleToAnnexB(mozilla::MediaRawData* aSample, bool aAddSPS)
{
MOZ_ASSERT(aSample);
@@ -327,9 +325,9 @@ AnnexB::IsAnnexB(const mozilla::MediaRaw
{
if (aSample->Size() < 4) {
return false;
}
uint32_t header = mozilla::BigEndian::readUint32(aSample->Data());
return header == 0x00000001 || (header >> 8) == 0x000001;
}
-} // namespace mp4_demuxer
+} // namespace mozilla
--- a/dom/media/platforms/agnostic/bytestreams/AnnexB.h
+++ b/dom/media/platforms/agnostic/bytestreams/AnnexB.h
@@ -9,20 +9,16 @@
#include "ErrorList.h"
template <class T> struct already_AddRefed;
namespace mozilla {
class BufferReader;
class MediaRawData;
class MediaByteBuffer;
-}
-
-namespace mp4_demuxer
-{
class AnnexB
{
public:
// All conversions assume size of NAL length field is 4 bytes.
// Convert a sample from AVCC format to Annex B.
static mozilla::Result<mozilla::Ok, nsresult>
ConvertSampleToAnnexB(mozilla::MediaRawData* aSample, bool aAddSPS = true);
@@ -40,11 +36,11 @@ public:
static bool IsAnnexB(const mozilla::MediaRawData* aSample);
private:
// AVCC box parser helper.
static mozilla::Result<mozilla::Ok, nsresult>
ConvertSPSOrPPS(mozilla::BufferReader& aReader, uint8_t aCount, mozilla::MediaByteBuffer* aAnnexB);
};
-} // namespace mp4_demuxer
+} // namespace mozilla
#endif // MP4_DEMUXER_ANNEX_B_H_
--- a/dom/media/platforms/agnostic/bytestreams/H264.cpp
+++ b/dom/media/platforms/agnostic/bytestreams/H264.cpp
@@ -26,19 +26,17 @@
{ \
uint32_t uval = br.ReadUE(); \
if (uval > max) { \
return false; \
} \
aDest.var = uval; \
}
-using namespace mozilla;
-
-namespace mp4_demuxer {
+namespace mozilla {
// Default scaling lists (per spec).
// ITU H264:
// Table 7-2 – Assignment of mnemonic names to scaling list indices and
// specification of fall-back rule
static const uint8_t Default_4x4_Intra[16] = {
6, 13, 13, 20,
20, 20, 28, 28,
@@ -1065,9 +1063,9 @@ H264::DecodeRecoverySEI(const mozilla::M
} while(br.PeekU8().isOk() && br.PeekU8().unwrap() != 0x80); // more_rbsp_data() msg[offset] != 0x80
// ignore the trailing bits rbsp_trailing_bits();
return false;
}
#undef READUE
#undef READSE
-} // namespace mp4_demuxer
+} // namespace mozilla
--- a/dom/media/platforms/agnostic/bytestreams/H264.h
+++ b/dom/media/platforms/agnostic/bytestreams/H264.h
@@ -4,19 +4,16 @@
#ifndef MP4_DEMUXER_H264_H_
#define MP4_DEMUXER_H264_H_
#include "DecoderData.h"
namespace mozilla {
class BitReader;
-}
-
-namespace mp4_demuxer {
// Spec 7.4.2.1
#define MAX_SPS_COUNT 32
#define MAX_PPS_COUNT 256
// NAL unit types
enum NAL_TYPES {
H264_NAL_SLICE = 1,
@@ -492,11 +489,11 @@ private:
static void hrd_parameters(mozilla::BitReader& aBr);
static uint8_t NumSPS(const mozilla::MediaByteBuffer* aExtraData);
// Decode SEI payload and return true if the SEI NAL indicates a recovery
// point.
static bool DecodeRecoverySEI(const mozilla::MediaByteBuffer* aSEI,
SEIRecoveryData& aDest);
};
-} // namespace mp4_demuxer
+} // namespace mozilla
#endif // MP4_DEMUXER_H264_H_
--- a/dom/media/platforms/apple/AppleATDecoder.cpp
+++ b/dom/media/platforms/apple/AppleATDecoder.cpp
@@ -663,23 +663,22 @@ AppleATDecoder::GetImplicitAACMagicCooki
{
MOZ_ASSERT(mTaskQueue->IsCurrentThreadIn());
// Prepend ADTS header to AAC audio.
RefPtr<MediaRawData> adtssample(aSample->Clone());
if (!adtssample) {
return NS_ERROR_OUT_OF_MEMORY;
}
- int8_t frequency_index =
- mp4_demuxer::Adts::GetFrequencyIndex(mConfig.mRate);
+ int8_t frequency_index = Adts::GetFrequencyIndex(mConfig.mRate);
- bool rv = mp4_demuxer::Adts::ConvertSample(mConfig.mChannels,
- frequency_index,
- mConfig.mProfile,
- adtssample);
+ bool rv = Adts::ConvertSample(mConfig.mChannels,
+ frequency_index,
+ mConfig.mProfile,
+ adtssample);
if (!rv) {
NS_WARNING("Failed to apply ADTS header");
return NS_ERROR_FAILURE;
}
if (!mStream) {
OSStatus rv = AudioFileStreamOpen(this,
_MetadataCallback,
_SampleCallback,
--- a/dom/media/platforms/apple/AppleVTDecoder.cpp
+++ b/dom/media/platforms/apple/AppleVTDecoder.cpp
@@ -28,17 +28,17 @@ AppleVTDecoder::AppleVTDecoder(const Vid
TaskQueue* aTaskQueue,
layers::ImageContainer* aImageContainer)
: mExtraData(aConfig.mExtraData)
, mPictureWidth(aConfig.mImage.width)
, mPictureHeight(aConfig.mImage.height)
, mDisplayWidth(aConfig.mDisplay.width)
, mDisplayHeight(aConfig.mDisplay.height)
, mTaskQueue(aTaskQueue)
- , mMaxRefFrames(mp4_demuxer::H264::ComputeMaxRefFrames(aConfig.mExtraData))
+ , mMaxRefFrames(H264::ComputeMaxRefFrames(aConfig.mExtraData))
, mImageContainer(aImageContainer)
#ifdef MOZ_WIDGET_UIKIT
, mUseSoftwareImages(true)
#else
, mUseSoftwareImages(false)
#endif
, mIsFlushing(false)
, mMonitor("AppleVTDecoder")
--- a/dom/media/platforms/wrappers/H264Converter.cpp
+++ b/dom/media/platforms/wrappers/H264Converter.cpp
@@ -31,17 +31,17 @@ H264Converter::H264Converter(PlatformDec
, mLastError(NS_OK)
, mType(aParams.mType)
, mOnWaitingForKeyEvent(aParams.mOnWaitingForKeyEvent)
, mDecoderOptions(aParams.mOptions)
, mRate(aParams.mRate)
{
mLastError = CreateDecoder(mOriginalConfig, aParams.mDiagnostics);
if (mDecoder) {
- MOZ_ASSERT(mp4_demuxer::H264::HasSPS(mOriginalConfig.mExtraData));
+ MOZ_ASSERT(H264::HasSPS(mOriginalConfig.mExtraData));
// The video metadata contains out of band SPS/PPS (AVC1) store it.
mOriginalExtraData = mOriginalConfig.mExtraData;
}
}
H264Converter::~H264Converter()
{
}
@@ -62,25 +62,25 @@ RefPtr<MediaDataDecoder::DecodePromise>
H264Converter::Decode(MediaRawData* aSample)
{
MOZ_RELEASE_ASSERT(mFlushPromise.IsEmpty(), "Flush operatin didn't complete");
MOZ_RELEASE_ASSERT(!mDecodePromiseRequest.Exists() &&
!mInitPromiseRequest.Exists(),
"Can't request a new decode until previous one completed");
- if (!mp4_demuxer::AnnexB::ConvertSampleToAVCC(aSample)) {
+ if (!AnnexB::ConvertSampleToAVCC(aSample)) {
// We need AVCC content to be able to later parse the SPS.
// This is a no-op if the data is already AVCC.
return DecodePromise::CreateAndReject(
MediaResult(NS_ERROR_OUT_OF_MEMORY, RESULT_DETAIL("ConvertSampleToAVCC")),
__func__);
}
- if (!mp4_demuxer::AnnexB::IsAVCC(aSample)) {
+ if (!AnnexB::IsAVCC(aSample)) {
return DecodePromise::CreateAndReject(
MediaResult(NS_ERROR_DOM_MEDIA_FATAL_ERR,
RESULT_DETAIL("Invalid H264 content")),
__func__);
}
MediaResult rv(NS_OK);
if (!mDecoder) {
@@ -116,17 +116,17 @@ H264Converter::Decode(MediaRawData* aSam
return DecodePromise::CreateAndReject(rv, __func__);
}
if (mNeedKeyframe && !aSample->mKeyframe) {
return DecodePromise::CreateAndResolve(DecodedData(), __func__);
}
auto res = !*mNeedAVCC
- ? mp4_demuxer::AnnexB::ConvertSampleToAnnexB(aSample, mNeedKeyframe)
+ ? AnnexB::ConvertSampleToAnnexB(aSample, mNeedKeyframe)
: Ok();
if (res.isErr()) {
return DecodePromise::CreateAndReject(
MediaResult(res.unwrapErr(), RESULT_DETAIL("ConvertSampleToAnnexB")),
__func__);
}
mNeedKeyframe = false;
@@ -241,24 +241,24 @@ H264Converter::SetSeekThreshold(const me
MediaDataDecoder::SetSeekThreshold(aTime);
}
}
MediaResult
H264Converter::CreateDecoder(const VideoInfo& aConfig,
DecoderDoctorDiagnostics* aDiagnostics)
{
- if (!mp4_demuxer::H264::HasSPS(aConfig.mExtraData)) {
+ if (!H264::HasSPS(aConfig.mExtraData)) {
// nothing found yet, will try again later
return NS_ERROR_NOT_INITIALIZED;
}
UpdateConfigFromExtraData(aConfig.mExtraData);
- mp4_demuxer::SPSData spsdata;
- if (mp4_demuxer::H264::DecodeSPSFromExtraData(aConfig.mExtraData, spsdata)) {
+ SPSData spsdata;
+ if (H264::DecodeSPSFromExtraData(aConfig.mExtraData, spsdata)) {
// Do some format check here.
// WMF H.264 Video Decoder and Apple ATDecoder do not support YUV444 format.
if (spsdata.profile_idc == 244 /* Hi444PP */ ||
spsdata.chroma_format_idc == PDMFactory::kYUV444) {
if (aDiagnostics) {
aDiagnostics->SetVideoNotSupported();
}
return MediaResult(NS_ERROR_DOM_MEDIA_FATAL_ERR,
@@ -298,20 +298,20 @@ H264Converter::CreateDecoder(const Video
return NS_OK;
}
MediaResult
H264Converter::CreateDecoderAndInit(MediaRawData* aSample)
{
RefPtr<MediaByteBuffer> extra_data =
- mp4_demuxer::H264::ExtractExtraData(aSample);
- bool inbandExtradata = mp4_demuxer::H264::HasSPS(extra_data);
+ H264::ExtractExtraData(aSample);
+ bool inbandExtradata = H264::HasSPS(extra_data);
if (!inbandExtradata &&
- !mp4_demuxer::H264::HasSPS(mCurrentConfig.mExtraData)) {
+ !H264::HasSPS(mCurrentConfig.mExtraData)) {
return NS_ERROR_NOT_INITIALIZED;
}
if (inbandExtradata) {
UpdateConfigFromExtraData(extra_data);
}
MediaResult rv =
@@ -371,17 +371,17 @@ H264Converter::DecodeFirstSample(MediaRa
{
if (mNeedKeyframe && !aSample->mKeyframe) {
mDecodePromise.Resolve(mPendingFrames, __func__);
mPendingFrames.Clear();
return;
}
auto res = !*mNeedAVCC
- ? mp4_demuxer::AnnexB::ConvertSampleToAnnexB(aSample, mNeedKeyframe)
+ ? AnnexB::ConvertSampleToAnnexB(aSample, mNeedKeyframe)
: Ok();
if (res.isErr()) {
mDecodePromise.Reject(
MediaResult(res.unwrapErr(), RESULT_DETAIL("ConvertSampleToAnnexB")),
__func__);
return;
}
@@ -402,37 +402,37 @@ H264Converter::DecodeFirstSample(MediaRa
})
->Track(mDecodePromiseRequest);
}
MediaResult
H264Converter::CheckForSPSChange(MediaRawData* aSample)
{
RefPtr<MediaByteBuffer> extra_data =
- mp4_demuxer::H264::ExtractExtraData(aSample);
- if (!mp4_demuxer::H264::HasSPS(extra_data)) {
+ H264::ExtractExtraData(aSample);
+ if (!H264::HasSPS(extra_data)) {
MOZ_ASSERT(mCanRecycleDecoder.isSome());
if (!*mCanRecycleDecoder) {
// If the decoder can't be recycled, the out of band extradata will never
// change as the H264Converter will be recreated by the MediaFormatReader
// instead. So there's no point in testing for changes.
return NS_OK;
}
// This sample doesn't contain inband SPS/PPS
// We now check if the out of band one has changed.
// This scenario can only occur on Android with devices that can recycle a
// decoder.
- if (!mp4_demuxer::H264::HasSPS(aSample->mExtraData) ||
- mp4_demuxer::H264::CompareExtraData(aSample->mExtraData,
+ if (!H264::HasSPS(aSample->mExtraData) ||
+ H264::CompareExtraData(aSample->mExtraData,
mOriginalExtraData)) {
return NS_OK;
}
extra_data = mOriginalExtraData = aSample->mExtraData;
}
- if (mp4_demuxer::H264::CompareExtraData(extra_data,
+ if (H264::CompareExtraData(extra_data,
mCurrentConfig.mExtraData)) {
return NS_OK;
}
MOZ_ASSERT(mCanRecycleDecoder.isSome());
if (*mCanRecycleDecoder) {
// Do not recreate the decoder, reuse it.
UpdateConfigFromExtraData(extra_data);
@@ -537,20 +537,20 @@ void H264Converter::FlushThenShutdownDec
mDecodePromise.Reject(aError, __func__);
})
->Track(mFlushRequest);
}
void
H264Converter::UpdateConfigFromExtraData(MediaByteBuffer* aExtraData)
{
- mp4_demuxer::SPSData spsdata;
- if (mp4_demuxer::H264::DecodeSPSFromExtraData(aExtraData, spsdata) &&
+ SPSData spsdata;
+ if (H264::DecodeSPSFromExtraData(aExtraData, spsdata) &&
spsdata.pic_width > 0 && spsdata.pic_height > 0) {
- mp4_demuxer::H264::EnsureSPSIsSane(spsdata);
+ H264::EnsureSPSIsSane(spsdata);
mCurrentConfig.mImage.width = spsdata.pic_width;
mCurrentConfig.mImage.height = spsdata.pic_height;
mCurrentConfig.mDisplay.width = spsdata.display_width;
mCurrentConfig.mDisplay.height = spsdata.display_height;
}
mCurrentConfig.mExtraData = aExtraData;
}