Snap for 7194171 from e51446c7a06e808a92bffee0830c5f3b0309d396 to sc-release (f23609d9) · Commits · e / os / android_frameworks_av

media/libaudioclient/fuzzer/audioflinger_fuzzer.cpp

+19 −24

Original line number	Diff line number	Diff line
		@@ -35,6 +35,10 @@
		#define MAX_STRING_LENGTH 256
		#define MAX_ARRAY_LENGTH 256

		constexpr int32_t kMinSampleRateHz = 4000;
		constexpr int32_t kMaxSampleRateHz = 192000;
		constexpr int32_t kSampleRateUnspecified = 0;

		using namespace std;
		using namespace android;

		@@ -129,30 +133,21 @@ static const std::vector<audio_output_flags_t> kOutputFlags =
		getFlags<audio_output_flags_t, xsd::AudioInOutFlag, decltype(audio_output_flag_from_string)>(
		xsdc_enum_range<xsd::AudioInOutFlag>{}, audio_output_flag_from_string, "_OUTPUT_");

		template <typename T, size_t size>
		T getValueFromArray(FuzzedDataProvider *fdp, const T (&arr)[size]) {
		return arr[fdp->ConsumeIntegralInRange<int32_t>(0, size - 1)];
		}

		template <typename T, size_t size>
		T getValue(FuzzedDataProvider *fdp, const T (&arr)[size]) {
		if (fdp->ConsumeBool()) {
		return static_cast<T>(fdp->ConsumeIntegral<int32_t>());
		}
		return getValueFromArray(fdp, arr);
		return arr[fdp->ConsumeIntegralInRange<int32_t>(0, size - 1)];
		}

		template <typename T>
		T getValueFromVector(FuzzedDataProvider *fdp, std::vector<T> vec) {
		T getValue(FuzzedDataProvider *fdp, std::vector<T> vec) {
		return vec[fdp->ConsumeIntegralInRange<int32_t>(0, vec.size() - 1)];
		}

		template <typename T>
		T getValue(FuzzedDataProvider *fdp, std::vector<T> vec) {
		int32_t getSampleRate(FuzzedDataProvider *fdp) {
		if (fdp->ConsumeBool()) {
		return static_cast<T>(fdp->ConsumeIntegral<int32_t>());
		return fdp->ConsumeIntegralInRange<int32_t>(kMinSampleRateHz, kMaxSampleRateHz);
		}
		return getValueFromVector(fdp, vec);
		return kSampleRateUnspecified;
		}

		class DeathNotifier : public IBinder::DeathRecipient {
		@@ -189,7 +184,7 @@ AudioFlingerFuzzer::AudioFlingerFuzzer(const uint8_t *data, size_t size) : mFdp(
		}

		void AudioFlingerFuzzer::invokeAudioTrack() {
		uint32_t sampleRate = mFdp.ConsumeIntegral<uint32_t>();
		uint32_t sampleRate = getSampleRate(&mFdp);
		audio_format_t format = getValue(&mFdp, kFormats);
		audio_channel_mask_t channelMask = getValue(&mFdp, kChannelMasks);
		size_t frameCount = static_cast<size_t>(mFdp.ConsumeIntegral<uint32_t>());
		@@ -259,7 +254,7 @@ void AudioFlingerFuzzer::invokeAudioTrack() {

		float auxEffectSendLevel;
		track->getAuxEffectSendLevel(&auxEffectSendLevel);
		track->setSampleRate(mFdp.ConsumeIntegral<uint32_t>());
		track->setSampleRate(getSampleRate(&mFdp));
		track->getSampleRate();
		track->getOriginalSampleRate();

		@@ -292,7 +287,7 @@ void AudioFlingerFuzzer::invokeAudioTrack() {

		void AudioFlingerFuzzer::invokeAudioRecord() {
		int32_t notificationFrames = mFdp.ConsumeIntegral<int32_t>();
		uint32_t sampleRate = mFdp.ConsumeIntegral<uint32_t>();
		uint32_t sampleRate = getSampleRate(&mFdp);
		size_t frameCount = static_cast<size_t>(mFdp.ConsumeIntegral<uint32_t>());
		audio_format_t format = getValue(&mFdp, kFormats);
		audio_channel_mask_t channelMask = getValue(&mFdp, kChannelMasks);
		@@ -518,7 +513,7 @@ void AudioFlingerFuzzer::invokeAudioSystem() {
		AudioSystem::getFrameCountHAL(mFdp.ConsumeIntegral<int32_t>(), &frameCount);

		size_t buffSize;
		uint32_t sampleRate = mFdp.ConsumeIntegral<uint32_t>();
		uint32_t sampleRate = getSampleRate(&mFdp);
		audio_format_t format = getValue(&mFdp, kFormats);
		audio_channel_mask_t channelMask = getValue(&mFdp, kChannelMasks);
		AudioSystem::getInputBufferSize(sampleRate, format, channelMask, &buffSize);
		@@ -572,12 +567,12 @@ status_t AudioFlingerFuzzer::invokeAudioInputDevice() {
		config.offload_info.format = getValue(&mFdp, kFormats);
		config.offload_info.has_video = mFdp.ConsumeBool();
		config.offload_info.is_streaming = mFdp.ConsumeBool();
		config.offload_info.sample_rate = (mFdp.ConsumeIntegral<uint32_t>());
		config.offload_info.sample_rate = getSampleRate(&mFdp);
		config.offload_info.sync_id = mFdp.ConsumeIntegral<uint32_t>();
		config.offload_info.stream_type = getValue(&mFdp, kStreamtypes);
		config.offload_info.usage = getValue(&mFdp, kUsages);

		config.sample_rate = mFdp.ConsumeIntegral<uint32_t>();
		config.sample_rate = getSampleRate(&mFdp);

		audio_devices_t device = getValue(&mFdp, kDevices);
		audio_source_t source = getValue(&mFdp, kInputSources);
		@@ -628,13 +623,13 @@ status_t AudioFlingerFuzzer::invokeAudioOutputDevice() {
		config.offload_info.format = getValue(&mFdp, kFormats);
		config.offload_info.has_video = mFdp.ConsumeBool();
		config.offload_info.is_streaming = mFdp.ConsumeBool();
		config.offload_info.sample_rate = mFdp.ConsumeIntegral<uint32_t>();
		config.offload_info.sample_rate = getSampleRate(&mFdp);
		config.offload_info.stream_type = getValue(&mFdp, kStreamtypes);
		config.offload_info.sync_id = mFdp.ConsumeIntegral<uint32_t>();
		config.offload_info.usage = getValue(&mFdp, kUsages);

		config.format = getValue(&mFdp, kFormats);
		config.sample_rate = mFdp.ConsumeIntegral<uint32_t>();
		config.sample_rate = getSampleRate(&mFdp);

		sp<DeviceDescriptorBase> device = new DeviceDescriptorBase(getValue(&mFdp, kDevices));
		audio_output_flags_t flags = getValue(&mFdp, kOutputFlags);
		@@ -683,7 +678,7 @@ void AudioFlingerFuzzer::invokeAudioPatch() {
		patch.sources[i].gain.ramp_duration_ms = mFdp.ConsumeIntegral<uint32_t>();
		patch.sources[i].id = static_cast<audio_format_t>(mFdp.ConsumeIntegral<int32_t>());
		patch.sources[i].role = getValue(&mFdp, kPortRoles);
		patch.sources[i].sample_rate = mFdp.ConsumeIntegral<uint32_t>();
		patch.sources[i].sample_rate = getSampleRate(&mFdp);
		patch.sources[i].type = getValue(&mFdp, kPortTypes);

		patch.sinks[i].config_mask = mFdp.ConsumeIntegral<uint32_t>();
		@@ -695,7 +690,7 @@ void AudioFlingerFuzzer::invokeAudioPatch() {
		patch.sinks[i].gain.ramp_duration_ms = mFdp.ConsumeIntegral<uint32_t>();
		patch.sinks[i].id = static_cast<audio_format_t>(mFdp.ConsumeIntegral<int32_t>());
		patch.sinks[i].role = getValue(&mFdp, kPortRoles);
		patch.sinks[i].sample_rate = mFdp.ConsumeIntegral<uint32_t>();
		patch.sinks[i].sample_rate = getSampleRate(&mFdp);
		patch.sinks[i].type = getValue(&mFdp, kPortTypes);
		}

media/libeffects/lvm/tests/Android.bp

+1 −1

Original line number	Diff line number	Diff line
		@@ -13,7 +13,7 @@ cc_test {
		name: "EffectReverbTest",
		vendor: true,
		gtest: true,
		host_supported: false,
		host_supported: true,
		srcs: [
		"EffectReverbTest.cpp",
		"EffectTestHelper.cpp",

media/libmediatranscoding/Android.bp

+43 −0

Original line number	Diff line number	Diff line
		@@ -82,6 +82,7 @@ cc_library {
		srcs: [
		"TranscoderWrapper.cpp",
		"TranscodingClientManager.cpp",
		"TranscodingLogger.cpp",
		"TranscodingResourcePolicy.cpp",
		"TranscodingSessionController.cpp",
		"TranscodingThermalPolicy.cpp",
		@@ -96,6 +97,7 @@ cc_library {
		"libutils",
		"libmediatranscoder",
		"libmediandk",
		"libstatssocket#30",
		],
		export_shared_lib_headers: [
		"libmediandk",
		@@ -106,6 +108,7 @@ cc_library {
		static_libs: [
		"mediatranscoding_aidl_interface-ndk_platform",
		"resourceobserver_aidl_interface-V1-ndk_platform",
		"libstatslog_media",
		],

		cflags: [
		@@ -126,3 +129,43 @@ cc_library {
		cfi: true,
		},
		}

		cc_library_static {
		name: "libstatslog_media",
		generated_sources: ["statslog_media.cpp"],
		generated_headers: ["statslog_media.h"],
		min_sdk_version: "29",
		cflags: [
		"-Wall",
		"-Werror",
		],
		export_generated_headers: ["statslog_media.h"],
		apex_available: [
		"com.android.media",
		"test_com.android.media",
		],
		shared_libs: [
		"libcutils",
		"liblog",
		"libstatssocket#30",
		"libutils",
		],
		}

		genrule {
		name: "statslog_media.h",
		tools: ["stats-log-api-gen"],
		cmd: "$(location stats-log-api-gen) --header $(genDir)/statslog_media.h --module media --namespace android,media,stats",
		out: [
		"statslog_media.h",
		],
		}

		genrule {
		name: "statslog_media.cpp",
		tools: ["stats-log-api-gen"],
		cmd: "$(location stats-log-api-gen) --cpp $(genDir)/statslog_media.cpp --module media --namespace android,media,stats --importHeader statslog_media.h",
		out: [
		"statslog_media.cpp",
		],
		}
		No newline at end of file

media/libmediatranscoding/TranscoderWrapper.cpp

+65 −22

Original line number	Diff line number	Diff line
		@@ -56,34 +56,34 @@ static TranscodingErrorCode toTranscodingError(media_status_t status) {
		}
		}

		static AMediaFormat* getVideoFormat(
		static std::shared_ptr<AMediaFormat> getVideoFormat(
		const char* originalMime,
		const std::optional<TranscodingVideoTrackFormat>& requestedFormat) {
		if (requestedFormat == std::nullopt) {
		return nullptr;
		}

		AMediaFormat* format = AMediaFormat_new();
		std::shared_ptr<AMediaFormat> format =
		std::shared_ptr<AMediaFormat>(AMediaFormat_new(), &AMediaFormat_delete);
		bool changed = false;
		if (requestedFormat->codecType == TranscodingVideoCodecType::kHevc &&
		strcmp(originalMime, AMEDIA_MIMETYPE_VIDEO_HEVC)) {
		AMediaFormat_setString(format, AMEDIAFORMAT_KEY_MIME, AMEDIA_MIMETYPE_VIDEO_HEVC);
		AMediaFormat_setString(format.get(), AMEDIAFORMAT_KEY_MIME, AMEDIA_MIMETYPE_VIDEO_HEVC);
		changed = true;
		} else if (requestedFormat->codecType == TranscodingVideoCodecType::kAvc &&
		strcmp(originalMime, AMEDIA_MIMETYPE_VIDEO_AVC)) {
		AMediaFormat_setString(format, AMEDIAFORMAT_KEY_MIME, AMEDIA_MIMETYPE_VIDEO_AVC);
		AMediaFormat_setString(format.get(), AMEDIAFORMAT_KEY_MIME, AMEDIA_MIMETYPE_VIDEO_AVC);
		changed = true;
		}
		if (requestedFormat->bitrateBps > 0) {
		AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_BIT_RATE, requestedFormat->bitrateBps);
		AMediaFormat_setInt32(format.get(), AMEDIAFORMAT_KEY_BIT_RATE, requestedFormat->bitrateBps);
		changed = true;
		}
		// TODO: translate other fields from requestedFormat to the format for MediaTranscoder.
		// Also need to determine more settings to expose in TranscodingVideoTrackFormat.
		if (!changed) {
		AMediaFormat_delete(format);
		// Use null format for passthru.
		format = nullptr;
		format.reset();
		}
		return format;
		}
		@@ -180,8 +180,10 @@ private:
		};

		TranscoderWrapper::TranscoderWrapper(const std::shared_ptr<TranscoderCallbackInterface>& cb,
		const std::shared_ptr<TranscodingLogger>& logger,
		int64_t heartBeatIntervalUs)
		: mCallback(cb),
		mLogger(logger),
		mHeartBeatIntervalUs(heartBeatIntervalUs),
		mCurrentClientId(0),
		mCurrentSessionId(-1),
		@@ -219,10 +221,10 @@ void TranscoderWrapper::reportError(ClientIdType clientId, SessionIdType session
		}

		void TranscoderWrapper::start(ClientIdType clientId, SessionIdType sessionId,
		const TranscodingRequestParcel& request,
		const TranscodingRequestParcel& request, uid_t callingUid,
		const std::shared_ptr<ITranscodingClientCallback>& clientCb) {
		queueEvent(Event::Start, clientId, sessionId, [=, &request] {
		media_status_t err = handleStart(clientId, sessionId, request, clientCb);
		media_status_t err = handleStart(clientId, sessionId, request, callingUid, clientCb);
		if (err != AMEDIA_OK) {
		cleanup();
		reportError(clientId, sessionId, err);
		@@ -253,10 +255,10 @@ void TranscoderWrapper::pause(ClientIdType clientId, SessionIdType sessionId) {
		}

		void TranscoderWrapper::resume(ClientIdType clientId, SessionIdType sessionId,
		const TranscodingRequestParcel& request,
		const TranscodingRequestParcel& request, uid_t callingUid,
		const std::shared_ptr<ITranscodingClientCallback>& clientCb) {
		queueEvent(Event::Resume, clientId, sessionId, [=, &request] {
		media_status_t err = handleResume(clientId, sessionId, request, clientCb);
		media_status_t err = handleResume(clientId, sessionId, request, callingUid, clientCb);
		if (err != AMEDIA_OK) {
		cleanup();
		reportError(clientId, sessionId, err);
		@@ -280,6 +282,7 @@ void TranscoderWrapper::stop(ClientIdType clientId, SessionIdType sessionId, boo
		} else {
		ALOGI("transcoder stopped");
		}
		logSessionEnded(TranscodingLogger::SessionEndedReason::CANCELLED, err);
		cleanup();
		} else {
		// For sessions that's not currently running, release any pausedState for the session.
		@@ -297,6 +300,7 @@ void TranscoderWrapper::onFinish(ClientIdType clientId, SessionIdType sessionId)
		queueEvent(Event::Finish, clientId, sessionId, [=] {
		if (mTranscoder != nullptr && clientId == mCurrentClientId &&
		sessionId == mCurrentSessionId) {
		logSessionEnded(TranscodingLogger::SessionEndedReason::FINISHED, AMEDIA_OK);
		cleanup();
		}

		@@ -314,6 +318,7 @@ void TranscoderWrapper::onError(ClientIdType clientId, SessionIdType sessionId,
		[=] {
		if (mTranscoder != nullptr && clientId == mCurrentClientId &&
		sessionId == mCurrentSessionId) {
		logSessionEnded(TranscodingLogger::SessionEndedReason::ERROR, error);
		cleanup();
		}
		reportError(clientId, sessionId, error);
		@@ -345,7 +350,8 @@ void TranscoderWrapper::onHeartBeat(ClientIdType clientId, SessionIdType session

		media_status_t TranscoderWrapper::setupTranscoder(
		ClientIdType clientId, SessionIdType sessionId, const TranscodingRequestParcel& request,
		const std::shared_ptr<ITranscodingClientCallback>& clientCb,
		uid_t callingUid, const std::shared_ptr<ITranscodingClientCallback>& clientCb,
		TranscodingLogger::SessionEndedReason* failureReason,
		const std::shared_ptr<ndk::ScopedAParcel>& pausedState) {
		if (clientCb == nullptr) {
		ALOGE("client callback is null");
		@@ -364,6 +370,7 @@ media_status_t TranscoderWrapper::setupTranscoder(
		status = clientCb->openFileDescriptor(request.sourceFilePath, "r", &srcFd);
		if (!status.isOk() \|\| srcFd.get() < 0) {
		ALOGE("failed to open source");
		*failureReason = TranscodingLogger::SessionEndedReason::OPEN_SRC_FD_FAILED;
		return AMEDIA_ERROR_IO;
		}
		srcFdInt = srcFd.get();
		@@ -377,6 +384,7 @@ media_status_t TranscoderWrapper::setupTranscoder(
		status = clientCb->openFileDescriptor(request.destinationFilePath, "rw", &dstFd);
		if (!status.isOk() \|\| dstFd.get() < 0) {
		ALOGE("failed to open destination");
		*failureReason = TranscodingLogger::SessionEndedReason::OPEN_DST_FD_FAILED;
		return AMEDIA_ERROR_IO;
		}
		dstFdInt = dstFd.get();
		@@ -384,41 +392,46 @@ media_status_t TranscoderWrapper::setupTranscoder(

		mCurrentClientId = clientId;
		mCurrentSessionId = sessionId;
		mCurrentCallingUid = callingUid;
		mTranscoderCb = std::make_shared<CallbackImpl>(shared_from_this(), clientId, sessionId);
		mTranscoder = MediaTranscoder::create(mTranscoderCb, mHeartBeatIntervalUs, request.clientPid,
		request.clientUid, pausedState);
		if (mTranscoder == nullptr) {
		ALOGE("failed to create transcoder");
		*failureReason = TranscodingLogger::SessionEndedReason::CREATE_FAILED;
		return AMEDIA_ERROR_UNKNOWN;
		}

		media_status_t err = mTranscoder->configureSource(srcFdInt);
		if (err != AMEDIA_OK) {
		ALOGE("failed to configure source: %d", err);
		*failureReason = TranscodingLogger::SessionEndedReason::CONFIG_SRC_FAILED;
		return err;
		}

		std::vector<std::shared_ptr<AMediaFormat>> trackFormats = mTranscoder->getTrackFormats();
		if (trackFormats.size() == 0) {
		ALOGE("failed to get track formats!");
		*failureReason = TranscodingLogger::SessionEndedReason::NO_TRACKS;
		return AMEDIA_ERROR_MALFORMED;
		}

		for (int i = 0; i < trackFormats.size(); ++i) {
		AMediaFormat* format = nullptr;
		std::shared_ptr<AMediaFormat> format;
		const char* mime = nullptr;
		AMediaFormat_getString(trackFormats[i].get(), AMEDIAFORMAT_KEY_MIME, &mime);

		if (!strncmp(mime, "video/", 6)) {
		format = getVideoFormat(mime, request.requestedVideoTrackFormat);
		}

		err = mTranscoder->configureTrackFormat(i, format);
		if (format != nullptr) {
		AMediaFormat_delete(format);
		mSrcFormat = trackFormats[i];
		mDstFormat = format;
		}

		err = mTranscoder->configureTrackFormat(i, format.get());
		if (err != AMEDIA_OK) {
		ALOGE("failed to configure track format for track %d: %d", i, err);
		*failureReason = TranscodingLogger::SessionEndedReason::CONFIG_TRACK_FAILED;
		return err;
		}
		}
		@@ -426,6 +439,7 @@ media_status_t TranscoderWrapper::setupTranscoder(
		err = mTranscoder->configureDestination(dstFdInt);
		if (err != AMEDIA_OK) {
		ALOGE("failed to configure dest: %d", err);
		*failureReason = TranscodingLogger::SessionEndedReason::CONFIG_DST_FAILED;
		return err;
		}

		@@ -434,17 +448,23 @@ media_status_t TranscoderWrapper::setupTranscoder(

		media_status_t TranscoderWrapper::handleStart(
		ClientIdType clientId, SessionIdType sessionId, const TranscodingRequestParcel& request,
		const std::shared_ptr<ITranscodingClientCallback>& clientCb) {
		uid_t callingUid, const std::shared_ptr<ITranscodingClientCallback>& clientCb) {
		ALOGI("%s: setting up transcoder for start", __FUNCTION__);
		media_status_t err = setupTranscoder(clientId, sessionId, request, clientCb);
		TranscodingLogger::SessionEndedReason reason = TranscodingLogger::SessionEndedReason::UNKNOWN;
		media_status_t err =
		setupTranscoder(clientId, sessionId, request, callingUid, clientCb, &reason);
		if (err != AMEDIA_OK) {
		ALOGI("%s: failed to setup transcoder", __FUNCTION__);
		logSessionEnded(reason, err);
		return err;
		}

		mTranscodeStartTime = std::chrono::steady_clock::now();

		err = mTranscoder->start();
		if (err != AMEDIA_OK) {
		ALOGE("%s: failed to start transcoder: %d", __FUNCTION__, err);
		logSessionEnded(TranscodingLogger::SessionEndedReason::START_FAILED, err);
		return err;
		}

		@@ -467,6 +487,7 @@ media_status_t TranscoderWrapper::handlePause(ClientIdType clientId, SessionIdTy

		std::shared_ptr<ndk::ScopedAParcel> pauseStates;
		media_status_t err = mTranscoder->pause(&pauseStates);
		logSessionEnded(TranscodingLogger::SessionEndedReason::PAUSED, err);
		if (err != AMEDIA_OK) {
		ALOGE("%s: failed to pause transcoder: %d", __FUNCTION__, err);
		return err;
		@@ -479,7 +500,7 @@ media_status_t TranscoderWrapper::handlePause(ClientIdType clientId, SessionIdTy

		media_status_t TranscoderWrapper::handleResume(
		ClientIdType clientId, SessionIdType sessionId, const TranscodingRequestParcel& request,
		const std::shared_ptr<ITranscodingClientCallback>& clientCb) {
		uid_t callingUid, const std::shared_ptr<ITranscodingClientCallback>& clientCb) {
		std::shared_ptr<ndk::ScopedAParcel> pausedState;
		auto it = mPausedStateMap.find(SessionKeyType(clientId, sessionId));
		if (it != mPausedStateMap.end()) {
		@@ -491,15 +512,23 @@ media_status_t TranscoderWrapper::handleResume(
		}

		ALOGI("%s: setting up transcoder for resume", __FUNCTION__);
		media_status_t err = setupTranscoder(clientId, sessionId, request, clientCb, pausedState);
		TranscodingLogger::SessionEndedReason reason = TranscodingLogger::SessionEndedReason::UNKNOWN;
		media_status_t err = setupTranscoder(clientId, sessionId, request, callingUid, clientCb,
		&reason, pausedState);
		if (err != AMEDIA_OK) {
		ALOGE("%s: failed to setup transcoder: %d", __FUNCTION__, err);
		logSessionEnded(reason, err);
		return err;
		}

		// Note: For now resume() will just restart transcoding from the beginning, so there is no need
		// to distinguish between resume and start from a performance perspective.
		mTranscodeStartTime = std::chrono::steady_clock::now();

		err = mTranscoder->resume();
		if (err != AMEDIA_OK) {
		ALOGE("%s: failed to resume transcoder: %d", __FUNCTION__, err);
		logSessionEnded(TranscodingLogger::SessionEndedReason::RESUME_FAILED, err);
		return err;
		}

		@@ -510,8 +539,23 @@ media_status_t TranscoderWrapper::handleResume(
		void TranscoderWrapper::cleanup() {
		mCurrentClientId = 0;
		mCurrentSessionId = -1;
		mCurrentCallingUid = -1;
		mTranscoderCb = nullptr;
		mTranscoder = nullptr;
		mSrcFormat = nullptr;
		mDstFormat = nullptr;
		}

		void TranscoderWrapper::logSessionEnded(const TranscodingLogger::SessionEndedReason& reason,
		int error) {
		std::chrono::microseconds transcodeDuration(-1);
		if (reason == TranscodingLogger::SessionEndedReason::FINISHED && error == AMEDIA_OK) {
		transcodeDuration = std::chrono::duration_cast<std::chrono::microseconds>(
		std::chrono::steady_clock::now() - mTranscodeStartTime);
		}

		mLogger->logSessionEnded(reason, mCurrentCallingUid, error, transcodeDuration, mSrcFormat.get(),
		mDstFormat.get());
		}

		void TranscoderWrapper::queueEvent(Event::Type type, ClientIdType clientId, SessionIdType sessionId,
		@@ -555,5 +599,4 @@ void TranscoderWrapper::threadLoop() {
		lock.lock();
		}
		}

		} // namespace android

media/libmediatranscoding/TranscodingClientManager.cpp

+2 −2

Original line number	Diff line number	Diff line
		@@ -162,8 +162,8 @@ Status TranscodingClientManager::ClientImpl::submitRequest(

		int32_t sessionId = mNextSessionId.fetch_add(1);

		*_aidl_return = owner->mSessionController->submit(mClientId, sessionId, in_clientUid,
		in_request, mClientCallback);
		*_aidl_return = owner->mSessionController->submit(mClientId, sessionId, callingUid,
		in_clientUid, in_request, mClientCallback);

		if (*_aidl_return) {
		out_session->sessionId = sessionId;