Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e3073c56 authored by Amy Zhang's avatar Amy Zhang Committed by Automerger Merge Worker
Browse files

Add filter dynamic configuration into Tuner 1.0 VTS am: 1d603678 

Original change: https://android-review.googlesource.com/c/platform/hardware/interfaces/+/1670260

Change-Id: If2a846417f0346f1a21b3b28cf8141a327bbdb38
parents 8743a66d 1d603678

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

+33 −22
Original line number Diff line number Diff line
@@ -394,6 +394,9 @@ TEST_P(TunerDemuxHidlTest, openDemux) { 


TEST_P(TunerDemuxHidlTest, getAvSyncTime) {

    description("Get the A/V sync time from a PCR filter.");

    if (live.pcrFilterId.compare(emptyHardwareId) == 0) {

        return;

    }

    uint32_t feId;

    uint32_t demuxId;

    sp<IDemux> demux;
@@ -409,15 +412,15 @@ TEST_P(TunerDemuxHidlTest, getAvSyncTime) { 
    ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));

    ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));

    mFilterTests.setDemux(demux);

    ASSERT_TRUE(mFilterTests.openFilterInDemux(filterArray[TS_VIDEO1].type,

                                               filterArray[TS_VIDEO1].bufferSize));

    ASSERT_TRUE(mFilterTests.openFilterInDemux(filterMap[live.videoFilterId].type,

                                               filterMap[live.videoFilterId].bufferSize));

    ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId(mediaFilterId));

    ASSERT_TRUE(mFilterTests.configFilter(filterArray[TS_VIDEO1].settings, mediaFilterId));

    ASSERT_TRUE(mFilterTests.configFilter(filterMap[live.videoFilterId].settings, mediaFilterId));

    mediaFilter = mFilterTests.getFilterById(mediaFilterId);

    ASSERT_TRUE(mFilterTests.openFilterInDemux(filterArray[TS_PCR0].type,

                                               filterArray[TS_PCR0].bufferSize));

    ASSERT_TRUE(mFilterTests.openFilterInDemux(filterMap[live.pcrFilterId].type,

                                               filterMap[live.pcrFilterId].bufferSize));

    ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId(pcrFilterId));

    ASSERT_TRUE(mFilterTests.configFilter(filterArray[TS_PCR0].settings, pcrFilterId));

    ASSERT_TRUE(mFilterTests.configFilter(filterMap[live.pcrFilterId].settings, pcrFilterId));

    ASSERT_TRUE(mDemuxTests.getAvSyncId(mediaFilter, avSyncHwId));

    ASSERT_TRUE(pcrFilterId == avSyncHwId);

    ASSERT_TRUE(mDemuxTests.getAvSyncTime(pcrFilterId));
@@ -430,7 +433,7 @@ TEST_P(TunerDemuxHidlTest, getAvSyncTime) { 
TEST_P(TunerFilterHidlTest, StartFilterInDemux) {

    description("Open and start a filter in Demux.");

    // TODO use paramterized tests

    configSingleFilterInDemuxTest(filterArray[TS_VIDEO0], frontendMap[live.frontendId]);

    configSingleFilterInDemuxTest(filterMap[live.videoFilterId], frontendMap[live.frontendId]);

}



TEST_P(TunerFilterHidlTest, SetFilterLinkage) {
@@ -471,35 +474,42 @@ TEST_P(TunerFilterHidlTest, testTimeFilter) { 


TEST_P(TunerBroadcastHidlTest, BroadcastDataFlowVideoFilterTest) {

    description("Test Video Filter functionality in Broadcast use case.");

    broadcastSingleFilterTest(filterArray[TS_VIDEO1], frontendMap[live.frontendId]);

    broadcastSingleFilterTest(filterMap[live.videoFilterId], frontendMap[live.frontendId]);

}



TEST_P(TunerBroadcastHidlTest, BroadcastDataFlowAudioFilterTest) {

    description("Test Audio Filter functionality in Broadcast use case.");

    broadcastSingleFilterTest(filterArray[TS_AUDIO0], frontendMap[live.frontendId]);

    broadcastSingleFilterTest(filterMap[live.audioFilterId], frontendMap[live.frontendId]);

}



TEST_P(TunerBroadcastHidlTest, BroadcastDataFlowSectionFilterTest) {

    description("Test Section Filter functionality in Broadcast use case.");

    broadcastSingleFilterTest(filterArray[TS_SECTION0], frontendMap[live.frontendId]);

    if (live.sectionFilterId.compare(emptyHardwareId) == 0) {

        return;

    }

    broadcastSingleFilterTest(filterMap[live.sectionFilterId], frontendMap[live.frontendId]);

}



TEST_P(TunerBroadcastHidlTest, IonBufferTest) {

    description("Test the av filter data bufferring.");

    broadcastSingleFilterTest(filterArray[TS_VIDEO0], frontendMap[live.frontendId]);

    broadcastSingleFilterTest(filterMap[live.videoFilterId], frontendMap[live.frontendId]);

}



TEST_P(TunerBroadcastHidlTest, LnbBroadcastDataFlowVideoFilterTest) {

    description("Test Video Filter functionality in Broadcast with Lnb use case.");

    broadcastSingleFilterTest(filterArray[TS_VIDEO0], frontendMap[live.frontendId]);

    if (!lnbLive.support) {

        return;

    }

    broadcastSingleFilterTestWithLnb(filterMap[lnbLive.videoFilterId],

                                     frontendMap[lnbLive.frontendId], lnbArray[LNB0]);

}



TEST_P(TunerPlaybackHidlTest, PlaybackDataFlowWithTsSectionFilterTest) {

    description("Feed ts data from playback and configure Ts section filter to get output");

    if (!playback.support) {

    if (!playback.support || playback.sectionFilterId.compare(emptyHardwareId) == 0) {

        return;

    }

    playbackSingleFilterTest(filterArray[TS_SECTION0], dvrMap[playback.dvrId]);

    playbackSingleFilterTest(filterMap[playback.sectionFilterId], dvrMap[playback.dvrId]);

}



TEST_P(TunerRecordHidlTest, AttachFiltersToRecordTest) {
@@ -508,8 +518,8 @@ TEST_P(TunerRecordHidlTest, AttachFiltersToRecordTest) { 
    if (!record.support) {

        return;

    }

    attachSingleFilterToRecordDvrTest(filterArray[TS_RECORD0], frontendMap[record.frontendId],

                                      dvrMap[record.dvrRecordId]);

    attachSingleFilterToRecordDvrTest(filterMap[record.recordFilterId],

                                      frontendMap[record.frontendId], dvrMap[record.dvrRecordId]);

}



TEST_P(TunerRecordHidlTest, RecordDataFlowWithTsRecordFilterTest) {
@@ -517,17 +527,18 @@ TEST_P(TunerRecordHidlTest, RecordDataFlowWithTsRecordFilterTest) { 
    if (!record.support) {

        return;

    }

    recordSingleFilterTest(filterArray[TS_RECORD0], frontendMap[record.frontendId],

    recordSingleFilterTest(filterMap[record.recordFilterId], frontendMap[record.frontendId],

                           dvrMap[record.dvrRecordId]);

}



TEST_P(TunerRecordHidlTest, LnbRecordDataFlowWithTsRecordFilterTest) {

    description("Feed ts data from Fe with Lnb to recording and test with ts record filter");

    if (record.support) {

    if (lnbRecord.support) {

        return;

    }

    recordSingleFilterTestWithLnb(filterArray[TS_RECORD0], frontendMap[lnbRecord.frontendId],

                                  dvrMap[record.dvrRecordId], lnbArray[LNB0]);

    recordSingleFilterTestWithLnb(filterMap[lnbRecord.recordFilterId],

                                  frontendMap[lnbRecord.frontendId], dvrMap[lnbRecord.dvrRecordId],

                                  lnbArray[LNB0]);

}



TEST_P(TunerDescramblerHidlTest, CreateDescrambler) {
@@ -556,8 +567,8 @@ TEST_P(TunerDescramblerHidlTest, ScrambledBroadcastDataFlowMediaFiltersTest) { 
        return;

    }

    set<FilterConfig> filterConfs;

    filterConfs.insert(filterArray[TS_AUDIO0]);

    filterConfs.insert(filterArray[TS_VIDEO1]);

    filterConfs.insert(static_cast<FilterConfig>(filterMap[descrambling.audioFilterId]));

    filterConfs.insert(static_cast<FilterConfig>(filterMap[descrambling.videoFilterId]));

    scrambledBroadcastTest(filterConfs, frontendMap[descrambling.frontendId],

                           descramblerArray[DESC_0]);

}

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

+1 −1
Original line number Diff line number Diff line
@@ -33,6 +33,7 @@ bool initConfiguration() { 
        return false;

    }

    initFrontendConfig();

    initFilterConfig();

    initDvrConfig();

    connectHardwaresToTestCases();

    if (!validateConnections()) {
@@ -41,7 +42,6 @@ bool initConfiguration() { 
    }



    initLnbConfig();

    initFilterConfig();

    initTimeFilterConfig();

    initDescramblerConfig();

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

+51 −102
Original line number Diff line number Diff line
@@ -79,18 +79,6 @@ const uint32_t FMQ_SIZE_16M = 0x1000000; 
    "  \"track_types\": [ ]                              " \

    "}                                                   "



typedef enum {

    TS_VIDEO0,

    TS_VIDEO1,

    TS_AUDIO0,

    TS_PES0,

    TS_PCR0,

    TS_SECTION0,

    TS_TS0,

    TS_RECORD0,

    FILTER_MAX,

} Filter;



typedef enum {

    TIMER0,

    TIMER_MAX,
@@ -118,15 +106,6 @@ typedef enum { 
    DESC_MAX,

} Descrambler;



struct FilterConfig {

    uint32_t bufferSize;

    DemuxFilterType type;

    DemuxFilterSettings settings;

    bool getMqDesc;



    bool operator<(const FilterConfig& /*c*/) const { return false; }

};



struct TimeFilterConfig {

    bool supportTimeFilter;

    uint64_t timeStamp;
@@ -149,13 +128,13 @@ struct DescramblerConfig { 
// TODO: remove all the manual config array after the dynamic config refactoring is done.

static LnbConfig lnbArray[LNB_MAX];

static vector<uint8_t> diseqcMsgArray[DISEQC_MAX];

static FilterConfig filterArray[FILTER_MAX];

static TimeFilterConfig timeFilterArray[TIMER_MAX];

static DemuxFilterType filterLinkageTypes[LINKAGE_DIR][FILTER_MAIN_TYPE_BIT_COUNT];

static DescramblerConfig descramblerArray[DESC_MAX];



// Hardware configs

static map<string, FrontendConfig> frontendMap;

static map<string, FilterConfig> filterMap;

static map<string, DvrConfig> dvrMap;



// Hardware and test cases connections
@@ -195,6 +174,28 @@ inline void initFrontendConfig() { 
    TunerTestingConfigReader::readFrontendConfig1_0(frontendMap);

};



inline void initFilterConfig() {

    // The test will use the internal default filter when default filter is connected to any

    // data flow without overriding in the xml config.

    string defaultAudioFilterId = "FILTER_AUDIO_DEFAULT";

    string defaultVideoFilterId = "FILTER_VIDEO_DEFAULT";



    filterMap[defaultVideoFilterId].type.mainType = DemuxFilterMainType::TS;

    filterMap[defaultVideoFilterId].type.subType.tsFilterType(DemuxTsFilterType::VIDEO);

    filterMap[defaultVideoFilterId].bufferSize = FMQ_SIZE_16M;

    filterMap[defaultVideoFilterId].settings.ts().tpid = 256;

    filterMap[defaultVideoFilterId].settings.ts().filterSettings.av({.isPassthrough = false});



    filterMap[defaultAudioFilterId].type.mainType = DemuxFilterMainType::TS;

    filterMap[defaultAudioFilterId].type.subType.tsFilterType(DemuxTsFilterType::AUDIO);

    filterMap[defaultAudioFilterId].bufferSize = FMQ_SIZE_16M;

    filterMap[defaultAudioFilterId].settings.ts().tpid = 256;

    filterMap[defaultAudioFilterId].settings.ts().filterSettings.av({.isPassthrough = false});



    // Read customized config

    TunerTestingConfigReader::readFilterConfig1_0(filterMap);

};



/** Config all the dvrs that would be used in the tests */

inline void initDvrConfig() {

    // Read customized config
@@ -249,6 +250,34 @@ inline bool validateConnections() { 
        return false;

    }



    bool filterIsValid = filterMap.find(live.audioFilterId) != filterMap.end() &&

                         filterMap.find(live.videoFilterId) != filterMap.end();



    filterIsValid &= playback.support

                             ? (filterMap.find(playback.audioFilterId) != filterMap.end() &&

                                filterMap.find(playback.videoFilterId) != filterMap.end())

                             : true;



    filterIsValid &=

            record.support ? filterMap.find(record.recordFilterId) != filterMap.end() : true;



    filterIsValid &= descrambling.support

                             ? (filterMap.find(descrambling.audioFilterId) != filterMap.end() &&

                                filterMap.find(descrambling.videoFilterId) != filterMap.end())

                             : true;



    filterIsValid &= lnbLive.support ? (filterMap.find(lnbLive.audioFilterId) != filterMap.end() &&

                                        filterMap.find(lnbLive.videoFilterId) != filterMap.end())

                                     : true;



    filterIsValid &=

            lnbRecord.support ? filterMap.find(lnbRecord.recordFilterId) != filterMap.end() : true;



    if (!filterIsValid) {

        ALOGW("[vts config] dynamic config filter connection is invalid.");

        return false;

    }



    return true;

}
@@ -271,86 +300,6 @@ inline void initDiseqcMsg() { 
    diseqcMsgArray[DISEQC_POWER_ON] = {0xE, 0x0, 0x0, 0x0, 0x0, 0x3};

};



/** Configuration array for the filter test */

inline void initFilterConfig() {

    // TS VIDEO filter setting for default implementation testing

    filterArray[TS_VIDEO0].type.mainType = DemuxFilterMainType::TS;

    filterArray[TS_VIDEO0].type.subType.tsFilterType(DemuxTsFilterType::VIDEO);

    filterArray[TS_VIDEO0].bufferSize = FMQ_SIZE_16M;

    filterArray[TS_VIDEO0].settings.ts().tpid = 256;

    filterArray[TS_VIDEO0].settings.ts().filterSettings.av({.isPassthrough = false});

    filterArray[TS_VIDEO1].type.mainType = DemuxFilterMainType::TS;

    filterArray[TS_VIDEO1].type.subType.tsFilterType(DemuxTsFilterType::VIDEO);

    filterArray[TS_VIDEO1].bufferSize = FMQ_SIZE_16M;

    filterArray[TS_VIDEO1].settings.ts().tpid = 256;

    filterArray[TS_VIDEO1].settings.ts().filterSettings.av({.isPassthrough = false});

    // TS AUDIO filter setting

    filterArray[TS_AUDIO0].type.mainType = DemuxFilterMainType::TS;

    filterArray[TS_AUDIO0].type.subType.tsFilterType(DemuxTsFilterType::AUDIO);

    filterArray[TS_AUDIO0].bufferSize = FMQ_SIZE_16M;

    filterArray[TS_AUDIO0].settings.ts().tpid = 256;

    filterArray[TS_AUDIO0].settings.ts().filterSettings.av({.isPassthrough = false});

    // TS PES filter setting

    filterArray[TS_PES0].type.mainType = DemuxFilterMainType::TS;

    filterArray[TS_PES0].type.subType.tsFilterType(DemuxTsFilterType::PES);

    filterArray[TS_PES0].bufferSize = FMQ_SIZE_16M;

    filterArray[TS_PES0].settings.ts().tpid = 256;

    filterArray[TS_PES0].settings.ts().filterSettings.pesData({

            .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);

    filterArray[TS_PCR0].bufferSize = FMQ_SIZE_16M;

    filterArray[TS_PCR0].settings.ts().tpid = 256;

    filterArray[TS_PCR0].settings.ts().filterSettings.noinit();

    // TS filter setting

    filterArray[TS_TS0].type.mainType = DemuxFilterMainType::TS;

    filterArray[TS_TS0].type.subType.tsFilterType(DemuxTsFilterType::TS);

    filterArray[TS_TS0].bufferSize = FMQ_SIZE_16M;

    filterArray[TS_TS0].settings.ts().tpid = 256;

    filterArray[TS_TS0].settings.ts().filterSettings.noinit();

    // TS SECTION filter setting

    filterArray[TS_SECTION0].type.mainType = DemuxFilterMainType::TS;

    filterArray[TS_SECTION0].type.subType.tsFilterType(DemuxTsFilterType::SECTION);

    filterArray[TS_SECTION0].bufferSize = FMQ_SIZE_16M;

    filterArray[TS_SECTION0].settings.ts().tpid = 256;

    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);

    filterArray[TS_RECORD0].settings.ts().tpid = 81;

    filterArray[TS_RECORD0].settings.ts().filterSettings.record({

            .scIndexType = DemuxRecordScIndexType::NONE,

    });



    // TS Linkage filter setting

    filterLinkageTypes[SOURCE][0].mainType = DemuxFilterMainType::TS;

    filterLinkageTypes[SOURCE][0].subType.tsFilterType(DemuxTsFilterType::TS);

    filterLinkageTypes[SINK][0] = filterLinkageTypes[SOURCE][0];

    // MMTP Linkage filter setting

    filterLinkageTypes[SOURCE][1].mainType = DemuxFilterMainType::MMTP;

    filterLinkageTypes[SOURCE][1].subType.mmtpFilterType(DemuxMmtpFilterType::AUDIO);

    filterLinkageTypes[SINK][1] = filterLinkageTypes[SOURCE][1];

    // IP Linkage filter setting

    filterLinkageTypes[SOURCE][2].mainType = DemuxFilterMainType::IP;

    filterLinkageTypes[SOURCE][2].subType.ipFilterType(DemuxIpFilterType::IP);

    filterLinkageTypes[SINK][2] = filterLinkageTypes[SOURCE][2];

    // TLV Linkage filter setting

    filterLinkageTypes[SOURCE][3].mainType = DemuxFilterMainType::TLV;

    filterLinkageTypes[SOURCE][3].subType.tlvFilterType(DemuxTlvFilterType::TLV);

    filterLinkageTypes[SINK][3] = filterLinkageTypes[SOURCE][3];

    // ALP Linkage PTP filter setting

    filterLinkageTypes[SOURCE][4].mainType = DemuxFilterMainType::ALP;

    filterLinkageTypes[SOURCE][4].subType.alpFilterType(DemuxAlpFilterType::PTP);

    filterLinkageTypes[SINK][4] = filterLinkageTypes[SOURCE][4];

};



/** Configuration array for the timer filter test */

inline void initTimeFilterConfig() {

    timeFilterArray[TIMER0].supportTimeFilter = true;

tv/tuner/config/TunerTestingConfigReader.h

+261 −43

File changed.

Preview size limit exceeded, changes collapsed.

tv/tuner/config/api/current.txt

+107 −0

File changed.

Preview size limit exceeded, changes collapsed.