Evolution-x/hardware_interfaces
1
0
Fork 0
mirror of https://github.com/Evolution-X/hardware_interfaces synced 2026-02-01 10:44:41 +00:00
Code Issues Packages Projects Releases Wiki Activity

Align Tuner VTS scan tests with the latest scan mechanism

Browse Source 
Test: atest VtsHalTvTunerV1_0TargetTest
Bug: 135708935
Bug: 150953857
Change-Id: Ibb0a70195b1e8f89a45f3ab1a025dfaab4c76859
This commit is contained in:
Amy
2020-02-28 11:13:06 -08:00
committed by Amy Zhang
parent d6afead9fc
commit e3b052154d
2 changed files with 168 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files

207
tv/tuner/1.0/vts/functional/VtsHalTvTunerV1_0TargetTest.cpp
View File

@@ -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();
return Void();
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,
FrontendScanType type) {
Result result = frontend->scan(settings, type);
EXPECT_TRUE(result == Result::SUCCESS);
android::Mutex::Autolock autoLock(mMsgLock);
int messagesCount = 0;
void FrontendCallback::scanTest(sp<IFrontend>& frontend, FrontendConfig config,
FrontendScanType 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);
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!!";
return;
}
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 ============================*/

18
tv/tuner/1.0/vts/functional/VtsHalTvTunerV1_0TestConfigurations.h
View File

@@ -113,9 +113,19 @@ 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,
});
};
/** Configuration array for the filter test */
@@ -135,4 +145,4 @@ inline void initFilterConfig() {
});
};
} // namespace
} // namespace