Merge "transcoding: renaming to session controller to avoid confusion" (5c75d0b7) · Commits · e / os / android_frameworks_av

media/libmediatranscoding/Android.bp

+4 −4

Original line number	Original line	Diff line number	Diff line
	@@ -21,12 +21,12 @@ filegroup {
	"aidl/android/media/ITranscodingClient.aidl",		"aidl/android/media/ITranscodingClient.aidl",
	"aidl/android/media/ITranscodingClientCallback.aidl",		"aidl/android/media/ITranscodingClientCallback.aidl",
	"aidl/android/media/TranscodingErrorCode.aidl",		"aidl/android/media/TranscodingErrorCode.aidl",
	"aidl/android/media/TranscodingJobPriority.aidl",		"aidl/android/media/TranscodingSessionPriority.aidl",
	"aidl/android/media/TranscodingJobStats.aidl",		"aidl/android/media/TranscodingSessionStats.aidl",
	"aidl/android/media/TranscodingType.aidl",		"aidl/android/media/TranscodingType.aidl",
	"aidl/android/media/TranscodingVideoCodecType.aidl",		"aidl/android/media/TranscodingVideoCodecType.aidl",
	"aidl/android/media/TranscodingVideoTrackFormat.aidl",		"aidl/android/media/TranscodingVideoTrackFormat.aidl",
	"aidl/android/media/TranscodingJobParcel.aidl",		"aidl/android/media/TranscodingSessionParcel.aidl",
	"aidl/android/media/TranscodingRequestParcel.aidl",		"aidl/android/media/TranscodingRequestParcel.aidl",
	"aidl/android/media/TranscodingResultParcel.aidl",		"aidl/android/media/TranscodingResultParcel.aidl",
	"aidl/android/media/TranscodingTestConfig.aidl",		"aidl/android/media/TranscodingTestConfig.aidl",
	@@ -53,7 +53,7 @@ cc_library_shared {

	srcs: [		srcs: [
	"TranscodingClientManager.cpp",		"TranscodingClientManager.cpp",
	"TranscodingJobScheduler.cpp",		"TranscodingSessionController.cpp",
	"TranscodingResourcePolicy.cpp",		"TranscodingResourcePolicy.cpp",
	"TranscodingUidPolicy.cpp",		"TranscodingUidPolicy.cpp",
	"TranscoderWrapper.cpp",		"TranscoderWrapper.cpp",

media/libmediatranscoding/TranscoderWrapper.cpp

+66 −61

Original line number	Original line	Diff line number	Diff line
	@@ -117,7 +117,7 @@ std::string TranscoderWrapper::toString(const Event& event) {
	return "(unknown)";		return "(unknown)";
	}		}
	std::string result;		std::string result;
	result = "job {" + std::to_string(event.clientId) + "," + std::to_string(event.jobId) +		result = "session {" + std::to_string(event.clientId) + "," + std::to_string(event.sessionId) +
	"}: " + typeStr;		"}: " + typeStr;
	if (event.type == Event::Error \|\| event.type == Event::Progress) {		if (event.type == Event::Error \|\| event.type == Event::Progress) {
	result += " " + std::to_string(event.arg);		result += " " + std::to_string(event.arg);
	@@ -128,13 +128,13 @@ std::string TranscoderWrapper::toString(const Event& event) {
	class TranscoderWrapper::CallbackImpl : public MediaTranscoder::CallbackInterface {		class TranscoderWrapper::CallbackImpl : public MediaTranscoder::CallbackInterface {
	public:		public:
	CallbackImpl(const std::shared_ptr<TranscoderWrapper>& owner, ClientIdType clientId,		CallbackImpl(const std::shared_ptr<TranscoderWrapper>& owner, ClientIdType clientId,
	JobIdType jobId)		SessionIdType sessionId)
	: mOwner(owner), mClientId(clientId), mJobId(jobId) {}		: mOwner(owner), mClientId(clientId), mSessionId(sessionId) {}

	virtual void onFinished(const MediaTranscoder* transcoder __unused) override {		virtual void onFinished(const MediaTranscoder* transcoder __unused) override {
	auto owner = mOwner.lock();		auto owner = mOwner.lock();
	if (owner != nullptr) {		if (owner != nullptr) {
	owner->onFinish(mClientId, mJobId);		owner->onFinish(mClientId, mSessionId);
	}		}
	}		}

	@@ -142,7 +142,7 @@ public:
	media_status_t error) override {		media_status_t error) override {
	auto owner = mOwner.lock();		auto owner = mOwner.lock();
	if (owner != nullptr) {		if (owner != nullptr) {
	owner->onError(mClientId, mJobId, error);		owner->onError(mClientId, mSessionId, error);
	}		}
	}		}

	@@ -150,23 +150,23 @@ public:
	int32_t progress) override {		int32_t progress) override {
	auto owner = mOwner.lock();		auto owner = mOwner.lock();
	if (owner != nullptr) {		if (owner != nullptr) {
	owner->onProgress(mClientId, mJobId, progress);		owner->onProgress(mClientId, mSessionId, progress);
	}		}
	}		}

	virtual void onCodecResourceLost(const MediaTranscoder* transcoder __unused,		virtual void onCodecResourceLost(const MediaTranscoder* transcoder __unused,
	const std::shared_ptr<const Parcel>& pausedState		const std::shared_ptr<const Parcel>& pausedState
	__unused) override {		__unused) override {
	ALOGV("%s: job {%lld, %d}", __FUNCTION__, (long long)mClientId, mJobId);		ALOGV("%s: session {%lld, %d}", __FUNCTION__, (long long)mClientId, mSessionId);
	}		}

	private:		private:
	std::weak_ptr<TranscoderWrapper> mOwner;		std::weak_ptr<TranscoderWrapper> mOwner;
	ClientIdType mClientId;		ClientIdType mClientId;
	JobIdType mJobId;		SessionIdType mSessionId;
	};		};

	TranscoderWrapper::TranscoderWrapper() : mCurrentClientId(0), mCurrentJobId(-1) {		TranscoderWrapper::TranscoderWrapper() : mCurrentClientId(0), mCurrentSessionId(-1) {
	std::thread(&TranscoderWrapper::threadLoop, this).detach();		std::thread(&TranscoderWrapper::threadLoop, this).detach();
	}		}

	@@ -178,83 +178,85 @@ static bool isResourceError(media_status_t err) {
	return err == AMEDIACODEC_ERROR_RECLAIMED \|\| err == AMEDIACODEC_ERROR_INSUFFICIENT_RESOURCE;		return err == AMEDIACODEC_ERROR_RECLAIMED \|\| err == AMEDIACODEC_ERROR_INSUFFICIENT_RESOURCE;
	}		}

	void TranscoderWrapper::reportError(ClientIdType clientId, JobIdType jobId, media_status_t err) {		void TranscoderWrapper::reportError(ClientIdType clientId, SessionIdType sessionId,
			media_status_t err) {
	auto callback = mCallback.lock();		auto callback = mCallback.lock();
	if (callback != nullptr) {		if (callback != nullptr) {
	if (isResourceError(err)) {		if (isResourceError(err)) {
	// Add a placeholder pause state to mPausedStateMap. This is required when resuming.		// Add a placeholder pause state to mPausedStateMap. This is required when resuming.
	// TODO: remove this when transcoder pause/resume logic is ready. New logic will		// TODO: remove this when transcoder pause/resume logic is ready. New logic will
	// no longer use the pause states.		// no longer use the pause states.
	auto it = mPausedStateMap.find(JobKeyType(clientId, jobId));		auto it = mPausedStateMap.find(SessionKeyType(clientId, sessionId));
	if (it == mPausedStateMap.end()) {		if (it == mPausedStateMap.end()) {
	mPausedStateMap.emplace(JobKeyType(clientId, jobId),		mPausedStateMap.emplace(SessionKeyType(clientId, sessionId),
	std::shared_ptr<const Parcel>());		std::shared_ptr<const Parcel>());
	}		}

	callback->onResourceLost();		callback->onResourceLost();
	} else {		} else {
	callback->onError(clientId, jobId, toTranscodingError(err));		callback->onError(clientId, sessionId, toTranscodingError(err));
	}		}
	}		}
	}		}

	void TranscoderWrapper::start(ClientIdType clientId, JobIdType jobId,		void TranscoderWrapper::start(ClientIdType clientId, SessionIdType sessionId,
	const TranscodingRequestParcel& request,		const TranscodingRequestParcel& request,
	const std::shared_ptr<ITranscodingClientCallback>& clientCb) {		const std::shared_ptr<ITranscodingClientCallback>& clientCb) {
	queueEvent(Event::Start, clientId, jobId, [=] {		queueEvent(Event::Start, clientId, sessionId, [=] {
	media_status_t err = handleStart(clientId, jobId, request, clientCb);		media_status_t err = handleStart(clientId, sessionId, request, clientCb);

	if (err != AMEDIA_OK) {		if (err != AMEDIA_OK) {
	cleanup();		cleanup();
	reportError(clientId, jobId, err);		reportError(clientId, sessionId, err);
	} else {		} else {
	auto callback = mCallback.lock();		auto callback = mCallback.lock();
	if (callback != nullptr) {		if (callback != nullptr) {
	callback->onStarted(clientId, jobId);		callback->onStarted(clientId, sessionId);
	}		}
	}		}
	});		});
	}		}

	void TranscoderWrapper::pause(ClientIdType clientId, JobIdType jobId) {		void TranscoderWrapper::pause(ClientIdType clientId, SessionIdType sessionId) {
	queueEvent(Event::Pause, clientId, jobId, [=] {		queueEvent(Event::Pause, clientId, sessionId, [=] {
	media_status_t err = handlePause(clientId, jobId);		media_status_t err = handlePause(clientId, sessionId);

	cleanup();		cleanup();

	if (err != AMEDIA_OK) {		if (err != AMEDIA_OK) {
	reportError(clientId, jobId, err);		reportError(clientId, sessionId, err);
	} else {		} else {
	auto callback = mCallback.lock();		auto callback = mCallback.lock();
	if (callback != nullptr) {		if (callback != nullptr) {
	callback->onPaused(clientId, jobId);		callback->onPaused(clientId, sessionId);
	}		}
	}		}
	});		});
	}		}

	void TranscoderWrapper::resume(ClientIdType clientId, JobIdType jobId,		void TranscoderWrapper::resume(ClientIdType clientId, SessionIdType sessionId,
	const TranscodingRequestParcel& request,		const TranscodingRequestParcel& request,
	const std::shared_ptr<ITranscodingClientCallback>& clientCb) {		const std::shared_ptr<ITranscodingClientCallback>& clientCb) {
	queueEvent(Event::Resume, clientId, jobId, [=] {		queueEvent(Event::Resume, clientId, sessionId, [=] {
	media_status_t err = handleResume(clientId, jobId, request, clientCb);		media_status_t err = handleResume(clientId, sessionId, request, clientCb);

	if (err != AMEDIA_OK) {		if (err != AMEDIA_OK) {
	cleanup();		cleanup();
	reportError(clientId, jobId, err);		reportError(clientId, sessionId, err);
	} else {		} else {
	auto callback = mCallback.lock();		auto callback = mCallback.lock();
	if (callback != nullptr) {		if (callback != nullptr) {
	callback->onResumed(clientId, jobId);		callback->onResumed(clientId, sessionId);
	}		}
	}		}
	});		});
	}		}

	void TranscoderWrapper::stop(ClientIdType clientId, JobIdType jobId) {		void TranscoderWrapper::stop(ClientIdType clientId, SessionIdType sessionId) {
	queueEvent(Event::Stop, clientId, jobId, [=] {		queueEvent(Event::Stop, clientId, sessionId, [=] {
	if (mTranscoder != nullptr && clientId == mCurrentClientId && jobId == mCurrentJobId) {		if (mTranscoder != nullptr && clientId == mCurrentClientId &&
	// Cancelling the currently running job.		sessionId == mCurrentSessionId) {
			// Cancelling the currently running session.
	media_status_t err = mTranscoder->cancel();		media_status_t err = mTranscoder->cancel();
	if (err != AMEDIA_OK) {		if (err != AMEDIA_OK) {
	ALOGW("failed to stop transcoder: %d", err);		ALOGW("failed to stop transcoder: %d", err);
	@@ -263,53 +265,56 @@ void TranscoderWrapper::stop(ClientIdType clientId, JobIdType jobId) {
	}		}
	cleanup();		cleanup();
	} else {		} else {
	// For jobs that's not currently running, release any pausedState for the job.		// For sessions that's not currently running, release any pausedState for the session.
	mPausedStateMap.erase(JobKeyType(clientId, jobId));		mPausedStateMap.erase(SessionKeyType(clientId, sessionId));
	}		}
	// No callback needed for stop.		// No callback needed for stop.
	});		});
	}		}

	void TranscoderWrapper::onFinish(ClientIdType clientId, JobIdType jobId) {		void TranscoderWrapper::onFinish(ClientIdType clientId, SessionIdType sessionId) {
	queueEvent(Event::Finish, clientId, jobId, [=] {		queueEvent(Event::Finish, clientId, sessionId, [=] {
	if (mTranscoder != nullptr && clientId == mCurrentClientId && jobId == mCurrentJobId) {		if (mTranscoder != nullptr && clientId == mCurrentClientId &&
			sessionId == mCurrentSessionId) {
	cleanup();		cleanup();
	}		}

	auto callback = mCallback.lock();		auto callback = mCallback.lock();
	if (callback != nullptr) {		if (callback != nullptr) {
	callback->onFinish(clientId, jobId);		callback->onFinish(clientId, sessionId);
	}		}
	});		});
	}		}

	void TranscoderWrapper::onError(ClientIdType clientId, JobIdType jobId, media_status_t error) {		void TranscoderWrapper::onError(ClientIdType clientId, SessionIdType sessionId,
			media_status_t error) {
	queueEvent(		queueEvent(
	Event::Error, clientId, jobId,		Event::Error, clientId, sessionId,
	[=] {		[=] {
	if (mTranscoder != nullptr && clientId == mCurrentClientId &&		if (mTranscoder != nullptr && clientId == mCurrentClientId &&
	jobId == mCurrentJobId) {		sessionId == mCurrentSessionId) {
	cleanup();		cleanup();
	}		}
	reportError(clientId, jobId, error);		reportError(clientId, sessionId, error);
	},		},
	error);		error);
	}		}

	void TranscoderWrapper::onProgress(ClientIdType clientId, JobIdType jobId, int32_t progress) {		void TranscoderWrapper::onProgress(ClientIdType clientId, SessionIdType sessionId,
			int32_t progress) {
	queueEvent(		queueEvent(
	Event::Progress, clientId, jobId,		Event::Progress, clientId, sessionId,
	[=] {		[=] {
	auto callback = mCallback.lock();		auto callback = mCallback.lock();
	if (callback != nullptr) {		if (callback != nullptr) {
	callback->onProgressUpdate(clientId, jobId, progress);		callback->onProgressUpdate(clientId, sessionId, progress);
	}		}
	},		},
	progress);		progress);
	}		}

	media_status_t TranscoderWrapper::setupTranscoder(		media_status_t TranscoderWrapper::setupTranscoder(
	ClientIdType clientId, JobIdType jobId, const TranscodingRequestParcel& request,		ClientIdType clientId, SessionIdType sessionId, const TranscodingRequestParcel& request,
	const std::shared_ptr<ITranscodingClientCallback>& clientCb,		const std::shared_ptr<ITranscodingClientCallback>& clientCb,
	const std::shared_ptr<const Parcel>& pausedState) {		const std::shared_ptr<const Parcel>& pausedState) {
	if (clientCb == nullptr) {		if (clientCb == nullptr) {
	@@ -340,8 +345,8 @@ media_status_t TranscoderWrapper::setupTranscoder(
	}		}

	mCurrentClientId = clientId;		mCurrentClientId = clientId;
	mCurrentJobId = jobId;		mCurrentSessionId = sessionId;
	mTranscoderCb = std::make_shared<CallbackImpl>(shared_from_this(), clientId, jobId);		mTranscoderCb = std::make_shared<CallbackImpl>(shared_from_this(), clientId, sessionId);
	mTranscoder = MediaTranscoder::create(mTranscoderCb, pausedState);		mTranscoder = MediaTranscoder::create(mTranscoderCb, pausedState);
	if (mTranscoder == nullptr) {		if (mTranscoder == nullptr) {
	ALOGE("failed to create transcoder");		ALOGE("failed to create transcoder");
	@@ -389,10 +394,10 @@ media_status_t TranscoderWrapper::setupTranscoder(
	}		}

	media_status_t TranscoderWrapper::handleStart(		media_status_t TranscoderWrapper::handleStart(
	ClientIdType clientId, JobIdType jobId, const TranscodingRequestParcel& request,		ClientIdType clientId, SessionIdType sessionId, const TranscodingRequestParcel& request,
	const std::shared_ptr<ITranscodingClientCallback>& clientCb) {		const std::shared_ptr<ITranscodingClientCallback>& clientCb) {
	ALOGI("%s: setting up transcoder for start", __FUNCTION__);		ALOGI("%s: setting up transcoder for start", __FUNCTION__);
	media_status_t err = setupTranscoder(clientId, jobId, request, clientCb);		media_status_t err = setupTranscoder(clientId, sessionId, request, clientCb);
	if (err != AMEDIA_OK) {		if (err != AMEDIA_OK) {
	ALOGI("%s: failed to setup transcoder", __FUNCTION__);		ALOGI("%s: failed to setup transcoder", __FUNCTION__);
	return err;		return err;
	@@ -408,15 +413,15 @@ media_status_t TranscoderWrapper::handleStart(
	return AMEDIA_OK;		return AMEDIA_OK;
	}		}

	media_status_t TranscoderWrapper::handlePause(ClientIdType clientId, JobIdType jobId) {		media_status_t TranscoderWrapper::handlePause(ClientIdType clientId, SessionIdType sessionId) {
	if (mTranscoder == nullptr) {		if (mTranscoder == nullptr) {
	ALOGE("%s: transcoder is not running", __FUNCTION__);		ALOGE("%s: transcoder is not running", __FUNCTION__);
	return AMEDIA_ERROR_INVALID_OPERATION;		return AMEDIA_ERROR_INVALID_OPERATION;
	}		}

	if (clientId != mCurrentClientId \|\| jobId != mCurrentJobId) {		if (clientId != mCurrentClientId \|\| sessionId != mCurrentSessionId) {
	ALOGW("%s: stopping job {%lld, %d} that's not current job {%lld, %d}", __FUNCTION__,		ALOGW("%s: stopping session {%lld, %d} that's not current session {%lld, %d}", __FUNCTION__,
	(long long)clientId, jobId, (long long)mCurrentClientId, mCurrentJobId);		(long long)clientId, sessionId, (long long)mCurrentClientId, mCurrentSessionId);
	}		}

	ALOGI("%s: pausing transcoder", __FUNCTION__);		ALOGI("%s: pausing transcoder", __FUNCTION__);
	@@ -427,17 +432,17 @@ media_status_t TranscoderWrapper::handlePause(ClientIdType clientId, JobIdType j
	ALOGE("%s: failed to pause transcoder: %d", __FUNCTION__, err);		ALOGE("%s: failed to pause transcoder: %d", __FUNCTION__, err);
	return err;		return err;
	}		}
	mPausedStateMap[JobKeyType(clientId, jobId)] = pauseStates;		mPausedStateMap[SessionKeyType(clientId, sessionId)] = pauseStates;

	ALOGI("%s: transcoder paused", __FUNCTION__);		ALOGI("%s: transcoder paused", __FUNCTION__);
	return AMEDIA_OK;		return AMEDIA_OK;
	}		}

	media_status_t TranscoderWrapper::handleResume(		media_status_t TranscoderWrapper::handleResume(
	ClientIdType clientId, JobIdType jobId, const TranscodingRequestParcel& request,		ClientIdType clientId, SessionIdType sessionId, const TranscodingRequestParcel& request,
	const std::shared_ptr<ITranscodingClientCallback>& clientCb) {		const std::shared_ptr<ITranscodingClientCallback>& clientCb) {
	std::shared_ptr<const Parcel> pausedState;		std::shared_ptr<const Parcel> pausedState;
	auto it = mPausedStateMap.find(JobKeyType(clientId, jobId));		auto it = mPausedStateMap.find(SessionKeyType(clientId, sessionId));
	if (it != mPausedStateMap.end()) {		if (it != mPausedStateMap.end()) {
	pausedState = it->second;		pausedState = it->second;
	mPausedStateMap.erase(it);		mPausedStateMap.erase(it);
	@@ -447,7 +452,7 @@ media_status_t TranscoderWrapper::handleResume(
	}		}

	ALOGI("%s: setting up transcoder for resume", __FUNCTION__);		ALOGI("%s: setting up transcoder for resume", __FUNCTION__);
	media_status_t err = setupTranscoder(clientId, jobId, request, clientCb, pausedState);		media_status_t err = setupTranscoder(clientId, sessionId, request, clientCb, pausedState);
	if (err != AMEDIA_OK) {		if (err != AMEDIA_OK) {
	ALOGE("%s: failed to setup transcoder: %d", __FUNCTION__, err);		ALOGE("%s: failed to setup transcoder: %d", __FUNCTION__, err);
	return err;		return err;
	@@ -465,16 +470,16 @@ media_status_t TranscoderWrapper::handleResume(

	void TranscoderWrapper::cleanup() {		void TranscoderWrapper::cleanup() {
	mCurrentClientId = 0;		mCurrentClientId = 0;
	mCurrentJobId = -1;		mCurrentSessionId = -1;
	mTranscoderCb = nullptr;		mTranscoderCb = nullptr;
	mTranscoder = nullptr;		mTranscoder = nullptr;
	}		}

	void TranscoderWrapper::queueEvent(Event::Type type, ClientIdType clientId, JobIdType jobId,		void TranscoderWrapper::queueEvent(Event::Type type, ClientIdType clientId, SessionIdType sessionId,
	const std::function<void()> runnable, int32_t arg) {		const std::function<void()> runnable, int32_t arg) {
	std::scoped_lock lock{mLock};		std::scoped_lock lock{mLock};

	mQueue.push_back({type, clientId, jobId, runnable, arg});		mQueue.push_back({type, clientId, sessionId, runnable, arg});
	mCondition.notify_one();		mCondition.notify_one();
	}		}

media/libmediatranscoding/TranscodingClientManager.cpp

+33 −30

Original line number	Original line	Diff line number	Diff line
	@@ -35,8 +35,8 @@ static constexpr const char* MEDIA_PROVIDER_PKG_NAME = "com.google.android.provi

	using ::aidl::android::media::BnTranscodingClient;		using ::aidl::android::media::BnTranscodingClient;
	using ::aidl::android::media::IMediaTranscodingService; // For service error codes		using ::aidl::android::media::IMediaTranscodingService; // For service error codes
	using ::aidl::android::media::TranscodingJobParcel;
	using ::aidl::android::media::TranscodingRequestParcel;		using ::aidl::android::media::TranscodingRequestParcel;
			using ::aidl::android::media::TranscodingSessionParcel;
	using Status = ::ndk::ScopedAStatus;		using Status = ::ndk::ScopedAStatus;
	using ::ndk::SpAIBinder;		using ::ndk::SpAIBinder;

	@@ -74,8 +74,8 @@ struct TranscodingClientManager::ClientImpl : public BnTranscodingClient {
	std::string mClientName;		std::string mClientName;
	std::string mClientOpPackageName;		std::string mClientOpPackageName;

	// Next jobId to assign.		// Next sessionId to assign.
	std::atomic<int32_t> mNextJobId;		std::atomic<int32_t> mNextSessionId;
	// Whether this client has been unregistered already.		// Whether this client has been unregistered already.
	std::atomic<bool> mAbandoned;		std::atomic<bool> mAbandoned;
	// Weak pointer to the client manager for this client.		// Weak pointer to the client manager for this client.
	@@ -86,11 +86,12 @@ struct TranscodingClientManager::ClientImpl : public BnTranscodingClient {
	const std::weak_ptr<TranscodingClientManager>& owner);		const std::weak_ptr<TranscodingClientManager>& owner);

	Status submitRequest(const TranscodingRequestParcel& /in_request/,		Status submitRequest(const TranscodingRequestParcel& /in_request/,
	TranscodingJobParcel* /out_job/, bool* /_aidl_return/) override;		TranscodingSessionParcel* /out_session/,
			bool* /_aidl_return/) override;

	Status cancelJob(int32_t /in_jobId/, bool* /_aidl_return/) override;		Status cancelSession(int32_t /in_sessionId/, bool* /_aidl_return/) override;

	Status getJobWithId(int32_t /in_jobId/, TranscodingJobParcel* /out_job/,		Status getSessionWithId(int32_t /in_sessionId/, TranscodingSessionParcel* /out_session/,
	bool* /_aidl_return/) override;		bool* /_aidl_return/) override;

	Status unregister() override;		Status unregister() override;
	@@ -104,12 +105,12 @@ TranscodingClientManager::ClientImpl::ClientImpl(
	mClientId(sCookieCounter.fetch_add(1, std::memory_order_relaxed)),		mClientId(sCookieCounter.fetch_add(1, std::memory_order_relaxed)),
	mClientName(clientName),		mClientName(clientName),
	mClientOpPackageName(opPackageName),		mClientOpPackageName(opPackageName),
	mNextJobId(0),		mNextSessionId(0),
	mAbandoned(false),		mAbandoned(false),
	mOwner(owner) {}		mOwner(owner) {}

	Status TranscodingClientManager::ClientImpl::submitRequest(		Status TranscodingClientManager::ClientImpl::submitRequest(
	const TranscodingRequestParcel& in_request, TranscodingJobParcel* out_job,		const TranscodingRequestParcel& in_request, TranscodingSessionParcel* out_session,
	bool* _aidl_return) {		bool* _aidl_return) {
	*_aidl_return = false;		*_aidl_return = false;

	@@ -161,23 +162,24 @@ Status TranscodingClientManager::ClientImpl::submitRequest(
	in_clientPid, in_clientUid, callingUid);		in_clientPid, in_clientUid, callingUid);
	}		}

	int32_t jobId = mNextJobId.fetch_add(1);		int32_t sessionId = mNextSessionId.fetch_add(1);

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

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

	// TODO(chz): is some of this coming from JobScheduler?		// TODO(chz): is some of this coming from SessionController?
	(TranscodingRequest)&out_job->request = in_request;		(TranscodingRequest)&out_session->request = in_request;
	out_job->awaitNumberOfJobs = 0;		out_session->awaitNumberOfSessions = 0;
	}		}

	return Status::ok();		return Status::ok();
	}		}

	Status TranscodingClientManager::ClientImpl::cancelJob(int32_t in_jobId, bool* _aidl_return) {		Status TranscodingClientManager::ClientImpl::cancelSession(int32_t in_sessionId,
			bool* _aidl_return) {
	*_aidl_return = false;		*_aidl_return = false;

	std::shared_ptr<TranscodingClientManager> owner;		std::shared_ptr<TranscodingClientManager> owner;
	@@ -185,16 +187,16 @@ Status TranscodingClientManager::ClientImpl::cancelJob(int32_t in_jobId, bool* _
	return Status::fromServiceSpecificError(IMediaTranscodingService::ERROR_DISCONNECTED);		return Status::fromServiceSpecificError(IMediaTranscodingService::ERROR_DISCONNECTED);
	}		}

	if (in_jobId < 0) {		if (in_sessionId < 0) {
	return Status::ok();		return Status::ok();
	}		}

	*_aidl_return = owner->mJobScheduler->cancel(mClientId, in_jobId);		*_aidl_return = owner->mSessionController->cancel(mClientId, in_sessionId);
	return Status::ok();		return Status::ok();
	}		}

	Status TranscodingClientManager::ClientImpl::getJobWithId(int32_t in_jobId,		Status TranscodingClientManager::ClientImpl::getSessionWithId(int32_t in_sessionId,
	TranscodingJobParcel* out_job,		TranscodingSessionParcel* out_session,
	bool* _aidl_return) {		bool* _aidl_return) {
	*_aidl_return = false;		*_aidl_return = false;

	@@ -203,15 +205,16 @@ Status TranscodingClientManager::ClientImpl::getJobWithId(int32_t in_jobId,
	return Status::fromServiceSpecificError(IMediaTranscodingService::ERROR_DISCONNECTED);		return Status::fromServiceSpecificError(IMediaTranscodingService::ERROR_DISCONNECTED);
	}		}

	if (in_jobId < 0) {		if (in_sessionId < 0) {
	return Status::ok();		return Status::ok();
	}		}

	*_aidl_return = owner->mJobScheduler->getJob(mClientId, in_jobId, &out_job->request);		*_aidl_return =
			owner->mSessionController->getSession(mClientId, in_sessionId, &out_session->request);

	if (*_aidl_return) {		if (*_aidl_return) {
	out_job->jobId = in_jobId;		out_session->sessionId = in_sessionId;
	out_job->awaitNumberOfJobs = 0;		out_session->awaitNumberOfSessions = 0;
	}		}
	return Status::ok();		return Status::ok();
	}		}
	@@ -224,8 +227,8 @@ Status TranscodingClientManager::ClientImpl::unregister() {
	return Status::fromServiceSpecificError(IMediaTranscodingService::ERROR_DISCONNECTED);		return Status::fromServiceSpecificError(IMediaTranscodingService::ERROR_DISCONNECTED);
	}		}

	// Use jobId == -1 to cancel all realtime jobs for this client with the scheduler.		// Use sessionId == -1 to cancel all realtime sessions for this client with the controller.
	owner->mJobScheduler->cancel(mClientId, -1);		owner->mSessionController->cancel(mClientId, -1);
	owner->removeClient(mClientId);		owner->removeClient(mClientId);

	return Status::ok();		return Status::ok();
	@@ -256,9 +259,9 @@ void TranscodingClientManager::BinderDiedCallback(void* cookie) {
	}		}

	TranscodingClientManager::TranscodingClientManager(		TranscodingClientManager::TranscodingClientManager(
	const std::shared_ptr<SchedulerClientInterface>& scheduler)		const std::shared_ptr<ControllerClientInterface>& controller)
	: mDeathRecipient(AIBinder_DeathRecipient_new(BinderDiedCallback)),		: mDeathRecipient(AIBinder_DeathRecipient_new(BinderDiedCallback)),
	mJobScheduler(scheduler),		mSessionController(controller),
	mMediaProviderUid(-1) {		mMediaProviderUid(-1) {
	ALOGD("TranscodingClientManager started");		ALOGD("TranscodingClientManager started");
	uid_t mpuid;		uid_t mpuid;

media/libmediatranscoding/TranscodingJobScheduler.cpp→media/libmediatranscoding/TranscodingSessionController.cpp

+574 −0

File changed and moved.

Preview size limit exceeded, changes collapsed.

media/libmediatranscoding/aidl/android/media/IMediaTranscodingService.aidl

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -18,7 +18,7 @@ package android.media;

	import android.media.ITranscodingClient;		import android.media.ITranscodingClient;
	import android.media.ITranscodingClientCallback;		import android.media.ITranscodingClientCallback;
	import android.media.TranscodingJobParcel;		import android.media.TranscodingSessionParcel;
	import android.media.TranscodingRequestParcel;		import android.media.TranscodingRequestParcel;

	/**		/**