Merge "Transcoder: Benchmark HEVC->AVC and max operating rate" (f2f31ace) · Commits · e / os / android_frameworks_av

media/libmediatranscoding/transcoder/benchmark/MediaTrackTranscoderBenchmark.cpp

+58 −12

Original line number	Diff line number	Diff line
		@@ -216,7 +216,8 @@ private:
		};

		static std::shared_ptr<AMediaFormat> GetDefaultTrackFormat(MediaType mediaType,
		AMediaFormat* sourceFormat) {
		AMediaFormat* sourceFormat,
		bool maxOperatingRate) {
		// Default video config.
		static constexpr int32_t kVideoBitRate = 20 * 1000 * 1000; // 20 mbps
		static constexpr float kVideoFrameRate = 30.0f; // 30 fps
		@@ -229,6 +230,11 @@ static std::shared_ptr<AMediaFormat> GetDefaultTrackFormat(MediaType mediaType,
		AMediaFormat_setString(format, AMEDIAFORMAT_KEY_MIME, AMEDIA_MIMETYPE_VIDEO_AVC);
		AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_BIT_RATE, kVideoBitRate);
		AMediaFormat_setFloat(format, AMEDIAFORMAT_KEY_FRAME_RATE, kVideoFrameRate);

		if (maxOperatingRate) {
		AMediaFormat_setFloat(format, AMEDIAFORMAT_KEY_OPERATING_RATE, INT32_MAX);
		AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_PRIORITY, 1);
		}
		}
		// nothing for audio.

		@@ -282,7 +288,7 @@ static void ConfigureEmptySampleConsumer(const std::shared_ptr<MediaTrackTransco
		*/
		static bool ConfigureSampleReader(const std::shared_ptr<MediaTrackTranscoder>& transcoder,
		const std::shared_ptr<MediaSampleReader>& sampleReader,
		MediaType mediaType) {
		MediaType mediaType, bool maxOperatingRate) {
		int srcTrackIndex = -1;
		std::shared_ptr<AMediaFormat> srcTrackFormat = nullptr;

		@@ -312,7 +318,8 @@ static bool ConfigureSampleReader(const std::shared_ptr<MediaTrackTranscoder>& t
		return false;
		}

		auto destinationFormat = GetDefaultTrackFormat(mediaType, srcTrackFormat.get());
		auto destinationFormat =
		GetDefaultTrackFormat(mediaType, srcTrackFormat.get(), maxOperatingRate);
		status = transcoder->configure(sampleReader, srcTrackIndex, destinationFormat);
		if (status != AMEDIA_OK) {
		LOG(ERROR) << "transcoder configure returned " << status;
		@@ -323,7 +330,7 @@ static bool ConfigureSampleReader(const std::shared_ptr<MediaTrackTranscoder>& t
		}

		static void BenchmarkTranscoder(benchmark::State& state, const std::string& srcFileName,
		bool mockReader, MediaType mediaType) {
		bool mockReader, MediaType mediaType, bool maxOperatingRate) {
		for (auto _ : state) {
		std::shared_ptr<TrackTranscoderCallbacks> callbacks =
		std::make_shared<TrackTranscoderCallbacks>();
		@@ -341,7 +348,7 @@ static void BenchmarkTranscoder(benchmark::State& state, const std::string& srcF
		return;
		}

		if (!ConfigureSampleReader(transcoder, sampleReader, mediaType)) {
		if (!ConfigureSampleReader(transcoder, sampleReader, mediaType, maxOperatingRate)) {
		state.SkipWithError("Unable to configure the transcoder");
		return;
		}
		@@ -367,33 +374,72 @@ static void BenchmarkTranscoder(benchmark::State& state, const std::string& srcF
		}
		}

		// Benchmark registration wrapper for transcoding.
		#define TRANSCODER_BENCHMARK(func) \
		BENCHMARK(func)->UseRealTime()->MeasureProcessCPUTime()->Unit(benchmark::kMillisecond)
		//-------------------------------- AVC to AVC Benchmarks -------------------------------------------

		static void BM_VideoTranscode_AVC2AVC_NoMuxer(benchmark::State& state) {
		const char* srcFile = "video_1920x1080_3648frame_h264_22Mbps_30fps_aac.mp4";
		BenchmarkTranscoder(state, srcFile, false /* mockReader */, kVideo);
		BenchmarkTranscoder(state, srcFile, false /* mockReader */, kVideo,
		false /* maxOperatingRate */);
		}

		static void BM_VideoTranscode_AVC2AVC_NoMuxer_NoExtractor(benchmark::State& state) {
		const char* srcFile = "video_1920x1080_3648frame_h264_22Mbps_30fps_aac.mp4";
		BenchmarkTranscoder(state, srcFile, true /* mockReader */, kVideo);
		BenchmarkTranscoder(state, srcFile, true /* mockReader */, kVideo,
		false /* maxOperatingRate */);
		}

		static void BM_VideoTranscode_AVC2AVC_NoMuxer_MaxOperatingRate(benchmark::State& state) {
		const char* srcFile = "video_1920x1080_3648frame_h264_22Mbps_30fps_aac.mp4";
		BenchmarkTranscoder(state, srcFile, false /* mockReader */, kVideo,
		true /* maxOperatingRate */);
		}

		static void BM_VideoTranscode_AVC2AVC_NoMuxer_NoExtractor_MaxOperatingRate(
		benchmark::State& state) {
		const char* srcFile = "video_1920x1080_3648frame_h264_22Mbps_30fps_aac.mp4";
		BenchmarkTranscoder(state, srcFile, true /* mockReader /, kVideo, true / maxOperatingRate */);
		}

		//-------------------------------- HEVC to AVC Benchmarks ------------------------------------------

		static void BM_VideoTranscode_HEVC2AVC_NoMuxer(benchmark::State& state) {
		const char* srcFile = "video_1920x1080_3863frame_hevc_4Mbps_30fps_aac.mp4";
		BenchmarkTranscoder(state, srcFile, false /* mockReader */, kVideo);
		BenchmarkTranscoder(state, srcFile, false /* mockReader */, kVideo,
		false /* maxOperatingRate */);
		}

		static void BM_VideoTranscode_HEVC2AVC_NoMuxer_NoExtractor(benchmark::State& state) {
		const char* srcFile = "video_1920x1080_3863frame_hevc_4Mbps_30fps_aac.mp4";
		BenchmarkTranscoder(state, srcFile, true /* mockReader */, kVideo);
		BenchmarkTranscoder(state, srcFile, true /* mockReader */, kVideo,
		false /* maxOperatingRate */);
		}

		static void BM_VideoTranscode_HEVC2AVC_NoMuxer_MaxOperatingRate(benchmark::State& state) {
		const char* srcFile = "video_1920x1080_3863frame_hevc_4Mbps_30fps_aac.mp4";
		BenchmarkTranscoder(state, srcFile, false /* mockReader */, kVideo,
		true /* maxOperatingRate */);
		}

		static void BM_VideoTranscode_HEVC2AVC_NoMuxer_NoExtractor_MaxOperatingRate(
		benchmark::State& state) {
		const char* srcFile = "video_1920x1080_3863frame_hevc_4Mbps_30fps_aac.mp4";
		BenchmarkTranscoder(state, srcFile, true /* mockReader /, kVideo, true / maxOperatingRate */);
		}

		//-------------------------------- Benchmark Registration ------------------------------------------

		// Benchmark registration wrapper for transcoding.
		#define TRANSCODER_BENCHMARK(func) \
		BENCHMARK(func)->UseRealTime()->MeasureProcessCPUTime()->Unit(benchmark::kMillisecond)

		TRANSCODER_BENCHMARK(BM_VideoTranscode_AVC2AVC_NoMuxer);
		TRANSCODER_BENCHMARK(BM_VideoTranscode_AVC2AVC_NoMuxer_NoExtractor);
		TRANSCODER_BENCHMARK(BM_VideoTranscode_AVC2AVC_NoMuxer_MaxOperatingRate);
		TRANSCODER_BENCHMARK(BM_VideoTranscode_AVC2AVC_NoMuxer_NoExtractor_MaxOperatingRate);

		TRANSCODER_BENCHMARK(BM_VideoTranscode_HEVC2AVC_NoMuxer);
		TRANSCODER_BENCHMARK(BM_VideoTranscode_HEVC2AVC_NoMuxer_NoExtractor);
		TRANSCODER_BENCHMARK(BM_VideoTranscode_HEVC2AVC_NoMuxer_MaxOperatingRate);
		TRANSCODER_BENCHMARK(BM_VideoTranscode_HEVC2AVC_NoMuxer_NoExtractor_MaxOperatingRate);

		BENCHMARK_MAIN();

media/libmediatranscoding/transcoder/benchmark/MediaTranscoderBenchmark.cpp

+59 −33

Original line number	Diff line number	Diff line
		@@ -191,14 +191,24 @@ exit:
		if (dstFd > 0) close(dstFd);
		}

		/**
		* Callback to edit track format for transcoding.
		* @param dstFormat The default track format for the track type.
		*/
		using TrackFormatEditCallback = std::function<void(AMediaFormat* dstFormat)>;

		static void TranscodeMediaFile(benchmark::State& state, const std::string& srcFileName,
		const std::string& dstFileName, bool includeAudio,
		bool transcodeVideo) {
		bool transcodeVideo,
		const TrackFormatEditCallback& videoFormatEditor = nullptr) {
		TranscodeMediaFile(state, srcFileName, dstFileName,
		[=](const char* mime, AMediaFormat** dstFormatOut) -> bool {
		*dstFormatOut = nullptr;
		if (strncmp(mime, "video/", 6) == 0 && transcodeVideo) {
		*dstFormatOut = CreateDefaultVideoFormat();
		if (videoFormatEditor != nullptr) {
		videoFormatEditor(*dstFormatOut);
		}
		} else if (strncmp(mime, "audio/", 6) == 0 && !includeAudio) {
		return false;
		}
		@@ -206,9 +216,12 @@ static void TranscodeMediaFile(benchmark::State& state, const std::string& srcFi
		});
		}

		// Benchmark registration wrapper for transcoding.
		#define TRANSCODER_BENCHMARK(func) \
		BENCHMARK(func)->UseRealTime()->MeasureProcessCPUTime()->Unit(benchmark::kMillisecond)
		static void SetMaxOperatingRate(AMediaFormat* format) {
		AMediaFormat_setFloat(format, AMEDIAFORMAT_KEY_OPERATING_RATE, INT32_MAX);
		AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_PRIORITY, 1);
		}

		//-------------------------------- AVC to AVC Benchmarks -------------------------------------------

		static void BM_TranscodeAvc2AvcAudioVideo2AudioVideo(benchmark::State& state) {
		TranscodeMediaFile(state, "video_1920x1080_3648frame_h264_22Mbps_30fps_aac.mp4",
		@@ -216,12 +229,6 @@ static void BM_TranscodeAvc2AvcAudioVideo2AudioVideo(benchmark::State& state) {
		true /* includeAudio /, true / transcodeVideo */);
		}

		static void BM_TranscodeAvc2AvcAudioVideo2Video(benchmark::State& state) {
		TranscodeMediaFile(state, "video_1920x1080_3648frame_h264_22Mbps_30fps_aac.mp4",
		"video_1920x1080_3648frame_h264_22Mbps_30fps_aac_transcoded_V.mp4",
		false /* includeAudio /, true / transcodeVideo */);
		}

		static void BM_TranscodeAvc2AvcVideo2Video(benchmark::State& state) {
		TranscodeMediaFile(state, "video_1920x1080_3648frame_h264_22Mbps_30fps.mp4",
		"video_1920x1080_3648frame_h264_22Mbps_30fps_transcoded_V.mp4",
		@@ -231,35 +238,43 @@ static void BM_TranscodeAvc2AvcVideo2Video(benchmark::State& state) {
		static void BM_TranscodeAvc2AvcAV2AVMaxOperatingRate(benchmark::State& state) {
		TranscodeMediaFile(state, "video_1920x1080_3648frame_h264_22Mbps_30fps_aac.mp4",
		"video_1920x1080_3648frame_h264_22Mbps_30fps_aac_transcoded_AV.mp4",
		[](const char* mime, AMediaFormat** dstFormatOut) -> bool {
		AMediaFormat* dstFormat = nullptr;
		if (strncmp(mime, "video/", 6) == 0) {
		dstFormat = CreateDefaultVideoFormat();
		AMediaFormat_setFloat(dstFormat, AMEDIAFORMAT_KEY_OPERATING_RATE,
		INT32_MAX);
		AMediaFormat_setInt32(dstFormat, AMEDIAFORMAT_KEY_PRIORITY, 1);
		}
		*dstFormatOut = dstFormat;
		return true;
		});
		true /* includeAudio /, true / transcodeVideo */, SetMaxOperatingRate);
		}

		static void BM_TranscodeAvc2AvcV2VMaxOperatingRate(benchmark::State& state) {
		TranscodeMediaFile(state, "video_1920x1080_3648frame_h264_22Mbps_30fps.mp4",
		"video_1920x1080_3648frame_h264_22Mbps_30fps_transcoded_V.mp4",
		[](const char* mime, AMediaFormat** dstFormatOut) -> bool {
		if (strncmp(mime, "video/", 6) == 0) {
		AMediaFormat* dstFormat = CreateDefaultVideoFormat();
		AMediaFormat_setFloat(dstFormat, AMEDIAFORMAT_KEY_OPERATING_RATE,
		INT32_MAX);
		AMediaFormat_setInt32(dstFormat, AMEDIAFORMAT_KEY_PRIORITY, 1);
		*dstFormatOut = dstFormat;
		return true;
		false /* includeAudio /, true / transcodeVideo */, SetMaxOperatingRate);
		}
		return false;
		});

		//-------------------------------- HEVC to AVC Benchmarks ------------------------------------------

		static void BM_TranscodeHevc2AvcAudioVideo2AudioVideo(benchmark::State& state) {
		TranscodeMediaFile(state, "video_1920x1080_3863frame_hevc_4Mbps_30fps_aac.mp4",
		"video_1920x1080_3863frame_hevc_4Mbps_30fps_aac_transcoded_AV.mp4",
		true /* includeAudio /, true / transcodeVideo */);
		}

		static void BM_TranscodeHevc2AvcVideo2Video(benchmark::State& state) {
		TranscodeMediaFile(state, "video_1920x1080_3863frame_hevc_4Mbps_30fps.mp4",
		"video_1920x1080_3863frame_hevc_4Mbps_30fps_transcoded_V.mp4",
		false /* includeAudio /, true / transcodeVideo */);
		}

		static void BM_TranscodeHevc2AvcAV2AVMaxOperatingRate(benchmark::State& state) {
		TranscodeMediaFile(state, "video_1920x1080_3863frame_hevc_4Mbps_30fps_aac.mp4",
		"video_1920x1080_3863frame_hevc_4Mbps_30fps_aac_transcoded_AV.mp4",
		true /* includeAudio /, true / transcodeVideo */, SetMaxOperatingRate);
		}

		static void BM_TranscodeHevc2AvcV2VMaxOperatingRate(benchmark::State& state) {
		TranscodeMediaFile(state, "video_1920x1080_3863frame_hevc_4Mbps_30fps.mp4",
		"video_1920x1080_3863frame_hevc_4Mbps_30fps_transcoded_V.mp4",
		false /* includeAudio /, true / transcodeVideo */, SetMaxOperatingRate);
		}

		//-------------------------------- Passthrough Benchmarks ------------------------------------------

		static void BM_TranscodeAudioVideoPassthrough(benchmark::State& state) {
		TranscodeMediaFile(state, "video_1920x1080_3648frame_h264_22Mbps_30fps_aac.mp4",
		"video_1920x1080_3648frame_h264_22Mbps_30fps_aac_passthrough_AV.mp4",
		@@ -271,11 +286,22 @@ static void BM_TranscodeVideoPassthrough(benchmark::State& state) {
		false /* includeAudio /, false / transcodeVideo */);
		}

		//-------------------------------- Benchmark Registration ------------------------------------------

		// Benchmark registration wrapper for transcoding.
		#define TRANSCODER_BENCHMARK(func) \
		BENCHMARK(func)->UseRealTime()->MeasureProcessCPUTime()->Unit(benchmark::kMillisecond)

		TRANSCODER_BENCHMARK(BM_TranscodeAvc2AvcAudioVideo2AudioVideo);
		TRANSCODER_BENCHMARK(BM_TranscodeAvc2AvcAudioVideo2Video);
		TRANSCODER_BENCHMARK(BM_TranscodeAvc2AvcVideo2Video);
		TRANSCODER_BENCHMARK(BM_TranscodeAvc2AvcAV2AVMaxOperatingRate);
		TRANSCODER_BENCHMARK(BM_TranscodeAvc2AvcV2VMaxOperatingRate);

		TRANSCODER_BENCHMARK(BM_TranscodeHevc2AvcAudioVideo2AudioVideo);
		TRANSCODER_BENCHMARK(BM_TranscodeHevc2AvcVideo2Video);
		TRANSCODER_BENCHMARK(BM_TranscodeHevc2AvcAV2AVMaxOperatingRate);
		TRANSCODER_BENCHMARK(BM_TranscodeHevc2AvcV2VMaxOperatingRate);

		TRANSCODER_BENCHMARK(BM_TranscodeAudioVideoPassthrough);
		TRANSCODER_BENCHMARK(BM_TranscodeVideoPassthrough);