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

Commit 016d01a9 authored by Amy Zhang's avatar Amy Zhang Committed by Android (Google) Code Review
Browse files

Merge "Add filter dynamic configuration into Tuner 1.0 VTS" into sc-dev

parents b6499702 2ea2fe2e

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 −108
Original line number Diff line number Diff line
@@ -79,19 +79,6 @@ const uint32_t FMQ_SIZE_16M = 0x1000000; 
    "  \"track_types\": [ ]                              " \

    "}                                                   "



typedef enum {

    TS_VIDEO0,

    TS_VIDEO1,

    TS_AUDIO0,

    TS_AUDIO1,

    TS_PES0,

    TS_PCR0,

    TS_SECTION0,

    TS_TS0,

    TS_RECORD0,

    FILTER_MAX,

} Filter;



typedef enum {

    TIMER0,

    TIMER_MAX,
@@ -119,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;
@@ -150,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
@@ -196,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
@@ -250,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;

}
@@ -272,91 +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});

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

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

    filterArray[TS_AUDIO1].bufferSize = FMQ_SIZE_16M;

    filterArray[TS_AUDIO1].settings.ts().tpid = 257;

    filterArray[TS_AUDIO1].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.