From 4f6980571a8430eb0c13c033822c470c0aa66a1b Mon Sep 17 00:00:00 2001 From: Amy Zhang Date: Tue, 7 Apr 2020 13:43:05 -0700 Subject: [PATCH] Separate Demux and Filter fixture classes from the Tuner HAL VTS target test Test: atest VtsHalTvTunerV1_0TargetTest Bug: 150953857 Change-Id: I373c3ba56ab80e02c79d24f865a956dae4b44226 --- tv/tuner/1.0/vts/functional/Android.bp | 2 + tv/tuner/1.0/vts/functional/DemuxTests.cpp | 41 ++ tv/tuner/1.0/vts/functional/DemuxTests.h | 57 +++ tv/tuner/1.0/vts/functional/FilterTests.cpp | 226 +++++++++++ tv/tuner/1.0/vts/functional/FilterTests.h | 226 +++++++++++ tv/tuner/1.0/vts/functional/FrontendTests.cpp | 2 +- tv/tuner/1.0/vts/functional/FrontendTests.h | 3 - .../VtsHalTvTunerV1_0TargetTest.cpp | 363 +++--------------- .../functional/VtsHalTvTunerV1_0TargetTest.h | 199 +++------- 9 files changed, 663 insertions(+), 456 deletions(-) create mode 100644 tv/tuner/1.0/vts/functional/DemuxTests.cpp create mode 100644 tv/tuner/1.0/vts/functional/DemuxTests.h create mode 100644 tv/tuner/1.0/vts/functional/FilterTests.cpp create mode 100644 tv/tuner/1.0/vts/functional/FilterTests.h diff --git a/tv/tuner/1.0/vts/functional/Android.bp b/tv/tuner/1.0/vts/functional/Android.bp index b4dbda7896..448575ea7a 100644 --- a/tv/tuner/1.0/vts/functional/Android.bp +++ b/tv/tuner/1.0/vts/functional/Android.bp @@ -20,6 +20,8 @@ cc_test { srcs: [ "VtsHalTvTunerV1_0TargetTest.cpp", "FrontendTests.cpp", + "DemuxTests.cpp", + "FilterTests.cpp", ], static_libs: [ "android.hardware.tv.tuner@1.0", diff --git a/tv/tuner/1.0/vts/functional/DemuxTests.cpp b/tv/tuner/1.0/vts/functional/DemuxTests.cpp new file mode 100644 index 0000000000..b1d8a0a0b2 --- /dev/null +++ b/tv/tuner/1.0/vts/functional/DemuxTests.cpp @@ -0,0 +1,41 @@ +/* + * Copyright 2020 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "DemuxTests.h" + +AssertionResult DemuxTests::openDemux(sp& demux, uint32_t& demuxId) { + Result status; + mService->openDemux([&](Result result, uint32_t id, const sp& demuxSp) { + mDemux = demuxSp; + demux = demuxSp; + demuxId = id; + status = result; + }); + return AssertionResult(status == Result::SUCCESS); +} + +AssertionResult DemuxTests::setDemuxFrontendDataSource(uint32_t frontendId) { + EXPECT_TRUE(mDemux) << "Test with openDemux first."; + auto status = mDemux->setFrontendDataSource(frontendId); + return AssertionResult(status.isOk()); +} + +AssertionResult DemuxTests::closeDemux() { + EXPECT_TRUE(mDemux) << "Test with openDemux first."; + auto status = mDemux->close(); + mDemux = nullptr; + return AssertionResult(status.isOk()); +} \ No newline at end of file diff --git a/tv/tuner/1.0/vts/functional/DemuxTests.h b/tv/tuner/1.0/vts/functional/DemuxTests.h new file mode 100644 index 0000000000..f405a79ae8 --- /dev/null +++ b/tv/tuner/1.0/vts/functional/DemuxTests.h @@ -0,0 +1,57 @@ +/* + * Copyright 2020 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using android::sp; +using android::hardware::Return; +using android::hardware::Void; +using android::hardware::tv::tuner::V1_0::IDemux; +using android::hardware::tv::tuner::V1_0::ITuner; +using android::hardware::tv::tuner::V1_0::Result; + +using ::testing::AssertionResult; + +class DemuxTests { + public: + sp mService; + + void setService(sp tuner) { mService = tuner; } + + AssertionResult openDemux(sp& demux, uint32_t& demuxId); + AssertionResult setDemuxFrontendDataSource(uint32_t frontendId); + AssertionResult closeDemux(); + + protected: + static AssertionResult failure() { return ::testing::AssertionFailure(); } + + static AssertionResult success() { return ::testing::AssertionSuccess(); } + + sp mDemux; +}; \ No newline at end of file diff --git a/tv/tuner/1.0/vts/functional/FilterTests.cpp b/tv/tuner/1.0/vts/functional/FilterTests.cpp new file mode 100644 index 0000000000..82e955d90e --- /dev/null +++ b/tv/tuner/1.0/vts/functional/FilterTests.cpp @@ -0,0 +1,226 @@ +/* + * Copyright 2020 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "FilterTests.h" + +void FilterCallback::startFilterEventThread(DemuxFilterEvent event) { + struct FilterThreadArgs* threadArgs = + (struct FilterThreadArgs*)malloc(sizeof(struct FilterThreadArgs)); + threadArgs->user = this; + threadArgs->event = event; + + pthread_create(&mFilterThread, NULL, __threadLoopFilter, (void*)threadArgs); + pthread_setname_np(mFilterThread, "test_playback_input_loop"); +} + +void FilterCallback::testFilterDataOutput() { + android::Mutex::Autolock autoLock(mMsgLock); + while (mPidFilterOutputCount < 1) { + if (-ETIMEDOUT == mMsgCondition.waitRelative(mMsgLock, WAIT_TIMEOUT)) { + EXPECT_TRUE(false) << "filter output matching pid does not output within timeout"; + return; + } + } + mPidFilterOutputCount = 0; + ALOGW("[vts] pass and stop"); +} + +void FilterCallback::updateFilterMQ(MQDesc& filterMQDescriptor) { + mFilterMQ = std::make_unique(filterMQDescriptor, true /* resetPointers */); + EXPECT_TRUE(mFilterMQ); + EXPECT_TRUE(EventFlag::createEventFlag(mFilterMQ->getEventFlagWord(), &mFilterMQEventFlag) == + android::OK); +} + +void FilterCallback::updateGoldenOutputMap(string goldenOutputFile) { + mFilterIdToGoldenOutput = goldenOutputFile; +} + +void* FilterCallback::__threadLoopFilter(void* threadArgs) { + FilterCallback* const self = + static_cast(((struct FilterThreadArgs*)threadArgs)->user); + self->filterThreadLoop(((struct FilterThreadArgs*)threadArgs)->event); + return 0; +} + +void FilterCallback::filterThreadLoop(DemuxFilterEvent& /* event */) { + android::Mutex::Autolock autoLock(mFilterOutputLock); + // Read from mFilterMQ[event.filterId] per event and filter type + + // Assemble to filterOutput[filterId] + + // check if filterOutput[filterId] matches goldenOutput[filterId] + + // If match, remove filterId entry from MQ map + + // end thread +} + +bool FilterCallback::readFilterEventData() { + bool result = false; + DemuxFilterEvent filterEvent = mFilterEvent; + ALOGW("[vts] reading from filter FMQ or buffer %d", mFilterId); + // todo separate filter handlers + for (int i = 0; i < filterEvent.events.size(); i++) { + switch (mFilterEventType) { + case FilterEventType::SECTION: + mDataLength = filterEvent.events[i].section().dataLength; + break; + case FilterEventType::PES: + mDataLength = filterEvent.events[i].pes().dataLength; + break; + case FilterEventType::MEDIA: + return dumpAvData(filterEvent.events[i].media()); + case FilterEventType::RECORD: + break; + case FilterEventType::MMTPRECORD: + break; + case FilterEventType::DOWNLOAD: + break; + default: + break; + } + // 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"; + + /*for (int i = 0; i < mDataLength; i++) { + EXPECT_TRUE(goldenDataOutputBuffer[i] == mDataOutputBuffer[i]) << "data does not match"; + }*/ + } + mFilterMQEventFlag->wake(static_cast(DemuxQueueNotifyBits::DATA_CONSUMED)); + return result; +} + +bool FilterCallback::dumpAvData(DemuxFilterMediaEvent event) { + uint32_t length = event.dataLength; + uint64_t dataId = event.avDataId; + // read data from buffer pointed by a handle + hidl_handle handle = event.avMemory; + + int av_fd = handle.getNativeHandle()->data[0]; + uint8_t* buffer = static_cast( + mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_SHARED, av_fd, 0 /*offset*/)); + if (buffer == MAP_FAILED) { + ALOGE("[vts] fail to allocate av buffer, errno=%d", errno); + return false; + } + uint8_t output[length + 1]; + memcpy(output, buffer, length); + // print buffer and check with golden output. + EXPECT_TRUE(mFilter->releaseAvHandle(handle, dataId) == Result::SUCCESS); + return true; +} + +AssertionResult FilterTests::openFilterInDemux(DemuxFilterType type) { + Result status; + EXPECT_TRUE(mDemux) << "Test with openDemux first."; + + // Create demux callback + mFilterCallback = new FilterCallback(); + + // Add filter to the local demux + mDemux->openFilter(type, FMQ_SIZE_16M, mFilterCallback, + [&](Result result, const sp& filter) { + mFilter = filter; + status = result; + }); + + if (status == Result::SUCCESS) { + mFilterCallback->setFilterEventType(getFilterEventType(type)); + } + + return AssertionResult(status == Result::SUCCESS); +} + +AssertionResult FilterTests::getNewlyOpenedFilterId(uint32_t& filterId) { + Result status; + EXPECT_TRUE(mDemux) << "Test with openDemux first."; + EXPECT_TRUE(mFilter) << "Test with openFilterInDemux first."; + EXPECT_TRUE(mFilterCallback) << "Test with openFilterInDemux first."; + + mFilter->getId([&](Result result, uint32_t filterId) { + mFilterId = filterId; + status = result; + }); + + if (status == Result::SUCCESS) { + mFilterCallback->setFilterId(mFilterId); + mFilterCallback->setFilterInterface(mFilter); + mUsedFilterIds.insert(mUsedFilterIds.end(), mFilterId); + mFilters[mFilterId] = mFilter; + mFilterCallbacks[mFilterId] = mFilterCallback; + filterId = mFilterId; + } + + return AssertionResult(status == Result::SUCCESS); +} + +AssertionResult FilterTests::configFilter(DemuxFilterSettings setting, uint32_t filterId) { + Result status; + EXPECT_TRUE(mFilters[filterId]) << "Test with getNewlyOpenedFilterId first."; + status = mFilters[filterId]->configure(setting); + + return AssertionResult(status == Result::SUCCESS); +} + +AssertionResult FilterTests::getFilterMQDescriptor(uint32_t filterId) { + Result status; + EXPECT_TRUE(mFilters[filterId]) << "Test with getNewlyOpenedFilterId first."; + EXPECT_TRUE(mFilterCallbacks[filterId]) << "Test with getNewlyOpenedFilterId first."; + + mFilter->getQueueDesc([&](Result result, const MQDesc& filterMQDesc) { + mFilterMQDescriptor = filterMQDesc; + status = result; + }); + + if (status == Result::SUCCESS) { + mFilterCallbacks[filterId]->updateFilterMQ(mFilterMQDescriptor); + } + + return AssertionResult(status == Result::SUCCESS); +} + +AssertionResult FilterTests::startFilter(uint32_t filterId) { + EXPECT_TRUE(mFilters[filterId]) << "Test with getNewlyOpenedFilterId first."; + Result status = mFilters[filterId]->start(); + return AssertionResult(status == Result::SUCCESS); +} + +AssertionResult FilterTests::stopFilter(uint32_t filterId) { + EXPECT_TRUE(mFilters[filterId]) << "Test with getNewlyOpenedFilterId first."; + Result status = mFilters[filterId]->stop(); + return AssertionResult(status == Result::SUCCESS); +} + +AssertionResult FilterTests::closeFilter(uint32_t filterId) { + EXPECT_TRUE(mFilters[filterId]) << "Test with getNewlyOpenedFilterId first."; + Result status = mFilters[filterId]->close(); + if (status == Result::SUCCESS) { + for (int i = 0; i < mUsedFilterIds.size(); i++) { + if (mUsedFilterIds[i] == filterId) { + mUsedFilterIds.erase(mUsedFilterIds.begin() + i); + break; + } + } + mFilterCallbacks.erase(filterId); + mFilters.erase(filterId); + } + return AssertionResult(status == Result::SUCCESS); +} \ No newline at end of file diff --git a/tv/tuner/1.0/vts/functional/FilterTests.h b/tv/tuner/1.0/vts/functional/FilterTests.h new file mode 100644 index 0000000000..eab963bc34 --- /dev/null +++ b/tv/tuner/1.0/vts/functional/FilterTests.h @@ -0,0 +1,226 @@ +/* + * Copyright 2020 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using android::Condition; +using android::Mutex; +using android::sp; +using android::hardware::EventFlag; +using android::hardware::hidl_handle; +using android::hardware::hidl_string; +using android::hardware::hidl_vec; +using android::hardware::kSynchronizedReadWrite; +using android::hardware::MessageQueue; +using android::hardware::MQDescriptorSync; +using android::hardware::Return; +using android::hardware::Void; +using android::hardware::tv::tuner::V1_0::DemuxFilterEvent; +using android::hardware::tv::tuner::V1_0::DemuxFilterMainType; +using android::hardware::tv::tuner::V1_0::DemuxFilterMediaEvent; +using android::hardware::tv::tuner::V1_0::DemuxFilterPesDataSettings; +using android::hardware::tv::tuner::V1_0::DemuxFilterPesEvent; +using android::hardware::tv::tuner::V1_0::DemuxFilterRecordSettings; +using android::hardware::tv::tuner::V1_0::DemuxFilterSectionEvent; +using android::hardware::tv::tuner::V1_0::DemuxFilterSectionSettings; +using android::hardware::tv::tuner::V1_0::DemuxFilterSettings; +using android::hardware::tv::tuner::V1_0::DemuxFilterStatus; +using android::hardware::tv::tuner::V1_0::DemuxFilterType; +using android::hardware::tv::tuner::V1_0::DemuxQueueNotifyBits; +using android::hardware::tv::tuner::V1_0::DemuxTsFilterSettings; +using android::hardware::tv::tuner::V1_0::DemuxTsFilterType; +using android::hardware::tv::tuner::V1_0::IDemux; +using android::hardware::tv::tuner::V1_0::IFilter; +using android::hardware::tv::tuner::V1_0::IFilterCallback; +using android::hardware::tv::tuner::V1_0::ITuner; +using android::hardware::tv::tuner::V1_0::Result; + +using ::testing::AssertionResult; + +enum FilterEventType : uint8_t { + UNDEFINED, + SECTION, + MEDIA, + PES, + RECORD, + MMTPRECORD, + DOWNLOAD, + TEMI, +}; + +using FilterMQ = MessageQueue; +using MQDesc = MQDescriptorSync; + +const uint32_t FMQ_SIZE_1M = 0x100000; +const uint32_t FMQ_SIZE_16M = 0x1000000; + +#define WAIT_TIMEOUT 3000000000 + +class FilterCallback : public IFilterCallback { + public: + virtual Return onFilterEvent(const DemuxFilterEvent& filterEvent) override { + android::Mutex::Autolock autoLock(mMsgLock); + // Temprarily we treat the first coming back filter data on the matching pid a success + // once all of the MQ are cleared, means we got all the expected output + mFilterEvent = filterEvent; + readFilterEventData(); + mPidFilterOutputCount++; + // mFilterIdToMQ.erase(filterEvent.filterId); + + // startFilterEventThread(filterEvent); + mMsgCondition.signal(); + return Void(); + } + + virtual Return onFilterStatus(const DemuxFilterStatus /*status*/) override { + return Void(); + } + + void setFilterId(uint32_t filterId) { mFilterId = filterId; } + void setFilterInterface(sp filter) { mFilter = filter; } + void setFilterEventType(FilterEventType type) { mFilterEventType = type; } + + void testFilterDataOutput(); + + void startFilterEventThread(DemuxFilterEvent event); + static void* __threadLoopFilter(void* threadArgs); + void filterThreadLoop(DemuxFilterEvent& event); + + void updateFilterMQ(MQDesc& filterMQDescriptor); + void updateGoldenOutputMap(string goldenOutputFile); + bool readFilterEventData(); + bool dumpAvData(DemuxFilterMediaEvent event); + + private: + struct FilterThreadArgs { + FilterCallback* user; + DemuxFilterEvent event; + }; + uint16_t mDataLength = 0; + std::vector mDataOutputBuffer; + + string mFilterIdToGoldenOutput; + + uint32_t mFilterId; + sp mFilter; + FilterEventType mFilterEventType; + std::unique_ptr mFilterMQ; + EventFlag* mFilterMQEventFlag; + DemuxFilterEvent mFilterEvent; + + android::Mutex mMsgLock; + android::Mutex mFilterOutputLock; + android::Condition mMsgCondition; + android::Condition mFilterOutputCondition; + + pthread_t mFilterThread; + + int mPidFilterOutputCount = 0; +}; + +class FilterTests { + public: + void setService(sp tuner) { mService = tuner; } + void setDemux(sp demux) { mDemux = demux; } + + std::map> getFilterCallbacks() { return mFilterCallbacks; } + + AssertionResult openFilterInDemux(DemuxFilterType type); + AssertionResult getNewlyOpenedFilterId(uint32_t& filterId); + AssertionResult configFilter(DemuxFilterSettings setting, uint32_t filterId); + AssertionResult getFilterMQDescriptor(uint32_t filterId); + AssertionResult startFilter(uint32_t filterId); + AssertionResult stopFilter(uint32_t filterId); + AssertionResult closeFilter(uint32_t filterId); + + FilterEventType getFilterEventType(DemuxFilterType type) { + FilterEventType eventType = FilterEventType::UNDEFINED; + switch (type.mainType) { + case DemuxFilterMainType::TS: + switch (type.subType.tsFilterType()) { + case DemuxTsFilterType::UNDEFINED: + break; + case DemuxTsFilterType::SECTION: + eventType = FilterEventType::SECTION; + break; + case DemuxTsFilterType::PES: + eventType = FilterEventType::PES; + break; + case DemuxTsFilterType::TS: + break; + case DemuxTsFilterType::AUDIO: + case DemuxTsFilterType::VIDEO: + eventType = FilterEventType::MEDIA; + break; + case DemuxTsFilterType::PCR: + break; + case DemuxTsFilterType::RECORD: + eventType = FilterEventType::RECORD; + break; + case DemuxTsFilterType::TEMI: + eventType = FilterEventType::TEMI; + break; + } + break; + case DemuxFilterMainType::MMTP: + /*mmtpSettings*/ + break; + case DemuxFilterMainType::IP: + /*ipSettings*/ + break; + case DemuxFilterMainType::TLV: + /*tlvSettings*/ + break; + case DemuxFilterMainType::ALP: + /*alpSettings*/ + break; + default: + break; + } + return eventType; + } + + protected: + static AssertionResult failure() { return ::testing::AssertionFailure(); } + + static AssertionResult success() { return ::testing::AssertionSuccess(); } + + sp mService; + sp mFilter; + sp mDemux; + std::map> mFilters; + std::map> mFilterCallbacks; + + sp mFilterCallback; + MQDesc mFilterMQDescriptor; + vector mUsedFilterIds; + + uint32_t mFilterId = -1; +}; \ No newline at end of file diff --git a/tv/tuner/1.0/vts/functional/FrontendTests.cpp b/tv/tuner/1.0/vts/functional/FrontendTests.cpp index 5bc3705fcd..fc5071ceaa 100644 --- a/tv/tuner/1.0/vts/functional/FrontendTests.cpp +++ b/tv/tuner/1.0/vts/functional/FrontendTests.cpp @@ -307,4 +307,4 @@ void FrontendTests::scanTest(FrontendConfig frontendConf, FrontendScanType scanT ASSERT_TRUE(scanFrontend(frontendConf, scanType)); ASSERT_TRUE(stopScanFrontend()); ASSERT_TRUE(closeFrontend()); -} \ No newline at end of file +} diff --git a/tv/tuner/1.0/vts/functional/FrontendTests.h b/tv/tuner/1.0/vts/functional/FrontendTests.h index 5aa6e159f1..701be826d5 100644 --- a/tv/tuner/1.0/vts/functional/FrontendTests.h +++ b/tv/tuner/1.0/vts/functional/FrontendTests.h @@ -45,10 +45,7 @@ using android::MemoryDealer; using android::Mutex; using android::sp; using android::hardware::fromHeap; -using android::hardware::hidl_handle; -using android::hardware::hidl_string; using android::hardware::hidl_vec; -using android::hardware::HidlMemory; using android::hardware::Return; using android::hardware::Void; using android::hardware::tv::tuner::V1_0::FrontendAtscModulation; diff --git a/tv/tuner/1.0/vts/functional/VtsHalTvTunerV1_0TargetTest.cpp b/tv/tuner/1.0/vts/functional/VtsHalTvTunerV1_0TargetTest.cpp index 59c94793ec..d836c26f9f 100644 --- a/tv/tuner/1.0/vts/functional/VtsHalTvTunerV1_0TargetTest.cpp +++ b/tv/tuner/1.0/vts/functional/VtsHalTvTunerV1_0TargetTest.cpp @@ -17,119 +17,6 @@ #include "VtsHalTvTunerV1_0TargetTest.h" namespace { -/******************************** Start FilterCallback **********************************/ -void FilterCallback::startFilterEventThread(DemuxFilterEvent event) { - struct FilterThreadArgs* threadArgs = - (struct FilterThreadArgs*)malloc(sizeof(struct FilterThreadArgs)); - threadArgs->user = this; - threadArgs->event = event; - - pthread_create(&mFilterThread, NULL, __threadLoopFilter, (void*)threadArgs); - pthread_setname_np(mFilterThread, "test_playback_input_loop"); -} - -void FilterCallback::testFilterDataOutput() { - android::Mutex::Autolock autoLock(mMsgLock); - while (mPidFilterOutputCount < 1) { - if (-ETIMEDOUT == mMsgCondition.waitRelative(mMsgLock, WAIT_TIMEOUT)) { - EXPECT_TRUE(false) << "filter output matching pid does not output within timeout"; - return; - } - } - mPidFilterOutputCount = 0; - ALOGW("[vts] pass and stop"); -} - -void FilterCallback::updateFilterMQ(MQDesc& filterMQDescriptor) { - mFilterMQ = std::make_unique(filterMQDescriptor, true /* resetPointers */); - EXPECT_TRUE(mFilterMQ); - EXPECT_TRUE(EventFlag::createEventFlag(mFilterMQ->getEventFlagWord(), &mFilterMQEventFlag) == - android::OK); -} - -void FilterCallback::updateGoldenOutputMap(string goldenOutputFile) { - mFilterIdToGoldenOutput = goldenOutputFile; -} - -void* FilterCallback::__threadLoopFilter(void* threadArgs) { - FilterCallback* const self = - static_cast(((struct FilterThreadArgs*)threadArgs)->user); - self->filterThreadLoop(((struct FilterThreadArgs*)threadArgs)->event); - return 0; -} - -void FilterCallback::filterThreadLoop(DemuxFilterEvent& /* event */) { - android::Mutex::Autolock autoLock(mFilterOutputLock); - // Read from mFilterMQ[event.filterId] per event and filter type - - // Assemble to filterOutput[filterId] - - // check if filterOutput[filterId] matches goldenOutput[filterId] - - // If match, remove filterId entry from MQ map - - // end thread -} - -bool FilterCallback::readFilterEventData() { - bool result = false; - DemuxFilterEvent filterEvent = mFilterEvent; - ALOGW("[vts] reading from filter FMQ or buffer %d", mFilterId); - // todo separate filter handlers - for (int i = 0; i < filterEvent.events.size(); i++) { - switch (mFilterEventType) { - case FilterEventType::SECTION: - mDataLength = filterEvent.events[i].section().dataLength; - break; - case FilterEventType::PES: - mDataLength = filterEvent.events[i].pes().dataLength; - break; - case FilterEventType::MEDIA: - return dumpAvData(filterEvent.events[i].media()); - case FilterEventType::RECORD: - break; - case FilterEventType::MMTPRECORD: - break; - case FilterEventType::DOWNLOAD: - break; - default: - break; - } - // 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"; - - /*for (int i = 0; i < mDataLength; i++) { - EXPECT_TRUE(goldenDataOutputBuffer[i] == mDataOutputBuffer[i]) << "data does not match"; - }*/ - } - mFilterMQEventFlag->wake(static_cast(DemuxQueueNotifyBits::DATA_CONSUMED)); - return result; -} - -bool FilterCallback::dumpAvData(DemuxFilterMediaEvent event) { - uint32_t length = event.dataLength; - uint64_t dataId = event.avDataId; - // read data from buffer pointed by a handle - hidl_handle handle = event.avMemory; - - int av_fd = handle.getNativeHandle()->data[0]; - uint8_t* buffer = static_cast( - mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_SHARED, av_fd, 0 /*offset*/)); - if (buffer == MAP_FAILED) { - ALOGE("[vts] fail to allocate av buffer, errno=%d", errno); - return false; - } - uint8_t output[length + 1]; - memcpy(output, buffer, length); - // print buffer and check with golden output. - EXPECT_TRUE(mFilter->releaseAvHandle(handle, dataId) == Result::SUCCESS); - return true; -} -/******************************** End FilterCallback **********************************/ /******************************** Start DvrCallback **********************************/ void DvrCallback::startPlaybackInputThread(PlaybackConf playbackConf, @@ -303,134 +190,9 @@ void DvrCallback::stopRecordThread() { } /********************************** End DvrCallback ************************************/ -/*============================ Start Demux APIs Tests Implementation ============================*/ -AssertionResult TunerHidlTest::openDemux() { - Result status; - mService->openDemux([&](Result result, uint32_t demuxId, const sp& demux) { - mDemux = demux; - mDemuxId = demuxId; - status = result; - }); - return AssertionResult(status == Result::SUCCESS); -} - -AssertionResult TunerHidlTest::setDemuxFrontendDataSource(uint32_t frontendId) { - EXPECT_TRUE(mDemux) << "Test with openDemux first."; - auto status = mDemux->setFrontendDataSource(frontendId); - return AssertionResult(status.isOk()); -} - -AssertionResult TunerHidlTest::closeDemux() { - EXPECT_TRUE(mDemux) << "Test with openDemux first."; - auto status = mDemux->close(); - mDemux = nullptr; - return AssertionResult(status.isOk()); -} - -AssertionResult TunerHidlTest::openFilterInDemux(DemuxFilterType type) { - Result status; - EXPECT_TRUE(mDemux) << "Test with openDemux first."; - - // Create demux callback - mFilterCallback = new FilterCallback(); - - // Add filter to the local demux - mDemux->openFilter(type, FMQ_SIZE_16M, mFilterCallback, - [&](Result result, const sp& filter) { - mFilter = filter; - status = result; - }); - - if (status == Result::SUCCESS) { - mFilterCallback->setFilterEventType(getFilterEventType(type)); - } - - return AssertionResult(status == Result::SUCCESS); -} -/*============================ End Demux APIs Tests Implementation ============================*/ - -/*=========================== Start Filter APIs Tests Implementation ===========================*/ -AssertionResult TunerHidlTest::getNewlyOpenedFilterId(uint32_t& filterId) { - Result status; - EXPECT_TRUE(mDemux) << "Test with openDemux first."; - EXPECT_TRUE(mFilter) << "Test with openFilterInDemux first."; - EXPECT_TRUE(mFilterCallback) << "Test with openFilterInDemux first."; - - mFilter->getId([&](Result result, uint32_t filterId) { - mFilterId = filterId; - status = result; - }); - - if (status == Result::SUCCESS) { - mFilterCallback->setFilterId(mFilterId); - mFilterCallback->setFilterInterface(mFilter); - mUsedFilterIds.insert(mUsedFilterIds.end(), mFilterId); - mFilters[mFilterId] = mFilter; - mFilterCallbacks[mFilterId] = mFilterCallback; - filterId = mFilterId; - } - - return AssertionResult(status == Result::SUCCESS); -} - -AssertionResult TunerHidlTest::configFilter(DemuxFilterSettings setting, uint32_t filterId) { - Result status; - EXPECT_TRUE(mFilters[filterId]) << "Test with getNewlyOpenedFilterId first."; - status = mFilters[filterId]->configure(setting); - - return AssertionResult(status == Result::SUCCESS); -} - -AssertionResult TunerHidlTest::getFilterMQDescriptor(uint32_t filterId) { - Result status; - EXPECT_TRUE(mFilters[filterId]) << "Test with getNewlyOpenedFilterId first."; - EXPECT_TRUE(mFilterCallbacks[filterId]) << "Test with getNewlyOpenedFilterId first."; - - mFilter->getQueueDesc([&](Result result, const MQDesc& filterMQDesc) { - mFilterMQDescriptor = filterMQDesc; - status = result; - }); - - if (status == Result::SUCCESS) { - mFilterCallbacks[filterId]->updateFilterMQ(mFilterMQDescriptor); - } - - return AssertionResult(status == Result::SUCCESS); -} - -AssertionResult TunerHidlTest::startFilter(uint32_t filterId) { - EXPECT_TRUE(mFilters[filterId]) << "Test with getNewlyOpenedFilterId first."; - Result status = mFilters[filterId]->start(); - return AssertionResult(status == Result::SUCCESS); -} - -AssertionResult TunerHidlTest::stopFilter(uint32_t filterId) { - EXPECT_TRUE(mFilters[filterId]) << "Test with getNewlyOpenedFilterId first."; - Result status = mFilters[filterId]->stop(); - return AssertionResult(status == Result::SUCCESS); -} - -AssertionResult TunerHidlTest::closeFilter(uint32_t filterId) { - EXPECT_TRUE(mFilters[filterId]) << "Test with getNewlyOpenedFilterId first."; - Result status = mFilters[filterId]->close(); - if (status == Result::SUCCESS) { - for (int i = 0; i < mUsedFilterIds.size(); i++) { - if (mUsedFilterIds[i] == filterId) { - mUsedFilterIds.erase(mUsedFilterIds.begin() + i); - break; - } - } - mFilterCallbacks.erase(filterId); - mFilters.erase(filterId); - } - return AssertionResult(status == Result::SUCCESS); -} -/*=========================== End Filter APIs Tests Implementation ===========================*/ - /*======================== Start Descrambler APIs Tests Implementation ========================*/ AssertionResult TunerHidlTest::createDescrambler() { Result status; - EXPECT_TRUE(mDemux) << "Test with openDemux first."; mService->openDescrambler([&](Result result, const sp& descrambler) { mDescrambler = descrambler; status = result; @@ -464,7 +226,6 @@ AssertionResult TunerHidlTest::closeDescrambler() { /*============================ Start Dvr APIs Tests Implementation ============================*/ AssertionResult TunerHidlTest::openDvrInDemux(DvrType type) { Result status; - EXPECT_TRUE(mDemux) << "Test with openDemux first."; // Create dvr callback mDvrCallback = new DvrCallback(); @@ -485,7 +246,6 @@ AssertionResult TunerHidlTest::configDvr(DvrSettings setting) { AssertionResult TunerHidlTest::getDvrMQDescriptor() { Result status; - EXPECT_TRUE(mDemux) << "Test with openDemux first."; EXPECT_TRUE(mDvr) << "Test with openDvr first."; mDvr->getQueueDesc([&](Result result, const MQDesc& dvrMQDesc) { @@ -499,12 +259,10 @@ AssertionResult TunerHidlTest::getDvrMQDescriptor() { /*========================== Start Data Flow Tests Implementation ==========================*/ AssertionResult TunerHidlTest::broadcastDataFlowTest(vector /*goldenOutputFiles*/) { - EXPECT_TRUE(mDemux) << "Test with openDemux first."; - EXPECT_TRUE(mFilterCallback) << "Test with getFilterMQDescriptor first."; - // Data Verify Module std::map>::iterator it; - for (it = mFilterCallbacks.begin(); it != mFilterCallbacks.end(); it++) { + std::map> filterCallbacks = mFilterTests.getFilterCallbacks(); + for (it = filterCallbacks.begin(); it != filterCallbacks.end(); it++) { it->second->testFilterDataOutput(); } return success(); @@ -668,74 +426,26 @@ void TunerHidlTest::broadcastSingleFilterTest(FilterConfig filterConf, } ASSERT_TRUE(mFrontendTests.openFrontendById(feId)); ASSERT_TRUE(mFrontendTests.setFrontendCallback()); - ASSERT_TRUE(openDemux()); - ASSERT_TRUE(setDemuxFrontendDataSource(feId)); - ASSERT_TRUE(openFilterInDemux(filterConf.type)); + ASSERT_TRUE(mDemuxTests.openDemux(mDemux, mDemuxId)); + mFilterTests.setDemux(mDemux); + ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId)); + ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type)); uint32_t filterId; - ASSERT_TRUE(getNewlyOpenedFilterId(filterId)); - ASSERT_TRUE(configFilter(filterConf.setting, filterId)); - ASSERT_TRUE(getFilterMQDescriptor(filterId)); - ASSERT_TRUE(startFilter(filterId)); + ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId(filterId)); + ASSERT_TRUE(mFilterTests.configFilter(filterConf.setting, filterId)); + ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId)); + ASSERT_TRUE(mFilterTests.startFilter(filterId)); // tune test ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf)); // broadcast data flow test ASSERT_TRUE(broadcastDataFlowTest(goldenOutputFiles)); ASSERT_TRUE(mFrontendTests.stopTuneFrontend()); - ASSERT_TRUE(stopFilter(filterId)); - ASSERT_TRUE(closeFilter(filterId)); - ASSERT_TRUE(closeDemux()); + ASSERT_TRUE(mFilterTests.stopFilter(filterId)); + ASSERT_TRUE(mFilterTests.closeFilter(filterId)); + ASSERT_TRUE(mDemuxTests.closeDemux()); ASSERT_TRUE(mFrontendTests.closeFrontend()); } /*================================== End Test Module ==================================*/ - -/*=============================== Start Helper Functions ===============================*/ -FilterEventType TunerHidlTest::getFilterEventType(DemuxFilterType type) { - FilterEventType eventType = FilterEventType::UNDEFINED; - switch (type.mainType) { - case DemuxFilterMainType::TS: - switch (type.subType.tsFilterType()) { - case DemuxTsFilterType::UNDEFINED: - break; - case DemuxTsFilterType::SECTION: - eventType = FilterEventType::SECTION; - break; - case DemuxTsFilterType::PES: - eventType = FilterEventType::PES; - break; - case DemuxTsFilterType::TS: - break; - case DemuxTsFilterType::AUDIO: - case DemuxTsFilterType::VIDEO: - eventType = FilterEventType::MEDIA; - break; - case DemuxTsFilterType::PCR: - break; - case DemuxTsFilterType::RECORD: - eventType = FilterEventType::RECORD; - break; - case DemuxTsFilterType::TEMI: - eventType = FilterEventType::TEMI; - break; - } - break; - case DemuxFilterMainType::MMTP: - /*mmtpSettings*/ - break; - case DemuxFilterMainType::IP: - /*ipSettings*/ - break; - case DemuxFilterMainType::TLV: - /*tlvSettings*/ - break; - case DemuxFilterMainType::ALP: - /*alpSettings*/ - break; - default: - break; - } - return eventType; -} -/*============================== End Helper Functions ==============================*/ /***************************** End Test Implementation *****************************/ /******************************** Start Test Entry **********************************/ @@ -754,28 +464,39 @@ TEST_P(TunerFrontendHidlTest, BlindScanFrontend) { mFrontendTests.scanTest(frontendScanArray[SCAN_DVBT], FrontendScanType::SCAN_BLIND); } -/*============================ Start Demux/Filter Tests ============================*/ -TEST_P(TunerHidlTest, StartFilterInDemux) { +TEST_P(TunerDemuxHidlTest, openDemux) { + description("Open and close a Demux."); + uint32_t feId; + mFrontendTests.getFrontendIdByType(frontendArray[DVBT].type, feId); + ASSERT_TRUE(feId != INVALID_ID); + ASSERT_TRUE(mFrontendTests.openFrontendById(feId)); + ASSERT_TRUE(mFrontendTests.setFrontendCallback()); + ASSERT_TRUE(mDemuxTests.openDemux(mDemux, mDemuxId)); + ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId)); + ASSERT_TRUE(mDemuxTests.closeDemux()); +} + +TEST_P(TunerFilterHidlTest, StartFilterInDemux) { description("Open and start a filter in Demux."); uint32_t feId; mFrontendTests.getFrontendIdByType(frontendArray[DVBT].type, feId); ASSERT_TRUE(feId != INVALID_ID); ASSERT_TRUE(mFrontendTests.openFrontendById(feId)); ASSERT_TRUE(mFrontendTests.setFrontendCallback()); - ASSERT_TRUE(openDemux()); - ASSERT_TRUE(setDemuxFrontendDataSource(feId)); - ASSERT_TRUE(openFilterInDemux(filterArray[TS_VIDEO0].type)); + ASSERT_TRUE(mDemuxTests.openDemux(mDemux, mDemuxId)); + mFilterTests.setDemux(mDemux); + ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId)); + ASSERT_TRUE(mFilterTests.openFilterInDemux(filterArray[TS_VIDEO0].type)); uint32_t filterId; - ASSERT_TRUE(getNewlyOpenedFilterId(filterId)); - ASSERT_TRUE(configFilter(filterArray[TS_VIDEO0].setting, filterId)); - ASSERT_TRUE(getFilterMQDescriptor(filterId)); - ASSERT_TRUE(startFilter(filterId)); - ASSERT_TRUE(stopFilter(filterId)); - ASSERT_TRUE(closeFilter(filterId)); - ASSERT_TRUE(closeDemux()); + ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId(filterId)); + ASSERT_TRUE(mFilterTests.configFilter(filterArray[TS_VIDEO0].setting, filterId)); + ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId)); + ASSERT_TRUE(mFilterTests.startFilter(filterId)); + ASSERT_TRUE(mFilterTests.stopFilter(filterId)); + ASSERT_TRUE(mFilterTests.closeFilter(filterId)); + ASSERT_TRUE(mDemuxTests.closeDemux()); ASSERT_TRUE(mFrontendTests.closeFrontend()); } -/*============================ End Demux/Filter Tests ============================*/ /*============================ Start Descrambler Tests ============================*/ /* @@ -911,4 +632,14 @@ INSTANTIATE_TEST_SUITE_P( PerInstance, TunerHidlTest, testing::ValuesIn(android::hardware::getAllHalInstanceNames(ITuner::descriptor)), android::hardware::PrintInstanceNameToString); + +INSTANTIATE_TEST_SUITE_P( + PerInstance, TunerDemuxHidlTest, + testing::ValuesIn(android::hardware::getAllHalInstanceNames(ITuner::descriptor)), + android::hardware::PrintInstanceNameToString); + +INSTANTIATE_TEST_SUITE_P( + PerInstance, TunerFilterHidlTest, + testing::ValuesIn(android::hardware::getAllHalInstanceNames(ITuner::descriptor)), + android::hardware::PrintInstanceNameToString); } // namespace diff --git a/tv/tuner/1.0/vts/functional/VtsHalTvTunerV1_0TargetTest.h b/tv/tuner/1.0/vts/functional/VtsHalTvTunerV1_0TargetTest.h index 4d6715eeb7..f17704774c 100644 --- a/tv/tuner/1.0/vts/functional/VtsHalTvTunerV1_0TargetTest.h +++ b/tv/tuner/1.0/vts/functional/VtsHalTvTunerV1_0TargetTest.h @@ -14,70 +14,27 @@ * limitations under the License. */ -#include #include #include #include -#include -#include -#include -#include -#include #include #include -#include +#include "DemuxTests.h" +#include "FilterTests.h" #include "FrontendTests.h" -using android::hardware::EventFlag; -using android::hardware::kSynchronizedReadWrite; -using android::hardware::MessageQueue; -using android::hardware::MQDescriptorSync; using android::hardware::tv::tuner::V1_0::DataFormat; -using android::hardware::tv::tuner::V1_0::DemuxFilterEvent; -using android::hardware::tv::tuner::V1_0::DemuxFilterMainType; -using android::hardware::tv::tuner::V1_0::DemuxFilterMediaEvent; -using android::hardware::tv::tuner::V1_0::DemuxFilterPesDataSettings; -using android::hardware::tv::tuner::V1_0::DemuxFilterPesEvent; -using android::hardware::tv::tuner::V1_0::DemuxFilterRecordSettings; -using android::hardware::tv::tuner::V1_0::DemuxFilterSectionEvent; -using android::hardware::tv::tuner::V1_0::DemuxFilterSectionSettings; -using android::hardware::tv::tuner::V1_0::DemuxFilterSettings; -using android::hardware::tv::tuner::V1_0::DemuxFilterStatus; -using android::hardware::tv::tuner::V1_0::DemuxFilterType; -using android::hardware::tv::tuner::V1_0::DemuxQueueNotifyBits; -using android::hardware::tv::tuner::V1_0::DemuxTsFilterSettings; -using android::hardware::tv::tuner::V1_0::DemuxTsFilterType; using android::hardware::tv::tuner::V1_0::DvrSettings; using android::hardware::tv::tuner::V1_0::DvrType; -using android::hardware::tv::tuner::V1_0::IDemux; using android::hardware::tv::tuner::V1_0::IDescrambler; using android::hardware::tv::tuner::V1_0::IDvr; using android::hardware::tv::tuner::V1_0::IDvrCallback; -using android::hardware::tv::tuner::V1_0::IFilter; -using android::hardware::tv::tuner::V1_0::IFilterCallback; using android::hardware::tv::tuner::V1_0::PlaybackSettings; using android::hardware::tv::tuner::V1_0::PlaybackStatus; using android::hardware::tv::tuner::V1_0::RecordSettings; using android::hardware::tv::tuner::V1_0::RecordStatus; -using FilterMQ = MessageQueue; -using MQDesc = MQDescriptorSync; - -const uint32_t FMQ_SIZE_1M = 0x100000; -const uint32_t FMQ_SIZE_16M = 0x1000000; - -enum FilterEventType : uint8_t { - UNDEFINED, - SECTION, - MEDIA, - PES, - RECORD, - MMTPRECORD, - DOWNLOAD, - TEMI, -}; - struct PlaybackConf { string inputDataFile; PlaybackSettings setting; @@ -93,68 +50,6 @@ static AssertionResult success() { namespace { -class FilterCallback : public IFilterCallback { - public: - virtual Return onFilterEvent(const DemuxFilterEvent& filterEvent) override { - android::Mutex::Autolock autoLock(mMsgLock); - // Temprarily we treat the first coming back filter data on the matching pid a success - // once all of the MQ are cleared, means we got all the expected output - mFilterEvent = filterEvent; - readFilterEventData(); - mPidFilterOutputCount++; - // mFilterIdToMQ.erase(filterEvent.filterId); - - // startFilterEventThread(filterEvent); - mMsgCondition.signal(); - return Void(); - } - - virtual Return onFilterStatus(const DemuxFilterStatus /*status*/) override { - return Void(); - } - - void setFilterId(uint32_t filterId) { mFilterId = filterId; } - void setFilterInterface(sp filter) { mFilter = filter; } - void setFilterEventType(FilterEventType type) { mFilterEventType = type; } - - void testFilterDataOutput(); - - void startFilterEventThread(DemuxFilterEvent event); - static void* __threadLoopFilter(void* threadArgs); - void filterThreadLoop(DemuxFilterEvent& event); - - void updateFilterMQ(MQDesc& filterMQDescriptor); - void updateGoldenOutputMap(string goldenOutputFile); - bool readFilterEventData(); - bool dumpAvData(DemuxFilterMediaEvent event); - - private: - struct FilterThreadArgs { - FilterCallback* user; - DemuxFilterEvent event; - }; - uint16_t mDataLength = 0; - std::vector mDataOutputBuffer; - - string mFilterIdToGoldenOutput; - - uint32_t mFilterId; - sp mFilter; - FilterEventType mFilterEventType; - std::unique_ptr mFilterMQ; - EventFlag* mFilterMQEventFlag; - DemuxFilterEvent mFilterEvent; - - android::Mutex mMsgLock; - android::Mutex mFilterOutputLock; - android::Condition mMsgCondition; - android::Condition mFilterOutputCondition; - - pthread_t mFilterThread; - - int mPidFilterOutputCount = 0; -}; - class DvrCallback : public IDvrCallback { public: virtual Return onRecordStatus(DemuxFilterStatus status) override { @@ -240,9 +135,6 @@ class DvrCallback : public IDvrCallback { class TunerFrontendHidlTest : public testing::TestWithParam { public: - sp mService; - FrontendTests mFrontendTests; - virtual void SetUp() override { mService = ITuner::getService(GetParam()); ASSERT_NE(mService, nullptr); @@ -256,12 +148,69 @@ class TunerFrontendHidlTest : public testing::TestWithParam { static void description(const std::string& description) { RecordProperty("description", description); } + + sp mService; + FrontendTests mFrontendTests; +}; + +class TunerDemuxHidlTest : public testing::TestWithParam { + public: + virtual void SetUp() override { + mService = ITuner::getService(GetParam()); + ASSERT_NE(mService, nullptr); + initFrontendConfig(); + initFrontendScanConfig(); + initFilterConfig(); + + mFrontendTests.setService(mService); + mDemuxTests.setService(mService); + } + + protected: + static void description(const std::string& description) { + RecordProperty("description", description); + } + + sp mService; + FrontendTests mFrontendTests; + DemuxTests mDemuxTests; + sp mDemux; + uint32_t mDemuxId; +}; + +class TunerFilterHidlTest : public testing::TestWithParam { + public: + virtual void SetUp() override { + mService = ITuner::getService(GetParam()); + ASSERT_NE(mService, nullptr); + initFrontendConfig(); + initFrontendScanConfig(); + initFilterConfig(); + + mFrontendTests.setService(mService); + mDemuxTests.setService(mService); + mFilterTests.setService(mService); + } + + protected: + static void description(const std::string& description) { + RecordProperty("description", description); + } + + sp mService; + FrontendTests mFrontendTests; + DemuxTests mDemuxTests; + FilterTests mFilterTests; + sp mDemux; + uint32_t mDemuxId; }; class TunerHidlTest : public testing::TestWithParam { public: sp mService; FrontendTests mFrontendTests; + DemuxTests mDemuxTests; + FilterTests mFilterTests; virtual void SetUp() override { mService = ITuner::getService(GetParam()); @@ -271,6 +220,8 @@ class TunerHidlTest : public testing::TestWithParam { initFilterConfig(); mFrontendTests.setService(mService); + mDemuxTests.setService(mService); + mFilterTests.setService(mService); } protected: @@ -279,43 +230,21 @@ class TunerHidlTest : public testing::TestWithParam { } sp mDescrambler; - - sp mDemux; sp mDvr; - sp mFilter; - std::map> mFilters; - std::map> mFilterCallbacks; + sp mDemux; + uint32_t mDemuxId; - sp mFilterCallback; sp mDvrCallback; - MQDesc mFilterMQDescriptor; MQDesc mDvrMQDescriptor; MQDesc mRecordMQDescriptor; - vector mUsedFilterIds; - hidl_vec mFeIds; - - uint32_t mDemuxId; - uint32_t mFilterId = -1; pthread_t mPlaybackshread; bool mPlaybackThreadRunning; - AssertionResult openDemux(); - AssertionResult setDemuxFrontendDataSource(uint32_t frontendId); - AssertionResult closeDemux(); - AssertionResult openDvrInDemux(DvrType type); AssertionResult configDvr(DvrSettings setting); AssertionResult getDvrMQDescriptor(); - AssertionResult openFilterInDemux(DemuxFilterType type); - AssertionResult getNewlyOpenedFilterId(uint32_t& filterId); - AssertionResult configFilter(DemuxFilterSettings setting, uint32_t filterId); - AssertionResult getFilterMQDescriptor(uint32_t filterId); - AssertionResult startFilter(uint32_t filterId); - AssertionResult stopFilter(uint32_t filterId); - AssertionResult closeFilter(uint32_t filterId); - AssertionResult createDescrambler(); AssertionResult closeDescrambler(); @@ -327,7 +256,5 @@ class TunerHidlTest : public testing::TestWithParam { AssertionResult broadcastDataFlowTest(vector goldenOutputFiles); void broadcastSingleFilterTest(FilterConfig filterConf, FrontendConfig frontendConf); - - FilterEventType getFilterEventType(DemuxFilterType type); }; } // namespace \ No newline at end of file