tequilaOS/platform_hardware_interfaces
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge changes Ic1b9dae6,I470d5931,Ic6756e28,Iba526237,I8e8be258

Browse source 
* changes:
  Improve Tuner VTS: Generate Descrambling Combos
  Improve Tuner VTS: Generate LnbRecord Combos
  Improve Tuner VTS: Generate Scan Combos
  Improve Tuner VTS: Generate LnbLive Combos
  Improve Tuner VTS: Generate DVR Playback Combos
This commit is contained in:
Frankie Lizcano 2022-07-25 23:50:44 +00:00 committed by Android (Google) Code Review
commit 81dcde82a8
4 changed files with 437 additions and 49 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

165
tv/tuner/aidl/vts/functional/VtsHalTvTunerTargetTest.cpp
View file

@ -494,23 +494,32 @@ TEST_P(TunerLnbAidlTest, SendDiseqcMessageToLnb) {
if (!lnbLive.support) {
return;
}
if (lnbMap[lnbLive.lnbId].name.compare(emptyHardwareId) == 0) {
vector<int32_t> ids;
ASSERT_TRUE(mLnbTests.getLnbIds(ids));
ASSERT_TRUE(ids.size() > 0);
ASSERT_TRUE(mLnbTests.openLnbById(ids[0]));
} else {
int32_t id;
ASSERT_TRUE(mLnbTests.openLnbByName(lnbMap[lnbLive.lnbId].name, id));
vector<LnbLiveHardwareConnections> lnbLive_configs = generateLnbLiveConfigurations();
if (lnbLive_configs.empty()) {
ALOGD("No frontends that support satellites.");
return;
}
ASSERT_TRUE(mLnbTests.setLnbCallback());
ASSERT_TRUE(mLnbTests.setVoltage(lnbMap[lnbLive.lnbId].voltage));
ASSERT_TRUE(mLnbTests.setTone(lnbMap[lnbLive.lnbId].tone));
ASSERT_TRUE(mLnbTests.setSatellitePosition(lnbMap[lnbLive.lnbId].position));
for (auto msgName : lnbLive.diseqcMsgs) {
ASSERT_TRUE(mLnbTests.sendDiseqcMessage(diseqcMsgMap[msgName]));
for (auto& combination : lnbLive_configs) {
lnbLive = combination;
if (lnbMap[lnbLive.lnbId].name.compare(emptyHardwareId) == 0) {
vector<int32_t> ids;
ASSERT_TRUE(mLnbTests.getLnbIds(ids));
ASSERT_TRUE(ids.size() > 0);
ASSERT_TRUE(mLnbTests.openLnbById(ids[0]));
} else {
int32_t id;
ASSERT_TRUE(mLnbTests.openLnbByName(lnbMap[lnbLive.lnbId].name, id));
}
ASSERT_TRUE(mLnbTests.setLnbCallback());
ASSERT_TRUE(mLnbTests.setVoltage(lnbMap[lnbLive.lnbId].voltage));
ASSERT_TRUE(mLnbTests.setTone(lnbMap[lnbLive.lnbId].tone));
ASSERT_TRUE(mLnbTests.setSatellitePosition(lnbMap[lnbLive.lnbId].position));
for (auto msgName : lnbLive.diseqcMsgs) {
ASSERT_TRUE(mLnbTests.sendDiseqcMessage(diseqcMsgMap[msgName]));
}
ASSERT_TRUE(mLnbTests.closeLnb());
}
ASSERT_TRUE(mLnbTests.closeLnb());
}
TEST_P(TunerDemuxAidlTest, openDemux) {
@ -839,10 +848,16 @@ TEST_P(TunerFilterAidlTest, FilterDelayHintTest) {
TEST_P(TunerPlaybackAidlTest, PlaybackDataFlowWithTsSectionFilterTest) {
description("Feed ts data from playback and configure Ts section filter to get output");
if (!playback.support || playback.sectionFilterId.compare(emptyHardwareId) == 0) {
if (!playback.support) {
return;
}
playbackSingleFilterTest(filterMap[playback.sectionFilterId], dvrMap[playback.dvrId]);
vector<DvrPlaybackHardwareConnections> playback_configs = generatePlaybackConfigs();
for (auto& configuration : playback_configs) {
if (configuration.sectionFilterId.compare(emptyHardwareId) != 0) {
playback = configuration;
playbackSingleFilterTest(filterMap[playback.sectionFilterId], dvrMap[playback.dvrId]);
}
}
}
TEST_P(TunerPlaybackAidlTest, PlaybackDataFlowWithTsAudioFilterTest) {
@ -850,7 +865,11 @@ TEST_P(TunerPlaybackAidlTest, PlaybackDataFlowWithTsAudioFilterTest) {
if (!playback.support) {
return;
}
playbackSingleFilterTest(filterMap[playback.audioFilterId], dvrMap[playback.dvrId]);
vector<DvrPlaybackHardwareConnections> playback_configs = generatePlaybackConfigs();
for (auto& configuration : playback_configs) {
playback = configuration;
playbackSingleFilterTest(filterMap[playback.audioFilterId], dvrMap[playback.dvrId]);
}
}
TEST_P(TunerPlaybackAidlTest, PlaybackDataFlowWithTsVideoFilterTest) {
@ -858,7 +877,11 @@ TEST_P(TunerPlaybackAidlTest, PlaybackDataFlowWithTsVideoFilterTest) {
if (!playback.support) {
return;
}
playbackSingleFilterTest(filterMap[playback.videoFilterId], dvrMap[playback.dvrId]);
vector<DvrPlaybackHardwareConnections> playback_configs = generatePlaybackConfigs();
for (auto& configuration : playback_configs) {
playback = configuration;
playbackSingleFilterTest(filterMap[playback.videoFilterId], dvrMap[playback.dvrId]);
}
}
TEST_P(TunerRecordAidlTest, RecordDataFlowWithTsRecordFilterTest) {
@ -885,9 +908,17 @@ TEST_P(TunerRecordAidlTest, LnbRecordDataFlowWithTsRecordFilterTest) {
if (!lnbRecord.support) {
return;
}
recordSingleFilterTestWithLnb(filterMap[lnbRecord.recordFilterId],
frontendMap[lnbRecord.frontendId], dvrMap[lnbRecord.dvrRecordId],
lnbMap[lnbRecord.lnbId]);
vector<LnbRecordHardwareConnections> lnbRecord_configs = generateLnbRecordConfigurations();
if (lnbRecord_configs.empty()) {
ALOGD("No frontends that support satellites.");
return;
}
for (auto& configuration : lnbRecord_configs) {
lnbRecord = configuration;
recordSingleFilterTestWithLnb(filterMap[lnbRecord.recordFilterId],
frontendMap[lnbRecord.frontendId],
dvrMap[lnbRecord.dvrRecordId], lnbMap[lnbRecord.lnbId]);
}
}
TEST_P(TunerFrontendAidlTest, TuneFrontend) {
@ -903,7 +934,11 @@ TEST_P(TunerFrontendAidlTest, AutoScanFrontend) {
if (!scan.hasFrontendConnection) {
return;
}
mFrontendTests.scanTest(frontendMap[scan.frontendId], FrontendScanType::SCAN_AUTO);
vector<ScanHardwareConnections> scan_configs = generateScanConfigurations();
for (auto& configuration : scan_configs) {
scan = configuration;
mFrontendTests.scanTest(frontendMap[scan.frontendId], FrontendScanType::SCAN_AUTO);
}
}
TEST_P(TunerFrontendAidlTest, BlindScanFrontend) {
@ -911,7 +946,11 @@ TEST_P(TunerFrontendAidlTest, BlindScanFrontend) {
if (!scan.hasFrontendConnection) {
return;
}
mFrontendTests.scanTest(frontendMap[scan.frontendId], FrontendScanType::SCAN_BLIND);
vector<ScanHardwareConnections> scan_configs = generateScanConfigurations();
for (auto& configuration : scan_configs) {
scan = configuration;
mFrontendTests.scanTest(frontendMap[scan.frontendId], FrontendScanType::SCAN_BLIND);
}
}
TEST_P(TunerFrontendAidlTest, TuneFrontendWithFrontendSettings) {
@ -927,7 +966,11 @@ TEST_P(TunerFrontendAidlTest, BlindScanFrontendWithEndFrequency) {
if (!scan.hasFrontendConnection) {
return;
}
mFrontendTests.scanTest(frontendMap[scan.frontendId], FrontendScanType::SCAN_BLIND);
vector<ScanHardwareConnections> scan_configs = generateScanConfigurations();
for (auto& configuration : scan_configs) {
scan = configuration;
mFrontendTests.scanTest(frontendMap[scan.frontendId], FrontendScanType::SCAN_BLIND);
}
}
TEST_P(TunerFrontendAidlTest, LinkToCiCam) {
@ -1005,8 +1048,16 @@ TEST_P(TunerBroadcastAidlTest, LnbBroadcastDataFlowVideoFilterTest) {
if (!lnbLive.support) {
return;
}
broadcastSingleFilterTestWithLnb(filterMap[lnbLive.videoFilterId],
frontendMap[lnbLive.frontendId], lnbMap[lnbLive.lnbId]);
vector<LnbLiveHardwareConnections> lnbLive_configs = generateLnbLiveConfigurations();
if (lnbLive_configs.empty()) {
ALOGD("No frontends that support satellites.");
return;
}
for (auto& combination : lnbLive_configs) {
lnbLive = combination;
broadcastSingleFilterTestWithLnb(filterMap[lnbLive.videoFilterId],
frontendMap[lnbLive.frontendId], lnbMap[lnbLive.lnbId]);
}
}
TEST_P(TunerBroadcastAidlTest, MediaFilterWithSharedMemoryHandle) {
@ -1022,25 +1073,34 @@ TEST_P(TunerDescramblerAidlTest, CreateDescrambler) {
if (!descrambling.support) {
return;
}
int32_t demuxId;
std::shared_ptr<IDemux> demux;
ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
if (descrambling.hasFrontendConnection) {
int32_t feId;
mFrontendTests.getFrontendIdByType(frontendMap[descrambling.frontendId].type, feId);
ASSERT_TRUE(feId != INVALID_ID);
ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
ASSERT_TRUE(mFrontendTests.setFrontendCallback());
ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
vector<DescramblingHardwareConnections> descrambling_configs =
generateDescramblingConfigurations();
if (descrambling_configs.empty()) {
ALOGD("No valid descrambling combinations in the configuration file.");
return;
}
for (auto& combination : descrambling_configs) {
descrambling = combination;
int32_t demuxId;
std::shared_ptr<IDemux> demux;
ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
ASSERT_TRUE(mDescramblerTests.openDescrambler(demuxId));
ASSERT_TRUE(mDescramblerTests.closeDescrambler());
ASSERT_TRUE(mDemuxTests.closeDemux());
if (descrambling.hasFrontendConnection) {
int32_t feId;
mFrontendTests.getFrontendIdByType(frontendMap[descrambling.frontendId].type, feId);
ASSERT_TRUE(feId != INVALID_ID);
ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
ASSERT_TRUE(mFrontendTests.setFrontendCallback());
ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
}
if (descrambling.hasFrontendConnection) {
ASSERT_TRUE(mFrontendTests.closeFrontend());
ASSERT_TRUE(mDescramblerTests.openDescrambler(demuxId));
ASSERT_TRUE(mDescramblerTests.closeDescrambler());
ASSERT_TRUE(mDemuxTests.closeDemux());
if (descrambling.hasFrontendConnection) {
ASSERT_TRUE(mFrontendTests.closeFrontend());
}
}
}
@ -1049,11 +1109,20 @@ TEST_P(TunerDescramblerAidlTest, ScrambledBroadcastDataFlowMediaFiltersTest) {
if (!descrambling.support) {
return;
}
set<FilterConfig> filterConfs;
filterConfs.insert(static_cast<FilterConfig>(filterMap[descrambling.audioFilterId]));
filterConfs.insert(static_cast<FilterConfig>(filterMap[descrambling.videoFilterId]));
scrambledBroadcastTest(filterConfs, frontendMap[descrambling.frontendId],
descramblerMap[descrambling.descramblerId]);
vector<DescramblingHardwareConnections> descrambling_configs =
generateDescramblingConfigurations();
if (descrambling_configs.empty()) {
ALOGD("No valid descrambling combinations in the configuration file.");
return;
}
for (auto& combination : descrambling_configs) {
descrambling = combination;
set<FilterConfig> filterConfs;
filterConfs.insert(static_cast<FilterConfig>(filterMap[descrambling.audioFilterId]));
filterConfs.insert(static_cast<FilterConfig>(filterMap[descrambling.videoFilterId]));
scrambledBroadcastTest(filterConfs, frontendMap[descrambling.frontendId],
descramblerMap[descrambling.descramblerId]);
}
}
INSTANTIATE_TEST_SUITE_P(PerInstance, TunerBroadcastAidlTest,

5
tv/tuner/aidl/vts/functional/VtsHalTvTunerTargetTest.h
View file

@ -65,11 +65,16 @@ AssertionResult filterDataOutputTestBase(FilterTests& tests) {
}
void clearIds() {
lnbIds.clear();
diseqcMsgs.clear();
frontendIds.clear();
recordDvrIds.clear();
descramblerIds.clear();
audioFilterIds.clear();
videoFilterIds.clear();
playbackDvrIds.clear();
recordFilterIds.clear();
sectionFilterIds.clear();
}
class TunerLnbAidlTest : public testing::TestWithParam<std::string> {

305
tv/tuner/aidl/vts/functional/VtsHalTvTunerTestConfigurations.h
View file

@ -75,6 +75,309 @@ static LnbLiveHardwareConnections lnbLive;
static LnbRecordHardwareConnections lnbRecord;
static TimeFilterHardwareConnections timeFilter;
/*
* This function takes in a 2d vector of device Id's
* The n vectors correlate to the ids for n different devices (eg frontends, filters)
* The resultant 2d vector is every combination of id's with 1 id from each vector
*/
inline vector<vector<string>> generateIdCombinations(vector<vector<string>>& ids) {
vector<vector<string>> combinations;
// The index of each vector in ids that will be used in the next combination
// EG {0, 2} means combo {ids[0][0] ids[1][2]} will be next
const int size = static_cast<int>(ids.size());
vector<int> indexes_used_in_combination(size, 0);
// The vector number from ids whose elements we will cycle through to make combinations.
// First, start at the right most vector
int cycled_vector = size - 1;
while (cycled_vector >= 0) {
// Make a combination (one at a time)
vector<string> combo;
for (size_t i = 0; i < indexes_used_in_combination.size(); ++i) {
const int combo_index = indexes_used_in_combination[i];
combo.push_back(ids[i][combo_index]);
}
combinations.push_back(combo);
// Find the right most vector that still has space [elements left] to cycle through and
// create a combination
while (cycled_vector >= 0 &&
indexes_used_in_combination[cycled_vector] == ids[cycled_vector].size() - 1) {
cycled_vector--;
}
// Use this check to avoid segmentation faults
if (cycled_vector >= 0) {
// Once found, we have a vector we can cycle through, so increase to its next element
indexes_used_in_combination[cycled_vector]++;
// Reset the other vectors to the right to their first element so we can cycle through
// them again with the new element from cycled vector
for (size_t i = cycled_vector + 1; i < indexes_used_in_combination.size(); ++i) {
indexes_used_in_combination[i] = 0;
}
// all the vectors to the right were reset, so we can cycle through them again
// Start at the furthest right vector
cycled_vector = size - 1;
}
}
return combinations;
}
/*
* index 0 - playback dvr
* index 1 - audio filters
* index 2 - video filters
* index 3 - optional section filters
*/
static inline vector<DvrPlaybackHardwareConnections> generatePlaybackCombinations() {
vector<DvrPlaybackHardwareConnections> combinations;
vector<string> sectionFilterIds_optional = sectionFilterIds;
sectionFilterIds_optional.push_back(emptyHardwareId);
vector<vector<string>> deviceIds{playbackDvrIds, audioFilterIds, videoFilterIds,
sectionFilterIds_optional};
const int dvrIndex = 0;
const int audioFilterIndex = 1;
const int videoFilterIndex = 2;
const int sectionFilterIndex = 3;
auto idCombinations = generateIdCombinations(deviceIds);
for (auto& combo : idCombinations) {
DvrPlaybackHardwareConnections mPlayback;
mPlayback.dvrId = combo[dvrIndex];
mPlayback.audioFilterId = combo[audioFilterIndex];
mPlayback.videoFilterId = combo[videoFilterIndex];
mPlayback.sectionFilterId = combo[sectionFilterIndex];
combinations.push_back(mPlayback);
}
return combinations;
}
static inline vector<DvrPlaybackHardwareConnections> generatePlaybackConfigs() {
vector<DvrPlaybackHardwareConnections> playback_configs;
if (configuredPlayback) {
ALOGD("Using DVR playback configuration provided.");
playback_configs = {playback};
} else {
ALOGD("Dvr playback not provided. Generating possible combinations. Consider adding it to "
"the configuration file.");
playback_configs = generatePlaybackCombinations();
}
return playback_configs;
}
/*
* index 0 - frontends
* index 1 - audio filters
* index 2 - video filters
* index 3 - lnbs
*/
static inline vector<LnbLiveHardwareConnections> generateLnbLiveCombinations() {
vector<LnbLiveHardwareConnections> combinations;
vector<vector<string>> deviceIds{frontendIds, audioFilterIds, videoFilterIds, lnbIds};
const int frontendIndex = 0;
const int audioFilterIndex = 1;
const int videoFilterIndex = 2;
const int lnbIndex = 3;
// TODO: Find a better way to vary diseqcMsgs, if at all
auto idCombinations = generateIdCombinations(deviceIds);
for (auto& combo : idCombinations) {
const string feId = combo[frontendIndex];
auto type = frontendMap[feId].type;
if (type == FrontendType::DVBS || type == FrontendType::ISDBS ||
type == FrontendType::ISDBS3) {
LnbLiveHardwareConnections mLnbLive;
mLnbLive.frontendId = feId;
mLnbLive.audioFilterId = combo[audioFilterIndex];
mLnbLive.videoFilterId = combo[videoFilterIndex];
mLnbLive.lnbId = combo[lnbIndex];
mLnbLive.diseqcMsgs = diseqcMsgs;
combinations.push_back(mLnbLive);
}
}
return combinations;
}
static inline vector<LnbLiveHardwareConnections> generateLnbLiveConfigurations() {
vector<LnbLiveHardwareConnections> lnbLive_configs;
if (configuredLnbLive) {
ALOGD("Using LnbLive configuration provided.");
lnbLive_configs = {lnbLive};
} else {
ALOGD("LnbLive not provided. Generating possible combinations. Consider adding it to the "
"configuration file.");
lnbLive_configs = generateLnbLiveCombinations();
}
return lnbLive_configs;
}
static inline vector<ScanHardwareConnections> generateScanCombinations() {
vector<ScanHardwareConnections> combinations;
for (auto& id : frontendIds) {
ScanHardwareConnections mScan;
mScan.frontendId = id;
combinations.push_back(mScan);
}
return combinations;
}
static inline vector<ScanHardwareConnections> generateScanConfigurations() {
vector<ScanHardwareConnections> scan_configs;
if (configuredScan) {
ALOGD("Using scan configuration provided.");
scan_configs = {scan};
} else {
ALOGD("Scan not provided. Generating possible combinations. Consider adding it to "
"the configuration file.");
scan_configs = generateScanCombinations();
}
return scan_configs;
}
/*
* index 0 - frontends
* index 1 - record filter
* index 2 - Record Dvr
* index 3 - Lnb
*/
static inline vector<LnbRecordHardwareConnections> generateLnbRecordCombinations() {
vector<LnbRecordHardwareConnections> combinations;
vector<vector<string>> deviceIds{frontendIds, recordFilterIds, recordDvrIds, lnbIds};
const int frontendIndex = 0;
const int recordFilterIndex = 1;
const int dvrIndex = 2;
const int lnbIndex = 3;
auto idCombinations = generateIdCombinations(deviceIds);
// TODO : Find a better way to vary diseqcMsgs, if at all
for (auto& combo : idCombinations) {
const string feId = combo[frontendIndex];
auto type = frontendMap[feId].type;
if (type == FrontendType::DVBS || type == FrontendType::ISDBS ||
type == FrontendType::ISDBS3) {
LnbRecordHardwareConnections mLnbRecord;
mLnbRecord.frontendId = feId;
mLnbRecord.recordFilterId = combo[recordFilterIndex];
mLnbRecord.dvrRecordId = combo[dvrIndex];
mLnbRecord.lnbId = combo[lnbIndex];
mLnbRecord.diseqcMsgs = diseqcMsgs;
combinations.push_back(mLnbRecord);
}
}
return combinations;
}
static inline vector<LnbRecordHardwareConnections> generateLnbRecordConfigurations() {
vector<LnbRecordHardwareConnections> lnbRecord_configs;
if (configuredLnbRecord) {
ALOGD("Using LnbRecord configuration provided.");
lnbRecord_configs = {lnbRecord};
} else {
ALOGD("LnbRecord not provided. Generating possible combinations. Consider adding it to "
"the configuration file.");
lnbRecord_configs = generateLnbRecordCombinations();
}
return lnbRecord_configs;
}
/*
* index 0 - decramblers
* index 1 - frontends
* index 2 - audio filters
* index 3 - video filters
* index 4 - Dvr SW Fe Connections
* index 5 - DVR Source Connections
*/
static inline vector<DescramblingHardwareConnections> generateDescramblingCombinations() {
vector<DescramblingHardwareConnections> combinations;
vector<string> mfrontendIds = frontendIds;
vector<string> mDvrFeConnectionIds = playbackDvrIds;
vector<string> mDvrSourceConnectionIds = playbackDvrIds;
// Add the empty hardware id to each vector to include combinations where these 3 fields might
// be optional
mfrontendIds.push_back(emptyHardwareId);
mDvrFeConnectionIds.push_back(emptyHardwareId);
mDvrSourceConnectionIds.push_back(emptyHardwareId);
const int descramblerIndex = 0;
const int frontendIndex = 1;
const int audioFilterIndex = 2;
const int videoFilterIndex = 3;
const int dvrFeIdIndex = 4;
const int dvrSourceIdIndex = 5;
vector<vector<string>> deviceIds{descramblerIds, mfrontendIds, audioFilterIds,
videoFilterIds, mDvrFeConnectionIds, mDvrSourceConnectionIds};
auto idCombinations = generateIdCombinations(deviceIds);
for (auto& combo : idCombinations) {
DescramblingHardwareConnections mDescrambling;
const string feId = combo[frontendIndex];
const string dvrSwFeId = combo[dvrFeIdIndex];
const string dvrSourceId = combo[dvrSourceIdIndex];
mDescrambling.hasFrontendConnection = feId.compare(emptyHardwareId) == 0 ? false : true;
if (!mDescrambling.hasFrontendConnection) {
if (dvrSourceId.compare(emptyHardwareId) == 0) {
// If combination does not have a frontend or dvr source connection, do not include
// it
continue;
}
} else {
if (frontendMap[feId].isSoftwareFe && dvrSwFeId.compare(emptyHardwareId) == 0) {
// If combination has a software frontend and no dvr->software frontend connection,
// do not include it
continue;
}
}
if (dvrSwFeId.compare(dvrSourceId) == 0) {
// If dvr->software frontend connection is the same as dvr source input to tuner, do not
// include it.
continue;
}
mDescrambling.frontendId = feId;
mDescrambling.audioFilterId = combo[audioFilterIndex];
mDescrambling.videoFilterId = combo[videoFilterIndex];
mDescrambling.dvrSoftwareFeId = dvrSwFeId;
mDescrambling.dvrSourceId = dvrSourceId;
mDescrambling.descramblerId = combo[descramblerIndex];
combinations.push_back(mDescrambling);
}
return combinations;
}
static inline vector<DescramblingHardwareConnections> generateDescramblingConfigurations() {
vector<DescramblingHardwareConnections> descrambling_configs;
if (configuredDescrambling) {
ALOGD("Using Descrambling configuration provided.");
descrambling_configs = {descrambling};
} else {
ALOGD("Descrambling not provided. Generating possible combinations. Consider adding it to "
"the "
"configuration file.");
descrambling_configs = generateDescramblingCombinations();
}
return descrambling_configs;
}
/** Config all the frontends that would be used in the tests */
inline void initFrontendConfig() {
// The test will use the internal default fe when default fe is connected to any data flow
@ -252,7 +555,7 @@ inline void determineDvrRecord() {
return;
}
if (frontendMap.empty() && playbackDvrIds.empty()) {
ALOGD("Cannot support dvr record. No frontends and no playback dvr's");
ALOGD("Cannot support dvr record. No frontends and no playback dvr's");
return;
}
if (hasSwFe && !hasHwFe && playbackDvrIds.empty()) {

11
tv/tuner/config/TunerTestingConfigAidlReaderV1_0.h
View file

@ -83,6 +83,11 @@ static vector<string> recordDvrIds;
static vector<string> audioFilterIds;
static vector<string> videoFilterIds;
static vector<string> recordFilterIds;
static vector<string> sectionFilterIds;
static vector<string> frontendIds;
static vector<string> lnbIds;
static vector<string> diseqcMsgs;
static vector<string> descramblerIds;
#define PROVISION_STR \
"{ " \
@ -268,6 +273,7 @@ struct TunerTestingConfigAidlReader1_0 {
auto frontends = *hardwareConfig.getFirstFrontends();
for (auto feConfig : frontends.getFrontend()) {
string id = feConfig.getId();
frontendIds.push_back(id);
if (id.compare(string("FE_DEFAULT")) == 0) {
// overrid default
frontendMap.erase(string("FE_DEFAULT"));
@ -438,6 +444,7 @@ struct TunerTestingConfigAidlReader1_0 {
auto lnbs = *hardwareConfig.getFirstLnbs();
for (auto lnbConfig : lnbs.getLnb()) {
string id = lnbConfig.getId();
lnbIds.push_back(id);
if (lnbConfig.hasName()) {
lnbMap[id].name = lnbConfig.getName();
} else {
@ -456,6 +463,7 @@ struct TunerTestingConfigAidlReader1_0 {
auto descramblers = *hardwareConfig.getFirstDescramblers();
for (auto descramblerConfig : descramblers.getDescrambler()) {
string id = descramblerConfig.getId();
descramblerIds.push_back(id);
descramblerMap[id].casSystemId =
static_cast<int32_t>(descramblerConfig.getCasSystemId());
if (descramblerConfig.hasProvisionStr()) {
@ -481,6 +489,7 @@ struct TunerTestingConfigAidlReader1_0 {
auto msgs = *hardwareConfig.getFirstDiseqcMessages();
for (auto msgConfig : msgs.getDiseqcMessage()) {
string name = msgConfig.getMsgName();
diseqcMsgs.push_back(name);
for (uint8_t atom : msgConfig.getMsgBody()) {
diseqcMsgMap[name].push_back(atom);
}
@ -840,6 +849,8 @@ struct TunerTestingConfigAidlReader1_0 {
videoFilterIds.push_back(filterConfig.getId());
} else if (subType == FilterSubTypeEnum::RECORD) {
recordFilterIds.push_back(filterConfig.getId());
} else if (subType == FilterSubTypeEnum::SECTION) {
sectionFilterIds.push_back(filterConfig.getId());
}
switch (mainType) {