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_0TargetTest.h"
18
19 namespace {
20
filterDataOutputTest(vector<string>)21 AssertionResult TunerBroadcastHidlTest::filterDataOutputTest(vector<string> /*goldenOutputFiles*/) {
22 return filterDataOutputTestBase(mFilterTests);
23 }
24
filterDataOutputTest(vector<string>)25 AssertionResult TunerPlaybackHidlTest::filterDataOutputTest(vector<string> /*goldenOutputFiles*/) {
26 return filterDataOutputTestBase(mFilterTests);
27 }
28
filterDataOutputTest(vector<string>)29 AssertionResult TunerDescramblerHidlTest::filterDataOutputTest(
30 vector<string> /*goldenOutputFiles*/) {
31 return filterDataOutputTestBase(mFilterTests);
32 }
33
configSingleFilterInDemuxTest(FilterConfig filterConf,FrontendConfig frontendConf)34 void TunerFilterHidlTest::configSingleFilterInDemuxTest(FilterConfig filterConf,
35 FrontendConfig frontendConf) {
36 uint32_t feId;
37 uint32_t demuxId;
38 sp<IDemux> demux;
39 uint32_t filterId;
40
41 mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
42 ASSERT_TRUE(feId != INVALID_ID);
43 ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
44 ASSERT_TRUE(mFrontendTests.setFrontendCallback());
45 ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
46 ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
47 mFilterTests.setDemux(demux);
48 ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type, filterConf.bufferSize));
49 ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId(filterId));
50 ASSERT_TRUE(mFilterTests.configFilter(filterConf.settings, filterId));
51 ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId));
52 ASSERT_TRUE(mFilterTests.startFilter(filterId));
53 ASSERT_TRUE(mFilterTests.stopFilter(filterId));
54 ASSERT_TRUE(mFilterTests.closeFilter(filterId));
55 ASSERT_TRUE(mDemuxTests.closeDemux());
56 ASSERT_TRUE(mFrontendTests.closeFrontend());
57 }
58
testTimeFilter(TimeFilterConfig filterConf)59 void TunerFilterHidlTest::testTimeFilter(TimeFilterConfig filterConf) {
60 if (!filterConf.supportTimeFilter) {
61 return;
62 }
63 uint32_t demuxId;
64 sp<IDemux> demux;
65
66 ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
67 mFilterTests.setDemux(demux);
68 ASSERT_TRUE(mFilterTests.openTimeFilterInDemux());
69 ASSERT_TRUE(mFilterTests.setTimeStamp(filterConf.timeStamp));
70 ASSERT_TRUE(mFilterTests.getTimeStamp());
71 ASSERT_TRUE(mFilterTests.clearTimeStamp());
72 ASSERT_TRUE(mFilterTests.closeTimeFilter());
73 ASSERT_TRUE(mDemuxTests.closeDemux());
74 }
75
broadcastSingleFilterTest(FilterConfig filterConf,FrontendConfig frontendConf)76 void TunerBroadcastHidlTest::broadcastSingleFilterTest(FilterConfig filterConf,
77 FrontendConfig frontendConf) {
78 uint32_t feId;
79 uint32_t demuxId;
80 sp<IDemux> demux;
81 uint32_t filterId;
82
83 mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
84 if (feId == INVALID_ID) {
85 // TODO broadcast test on Cuttlefish needs licensed ts input,
86 // these tests are runnable on vendor device with real frontend module
87 // or with manual ts installing and use DVBT frontend.
88 return;
89 }
90 ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
91 ASSERT_TRUE(mFrontendTests.setFrontendCallback());
92 if (mLnbId) {
93 ASSERT_TRUE(mFrontendTests.setLnb(*mLnbId));
94 }
95 ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
96 ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
97 mFrontendTests.setDemux(demux);
98 mFilterTests.setDemux(demux);
99 ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type, filterConf.bufferSize));
100 ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId(filterId));
101 ASSERT_TRUE(mFilterTests.configFilter(filterConf.settings, filterId));
102 ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId));
103 ASSERT_TRUE(mFilterTests.startFilter(filterId));
104 // tune test
105 ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
106 ASSERT_TRUE(filterDataOutputTest(goldenOutputFiles));
107 ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
108 ASSERT_TRUE(mFilterTests.stopFilter(filterId));
109 ASSERT_TRUE(mFilterTests.closeFilter(filterId));
110 ASSERT_TRUE(mDemuxTests.closeDemux());
111 ASSERT_TRUE(mFrontendTests.closeFrontend());
112 }
113
broadcastSingleFilterTestWithLnb(FilterConfig filterConf,FrontendConfig frontendConf,LnbConfig lnbConf)114 void TunerBroadcastHidlTest::broadcastSingleFilterTestWithLnb(FilterConfig filterConf,
115 FrontendConfig frontendConf,
116 LnbConfig lnbConf) {
117 vector<uint32_t> ids;
118 ASSERT_TRUE(mLnbTests.getLnbIds(ids));
119 if (!lnbConf.usingLnb) {
120 return;
121 }
122 ASSERT_TRUE(ids.size() > 0);
123 ASSERT_TRUE(mLnbTests.openLnbById(ids[0]));
124 *mLnbId = ids[0];
125 ASSERT_TRUE(mLnbTests.setLnbCallback());
126 ASSERT_TRUE(mLnbTests.setVoltage(lnbConf.voltage));
127 ASSERT_TRUE(mLnbTests.setTone(lnbConf.tone));
128 ASSERT_TRUE(mLnbTests.setSatellitePosition(lnbConf.position));
129 broadcastSingleFilterTest(filterConf, frontendConf);
130 ASSERT_TRUE(mLnbTests.closeLnb());
131 mLnbId = nullptr;
132 }
133
playbackSingleFilterTest(FilterConfig filterConf,DvrConfig dvrConf)134 void TunerPlaybackHidlTest::playbackSingleFilterTest(FilterConfig filterConf, DvrConfig dvrConf) {
135 uint32_t demuxId;
136 sp<IDemux> demux;
137 uint32_t filterId;
138
139 ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
140 mFilterTests.setDemux(demux);
141 mDvrTests.setDemux(demux);
142 ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrConf.type, dvrConf.bufferSize));
143 ASSERT_TRUE(mDvrTests.configDvrPlayback(dvrConf.settings));
144 ASSERT_TRUE(mDvrTests.getDvrPlaybackMQDescriptor());
145 ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type, filterConf.bufferSize));
146 ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId(filterId));
147 ASSERT_TRUE(mFilterTests.configFilter(filterConf.settings, filterId));
148 ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId));
149 mDvrTests.startPlaybackInputThread(dvrConf.playbackInputFile, dvrConf.settings.playback());
150 ASSERT_TRUE(mDvrTests.startDvrPlayback());
151 ASSERT_TRUE(mFilterTests.startFilter(filterId));
152 ASSERT_TRUE(filterDataOutputTest(goldenOutputFiles));
153 mDvrTests.stopPlaybackThread();
154 ASSERT_TRUE(mFilterTests.stopFilter(filterId));
155 ASSERT_TRUE(mDvrTests.stopDvrPlayback());
156 ASSERT_TRUE(mFilterTests.closeFilter(filterId));
157 mDvrTests.closeDvrPlayback();
158 ASSERT_TRUE(mDemuxTests.closeDemux());
159 }
160
recordSingleFilterTest(FilterConfig filterConf,FrontendConfig frontendConf,DvrConfig dvrConf)161 void TunerRecordHidlTest::recordSingleFilterTest(FilterConfig filterConf,
162 FrontendConfig frontendConf, DvrConfig dvrConf) {
163 uint32_t feId;
164 uint32_t demuxId;
165 sp<IDemux> demux;
166 uint32_t filterId;
167 sp<IFilter> filter;
168
169 mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
170 ASSERT_TRUE(feId != INVALID_ID);
171 ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
172 ASSERT_TRUE(mFrontendTests.setFrontendCallback());
173 if (mLnbId) {
174 ASSERT_TRUE(mFrontendTests.setLnb(*mLnbId));
175 }
176 ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
177 ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
178 mFilterTests.setDemux(demux);
179 mDvrTests.setDemux(demux);
180 mFrontendTests.setDvrTests(mDvrTests);
181 ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrConf.type, dvrConf.bufferSize));
182 ASSERT_TRUE(mDvrTests.configDvrRecord(dvrConf.settings));
183 ASSERT_TRUE(mDvrTests.getDvrRecordMQDescriptor());
184 ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type, filterConf.bufferSize));
185 ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId(filterId));
186 ASSERT_TRUE(mFilterTests.configFilter(filterConf.settings, filterId));
187 ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId));
188 filter = mFilterTests.getFilterById(filterId);
189 ASSERT_TRUE(filter != nullptr);
190 mDvrTests.startRecordOutputThread(dvrConf.settings.record());
191 ASSERT_TRUE(mDvrTests.attachFilterToDvr(filter));
192 ASSERT_TRUE(mDvrTests.startDvrRecord());
193 ASSERT_TRUE(mFilterTests.startFilter(filterId));
194 ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
195 mDvrTests.testRecordOutput();
196 mDvrTests.stopRecordThread();
197 ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
198 ASSERT_TRUE(mFilterTests.stopFilter(filterId));
199 ASSERT_TRUE(mDvrTests.stopDvrRecord());
200 ASSERT_TRUE(mDvrTests.detachFilterToDvr(filter));
201 ASSERT_TRUE(mFilterTests.closeFilter(filterId));
202 mDvrTests.closeDvrRecord();
203 ASSERT_TRUE(mDemuxTests.closeDemux());
204 ASSERT_TRUE(mFrontendTests.closeFrontend());
205 }
206
recordSingleFilterTestWithLnb(FilterConfig filterConf,FrontendConfig frontendConf,DvrConfig dvrConf,LnbConfig lnbConf)207 void TunerRecordHidlTest::recordSingleFilterTestWithLnb(FilterConfig filterConf,
208 FrontendConfig frontendConf,
209 DvrConfig dvrConf, LnbConfig lnbConf) {
210 vector<uint32_t> ids;
211 ASSERT_TRUE(mLnbTests.getLnbIds(ids));
212 if (!lnbConf.usingLnb) {
213 return;
214 }
215 ASSERT_TRUE(ids.size() > 0);
216 ASSERT_TRUE(mLnbTests.openLnbById(ids[0]));
217 *mLnbId = ids[0];
218 ASSERT_TRUE(mLnbTests.setLnbCallback());
219 ASSERT_TRUE(mLnbTests.setVoltage(lnbConf.voltage));
220 ASSERT_TRUE(mLnbTests.setTone(lnbConf.tone));
221 ASSERT_TRUE(mLnbTests.setSatellitePosition(lnbConf.position));
222 recordSingleFilterTest(filterConf, frontendConf, dvrConf);
223 ASSERT_TRUE(mLnbTests.closeLnb());
224 mLnbId = nullptr;
225 }
226
attachSingleFilterToRecordDvrTest(FilterConfig filterConf,FrontendConfig frontendConf,DvrConfig dvrConf)227 void TunerRecordHidlTest::attachSingleFilterToRecordDvrTest(FilterConfig filterConf,
228 FrontendConfig frontendConf,
229 DvrConfig dvrConf) {
230 uint32_t feId;
231 uint32_t demuxId;
232 sp<IDemux> demux;
233 uint32_t filterId;
234 sp<IFilter> filter;
235
236 mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
237 ASSERT_TRUE(feId != INVALID_ID);
238 ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
239 ASSERT_TRUE(mFrontendTests.setFrontendCallback());
240 ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
241 ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
242 mFilterTests.setDemux(demux);
243 mDvrTests.setDemux(demux);
244 ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrConf.type, dvrConf.bufferSize));
245 ASSERT_TRUE(mDvrTests.configDvrRecord(dvrConf.settings));
246 ASSERT_TRUE(mDvrTests.getDvrRecordMQDescriptor());
247 ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type, filterConf.bufferSize));
248 ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId(filterId));
249 ASSERT_TRUE(mFilterTests.configFilter(filterConf.settings, filterId));
250 ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId));
251 filter = mFilterTests.getFilterById(filterId);
252 ASSERT_TRUE(filter != nullptr);
253 ASSERT_TRUE(mDvrTests.attachFilterToDvr(filter));
254 ASSERT_TRUE(mDvrTests.startDvrRecord());
255 ASSERT_TRUE(mFilterTests.startFilter(filterId));
256 ASSERT_TRUE(mFilterTests.stopFilter(filterId));
257 ASSERT_TRUE(mDvrTests.stopDvrRecord());
258 ASSERT_TRUE(mDvrTests.detachFilterToDvr(filter));
259 ASSERT_TRUE(mFilterTests.closeFilter(filterId));
260 mDvrTests.closeDvrRecord();
261 ASSERT_TRUE(mDemuxTests.closeDemux());
262 ASSERT_TRUE(mFrontendTests.closeFrontend());
263 }
264
scrambledBroadcastTest(set<struct FilterConfig> mediaFilterConfs,FrontendConfig frontendConf,DescramblerConfig descConfig)265 void TunerDescramblerHidlTest::scrambledBroadcastTest(set<struct FilterConfig> mediaFilterConfs,
266 FrontendConfig frontendConf,
267 DescramblerConfig descConfig) {
268 uint32_t feId;
269 uint32_t demuxId;
270 sp<IDemux> demux;
271 set<uint32_t> filterIds;
272 uint32_t filterId;
273 set<struct FilterConfig>::iterator config;
274 set<uint32_t>::iterator id;
275
276 mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
277 if (feId == INVALID_ID) {
278 // TODO broadcast test on Cuttlefish needs licensed ts input,
279 // these tests are runnable on vendor device with real frontend module
280 // or with manual ts installing and use DVBT frontend.
281 return;
282 }
283 ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
284 ASSERT_TRUE(mFrontendTests.setFrontendCallback());
285 ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
286 ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
287 mFilterTests.setDemux(demux);
288 mFrontendTests.setDemux(demux);
289 for (config = mediaFilterConfs.begin(); config != mediaFilterConfs.end(); config++) {
290 ASSERT_TRUE(mFilterTests.openFilterInDemux((*config).type, (*config).bufferSize));
291 ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId(filterId));
292 ASSERT_TRUE(mFilterTests.configFilter((*config).settings, filterId));
293 filterIds.insert(filterId);
294 }
295 ASSERT_TRUE(mDescramblerTests.openDescrambler(demuxId));
296 TunerKeyToken token;
297 ASSERT_TRUE(mDescramblerTests.getKeyToken(descConfig.casSystemId, descConfig.provisionStr,
298 descConfig.hidlPvtData, token));
299 ASSERT_TRUE(mDescramblerTests.setKeyToken(token));
300 vector<DemuxPid> pids;
301 DemuxPid pid;
302 for (config = mediaFilterConfs.begin(); config != mediaFilterConfs.end(); config++) {
303 ASSERT_TRUE(mDescramblerTests.getDemuxPidFromFilterSettings((*config).type,
304 (*config).settings, pid));
305 pids.push_back(pid);
306 ASSERT_TRUE(mDescramblerTests.addPid(pid, nullptr));
307 }
308 for (id = filterIds.begin(); id != filterIds.end(); id++) {
309 ASSERT_TRUE(mFilterTests.startFilter(*id));
310 }
311 // tune test
312 ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
313 ASSERT_TRUE(filterDataOutputTest(goldenOutputFiles));
314 ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
315 for (id = filterIds.begin(); id != filterIds.end(); id++) {
316 ASSERT_TRUE(mFilterTests.stopFilter(*id));
317 }
318 for (auto pid : pids) {
319 ASSERT_TRUE(mDescramblerTests.removePid(pid, nullptr));
320 }
321 ASSERT_TRUE(mDescramblerTests.closeDescrambler());
322 for (id = filterIds.begin(); id != filterIds.end(); id++) {
323 ASSERT_TRUE(mFilterTests.closeFilter(*id));
324 }
325 ASSERT_TRUE(mDemuxTests.closeDemux());
326 ASSERT_TRUE(mFrontendTests.closeFrontend());
327 }
328
TEST_P(TunerFrontendHidlTest,TuneFrontend)329 TEST_P(TunerFrontendHidlTest, TuneFrontend) {
330 description("Tune one Frontend with specific setting and check Lock event");
331 mFrontendTests.tuneTest(frontendArray[DVBT]);
332 }
333
TEST_P(TunerFrontendHidlTest,AutoScanFrontend)334 TEST_P(TunerFrontendHidlTest, AutoScanFrontend) {
335 description("Run an auto frontend scan with specific setting and check lock scanMessage");
336 mFrontendTests.scanTest(frontendScanArray[SCAN_DVBT], FrontendScanType::SCAN_AUTO);
337 }
338
TEST_P(TunerFrontendHidlTest,BlindScanFrontend)339 TEST_P(TunerFrontendHidlTest, BlindScanFrontend) {
340 description("Run an blind frontend scan with specific setting and check lock scanMessage");
341 mFrontendTests.scanTest(frontendScanArray[SCAN_DVBT], FrontendScanType::SCAN_BLIND);
342 }
343
TEST_P(TunerLnbHidlTest,OpenLnbByName)344 TEST_P(TunerLnbHidlTest, OpenLnbByName) {
345 description("Open and configure an Lnb with name then send a diseqc msg to it.");
346 ASSERT_TRUE(mLnbTests.openLnbByName(lnbArray[LNB_EXTERNAL].name));
347 ASSERT_TRUE(mLnbTests.setLnbCallback());
348 ASSERT_TRUE(mLnbTests.setVoltage(lnbArray[LNB_EXTERNAL].voltage));
349 ASSERT_TRUE(mLnbTests.setTone(lnbArray[LNB_EXTERNAL].tone));
350 ASSERT_TRUE(mLnbTests.setSatellitePosition(lnbArray[LNB_EXTERNAL].position));
351 ASSERT_TRUE(mLnbTests.sendDiseqcMessage(diseqcMsgArray[DISEQC_POWER_ON]));
352 ASSERT_TRUE(mLnbTests.closeLnb());
353 }
354
TEST_P(TunerLnbHidlTest,SendDiseqcMessageToLnb)355 TEST_P(TunerLnbHidlTest, SendDiseqcMessageToLnb) {
356 description("Open and configure an Lnb with specific settings then send a diseqc msg to it.");
357 vector<uint32_t> ids;
358 ASSERT_TRUE(mLnbTests.getLnbIds(ids));
359 if (!lnbArray[LNB0].usingLnb) {
360 return;
361 }
362 ASSERT_TRUE(ids.size() > 0);
363 ASSERT_TRUE(mLnbTests.openLnbById(ids[0]));
364 ASSERT_TRUE(mLnbTests.setLnbCallback());
365 ASSERT_TRUE(mLnbTests.setVoltage(lnbArray[LNB0].voltage));
366 ASSERT_TRUE(mLnbTests.setTone(lnbArray[LNB0].tone));
367 ASSERT_TRUE(mLnbTests.setSatellitePosition(lnbArray[LNB0].position));
368 ASSERT_TRUE(mLnbTests.sendDiseqcMessage(diseqcMsgArray[DISEQC_POWER_ON]));
369 ASSERT_TRUE(mLnbTests.closeLnb());
370 }
371
TEST_P(TunerDemuxHidlTest,openDemux)372 TEST_P(TunerDemuxHidlTest, openDemux) {
373 description("Open and close a Demux.");
374 uint32_t feId;
375 uint32_t demuxId;
376 sp<IDemux> demux;
377 mFrontendTests.getFrontendIdByType(frontendArray[DVBT].type, feId);
378 ASSERT_TRUE(feId != INVALID_ID);
379 ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
380 ASSERT_TRUE(mFrontendTests.setFrontendCallback());
381 ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
382 ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
383 ASSERT_TRUE(mDemuxTests.closeDemux());
384 ASSERT_TRUE(mFrontendTests.closeFrontend());
385 }
386
TEST_P(TunerDemuxHidlTest,getAvSyncTime)387 TEST_P(TunerDemuxHidlTest, getAvSyncTime) {
388 description("Get the A/V sync time from a PCR filter.");
389 uint32_t feId;
390 uint32_t demuxId;
391 sp<IDemux> demux;
392 uint32_t mediaFilterId;
393 uint32_t pcrFilterId;
394 uint32_t avSyncHwId;
395 sp<IFilter> mediaFilter;
396
397 mFrontendTests.getFrontendIdByType(frontendArray[DVBT].type, feId);
398 ASSERT_TRUE(feId != INVALID_ID);
399 ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
400 ASSERT_TRUE(mFrontendTests.setFrontendCallback());
401 ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
402 ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
403 mFilterTests.setDemux(demux);
404 ASSERT_TRUE(mFilterTests.openFilterInDemux(filterArray[TS_VIDEO1].type,
405 filterArray[TS_VIDEO1].bufferSize));
406 ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId(mediaFilterId));
407 ASSERT_TRUE(mFilterTests.configFilter(filterArray[TS_VIDEO1].settings, mediaFilterId));
408 mediaFilter = mFilterTests.getFilterById(mediaFilterId);
409 ASSERT_TRUE(mFilterTests.openFilterInDemux(filterArray[TS_PCR0].type,
410 filterArray[TS_PCR0].bufferSize));
411 ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId(pcrFilterId));
412 ASSERT_TRUE(mFilterTests.configFilter(filterArray[TS_PCR0].settings, pcrFilterId));
413 ASSERT_TRUE(mDemuxTests.getAvSyncId(mediaFilter, avSyncHwId));
414 ASSERT_TRUE(pcrFilterId == avSyncHwId);
415 ASSERT_TRUE(mDemuxTests.getAvSyncTime(pcrFilterId));
416 ASSERT_TRUE(mFilterTests.closeFilter(pcrFilterId));
417 ASSERT_TRUE(mFilterTests.closeFilter(mediaFilterId));
418 ASSERT_TRUE(mDemuxTests.closeDemux());
419 ASSERT_TRUE(mFrontendTests.closeFrontend());
420 }
421
TEST_P(TunerFilterHidlTest,StartFilterInDemux)422 TEST_P(TunerFilterHidlTest, StartFilterInDemux) {
423 description("Open and start a filter in Demux.");
424 // TODO use paramterized tests
425 configSingleFilterInDemuxTest(filterArray[TS_VIDEO0], frontendArray[DVBT]);
426 }
427
TEST_P(TunerFilterHidlTest,SetFilterLinkage)428 TEST_P(TunerFilterHidlTest, SetFilterLinkage) {
429 description("Pick up all the possible linkages from the demux caps and set them up.");
430 DemuxCapabilities caps;
431 uint32_t demuxId;
432 sp<IDemux> demux;
433 ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
434 ASSERT_TRUE(mDemuxTests.getDemuxCaps(caps));
435 mFilterTests.setDemux(demux);
436 for (int i = 0; i < caps.linkCaps.size(); i++) {
437 uint32_t bitMask = 1;
438 for (int j = 0; j < FILTER_MAIN_TYPE_BIT_COUNT; j++) {
439 if (caps.linkCaps[i] & (bitMask << j)) {
440 uint32_t sourceFilterId;
441 uint32_t sinkFilterId;
442 ASSERT_TRUE(mFilterTests.openFilterInDemux(filterLinkageTypes[SOURCE][i],
443 FMQ_SIZE_16M));
444 ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId(sourceFilterId));
445 ASSERT_TRUE(
446 mFilterTests.openFilterInDemux(filterLinkageTypes[SINK][j], FMQ_SIZE_16M));
447 ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId(sinkFilterId));
448 ASSERT_TRUE(mFilterTests.setFilterDataSource(sourceFilterId, sinkFilterId));
449 ASSERT_TRUE(mFilterTests.setFilterDataSourceToDemux(sinkFilterId));
450 ASSERT_TRUE(mFilterTests.closeFilter(sinkFilterId));
451 ASSERT_TRUE(mFilterTests.closeFilter(sourceFilterId));
452 }
453 }
454 }
455 ASSERT_TRUE(mDemuxTests.closeDemux());
456 }
457
TEST_P(TunerFilterHidlTest,testTimeFilter)458 TEST_P(TunerFilterHidlTest, testTimeFilter) {
459 description("Open a timer filter in Demux and set time stamp.");
460 // TODO use paramterized tests
461 testTimeFilter(timeFilterArray[TIMER0]);
462 }
463
TEST_P(TunerBroadcastHidlTest,BroadcastDataFlowVideoFilterTest)464 TEST_P(TunerBroadcastHidlTest, BroadcastDataFlowVideoFilterTest) {
465 description("Test Video Filter functionality in Broadcast use case.");
466 broadcastSingleFilterTest(filterArray[TS_VIDEO1], frontendArray[DVBT]);
467 }
468
TEST_P(TunerBroadcastHidlTest,BroadcastDataFlowAudioFilterTest)469 TEST_P(TunerBroadcastHidlTest, BroadcastDataFlowAudioFilterTest) {
470 description("Test Audio Filter functionality in Broadcast use case.");
471 broadcastSingleFilterTest(filterArray[TS_AUDIO0], frontendArray[DVBT]);
472 }
473
TEST_P(TunerBroadcastHidlTest,BroadcastDataFlowSectionFilterTest)474 TEST_P(TunerBroadcastHidlTest, BroadcastDataFlowSectionFilterTest) {
475 description("Test Section Filter functionality in Broadcast use case.");
476 broadcastSingleFilterTest(filterArray[TS_SECTION0], frontendArray[DVBT]);
477 }
478
TEST_P(TunerBroadcastHidlTest,IonBufferTest)479 TEST_P(TunerBroadcastHidlTest, IonBufferTest) {
480 description("Test the av filter data bufferring.");
481 broadcastSingleFilterTest(filterArray[TS_VIDEO0], frontendArray[DVBT]);
482 }
483
TEST_P(TunerBroadcastHidlTest,LnbBroadcastDataFlowVideoFilterTest)484 TEST_P(TunerBroadcastHidlTest, LnbBroadcastDataFlowVideoFilterTest) {
485 description("Test Video Filter functionality in Broadcast with Lnb use case.");
486 broadcastSingleFilterTest(filterArray[TS_VIDEO0], frontendArray[DVBS]);
487 }
488
TEST_P(TunerPlaybackHidlTest,PlaybackDataFlowWithTsSectionFilterTest)489 TEST_P(TunerPlaybackHidlTest, PlaybackDataFlowWithTsSectionFilterTest) {
490 description("Feed ts data from playback and configure Ts section filter to get output");
491 playbackSingleFilterTest(filterArray[TS_SECTION0], dvrArray[DVR_PLAYBACK0]);
492 }
493
TEST_P(TunerRecordHidlTest,AttachFiltersToRecordTest)494 TEST_P(TunerRecordHidlTest, AttachFiltersToRecordTest) {
495 description("Attach a single filter to the record dvr test.");
496 // TODO use paramterized tests
497 attachSingleFilterToRecordDvrTest(filterArray[TS_RECORD0], frontendArray[DVBT],
498 dvrArray[DVR_RECORD0]);
499 }
500
TEST_P(TunerRecordHidlTest,RecordDataFlowWithTsRecordFilterTest)501 TEST_P(TunerRecordHidlTest, RecordDataFlowWithTsRecordFilterTest) {
502 description("Feed ts data from frontend to recording and test with ts record filter");
503 recordSingleFilterTest(filterArray[TS_RECORD0], frontendArray[DVBT], dvrArray[DVR_RECORD0]);
504 }
505
TEST_P(TunerRecordHidlTest,LnbRecordDataFlowWithTsRecordFilterTest)506 TEST_P(TunerRecordHidlTest, LnbRecordDataFlowWithTsRecordFilterTest) {
507 description("Feed ts data from Fe with Lnb to recording and test with ts record filter");
508 recordSingleFilterTest(filterArray[TS_RECORD0], frontendArray[DVBS], dvrArray[DVR_RECORD0]);
509 }
510
TEST_P(TunerDescramblerHidlTest,CreateDescrambler)511 TEST_P(TunerDescramblerHidlTest, CreateDescrambler) {
512 description("Create Descrambler");
513 uint32_t feId;
514 uint32_t demuxId;
515 sp<IDemux> demux;
516 mFrontendTests.getFrontendIdByType(frontendArray[DVBT].type, feId);
517 ASSERT_TRUE(feId != INVALID_ID);
518 ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
519 ASSERT_TRUE(mFrontendTests.setFrontendCallback());
520 ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
521 ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
522 ASSERT_TRUE(mDescramblerTests.openDescrambler(demuxId));
523 ASSERT_TRUE(mDescramblerTests.closeDescrambler());
524 ASSERT_TRUE(mDemuxTests.closeDemux());
525 ASSERT_TRUE(mFrontendTests.closeFrontend());
526 }
527
TEST_P(TunerDescramblerHidlTest,ScrambledBroadcastDataFlowMediaFiltersTest)528 TEST_P(TunerDescramblerHidlTest, ScrambledBroadcastDataFlowMediaFiltersTest) {
529 description("Test ts audio filter in scrambled broadcast use case");
530 set<FilterConfig> filterConfs;
531 filterConfs.insert(filterArray[TS_AUDIO0]);
532 filterConfs.insert(filterArray[TS_VIDEO1]);
533 scrambledBroadcastTest(filterConfs, frontendArray[DVBT], descramblerArray[DESC_0]);
534 }
535
536 INSTANTIATE_TEST_SUITE_P(
537 PerInstance, TunerFrontendHidlTest,
538 testing::ValuesIn(android::hardware::getAllHalInstanceNames(ITuner::descriptor)),
539 android::hardware::PrintInstanceNameToString);
540
541 INSTANTIATE_TEST_SUITE_P(
542 PerInstance, TunerLnbHidlTest,
543 testing::ValuesIn(android::hardware::getAllHalInstanceNames(ITuner::descriptor)),
544 android::hardware::PrintInstanceNameToString);
545
546 INSTANTIATE_TEST_SUITE_P(
547 PerInstance, TunerDemuxHidlTest,
548 testing::ValuesIn(android::hardware::getAllHalInstanceNames(ITuner::descriptor)),
549 android::hardware::PrintInstanceNameToString);
550
551 INSTANTIATE_TEST_SUITE_P(
552 PerInstance, TunerFilterHidlTest,
553 testing::ValuesIn(android::hardware::getAllHalInstanceNames(ITuner::descriptor)),
554 android::hardware::PrintInstanceNameToString);
555
556 INSTANTIATE_TEST_SUITE_P(
557 PerInstance, TunerBroadcastHidlTest,
558 testing::ValuesIn(android::hardware::getAllHalInstanceNames(ITuner::descriptor)),
559 android::hardware::PrintInstanceNameToString);
560
561 INSTANTIATE_TEST_SUITE_P(
562 PerInstance, TunerPlaybackHidlTest,
563 testing::ValuesIn(android::hardware::getAllHalInstanceNames(ITuner::descriptor)),
564 android::hardware::PrintInstanceNameToString);
565
566 INSTANTIATE_TEST_SUITE_P(
567 PerInstance, TunerRecordHidlTest,
568 testing::ValuesIn(android::hardware::getAllHalInstanceNames(ITuner::descriptor)),
569 android::hardware::PrintInstanceNameToString);
570
571 INSTANTIATE_TEST_SUITE_P(
572 PerInstance, TunerDescramblerHidlTest,
573 testing::ValuesIn(android::hardware::getAllHalInstanceNames(ITuner::descriptor)),
574 android::hardware::PrintInstanceNameToString);
575 } // namespace
576