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(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
52 if (filterConf.monitorEventTypes > 0) {
53 ASSERT_TRUE(mFilterTests.testMonitorEvent(filterId, filterConf.monitorEventTypes));
54 }
55 ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
56 ASSERT_TRUE(mFilterTests.stopFilter(filterId));
57 ASSERT_TRUE(mFilterTests.closeFilter(filterId));
58 ASSERT_TRUE(mDemuxTests.closeDemux());
59 ASSERT_TRUE(mFrontendTests.closeFrontend());
60 }
61
reconfigSingleFilterInDemuxTest(FilterConfig1_1 filterConf,FilterConfig1_1 filterReconf,FrontendConfig1_1 frontendConf)62 void TunerFilterHidlTest::reconfigSingleFilterInDemuxTest(FilterConfig1_1 filterConf,
63 FilterConfig1_1 filterReconf,
64 FrontendConfig1_1 frontendConf) {
65 uint32_t feId;
66 uint32_t demuxId;
67 sp<IDemux> demux;
68 uint64_t filterId;
69
70 mFrontendTests.getFrontendIdByType(frontendConf.config1_0.type, feId);
71 ASSERT_TRUE(feId != INVALID_ID);
72 ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
73 ASSERT_TRUE(mFrontendTests.setFrontendCallback());
74 if (frontendConf.config1_0.isSoftwareFe) {
75 mFrontendTests.setSoftwareFrontendDvrConfig(dvrMap[live.dvrSoftwareFeId]);
76 }
77 ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
78 ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
79 mFrontendTests.setDemux(demux);
80 mFilterTests.setDemux(demux);
81 ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.config1_0.type,
82 filterConf.config1_0.bufferSize));
83 ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
84 ASSERT_TRUE(mFilterTests.configFilter(filterConf.config1_0.settings, filterId));
85 ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId, filterConf.config1_0.getMqDesc));
86 ASSERT_TRUE(mFilterTests.startFilter(filterId));
87 ASSERT_TRUE(mFilterTests.stopFilter(filterId));
88 ASSERT_TRUE(mFilterTests.configFilter(filterReconf.config1_0.settings, filterId));
89 ASSERT_TRUE(mFilterTests.startFilter(filterId));
90 ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
91 ASSERT_TRUE(mFilterTests.startIdTest(filterId));
92 ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
93 ASSERT_TRUE(mFilterTests.stopFilter(filterId));
94 ASSERT_TRUE(mFilterTests.closeFilter(filterId));
95 ASSERT_TRUE(mDemuxTests.closeDemux());
96 ASSERT_TRUE(mFrontendTests.closeFrontend());
97 }
98
mediaFilterUsingSharedMemoryTest(FilterConfig1_1 filterConf,FrontendConfig1_1 frontendConf)99 void TunerBroadcastHidlTest::mediaFilterUsingSharedMemoryTest(FilterConfig1_1 filterConf,
100 FrontendConfig1_1 frontendConf) {
101 uint32_t feId;
102 uint32_t demuxId;
103 sp<IDemux> demux;
104 uint64_t filterId;
105
106 mFrontendTests.getFrontendIdByType(frontendConf.config1_0.type, feId);
107 ASSERT_TRUE(feId != INVALID_ID);
108 ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
109 ASSERT_TRUE(mFrontendTests.setFrontendCallback());
110 if (frontendConf.config1_0.isSoftwareFe) {
111 mFrontendTests.setSoftwareFrontendDvrConfig(dvrMap[live.dvrSoftwareFeId]);
112 }
113 ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
114 ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
115 mFrontendTests.setDemux(demux);
116 mFilterTests.setDemux(demux);
117 ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.config1_0.type,
118 filterConf.config1_0.bufferSize));
119 ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
120 ASSERT_TRUE(mFilterTests.configFilter(filterConf.config1_0.settings, filterId));
121 ASSERT_TRUE(mFilterTests.getSharedAvMemoryHandle(filterId));
122 ASSERT_TRUE(mFilterTests.configAvFilterStreamType(filterConf.streamType, filterId));
123 ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId, filterConf.config1_0.getMqDesc));
124 ASSERT_TRUE(mFilterTests.startFilter(filterId));
125 // tune test
126 ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
127 ASSERT_TRUE(filterDataOutputTest());
128 ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
129 ASSERT_TRUE(mFilterTests.stopFilter(filterId));
130 ASSERT_TRUE(mFilterTests.releaseShareAvHandle(filterId));
131 ASSERT_TRUE(mFilterTests.closeFilter(filterId));
132 ASSERT_TRUE(mDemuxTests.closeDemux());
133 ASSERT_TRUE(mFrontendTests.closeFrontend());
134 }
135
recordSingleFilterTest(FilterConfig1_1 filterConf,FrontendConfig1_1 frontendConf,DvrConfig dvrConf)136 void TunerRecordHidlTest::recordSingleFilterTest(FilterConfig1_1 filterConf,
137 FrontendConfig1_1 frontendConf,
138 DvrConfig dvrConf) {
139 uint32_t demuxId;
140 sp<IDemux> demux;
141 ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
142 mDvrTests.setDemux(demux);
143
144 DvrConfig dvrSourceConfig;
145 if (record.hasFrontendConnection) {
146 uint32_t feId;
147 mFrontendTests.getFrontendIdByType(frontendConf.config1_0.type, feId);
148 ASSERT_TRUE(feId != INVALID_ID);
149 ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
150 ASSERT_TRUE(mFrontendTests.setFrontendCallback());
151 if (frontendConf.config1_0.isSoftwareFe) {
152 mFrontendTests.setSoftwareFrontendDvrConfig(dvrMap[record.dvrSoftwareFeId]);
153 }
154 ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
155 mFrontendTests.setDvrTests(&mDvrTests);
156 } else {
157 dvrSourceConfig = dvrMap[record.dvrSourceId];
158 ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrSourceConfig.type, dvrSourceConfig.bufferSize));
159 ASSERT_TRUE(mDvrTests.configDvrPlayback(dvrSourceConfig.settings));
160 ASSERT_TRUE(mDvrTests.getDvrPlaybackMQDescriptor());
161 }
162
163 uint64_t filterId;
164 sp<IFilter> filter;
165 mFilterTests.setDemux(demux);
166 ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrConf.type, dvrConf.bufferSize));
167 ASSERT_TRUE(mDvrTests.configDvrRecord(dvrConf.settings));
168 ASSERT_TRUE(mDvrTests.getDvrRecordMQDescriptor());
169 ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.config1_0.type,
170 filterConf.config1_0.bufferSize));
171 ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
172 ASSERT_TRUE(mFilterTests.configFilter(filterConf.config1_0.settings, filterId));
173 ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId, filterConf.config1_0.getMqDesc));
174 filter = mFilterTests.getFilterById(filterId);
175 ASSERT_TRUE(filter != nullptr);
176 mDvrTests.startRecordOutputThread(dvrConf.settings.record());
177 ASSERT_TRUE(mDvrTests.attachFilterToDvr(filter));
178 ASSERT_TRUE(mDvrTests.startDvrRecord());
179 ASSERT_TRUE(mFilterTests.startFilter(filterId));
180
181 if (record.hasFrontendConnection) {
182 ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
183 } else {
184 // Start DVR Source
185 mDvrTests.startPlaybackInputThread(dvrSourceConfig.playbackInputFile,
186 dvrSourceConfig.settings.playback());
187 ASSERT_TRUE(mDvrTests.startDvrPlayback());
188 }
189
190 mDvrTests.testRecordOutput();
191 mDvrTests.stopRecordThread();
192
193 if (record.hasFrontendConnection) {
194 ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
195 } else {
196 mDvrTests.stopPlaybackThread();
197 ASSERT_TRUE(mDvrTests.stopDvrPlayback());
198 }
199
200 ASSERT_TRUE(mFilterTests.stopFilter(filterId));
201 ASSERT_TRUE(mDvrTests.stopDvrRecord());
202 ASSERT_TRUE(mDvrTests.detachFilterToDvr(filter));
203 ASSERT_TRUE(mFilterTests.closeFilter(filterId));
204 mDvrTests.closeDvrRecord();
205
206 if (record.hasFrontendConnection) {
207 ASSERT_TRUE(mFrontendTests.closeFrontend());
208 } else {
209 mDvrTests.closeDvrPlayback();
210 }
211
212 ASSERT_TRUE(mDemuxTests.closeDemux());
213 }
214
TEST_P(TunerFilterHidlTest,StartFilterInDemux)215 TEST_P(TunerFilterHidlTest, StartFilterInDemux) {
216 description("Open and start a filter in Demux.");
217 if (!live.hasFrontendConnection) {
218 return;
219 }
220 // TODO use parameterized tests
221 configSingleFilterInDemuxTest(filterMap[live.videoFilterId], frontendMap[live.frontendId]);
222 }
223
TEST_P(TunerFilterHidlTest,ConfigIpFilterInDemuxWithCid)224 TEST_P(TunerFilterHidlTest, ConfigIpFilterInDemuxWithCid) {
225 description("Open and configure an ip filter in Demux.");
226 // TODO use parameterized tests
227 if (!live.hasFrontendConnection) {
228 return;
229 }
230 if (live.ipFilterId.compare(emptyHardwareId) == 0) {
231 return;
232 }
233 configSingleFilterInDemuxTest(filterMap[live.ipFilterId], frontendMap[live.frontendId]);
234 }
235
TEST_P(TunerFilterHidlTest,ReconfigFilterToReceiveStartId)236 TEST_P(TunerFilterHidlTest, ReconfigFilterToReceiveStartId) {
237 description("Recofigure and restart a filter to test start id.");
238 if (!live.hasFrontendConnection) {
239 return;
240 }
241 // TODO use parameterized tests
242 reconfigSingleFilterInDemuxTest(filterMap[live.videoFilterId], filterMap[live.videoFilterId],
243 frontendMap[live.frontendId]);
244 }
245
TEST_P(TunerRecordHidlTest,RecordDataFlowWithTsRecordFilterTest)246 TEST_P(TunerRecordHidlTest, RecordDataFlowWithTsRecordFilterTest) {
247 description("Feed ts data from frontend to recording and test with ts record filter");
248 if (!record.support) {
249 return;
250 }
251 recordSingleFilterTest(filterMap[record.recordFilterId], frontendMap[record.frontendId],
252 dvrMap[record.dvrRecordId]);
253 }
254
TEST_P(TunerFrontendHidlTest,TuneFrontendWithFrontendSettingsExt1_1)255 TEST_P(TunerFrontendHidlTest, TuneFrontendWithFrontendSettingsExt1_1) {
256 description("Tune one Frontend with v1_1 extended setting and check Lock event");
257 if (!live.hasFrontendConnection) {
258 return;
259 }
260 mFrontendTests.tuneTest(frontendMap[live.frontendId]);
261 }
262
TEST_P(TunerFrontendHidlTest,BlindScanFrontendWithEndFrequency)263 TEST_P(TunerFrontendHidlTest, BlindScanFrontendWithEndFrequency) {
264 description("Run an blind frontend scan with v1_1 extended setting and check lock scanMessage");
265 if (!scan.hasFrontendConnection) {
266 return;
267 }
268 mFrontendTests.scanTest(frontendMap[scan.frontendId], FrontendScanType::SCAN_BLIND);
269 }
270
TEST_P(TunerBroadcastHidlTest,MediaFilterWithSharedMemoryHandle)271 TEST_P(TunerBroadcastHidlTest, MediaFilterWithSharedMemoryHandle) {
272 description("Test the Media Filter with shared memory handle");
273 if (!live.hasFrontendConnection) {
274 return;
275 }
276 mediaFilterUsingSharedMemoryTest(filterMap[live.videoFilterId], frontendMap[live.frontendId]);
277 }
278
TEST_P(TunerFrontendHidlTest,GetFrontendDtmbCaps)279 TEST_P(TunerFrontendHidlTest, GetFrontendDtmbCaps) {
280 description("Test to query Dtmb frontend caps if exists");
281 mFrontendTests.getFrontendDtmbCapsTest();
282 }
283
TEST_P(TunerFrontendHidlTest,LinkToCiCam)284 TEST_P(TunerFrontendHidlTest, LinkToCiCam) {
285 description("Test Frontend link to CiCam");
286 if (!live.hasFrontendConnection) {
287 return;
288 }
289 if (!frontendMap[live.frontendId].canConnectToCiCam) {
290 return;
291 }
292 mFrontendTests.tuneTest(frontendMap[live.frontendId]);
293 }
294
295 INSTANTIATE_TEST_SUITE_P(
296 PerInstance, TunerBroadcastHidlTest,
297 testing::ValuesIn(android::hardware::getAllHalInstanceNames(ITuner::descriptor)),
298 android::hardware::PrintInstanceNameToString);
299
300 INSTANTIATE_TEST_SUITE_P(
301 PerInstance, TunerFrontendHidlTest,
302 testing::ValuesIn(android::hardware::getAllHalInstanceNames(ITuner::descriptor)),
303 android::hardware::PrintInstanceNameToString);
304
305 INSTANTIATE_TEST_SUITE_P(
306 PerInstance, TunerFilterHidlTest,
307 testing::ValuesIn(android::hardware::getAllHalInstanceNames(ITuner::descriptor)),
308 android::hardware::PrintInstanceNameToString);
309
310 INSTANTIATE_TEST_SUITE_P(
311 PerInstance, TunerRecordHidlTest,
312 testing::ValuesIn(android::hardware::getAllHalInstanceNames(ITuner::descriptor)),
313 android::hardware::PrintInstanceNameToString);
314 } // namespace
315