Backed out 7 changesets (bug 1570337) for bustages on AndroidDataEncoder.h . CLOSED TREE (18c3932c) · Commits · The Tor Project / Applications / Tor Browser

dom/media/gtest/TestMediaDataEncoder.cpp

+25 −45

Original line number	Original line	Diff line number	Diff line
	@@ -33,7 +33,6 @@
	#define FRAME_RATE 30		#define FRAME_RATE 30
	#define FRAME_DURATION (1000000 / FRAME_RATE)		#define FRAME_DURATION (1000000 / FRAME_RATE)
	#define BIT_RATE (1000 * 1000) // 1Mbps		#define BIT_RATE (1000 * 1000) // 1Mbps
	#define KEYFRAME_INTERVAL FRAME_RATE // 1 keyframe per second

	using namespace mozilla;		using namespace mozilla;

	@@ -134,11 +133,8 @@ class MediaDataEncoderTest : public testing::Test {
	};		};

	static already_AddRefed<MediaDataEncoder> CreateH264Encoder(		static already_AddRefed<MediaDataEncoder> CreateH264Encoder(
	MediaDataEncoder::Usage aUsage, MediaDataEncoder::PixelFormat aPixelFormat,		MediaDataEncoder::Usage aUsage,
	const Maybe<MediaDataEncoder::H264Specific>& aSpecific =		MediaDataEncoder::PixelFormat aPixelFormat) {
	Some(MediaDataEncoder::H264Specific(
	KEYFRAME_INTERVAL,
	MediaDataEncoder::H264Specific::ProfileLevel::BaselineAutoLevel))) {
	RefPtr<PEMFactory> f(new PEMFactory());		RefPtr<PEMFactory> f(new PEMFactory());

	if (!f->SupportsMimeType(NS_LITERAL_CSTRING(VIDEO_MP4))) {		if (!f->SupportsMimeType(NS_LITERAL_CSTRING(VIDEO_MP4))) {
	@@ -149,19 +145,10 @@ static already_AddRefed<MediaDataEncoder> CreateH264Encoder(
	videoInfo.mMimeType = NS_LITERAL_CSTRING(VIDEO_MP4);		videoInfo.mMimeType = NS_LITERAL_CSTRING(VIDEO_MP4);
	const RefPtr<TaskQueue> taskQueue(		const RefPtr<TaskQueue> taskQueue(
	new TaskQueue(GetMediaThreadPool(MediaThreadType::PLAYBACK)));		new TaskQueue(GetMediaThreadPool(MediaThreadType::PLAYBACK)));
			CreateEncoderParams c(videoInfo /* track info */, aUsage, taskQueue,
	RefPtr<MediaDataEncoder> e;		aPixelFormat, FRAME_RATE /* FPS */,
	if (aSpecific) {		BIT_RATE /* bitrate */);
	e = f->CreateEncoder(CreateEncoderParams(		return f->CreateEncoder(c);
	videoInfo /* track info */, aUsage, taskQueue, aPixelFormat,
	FRAME_RATE /* FPS /, BIT_RATE / bitrate */, aSpecific.value()));
	} else {
	e = f->CreateEncoder(CreateEncoderParams(
	videoInfo /* track info */, aUsage, taskQueue, aPixelFormat,
	FRAME_RATE /* FPS /, BIT_RATE / bitrate */));
	}

	return e.forget();
	}		}

	void WaitForShutdown(RefPtr<MediaDataEncoder> aEncoder) {		void WaitForShutdown(RefPtr<MediaDataEncoder> aEncoder) {
	@@ -211,22 +198,6 @@ static bool EnsureInit(RefPtr<MediaDataEncoder> aEncoder) {
	return succeeded;		return succeeded;
	}		}

	TEST_F(MediaDataEncoderTest, H264InitWithoutSpecific) {
	SKIP_IF_NOT_SUPPORTED(VIDEO_MP4);

	RefPtr<MediaDataEncoder> e =
	CreateH264Encoder(MediaDataEncoder::Usage::Realtime,
	MediaDataEncoder::PixelFormat::YUV420P, Nothing());

	#if defined(MOZ_WIDGET_ANDROID) // Android encoder requires I-frame interval
	EXPECT_FALSE(EnsureInit(e));
	#else
	EXPECT_TRUE(EnsureInit(e));
	#endif

	WaitForShutdown(e);
	}

	TEST_F(MediaDataEncoderTest, H264Init) {		TEST_F(MediaDataEncoderTest, H264Init) {
	SKIP_IF_NOT_SUPPORTED(VIDEO_MP4);		SKIP_IF_NOT_SUPPORTED(VIDEO_MP4);

	@@ -260,7 +231,6 @@ static MediaDataEncoder::EncodedData Encode(
	}		}

	size_t pending = 0;		size_t pending = 0;
	do {
	media::Await(		media::Await(
	GetMediaThreadPool(MediaThreadType::PLAYBACK), aEncoder->Drain(),		GetMediaThreadPool(MediaThreadType::PLAYBACK), aEncoder->Drain(),
	[&pending, &output, &succeeded](MediaDataEncoder::EncodedData encoded) {		[&pending, &output, &succeeded](MediaDataEncoder::EncodedData encoded) {
	@@ -273,7 +243,17 @@ static MediaDataEncoder::EncodedData Encode(
	if (!succeeded) {		if (!succeeded) {
	return output;		return output;
	}		}
	} while (pending > 0);
			if (pending > 0) {
			media::Await(
			GetMediaThreadPool(MediaThreadType::PLAYBACK), aEncoder->Drain(),
			[&succeeded](MediaDataEncoder::EncodedData encoded) {
			EXPECT_EQ(encoded.Length(), 0UL);
			succeeded = true;
			},
			[&succeeded](MediaResult r) { succeeded = false; });
			EXPECT_TRUE(succeeded);
			}

	return output;		return output;
	}		}

dom/media/platforms/PEMFactory.cpp

+0 −8

Original line number	Original line	Diff line number	Diff line
	@@ -9,22 +9,14 @@
	#ifdef MOZ_APPLEMEDIA		#ifdef MOZ_APPLEMEDIA
	# include "AppleEncoderModule.h"		# include "AppleEncoderModule.h"
	#endif		#endif
	#ifdef MOZ_WIDGET_ANDROID
	# include "AndroidEncoderModule.h"
	#endif

	namespace mozilla {		namespace mozilla {

	LazyLogModule sPEMLog("PlatformEncoderModule");

	PEMFactory::PEMFactory() {		PEMFactory::PEMFactory() {
	#ifdef MOZ_APPLEMEDIA		#ifdef MOZ_APPLEMEDIA
	RefPtr<PlatformEncoderModule> m(new AppleEncoderModule());		RefPtr<PlatformEncoderModule> m(new AppleEncoderModule());
	mModules.AppendElement(m);		mModules.AppendElement(m);
	#endif		#endif
	#ifdef MOZ_WIDGET_ANDROID
	mModules.AppendElement(new AndroidEncoderModule());
	#endif
	}		}

	bool PEMFactory::SupportsMimeType(const nsACString& aMimeType) const {		bool PEMFactory::SupportsMimeType(const nsACString& aMimeType) const {

dom/media/platforms/PlatformEncoderModule.h

+2 −17

Original line number	Original line	Diff line number	Diff line
	@@ -23,6 +23,8 @@ namespace mozilla {
	class MediaDataEncoder;		class MediaDataEncoder;
	struct CreateEncoderParams;		struct CreateEncoderParams;

			static LazyLogModule sPEMLog("PlatformEncoderModule");

	class PlatformEncoderModule {		class PlatformEncoderModule {
	public:		public:
	NS_INLINE_DECL_THREADSAFE_REFCOUNTING(PlatformEncoderModule)		NS_INLINE_DECL_THREADSAFE_REFCOUNTING(PlatformEncoderModule)
	@@ -202,9 +204,6 @@ class MediaDataEncoder {
	};		};

	virtual ~MediaDataEncoder() {}		virtual ~MediaDataEncoder() {}

	public:
	using H264Config = VideoConfig<H264Specific>;
	};		};

	struct MOZ_STACK_CLASS CreateEncoderParams final {		struct MOZ_STACK_CLASS CreateEncoderParams final {
	@@ -251,20 +250,6 @@ struct MOZ_STACK_CLASS CreateEncoderParams final {
	Set(std::forward<const Ts>(aCodecSpecific)...);		Set(std::forward<const Ts>(aCodecSpecific)...);
	}		}

	const MediaDataEncoder::H264Config ToH264Config() const {
	const VideoInfo* info = mConfig.GetAsVideoInfo();
	MOZ_ASSERT(info);

	auto config = MediaDataEncoder::H264Config(
	MediaDataEncoder::CodecType::H264, mUsage, info->mImage, mPixelFormat,
	mFramerate, mBitrate);
	if (mCodecSpecific) {
	config.SetCodecSpecific(mCodecSpecific.ref().mH264);
	}

	return config;
	}

	const TrackInfo& mConfig;		const TrackInfo& mConfig;
	const MediaDataEncoder::Usage mUsage;		const MediaDataEncoder::Usage mUsage;
	const RefPtr<TaskQueue> mTaskQueue;		const RefPtr<TaskQueue> mTaskQueue;

dom/media/platforms/agnostic/bytestreams/AnnexB.cpp

+3 −10

Original line number	Original line	Diff line number	Diff line
	@@ -255,8 +255,7 @@ static Result<mozilla::Ok, nsresult> ParseNALUnits(ByteWriter<BigEndian>& aBw,
	return Ok();		return Ok();
	}		}

	bool AnnexB::ConvertSampleToAVCC(mozilla::MediaRawData* aSample,		bool AnnexB::ConvertSampleToAVCC(mozilla::MediaRawData* aSample) {
	const RefPtr<MediaByteBuffer>& aAVCCHeader) {
	if (IsAVCC(aSample)) {		if (IsAVCC(aSample)) {
	return ConvertSampleTo4BytesAVCC(aSample).isOk();		return ConvertSampleTo4BytesAVCC(aSample).isOk();
	}		}
	@@ -276,14 +275,8 @@ bool AnnexB::ConvertSampleToAVCC(mozilla::MediaRawData* aSample,
	if (!samplewriter->Replace(nalu.Elements(), nalu.Length())) {		if (!samplewriter->Replace(nalu.Elements(), nalu.Length())) {
	return false;		return false;
	}		}

	if (aAVCCHeader) {
	aSample->mExtraData = aAVCCHeader;
	return true;
	}

	// Create the AVCC header.		// Create the AVCC header.
	auto extradata = MakeRefPtr<mozilla::MediaByteBuffer>();		RefPtr<mozilla::MediaByteBuffer> extradata = new mozilla::MediaByteBuffer;
	static const uint8_t kFakeExtraData[] = {		static const uint8_t kFakeExtraData[] = {
	1 /* version */,		1 /* version */,
	0x64 /* profile (High) */,		0x64 /* profile (High) */,
	@@ -296,7 +289,7 @@ bool AnnexB::ConvertSampleToAVCC(mozilla::MediaRawData* aSample,
	if (!extradata->AppendElements(kFakeExtraData, ArrayLength(kFakeExtraData))) {		if (!extradata->AppendElements(kFakeExtraData, ArrayLength(kFakeExtraData))) {
	return false;		return false;
	}		}
	aSample->mExtraData = std::move(extradata);		aSample->mExtraData = extradata;
	return true;		return true;
	}		}

dom/media/platforms/agnostic/bytestreams/AnnexB.h

+1 −3

Original line number	Original line	Diff line number	Diff line
	@@ -34,9 +34,7 @@ class AnnexB {
	mozilla::MediaRawData* aSample, bool aAddSPS = true);		mozilla::MediaRawData* aSample, bool aAddSPS = true);
	// Convert a sample from Annex B to AVCC.		// Convert a sample from Annex B to AVCC.
	// an AVCC extradata must not be set.		// an AVCC extradata must not be set.
	static bool ConvertSampleToAVCC(		static bool ConvertSampleToAVCC(mozilla::MediaRawData* aSample);
	mozilla::MediaRawData* aSample,
	const RefPtr<mozilla::MediaByteBuffer>& aAVCCHeader = nullptr);
	static mozilla::Result<mozilla::Ok, nsresult> ConvertSampleTo4BytesAVCC(		static mozilla::Result<mozilla::Ok, nsresult> ConvertSampleTo4BytesAVCC(
	mozilla::MediaRawData* aSample);		mozilla::MediaRawData* aSample);