1 /*
2  * Copyright 2020 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include "VtsHalTvTunerV1_1TargetTest.h"
18 
19 namespace {
20 
filterDataOutputTest()21 AssertionResult TunerBroadcastHidlTest::filterDataOutputTest() {
22     return filterDataOutputTestBase(mFilterTests);
23 }
24 
configSingleFilterInDemuxTest(FilterConfig1_1 filterConf,FrontendConfig1_1 frontendConf)25 void TunerFilterHidlTest::configSingleFilterInDemuxTest(FilterConfig1_1 filterConf,
26                                                         FrontendConfig1_1 frontendConf) {
27     uint32_t feId;
28     uint32_t demuxId;
29     sp<IDemux> demux;
30     uint64_t filterId;
31 
32     mFrontendTests.getFrontendIdByType(frontendConf.config1_0.type, feId);
33     ASSERT_TRUE(feId != INVALID_ID);
34     ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
35     ASSERT_TRUE(mFrontendTests.setFrontendCallback());
36     ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
37     ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
38     mFilterTests.setDemux(demux);
39     ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.config1_0.type,
40                                                filterConf.config1_0.bufferSize));
41     ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
42     ASSERT_TRUE(mFilterTests.configFilter(filterConf.config1_0.settings, filterId));
43     if (filterConf.config1_0.type.mainType == DemuxFilterMainType::IP) {
44         ASSERT_TRUE(mFilterTests.configIpFilterCid(filterConf.ipCid, filterId));
45     }
46     if (filterConf.monitorEventTypes > 0) {
47         ASSERT_TRUE(mFilterTests.configureMonitorEvent(filterId, filterConf.monitorEventTypes));
48     }
49     ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId, filterConf.config1_0.getMqDesc));
50     ASSERT_TRUE(mFilterTests.startFilter(filterId));
51     ASSERT_TRUE(mFilterTests.stopFilter(filterId));
52     ASSERT_TRUE(mFilterTests.closeFilter(filterId));
53     ASSERT_TRUE(mDemuxTests.closeDemux());
54     ASSERT_TRUE(mFrontendTests.closeFrontend());
55 }
56 
reconfigSingleFilterInDemuxTest(FilterConfig1_1 filterConf,FilterConfig1_1 filterReconf,FrontendConfig1_1 frontendConf)57 void TunerFilterHidlTest::reconfigSingleFilterInDemuxTest(FilterConfig1_1 filterConf,
58                                                           FilterConfig1_1 filterReconf,
59                                                           FrontendConfig1_1 frontendConf) {
60     uint32_t feId;
61     uint32_t demuxId;
62     sp<IDemux> demux;
63     uint64_t filterId;
64 
65     mFrontendTests.getFrontendIdByType(frontendConf.config1_0.type, feId);
66     ASSERT_TRUE(feId != INVALID_ID);
67     ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
68     ASSERT_TRUE(mFrontendTests.setFrontendCallback());
69     if (frontendConf.config1_0.isSoftwareFe) {
70         mFrontendTests.setSoftwareFrontendDvrConfig(dvrMap[live.dvrSoftwareFeId]);
71     }
72     ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
73     ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
74     mFrontendTests.setDemux(demux);
75     mFilterTests.setDemux(demux);
76     ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.config1_0.type,
77                                                filterConf.config1_0.bufferSize));
78     ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
79     ASSERT_TRUE(mFilterTests.configFilter(filterConf.config1_0.settings, filterId));
80     ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId, filterConf.config1_0.getMqDesc));
81     ASSERT_TRUE(mFilterTests.startFilter(filterId));
82     ASSERT_TRUE(mFilterTests.stopFilter(filterId));
83     ASSERT_TRUE(mFilterTests.configFilter(filterReconf.config1_0.settings, filterId));
84     ASSERT_TRUE(mFilterTests.startFilter(filterId));
85     ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
86     ASSERT_TRUE(mFilterTests.startIdTest(filterId));
87     ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
88     ASSERT_TRUE(mFilterTests.stopFilter(filterId));
89     ASSERT_TRUE(mFilterTests.closeFilter(filterId));
90     ASSERT_TRUE(mDemuxTests.closeDemux());
91     ASSERT_TRUE(mFrontendTests.closeFrontend());
92 }
93 
mediaFilterUsingSharedMemoryTest(FilterConfig1_1 filterConf,FrontendConfig1_1 frontendConf)94 void TunerBroadcastHidlTest::mediaFilterUsingSharedMemoryTest(FilterConfig1_1 filterConf,
95                                                               FrontendConfig1_1 frontendConf) {
96     uint32_t feId;
97     uint32_t demuxId;
98     sp<IDemux> demux;
99     uint64_t filterId;
100 
101     mFrontendTests.getFrontendIdByType(frontendConf.config1_0.type, feId);
102     ASSERT_TRUE(feId != INVALID_ID);
103     ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
104     ASSERT_TRUE(mFrontendTests.setFrontendCallback());
105     if (frontendConf.config1_0.isSoftwareFe) {
106         mFrontendTests.setSoftwareFrontendDvrConfig(dvrMap[live.dvrSoftwareFeId]);
107     }
108     ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
109     ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
110     mFrontendTests.setDemux(demux);
111     mFilterTests.setDemux(demux);
112     ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.config1_0.type,
113                                                filterConf.config1_0.bufferSize));
114     ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
115     ASSERT_TRUE(mFilterTests.configFilter(filterConf.config1_0.settings, filterId));
116     ASSERT_TRUE(mFilterTests.getSharedAvMemoryHandle(filterId));
117     ASSERT_TRUE(mFilterTests.configAvFilterStreamType(filterConf.streamType, filterId));
118     ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId, filterConf.config1_0.getMqDesc));
119     ASSERT_TRUE(mFilterTests.startFilter(filterId));
120     // tune test
121     ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
122     ASSERT_TRUE(filterDataOutputTest());
123     ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
124     ASSERT_TRUE(mFilterTests.stopFilter(filterId));
125     ASSERT_TRUE(mFilterTests.releaseShareAvHandle(filterId));
126     ASSERT_TRUE(mFilterTests.closeFilter(filterId));
127     ASSERT_TRUE(mDemuxTests.closeDemux());
128     ASSERT_TRUE(mFrontendTests.closeFrontend());
129 }
130 
recordSingleFilterTest(FilterConfig1_1 filterConf,FrontendConfig1_1 frontendConf,DvrConfig dvrConf)131 void TunerRecordHidlTest::recordSingleFilterTest(FilterConfig1_1 filterConf,
132                                                  FrontendConfig1_1 frontendConf,
133                                                  DvrConfig dvrConf) {
134     uint32_t demuxId;
135     sp<IDemux> demux;
136     ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
137     mDvrTests.setDemux(demux);
138 
139     DvrConfig dvrSourceConfig;
140     if (record.hasFrontendConnection) {
141         uint32_t feId;
142         mFrontendTests.getFrontendIdByType(frontendConf.config1_0.type, feId);
143         ASSERT_TRUE(feId != INVALID_ID);
144         ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
145         ASSERT_TRUE(mFrontendTests.setFrontendCallback());
146         if (frontendConf.config1_0.isSoftwareFe) {
147             mFrontendTests.setSoftwareFrontendDvrConfig(dvrMap[record.dvrSoftwareFeId]);
148         }
149         ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
150         mFrontendTests.setDvrTests(mDvrTests);
151     } else {
152         dvrSourceConfig = dvrMap[record.dvrSourceId];
153         ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrSourceConfig.type, dvrSourceConfig.bufferSize));
154         ASSERT_TRUE(mDvrTests.configDvrPlayback(dvrSourceConfig.settings));
155         ASSERT_TRUE(mDvrTests.getDvrPlaybackMQDescriptor());
156     }
157 
158     uint64_t filterId;
159     sp<IFilter> filter;
160     mFilterTests.setDemux(demux);
161     ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrConf.type, dvrConf.bufferSize));
162     ASSERT_TRUE(mDvrTests.configDvrRecord(dvrConf.settings));
163     ASSERT_TRUE(mDvrTests.getDvrRecordMQDescriptor());
164     ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.config1_0.type,
165                                                filterConf.config1_0.bufferSize));
166     ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
167     ASSERT_TRUE(mFilterTests.configFilter(filterConf.config1_0.settings, filterId));
168     ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId, filterConf.config1_0.getMqDesc));
169     filter = mFilterTests.getFilterById(filterId);
170     ASSERT_TRUE(filter != nullptr);
171     mDvrTests.startRecordOutputThread(dvrConf.settings.record());
172     ASSERT_TRUE(mDvrTests.attachFilterToDvr(filter));
173     ASSERT_TRUE(mDvrTests.startDvrRecord());
174     ASSERT_TRUE(mFilterTests.startFilter(filterId));
175 
176     if (record.hasFrontendConnection) {
177         ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
178     } else {
179         // Start DVR Source
180         mDvrTests.startPlaybackInputThread(dvrSourceConfig.playbackInputFile,
181                                            dvrSourceConfig.settings.playback());
182         ASSERT_TRUE(mDvrTests.startDvrPlayback());
183     }
184 
185     mDvrTests.testRecordOutput();
186     mDvrTests.stopRecordThread();
187 
188     if (record.hasFrontendConnection) {
189         ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
190     } else {
191         mDvrTests.stopPlaybackThread();
192         ASSERT_TRUE(mDvrTests.stopDvrPlayback());
193     }
194 
195     ASSERT_TRUE(mFilterTests.stopFilter(filterId));
196     ASSERT_TRUE(mDvrTests.stopDvrRecord());
197     ASSERT_TRUE(mDvrTests.detachFilterToDvr(filter));
198     ASSERT_TRUE(mFilterTests.closeFilter(filterId));
199     mDvrTests.closeDvrRecord();
200 
201     if (record.hasFrontendConnection) {
202         ASSERT_TRUE(mFrontendTests.closeFrontend());
203     } else {
204         mDvrTests.closeDvrPlayback();
205     }
206 
207     ASSERT_TRUE(mDemuxTests.closeDemux());
208 }
209 
TEST_P(TunerFilterHidlTest,StartFilterInDemux)210 TEST_P(TunerFilterHidlTest, StartFilterInDemux) {
211     description("Open and start a filter in Demux.");
212     if (!live.hasFrontendConnection) {
213         return;
214     }
215     // TODO use parameterized tests
216     configSingleFilterInDemuxTest(filterMap[live.videoFilterId], frontendMap[live.frontendId]);
217 }
218 
TEST_P(TunerFilterHidlTest,ConfigIpFilterInDemuxWithCid)219 TEST_P(TunerFilterHidlTest, ConfigIpFilterInDemuxWithCid) {
220     description("Open and configure an ip filter in Demux.");
221     // TODO use parameterized tests
222     if (!live.hasFrontendConnection) {
223         return;
224     }
225     if (live.ipFilterId.compare(emptyHardwareId) == 0) {
226         return;
227     }
228     configSingleFilterInDemuxTest(filterMap[live.ipFilterId], frontendMap[live.frontendId]);
229 }
230 
TEST_P(TunerFilterHidlTest,ReconfigFilterToReceiveStartId)231 TEST_P(TunerFilterHidlTest, ReconfigFilterToReceiveStartId) {
232     description("Recofigure and restart a filter to test start id.");
233     if (!live.hasFrontendConnection) {
234         return;
235     }
236     // TODO use parameterized tests
237     reconfigSingleFilterInDemuxTest(filterMap[live.videoFilterId], filterMap[live.videoFilterId],
238                                     frontendMap[live.frontendId]);
239 }
240 
TEST_P(TunerRecordHidlTest,RecordDataFlowWithTsRecordFilterTest)241 TEST_P(TunerRecordHidlTest, RecordDataFlowWithTsRecordFilterTest) {
242     description("Feed ts data from frontend to recording and test with ts record filter");
243     if (!record.support) {
244         return;
245     }
246     recordSingleFilterTest(filterMap[record.recordFilterId], frontendMap[record.frontendId],
247                            dvrMap[record.dvrRecordId]);
248 }
249 
TEST_P(TunerFrontendHidlTest,TuneFrontendWithFrontendSettingsExt1_1)250 TEST_P(TunerFrontendHidlTest, TuneFrontendWithFrontendSettingsExt1_1) {
251     description("Tune one Frontend with v1_1 extended setting and check Lock event");
252     if (!live.hasFrontendConnection) {
253         return;
254     }
255     mFrontendTests.tuneTest(frontendMap[live.frontendId]);
256 }
257 
TEST_P(TunerFrontendHidlTest,BlindScanFrontendWithEndFrequency)258 TEST_P(TunerFrontendHidlTest, BlindScanFrontendWithEndFrequency) {
259     description("Run an blind frontend scan with v1_1 extended setting and check lock scanMessage");
260     if (!scan.hasFrontendConnection) {
261         return;
262     }
263     mFrontendTests.scanTest(frontendMap[scan.frontendId], FrontendScanType::SCAN_BLIND);
264 }
265 
TEST_P(TunerBroadcastHidlTest,MediaFilterWithSharedMemoryHandle)266 TEST_P(TunerBroadcastHidlTest, MediaFilterWithSharedMemoryHandle) {
267     description("Test the Media Filter with shared memory handle");
268     if (!live.hasFrontendConnection) {
269         return;
270     }
271     mediaFilterUsingSharedMemoryTest(filterMap[live.videoFilterId], frontendMap[live.frontendId]);
272 }
273 
TEST_P(TunerFrontendHidlTest,GetFrontendDtmbCaps)274 TEST_P(TunerFrontendHidlTest, GetFrontendDtmbCaps) {
275     description("Test to query Dtmb frontend caps if exists");
276     mFrontendTests.getFrontendDtmbCapsTest();
277 }
278 
TEST_P(TunerFrontendHidlTest,LinkToCiCam)279 TEST_P(TunerFrontendHidlTest, LinkToCiCam) {
280     description("Test Frontend link to CiCam");
281     if (!live.hasFrontendConnection) {
282         return;
283     }
284     if (!frontendMap[live.frontendId].canConnectToCiCam) {
285         return;
286     }
287     mFrontendTests.tuneTest(frontendMap[live.frontendId]);
288 }
289 
290 INSTANTIATE_TEST_SUITE_P(
291         PerInstance, TunerBroadcastHidlTest,
292         testing::ValuesIn(android::hardware::getAllHalInstanceNames(ITuner::descriptor)),
293         android::hardware::PrintInstanceNameToString);
294 
295 INSTANTIATE_TEST_SUITE_P(
296         PerInstance, TunerFrontendHidlTest,
297         testing::ValuesIn(android::hardware::getAllHalInstanceNames(ITuner::descriptor)),
298         android::hardware::PrintInstanceNameToString);
299 
300 INSTANTIATE_TEST_SUITE_P(
301         PerInstance, TunerFilterHidlTest,
302         testing::ValuesIn(android::hardware::getAllHalInstanceNames(ITuner::descriptor)),
303         android::hardware::PrintInstanceNameToString);
304 
305 INSTANTIATE_TEST_SUITE_P(
306         PerInstance, TunerRecordHidlTest,
307         testing::ValuesIn(android::hardware::getAllHalInstanceNames(ITuner::descriptor)),
308         android::hardware::PrintInstanceNameToString);
309 }  // namespace
310