transcoding: add test to test watchdog error returned to client (456787fa) · Commits · e / os / android_frameworks_av

media/libmediatranscoding/aidl/android/media/TranscodingTestConfig.aidl

+0 −6

Original line number	Diff line number	Diff line
		@@ -22,12 +22,6 @@
		* {@hide}
		*/
		parcelable TranscodingTestConfig {
		/**
		* Whether to use SimulatedTranscoder for testing. Note that SimulatedTranscoder does not send
		* transcoding sessions to real MediaTranscoder.
		*/
		boolean useSimulatedTranscoder = false;

		/**
		* Passthrough mode used for testing. The transcoding service will assume the destination
		* path already contains the transcoding of the source file and return it to client directly.

services/mediatranscoding/SimulatedTranscoder.cpp

+28 −12

Original line number	Diff line number	Diff line
		@@ -60,11 +60,18 @@ SimulatedTranscoder::~SimulatedTranscoder() {
		void SimulatedTranscoder::start(
		ClientIdType clientId, SessionIdType sessionId, const TranscodingRequestParcel& request,
		const std::shared_ptr<ITranscodingClientCallback>& /clientCallback/) {
		{
		auto lock = std::scoped_lock(mLock);
		int64_t processingTimeUs = kSessionDurationUs;
		if (request.testConfig.has_value() && request.testConfig->processingTotalTimeMs > 0) {
		mSessionProcessingTimeMs = request.testConfig->processingTotalTimeMs;
		processingTimeUs = request.testConfig->processingTotalTimeMs * 1000;
		}
		ALOGI("%s: session {%lld, %d}: processingTimeUs: %lld", __FUNCTION__, (long long)clientId,
		sessionId, (long long)processingTimeUs);
		SessionKeyType key = std::make_pair(clientId, sessionId);
		mRemainingTimeMap.emplace(key, processingTimeUs);
		}
		ALOGV("%s: session {%d}: processingTime: %lld", __FUNCTION__, sessionId,
		(long long)mSessionProcessingTimeMs);

		queueEvent(Event::Start, clientId, sessionId, [=] {
		auto callback = mCallback.lock();
		if (callback != nullptr) {
		@@ -123,7 +130,6 @@ void SimulatedTranscoder::queueEvent(Event::Type type, ClientIdType clientId,

		void SimulatedTranscoder::threadLoop() {
		bool running = false;
		std::chrono::microseconds remainingUs(kSessionDurationUs);
		std::chrono::system_clock::time_point lastRunningTime;
		Event lastRunningEvent;

		@@ -138,12 +144,16 @@ void SimulatedTranscoder::threadLoop() {
		continue;
		}
		// If running, wait for the remaining life of this session. Report finish if timed out.
		std::cv_status status = mCondition.wait_for(lock, remainingUs);
		SessionKeyType key =
		std::make_pair(lastRunningEvent.clientId, lastRunningEvent.sessionId);
		std::cv_status status = mCondition.wait_for(lock, mRemainingTimeMap[key]);
		if (status == std::cv_status::timeout) {
		running = false;

		auto callback = mCallback.lock();
		if (callback != nullptr) {
		mRemainingTimeMap.erase(key);

		lock.unlock();
		callback->onFinish(lastRunningEvent.clientId, lastRunningEvent.sessionId);
		lock.lock();
		@@ -153,7 +163,7 @@ void SimulatedTranscoder::threadLoop() {
		// against bad events (which will be ignored) or spurious wakeups, in that
		// case we don't want to wait for the same time again.
		auto now = std::chrono::system_clock::now();
		remainingUs -= (now - lastRunningTime);
		mRemainingTimeMap[key] -= (now - lastRunningTime);
		lastRunningTime = now;
		}
		}
		@@ -162,23 +172,29 @@ void SimulatedTranscoder::threadLoop() {
		Event event = *mQueue.begin();
		mQueue.pop_front();

		ALOGV("%s: session {%lld, %d}: %s", __FUNCTION__, (long long)event.clientId,
		ALOGD("%s: session {%lld, %d}: %s", __FUNCTION__, (long long)event.clientId,
		event.sessionId, toString(event.type));

		if (event.type == Event::Abandon) {
		break;
		}

		SessionKeyType key = std::make_pair(event.clientId, event.sessionId);
		if (!running && (event.type == Event::Start \|\| event.type == Event::Resume)) {
		running = true;
		lastRunningTime = std::chrono::system_clock::now();
		lastRunningEvent = event;
		if (event.type == Event::Start) {
		remainingUs = std::chrono::milliseconds(mSessionProcessingTimeMs);
		}
		ALOGV("%s: session {%lld, %d}: remaining time: %lld", __FUNCTION__,
		(long long)event.clientId, event.sessionId,
		(long long)mRemainingTimeMap[key].count());

		} else if (running && (event.type == Event::Pause \|\| event.type == Event::Stop)) {
		running = false;
		remainingUs -= (std::chrono::system_clock::now() - lastRunningTime);
		if (event.type == Event::Stop) {
		mRemainingTimeMap.erase(key);
		} else {
		mRemainingTimeMap[key] -= (std::chrono::system_clock::now() - lastRunningTime);
		}
		} else {
		ALOGW("%s: discarding bad event: session {%lld, %d}: %s", __FUNCTION__,
		(long long)event.clientId, event.sessionId, toString(event.type));

services/mediatranscoding/SimulatedTranscoder.h

+4 −2

Original line number	Diff line number	Diff line
		@@ -21,6 +21,7 @@
		#include <media/TranscoderInterface.h>

		#include <list>
		#include <map>
		#include <mutex>

		namespace android {
		@@ -70,8 +71,9 @@ private:
		std::list<Event> mQueue GUARDED_BY(mLock);
		bool mLooperReady;

		// Minimum time spent on transcode the video. This is used just for testing.
		int64_t mSessionProcessingTimeMs = kSessionDurationUs / 1000;
		using SessionKeyType = std::pair<ClientIdType, SessionIdType>;
		// map of session's remaining time in microsec.
		std::map<SessionKeyType, std::chrono::microseconds> mRemainingTimeMap;

		static const char* toString(Event::Type type);
		void queueEvent(Event::Type type, ClientIdType clientId, SessionIdType sessionId,

services/mediatranscoding/tests/MediaTranscodingServiceTestHelper.h

+8 −1

Original line number	Diff line number	Diff line
		@@ -51,6 +51,7 @@ using aidl::android::media::ITranscodingClientCallback;
		using aidl::android::media::TranscodingRequestParcel;
		using aidl::android::media::TranscodingSessionParcel;
		using aidl::android::media::TranscodingSessionPriority;
		using aidl::android::media::TranscodingTestConfig;
		using aidl::android::media::TranscodingVideoTrackFormat;

		constexpr int32_t kClientUseCallingPid = IMediaTranscodingService::USE_CALLING_PID;
		@@ -359,7 +360,8 @@ struct TestClientCallback : public BnTranscodingClientCallback,
		template <bool expectation = success>
		bool submit(int32_t sessionId, const char* sourceFilePath, const char* destinationFilePath,
		TranscodingSessionPriority priority = TranscodingSessionPriority::kNormal,
		int bitrateBps = -1, int overridePid = -1, int overrideUid = -1) {
		int bitrateBps = -1, int overridePid = -1, int overrideUid = -1,
		int sessionDurationMs = -1) {
		constexpr bool shouldSucceed = (expectation == success);
		bool result;
		TranscodingRequestParcel request;
		@@ -375,6 +377,11 @@ struct TestClientCallback : public BnTranscodingClientCallback,
		request.requestedVideoTrackFormat.emplace(TranscodingVideoTrackFormat());
		request.requestedVideoTrackFormat->bitrateBps = bitrateBps;
		}
		if (sessionDurationMs > 0) {
		request.isForTesting = true;
		request.testConfig.emplace(TranscodingTestConfig());
		request.testConfig->processingTotalTimeMs = sessionDurationMs;
		}
		Status status = mClient->submitRequest(request, &session, &result);

		EXPECT_TRUE(status.isOk());

services/mediatranscoding/tests/mediatranscodingservice_simulated_tests.cpp

+29 −0

Original line number	Diff line number	Diff line
		@@ -53,6 +53,7 @@ constexpr const char* kInvalidClientOpPackageName = "";

		constexpr int64_t kPaddingUs = 1000000;
		constexpr int64_t kSessionWithPaddingUs = SimulatedTranscoder::kSessionDurationUs + kPaddingUs;
		constexpr int64_t kWatchdogTimeoutUs = 3000000;

		constexpr const char* kClientOpPackageName = "TestClientPackage";

		@@ -385,5 +386,33 @@ TEST_F(MediaTranscodingServiceSimulatedTest, TestTranscodingThermalPolicy) {

		ALOGD("TestTranscodingThermalPolicy finished.");
		}

		TEST_F(MediaTranscodingServiceSimulatedTest, TestTranscodingWatchdog) {
		ALOGD("TestTranscodingWatchdog starting...");

		registerMultipleClients();

		// SimulatedTranscoder itself does not send heartbeat. Its sessions last 1sec
		// by default, so timeout will not happen normally.
		// Here we run a session of 4000ms with TranscodingTestConfig. This will trigger
		// a watchdog timeout on server side. We use it to check that error code is correct.
		EXPECT_TRUE(mClient1->submit(
		0, "test_source_file_0", "test_destination_file_0", TranscodingSessionPriority::kNormal,
		-1 /bitrateBps/, -1 /overridePid/, -1 /overrideUid/, 4000 /sessionDurationMs/));
		EXPECT_EQ(mClient1->pop(100000), EventTracker::Start(CLIENT(1), 0));
		EXPECT_EQ(mClient1->pop(kWatchdogTimeoutUs - 100000), EventTracker::NoEvent);
		EXPECT_EQ(mClient1->pop(200000), EventTracker::Failed(CLIENT(1), 0));
		EXPECT_EQ(mClient1->getLastError(), TranscodingErrorCode::kWatchdogTimeout);

		// After the timeout, submit another request and check it's finished.
		EXPECT_TRUE(mClient1->submit(1, "test_source_file_1", "test_destination_file_1"));
		EXPECT_EQ(mClient1->pop(kPaddingUs), EventTracker::Start(CLIENT(1), 1));
		EXPECT_EQ(mClient1->pop(kSessionWithPaddingUs), EventTracker::Finished(CLIENT(1), 1));

		unregisterMultipleClients();

		ALOGD("TestTranscodingWatchdog finished.");
		}

		} // namespace media
		} // namespace android