Merge changes from topics "ion", "scan" into rvc-dev am: aeaaeaabb1 (8a9bd559) · Commits · e / os / android_hardware_interfaces

tv/tuner/1.0/vts/functional/VtsHalTvTunerV1_0TargetTest.cpp

+153 −52

Original line number	Diff line number	Diff line
		@@ -47,7 +47,6 @@
		#include "VtsHalTvTunerV1_0TestConfigurations.h"

		#define WAIT_TIMEOUT 3000000000
		#define WAIT_TIMEOUT_data_ready 3000000000 * 4

		using android::Condition;
		using android::IMemory;
		@@ -158,7 +157,6 @@ const std::vector<uint8_t> goldenDataOutputBuffer{
		// const uint16_t FMQ_SIZE_4K = 0x1000;
		const uint32_t FMQ_SIZE_1M = 0x100000;
		const uint32_t FMQ_SIZE_16M = 0x1000000;
		const uint8_t FRONTEND_EVENT_CALLBACK_WAIT_COUNT = 4;

		enum FilterEventType : uint8_t {
		UNDEFINED,
		@@ -181,52 +179,65 @@ class FrontendCallback : public IFrontendCallback {
		public:
		virtual Return<void> onEvent(FrontendEventType frontendEventType) override {
		android::Mutex::Autolock autoLock(mMsgLock);
		ALOGD("[vts] frontend event received. Type: %d", frontendEventType);
		mEventReceived = true;
		mEventType = frontendEventType;
		mMsgCondition.signal();
		switch (frontendEventType) {
		case FrontendEventType::LOCKED:
		mLockMsgReceived = true;
		mLockMsgCondition.signal();
		return Void();
		default:
		// do nothing
		return Void();
		}
		}

		virtual Return<void> onScanMessage(FrontendScanMessageType type,
		const FrontendScanMessage& message) override {
		android::Mutex::Autolock autoLock(mMsgLock);
		ALOGD("[vts] scan message. Type: %d", mScanMessageType);
		while (!mScanMsgProcessed) {
		mMsgCondition.wait(mMsgLock);
		}
		ALOGD("[vts] frontend scan message. Type: %d", type);
		mScanMessageReceived = true;
		mScanMsgProcessed = false;
		mScanMessageType = type;
		mScanLockMessageReceived =
		mScanLockMessageReceived \| (type == FrontendScanMessageType::LOCKED);
		mScanMessage = message;
		mMsgCondition.signal();
		return Void();
		};
		}

		void tuneTestOnEventReceive(sp<IFrontend>& frontend, FrontendSettings settings);
		void tuneTestOnLock(sp<IFrontend>& frontend, FrontendSettings settings);
		void scanTestOnMessageLock(sp<IFrontend>& frontend, FrontendSettings settings,
		FrontendScanType type);
		void scanTest(sp<IFrontend>& frontend, FrontendConfig config, FrontendScanType type);

		// Helper methods
		uint32_t getTargetFrequency(FrontendSettings settings, FrontendType type);
		void resetBlindScanStartingFrequency(FrontendConfig config, uint32_t resetingFreq);

		private:
		bool mEventReceived = false;
		bool mScanMessageReceived = false;
		bool mScanLockMessageReceived = false;
		FrontendEventType mEventType;
		bool mLockMsgReceived = false;
		bool mScanMsgProcessed = true;
		FrontendScanMessageType mScanMessageType;
		FrontendScanMessage mScanMessage;
		hidl_vec<uint8_t> mEventMessage;
		android::Mutex mMsgLock;
		android::Condition mMsgCondition;
		uint8_t mOnEvenRetry = 0;
		android::Condition mLockMsgCondition;
		};

		void FrontendCallback::tuneTestOnEventReceive(sp<IFrontend>& frontend, FrontendSettings settings) {
		Result result = frontend->tune(settings);

		EXPECT_TRUE(result == Result::SUCCESS);

		android::Mutex::Autolock autoLock(mMsgLock);
		while (!mEventReceived) {
		if (-ETIMEDOUT == mMsgCondition.waitRelative(mMsgLock, WAIT_TIMEOUT)) {
		EXPECT_TRUE(false) << "event not received within timeout";
		EXPECT_TRUE(false) << "Event not received within timeout";
		mLockMsgReceived = false;
		return;
		}
		}
		@@ -235,61 +246,134 @@ void FrontendCallback::tuneTestOnEventReceive(sp<IFrontend>& frontend, FrontendS

		void FrontendCallback::tuneTestOnLock(sp<IFrontend>& frontend, FrontendSettings settings) {
		Result result = frontend->tune(settings);

		EXPECT_TRUE(result == Result::SUCCESS);

		android::Mutex::Autolock autoLock(mMsgLock);
		wait:
		while (!mEventReceived) {
		if (-ETIMEDOUT == mMsgCondition.waitRelative(mMsgLock, WAIT_TIMEOUT)) {
		EXPECT_TRUE(false) << "event not received within timeout";
		while (!mLockMsgReceived) {
		if (-ETIMEDOUT == mLockMsgCondition.waitRelative(mMsgLock, WAIT_TIMEOUT)) {
		EXPECT_TRUE(false) << "Event LOCKED not received within timeout";
		mLockMsgReceived = false;
		return;
		}
		}
		if (mEventType != FrontendEventType::LOCKED) {
		ALOGD("[vts] frontend callback event received. Type: %d", mEventType);
		mEventReceived = false;
		if (mOnEvenRetry++ < FRONTEND_EVENT_CALLBACK_WAIT_COUNT) {
		goto wait;
		}
		}
		EXPECT_TRUE(mEventType == FrontendEventType::LOCKED) << "LOCK event not received";
		mEventReceived = false;
		mOnEvenRetry = 0;
		mLockMsgReceived = false;
		}

		void FrontendCallback::scanTestOnMessageLock(sp<IFrontend>& frontend, FrontendSettings settings,
		void FrontendCallback::scanTest(sp<IFrontend>& frontend, FrontendConfig config,
		FrontendScanType type) {
		Result result = frontend->scan(settings, type);
		uint32_t targetFrequency = getTargetFrequency(config.settings, config.type);
		if (type == FrontendScanType::SCAN_BLIND) {
		// reset the frequency in the scan configuration to test blind scan. The settings param of
		// passed in means the real input config on the transponder connected to the DUT.
		// We want the blind the test to start from lower frequency than this to check the blind
		// scan implementation.
		resetBlindScanStartingFrequency(config, targetFrequency - 100);
		}

		Result result = frontend->scan(config.settings, type);
		EXPECT_TRUE(result == Result::SUCCESS);
		android::Mutex::Autolock autoLock(mMsgLock);
		int messagesCount = 0;

		bool scanMsgLockedReceived = false;
		bool targetFrequencyReceived = false;

		android::Mutex::Autolock autoLock(mMsgLock);
		wait:
		int count = 0;
		while (!mScanMessageReceived) {
		if (-ETIMEDOUT == mMsgCondition.waitRelative(mMsgLock, WAIT_TIMEOUT)) {
		ALOGD("[vts] waiting for scan message callback...");
		if (count++ > 10) {
		EXPECT_TRUE(false) << "WAITING TOO LONG!!";
		EXPECT_TRUE(false) << "Scan message not received within timeout";
		mScanMessageReceived = false;
		mScanMsgProcessed = true;
		return;
		}
		}
		}

		if (mScanMessageType != FrontendScanMessageType::END) {
		ALOGD("[vts] frontend scan message received. Type: %d", mScanMessageType);
		mScanMessageReceived = false;
		if (messagesCount++ > 3) {
		EXPECT_TRUE(false) << "WAITING ON TOO MANY MSGS!!";
		return;
		if (mScanMessageType == FrontendScanMessageType::LOCKED) {
		scanMsgLockedReceived = true;
		Result result = frontend->scan(config.settings, type);
		EXPECT_TRUE(result == Result::SUCCESS);
		}

		if (mScanMessageType == FrontendScanMessageType::FREQUENCY) {
		targetFrequencyReceived = mScanMessage.frequencies().size() > 0 &&
		mScanMessage.frequencies()[0] == targetFrequency;
		}

		if (mScanMessageType == FrontendScanMessageType::PROGRESS_PERCENT) {
		ALOGD("[vts] Scan in progress...[%d%%]", mScanMessage.progressPercent());
		}

		mScanMessageReceived = false;
		mScanMsgProcessed = true;
		mMsgCondition.signal();
		goto wait;
		}

		EXPECT_TRUE(mScanLockMessageReceived) << "scan lock message not received before scan ended";
		EXPECT_TRUE(scanMsgLockedReceived) << "Scan message LOCKED not received before END";
		EXPECT_TRUE(targetFrequencyReceived) << "frequency not received before LOCKED on blindScan";
		mScanMessageReceived = false;
		mScanLockMessageReceived = false;
		mScanMsgProcessed = true;
		}

		uint32_t FrontendCallback::getTargetFrequency(FrontendSettings settings, FrontendType type) {
		switch (type) {
		case FrontendType::ANALOG:
		return settings.analog().frequency;
		case FrontendType::ATSC:
		return settings.atsc().frequency;
		case FrontendType::ATSC3:
		return settings.atsc3().frequency;
		case FrontendType::DVBC:
		return settings.dvbc().frequency;
		case FrontendType::DVBS:
		return settings.dvbs().frequency;
		case FrontendType::DVBT:
		return settings.dvbt().frequency;
		case FrontendType::ISDBS:
		return settings.isdbs().frequency;
		case FrontendType::ISDBS3:
		return settings.isdbs3().frequency;
		case FrontendType::ISDBT:
		return settings.isdbt().frequency;
		default:
		return 0;
		}
		}

		void FrontendCallback::resetBlindScanStartingFrequency(FrontendConfig config,
		uint32_t resetingFreq) {
		switch (config.type) {
		case FrontendType::ANALOG:
		config.settings.analog().frequency = resetingFreq;
		break;
		case FrontendType::ATSC:
		config.settings.atsc().frequency = resetingFreq;
		break;
		case FrontendType::ATSC3:
		config.settings.atsc3().frequency = resetingFreq;
		break;
		case FrontendType::DVBC:
		config.settings.dvbc().frequency = resetingFreq;
		break;
		case FrontendType::DVBS:
		config.settings.dvbs().frequency = resetingFreq;
		break;
		case FrontendType::DVBT:
		config.settings.dvbt().frequency = resetingFreq;
		break;
		case FrontendType::ISDBS:
		config.settings.isdbs().frequency = resetingFreq;
		break;
		case FrontendType::ISDBS3:
		config.settings.isdbs3().frequency = resetingFreq;
		break;
		case FrontendType::ISDBT:
		config.settings.isdbt().frequency = resetingFreq;
		break;
		default:
		// do nothing
		return;
		}
		}
		/****************************** End FrontendCallback ********************************/

		@@ -851,7 +935,7 @@ AssertionResult TunerHidlTest::scanFrontend(FrontendConfig config, FrontendScanT
		EXPECT_TRUE(mFrontendInfo.type == config.type)
		<< "FrontendConfig does not match the frontend info of the given id.";

		mFrontendCallback->scanTestOnMessageLock(mFrontend, config.settings, type);
		mFrontendCallback->scanTest(mFrontend, config, type);
		return AssertionResult(true);
		}

		@@ -958,7 +1042,7 @@ AssertionResult TunerHidlTest::getNewlyOpenedFilterId(uint32_t& filterId) {
		filterId = mFilterId;
		}

		return AssertionResult(status == Result::SUCCESS \|\| status == Result::UNAVAILABLE);
		return AssertionResult(status == Result::SUCCESS);
		}

		AssertionResult TunerHidlTest::configFilter(DemuxFilterSettings setting, uint32_t filterId) {
		@@ -1326,7 +1410,6 @@ TEST_P(TunerHidlTest, TuneFrontend) {
		}
		ASSERT_TRUE(openFrontend(mFeIds[i]));
		ASSERT_TRUE(setFrontendCallback());
		ASSERT_TRUE(stopTuneFrontend());
		ASSERT_TRUE(tuneFrontend(frontendArray[0]));
		ASSERT_TRUE(stopTuneFrontend());
		ASSERT_TRUE(closeFrontend());
		@@ -1346,13 +1429,31 @@ TEST_P(TunerHidlTest, AutoScanFrontend) {
		}
		ASSERT_TRUE(openFrontend(mFeIds[i]));
		ASSERT_TRUE(setFrontendCallback());
		ASSERT_TRUE(stopScanFrontend());
		ASSERT_TRUE(scanFrontend(frontendScanArray[0], FrontendScanType::SCAN_AUTO));
		ASSERT_TRUE(stopScanFrontend());
		ASSERT_TRUE(closeFrontend());
		break;
		}
		}

		TEST_P(TunerHidlTest, BlindScanFrontend) {
		description("Run an blind frontend scan with specific setting and check lock scanMessage");
		ASSERT_TRUE(getFrontendIds());
		ASSERT_TRUE(mFeIds.size() > 0);

		for (size_t i = 0; i < mFeIds.size(); i++) {
		ASSERT_TRUE(getFrontendInfo(mFeIds[i]));
		if (mFrontendInfo.type != frontendArray[0].type) {
		continue;
		}
		ASSERT_TRUE(openFrontend(mFeIds[i]));
		ASSERT_TRUE(setFrontendCallback());
		ASSERT_TRUE(scanFrontend(frontendScanArray[0], FrontendScanType::SCAN_BLIND));
		ASSERT_TRUE(stopScanFrontend());
		ASSERT_TRUE(closeFrontend());
		break;
		}
		}
		/=============================== End Frontend Tests ===============================/

		/============================ Start Demux/Filter Tests ============================/

tv/tuner/1.0/vts/functional/VtsHalTvTunerV1_0TestConfigurations.h

+14 −4

Original line number	Diff line number	Diff line
		@@ -113,8 +113,18 @@ inline void initFrontendConfig() {

		/** Configuration array for the frontend scan test */
		inline void initFrontendScanConfig() {
		frontendScanArray[0].type = FrontendType::DVBT, frontendScanArray[0].settings.dvbt({
		.frequency = 577000,
		frontendScanArray[0].type = FrontendType::DVBT;
		frontendScanArray[0].settings.dvbt({
		.frequency = 578000,
		.transmissionMode = FrontendDvbtTransmissionMode::MODE_8K,
		.bandwidth = FrontendDvbtBandwidth::BANDWIDTH_8MHZ,
		.constellation = FrontendDvbtConstellation::AUTO,
		.hierarchy = FrontendDvbtHierarchy::AUTO,
		.hpCoderate = FrontendDvbtCoderate::AUTO,
		.lpCoderate = FrontendDvbtCoderate::AUTO,
		.guardInterval = FrontendDvbtGuardInterval::AUTO,
		.isHighPriority = true,
		.standard = FrontendDvbtStandard::T,
		});
		};