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

Improve Tuner 1.1 VTS configuration and 1.0 VTS compatibility

Browse Source 
This CL cherry-picks most of the backported changes of Tuner 1.0 from
android 12 to android 11 vts branch to Tuner 1.1 VTS in Android 12
per BCM's suggestions

Test: atest VtsHalTvTunerV1_0TargetTest
Test: atest VtsHalTvTunerV1_1TargetTest
Bug: 182519645
Change-Id: I3651396511fa067ce053ac2531cd2324832eb5f0
This commit is contained in:
Amy Zhang
2021-03-11 17:39:10 -08:00
parent fc68c319d0
commit df57fbfb6c
8 changed files with 80 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
tv/tuner/1.0/vts/functional/FilterTests.cpp
View File

@@ -70,10 +70,6 @@ void FilterCallback::filterThreadLoop(DemuxFilterEvent& /* event */) {
}
bool FilterCallback::readFilterEventData() {
if (mFilterMQ == NULL) {
ALOGW("[vts] FMQ is not configured and does not need to be tested.");
return true;
}
bool result = false;
DemuxFilterEvent filterEvent = mFilterEvent;
ALOGW("[vts] reading from filter FMQ or buffer %d", mFilterId);
@@ -95,16 +91,19 @@ bool FilterCallback::readFilterEventData() {
}
// EXPECT_TRUE(mDataLength == goldenDataOutputBuffer.size()) << "buffer size does not
// match";
mDataOutputBuffer.resize(mDataLength);
result = mFilterMQ->read(mDataOutputBuffer.data(), mDataLength);
EXPECT_TRUE(result) << "can't read from Filter MQ";
if (mFilterMQ != NULL) {
mDataOutputBuffer.resize(mDataLength);
result = mFilterMQ->read(mDataOutputBuffer.data(), mDataLength);
EXPECT_TRUE(result) << "can't read from Filter MQ";
}
/*for (int i = 0; i < mDataLength; i++) {
EXPECT_TRUE(goldenDataOutputBuffer[i] == mDataOutputBuffer[i]) << "data does not match";
}*/
}
mFilterMQEventFlag->wake(static_cast<uint32_t>(DemuxQueueNotifyBits::DATA_CONSUMED));
if (mFilterMQ != NULL) {
mFilterMQEventFlag->wake(static_cast<uint32_t>(DemuxQueueNotifyBits::DATA_CONSUMED));
}
return result;
}

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

@@ -221,7 +221,7 @@ inline void initFrontendConfig() {
frontendArray[DVBT].tuneStatusTypes = types;
frontendArray[DVBT].expectTuneStatuses = statuses;
frontendArray[DVBT].isSoftwareFe = true;
frontendArray[DVBS].enable = true;
frontendArray[DVBT].enable = true;
frontendArray[DVBS].type = FrontendType::DVBS;
frontendArray[DVBS].enable = true;
frontendArray[DVBS].isSoftwareFe = true;

6
tv/tuner/1.1/vts/functional/FilterTests.cpp
View File

@@ -252,7 +252,11 @@ AssertionResult FilterTests::configIpFilterCid(uint32_t ipCid, uint64_t filterId
return AssertionResult(status == Result::SUCCESS);
}
AssertionResult FilterTests::getFilterMQDescriptor(uint64_t filterId) {
AssertionResult FilterTests::getFilterMQDescriptor(uint64_t filterId, bool getMqDesc) {
if (!getMqDesc) {
ALOGE("[vts] Filter does not need FMQ.");
return success();
}
Result status;
EXPECT_TRUE(mFilters[filterId]) << "Test with getNewlyOpenedFilterId first.";
EXPECT_TRUE(mFilterCallbacks[filterId]) << "Test with getNewlyOpenedFilterId first.";

2
tv/tuner/1.1/vts/functional/FilterTests.h
View File

@@ -161,7 +161,7 @@ class FilterTests {
AssertionResult configAvFilterStreamType(AvStreamType type, uint64_t filterId);
AssertionResult configIpFilterCid(uint32_t ipCid, uint64_t filterId);
AssertionResult configureMonitorEvent(uint64_t filterId, uint32_t monitorEventTypes);
AssertionResult getFilterMQDescriptor(uint64_t filterId);
AssertionResult getFilterMQDescriptor(uint64_t filterId, bool getMqDesc);
AssertionResult startFilter(uint64_t filterId);
AssertionResult stopFilter(uint64_t filterId);
AssertionResult closeFilter(uint64_t filterId);

55
tv/tuner/1.1/vts/functional/FrontendTests.cpp
View File

@@ -130,7 +130,7 @@ void FrontendCallback::scanTest(sp<IFrontend>& frontend, FrontendConfig config,
return;
}
uint32_t targetFrequency = getTargetFrequency(config.settings, config.type);
uint32_t targetFrequency = getTargetFrequency(config.settings);
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.
@@ -184,64 +184,59 @@ wait:
mScanMsgProcessed = true;
}
uint32_t FrontendCallback::getTargetFrequency(FrontendSettings settings, FrontendType type) {
switch (type) {
case FrontendType::ANALOG:
uint32_t FrontendCallback::getTargetFrequency(FrontendSettings settings) {
switch (settings.getDiscriminator()) {
case FrontendSettings::hidl_discriminator::analog:
return settings.analog().frequency;
case FrontendType::ATSC:
case FrontendSettings::hidl_discriminator::atsc:
return settings.atsc().frequency;
case FrontendType::ATSC3:
case FrontendSettings::hidl_discriminator::atsc3:
return settings.atsc3().frequency;
case FrontendType::DVBC:
case FrontendSettings::hidl_discriminator::dvbc:
return settings.dvbc().frequency;
case FrontendType::DVBS:
case FrontendSettings::hidl_discriminator::dvbs:
return settings.dvbs().frequency;
case FrontendType::DVBT:
case FrontendSettings::hidl_discriminator::dvbt:
return settings.dvbt().frequency;
case FrontendType::ISDBS:
case FrontendSettings::hidl_discriminator::isdbs:
return settings.isdbs().frequency;
case FrontendType::ISDBS3:
case FrontendSettings::hidl_discriminator::isdbs3:
return settings.isdbs3().frequency;
case FrontendType::ISDBT:
case FrontendSettings::hidl_discriminator::isdbt:
return settings.isdbt().frequency;
default:
return 0;
}
}
void FrontendCallback::resetBlindScanStartingFrequency(FrontendConfig& config,
uint32_t resetingFreq) {
switch (config.type) {
case FrontendType::ANALOG:
switch (config.settings.getDiscriminator()) {
case FrontendSettings::hidl_discriminator::analog:
config.settings.analog().frequency = resetingFreq;
break;
case FrontendType::ATSC:
case FrontendSettings::hidl_discriminator::atsc:
config.settings.atsc().frequency = resetingFreq;
break;
case FrontendType::ATSC3:
case FrontendSettings::hidl_discriminator::atsc3:
config.settings.atsc3().frequency = resetingFreq;
break;
case FrontendType::DVBC:
case FrontendSettings::hidl_discriminator::dvbc:
config.settings.dvbc().frequency = resetingFreq;
break;
case FrontendType::DVBS:
case FrontendSettings::hidl_discriminator::dvbs:
config.settings.dvbs().frequency = resetingFreq;
break;
case FrontendType::DVBT:
case FrontendSettings::hidl_discriminator::dvbt:
config.settings.dvbt().frequency = resetingFreq;
break;
case FrontendType::ISDBS:
case FrontendSettings::hidl_discriminator::isdbs:
config.settings.isdbs().frequency = resetingFreq;
break;
case FrontendType::ISDBS3:
case FrontendSettings::hidl_discriminator::isdbs3:
config.settings.isdbs3().frequency = resetingFreq;
break;
case FrontendType::ISDBT:
case FrontendSettings::hidl_discriminator::isdbt:
config.settings.isdbt().frequency = resetingFreq;
break;
default:
// do nothing
return;
}
}
@@ -490,6 +485,9 @@ void FrontendTests::getFrontendIdByType(FrontendType feType, uint32_t& feId) {
}
void FrontendTests::tuneTest(FrontendConfig frontendConf) {
if (!frontendConf.enable) {
return;
}
uint32_t feId;
getFrontendIdByType(frontendConf.type, feId);
ASSERT_TRUE(feId != INVALID_ID);
@@ -506,6 +504,9 @@ void FrontendTests::tuneTest(FrontendConfig frontendConf) {
}
void FrontendTests::scanTest(FrontendConfig frontendConf, FrontendScanType scanType) {
if (!frontendConf.enable) {
return;
}
uint32_t feId;
getFrontendIdByType(frontendConf.type, feId);
ASSERT_TRUE(feId != INVALID_ID);

2
tv/tuner/1.1/vts/functional/FrontendTests.h
View File

@@ -82,7 +82,7 @@ class FrontendCallback : public IFrontendCallback {
void scanTest(sp<IFrontend>& frontend, FrontendConfig config, FrontendScanType type);
// Helper methods
uint32_t getTargetFrequency(FrontendSettings settings, FrontendType type);
uint32_t getTargetFrequency(FrontendSettings settings);
void resetBlindScanStartingFrequency(FrontendConfig& config, uint32_t resetingFreq);
private:

39
tv/tuner/1.1/vts/functional/VtsHalTvTunerV1_1TargetTest.cpp
View File

@@ -28,6 +28,10 @@ AssertionResult TunerRecordHidlTest::filterDataOutputTest() {
void TunerFilterHidlTest::configSingleFilterInDemuxTest(FilterConfig filterConf,
FrontendConfig frontendConf) {
if (!frontendConf.enable) {
return;
}
uint32_t feId;
uint32_t demuxId;
sp<IDemux> demux;
@@ -49,7 +53,7 @@ void TunerFilterHidlTest::configSingleFilterInDemuxTest(FilterConfig filterConf,
if (filterConf.monitorEventTypes > 0) {
ASSERT_TRUE(mFilterTests.configureMonitorEvent(filterId, filterConf.monitorEventTypes));
}
ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId));
ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId, filterConf.getMqDesc));
ASSERT_TRUE(mFilterTests.startFilter(filterId));
ASSERT_TRUE(mFilterTests.stopFilter(filterId));
ASSERT_TRUE(mFilterTests.closeFilter(filterId));
@@ -60,6 +64,10 @@ void TunerFilterHidlTest::configSingleFilterInDemuxTest(FilterConfig filterConf,
void TunerFilterHidlTest::reconfigSingleFilterInDemuxTest(FilterConfig filterConf,
FilterConfig filterReconf,
FrontendConfig frontendConf) {
if (!frontendConf.enable) {
return;
}
uint32_t feId;
uint32_t demuxId;
sp<IDemux> demux;
@@ -76,7 +84,7 @@ void TunerFilterHidlTest::reconfigSingleFilterInDemuxTest(FilterConfig filterCon
ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type, filterConf.bufferSize));
ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
ASSERT_TRUE(mFilterTests.configFilter(filterConf.settings, filterId));
ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId));
ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId, filterConf.getMqDesc));
ASSERT_TRUE(mFilterTests.startFilter(filterId));
ASSERT_TRUE(mFilterTests.stopFilter(filterId));
ASSERT_TRUE(mFilterTests.configFilter(filterReconf.settings, filterId));
@@ -92,6 +100,10 @@ void TunerFilterHidlTest::reconfigSingleFilterInDemuxTest(FilterConfig filterCon
void TunerBroadcastHidlTest::mediaFilterUsingSharedMemoryTest(FilterConfig filterConf,
FrontendConfig frontendConf) {
if (!frontendConf.enable) {
return;
}
uint32_t feId;
uint32_t demuxId;
sp<IDemux> demux;
@@ -110,7 +122,7 @@ void TunerBroadcastHidlTest::mediaFilterUsingSharedMemoryTest(FilterConfig filte
ASSERT_TRUE(mFilterTests.getSharedAvMemoryHandle(filterId));
ASSERT_TRUE(mFilterTests.configFilter(filterConf.settings, filterId));
ASSERT_TRUE(mFilterTests.configAvFilterStreamType(filterConf.streamType, filterId));
ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId));
ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId, filterConf.getMqDesc));
ASSERT_TRUE(mFilterTests.startFilter(filterId));
// tune test
ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
@@ -125,6 +137,10 @@ void TunerBroadcastHidlTest::mediaFilterUsingSharedMemoryTest(FilterConfig filte
void TunerRecordHidlTest::recordSingleFilterTest(FilterConfig filterConf,
FrontendConfig frontendConf, DvrConfig dvrConf) {
if (!frontendConf.enable) {
return;
}
uint32_t feId;
uint32_t demuxId;
sp<IDemux> demux;
@@ -146,7 +162,7 @@ void TunerRecordHidlTest::recordSingleFilterTest(FilterConfig filterConf,
ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type, filterConf.bufferSize));
ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
ASSERT_TRUE(mFilterTests.configFilter(filterConf.settings, filterId));
ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId));
ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId, filterConf.getMqDesc));
filter = mFilterTests.getFilterById(filterId);
ASSERT_TRUE(filter != nullptr);
mDvrTests.startRecordOutputThread(dvrConf.settings.record());
@@ -170,40 +186,41 @@ void TunerRecordHidlTest::recordSingleFilterTest(FilterConfig filterConf,
TEST_P(TunerFilterHidlTest, StartFilterInDemux) {
description("Open and start a filter in Demux.");
// TODO use parameterized tests
configSingleFilterInDemuxTest(filterArray[TS_VIDEO0], frontendArray[DVBT]);
configSingleFilterInDemuxTest(filterArray[TS_VIDEO0], frontendArray[defaultFrontend]);
}
TEST_P(TunerFilterHidlTest, ConfigIpFilterInDemuxWithCid) {
description("Open and configure an ip filter in Demux.");
// TODO use parameterized tests
configSingleFilterInDemuxTest(filterArray[IP_IP0], frontendArray[DVBT]);
configSingleFilterInDemuxTest(filterArray[IP_IP0], frontendArray[defaultFrontend]);
}
TEST_P(TunerFilterHidlTest, ReconfigFilterToReceiveStartId) {
description("Recofigure and restart a filter to test start id.");
// TODO use parameterized tests
reconfigSingleFilterInDemuxTest(filterArray[TS_VIDEO0], filterArray[TS_VIDEO1],
frontendArray[DVBT]);
frontendArray[defaultFrontend]);
}
TEST_P(TunerRecordHidlTest, RecordDataFlowWithTsRecordFilterTest) {
description("Feed ts data from frontend to recording and test with ts record filter");
recordSingleFilterTest(filterArray[TS_RECORD0], frontendArray[DVBT], dvrArray[DVR_RECORD0]);
recordSingleFilterTest(filterArray[TS_RECORD0], frontendArray[defaultFrontend],
dvrArray[DVR_RECORD0]);
}
TEST_P(TunerFrontendHidlTest, TuneFrontendWithFrontendSettingsExt1_1) {
description("Tune one Frontend with v1_1 extended setting and check Lock event");
mFrontendTests.tuneTest(frontendArray[DVBT]);
mFrontendTests.tuneTest(frontendArray[defaultFrontend]);
}
TEST_P(TunerFrontendHidlTest, BlindScanFrontendWithEndFrequency) {
description("Run an blind frontend scan with v1_1 extended setting and check lock scanMessage");
mFrontendTests.scanTest(frontendScanArray[SCAN_DVBT], FrontendScanType::SCAN_BLIND);
mFrontendTests.scanTest(frontendScanArray[defaultScanFrontend], FrontendScanType::SCAN_BLIND);
}
TEST_P(TunerBroadcastHidlTest, MediaFilterWithSharedMemoryHandle) {
description("Test the Media Filter with shared memory handle");
mediaFilterUsingSharedMemoryTest(filterArray[TS_VIDEO0], frontendArray[DVBT]);
mediaFilterUsingSharedMemoryTest(filterArray[TS_VIDEO0], frontendArray[defaultFrontend]);
}
TEST_P(TunerFrontendHidlTest, GetFrontendDtmbCaps) {

8
tv/tuner/1.1/vts/functional/VtsHalTvTunerV1_1TestConfigurations.h
View File

@@ -55,6 +55,7 @@ using android::hardware::tv::tuner::V1_1::VideoStreamType;
using namespace std;
const uint32_t FMQ_SIZE_512K = 0x80000;
const uint32_t FMQ_SIZE_1M = 0x100000;
const uint32_t FMQ_SIZE_4M = 0x400000;
const uint32_t FMQ_SIZE_16M = 0x1000000;
@@ -94,6 +95,7 @@ struct FilterConfig {
uint32_t bufferSize;
DemuxFilterType type;
DemuxFilterSettings settings;
bool getMqDesc;
AvStreamType streamType;
uint32_t ipCid;
uint32_t monitorEventTypes;
@@ -102,6 +104,7 @@ struct FilterConfig {
};
struct FrontendConfig {
bool enable;
bool isSoftwareFe;
bool canConnectToCiCam;
uint32_t ciCamId;
@@ -124,6 +127,7 @@ static FrontendConfig frontendScanArray[SCAN_MAX];
static FilterConfig filterArray[FILTER_MAX];
static DvrConfig dvrArray[DVR_MAX];
static int defaultFrontend = DVBT;
static int defaultScanFrontend = SCAN_DVBT;
/** Configuration array for the frontend tune test */
inline void initFrontendConfig() {
@@ -159,8 +163,10 @@ inline void initFrontendConfig() {
.transmissionMode =
android::hardware::tv::tuner::V1_1::FrontendDvbtTransmissionMode::MODE_8K_E,
});
frontendArray[DVBT].enable = true;
frontendArray[DVBS].type = FrontendType::DVBS;
frontendArray[DVBS].isSoftwareFe = true;
frontendArray[DVBS].enable = true;
};
/** Configuration array for the frontend scan test */
@@ -223,6 +229,7 @@ inline void initFilterConfig() {
.isRaw = false,
.streamId = 0xbd,
});
filterArray[TS_PES0].getMqDesc = true;
// TS PCR filter setting
filterArray[TS_PCR0].type.mainType = DemuxFilterMainType::TS;
filterArray[TS_PCR0].type.subType.tsFilterType(DemuxTsFilterType::PCR);
@@ -243,6 +250,7 @@ inline void initFilterConfig() {
filterArray[TS_SECTION0].settings.ts().filterSettings.section({
.isRaw = false,
});
filterArray[TS_SECTION0].getMqDesc = true;
// TS RECORD filter setting
filterArray[TS_RECORD0].type.mainType = DemuxFilterMainType::TS;
filterArray[TS_RECORD0].type.subType.tsFilterType(DemuxTsFilterType::RECORD);