1 /*
2 * Copyright 2021 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 "VtsHalTvTunerTargetTest.h"
18
19 #include <aidl/Gtest.h>
20 #include <aidl/Vintf.h>
21 #include <android/binder_manager.h>
22 #include <android/binder_process.h>
23
24 namespace {
25
filterDataOutputTest()26 AssertionResult TunerBroadcastAidlTest::filterDataOutputTest() {
27 return filterDataOutputTestBase(mFilterTests);
28 }
29
filterDataOutputTest()30 AssertionResult TunerPlaybackAidlTest::filterDataOutputTest() {
31 return filterDataOutputTestBase(mFilterTests);
32 }
33
filterDataOutputTest()34 AssertionResult TunerDescramblerAidlTest::filterDataOutputTest() {
35 return filterDataOutputTestBase(mFilterTests);
36 }
37
configSingleFilterInDemuxTest(FilterConfig filterConf,FrontendConfig frontendConf)38 void TunerFilterAidlTest::configSingleFilterInDemuxTest(FilterConfig filterConf,
39 FrontendConfig frontendConf) {
40 int32_t feId;
41 int32_t demuxId;
42 std::shared_ptr<IDemux> demux;
43 int64_t filterId;
44
45 mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
46 ASSERT_TRUE(feId != INVALID_ID);
47 ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
48 ASSERT_TRUE(mFrontendTests.setFrontendCallback());
49 ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
50 ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
51 mFilterTests.setDemux(demux);
52 ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type, filterConf.bufferSize));
53 ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
54 ASSERT_TRUE(mFilterTests.configFilter(filterConf.settings, filterId));
55 if (filterConf.type.mainType == DemuxFilterMainType::IP) {
56 ASSERT_TRUE(mFilterTests.configIpFilterCid(filterConf.ipCid, filterId));
57 }
58 if (filterConf.monitorEventTypes > 0) {
59 ASSERT_TRUE(mFilterTests.configureMonitorEvent(filterId, filterConf.monitorEventTypes));
60 }
61 ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId, filterConf.getMqDesc));
62 ASSERT_TRUE(mFilterTests.startFilter(filterId));
63 ASSERT_TRUE(mFilterTests.stopFilter(filterId));
64 ASSERT_TRUE(mFilterTests.closeFilter(filterId));
65 ASSERT_TRUE(mDemuxTests.closeDemux());
66 ASSERT_TRUE(mFrontendTests.closeFrontend());
67 }
68
reconfigSingleFilterInDemuxTest(FilterConfig filterConf,FilterConfig filterReconf,FrontendConfig frontendConf)69 void TunerFilterAidlTest::reconfigSingleFilterInDemuxTest(FilterConfig filterConf,
70 FilterConfig filterReconf,
71 FrontendConfig frontendConf) {
72 int32_t feId;
73 int32_t demuxId;
74 std::shared_ptr<IDemux> demux;
75 int64_t filterId;
76
77 mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
78 ASSERT_TRUE(feId != INVALID_ID);
79 ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
80 ASSERT_TRUE(mFrontendTests.setFrontendCallback());
81 if (frontendConf.isSoftwareFe) {
82 mFrontendTests.setSoftwareFrontendDvrConfig(dvrMap[live.dvrSoftwareFeId]);
83 }
84 ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
85 ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
86 mFrontendTests.setDemux(demux);
87 mFilterTests.setDemux(demux);
88 ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type, filterConf.bufferSize));
89 ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
90 ASSERT_TRUE(mFilterTests.configFilter(filterConf.settings, filterId));
91 ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId, filterConf.getMqDesc));
92 ASSERT_TRUE(mFilterTests.startFilter(filterId));
93 ASSERT_TRUE(mFilterTests.stopFilter(filterId));
94 ASSERT_TRUE(mFilterTests.configFilter(filterReconf.settings, filterId));
95 ASSERT_TRUE(mFilterTests.startFilter(filterId));
96 ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
97 ASSERT_TRUE(mFilterTests.startIdTest(filterId));
98 ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
99 ASSERT_TRUE(mFilterTests.stopFilter(filterId));
100 ASSERT_TRUE(mFilterTests.closeFilter(filterId));
101 ASSERT_TRUE(mDemuxTests.closeDemux());
102 ASSERT_TRUE(mFrontendTests.closeFrontend());
103 }
104
testTimeFilter(TimeFilterConfig filterConf)105 void TunerFilterAidlTest::testTimeFilter(TimeFilterConfig filterConf) {
106 int32_t demuxId;
107 std::shared_ptr<IDemux> demux;
108 DemuxCapabilities caps;
109
110 ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
111 ASSERT_TRUE(mDemuxTests.getDemuxCaps(caps));
112 ASSERT_TRUE(caps.bTimeFilter);
113 mFilterTests.setDemux(demux);
114 ASSERT_TRUE(mFilterTests.openTimeFilterInDemux());
115 ASSERT_TRUE(mFilterTests.setTimeStamp(filterConf.timeStamp));
116 ASSERT_TRUE(mFilterTests.getTimeStamp());
117 ASSERT_TRUE(mFilterTests.clearTimeStamp());
118 ASSERT_TRUE(mFilterTests.closeTimeFilter());
119 ASSERT_TRUE(mDemuxTests.closeDemux());
120 }
121
broadcastSingleFilterTest(FilterConfig filterConf,FrontendConfig frontendConf)122 void TunerBroadcastAidlTest::broadcastSingleFilterTest(FilterConfig filterConf,
123 FrontendConfig frontendConf) {
124 int32_t feId;
125 int32_t demuxId;
126 std::shared_ptr<IDemux> demux;
127 int64_t filterId;
128
129 mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
130 ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
131 ASSERT_TRUE(mFrontendTests.setFrontendCallback());
132 if (mLnbId != INVALID_LNB_ID) {
133 ASSERT_TRUE(mFrontendTests.setLnb(mLnbId));
134 }
135 if (frontendConf.isSoftwareFe) {
136 mFrontendTests.setSoftwareFrontendDvrConfig(dvrMap[live.dvrSoftwareFeId]);
137 }
138 ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
139 ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
140 mFrontendTests.setDemux(demux);
141 mFilterTests.setDemux(demux);
142 ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type, filterConf.bufferSize));
143 ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
144 ASSERT_TRUE(mFilterTests.configFilter(filterConf.settings, filterId));
145 ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId, filterConf.getMqDesc));
146 ASSERT_TRUE(mFilterTests.startFilter(filterId));
147 // tune test
148 ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
149 ASSERT_TRUE(filterDataOutputTest());
150 ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
151 ASSERT_TRUE(mFilterTests.stopFilter(filterId));
152 ASSERT_TRUE(mFilterTests.closeFilter(filterId));
153 ASSERT_TRUE(mDemuxTests.closeDemux());
154 ASSERT_TRUE(mFrontendTests.closeFrontend());
155 }
156
broadcastSingleFilterTestWithLnb(FilterConfig filterConf,FrontendConfig frontendConf,LnbConfig lnbConf)157 void TunerBroadcastAidlTest::broadcastSingleFilterTestWithLnb(FilterConfig filterConf,
158 FrontendConfig frontendConf,
159 LnbConfig lnbConf) {
160 if (lnbConf.name.compare(emptyHardwareId) == 0) {
161 vector<int32_t> ids;
162 ASSERT_TRUE(mLnbTests.getLnbIds(ids));
163 ASSERT_TRUE(ids.size() > 0);
164 ASSERT_TRUE(mLnbTests.openLnbById(ids[0]));
165 mLnbId = ids[0];
166 } else {
167 ASSERT_TRUE(mLnbTests.openLnbByName(lnbConf.name, mLnbId));
168 }
169 ASSERT_TRUE(mLnbTests.setLnbCallback());
170 ASSERT_TRUE(mLnbTests.setVoltage(lnbConf.voltage));
171 ASSERT_TRUE(mLnbTests.setTone(lnbConf.tone));
172 ASSERT_TRUE(mLnbTests.setSatellitePosition(lnbConf.position));
173 if (!frontendConf.isSoftwareFe) {
174 broadcastSingleFilterTest(filterConf, frontendConf);
175 }
176 ASSERT_TRUE(mLnbTests.closeLnb());
177 mLnbId = INVALID_LNB_ID;
178 }
179
mediaFilterUsingSharedMemoryTest(FilterConfig filterConf,FrontendConfig frontendConf)180 void TunerBroadcastAidlTest::mediaFilterUsingSharedMemoryTest(FilterConfig filterConf,
181 FrontendConfig frontendConf) {
182 int32_t feId;
183 int32_t demuxId;
184 std::shared_ptr<IDemux> demux;
185 int64_t filterId;
186
187 mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
188 ASSERT_TRUE(feId != INVALID_ID);
189 ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
190 ASSERT_TRUE(mFrontendTests.setFrontendCallback());
191 if (frontendConf.isSoftwareFe) {
192 mFrontendTests.setSoftwareFrontendDvrConfig(dvrMap[live.dvrSoftwareFeId]);
193 }
194 ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
195 ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
196 mFrontendTests.setDemux(demux);
197 mFilterTests.setDemux(demux);
198 ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type, filterConf.bufferSize));
199 ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
200 ASSERT_TRUE(mFilterTests.configFilter(filterConf.settings, filterId));
201 ASSERT_TRUE(mFilterTests.getSharedAvMemoryHandle(filterId));
202 ASSERT_TRUE(mFilterTests.configAvFilterStreamType(filterConf.streamType, filterId));
203 ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId, filterConf.getMqDesc));
204 ASSERT_TRUE(mFilterTests.startFilter(filterId));
205 // tune test
206 ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
207 ASSERT_TRUE(filterDataOutputTest());
208 ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
209 ASSERT_TRUE(mFilterTests.stopFilter(filterId));
210 ASSERT_TRUE(mFilterTests.releaseShareAvHandle(filterId));
211 ASSERT_TRUE(mFilterTests.closeFilter(filterId));
212 ASSERT_TRUE(mDemuxTests.closeDemux());
213 ASSERT_TRUE(mFrontendTests.closeFrontend());
214 }
215
playbackSingleFilterTest(FilterConfig filterConf,DvrConfig dvrConf)216 void TunerPlaybackAidlTest::playbackSingleFilterTest(FilterConfig filterConf, DvrConfig dvrConf) {
217 int32_t demuxId;
218 std::shared_ptr<IDemux> demux;
219 int64_t filterId;
220
221 ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
222 mFilterTests.setDemux(demux);
223 mDvrTests.setDemux(demux);
224 ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrConf.type, dvrConf.bufferSize));
225 ASSERT_TRUE(mDvrTests.configDvrPlayback(dvrConf.settings));
226 ASSERT_TRUE(mDvrTests.getDvrPlaybackMQDescriptor());
227 ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type, filterConf.bufferSize));
228 ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
229 ASSERT_TRUE(mFilterTests.configFilter(filterConf.settings, filterId));
230 ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId, filterConf.getMqDesc));
231 mDvrTests.startPlaybackInputThread(dvrConf.playbackInputFile,
232 dvrConf.settings.get<DvrSettings::Tag::playback>());
233 ASSERT_TRUE(mDvrTests.startDvrPlayback());
234 ASSERT_TRUE(mFilterTests.startFilter(filterId));
235 ASSERT_TRUE(filterDataOutputTest());
236 mDvrTests.stopPlaybackThread();
237 ASSERT_TRUE(mFilterTests.stopFilter(filterId));
238 ASSERT_TRUE(mDvrTests.stopDvrPlayback());
239 ASSERT_TRUE(mFilterTests.closeFilter(filterId));
240 mDvrTests.closeDvrPlayback();
241 ASSERT_TRUE(mDemuxTests.closeDemux());
242 }
243
setStatusCheckIntervalHintTest(int64_t statusCheckIntervalHint,DvrConfig dvrConf)244 void TunerPlaybackAidlTest::setStatusCheckIntervalHintTest(int64_t statusCheckIntervalHint,
245 DvrConfig dvrConf) {
246 int32_t demuxId;
247 std::shared_ptr<IDemux> demux;
248
249 ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
250 mDvrTests.setDemux(demux);
251 ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrConf.type, dvrConf.bufferSize));
252 ASSERT_TRUE(mDvrTests.configDvrPlayback(dvrConf.settings));
253 ASSERT_TRUE(mDvrTests.getDvrPlaybackMQDescriptor());
254
255 ASSERT_TRUE(mDvrTests.setPlaybackStatusCheckIntervalHint(statusCheckIntervalHint));
256
257 mDvrTests.startPlaybackInputThread(dvrConf.playbackInputFile,
258 dvrConf.settings.get<DvrSettings::Tag::playback>());
259 ASSERT_TRUE(mDvrTests.startDvrPlayback());
260 mDvrTests.stopPlaybackThread();
261 ASSERT_TRUE(mDvrTests.stopDvrPlayback());
262 mDvrTests.closeDvrPlayback();
263 ASSERT_TRUE(mDemuxTests.closeDemux());
264 }
265
recordSingleFilterTestWithLnb(FilterConfig filterConf,FrontendConfig frontendConf,DvrConfig dvrConf,LnbConfig lnbConf)266 void TunerRecordAidlTest::recordSingleFilterTestWithLnb(FilterConfig filterConf,
267 FrontendConfig frontendConf,
268 DvrConfig dvrConf, LnbConfig lnbConf) {
269 if (lnbConf.name.compare(emptyHardwareId) == 0) {
270 vector<int32_t> ids;
271 ASSERT_TRUE(mLnbTests.getLnbIds(ids));
272 ASSERT_TRUE(ids.size() > 0);
273 ASSERT_TRUE(mLnbTests.openLnbById(ids[0]));
274 mLnbId = ids[0];
275 } else {
276 ASSERT_TRUE(mLnbTests.openLnbByName(lnbConf.name, mLnbId));
277 }
278 ASSERT_TRUE(mLnbTests.setLnbCallback());
279 ASSERT_TRUE(mLnbTests.setVoltage(lnbConf.voltage));
280 ASSERT_TRUE(mLnbTests.setTone(lnbConf.tone));
281 ASSERT_TRUE(mLnbTests.setSatellitePosition(lnbConf.position));
282 for (auto msgName : lnbRecord.diseqcMsgs) {
283 ASSERT_TRUE(mLnbTests.sendDiseqcMessage(diseqcMsgMap[msgName]));
284 }
285 if (!frontendConf.isSoftwareFe) {
286 recordSingleFilterTest(filterConf, frontendConf, dvrConf, Dataflow_Context::LNBRECORD);
287 }
288 ASSERT_TRUE(mLnbTests.closeLnb());
289 mLnbId = INVALID_LNB_ID;
290 }
291
attachSingleFilterToRecordDvrTest(FilterConfig filterConf,FrontendConfig frontendConf,DvrConfig dvrConf)292 void TunerRecordAidlTest::attachSingleFilterToRecordDvrTest(FilterConfig filterConf,
293 FrontendConfig frontendConf,
294 DvrConfig dvrConf) {
295 int32_t demuxId;
296 std::shared_ptr<IDemux> demux;
297 ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
298 mDvrTests.setDemux(demux);
299
300 DvrConfig dvrSourceConfig;
301 if (record.hasFrontendConnection) {
302 int32_t feId;
303 mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
304 ASSERT_TRUE(feId != INVALID_ID);
305 ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
306 ASSERT_TRUE(mFrontendTests.setFrontendCallback());
307 ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
308 } else {
309 dvrSourceConfig = dvrMap[record.dvrSourceId];
310 ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrSourceConfig.type, dvrSourceConfig.bufferSize));
311 ASSERT_TRUE(mDvrTests.configDvrPlayback(dvrSourceConfig.settings));
312 ASSERT_TRUE(mDvrTests.getDvrPlaybackMQDescriptor());
313 }
314
315 int64_t filterId;
316 std::shared_ptr<IFilter> filter;
317 mFilterTests.setDemux(demux);
318
319 ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrConf.type, dvrConf.bufferSize));
320 ASSERT_TRUE(mDvrTests.configDvrRecord(dvrConf.settings));
321 ASSERT_TRUE(mDvrTests.getDvrRecordMQDescriptor());
322
323 ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type, filterConf.bufferSize));
324 ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
325 ASSERT_TRUE(mFilterTests.configFilter(filterConf.settings, filterId));
326 ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId, filterConf.getMqDesc));
327 filter = mFilterTests.getFilterById(filterId);
328 ASSERT_TRUE(filter != nullptr);
329 ASSERT_TRUE(mDvrTests.attachFilterToDvr(filter));
330 ASSERT_TRUE(mDvrTests.startDvrRecord());
331 ASSERT_TRUE(mFilterTests.startFilter(filterId));
332 ASSERT_TRUE(mFilterTests.stopFilter(filterId));
333 ASSERT_TRUE(mDvrTests.stopDvrRecord());
334 ASSERT_TRUE(mDvrTests.detachFilterToDvr(filter));
335 ASSERT_TRUE(mFilterTests.closeFilter(filterId));
336 mDvrTests.closeDvrRecord();
337 ASSERT_TRUE(mDemuxTests.closeDemux());
338
339 if (record.hasFrontendConnection) {
340 ASSERT_TRUE(mFrontendTests.closeFrontend());
341 }
342 }
343
recordSingleFilterTest(FilterConfig filterConf,FrontendConfig frontendConf,DvrConfig dvrConf,Dataflow_Context context)344 void TunerRecordAidlTest::recordSingleFilterTest(FilterConfig filterConf,
345 FrontendConfig frontendConf, DvrConfig dvrConf,
346 Dataflow_Context context) {
347 int32_t demuxId;
348 std::shared_ptr<IDemux> demux;
349 ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
350 mDvrTests.setDemux(demux);
351
352 DvrConfig dvrSourceConfig;
353 if (context == Dataflow_Context::RECORD) {
354 if (record.hasFrontendConnection) {
355 int32_t feId;
356 mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
357 ASSERT_TRUE(feId != INVALID_ID);
358 ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
359 ASSERT_TRUE(mFrontendTests.setFrontendCallback());
360 if (frontendConf.isSoftwareFe) {
361 mFrontendTests.setSoftwareFrontendDvrConfig(dvrMap[record.dvrSoftwareFeId]);
362 }
363 ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
364 mFrontendTests.setDvrTests(&mDvrTests);
365 } else {
366 dvrSourceConfig = dvrMap[record.dvrSourceId];
367 ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrSourceConfig.type, dvrSourceConfig.bufferSize));
368 ASSERT_TRUE(mDvrTests.configDvrPlayback(dvrSourceConfig.settings));
369 ASSERT_TRUE(mDvrTests.getDvrPlaybackMQDescriptor());
370 }
371 } else if (context == Dataflow_Context::LNBRECORD) {
372 // If function arrives here, frontend should not be software, so no need to configure a dvr
373 // source or dvr fe connection that might be used for recording without an Lnb
374 int32_t feId;
375 mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
376 ASSERT_TRUE(feId != INVALID_ID);
377 ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
378 ASSERT_TRUE(mFrontendTests.setFrontendCallback());
379 if (mLnbId != INVALID_LNB_ID) {
380 ASSERT_TRUE(mFrontendTests.setLnb(mLnbId));
381 } else {
382 FAIL();
383 }
384 ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
385 mFrontendTests.setDvrTests(&mDvrTests);
386 }
387
388 int64_t filterId;
389 std::shared_ptr<IFilter> filter;
390 mFilterTests.setDemux(demux);
391 ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrConf.type, dvrConf.bufferSize));
392 ASSERT_TRUE(mDvrTests.configDvrRecord(dvrConf.settings));
393 ASSERT_TRUE(mDvrTests.getDvrRecordMQDescriptor());
394 ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type, filterConf.bufferSize));
395 ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
396 ASSERT_TRUE(mFilterTests.configFilter(filterConf.settings, filterId));
397 ASSERT_TRUE(mFilterTests.getFilterMQDescriptor(filterId, filterConf.getMqDesc));
398 filter = mFilterTests.getFilterById(filterId);
399 ASSERT_TRUE(filter != nullptr);
400 mDvrTests.startRecordOutputThread(dvrConf.settings.get<DvrSettings::Tag::record>());
401 ASSERT_TRUE(mDvrTests.attachFilterToDvr(filter));
402 ASSERT_TRUE(mDvrTests.startDvrRecord());
403 ASSERT_TRUE(mFilterTests.startFilter(filterId));
404
405 if (context == Dataflow_Context::RECORD) {
406 if (record.hasFrontendConnection) {
407 ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
408 } else {
409 // Start DVR Source
410 mDvrTests.startPlaybackInputThread(
411 dvrSourceConfig.playbackInputFile,
412 dvrSourceConfig.settings.get<DvrSettings::Tag::playback>());
413 ASSERT_TRUE(mDvrTests.startDvrPlayback());
414 }
415 } else if (context == Dataflow_Context::LNBRECORD) {
416 ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
417 }
418 mDvrTests.testRecordOutput();
419 mDvrTests.stopRecordThread();
420
421 if (context == Dataflow_Context::RECORD) {
422 if (record.hasFrontendConnection) {
423 ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
424 } else {
425 mDvrTests.stopPlaybackThread();
426 ASSERT_TRUE(mDvrTests.stopDvrPlayback());
427 }
428 } else if (context == Dataflow_Context::LNBRECORD) {
429 ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
430 }
431
432 ASSERT_TRUE(mFilterTests.stopFilter(filterId));
433 ASSERT_TRUE(mDvrTests.stopDvrRecord());
434 ASSERT_TRUE(mDvrTests.detachFilterToDvr(filter));
435 ASSERT_TRUE(mFilterTests.closeFilter(filterId));
436 mDvrTests.closeDvrRecord();
437
438 if (context == Dataflow_Context::RECORD) {
439 if (record.hasFrontendConnection) {
440 ASSERT_TRUE(mFrontendTests.closeFrontend());
441 } else {
442 mDvrTests.closeDvrPlayback();
443 }
444 } else if (context == Dataflow_Context::LNBRECORD) {
445 ASSERT_TRUE(mFrontendTests.closeFrontend());
446 }
447
448 ASSERT_TRUE(mDemuxTests.closeDemux());
449 }
450
setStatusCheckIntervalHintTest(int64_t statusCheckIntervalHint,FrontendConfig frontendConf,DvrConfig dvrConf)451 void TunerRecordAidlTest::setStatusCheckIntervalHintTest(int64_t statusCheckIntervalHint,
452 FrontendConfig frontendConf,
453 DvrConfig dvrConf) {
454 int32_t demuxId;
455 std::shared_ptr<IDemux> demux;
456 ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
457 mDvrTests.setDemux(demux);
458
459 DvrConfig dvrSourceConfig;
460 if (record.hasFrontendConnection) {
461 int32_t feId;
462 mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
463 ASSERT_TRUE(feId != INVALID_ID);
464 ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
465 ASSERT_TRUE(mFrontendTests.setFrontendCallback());
466 ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
467 } else {
468 dvrSourceConfig = dvrMap[record.dvrSourceId];
469 ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrSourceConfig.type, dvrSourceConfig.bufferSize));
470 ASSERT_TRUE(mDvrTests.configDvrPlayback(dvrSourceConfig.settings));
471 ASSERT_TRUE(mDvrTests.getDvrPlaybackMQDescriptor());
472 }
473
474 ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrConf.type, dvrConf.bufferSize));
475 ASSERT_TRUE(mDvrTests.configDvrRecord(dvrConf.settings));
476 ASSERT_TRUE(mDvrTests.getDvrRecordMQDescriptor());
477
478 ASSERT_TRUE(mDvrTests.setRecordStatusCheckIntervalHint(statusCheckIntervalHint));
479
480 ASSERT_TRUE(mDvrTests.startDvrRecord());
481 ASSERT_TRUE(mDvrTests.stopDvrRecord());
482 mDvrTests.closeDvrRecord();
483 ASSERT_TRUE(mDemuxTests.closeDemux());
484
485 if (record.hasFrontendConnection) {
486 ASSERT_TRUE(mFrontendTests.closeFrontend());
487 }
488 }
489
scrambledBroadcastTest(set<struct FilterConfig> mediaFilterConfs,FrontendConfig frontendConf,DescramblerConfig descConfig,Dataflow_Context context)490 void TunerDescramblerAidlTest::scrambledBroadcastTest(set<struct FilterConfig> mediaFilterConfs,
491 FrontendConfig frontendConf,
492 DescramblerConfig descConfig,
493 Dataflow_Context context) {
494 int32_t demuxId;
495 std::shared_ptr<IDemux> demux;
496 ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
497
498 DvrConfig dvrSourceConfig;
499 if (context == Dataflow_Context::DESCRAMBLING) {
500 if (descrambling.hasFrontendConnection) {
501 int32_t feId;
502 mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
503 ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
504 ASSERT_TRUE(mFrontendTests.setFrontendCallback());
505 if (frontendConf.isSoftwareFe) {
506 mFrontendTests.setSoftwareFrontendDvrConfig(dvrMap[descrambling.dvrSoftwareFeId]);
507 }
508 ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
509 mFrontendTests.setDemux(demux);
510 } else {
511 dvrSourceConfig = dvrMap[descrambling.dvrSourceId];
512 mDvrTests.setDemux(demux);
513 ASSERT_TRUE(mDvrTests.openDvrInDemux(dvrSourceConfig.type, dvrSourceConfig.bufferSize));
514 ASSERT_TRUE(mDvrTests.configDvrPlayback(dvrSourceConfig.settings));
515 ASSERT_TRUE(mDvrTests.getDvrPlaybackMQDescriptor());
516 }
517 } else if (context == Dataflow_Context::LNBDESCRAMBLING) {
518 int32_t feId;
519 mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
520 ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
521 ASSERT_TRUE(mFrontendTests.setFrontendCallback());
522 if (mLnbId != INVALID_LNB_ID) {
523 ASSERT_TRUE(mFrontendTests.setLnb(mLnbId));
524 } else {
525 // If, for some reason, the test got here without failing. We fail it here.
526 ALOGD("mLnbId is null. Something went wrong. Exiting ScrambledBroadcastWithLnbId.");
527 FAIL();
528 }
529 ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
530 mFrontendTests.setDemux(demux);
531 }
532
533 set<int64_t> filterIds;
534 int64_t filterId;
535 set<struct FilterConfig>::iterator config;
536 set<int64_t>::iterator id;
537 mFilterTests.setDemux(demux);
538 for (config = mediaFilterConfs.begin(); config != mediaFilterConfs.end(); config++) {
539 ASSERT_TRUE(mFilterTests.openFilterInDemux((*config).type, (*config).bufferSize));
540 ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
541 ASSERT_TRUE(mFilterTests.configFilter((*config).settings, filterId));
542 filterIds.insert(filterId);
543 }
544 ASSERT_TRUE(mDescramblerTests.openDescrambler(demuxId));
545 vector<uint8_t> token;
546 ASSERT_TRUE(mDescramblerTests.getKeyToken(descConfig.casSystemId, descConfig.provisionStr,
547 descConfig.hidlPvtData, token));
548 mDescramblerTests.setKeyToken(token);
549 vector<DemuxPid> pids;
550 DemuxPid pid;
551 for (config = mediaFilterConfs.begin(); config != mediaFilterConfs.end(); config++) {
552 ASSERT_TRUE(mDescramblerTests.getDemuxPidFromFilterSettings((*config).type,
553 (*config).settings, pid));
554 pids.push_back(pid);
555 ASSERT_TRUE(mDescramblerTests.addPid(pid, nullptr));
556 }
557 for (id = filterIds.begin(); id != filterIds.end(); id++) {
558 ASSERT_TRUE(mFilterTests.startFilter(*id));
559 }
560
561 if (context == Dataflow_Context::DESCRAMBLING) {
562 if (descrambling.hasFrontendConnection) {
563 // tune test
564 ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
565 } else {
566 // Start DVR Source
567 mDvrTests.startPlaybackInputThread(
568 dvrSourceConfig.playbackInputFile,
569 dvrSourceConfig.settings.get<DvrSettings::Tag::playback>());
570 ASSERT_TRUE(mDvrTests.startDvrPlayback());
571 }
572 } else if (context == Dataflow_Context::LNBDESCRAMBLING) {
573 ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
574 }
575
576 ASSERT_TRUE(filterDataOutputTest());
577
578 if (context == Dataflow_Context::DESCRAMBLING) {
579 if (descrambling.hasFrontendConnection) {
580 ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
581 } else {
582 mDvrTests.stopPlaybackThread();
583 ASSERT_TRUE(mDvrTests.stopDvrPlayback());
584 }
585 } else if (context == Dataflow_Context::LNBDESCRAMBLING) {
586 ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
587 }
588
589 for (id = filterIds.begin(); id != filterIds.end(); id++) {
590 ASSERT_TRUE(mFilterTests.stopFilter(*id));
591 }
592 for (auto pid : pids) {
593 ASSERT_TRUE(mDescramblerTests.removePid(pid, nullptr));
594 }
595 ASSERT_TRUE(mDescramblerTests.closeDescrambler());
596 for (id = filterIds.begin(); id != filterIds.end(); id++) {
597 ASSERT_TRUE(mFilterTests.closeFilter(*id));
598 }
599
600 if (context == Dataflow_Context::DESCRAMBLING) {
601 if (descrambling.hasFrontendConnection) {
602 ASSERT_TRUE(mFrontendTests.closeFrontend());
603 } else {
604 mDvrTests.closeDvrPlayback();
605 }
606 } else if (context == Dataflow_Context::LNBDESCRAMBLING) {
607 ASSERT_TRUE(mFrontendTests.closeFrontend());
608 }
609
610 ASSERT_TRUE(mDemuxTests.closeDemux());
611 }
612
scrambledBroadcastTestWithLnb(set<struct FilterConfig> & mediaFilterConfs,FrontendConfig & frontendConf,DescramblerConfig & descConfig,LnbConfig & lnbConfig)613 void TunerDescramblerAidlTest::scrambledBroadcastTestWithLnb(
614 set<struct FilterConfig>& mediaFilterConfs, FrontendConfig& frontendConf,
615 DescramblerConfig& descConfig, LnbConfig& lnbConfig) {
616 // We can test the Lnb individually and make sure it functions properly. If the frontend is
617 // software, we cannot test the whole dataflow. If the frontend is hardware, we can
618 if (lnbConfig.name.compare(emptyHardwareId) == 0) {
619 vector<int32_t> ids;
620 ASSERT_TRUE(mLnbTests.getLnbIds(ids));
621 ASSERT_TRUE(ids.size() > 0);
622 ASSERT_TRUE(mLnbTests.openLnbById(ids[0]));
623 mLnbId = ids[0];
624 } else {
625 ASSERT_TRUE(mLnbTests.openLnbByName(lnbConfig.name, mLnbId));
626 }
627 // Once Lnb is opened, test some of its basic functionality
628 ASSERT_TRUE(mLnbTests.setLnbCallback());
629 ASSERT_TRUE(mLnbTests.setVoltage(lnbConfig.voltage));
630 ASSERT_TRUE(mLnbTests.setTone(lnbConfig.tone));
631 ASSERT_TRUE(mLnbTests.setSatellitePosition(lnbConfig.position));
632 if (!frontendConf.isSoftwareFe) {
633 ALOGD("Frontend is not software, testing entire dataflow.");
634 scrambledBroadcastTest(mediaFilterConfs, frontendConf, descConfig,
635 Dataflow_Context::LNBDESCRAMBLING);
636 } else {
637 ALOGD("Frontend is software, did not test the entire dataflow, but tested the Lnb "
638 "individually.");
639 }
640 ASSERT_TRUE(mLnbTests.closeLnb());
641 mLnbId = INVALID_LNB_ID;
642 }
643
TEST_P(TunerLnbAidlTest,SendDiseqcMessageToLnb)644 TEST_P(TunerLnbAidlTest, SendDiseqcMessageToLnb) {
645 description("Open and configure an Lnb with specific settings then send a diseqc msg to it.");
646 if (!lnbLive.support) {
647 return;
648 }
649 vector<LnbLiveHardwareConnections> lnbLive_configs = generateLnbLiveConfigurations();
650 if (lnbLive_configs.empty()) {
651 ALOGD("No frontends that support satellites.");
652 return;
653 }
654 for (auto& combination : lnbLive_configs) {
655 lnbLive = combination;
656 if (lnbMap[lnbLive.lnbId].name.compare(emptyHardwareId) == 0) {
657 vector<int32_t> ids;
658 ASSERT_TRUE(mLnbTests.getLnbIds(ids));
659 ASSERT_TRUE(ids.size() > 0);
660 ASSERT_TRUE(mLnbTests.openLnbById(ids[0]));
661 } else {
662 int32_t id;
663 ASSERT_TRUE(mLnbTests.openLnbByName(lnbMap[lnbLive.lnbId].name, id));
664 }
665 ASSERT_TRUE(mLnbTests.setLnbCallback());
666 ASSERT_TRUE(mLnbTests.setVoltage(lnbMap[lnbLive.lnbId].voltage));
667 ASSERT_TRUE(mLnbTests.setTone(lnbMap[lnbLive.lnbId].tone));
668 ASSERT_TRUE(mLnbTests.setSatellitePosition(lnbMap[lnbLive.lnbId].position));
669 for (auto msgName : lnbLive.diseqcMsgs) {
670 ASSERT_TRUE(mLnbTests.sendDiseqcMessage(diseqcMsgMap[msgName]));
671 }
672 ASSERT_TRUE(mLnbTests.closeLnb());
673 }
674 }
675
TEST_P(TunerDemuxAidlTest,openDemux)676 TEST_P(TunerDemuxAidlTest, openDemux) {
677 description("Open and close a Demux.");
678 if (!live.hasFrontendConnection) {
679 return;
680 }
681 auto live_configs = generateLiveConfigurations();
682 for (auto& configuration : live_configs) {
683 live = configuration;
684 int32_t feId;
685 int32_t demuxId;
686 std::shared_ptr<IDemux> demux;
687 mFrontendTests.getFrontendIdByType(frontendMap[live.frontendId].type, feId);
688 ASSERT_TRUE(feId != INVALID_ID);
689 ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
690 ASSERT_TRUE(mFrontendTests.setFrontendCallback());
691 ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
692 ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
693 ASSERT_TRUE(mDemuxTests.closeDemux());
694 ASSERT_TRUE(mFrontendTests.closeFrontend());
695 }
696 }
697
TEST_P(TunerDemuxAidlTest,openDemuxById)698 TEST_P(TunerDemuxAidlTest, openDemuxById) {
699 description("Open (with id) and close a Demux.");
700 std::vector<int32_t> demuxIds;
701 ASSERT_TRUE(mDemuxTests.getDemuxIds(demuxIds));
702 for (int i = 0; i < demuxIds.size(); i++) {
703 std::shared_ptr<IDemux> demux;
704 ASSERT_TRUE(mDemuxTests.openDemuxById(demuxIds[i], demux));
705 ASSERT_TRUE(mDemuxTests.closeDemux());
706 }
707 }
708
TEST_P(TunerDemuxAidlTest,getDemuxInfo)709 TEST_P(TunerDemuxAidlTest, getDemuxInfo) {
710 description("Check getDemuxInfo against demux caps");
711 std::vector<int32_t> demuxIds;
712 ASSERT_TRUE(mDemuxTests.getDemuxIds(demuxIds));
713 int32_t combinedFilterTypes = 0;
714 for (int i = 0; i < demuxIds.size(); i++) {
715 DemuxInfo demuxInfo;
716 ASSERT_TRUE(mDemuxTests.getDemuxInfo(demuxIds[i], demuxInfo));
717 combinedFilterTypes |= demuxInfo.filterTypes;
718 }
719 if (demuxIds.size() > 0) {
720 DemuxCapabilities demuxCaps;
721 ASSERT_TRUE(mDemuxTests.getDemuxCaps(demuxCaps));
722 ASSERT_TRUE(demuxCaps.filterCaps == combinedFilterTypes);
723 }
724 }
725
TEST_P(TunerDemuxAidlTest,getAvSyncTime)726 TEST_P(TunerDemuxAidlTest, getAvSyncTime) {
727 description("Get the A/V sync time from a PCR filter.");
728 if (!live.hasFrontendConnection) {
729 return;
730 }
731 auto live_configs = generateLiveConfigurations();
732 for (auto& configuration : live_configs) {
733 live = configuration;
734 if (live.pcrFilterId.compare(emptyHardwareId) == 0) {
735 continue;
736 }
737 int32_t feId;
738 int32_t demuxId;
739 std::shared_ptr<IDemux> demux;
740 int64_t mediaFilterId;
741 int64_t pcrFilterId;
742 int32_t avSyncHwId;
743 std::shared_ptr<IFilter> mediaFilter;
744
745 mFrontendTests.getFrontendIdByType(frontendMap[live.frontendId].type, feId);
746 ASSERT_TRUE(feId != INVALID_ID);
747 ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
748 ASSERT_TRUE(mFrontendTests.setFrontendCallback());
749 ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
750 ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
751 mFilterTests.setDemux(demux);
752 ASSERT_TRUE(mFilterTests.openFilterInDemux(filterMap[live.videoFilterId].type,
753 filterMap[live.videoFilterId].bufferSize));
754 ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(mediaFilterId));
755 ASSERT_TRUE(
756 mFilterTests.configFilter(filterMap[live.videoFilterId].settings, mediaFilterId));
757 mediaFilter = mFilterTests.getFilterById(mediaFilterId);
758 ASSERT_TRUE(mFilterTests.openFilterInDemux(filterMap[live.pcrFilterId].type,
759 filterMap[live.pcrFilterId].bufferSize));
760 ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(pcrFilterId));
761 ASSERT_TRUE(mFilterTests.configFilter(filterMap[live.pcrFilterId].settings, pcrFilterId));
762 ASSERT_TRUE(mDemuxTests.getAvSyncId(mediaFilter, avSyncHwId));
763 ASSERT_TRUE(pcrFilterId == avSyncHwId);
764 ASSERT_TRUE(mDemuxTests.getAvSyncTime(pcrFilterId));
765 ASSERT_TRUE(mFilterTests.closeFilter(pcrFilterId));
766 ASSERT_TRUE(mFilterTests.closeFilter(mediaFilterId));
767 ASSERT_TRUE(mDemuxTests.closeDemux());
768 ASSERT_TRUE(mFrontendTests.closeFrontend());
769 }
770 }
771
TEST_P(TunerFilterAidlTest,StartFilterInDemux)772 TEST_P(TunerFilterAidlTest, StartFilterInDemux) {
773 description("Open and start a filter in Demux.");
774 if (!live.hasFrontendConnection) {
775 return;
776 }
777 // TODO use parameterized tests
778 auto live_configs = generateLiveConfigurations();
779 for (auto& configuration : live_configs) {
780 live = configuration;
781 configSingleFilterInDemuxTest(filterMap[live.videoFilterId], frontendMap[live.frontendId]);
782 }
783 }
784
TEST_P(TunerFilterAidlTest,ConfigIpFilterInDemuxWithCid)785 TEST_P(TunerFilterAidlTest, ConfigIpFilterInDemuxWithCid) {
786 description("Open and configure an ip filter in Demux.");
787 // TODO use parameterized tests
788 if (!live.hasFrontendConnection) {
789 return;
790 }
791 auto live_configs = generateLiveConfigurations();
792 for (auto& configuration : live_configs) {
793 live = configuration;
794 if (live.ipFilterId.compare(emptyHardwareId) == 0) {
795 continue;
796 }
797 configSingleFilterInDemuxTest(filterMap[live.ipFilterId], frontendMap[live.frontendId]);
798 }
799 }
800
TEST_P(TunerFilterAidlTest,ReconfigFilterToReceiveStartId)801 TEST_P(TunerFilterAidlTest, ReconfigFilterToReceiveStartId) {
802 description("Recofigure and restart a filter to test start id.");
803 if (!live.hasFrontendConnection) {
804 return;
805 }
806 // TODO use parameterized tests
807 auto live_configs = generateLiveConfigurations();
808 for (auto& configuration : live_configs) {
809 live = configuration;
810 reconfigSingleFilterInDemuxTest(filterMap[live.videoFilterId],
811 filterMap[live.videoFilterId],
812 frontendMap[live.frontendId]);
813 }
814 }
815
TEST_P(TunerFilterAidlTest,SetFilterLinkage)816 TEST_P(TunerFilterAidlTest, SetFilterLinkage) {
817 description("Pick up all the possible linkages from the demux caps and set them up.");
818 DemuxCapabilities caps;
819 int32_t demuxId;
820 std::shared_ptr<IDemux> demux;
821 ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
822 ASSERT_TRUE(mDemuxTests.getDemuxCaps(caps));
823 mFilterTests.setDemux(demux);
824 for (int i = 0; i < caps.linkCaps.size(); i++) {
825 uint32_t bitMask = 1;
826 for (int j = 0; j < FILTER_MAIN_TYPE_BIT_COUNT; j++) {
827 if (caps.linkCaps[i] & (bitMask << j)) {
828 int64_t sourceFilterId;
829 int64_t sinkFilterId;
830 ASSERT_TRUE(mFilterTests.openFilterInDemux(getLinkageFilterType(i), FMQ_SIZE_16M));
831 ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(sourceFilterId));
832 ASSERT_TRUE(mFilterTests.openFilterInDemux(getLinkageFilterType(j), FMQ_SIZE_16M));
833 ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(sinkFilterId));
834 ASSERT_TRUE(mFilterTests.setFilterDataSource(sourceFilterId, sinkFilterId));
835 ASSERT_TRUE(mFilterTests.setFilterDataSourceToDemux(sinkFilterId));
836 ASSERT_TRUE(mFilterTests.closeFilter(sinkFilterId));
837 ASSERT_TRUE(mFilterTests.closeFilter(sourceFilterId));
838 }
839 }
840 }
841 ASSERT_TRUE(mDemuxTests.closeDemux());
842 }
843
TEST_P(TunerFilterAidlTest,testTimeFilter)844 TEST_P(TunerFilterAidlTest, testTimeFilter) {
845 description("Open a timer filter in Demux and set time stamp.");
846 if (!timeFilter.support) {
847 return;
848 }
849 // TODO use parameterized tests
850 auto timeFilter_configs = generateTimeFilterConfigurations();
851 for (auto& configuration : timeFilter_configs) {
852 timeFilter = configuration;
853 testTimeFilter(timeFilterMap[timeFilter.timeFilterId]);
854 }
855 }
856
isEventProducingFilter(const FilterConfig & filterConfig)857 static bool isEventProducingFilter(const FilterConfig& filterConfig) {
858 switch (filterConfig.type.mainType) {
859 case DemuxFilterMainType::TS: {
860 auto tsFilterType =
861 filterConfig.type.subType.get<DemuxFilterSubType::Tag::tsFilterType>();
862 return (tsFilterType == DemuxTsFilterType::SECTION ||
863 tsFilterType == DemuxTsFilterType::PES ||
864 tsFilterType == DemuxTsFilterType::AUDIO ||
865 tsFilterType == DemuxTsFilterType::VIDEO ||
866 tsFilterType == DemuxTsFilterType::RECORD ||
867 tsFilterType == DemuxTsFilterType::TEMI);
868 }
869 case DemuxFilterMainType::MMTP: {
870 auto mmtpFilterType =
871 filterConfig.type.subType.get<DemuxFilterSubType::Tag::mmtpFilterType>();
872 return (mmtpFilterType == DemuxMmtpFilterType::SECTION ||
873 mmtpFilterType == DemuxMmtpFilterType::PES ||
874 mmtpFilterType == DemuxMmtpFilterType::AUDIO ||
875 mmtpFilterType == DemuxMmtpFilterType::VIDEO ||
876 mmtpFilterType == DemuxMmtpFilterType::RECORD ||
877 mmtpFilterType == DemuxMmtpFilterType::DOWNLOAD);
878 }
879 case DemuxFilterMainType::IP: {
880 auto ipFilterType =
881 filterConfig.type.subType.get<DemuxFilterSubType::Tag::ipFilterType>();
882 return (ipFilterType == DemuxIpFilterType::SECTION);
883 }
884 case DemuxFilterMainType::TLV: {
885 auto tlvFilterType =
886 filterConfig.type.subType.get<DemuxFilterSubType::Tag::tlvFilterType>();
887 return (tlvFilterType == DemuxTlvFilterType::SECTION);
888 }
889 case DemuxFilterMainType::ALP: {
890 auto alpFilterType =
891 filterConfig.type.subType.get<DemuxFilterSubType::Tag::alpFilterType>();
892 return (alpFilterType == DemuxAlpFilterType::SECTION);
893 }
894 default:
895 return false;
896 }
897 }
898
isMediaFilter(const FilterConfig & filterConfig)899 static bool isMediaFilter(const FilterConfig& filterConfig) {
900 switch (filterConfig.type.mainType) {
901 case DemuxFilterMainType::TS: {
902 // TS Audio and Video filters are media filters
903 auto tsFilterType =
904 filterConfig.type.subType.get<DemuxFilterSubType::Tag::tsFilterType>();
905 return (tsFilterType == DemuxTsFilterType::AUDIO ||
906 tsFilterType == DemuxTsFilterType::VIDEO);
907 }
908 case DemuxFilterMainType::MMTP: {
909 // MMTP Audio and Video filters are media filters
910 auto mmtpFilterType =
911 filterConfig.type.subType.get<DemuxFilterSubType::Tag::mmtpFilterType>();
912 return (mmtpFilterType == DemuxMmtpFilterType::AUDIO ||
913 mmtpFilterType == DemuxMmtpFilterType::VIDEO);
914 }
915 default:
916 return false;
917 }
918 }
919
getDemuxFilterEventDataLength(const DemuxFilterEvent & event)920 static int getDemuxFilterEventDataLength(const DemuxFilterEvent& event) {
921 switch (event.getTag()) {
922 case DemuxFilterEvent::Tag::section:
923 return event.get<DemuxFilterEvent::Tag::section>().dataLength;
924 case DemuxFilterEvent::Tag::media:
925 return event.get<DemuxFilterEvent::Tag::media>().dataLength;
926 case DemuxFilterEvent::Tag::pes:
927 return event.get<DemuxFilterEvent::Tag::pes>().dataLength;
928 case DemuxFilterEvent::Tag::download:
929 return event.get<DemuxFilterEvent::Tag::download>().dataLength;
930 case DemuxFilterEvent::Tag::ipPayload:
931 return event.get<DemuxFilterEvent::Tag::ipPayload>().dataLength;
932
933 case DemuxFilterEvent::Tag::tsRecord:
934 case DemuxFilterEvent::Tag::mmtpRecord:
935 case DemuxFilterEvent::Tag::temi:
936 case DemuxFilterEvent::Tag::monitorEvent:
937 case DemuxFilterEvent::Tag::startId:
938 return 0;
939 }
940 }
941
942 // TODO: move boilerplate into text fixture
testDelayHint(const FilterConfig & filterConf)943 void TunerFilterAidlTest::testDelayHint(const FilterConfig& filterConf) {
944 if (!filterConf.timeDelayInMs && !filterConf.dataDelayInBytes) {
945 return;
946 }
947 if (!isEventProducingFilter(filterConf)) {
948 return;
949 }
950 int32_t feId;
951 int32_t demuxId;
952 std::shared_ptr<IDemux> demux;
953 int64_t filterId;
954
955 mFrontendTests.getFrontendIdByType(frontendMap[live.frontendId].type, feId);
956 ASSERT_TRUE(feId != INVALID_ID);
957 ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
958 ASSERT_TRUE(mFrontendTests.setFrontendCallback());
959 ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
960 ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
961 mFilterTests.setDemux(demux);
962
963 ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type, filterConf.bufferSize));
964 ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
965
966 bool mediaFilter = isMediaFilter(filterConf);
967 auto filter = mFilterTests.getFilterById(filterId);
968
969 // startTime needs to be set before calling setDelayHint.
970 auto startTime = std::chrono::steady_clock::now();
971
972 int timeDelayInMs = filterConf.timeDelayInMs;
973 if (timeDelayInMs > 0) {
974 FilterDelayHint delayHint;
975 delayHint.hintType = FilterDelayHintType::TIME_DELAY_IN_MS;
976 delayHint.hintValue = timeDelayInMs;
977
978 // setDelayHint should fail for media filters.
979 ASSERT_EQ(filter->setDelayHint(delayHint).isOk(), !mediaFilter);
980 }
981
982 int dataDelayInBytes = filterConf.dataDelayInBytes;
983 if (dataDelayInBytes > 0) {
984 FilterDelayHint delayHint;
985 delayHint.hintType = FilterDelayHintType::DATA_SIZE_DELAY_IN_BYTES;
986 delayHint.hintValue = dataDelayInBytes;
987
988 // setDelayHint should fail for media filters.
989 ASSERT_EQ(filter->setDelayHint(delayHint).isOk(), !mediaFilter);
990 }
991
992 // start and stop filter (and wait for first callback) in order to
993 // circumvent callback scheduler race conditions after adjusting filter
994 // delays.
995 auto cb = mFilterTests.getFilterCallbacks().at(filterId);
996 auto future =
997 cb->verifyFilterCallback([](const std::vector<DemuxFilterEvent>&) { return true; });
998
999 // The configure stage can also produce events, so we should set the delay
1000 // hint beforehand.
1001 ASSERT_TRUE(mFilterTests.configFilter(filterConf.settings, filterId));
1002 mFilterTests.startFilter(filterId);
1003
1004 auto timeout = std::chrono::seconds(30);
1005 ASSERT_EQ(future.wait_for(timeout), std::future_status::ready);
1006
1007 mFilterTests.stopFilter(filterId);
1008
1009 if (!mediaFilter) {
1010 int callbackSize = 0;
1011 future = cb->verifyFilterCallback(
1012 [&callbackSize](const std::vector<DemuxFilterEvent>& events) {
1013 for (const auto& event : events) {
1014 callbackSize += getDemuxFilterEventDataLength(event);
1015 }
1016 return true;
1017 });
1018
1019 ASSERT_TRUE(mFilterTests.startFilter(filterId));
1020
1021 // block and wait for callback to be received.
1022 ASSERT_EQ(future.wait_for(timeout), std::future_status::ready);
1023
1024 auto duration = std::chrono::steady_clock::now() - startTime;
1025 bool delayHintTest = duration >= std::chrono::milliseconds(timeDelayInMs);
1026 bool dataSizeTest = callbackSize >= dataDelayInBytes;
1027
1028 if (timeDelayInMs > 0 && dataDelayInBytes > 0) {
1029 ASSERT_TRUE(delayHintTest || dataSizeTest);
1030 } else {
1031 // if only one of time delay / data delay is configured, one of them
1032 // holds true by default, so we want both assertions to be true.
1033 ASSERT_TRUE(delayHintTest && dataSizeTest);
1034 }
1035
1036 ASSERT_TRUE(mFilterTests.stopFilter(filterId));
1037 }
1038
1039 ASSERT_TRUE(mFilterTests.closeFilter(filterId));
1040 ASSERT_TRUE(mDemuxTests.closeDemux());
1041 ASSERT_TRUE(mFrontendTests.closeFrontend());
1042 }
1043
TEST_P(TunerFilterAidlTest,FilterDelayHintTest)1044 TEST_P(TunerFilterAidlTest, FilterDelayHintTest) {
1045 description("Test filter time delay hint.");
1046 if (!live.hasFrontendConnection) {
1047 return;
1048 }
1049 for (const auto& obj : filterMap) {
1050 testDelayHint(obj.second);
1051 }
1052 }
1053
TEST_P(TunerPlaybackAidlTest,PlaybackDataFlowWithTsSectionFilterTest)1054 TEST_P(TunerPlaybackAidlTest, PlaybackDataFlowWithTsSectionFilterTest) {
1055 description("Feed ts data from playback and configure Ts section filter to get output");
1056 if (!playback.support) {
1057 return;
1058 }
1059 vector<DvrPlaybackHardwareConnections> playback_configs = generatePlaybackConfigs();
1060 for (auto& configuration : playback_configs) {
1061 if (configuration.sectionFilterId.compare(emptyHardwareId) != 0) {
1062 playback = configuration;
1063 playbackSingleFilterTest(filterMap[playback.sectionFilterId], dvrMap[playback.dvrId]);
1064 }
1065 }
1066 }
1067
TEST_P(TunerPlaybackAidlTest,PlaybackDataFlowWithTsAudioFilterTest)1068 TEST_P(TunerPlaybackAidlTest, PlaybackDataFlowWithTsAudioFilterTest) {
1069 description("Feed ts data from playback and configure Ts audio filter to get output");
1070 if (!playback.support) {
1071 return;
1072 }
1073 vector<DvrPlaybackHardwareConnections> playback_configs = generatePlaybackConfigs();
1074 for (auto& configuration : playback_configs) {
1075 playback = configuration;
1076 playbackSingleFilterTest(filterMap[playback.audioFilterId], dvrMap[playback.dvrId]);
1077 }
1078 }
1079
TEST_P(TunerPlaybackAidlTest,PlaybackDataFlowWithTsVideoFilterTest)1080 TEST_P(TunerPlaybackAidlTest, PlaybackDataFlowWithTsVideoFilterTest) {
1081 description("Feed ts data from playback and configure Ts video filter to get output");
1082 if (!playback.support) {
1083 return;
1084 }
1085 vector<DvrPlaybackHardwareConnections> playback_configs = generatePlaybackConfigs();
1086 for (auto& configuration : playback_configs) {
1087 playback = configuration;
1088 playbackSingleFilterTest(filterMap[playback.videoFilterId], dvrMap[playback.dvrId]);
1089 }
1090 }
1091
TEST_P(TunerPlaybackAidlTest,SetStatusCheckIntervalHintToPlaybackTest)1092 TEST_P(TunerPlaybackAidlTest, SetStatusCheckIntervalHintToPlaybackTest) {
1093 description("Set status check interval hint to playback test.");
1094 if (!playback.support) {
1095 return;
1096 }
1097 vector<DvrPlaybackHardwareConnections> playback_configs = generatePlaybackConfigs();
1098 for (auto& configuration : playback_configs) {
1099 playback = configuration;
1100 setStatusCheckIntervalHintTest(STATUS_CHECK_INTERVAL_MS, dvrMap[playback.dvrId]);
1101 }
1102 }
1103
TEST_P(TunerRecordAidlTest,RecordDataFlowWithTsRecordFilterTest)1104 TEST_P(TunerRecordAidlTest, RecordDataFlowWithTsRecordFilterTest) {
1105 description("Feed ts data from frontend to recording and test with ts record filter");
1106 if (!record.support) {
1107 return;
1108 }
1109 auto record_configs = generateRecordConfigurations();
1110 for (auto& configuration : record_configs) {
1111 record = configuration;
1112 recordSingleFilterTest(filterMap[record.recordFilterId], frontendMap[record.frontendId],
1113 dvrMap[record.dvrRecordId], Dataflow_Context::RECORD);
1114 }
1115 }
1116
TEST_P(TunerRecordAidlTest,AttachFiltersToRecordTest)1117 TEST_P(TunerRecordAidlTest, AttachFiltersToRecordTest) {
1118 description("Attach a single filter to the record dvr test.");
1119 // TODO use parameterized tests
1120 if (!record.support) {
1121 return;
1122 }
1123 auto record_configs = generateRecordConfigurations();
1124 for (auto& configuration : record_configs) {
1125 record = configuration;
1126 attachSingleFilterToRecordDvrTest(filterMap[record.recordFilterId],
1127 frontendMap[record.frontendId],
1128 dvrMap[record.dvrRecordId]);
1129 }
1130 }
1131
TEST_P(TunerRecordAidlTest,LnbRecordDataFlowWithTsRecordFilterTest)1132 TEST_P(TunerRecordAidlTest, LnbRecordDataFlowWithTsRecordFilterTest) {
1133 description("Feed ts data from Fe with Lnb to recording and test with ts record filter");
1134 if (!lnbRecord.support) {
1135 return;
1136 }
1137 vector<LnbRecordHardwareConnections> lnbRecord_configs = generateLnbRecordConfigurations();
1138 if (lnbRecord_configs.empty()) {
1139 ALOGD("No frontends that support satellites.");
1140 return;
1141 }
1142 for (auto& configuration : lnbRecord_configs) {
1143 lnbRecord = configuration;
1144 recordSingleFilterTestWithLnb(filterMap[lnbRecord.recordFilterId],
1145 frontendMap[lnbRecord.frontendId],
1146 dvrMap[lnbRecord.dvrRecordId], lnbMap[lnbRecord.lnbId]);
1147 }
1148 }
1149
TEST_P(TunerRecordAidlTest,SetStatusCheckIntervalHintToRecordTest)1150 TEST_P(TunerRecordAidlTest, SetStatusCheckIntervalHintToRecordTest) {
1151 description("Set status check interval hint to record test.");
1152 if (!record.support) {
1153 return;
1154 }
1155 auto record_configs = generateRecordConfigurations();
1156 for (auto& configuration : record_configs) {
1157 record = configuration;
1158 setStatusCheckIntervalHintTest(STATUS_CHECK_INTERVAL_MS, frontendMap[record.frontendId],
1159 dvrMap[record.dvrRecordId]);
1160 }
1161 }
1162
TEST_P(TunerFrontendAidlTest,TuneFrontend)1163 TEST_P(TunerFrontendAidlTest, TuneFrontend) {
1164 description("Tune one Frontend with specific setting and check Lock event");
1165 if (!live.hasFrontendConnection) {
1166 return;
1167 }
1168 auto live_configs = generateLiveConfigurations();
1169 for (auto& configuration : live_configs) {
1170 live = configuration;
1171 mFrontendTests.tuneTest(frontendMap[live.frontendId]);
1172 }
1173 }
1174
TEST_P(TunerFrontendAidlTest,AutoScanFrontend)1175 TEST_P(TunerFrontendAidlTest, AutoScanFrontend) {
1176 description("Run an auto frontend scan with specific setting and check lock scanMessage");
1177 if (!scan.hasFrontendConnection) {
1178 return;
1179 }
1180 vector<ScanHardwareConnections> scan_configs = generateScanConfigurations();
1181 for (auto& configuration : scan_configs) {
1182 scan = configuration;
1183 mFrontendTests.scanTest(frontendMap[scan.frontendId], FrontendScanType::SCAN_AUTO);
1184 }
1185 }
1186
TEST_P(TunerFrontendAidlTest,BlindScanFrontend)1187 TEST_P(TunerFrontendAidlTest, BlindScanFrontend) {
1188 description("Run an blind frontend scan with specific setting and check lock scanMessage");
1189 if (!scan.hasFrontendConnection) {
1190 return;
1191 }
1192 vector<ScanHardwareConnections> scan_configs = generateScanConfigurations();
1193 for (auto& configuration : scan_configs) {
1194 scan = configuration;
1195 mFrontendTests.scanTest(frontendMap[scan.frontendId], FrontendScanType::SCAN_BLIND);
1196 }
1197 }
1198
TEST_P(TunerFrontendAidlTest,TuneFrontendWithFrontendSettings)1199 TEST_P(TunerFrontendAidlTest, TuneFrontendWithFrontendSettings) {
1200 description("Tune one Frontend with setting and check Lock event");
1201 if (!live.hasFrontendConnection) {
1202 return;
1203 }
1204 auto live_configs = generateLiveConfigurations();
1205 for (auto& configuration : live_configs) {
1206 live = configuration;
1207 mFrontendTests.tuneTest(frontendMap[live.frontendId]);
1208 }
1209 }
1210
TEST_P(TunerFrontendAidlTest,BlindScanFrontendWithEndFrequency)1211 TEST_P(TunerFrontendAidlTest, BlindScanFrontendWithEndFrequency) {
1212 description("Run an blind frontend scan with setting and check lock scanMessage");
1213 if (!scan.hasFrontendConnection) {
1214 return;
1215 }
1216 vector<ScanHardwareConnections> scan_configs = generateScanConfigurations();
1217 for (auto& configuration : scan_configs) {
1218 scan = configuration;
1219 mFrontendTests.scanTest(frontendMap[scan.frontendId], FrontendScanType::SCAN_BLIND);
1220 }
1221 }
1222
TEST_P(TunerFrontendAidlTest,LinkToCiCam)1223 TEST_P(TunerFrontendAidlTest, LinkToCiCam) {
1224 description("Test Frontend link to CiCam");
1225 if (!live.hasFrontendConnection) {
1226 return;
1227 }
1228 auto live_configs = generateLiveConfigurations();
1229 for (auto& configuration : live_configs) {
1230 live = configuration;
1231 if (!frontendMap[live.frontendId].canConnectToCiCam) {
1232 continue;
1233 }
1234 mFrontendTests.tuneTest(frontendMap[live.frontendId]);
1235 }
1236 }
1237
TEST_P(TunerFrontendAidlTest,getHardwareInfo)1238 TEST_P(TunerFrontendAidlTest, getHardwareInfo) {
1239 description("Test Frontend get hardware info");
1240 if (!live.hasFrontendConnection) {
1241 return;
1242 }
1243 auto live_configs = generateLiveConfigurations();
1244 for (auto& configuration : live_configs) {
1245 live = configuration;
1246 mFrontendTests.debugInfoTest(frontendMap[live.frontendId]);
1247 }
1248 }
1249
TEST_P(TunerFrontendAidlTest,maxNumberOfFrontends)1250 TEST_P(TunerFrontendAidlTest, maxNumberOfFrontends) {
1251 description("Test Max Frontend number");
1252 if (!live.hasFrontendConnection) {
1253 return;
1254 }
1255 mFrontendTests.maxNumberOfFrontendsTest();
1256 }
1257
TEST_P(TunerFrontendAidlTest,statusReadinessTest)1258 TEST_P(TunerFrontendAidlTest, statusReadinessTest) {
1259 description("Test Max Frontend status readiness");
1260 if (!live.hasFrontendConnection) {
1261 return;
1262 }
1263 auto live_configs = generateLiveConfigurations();
1264 for (auto& configuration : live_configs) {
1265 live = configuration;
1266 mFrontendTests.statusReadinessTest(frontendMap[live.frontendId]);
1267 }
1268 }
1269
TEST_P(TunerBroadcastAidlTest,BroadcastDataFlowVideoFilterTest)1270 TEST_P(TunerBroadcastAidlTest, BroadcastDataFlowVideoFilterTest) {
1271 description("Test Video Filter functionality in Broadcast use case.");
1272 if (!live.hasFrontendConnection) {
1273 return;
1274 }
1275 auto live_configs = generateLiveConfigurations();
1276 for (auto& configuration : live_configs) {
1277 live = configuration;
1278 broadcastSingleFilterTest(filterMap[live.videoFilterId], frontendMap[live.frontendId]);
1279 }
1280 }
1281
TEST_P(TunerBroadcastAidlTest,BroadcastDataFlowAudioFilterTest)1282 TEST_P(TunerBroadcastAidlTest, BroadcastDataFlowAudioFilterTest) {
1283 description("Test Audio Filter functionality in Broadcast use case.");
1284 if (!live.hasFrontendConnection) {
1285 return;
1286 }
1287 auto live_configs = generateLiveConfigurations();
1288 for (auto& configuration : live_configs) {
1289 live = configuration;
1290 broadcastSingleFilterTest(filterMap[live.audioFilterId], frontendMap[live.frontendId]);
1291 }
1292 }
1293
TEST_P(TunerBroadcastAidlTest,BroadcastDataFlowSectionFilterTest)1294 TEST_P(TunerBroadcastAidlTest, BroadcastDataFlowSectionFilterTest) {
1295 description("Test Section Filter functionality in Broadcast use case.");
1296 if (!live.hasFrontendConnection) {
1297 return;
1298 }
1299 auto live_configs = generateLiveConfigurations();
1300 for (auto& configuration : live_configs) {
1301 live = configuration;
1302 if (live.sectionFilterId.compare(emptyHardwareId) == 0) {
1303 continue;
1304 }
1305 broadcastSingleFilterTest(filterMap[live.sectionFilterId], frontendMap[live.frontendId]);
1306 }
1307 }
1308
TEST_P(TunerBroadcastAidlTest,IonBufferTest)1309 TEST_P(TunerBroadcastAidlTest, IonBufferTest) {
1310 description("Test the av filter data bufferring.");
1311 if (!live.hasFrontendConnection) {
1312 return;
1313 }
1314 auto live_configs = generateLiveConfigurations();
1315 for (auto& configuration : live_configs) {
1316 live = configuration;
1317 broadcastSingleFilterTest(filterMap[live.videoFilterId], frontendMap[live.frontendId]);
1318 }
1319 }
1320
TEST_P(TunerBroadcastAidlTest,LnbBroadcastDataFlowVideoFilterTest)1321 TEST_P(TunerBroadcastAidlTest, LnbBroadcastDataFlowVideoFilterTest) {
1322 description("Test Video Filter functionality in Broadcast with Lnb use case.");
1323 if (!lnbLive.support) {
1324 return;
1325 }
1326 vector<LnbLiveHardwareConnections> lnbLive_configs = generateLnbLiveConfigurations();
1327 if (lnbLive_configs.empty()) {
1328 ALOGD("No frontends that support satellites.");
1329 return;
1330 }
1331 for (auto& combination : lnbLive_configs) {
1332 lnbLive = combination;
1333 broadcastSingleFilterTestWithLnb(filterMap[lnbLive.videoFilterId],
1334 frontendMap[lnbLive.frontendId], lnbMap[lnbLive.lnbId]);
1335 }
1336 }
1337
TEST_P(TunerBroadcastAidlTest,MediaFilterWithSharedMemoryHandle)1338 TEST_P(TunerBroadcastAidlTest, MediaFilterWithSharedMemoryHandle) {
1339 description("Test the Media Filter with shared memory handle");
1340 if (!live.hasFrontendConnection) {
1341 return;
1342 }
1343 auto live_configs = generateLiveConfigurations();
1344 for (auto& configuration : live_configs) {
1345 live = configuration;
1346 mediaFilterUsingSharedMemoryTest(filterMap[live.videoFilterId],
1347 frontendMap[live.frontendId]);
1348 }
1349 }
1350
TEST_P(TunerDescramblerAidlTest,CreateDescrambler)1351 TEST_P(TunerDescramblerAidlTest, CreateDescrambler) {
1352 description("Create Descrambler");
1353 if (!descrambling.support) {
1354 return;
1355 }
1356 vector<DescramblingHardwareConnections> descrambling_configs =
1357 generateDescramblingConfigurations();
1358 if (descrambling_configs.empty()) {
1359 ALOGD("No valid descrambling combinations in the configuration file.");
1360 return;
1361 }
1362 for (auto& combination : descrambling_configs) {
1363 descrambling = combination;
1364 int32_t demuxId;
1365 std::shared_ptr<IDemux> demux;
1366 ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
1367
1368 if (descrambling.hasFrontendConnection) {
1369 int32_t feId;
1370 mFrontendTests.getFrontendIdByType(frontendMap[descrambling.frontendId].type, feId);
1371 ASSERT_TRUE(feId != INVALID_ID);
1372 ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
1373 ASSERT_TRUE(mFrontendTests.setFrontendCallback());
1374 ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
1375 }
1376
1377 ASSERT_TRUE(mDescramblerTests.openDescrambler(demuxId));
1378 ASSERT_TRUE(mDescramblerTests.closeDescrambler());
1379 ASSERT_TRUE(mDemuxTests.closeDemux());
1380
1381 if (descrambling.hasFrontendConnection) {
1382 ASSERT_TRUE(mFrontendTests.closeFrontend());
1383 }
1384 }
1385 }
1386
TEST_P(TunerDescramblerAidlTest,ScrambledBroadcastDataFlowMediaFiltersTest)1387 TEST_P(TunerDescramblerAidlTest, ScrambledBroadcastDataFlowMediaFiltersTest) {
1388 description("Test ts audio filter in scrambled broadcast use case");
1389 if (!descrambling.support) {
1390 return;
1391 }
1392 vector<DescramblingHardwareConnections> descrambling_configs =
1393 generateDescramblingConfigurations();
1394 if (descrambling_configs.empty()) {
1395 ALOGD("No valid descrambling combinations in the configuration file.");
1396 return;
1397 }
1398 for (auto& combination : descrambling_configs) {
1399 descrambling = combination;
1400 set<FilterConfig> filterConfs;
1401 filterConfs.insert(static_cast<FilterConfig>(filterMap[descrambling.audioFilterId]));
1402 filterConfs.insert(static_cast<FilterConfig>(filterMap[descrambling.videoFilterId]));
1403 scrambledBroadcastTest(filterConfs, frontendMap[descrambling.frontendId],
1404 descramblerMap[descrambling.descramblerId],
1405 Dataflow_Context::DESCRAMBLING);
1406 }
1407 }
1408
TEST_P(TunerDescramblerAidlTest,ScrambledBroadcastDataFlowMediaFiltersTestWithLnb)1409 TEST_P(TunerDescramblerAidlTest, ScrambledBroadcastDataFlowMediaFiltersTestWithLnb) {
1410 description("Test media filters in scrambled broadcast use case with Lnb");
1411 if (!lnbDescrambling.support) {
1412 return;
1413 }
1414 auto lnbDescrambling_configs = generateLnbDescramblingConfigurations();
1415 if (lnbDescrambling_configs.empty()) {
1416 ALOGD("No frontends that support satellites.");
1417 return;
1418 }
1419 for (auto& configuration : lnbDescrambling_configs) {
1420 lnbDescrambling = configuration;
1421 set<FilterConfig> filterConfs;
1422 filterConfs.insert(static_cast<FilterConfig>(filterMap[lnbDescrambling.audioFilterId]));
1423 filterConfs.insert(static_cast<FilterConfig>(filterMap[lnbDescrambling.videoFilterId]));
1424 scrambledBroadcastTestWithLnb(filterConfs, frontendMap[lnbDescrambling.frontendId],
1425 descramblerMap[lnbDescrambling.descramblerId],
1426 lnbMap[lnbDescrambling.lnbId]);
1427 }
1428 }
1429
1430 INSTANTIATE_TEST_SUITE_P(PerInstance, TunerBroadcastAidlTest,
1431 testing::ValuesIn(android::getAidlHalInstanceNames(ITuner::descriptor)),
1432 android::PrintInstanceNameToString);
1433
1434 INSTANTIATE_TEST_SUITE_P(PerInstance, TunerFrontendAidlTest,
1435 testing::ValuesIn(android::getAidlHalInstanceNames(ITuner::descriptor)),
1436 android::PrintInstanceNameToString);
1437
1438 INSTANTIATE_TEST_SUITE_P(PerInstance, TunerFilterAidlTest,
1439 testing::ValuesIn(android::getAidlHalInstanceNames(ITuner::descriptor)),
1440 android::PrintInstanceNameToString);
1441
1442 INSTANTIATE_TEST_SUITE_P(PerInstance, TunerRecordAidlTest,
1443 testing::ValuesIn(android::getAidlHalInstanceNames(ITuner::descriptor)),
1444 android::PrintInstanceNameToString);
1445
1446 INSTANTIATE_TEST_SUITE_P(PerInstance, TunerLnbAidlTest,
1447 testing::ValuesIn(android::getAidlHalInstanceNames(ITuner::descriptor)),
1448 android::PrintInstanceNameToString);
1449
1450 INSTANTIATE_TEST_SUITE_P(PerInstance, TunerDemuxAidlTest,
1451 testing::ValuesIn(android::getAidlHalInstanceNames(ITuner::descriptor)),
1452 android::PrintInstanceNameToString);
1453
1454 INSTANTIATE_TEST_SUITE_P(PerInstance, TunerPlaybackAidlTest,
1455 testing::ValuesIn(android::getAidlHalInstanceNames(ITuner::descriptor)),
1456 android::PrintInstanceNameToString);
1457
1458 INSTANTIATE_TEST_SUITE_P(PerInstance, TunerDescramblerAidlTest,
1459 testing::ValuesIn(android::getAidlHalInstanceNames(ITuner::descriptor)),
1460 android::PrintInstanceNameToString);
1461
1462 } // namespace
1463
1464 // Start thread pool to receive callbacks from AIDL service.
main(int argc,char ** argv)1465 int main(int argc, char** argv) {
1466 ::testing::InitGoogleTest(&argc, argv);
1467 ABinderProcess_setThreadPoolMaxThreadCount(1);
1468 ABinderProcess_startThreadPool();
1469 return RUN_ALL_TESTS();
1470 }
1471