blob: 9db82c893de0cf903a2a231ed3d351b7bc16aff8 [file] [log] [blame]
Hongguang600a6ae2021-07-08 18:51:51 -07001/*
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
24namespace {
25
26AssertionResult TunerBroadcastAidlTest::filterDataOutputTest() {
27 return filterDataOutputTestBase(mFilterTests);
28}
29
30AssertionResult TunerPlaybackAidlTest::filterDataOutputTest() {
31 return filterDataOutputTestBase(mFilterTests);
32}
33
34AssertionResult TunerDescramblerAidlTest::filterDataOutputTest() {
35 return filterDataOutputTestBase(mFilterTests);
36}
37
38void 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
69void 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
105void 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
122void 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());
Frankie Lizcano87421812022-07-28 17:13:01 +0000132 if (mLnbId != INVALID_LNB_ID) {
133 ASSERT_TRUE(mFrontendTests.setLnb(mLnbId));
Hongguang600a6ae2021-07-08 18:51:51 -0700134 }
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
157void 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]));
Frankie Lizcano87421812022-07-28 17:13:01 +0000165 mLnbId = ids[0];
Hongguang600a6ae2021-07-08 18:51:51 -0700166 } else {
Frankie Lizcano87421812022-07-28 17:13:01 +0000167 ASSERT_TRUE(mLnbTests.openLnbByName(lnbConf.name, mLnbId));
Hongguang600a6ae2021-07-08 18:51:51 -0700168 }
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));
Frankie Lizcanod1f520e2022-07-26 20:05:46 +0000173 if (!frontendConf.isSoftwareFe) {
174 broadcastSingleFilterTest(filterConf, frontendConf);
175 }
Hongguang600a6ae2021-07-08 18:51:51 -0700176 ASSERT_TRUE(mLnbTests.closeLnb());
Frankie Lizcano87421812022-07-28 17:13:01 +0000177 mLnbId = INVALID_LNB_ID;
Hongguang600a6ae2021-07-08 18:51:51 -0700178}
179
180void 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
216void 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
Ray Chin62ab6c92022-09-15 15:07:33 +0800244void 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
Hongguang600a6ae2021-07-08 18:51:51 -0700266void 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]));
Frankie Lizcano87421812022-07-28 17:13:01 +0000274 mLnbId = ids[0];
Hongguang600a6ae2021-07-08 18:51:51 -0700275 } else {
Frankie Lizcano87421812022-07-28 17:13:01 +0000276 ASSERT_TRUE(mLnbTests.openLnbByName(lnbConf.name, mLnbId));
Hongguang600a6ae2021-07-08 18:51:51 -0700277 }
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 }
Frankie Lizcano9c464f72022-07-18 17:56:52 +0000285 if (!frontendConf.isSoftwareFe) {
286 recordSingleFilterTest(filterConf, frontendConf, dvrConf, Dataflow_Context::LNBRECORD);
287 }
Hongguang600a6ae2021-07-08 18:51:51 -0700288 ASSERT_TRUE(mLnbTests.closeLnb());
Frankie Lizcano87421812022-07-28 17:13:01 +0000289 mLnbId = INVALID_LNB_ID;
Hongguang600a6ae2021-07-08 18:51:51 -0700290}
291
292void 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
344void TunerRecordAidlTest::recordSingleFilterTest(FilterConfig filterConf,
Frankie Lizcano9c464f72022-07-18 17:56:52 +0000345 FrontendConfig frontendConf, DvrConfig dvrConf,
346 Dataflow_Context context) {
Hongguang600a6ae2021-07-08 18:51:51 -0700347 int32_t demuxId;
348 std::shared_ptr<IDemux> demux;
349 ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
350 mDvrTests.setDemux(demux);
351
352 DvrConfig dvrSourceConfig;
Frankie Lizcano9c464f72022-07-18 17:56:52 +0000353 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
Hongguang600a6ae2021-07-08 18:51:51 -0700374 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());
Frankie Lizcano9c464f72022-07-18 17:56:52 +0000379 if (mLnbId != INVALID_LNB_ID) {
380 ASSERT_TRUE(mFrontendTests.setLnb(mLnbId));
381 } else {
382 FAIL();
Hongguang600a6ae2021-07-08 18:51:51 -0700383 }
384 ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
385 mFrontendTests.setDvrTests(&mDvrTests);
Hongguang600a6ae2021-07-08 18:51:51 -0700386 }
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
Frankie Lizcano9c464f72022-07-18 17:56:52 +0000405 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) {
Hongguang600a6ae2021-07-08 18:51:51 -0700416 ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
Hongguang600a6ae2021-07-08 18:51:51 -0700417 }
Hongguang600a6ae2021-07-08 18:51:51 -0700418 mDvrTests.testRecordOutput();
419 mDvrTests.stopRecordThread();
420
Frankie Lizcano9c464f72022-07-18 17:56:52 +0000421 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) {
Hongguang600a6ae2021-07-08 18:51:51 -0700429 ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
Hongguang600a6ae2021-07-08 18:51:51 -0700430 }
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
Frankie Lizcano9c464f72022-07-18 17:56:52 +0000438 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) {
Hongguang600a6ae2021-07-08 18:51:51 -0700445 ASSERT_TRUE(mFrontendTests.closeFrontend());
Hongguang600a6ae2021-07-08 18:51:51 -0700446 }
447
448 ASSERT_TRUE(mDemuxTests.closeDemux());
449}
450
Ray Chin62ab6c92022-09-15 15:07:33 +0800451void 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
Hongguang600a6ae2021-07-08 18:51:51 -0700490void TunerDescramblerAidlTest::scrambledBroadcastTest(set<struct FilterConfig> mediaFilterConfs,
491 FrontendConfig frontendConf,
Frankie Lizcano82101d22022-07-28 00:12:35 +0000492 DescramblerConfig descConfig,
493 Dataflow_Context context) {
Hongguang600a6ae2021-07-08 18:51:51 -0700494 int32_t demuxId;
495 std::shared_ptr<IDemux> demux;
496 ASSERT_TRUE(mDemuxTests.openDemux(demux, demuxId));
497
498 DvrConfig dvrSourceConfig;
Frankie Lizcano82101d22022-07-28 00:12:35 +0000499 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) {
Hongguang600a6ae2021-07-08 18:51:51 -0700518 int32_t feId;
519 mFrontendTests.getFrontendIdByType(frontendConf.type, feId);
520 ASSERT_TRUE(mFrontendTests.openFrontendById(feId));
521 ASSERT_TRUE(mFrontendTests.setFrontendCallback());
Frankie Lizcano82101d22022-07-28 00:12:35 +0000522 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();
Hongguang600a6ae2021-07-08 18:51:51 -0700528 }
529 ASSERT_TRUE(mDemuxTests.setDemuxFrontendDataSource(feId));
530 mFrontendTests.setDemux(demux);
Hongguang600a6ae2021-07-08 18:51:51 -0700531 }
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
Frankie Lizcano82101d22022-07-28 00:12:35 +0000561 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) {
Hongguang600a6ae2021-07-08 18:51:51 -0700573 ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
Hongguang600a6ae2021-07-08 18:51:51 -0700574 }
575
576 ASSERT_TRUE(filterDataOutputTest());
577
Frankie Lizcano82101d22022-07-28 00:12:35 +0000578 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) {
Hongguang600a6ae2021-07-08 18:51:51 -0700586 ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
Hongguang600a6ae2021-07-08 18:51:51 -0700587 }
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
Frankie Lizcano82101d22022-07-28 00:12:35 +0000600 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) {
Hongguang600a6ae2021-07-08 18:51:51 -0700607 ASSERT_TRUE(mFrontendTests.closeFrontend());
Hongguang600a6ae2021-07-08 18:51:51 -0700608 }
609
610 ASSERT_TRUE(mDemuxTests.closeDemux());
611}
612
Frankie Lizcano82101d22022-07-28 00:12:35 +0000613void 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
Hongguang600a6ae2021-07-08 18:51:51 -0700644TEST_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 }
Frankie Lizcano1e283b32022-07-08 21:07:42 +0000649 vector<LnbLiveHardwareConnections> lnbLive_configs = generateLnbLiveConfigurations();
650 if (lnbLive_configs.empty()) {
651 ALOGD("No frontends that support satellites.");
652 return;
Hongguang600a6ae2021-07-08 18:51:51 -0700653 }
Frankie Lizcano1e283b32022-07-08 21:07:42 +0000654 for (auto& combination : lnbLive_configs) {
655 lnbLive = combination;
Frankie Lizcano1e283b32022-07-08 21:07:42 +0000656 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());
Hongguang600a6ae2021-07-08 18:51:51 -0700673 }
Hongguang600a6ae2021-07-08 18:51:51 -0700674}
675
676TEST_P(TunerDemuxAidlTest, openDemux) {
677 description("Open and close a Demux.");
678 if (!live.hasFrontendConnection) {
679 return;
680 }
Frankie Lizcano8b87f252022-07-19 21:51:54 +0000681 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 }
Hongguang600a6ae2021-07-08 18:51:51 -0700696}
697
Kensuke Miyagi73b18ac2022-11-07 10:49:09 -0800698TEST_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
709TEST_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
Hongguang600a6ae2021-07-08 18:51:51 -0700726TEST_P(TunerDemuxAidlTest, getAvSyncTime) {
727 description("Get the A/V sync time from a PCR filter.");
728 if (!live.hasFrontendConnection) {
729 return;
730 }
Frankie Lizcano8b87f252022-07-19 21:51:54 +0000731 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;
Hongguang600a6ae2021-07-08 18:51:51 -0700744
Frankie Lizcano8b87f252022-07-19 21:51:54 +0000745 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 }
Hongguang600a6ae2021-07-08 18:51:51 -0700770}
771
772TEST_P(TunerFilterAidlTest, StartFilterInDemux) {
773 description("Open and start a filter in Demux.");
774 if (!live.hasFrontendConnection) {
775 return;
776 }
777 // TODO use parameterized tests
Frankie Lizcano8b87f252022-07-19 21:51:54 +0000778 auto live_configs = generateLiveConfigurations();
779 for (auto& configuration : live_configs) {
780 live = configuration;
781 configSingleFilterInDemuxTest(filterMap[live.videoFilterId], frontendMap[live.frontendId]);
782 }
Hongguang600a6ae2021-07-08 18:51:51 -0700783}
784
785TEST_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 }
Frankie Lizcano8b87f252022-07-19 21:51:54 +0000791 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]);
Hongguang600a6ae2021-07-08 18:51:51 -0700798 }
Hongguang600a6ae2021-07-08 18:51:51 -0700799}
800
801TEST_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
Frankie Lizcano8b87f252022-07-19 21:51:54 +0000807 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 }
Hongguang600a6ae2021-07-08 18:51:51 -0700814}
815
816TEST_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
844TEST_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
Frankie Lizcano0c069532022-07-14 20:20:46 +0000850 auto timeFilter_configs = generateTimeFilterConfigurations();
851 for (auto& configuration : timeFilter_configs) {
852 timeFilter = configuration;
853 testTimeFilter(timeFilterMap[timeFilter.timeFilterId]);
854 }
Hongguang600a6ae2021-07-08 18:51:51 -0700855}
856
Gareth Fenn9a808452022-03-31 08:40:00 +0100857static 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
Patrick Rohr1586d212021-11-23 00:40:56 +0100899static 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}
Patrick Rohr149b0872021-11-20 00:39:37 +0100919
Patrick Rohr1586d212021-11-23 00:40:56 +0100920static 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
943void TunerFilterAidlTest::testDelayHint(const FilterConfig& filterConf) {
Gareth Fenn9a808452022-03-31 08:40:00 +0100944 if (!filterConf.timeDelayInMs && !filterConf.dataDelayInBytes) {
945 return;
946 }
947 if (!isEventProducingFilter(filterConf)) {
948 return;
949 }
Patrick Rohr149b0872021-11-20 00:39:37 +0100950 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
Patrick Rohr149b0872021-11-20 00:39:37 +0100963 ASSERT_TRUE(mFilterTests.openFilterInDemux(filterConf.type, filterConf.bufferSize));
964 ASSERT_TRUE(mFilterTests.getNewlyOpenedFilterId_64bit(filterId));
Patrick Rohr149b0872021-11-20 00:39:37 +0100965
Patrick Rohr1586d212021-11-23 00:40:56 +0100966 bool mediaFilter = isMediaFilter(filterConf);
Patrick Rohr149b0872021-11-20 00:39:37 +0100967 auto filter = mFilterTests.getFilterById(filterId);
968
Patrick Rohr2b0e9ee2021-12-27 13:55:16 +0100969 // startTime needs to be set before calling setDelayHint.
970 auto startTime = std::chrono::steady_clock::now();
971
Gareth Fenn9a808452022-03-31 08:40:00 +0100972 int timeDelayInMs = filterConf.timeDelayInMs;
973 if (timeDelayInMs > 0) {
Patrick Rohr1586d212021-11-23 00:40:56 +0100974 FilterDelayHint delayHint;
975 delayHint.hintType = FilterDelayHintType::TIME_DELAY_IN_MS;
Gareth Fenn9a808452022-03-31 08:40:00 +0100976 delayHint.hintValue = timeDelayInMs;
Patrick Rohr149b0872021-11-20 00:39:37 +0100977
Patrick Rohr1586d212021-11-23 00:40:56 +0100978 // setDelayHint should fail for media filters.
979 ASSERT_EQ(filter->setDelayHint(delayHint).isOk(), !mediaFilter);
980 }
Patrick Rohr149b0872021-11-20 00:39:37 +0100981
Patrick Rohr1586d212021-11-23 00:40:56 +0100982 int dataDelayInBytes = filterConf.dataDelayInBytes;
983 if (dataDelayInBytes > 0) {
984 FilterDelayHint delayHint;
985 delayHint.hintType = FilterDelayHintType::DATA_SIZE_DELAY_IN_BYTES;
986 delayHint.hintValue = dataDelayInBytes;
Patrick Rohr149b0872021-11-20 00:39:37 +0100987
Patrick Rohr1586d212021-11-23 00:40:56 +0100988 // setDelayHint should fail for media filters.
989 ASSERT_EQ(filter->setDelayHint(delayHint).isOk(), !mediaFilter);
990 }
Patrick Rohr149b0872021-11-20 00:39:37 +0100991
Patrick Rohr2b0e9ee2021-12-27 13:55:16 +0100992 // 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; });
Gareth Fenn9a808452022-03-31 08:40:00 +0100998
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));
Patrick Rohr1586d212021-11-23 00:40:56 +01001002 mFilterTests.startFilter(filterId);
Patrick Rohr2b0e9ee2021-12-27 13:55:16 +01001003
1004 auto timeout = std::chrono::seconds(30);
1005 ASSERT_EQ(future.wait_for(timeout), std::future_status::ready);
1006
Patrick Rohr1586d212021-11-23 00:40:56 +01001007 mFilterTests.stopFilter(filterId);
Patrick Rohr149b0872021-11-20 00:39:37 +01001008
Patrick Rohr1586d212021-11-23 00:40:56 +01001009 if (!mediaFilter) {
Patrick Rohr1586d212021-11-23 00:40:56 +01001010 int callbackSize = 0;
Patrick Rohr2b0e9ee2021-12-27 13:55:16 +01001011 future = cb->verifyFilterCallback(
Patrick Rohr1586d212021-11-23 00:40:56 +01001012 [&callbackSize](const std::vector<DemuxFilterEvent>& events) {
1013 for (const auto& event : events) {
1014 callbackSize += getDemuxFilterEventDataLength(event);
1015 }
1016 return true;
1017 });
1018
Patrick Rohr1586d212021-11-23 00:40:56 +01001019 ASSERT_TRUE(mFilterTests.startFilter(filterId));
1020
1021 // block and wait for callback to be received.
Patrick Rohr1586d212021-11-23 00:40:56 +01001022 ASSERT_EQ(future.wait_for(timeout), std::future_status::ready);
Patrick Rohr1586d212021-11-23 00:40:56 +01001023
Gareth Fenn9a808452022-03-31 08:40:00 +01001024 auto duration = std::chrono::steady_clock::now() - startTime;
1025 bool delayHintTest = duration >= std::chrono::milliseconds(timeDelayInMs);
Patrick Rohr1586d212021-11-23 00:40:56 +01001026 bool dataSizeTest = callbackSize >= dataDelayInBytes;
1027
Gareth Fenn9a808452022-03-31 08:40:00 +01001028 if (timeDelayInMs > 0 && dataDelayInBytes > 0) {
Patrick Rohr1586d212021-11-23 00:40:56 +01001029 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
Patrick Rohr149b0872021-11-20 00:39:37 +01001039 ASSERT_TRUE(mFilterTests.closeFilter(filterId));
1040 ASSERT_TRUE(mDemuxTests.closeDemux());
1041 ASSERT_TRUE(mFrontendTests.closeFrontend());
1042}
1043
Patrick Rohr1586d212021-11-23 00:40:56 +01001044TEST_P(TunerFilterAidlTest, FilterDelayHintTest) {
1045 description("Test filter time delay hint.");
Gareth Fenn9a808452022-03-31 08:40:00 +01001046 if (!live.hasFrontendConnection) {
1047 return;
1048 }
Patrick Rohr1586d212021-11-23 00:40:56 +01001049 for (const auto& obj : filterMap) {
1050 testDelayHint(obj.second);
1051 }
1052}
1053
Hongguang600a6ae2021-07-08 18:51:51 -07001054TEST_P(TunerPlaybackAidlTest, PlaybackDataFlowWithTsSectionFilterTest) {
1055 description("Feed ts data from playback and configure Ts section filter to get output");
Frankie Lizcanoa53f5542022-07-07 17:32:06 +00001056 if (!playback.support) {
Hongguang600a6ae2021-07-08 18:51:51 -07001057 return;
1058 }
Frankie Lizcanoa53f5542022-07-07 17:32:06 +00001059 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 }
Hongguang600a6ae2021-07-08 18:51:51 -07001066}
1067
1068TEST_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 }
Frankie Lizcanoa53f5542022-07-07 17:32:06 +00001073 vector<DvrPlaybackHardwareConnections> playback_configs = generatePlaybackConfigs();
1074 for (auto& configuration : playback_configs) {
1075 playback = configuration;
1076 playbackSingleFilterTest(filterMap[playback.audioFilterId], dvrMap[playback.dvrId]);
1077 }
Hongguang600a6ae2021-07-08 18:51:51 -07001078}
1079
1080TEST_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 }
Frankie Lizcanoa53f5542022-07-07 17:32:06 +00001085 vector<DvrPlaybackHardwareConnections> playback_configs = generatePlaybackConfigs();
1086 for (auto& configuration : playback_configs) {
1087 playback = configuration;
1088 playbackSingleFilterTest(filterMap[playback.videoFilterId], dvrMap[playback.dvrId]);
1089 }
Hongguang600a6ae2021-07-08 18:51:51 -07001090}
1091
Ray Chin62ab6c92022-09-15 15:07:33 +08001092TEST_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
Hongguang600a6ae2021-07-08 18:51:51 -07001104TEST_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 }
Frankie Lizcano9c464f72022-07-18 17:56:52 +00001109 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 }
Hongguang600a6ae2021-07-08 18:51:51 -07001115}
1116
1117TEST_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 }
Frankie Lizcano9c464f72022-07-18 17:56:52 +00001123 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 }
Hongguang600a6ae2021-07-08 18:51:51 -07001130}
1131
1132TEST_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 }
Frankie Lizcanoecba02a2022-07-12 17:56:54 +00001137 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 }
Hongguang600a6ae2021-07-08 18:51:51 -07001148}
1149
Ray Chin62ab6c92022-09-15 15:07:33 +08001150TEST_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
Hongguang600a6ae2021-07-08 18:51:51 -07001163TEST_P(TunerFrontendAidlTest, TuneFrontend) {
1164 description("Tune one Frontend with specific setting and check Lock event");
1165 if (!live.hasFrontendConnection) {
1166 return;
1167 }
Frankie Lizcano8b87f252022-07-19 21:51:54 +00001168 auto live_configs = generateLiveConfigurations();
1169 for (auto& configuration : live_configs) {
1170 live = configuration;
1171 mFrontendTests.tuneTest(frontendMap[live.frontendId]);
1172 }
Hongguang600a6ae2021-07-08 18:51:51 -07001173}
1174
1175TEST_P(TunerFrontendAidlTest, AutoScanFrontend) {
1176 description("Run an auto frontend scan with specific setting and check lock scanMessage");
1177 if (!scan.hasFrontendConnection) {
1178 return;
1179 }
Frankie Lizcano3138d6b2022-07-11 22:06:45 +00001180 vector<ScanHardwareConnections> scan_configs = generateScanConfigurations();
1181 for (auto& configuration : scan_configs) {
1182 scan = configuration;
1183 mFrontendTests.scanTest(frontendMap[scan.frontendId], FrontendScanType::SCAN_AUTO);
1184 }
Hongguang600a6ae2021-07-08 18:51:51 -07001185}
1186
1187TEST_P(TunerFrontendAidlTest, BlindScanFrontend) {
1188 description("Run an blind frontend scan with specific setting and check lock scanMessage");
1189 if (!scan.hasFrontendConnection) {
1190 return;
1191 }
Frankie Lizcano3138d6b2022-07-11 22:06:45 +00001192 vector<ScanHardwareConnections> scan_configs = generateScanConfigurations();
1193 for (auto& configuration : scan_configs) {
1194 scan = configuration;
1195 mFrontendTests.scanTest(frontendMap[scan.frontendId], FrontendScanType::SCAN_BLIND);
1196 }
Hongguang600a6ae2021-07-08 18:51:51 -07001197}
1198
1199TEST_P(TunerFrontendAidlTest, TuneFrontendWithFrontendSettings) {
1200 description("Tune one Frontend with setting and check Lock event");
1201 if (!live.hasFrontendConnection) {
1202 return;
1203 }
Frankie Lizcano8b87f252022-07-19 21:51:54 +00001204 auto live_configs = generateLiveConfigurations();
1205 for (auto& configuration : live_configs) {
1206 live = configuration;
1207 mFrontendTests.tuneTest(frontendMap[live.frontendId]);
1208 }
Hongguang600a6ae2021-07-08 18:51:51 -07001209}
1210
1211TEST_P(TunerFrontendAidlTest, BlindScanFrontendWithEndFrequency) {
1212 description("Run an blind frontend scan with setting and check lock scanMessage");
1213 if (!scan.hasFrontendConnection) {
1214 return;
1215 }
Frankie Lizcano3138d6b2022-07-11 22:06:45 +00001216 vector<ScanHardwareConnections> scan_configs = generateScanConfigurations();
1217 for (auto& configuration : scan_configs) {
1218 scan = configuration;
1219 mFrontendTests.scanTest(frontendMap[scan.frontendId], FrontendScanType::SCAN_BLIND);
1220 }
Hongguang600a6ae2021-07-08 18:51:51 -07001221}
1222
1223TEST_P(TunerFrontendAidlTest, LinkToCiCam) {
1224 description("Test Frontend link to CiCam");
1225 if (!live.hasFrontendConnection) {
1226 return;
1227 }
Frankie Lizcano8b87f252022-07-19 21:51:54 +00001228 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]);
Hongguang600a6ae2021-07-08 18:51:51 -07001235 }
Hongguang600a6ae2021-07-08 18:51:51 -07001236}
1237
Hongguangfcedda02021-12-13 17:08:02 -08001238TEST_P(TunerFrontendAidlTest, getHardwareInfo) {
1239 description("Test Frontend get hardware info");
1240 if (!live.hasFrontendConnection) {
1241 return;
1242 }
Frankie Lizcano8b87f252022-07-19 21:51:54 +00001243 auto live_configs = generateLiveConfigurations();
1244 for (auto& configuration : live_configs) {
1245 live = configuration;
1246 mFrontendTests.debugInfoTest(frontendMap[live.frontendId]);
1247 }
Hongguangfcedda02021-12-13 17:08:02 -08001248}
1249
Hongguang5766ddf2021-12-23 11:40:37 -08001250TEST_P(TunerFrontendAidlTest, maxNumberOfFrontends) {
1251 description("Test Max Frontend number");
1252 if (!live.hasFrontendConnection) {
1253 return;
1254 }
1255 mFrontendTests.maxNumberOfFrontendsTest();
1256}
1257
Hongguang881190f2022-01-14 13:23:37 -08001258TEST_P(TunerFrontendAidlTest, statusReadinessTest) {
1259 description("Test Max Frontend status readiness");
1260 if (!live.hasFrontendConnection) {
1261 return;
1262 }
Frankie Lizcano8b87f252022-07-19 21:51:54 +00001263 auto live_configs = generateLiveConfigurations();
1264 for (auto& configuration : live_configs) {
1265 live = configuration;
1266 mFrontendTests.statusReadinessTest(frontendMap[live.frontendId]);
1267 }
Hongguang881190f2022-01-14 13:23:37 -08001268}
1269
Hongguang600a6ae2021-07-08 18:51:51 -07001270TEST_P(TunerBroadcastAidlTest, BroadcastDataFlowVideoFilterTest) {
1271 description("Test Video Filter functionality in Broadcast use case.");
1272 if (!live.hasFrontendConnection) {
1273 return;
1274 }
Frankie Lizcano8b87f252022-07-19 21:51:54 +00001275 auto live_configs = generateLiveConfigurations();
1276 for (auto& configuration : live_configs) {
1277 live = configuration;
1278 broadcastSingleFilterTest(filterMap[live.videoFilterId], frontendMap[live.frontendId]);
1279 }
Hongguang600a6ae2021-07-08 18:51:51 -07001280}
1281
1282TEST_P(TunerBroadcastAidlTest, BroadcastDataFlowAudioFilterTest) {
1283 description("Test Audio Filter functionality in Broadcast use case.");
1284 if (!live.hasFrontendConnection) {
1285 return;
1286 }
Frankie Lizcano8b87f252022-07-19 21:51:54 +00001287 auto live_configs = generateLiveConfigurations();
1288 for (auto& configuration : live_configs) {
1289 live = configuration;
1290 broadcastSingleFilterTest(filterMap[live.audioFilterId], frontendMap[live.frontendId]);
1291 }
Hongguang600a6ae2021-07-08 18:51:51 -07001292}
1293
1294TEST_P(TunerBroadcastAidlTest, BroadcastDataFlowSectionFilterTest) {
1295 description("Test Section Filter functionality in Broadcast use case.");
1296 if (!live.hasFrontendConnection) {
1297 return;
1298 }
Frankie Lizcano8b87f252022-07-19 21:51:54 +00001299 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]);
Hongguang600a6ae2021-07-08 18:51:51 -07001306 }
Hongguang600a6ae2021-07-08 18:51:51 -07001307}
1308
1309TEST_P(TunerBroadcastAidlTest, IonBufferTest) {
1310 description("Test the av filter data bufferring.");
1311 if (!live.hasFrontendConnection) {
1312 return;
1313 }
Frankie Lizcano8b87f252022-07-19 21:51:54 +00001314 auto live_configs = generateLiveConfigurations();
1315 for (auto& configuration : live_configs) {
1316 live = configuration;
1317 broadcastSingleFilterTest(filterMap[live.videoFilterId], frontendMap[live.frontendId]);
1318 }
Hongguang600a6ae2021-07-08 18:51:51 -07001319}
1320
1321TEST_P(TunerBroadcastAidlTest, LnbBroadcastDataFlowVideoFilterTest) {
1322 description("Test Video Filter functionality in Broadcast with Lnb use case.");
1323 if (!lnbLive.support) {
1324 return;
1325 }
Frankie Lizcano1e283b32022-07-08 21:07:42 +00001326 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 }
Hongguang600a6ae2021-07-08 18:51:51 -07001336}
1337
1338TEST_P(TunerBroadcastAidlTest, MediaFilterWithSharedMemoryHandle) {
1339 description("Test the Media Filter with shared memory handle");
1340 if (!live.hasFrontendConnection) {
1341 return;
1342 }
Frankie Lizcano8b87f252022-07-19 21:51:54 +00001343 auto live_configs = generateLiveConfigurations();
1344 for (auto& configuration : live_configs) {
1345 live = configuration;
1346 mediaFilterUsingSharedMemoryTest(filterMap[live.videoFilterId],
1347 frontendMap[live.frontendId]);
1348 }
Hongguang600a6ae2021-07-08 18:51:51 -07001349}
1350
1351TEST_P(TunerDescramblerAidlTest, CreateDescrambler) {
1352 description("Create Descrambler");
1353 if (!descrambling.support) {
1354 return;
1355 }
Frankie Lizcanof4e07962022-07-13 20:54:34 +00001356 vector<DescramblingHardwareConnections> descrambling_configs =
1357 generateDescramblingConfigurations();
1358 if (descrambling_configs.empty()) {
1359 ALOGD("No valid descrambling combinations in the configuration file.");
1360 return;
Hongguang600a6ae2021-07-08 18:51:51 -07001361 }
Frankie Lizcanof4e07962022-07-13 20:54:34 +00001362 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));
Hongguang600a6ae2021-07-08 18:51:51 -07001367
Frankie Lizcanof4e07962022-07-13 20:54:34 +00001368 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 }
Hongguang600a6ae2021-07-08 18:51:51 -07001376
Frankie Lizcanof4e07962022-07-13 20:54:34 +00001377 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 }
Hongguang600a6ae2021-07-08 18:51:51 -07001384 }
1385}
1386
1387TEST_P(TunerDescramblerAidlTest, ScrambledBroadcastDataFlowMediaFiltersTest) {
1388 description("Test ts audio filter in scrambled broadcast use case");
1389 if (!descrambling.support) {
1390 return;
1391 }
Frankie Lizcanof4e07962022-07-13 20:54:34 +00001392 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],
Frankie Lizcano82101d22022-07-28 00:12:35 +00001404 descramblerMap[descrambling.descramblerId],
1405 Dataflow_Context::DESCRAMBLING);
Frankie Lizcanof4e07962022-07-13 20:54:34 +00001406 }
Hongguang600a6ae2021-07-08 18:51:51 -07001407}
1408
Frankie Lizcano82101d22022-07-28 00:12:35 +00001409TEST_P(TunerDescramblerAidlTest, ScrambledBroadcastDataFlowMediaFiltersTestWithLnb) {
1410 description("Test media filters in scrambled broadcast use case with Lnb");
1411 if (!lnbDescrambling.support) {
1412 return;
1413 }
Frankie Lizcanobcf4ebb2022-08-01 18:06:00 +00001414 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 }
Frankie Lizcano82101d22022-07-28 00:12:35 +00001428}
1429
Hongguang600a6ae2021-07-08 18:51:51 -07001430INSTANTIATE_TEST_SUITE_P(PerInstance, TunerBroadcastAidlTest,
1431 testing::ValuesIn(android::getAidlHalInstanceNames(ITuner::descriptor)),
1432 android::PrintInstanceNameToString);
1433
1434INSTANTIATE_TEST_SUITE_P(PerInstance, TunerFrontendAidlTest,
1435 testing::ValuesIn(android::getAidlHalInstanceNames(ITuner::descriptor)),
1436 android::PrintInstanceNameToString);
1437
1438INSTANTIATE_TEST_SUITE_P(PerInstance, TunerFilterAidlTest,
1439 testing::ValuesIn(android::getAidlHalInstanceNames(ITuner::descriptor)),
1440 android::PrintInstanceNameToString);
1441
1442INSTANTIATE_TEST_SUITE_P(PerInstance, TunerRecordAidlTest,
1443 testing::ValuesIn(android::getAidlHalInstanceNames(ITuner::descriptor)),
1444 android::PrintInstanceNameToString);
1445
1446INSTANTIATE_TEST_SUITE_P(PerInstance, TunerLnbAidlTest,
1447 testing::ValuesIn(android::getAidlHalInstanceNames(ITuner::descriptor)),
1448 android::PrintInstanceNameToString);
1449
1450INSTANTIATE_TEST_SUITE_P(PerInstance, TunerDemuxAidlTest,
1451 testing::ValuesIn(android::getAidlHalInstanceNames(ITuner::descriptor)),
1452 android::PrintInstanceNameToString);
1453
1454INSTANTIATE_TEST_SUITE_P(PerInstance, TunerPlaybackAidlTest,
1455 testing::ValuesIn(android::getAidlHalInstanceNames(ITuner::descriptor)),
1456 android::PrintInstanceNameToString);
1457
1458INSTANTIATE_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.
1465int main(int argc, char** argv) {
1466 ::testing::InitGoogleTest(&argc, argv);
1467 ABinderProcess_setThreadPoolMaxThreadCount(1);
1468 ABinderProcess_startThreadPool();
1469 return RUN_ALL_TESTS();
1470}