blob: b6e1020b645f8824a83b87040adb2b5be5544810 [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#pragma once
18
19#include <android-base/logging.h>
20#include <android_media_tuner_testing_configuration_V1_0.h>
21#include <android_media_tuner_testing_configuration_V1_0_enums.h>
22
23#include <aidl/android/hardware/tv/tuner/DataFormat.h>
24#include <aidl/android/hardware/tv/tuner/DemuxAlpFilterType.h>
25#include <aidl/android/hardware/tv/tuner/DemuxFilterAvSettings.h>
26#include <aidl/android/hardware/tv/tuner/DemuxFilterEvent.h>
27#include <aidl/android/hardware/tv/tuner/DemuxFilterMainType.h>
28#include <aidl/android/hardware/tv/tuner/DemuxFilterRecordSettings.h>
29#include <aidl/android/hardware/tv/tuner/DemuxFilterSectionSettings.h>
30#include <aidl/android/hardware/tv/tuner/DemuxFilterSettings.h>
31#include <aidl/android/hardware/tv/tuner/DemuxFilterType.h>
32#include <aidl/android/hardware/tv/tuner/DemuxIpAddress.h>
33#include <aidl/android/hardware/tv/tuner/DemuxIpFilterSettings.h>
34#include <aidl/android/hardware/tv/tuner/DemuxIpFilterType.h>
35#include <aidl/android/hardware/tv/tuner/DemuxMmtpFilterType.h>
36#include <aidl/android/hardware/tv/tuner/DemuxRecordScIndexType.h>
37#include <aidl/android/hardware/tv/tuner/DemuxTlvFilterType.h>
38#include <aidl/android/hardware/tv/tuner/DemuxTsFilterType.h>
39#include <aidl/android/hardware/tv/tuner/DvrSettings.h>
40#include <aidl/android/hardware/tv/tuner/DvrType.h>
41#include <aidl/android/hardware/tv/tuner/FrontendDvbsSettings.h>
42#include <aidl/android/hardware/tv/tuner/FrontendDvbtBandwidth.h>
43#include <aidl/android/hardware/tv/tuner/FrontendDvbtCoderate.h>
44#include <aidl/android/hardware/tv/tuner/FrontendDvbtConstellation.h>
45#include <aidl/android/hardware/tv/tuner/FrontendDvbtGuardInterval.h>
46#include <aidl/android/hardware/tv/tuner/FrontendDvbtHierarchy.h>
47#include <aidl/android/hardware/tv/tuner/FrontendDvbtPlpMode.h>
48#include <aidl/android/hardware/tv/tuner/FrontendDvbtSettings.h>
49#include <aidl/android/hardware/tv/tuner/FrontendDvbtStandard.h>
50#include <aidl/android/hardware/tv/tuner/FrontendDvbtTransmissionMode.h>
51#include <aidl/android/hardware/tv/tuner/FrontendSettings.h>
52#include <aidl/android/hardware/tv/tuner/FrontendStatus.h>
53#include <aidl/android/hardware/tv/tuner/FrontendStatusType.h>
54#include <aidl/android/hardware/tv/tuner/FrontendType.h>
55#include <aidl/android/hardware/tv/tuner/LnbPosition.h>
56#include <aidl/android/hardware/tv/tuner/LnbTone.h>
57#include <aidl/android/hardware/tv/tuner/LnbVoltage.h>
58#include <aidl/android/hardware/tv/tuner/PlaybackSettings.h>
59#include <aidl/android/hardware/tv/tuner/RecordSettings.h>
60
61using namespace std;
62using namespace aidl::android::hardware::tv::tuner;
63using namespace android::media::tuner::testing::configuration::V1_0;
64
65const string emptyHardwareId = "";
66
67static string mConfigFilePath;
68
69#define PROVISION_STR \
70 "{ " \
71 " \"id\": 21140844, " \
72 " \"name\": \"Test Title\", " \
73 " \"lowercase_organization_name\": \"Android\", " \
74 " \"asset_key\": { " \
75 " \"encryption_key\": \"nezAr3CHFrmBR9R8Tedotw==\" " \
76 " }, " \
77 " \"cas_type\": 1, " \
78 " \"track_types\": [ ] " \
79 "} "
80
81struct FrontendConfig {
82 bool isSoftwareFe;
83 FrontendType type;
84 bool canConnectToCiCam;
85 int32_t ciCamId;
Hongguange106f472022-01-11 12:09:22 -080086 int32_t removePid;
Hongguang600a6ae2021-07-08 18:51:51 -070087 FrontendSettings settings;
88 vector<FrontendStatusType> tuneStatusTypes;
89 vector<FrontendStatus> expectTuneStatuses;
90};
91
92struct FilterConfig {
93 int32_t bufferSize;
94 DemuxFilterType type;
95 DemuxFilterSettings settings;
96 bool getMqDesc;
97 AvStreamType streamType;
98 int32_t ipCid;
99 int32_t monitorEventTypes;
Patrick Rohr1586d212021-11-23 00:40:56 +0100100 int timeDelayInMs = 0;
101 int dataDelayInBytes = 0;
Hongguang600a6ae2021-07-08 18:51:51 -0700102
103 bool operator<(const FilterConfig& /*c*/) const { return false; }
104};
105
106struct DvrConfig {
107 DvrType type;
108 int32_t bufferSize;
109 DvrSettings settings;
110 string playbackInputFile;
111};
112
113struct LnbConfig {
114 string name;
115 LnbVoltage voltage;
116 LnbTone tone;
117 LnbPosition position;
118};
119
120struct TimeFilterConfig {
121 int64_t timeStamp;
122};
123
124struct DescramblerConfig {
125 int32_t casSystemId;
126 string provisionStr;
127 vector<uint8_t> hidlPvtData;
128};
129
130struct LiveBroadcastHardwareConnections {
131 bool hasFrontendConnection;
132 string frontendId;
133 string dvrSoftwareFeId;
134 string audioFilterId;
135 string videoFilterId;
136 string sectionFilterId;
137 string ipFilterId;
138 string pcrFilterId;
139 /* list string of extra filters; */
140};
141
142struct ScanHardwareConnections {
143 bool hasFrontendConnection;
144 string frontendId;
145};
146
147struct DvrPlaybackHardwareConnections {
148 bool support;
Frankie Lizcano50461932022-06-28 21:36:26 +0000149 bool hasExtraFilters = false;
Hongguang600a6ae2021-07-08 18:51:51 -0700150 string frontendId;
151 string dvrId;
152 string audioFilterId;
153 string videoFilterId;
154 string sectionFilterId;
Frankie Lizcano50461932022-06-28 21:36:26 +0000155 vector<string> extraFilters;
Hongguang600a6ae2021-07-08 18:51:51 -0700156};
157
158struct DvrRecordHardwareConnections {
159 bool support;
160 bool hasFrontendConnection;
161 string frontendId;
162 string dvrRecordId;
163 string dvrSoftwareFeId;
164 string recordFilterId;
165 string dvrSourceId;
166};
167
168struct DescramblingHardwareConnections {
169 bool support;
170 bool hasFrontendConnection;
171 string frontendId;
172 string dvrSoftwareFeId;
173 string audioFilterId;
174 string videoFilterId;
175 string descramblerId;
176 string dvrSourceId;
Frankie Lizcanof5352122022-06-29 22:10:16 +0000177 vector<string> extraFilters;
Hongguang600a6ae2021-07-08 18:51:51 -0700178};
179
180struct LnbLiveHardwareConnections {
181 bool support;
182 string frontendId;
183 string audioFilterId;
184 string videoFilterId;
185 string lnbId;
186 vector<string> diseqcMsgs;
Frankie Lizcano647d5aa2022-06-30 20:49:31 +0000187 vector<string> extraFilters;
Hongguang600a6ae2021-07-08 18:51:51 -0700188};
189
190struct LnbRecordHardwareConnections {
191 bool support;
192 string frontendId;
193 string dvrRecordId;
194 string recordFilterId;
195 string lnbId;
196 vector<string> diseqcMsgs;
Frankie Lizcano647d5aa2022-06-30 20:49:31 +0000197 vector<string> extraFilters;
Hongguang600a6ae2021-07-08 18:51:51 -0700198};
199
200struct TimeFilterHardwareConnections {
201 bool support;
202 string timeFilterId;
203};
204
205struct TunerTestingConfigAidlReader1_0 {
206 public:
207 static void setConfigFilePath(string path) { mConfigFilePath = path; }
208
209 static bool checkConfigFileExists() {
210 auto res = read(mConfigFilePath.c_str());
211 if (res == nullopt) {
212 ALOGW("[ConfigReader] Couldn't read %s."
213 "Please check tuner_testing_dynamic_configuration.xsd"
214 "and sample_tuner_vts_config.xml for more details on how to config Tune VTS.",
215 mConfigFilePath.c_str());
216 }
217 return (res != nullopt);
218 }
219
220 static TunerConfiguration getTunerConfig() { return *read(mConfigFilePath.c_str()); }
221
222 static DataFlowConfiguration getDataFlowConfiguration() {
223 return *getTunerConfig().getFirstDataFlowConfiguration();
224 }
225
226 static HardwareConfiguration getHardwareConfig() {
227 return *getTunerConfig().getFirstHardwareConfiguration();
228 }
229
230 static void readFrontendConfig1_0(map<string, FrontendConfig>& frontendMap) {
231 auto hardwareConfig = getHardwareConfig();
232 if (hardwareConfig.hasFrontends()) {
233 // TODO: b/182519645 complete the tune status config
234 vector<FrontendStatusType> types;
235 vector<FrontendStatus> statuses;
236
237 types.push_back(FrontendStatusType::DEMOD_LOCK);
238 types.push_back(FrontendStatusType::UEC);
239 types.push_back(FrontendStatusType::IS_MISO);
240
241 FrontendStatus status;
242 status.set<FrontendStatus::Tag::isDemodLocked>(true);
243 statuses.push_back(status);
244 status.set<FrontendStatus::Tag::uec>(4);
245 statuses.push_back(status);
246 status.set<FrontendStatus::Tag::isMiso>(true);
247 statuses.push_back(status);
248
249 auto frontends = *hardwareConfig.getFirstFrontends();
250 for (auto feConfig : frontends.getFrontend()) {
251 string id = feConfig.getId();
252 if (id.compare(string("FE_DEFAULT")) == 0) {
253 // overrid default
254 frontendMap.erase(string("FE_DEFAULT"));
255 }
256 FrontendType type;
257 switch (feConfig.getType()) {
258 case FrontendTypeEnum::UNDEFINED:
259 type = FrontendType::UNDEFINED;
260 break;
261 // TODO: b/182519645 finish all other frontend settings
262 case FrontendTypeEnum::ANALOG:
263 type = FrontendType::ANALOG;
264 break;
265 case FrontendTypeEnum::ATSC:
266 type = FrontendType::ATSC;
Frankie Lizcano3ad735d2022-06-24 19:20:54 +0000267 frontendMap[id].settings.set<
268 FrontendSettings::Tag::atsc>(
269 readAtscFrontendSettings(feConfig));
Hongguang600a6ae2021-07-08 18:51:51 -0700270 break;
271 case FrontendTypeEnum::ATSC3:
272 type = FrontendType::ATSC3;
273 break;
274 case FrontendTypeEnum::DVBC:
275 type = FrontendType::DVBC;
276 break;
277 case FrontendTypeEnum::DVBS:
278 type = FrontendType::DVBS;
279 frontendMap[id].settings.set<FrontendSettings::Tag::dvbs>(
280 readDvbsFrontendSettings(feConfig));
281 break;
282 case FrontendTypeEnum::DVBT: {
283 type = FrontendType::DVBT;
284 frontendMap[id].settings.set<FrontendSettings::Tag::dvbt>(
285 readDvbtFrontendSettings(feConfig));
286 break;
287 }
288 case FrontendTypeEnum::ISDBS:
289 type = FrontendType::ISDBS;
Frankie Lizcano01dca3d2022-06-29 18:22:02 +0000290 frontendMap[id].settings.set<FrontendSettings::Tag::isdbs>(
Frankie Lizcano452b0262022-06-27 22:00:33 +0000291 readIsdbsFrontendSettings(feConfig));
Hongguang600a6ae2021-07-08 18:51:51 -0700292 break;
293 case FrontendTypeEnum::ISDBS3:
294 type = FrontendType::ISDBS3;
295 break;
296 case FrontendTypeEnum::ISDBT:
297 type = FrontendType::ISDBT;
Frankie Lizcanoaee8c9e2022-06-24 21:28:00 +0000298 frontendMap[id].settings.set<FrontendSettings::Tag::isdbt>(
299 readIsdbtFrontendSettings(feConfig));
Hongguang600a6ae2021-07-08 18:51:51 -0700300 break;
301 case FrontendTypeEnum::DTMB:
302 type = FrontendType::DTMB;
303 break;
304 case FrontendTypeEnum::UNKNOWN:
305 ALOGW("[ConfigReader] invalid frontend type");
306 return;
307 default:
308 ALOGW("[ConfigReader] fe already handled in 1_0 reader.");
309 break;
310 }
311 frontendMap[id].type = type;
312 frontendMap[id].isSoftwareFe = feConfig.getIsSoftwareFrontend();
313 // TODO: b/182519645 complete the tune status config
314 frontendMap[id].tuneStatusTypes = types;
315 frontendMap[id].expectTuneStatuses = statuses;
Hongguange106f472022-01-11 12:09:22 -0800316 getCiCamInfo(feConfig, frontendMap[id].canConnectToCiCam, frontendMap[id].ciCamId,
317 frontendMap[id].removePid);
Hongguang600a6ae2021-07-08 18:51:51 -0700318 }
319 }
320 }
321
322 static void readFilterConfig1_0(map<string, FilterConfig>& filterMap) {
323 auto hardwareConfig = getHardwareConfig();
324 if (hardwareConfig.hasFilters()) {
325 auto filters = *hardwareConfig.getFirstFilters();
326 for (auto filterConfig : filters.getFilter()) {
327 string id = filterConfig.getId();
328 if (id.compare(string("FILTER_AUDIO_DEFAULT")) == 0) {
329 // overrid default
330 filterMap.erase(string("FILTER_AUDIO_DEFAULT"));
331 }
332 if (id.compare(string("FILTER_VIDEO_DEFAULT")) == 0) {
333 // overrid default
334 filterMap.erase(string("FILTER_VIDEO_DEFAULT"));
335 }
336
337 DemuxFilterType type;
338 DemuxFilterSettings settings;
339 if (!readFilterTypeAndSettings(filterConfig, type, settings)) {
340 ALOGW("[ConfigReader] invalid filter type");
341 return;
342 }
343 filterMap[id].type = type;
344 filterMap[id].bufferSize = filterConfig.getBufferSize();
345 filterMap[id].getMqDesc = filterConfig.getUseFMQ();
346 filterMap[id].settings = settings;
347
348 if (filterConfig.hasMonitorEventTypes()) {
Hongguang11da2cb2021-08-05 19:05:12 -0700349 filterMap[id].monitorEventTypes = (int32_t)filterConfig.getMonitorEventTypes();
Hongguang600a6ae2021-07-08 18:51:51 -0700350 }
Patrick Rohr1586d212021-11-23 00:40:56 +0100351 if (filterConfig.hasTimeDelayInMs()) {
352 filterMap[id].timeDelayInMs = filterConfig.getTimeDelayInMs();
353 }
354 if (filterConfig.hasDataDelayInBytes()) {
355 filterMap[id].dataDelayInBytes = filterConfig.getDataDelayInBytes();
356 }
Hongguang600a6ae2021-07-08 18:51:51 -0700357 if (filterConfig.hasAvFilterSettings_optional()) {
358 auto av = filterConfig.getFirstAvFilterSettings_optional();
359 if (av->hasAudioStreamType_optional()) {
360 filterMap[id].streamType.set<AvStreamType::Tag::audio>(
361 static_cast<AudioStreamType>(av->getAudioStreamType_optional()));
362 }
363 if (av->hasVideoStreamType_optional()) {
364 filterMap[id].streamType.set<AvStreamType::Tag::video>(
365 static_cast<VideoStreamType>(av->getVideoStreamType_optional()));
366 }
367 }
368 if (filterConfig.hasIpFilterConfig_optional()) {
369 auto ip = filterConfig.getFirstIpFilterConfig_optional();
370 if (ip->hasIpCid()) {
371 filterMap[id].ipCid = ip->getIpCid();
372 }
373 }
374 }
375 }
376 }
377
378 static void readDvrConfig1_0(map<string, DvrConfig>& dvrMap) {
379 auto hardwareConfig = getHardwareConfig();
380 if (hardwareConfig.hasDvrs()) {
381 auto dvrs = *hardwareConfig.getFirstDvrs();
382 for (auto dvrConfig : dvrs.getDvr()) {
383 string id = dvrConfig.getId();
384 DvrType type;
385 switch (dvrConfig.getType()) {
386 case DvrTypeEnum::PLAYBACK:
387 type = DvrType::PLAYBACK;
388 dvrMap[id].settings.set<DvrSettings::Tag::playback>(
389 readPlaybackSettings(dvrConfig));
390 break;
391 case DvrTypeEnum::RECORD:
392 type = DvrType::RECORD;
393 dvrMap[id].settings.set<DvrSettings::Tag::record>(
394 readRecordSettings(dvrConfig));
395 break;
396 case DvrTypeEnum::UNKNOWN:
397 ALOGW("[ConfigReader] invalid DVR type");
398 return;
399 }
400 dvrMap[id].type = type;
Hongguang11da2cb2021-08-05 19:05:12 -0700401 dvrMap[id].bufferSize = static_cast<int32_t>(dvrConfig.getBufferSize());
Hongguang600a6ae2021-07-08 18:51:51 -0700402 if (dvrConfig.hasInputFilePath()) {
403 dvrMap[id].playbackInputFile = dvrConfig.getInputFilePath();
404 }
405 }
406 }
407 }
408
409 static void readLnbConfig1_0(map<string, LnbConfig>& lnbMap) {
410 auto hardwareConfig = getHardwareConfig();
411 if (hardwareConfig.hasLnbs()) {
412 auto lnbs = *hardwareConfig.getFirstLnbs();
413 for (auto lnbConfig : lnbs.getLnb()) {
414 string id = lnbConfig.getId();
415 if (lnbConfig.hasName()) {
416 lnbMap[id].name = lnbConfig.getName();
417 } else {
418 lnbMap[id].name = emptyHardwareId;
419 }
420 lnbMap[id].voltage = static_cast<LnbVoltage>(lnbConfig.getVoltage());
421 lnbMap[id].tone = static_cast<LnbTone>(lnbConfig.getTone());
422 lnbMap[id].position = static_cast<LnbPosition>(lnbConfig.getPosition());
423 }
424 }
425 }
426
427 static void readDescramblerConfig1_0(map<string, DescramblerConfig>& descramblerMap) {
428 auto hardwareConfig = getHardwareConfig();
429 if (hardwareConfig.hasDescramblers()) {
430 auto descramblers = *hardwareConfig.getFirstDescramblers();
431 for (auto descramblerConfig : descramblers.getDescrambler()) {
432 string id = descramblerConfig.getId();
433 descramblerMap[id].casSystemId =
Hongguang11da2cb2021-08-05 19:05:12 -0700434 static_cast<int32_t>(descramblerConfig.getCasSystemId());
Hongguang600a6ae2021-07-08 18:51:51 -0700435 if (descramblerConfig.hasProvisionStr()) {
436 descramblerMap[id].provisionStr = descramblerConfig.getProvisionStr();
437 } else {
438 descramblerMap[id].provisionStr = PROVISION_STR;
439 }
440 if (descramblerConfig.hasSesstionPrivatData()) {
441 auto privateData = descramblerConfig.getSesstionPrivatData();
442 int size = privateData.size();
443 descramblerMap[id].hidlPvtData.resize(size);
444 memcpy(descramblerMap[id].hidlPvtData.data(), privateData.data(), size);
445 } else {
446 descramblerMap[id].hidlPvtData.resize(256);
447 }
448 }
449 }
450 }
451
452 static void readDiseqcMessages(map<string, vector<uint8_t>>& diseqcMsgMap) {
453 auto hardwareConfig = getHardwareConfig();
454 if (hardwareConfig.hasDiseqcMessages()) {
455 auto msgs = *hardwareConfig.getFirstDiseqcMessages();
456 for (auto msgConfig : msgs.getDiseqcMessage()) {
457 string name = msgConfig.getMsgName();
458 for (uint8_t atom : msgConfig.getMsgBody()) {
459 diseqcMsgMap[name].push_back(atom);
460 }
461 }
462 }
463 }
464
465 static void readTimeFilterConfig1_0(map<string, TimeFilterConfig>& timeFilterMap) {
466 auto hardwareConfig = getHardwareConfig();
467 if (hardwareConfig.hasTimeFilters()) {
468 auto timeFilters = *hardwareConfig.getFirstTimeFilters();
469 for (auto timeFilterConfig : timeFilters.getTimeFilter()) {
470 string id = timeFilterConfig.getId();
Hongguang11da2cb2021-08-05 19:05:12 -0700471 timeFilterMap[id].timeStamp = static_cast<int64_t>(timeFilterConfig.getTimeStamp());
Hongguang600a6ae2021-07-08 18:51:51 -0700472 }
473 }
474 }
475
476 static void connectLiveBroadcast(LiveBroadcastHardwareConnections& live) {
477 auto dataFlow = getDataFlowConfiguration();
478 if (dataFlow.hasClearLiveBroadcast()) {
479 live.hasFrontendConnection = true;
480 } else {
481 live.hasFrontendConnection = false;
482 return;
483 }
484 auto liveConfig = *dataFlow.getFirstClearLiveBroadcast();
485 live.frontendId = liveConfig.getFrontendConnection();
486
487 live.audioFilterId = liveConfig.getAudioFilterConnection();
488 live.videoFilterId = liveConfig.getVideoFilterConnection();
489 if (liveConfig.hasPcrFilterConnection()) {
490 live.pcrFilterId = liveConfig.getPcrFilterConnection();
491 } else {
492 live.pcrFilterId = emptyHardwareId;
493 }
494 if (liveConfig.hasSectionFilterConnection()) {
495 live.sectionFilterId = liveConfig.getSectionFilterConnection();
496 } else {
497 live.sectionFilterId = emptyHardwareId;
498 }
499 if (liveConfig.hasDvrSoftwareFeConnection()) {
500 live.dvrSoftwareFeId = liveConfig.getDvrSoftwareFeConnection();
501 }
502 if (liveConfig.hasIpFilterConnection()) {
503 live.ipFilterId = liveConfig.getIpFilterConnection();
504 } else {
505 live.ipFilterId = emptyHardwareId;
506 }
507 }
508
509 static void connectScan(ScanHardwareConnections& scan) {
510 auto dataFlow = getDataFlowConfiguration();
511 if (dataFlow.hasScan()) {
512 scan.hasFrontendConnection = true;
513 } else {
514 scan.hasFrontendConnection = false;
515 return;
516 }
517 auto scanConfig = *dataFlow.getFirstScan();
518 scan.frontendId = scanConfig.getFrontendConnection();
519 }
520
521 static void connectDvrPlayback(DvrPlaybackHardwareConnections& playback) {
522 auto dataFlow = getDataFlowConfiguration();
523 if (dataFlow.hasDvrPlayback()) {
524 playback.support = true;
525 } else {
526 playback.support = false;
527 return;
528 }
529 auto playbackConfig = *dataFlow.getFirstDvrPlayback();
530 playback.dvrId = playbackConfig.getDvrConnection();
531 playback.audioFilterId = playbackConfig.getAudioFilterConnection();
532 playback.videoFilterId = playbackConfig.getVideoFilterConnection();
533 if (playbackConfig.hasSectionFilterConnection()) {
534 playback.sectionFilterId = playbackConfig.getSectionFilterConnection();
535 } else {
536 playback.sectionFilterId = emptyHardwareId;
537 }
Frankie Lizcano50461932022-06-28 21:36:26 +0000538 if (playbackConfig.hasOptionalFilters() && !playback.hasExtraFilters) {
539 auto optionalFilters = playbackConfig.getFirstOptionalFilters()->getOptionalFilter();
540 for (size_t i = 0; i < optionalFilters.size(); ++i) {
541 playback.extraFilters.push_back(optionalFilters[i].getFilterId());
542 }
543 playback.hasExtraFilters = true;
544 }
Hongguang600a6ae2021-07-08 18:51:51 -0700545 }
546
547 static void connectDvrRecord(DvrRecordHardwareConnections& record) {
548 auto dataFlow = getDataFlowConfiguration();
549 if (dataFlow.hasDvrRecord()) {
550 record.support = true;
551 } else {
552 record.support = false;
553 return;
554 }
555 auto recordConfig = *dataFlow.getFirstDvrRecord();
556 record.recordFilterId = recordConfig.getRecordFilterConnection();
557 record.dvrRecordId = recordConfig.getDvrRecordConnection();
558 if (recordConfig.hasDvrSoftwareFeConnection()) {
559 record.dvrSoftwareFeId = recordConfig.getDvrSoftwareFeConnection();
560 }
561 if (recordConfig.getHasFrontendConnection()) {
562 record.hasFrontendConnection = true;
563 record.dvrSourceId = emptyHardwareId;
564 record.frontendId = recordConfig.getFrontendConnection();
565 } else {
566 record.hasFrontendConnection = false;
567 record.dvrSourceId = recordConfig.getDvrSourceConnection();
568 }
569 }
570
571 static void connectDescrambling(DescramblingHardwareConnections& descrambling) {
572 auto dataFlow = getDataFlowConfiguration();
573 if (dataFlow.hasDescrambling()) {
574 descrambling.support = true;
575 } else {
576 descrambling.support = false;
577 return;
578 }
579 auto descConfig = *dataFlow.getFirstDescrambling();
580 descrambling.descramblerId = descConfig.getDescramblerConnection();
581 descrambling.audioFilterId = descConfig.getAudioFilterConnection();
582 descrambling.videoFilterId = descConfig.getVideoFilterConnection();
583 if (descConfig.hasDvrSoftwareFeConnection()) {
584 descrambling.dvrSoftwareFeId = descConfig.getDvrSoftwareFeConnection();
585 }
586 if (descConfig.getHasFrontendConnection()) {
587 descrambling.hasFrontendConnection = true;
588 descrambling.dvrSourceId = emptyHardwareId;
589 descrambling.frontendId = descConfig.getFrontendConnection();
590 } else {
591 descrambling.hasFrontendConnection = false;
592 descrambling.dvrSourceId = descConfig.getDvrSourceConnection();
593 }
Frankie Lizcanof5352122022-06-29 22:10:16 +0000594 if (descConfig.hasOptionalFilters()) {
595 auto optionalFilters = descConfig.getOptionalFilters();
596 descrambling.extraFilters = optionalFilters;
597 }
Hongguang600a6ae2021-07-08 18:51:51 -0700598 }
599
600 static void connectLnbLive(LnbLiveHardwareConnections& lnbLive) {
601 auto dataFlow = getDataFlowConfiguration();
602 if (dataFlow.hasLnbLive()) {
603 lnbLive.support = true;
604 } else {
605 lnbLive.support = false;
606 return;
607 }
608 auto lnbLiveConfig = *dataFlow.getFirstLnbLive();
609 lnbLive.frontendId = lnbLiveConfig.getFrontendConnection();
610 lnbLive.audioFilterId = lnbLiveConfig.getAudioFilterConnection();
611 lnbLive.videoFilterId = lnbLiveConfig.getVideoFilterConnection();
612 lnbLive.lnbId = lnbLiveConfig.getLnbConnection();
613 if (lnbLiveConfig.hasDiseqcMsgSender()) {
614 for (auto msgName : lnbLiveConfig.getDiseqcMsgSender()) {
615 lnbLive.diseqcMsgs.push_back(msgName);
616 }
617 }
Frankie Lizcano647d5aa2022-06-30 20:49:31 +0000618 if (lnbLiveConfig.hasOptionalFilters()) {
619 auto optionalFilters = lnbLiveConfig.getOptionalFilters();
620 lnbLive.extraFilters = optionalFilters;
621 }
Hongguang600a6ae2021-07-08 18:51:51 -0700622 }
623
624 static void connectLnbRecord(LnbRecordHardwareConnections& lnbRecord) {
625 auto dataFlow = getDataFlowConfiguration();
626 if (dataFlow.hasLnbRecord()) {
627 lnbRecord.support = true;
628 } else {
629 lnbRecord.support = false;
630 return;
631 }
632 auto lnbRecordConfig = *dataFlow.getFirstLnbRecord();
633 lnbRecord.frontendId = lnbRecordConfig.getFrontendConnection();
634 lnbRecord.recordFilterId = lnbRecordConfig.getRecordFilterConnection();
635 lnbRecord.dvrRecordId = lnbRecordConfig.getDvrRecordConnection();
636 lnbRecord.lnbId = lnbRecordConfig.getLnbConnection();
637 if (lnbRecordConfig.hasDiseqcMsgSender()) {
638 for (auto msgName : lnbRecordConfig.getDiseqcMsgSender()) {
639 lnbRecord.diseqcMsgs.push_back(msgName);
640 }
641 }
Frankie Lizcano647d5aa2022-06-30 20:49:31 +0000642 if (lnbRecordConfig.hasOptionalFilters()) {
643 auto optionalFilters = lnbRecordConfig.getOptionalFilters();
644 lnbRecord.extraFilters = optionalFilters;
645 }
Hongguang600a6ae2021-07-08 18:51:51 -0700646 }
647
648 static void connectTimeFilter(TimeFilterHardwareConnections& timeFilter) {
649 auto dataFlow = getDataFlowConfiguration();
650 if (dataFlow.hasTimeFilter()) {
651 timeFilter.support = true;
652 } else {
653 timeFilter.support = false;
654 return;
655 }
656 auto timeFilterConfig = *dataFlow.getFirstTimeFilter();
657 timeFilter.timeFilterId = timeFilterConfig.getTimeFilterConnection();
658 }
659
660 private:
661 static FrontendDvbtSettings readDvbtFrontendSettings(Frontend feConfig) {
662 ALOGW("[ConfigReader] fe type is dvbt");
663 FrontendDvbtSettings dvbtSettings{
Hongguang11da2cb2021-08-05 19:05:12 -0700664 .frequency = (int64_t)feConfig.getFrequency(),
Hongguang600a6ae2021-07-08 18:51:51 -0700665 };
Hongguang11da2cb2021-08-05 19:05:12 -0700666 if (feConfig.hasEndFrequency()) {
667 dvbtSettings.endFrequency = (int64_t)feConfig.getEndFrequency();
668 }
Hongguang600a6ae2021-07-08 18:51:51 -0700669 if (!feConfig.hasDvbtFrontendSettings_optional()) {
670 ALOGW("[ConfigReader] no more dvbt settings");
671 return dvbtSettings;
672 }
673 auto dvbt = feConfig.getFirstDvbtFrontendSettings_optional();
Hongguang11da2cb2021-08-05 19:05:12 -0700674 int32_t trans = static_cast<int32_t>(dvbt->getTransmissionMode());
Hongguang600a6ae2021-07-08 18:51:51 -0700675 dvbtSettings.transmissionMode = static_cast<FrontendDvbtTransmissionMode>(trans);
676 dvbtSettings.bandwidth = static_cast<FrontendDvbtBandwidth>(dvbt->getBandwidth());
677 dvbtSettings.isHighPriority = dvbt->getIsHighPriority();
678 dvbtSettings.hierarchy = static_cast<FrontendDvbtHierarchy>(dvbt->getHierarchy());
679 dvbtSettings.hpCoderate = static_cast<FrontendDvbtCoderate>(dvbt->getHpCoderate());
680 dvbtSettings.lpCoderate = static_cast<FrontendDvbtCoderate>(dvbt->getLpCoderate());
681 dvbtSettings.guardInterval =
682 static_cast<FrontendDvbtGuardInterval>(dvbt->getGuardInterval());
683 dvbtSettings.standard = static_cast<FrontendDvbtStandard>(dvbt->getStandard());
684 dvbtSettings.isMiso = dvbt->getIsMiso();
685 dvbtSettings.plpMode = static_cast<FrontendDvbtPlpMode>(dvbt->getPlpMode());
686 dvbtSettings.plpId = dvbt->getPlpId();
687 dvbtSettings.plpGroupId = dvbt->getPlpGroupId();
688 if (dvbt->hasConstellation()) {
689 dvbtSettings.constellation =
690 static_cast<FrontendDvbtConstellation>(dvbt->getConstellation());
691 }
692 return dvbtSettings;
693 }
694
695 static FrontendDvbsSettings readDvbsFrontendSettings(Frontend feConfig) {
696 ALOGW("[ConfigReader] fe type is dvbs");
697 FrontendDvbsSettings dvbsSettings{
Hongguang11da2cb2021-08-05 19:05:12 -0700698 .frequency = (int64_t)feConfig.getFrequency(),
Hongguang600a6ae2021-07-08 18:51:51 -0700699 };
Hongguang11da2cb2021-08-05 19:05:12 -0700700 if (feConfig.hasEndFrequency()) {
701 dvbsSettings.endFrequency = (int64_t)feConfig.getEndFrequency();
702 }
Hongguang600a6ae2021-07-08 18:51:51 -0700703 if (!feConfig.hasDvbsFrontendSettings_optional()) {
704 ALOGW("[ConfigReader] no more dvbs settings");
705 return dvbsSettings;
706 }
Hongguang11da2cb2021-08-05 19:05:12 -0700707 dvbsSettings.symbolRate = static_cast<int32_t>(
Hongguang600a6ae2021-07-08 18:51:51 -0700708 feConfig.getFirstDvbsFrontendSettings_optional()->getSymbolRate());
Hongguang11da2cb2021-08-05 19:05:12 -0700709 dvbsSettings.inputStreamId = static_cast<int32_t>(
Hongguang600a6ae2021-07-08 18:51:51 -0700710 feConfig.getFirstDvbsFrontendSettings_optional()->getInputStreamId());
711 auto dvbs = feConfig.getFirstDvbsFrontendSettings_optional();
712 if (dvbs->hasScanType()) {
713 dvbsSettings.scanType = static_cast<FrontendDvbsScanType>(dvbs->getScanType());
714 }
715 if (dvbs->hasIsDiseqcRxMessage()) {
716 dvbsSettings.isDiseqcRxMessage = dvbs->getIsDiseqcRxMessage();
717 }
718 return dvbsSettings;
719 }
720
Frankie Lizcano3ad735d2022-06-24 19:20:54 +0000721 static FrontendAtscSettings readAtscFrontendSettings(Frontend& feConfig) {
Frankie Lizcano01dca3d2022-06-29 18:22:02 +0000722 ALOGW("[ConfigReader] fe type is atsc");
723 FrontendAtscSettings atscSettings{
724 .frequency = (int64_t)feConfig.getFrequency(),
725 };
726 if (feConfig.hasEndFrequency()) {
727 atscSettings.endFrequency = (int64_t)feConfig.getEndFrequency();
728 }
729 if (!feConfig.hasAtscFrontendSettings_optional()) {
730 ALOGW("[ConfigReader] no more atsc settings");
731 return atscSettings;
732 }
733 auto atsc = feConfig.getFirstAtscFrontendSettings_optional();
734 atscSettings.inversion = static_cast<FrontendSpectralInversion>(atsc->getInversion());
735 atscSettings.modulation = static_cast<FrontendAtscModulation>(atsc->getModulation());
Frankie Lizcano3ad735d2022-06-24 19:20:54 +0000736 return atscSettings;
Frankie Lizcano452b0262022-06-27 22:00:33 +0000737 }
738
Frankie Lizcano01dca3d2022-06-29 18:22:02 +0000739 static FrontendIsdbsSettings readIsdbsFrontendSettings(Frontend& feConfig) {
740 ALOGW("[ConfigReader] fe type is isdbs");
741 FrontendIsdbsSettings isdbsSettings{.frequency = (int64_t)feConfig.getFrequency()};
742 if (feConfig.hasEndFrequency()) {
Frankie Lizcano452b0262022-06-27 22:00:33 +0000743 isdbsSettings.endFrequency = (int64_t)feConfig.getEndFrequency();
Frankie Lizcano01dca3d2022-06-29 18:22:02 +0000744 }
745 if (!feConfig.hasIsdbsFrontendSettings_optional()) {
Frankie Lizcano452b0262022-06-27 22:00:33 +0000746 ALOGW("[ConfigReader] no more isdbs settings");
747 return isdbsSettings;
Frankie Lizcano01dca3d2022-06-29 18:22:02 +0000748 }
749 auto isdbs = feConfig.getFirstIsdbsFrontendSettings_optional();
750 isdbsSettings.streamId = (int32_t)isdbs->getStreamId();
751 isdbsSettings.symbolRate = (int32_t)isdbs->getSymbolRate();
752 isdbsSettings.modulation = static_cast<FrontendIsdbsModulation>(isdbs->getModulation());
753 isdbsSettings.coderate = static_cast<FrontendIsdbsCoderate>(isdbs->getCoderate());
754 isdbsSettings.rolloff = static_cast<FrontendIsdbsRolloff>(isdbs->getRolloff());
755 isdbsSettings.streamIdType =
756 static_cast<FrontendIsdbsStreamIdType>(isdbs->getStreamIdType());
757 return isdbsSettings;
Frankie Lizcano3ad735d2022-06-24 19:20:54 +0000758 }
759
Frankie Lizcanoaee8c9e2022-06-24 21:28:00 +0000760 static FrontendIsdbtSettings readIsdbtFrontendSettings(Frontend& feConfig) {
761 ALOGW("[ConfigReader] fe type is isdbt");
762 FrontendIsdbtSettings isdbtSettings{
763 .frequency = (int64_t)feConfig.getFrequency(),
764 };
765 if (feConfig.hasEndFrequency()) {
766 isdbtSettings.endFrequency = (int64_t)feConfig.getEndFrequency();
767 }
768 if (!feConfig.hasIsdbtFrontendSettings_optional()) {
769 ALOGW("[ConfigReader] no more isdbt settings");
770 return isdbtSettings;
771 }
772 auto isdbt = feConfig.getFirstIsdbtFrontendSettings_optional();
773 isdbtSettings.inversion = static_cast<FrontendSpectralInversion>(isdbt->getInversion());
774 isdbtSettings.bandwidth = static_cast<FrontendIsdbtBandwidth>(isdbt->getBandwidth());
775 isdbtSettings.mode = static_cast<FrontendIsdbtMode>(isdbt->getMode());
776 isdbtSettings.guardInterval =
777 static_cast<FrontendIsdbtGuardInterval>(isdbt->getGuardInterval());
778 isdbtSettings.serviceAreaId = (int32_t)isdbt->getServiceAreaId();
779 isdbtSettings.partialReceptionFlag =
780 static_cast<FrontendIsdbtPartialReceptionFlag>(isdbt->getPartialReceptionFlag());
781 if (!isdbt->hasFrontendIsdbtLayerSettings()) {
782 ALOGW("[ConfigReader] no isdbt layer settings");
783 return isdbtSettings;
784 }
785 auto layerSettings = isdbt->getFirstFrontendIsdbtLayerSettings();
786 ::aidl::android::hardware::tv::tuner::FrontendIsdbtLayerSettings mLayerSettings;
787 mLayerSettings.modulation =
788 static_cast<FrontendIsdbtModulation>(layerSettings->getModulation());
789 mLayerSettings.coderate = static_cast<FrontendIsdbtCoderate>(layerSettings->getCoderate());
790 mLayerSettings.timeInterleave =
791 static_cast<FrontendIsdbtTimeInterleaveMode>(layerSettings->getTimeInterleave());
792 mLayerSettings.numOfSegment = (int32_t)layerSettings->getNumOfSegment();
793 isdbtSettings.layerSettings.push_back(mLayerSettings);
794 return isdbtSettings;
795 }
796
Hongguang600a6ae2021-07-08 18:51:51 -0700797 static bool readFilterTypeAndSettings(Filter filterConfig, DemuxFilterType& type,
798 DemuxFilterSettings& settings) {
799 auto mainType = filterConfig.getMainType();
800 auto subType = filterConfig.getSubType();
801
802 switch (mainType) {
803 case FilterMainTypeEnum::TS: {
804 ALOGW("[ConfigReader] filter main type is ts");
805 type.mainType = DemuxFilterMainType::TS;
806 DemuxTsFilterSettings ts;
807 bool isTsSet = false;
808 switch (subType) {
809 case FilterSubTypeEnum::UNDEFINED:
Hongguangce1e30d2021-08-02 21:55:44 -0700810 type.subType.set<DemuxFilterSubType::Tag::tsFilterType>(
Hongguang600a6ae2021-07-08 18:51:51 -0700811 DemuxTsFilterType::UNDEFINED);
812 break;
813 case FilterSubTypeEnum::SECTION:
Hongguangce1e30d2021-08-02 21:55:44 -0700814 type.subType.set<DemuxFilterSubType::Tag::tsFilterType>(
Hongguang600a6ae2021-07-08 18:51:51 -0700815 DemuxTsFilterType::SECTION);
816 ts.filterSettings.set<DemuxTsFilterSettingsFilterSettings::Tag::section>(
817 readSectionFilterSettings(filterConfig));
818 isTsSet = true;
819 break;
820 case FilterSubTypeEnum::PES:
821 // TODO: b/182519645 support all the filter settings
Hongguangce1e30d2021-08-02 21:55:44 -0700822 type.subType.set<DemuxFilterSubType::Tag::tsFilterType>(
Hongguang600a6ae2021-07-08 18:51:51 -0700823 DemuxTsFilterType::PES);
824 break;
825 case FilterSubTypeEnum::TS:
Hongguangce1e30d2021-08-02 21:55:44 -0700826 type.subType.set<DemuxFilterSubType::Tag::tsFilterType>(
Hongguang600a6ae2021-07-08 18:51:51 -0700827 DemuxTsFilterType::TS);
828 ts.filterSettings.set<DemuxTsFilterSettingsFilterSettings::Tag::noinit>(
829 true);
830 isTsSet = true;
831 break;
832 case FilterSubTypeEnum::PCR:
Hongguangce1e30d2021-08-02 21:55:44 -0700833 type.subType.set<DemuxFilterSubType::Tag::tsFilterType>(
Hongguang600a6ae2021-07-08 18:51:51 -0700834 DemuxTsFilterType::PCR);
835 ts.filterSettings.set<DemuxTsFilterSettingsFilterSettings::Tag::noinit>(
836 true);
837 isTsSet = true;
838 break;
839 case FilterSubTypeEnum::TEMI:
Hongguangce1e30d2021-08-02 21:55:44 -0700840 type.subType.set<DemuxFilterSubType::Tag::tsFilterType>(
Hongguang600a6ae2021-07-08 18:51:51 -0700841 DemuxTsFilterType::TEMI);
842 ts.filterSettings.set<DemuxTsFilterSettingsFilterSettings::Tag::noinit>(
843 true);
844 isTsSet = true;
845 break;
846 case FilterSubTypeEnum::AUDIO:
Hongguangce1e30d2021-08-02 21:55:44 -0700847 type.subType.set<DemuxFilterSubType::Tag::tsFilterType>(
Hongguang600a6ae2021-07-08 18:51:51 -0700848 DemuxTsFilterType::AUDIO);
849 ts.filterSettings.set<DemuxTsFilterSettingsFilterSettings::Tag::av>(
850 readAvFilterSettings(filterConfig));
851 isTsSet = true;
852 break;
853 case FilterSubTypeEnum::VIDEO:
Hongguangce1e30d2021-08-02 21:55:44 -0700854 type.subType.set<DemuxFilterSubType::Tag::tsFilterType>(
Hongguang600a6ae2021-07-08 18:51:51 -0700855 DemuxTsFilterType::VIDEO);
856 ts.filterSettings.set<DemuxTsFilterSettingsFilterSettings::Tag::av>(
857 readAvFilterSettings(filterConfig));
858 isTsSet = true;
859 break;
860 case FilterSubTypeEnum::RECORD:
Hongguangce1e30d2021-08-02 21:55:44 -0700861 type.subType.set<DemuxFilterSubType::Tag::tsFilterType>(
Hongguang600a6ae2021-07-08 18:51:51 -0700862 DemuxTsFilterType::RECORD);
863 ts.filterSettings.set<DemuxTsFilterSettingsFilterSettings::Tag::record>(
864 readRecordFilterSettings(filterConfig));
865 isTsSet = true;
866 break;
867 default:
868 ALOGW("[ConfigReader] ts subtype is not supported");
869 return false;
870 }
871 if (filterConfig.hasPid()) {
872 ts.tpid = static_cast<int32_t>(filterConfig.getPid());
873 isTsSet = true;
874 }
875 if (isTsSet) {
876 settings.set<DemuxFilterSettings::Tag::ts>(ts);
877 }
878 break;
879 }
880 case FilterMainTypeEnum::MMTP: {
881 ALOGW("[ConfigReader] filter main type is mmtp");
882 type.mainType = DemuxFilterMainType::MMTP;
883 DemuxMmtpFilterSettings mmtp;
884 bool isMmtpSet = false;
885 switch (subType) {
886 case FilterSubTypeEnum::UNDEFINED:
Hongguangce1e30d2021-08-02 21:55:44 -0700887 type.subType.set<DemuxFilterSubType::Tag::mmtpFilterType>(
Hongguang600a6ae2021-07-08 18:51:51 -0700888 DemuxMmtpFilterType::UNDEFINED);
889 break;
890 case FilterSubTypeEnum::SECTION:
Hongguangce1e30d2021-08-02 21:55:44 -0700891 type.subType.set<DemuxFilterSubType::Tag::mmtpFilterType>(
Hongguang600a6ae2021-07-08 18:51:51 -0700892 DemuxMmtpFilterType::SECTION);
893 mmtp.filterSettings
894 .set<DemuxMmtpFilterSettingsFilterSettings::Tag::section>(
895 readSectionFilterSettings(filterConfig));
896 isMmtpSet = true;
897 break;
898 case FilterSubTypeEnum::PES:
Hongguangce1e30d2021-08-02 21:55:44 -0700899 type.subType.set<DemuxFilterSubType::Tag::mmtpFilterType>(
Hongguang600a6ae2021-07-08 18:51:51 -0700900 DemuxMmtpFilterType::PES);
901 // TODO: b/182519645 support all the filter settings
902 break;
903 case FilterSubTypeEnum::MMTP:
Hongguangce1e30d2021-08-02 21:55:44 -0700904 type.subType.set<DemuxFilterSubType::Tag::mmtpFilterType>(
Hongguang600a6ae2021-07-08 18:51:51 -0700905 DemuxMmtpFilterType::MMTP);
906 mmtp.filterSettings.set<DemuxMmtpFilterSettingsFilterSettings::Tag::noinit>(
907 true);
908 isMmtpSet = true;
909 break;
910 case FilterSubTypeEnum::AUDIO:
Hongguangce1e30d2021-08-02 21:55:44 -0700911 type.subType.set<DemuxFilterSubType::Tag::mmtpFilterType>(
Hongguang600a6ae2021-07-08 18:51:51 -0700912 DemuxMmtpFilterType::AUDIO);
913 mmtp.filterSettings.set<DemuxMmtpFilterSettingsFilterSettings::Tag::av>(
914 readAvFilterSettings(filterConfig));
915 isMmtpSet = true;
916 break;
917 case FilterSubTypeEnum::VIDEO:
Hongguangce1e30d2021-08-02 21:55:44 -0700918 type.subType.set<DemuxFilterSubType::Tag::mmtpFilterType>(
Hongguang600a6ae2021-07-08 18:51:51 -0700919 DemuxMmtpFilterType::VIDEO);
920 mmtp.filterSettings.set<DemuxMmtpFilterSettingsFilterSettings::Tag::av>(
921 readAvFilterSettings(filterConfig));
922 isMmtpSet = true;
923 break;
924 case FilterSubTypeEnum::RECORD:
Hongguangce1e30d2021-08-02 21:55:44 -0700925 type.subType.set<DemuxFilterSubType::Tag::mmtpFilterType>(
Hongguang600a6ae2021-07-08 18:51:51 -0700926 DemuxMmtpFilterType::RECORD);
927 mmtp.filterSettings.set<DemuxMmtpFilterSettingsFilterSettings::Tag::record>(
928 readRecordFilterSettings(filterConfig));
929 isMmtpSet = true;
930 break;
931 case FilterSubTypeEnum::DOWNLOAD:
Hongguangce1e30d2021-08-02 21:55:44 -0700932 type.subType.set<DemuxFilterSubType::Tag::mmtpFilterType>(
Hongguang600a6ae2021-07-08 18:51:51 -0700933 DemuxMmtpFilterType::DOWNLOAD);
934 // TODO: b/182519645 support all the filter settings
935 break;
936 default:
937 ALOGW("[ConfigReader] mmtp subtype is not supported");
938 return false;
939 }
940 if (filterConfig.hasPid()) {
941 mmtp.mmtpPid = static_cast<int32_t>(filterConfig.getPid());
942 isMmtpSet = true;
943 }
944 if (isMmtpSet) {
945 settings.set<DemuxFilterSettings::Tag::mmtp>(mmtp);
946 }
947 break;
948 }
949 case FilterMainTypeEnum::IP: {
950 ALOGW("[ConfigReader] filter main type is ip");
951 type.mainType = DemuxFilterMainType::IP;
952 DemuxIpFilterSettings ip;
953 switch (subType) {
954 case FilterSubTypeEnum::UNDEFINED:
Hongguangce1e30d2021-08-02 21:55:44 -0700955 type.subType.set<DemuxFilterSubType::Tag::ipFilterType>(
Hongguang600a6ae2021-07-08 18:51:51 -0700956 DemuxIpFilterType::UNDEFINED);
957 break;
958 case FilterSubTypeEnum::SECTION:
Hongguangce1e30d2021-08-02 21:55:44 -0700959 type.subType.set<DemuxFilterSubType::Tag::ipFilterType>(
Hongguang600a6ae2021-07-08 18:51:51 -0700960 DemuxIpFilterType::SECTION);
961 ip.filterSettings.set<DemuxIpFilterSettingsFilterSettings::Tag::section>(
962 readSectionFilterSettings(filterConfig));
963 settings.set<DemuxFilterSettings::Tag::ip>(ip);
964 break;
965 case FilterSubTypeEnum::NTP:
Hongguangce1e30d2021-08-02 21:55:44 -0700966 type.subType.set<DemuxFilterSubType::Tag::ipFilterType>(
Hongguang600a6ae2021-07-08 18:51:51 -0700967 DemuxIpFilterType::NTP);
968 ip.filterSettings.set<DemuxIpFilterSettingsFilterSettings::Tag::noinit>(
969 true);
970 settings.set<DemuxFilterSettings::Tag::ip>(ip);
971 break;
972 case FilterSubTypeEnum::IP: {
Gareth Fenn9a808452022-03-31 08:40:00 +0100973 type.subType.set<DemuxFilterSubType::Tag::ipFilterType>(
974 DemuxIpFilterType::IP);
Hongguang600a6ae2021-07-08 18:51:51 -0700975 ip.ipAddr = readIpAddress(filterConfig),
976 ip.filterSettings
977 .set<DemuxIpFilterSettingsFilterSettings::Tag::bPassthrough>(
978 readPassthroughSettings(filterConfig));
979 settings.set<DemuxFilterSettings::Tag::ip>(ip);
980 break;
981 }
982 case FilterSubTypeEnum::IP_PAYLOAD:
Hongguangce1e30d2021-08-02 21:55:44 -0700983 type.subType.set<DemuxFilterSubType::Tag::ipFilterType>(
Hongguang600a6ae2021-07-08 18:51:51 -0700984 DemuxIpFilterType::IP_PAYLOAD);
985 ip.filterSettings.set<DemuxIpFilterSettingsFilterSettings::Tag::noinit>(
986 true);
987 settings.set<DemuxFilterSettings::Tag::ip>(ip);
988 break;
989 case FilterSubTypeEnum::PAYLOAD_THROUGH:
Hongguangce1e30d2021-08-02 21:55:44 -0700990 type.subType.set<DemuxFilterSubType::Tag::ipFilterType>(
Hongguang600a6ae2021-07-08 18:51:51 -0700991 DemuxIpFilterType::PAYLOAD_THROUGH);
992 ip.filterSettings.set<DemuxIpFilterSettingsFilterSettings::Tag::noinit>(
993 true);
994 settings.set<DemuxFilterSettings::Tag::ip>(ip);
995 break;
996 default:
997 ALOGW("[ConfigReader] mmtp subtype is not supported");
998 return false;
999 }
1000 break;
1001 }
1002 default:
1003 // TODO: b/182519645 support all the filter configs
1004 ALOGW("[ConfigReader] filter main type is not supported in dynamic config");
1005 return false;
1006 }
1007 return true;
1008 }
1009
1010 static DemuxIpAddress readIpAddress(Filter filterConfig) {
1011 DemuxIpAddress ipAddress;
1012 vector<uint8_t> data;
1013 if (!filterConfig.hasIpFilterConfig_optional()) {
1014 return ipAddress;
1015 }
1016 auto ipFilterConfig = filterConfig.getFirstIpFilterConfig_optional();
1017 if (ipFilterConfig->hasSrcPort()) {
1018 ipAddress.srcPort = ipFilterConfig->getSrcPort();
1019 }
1020 if (ipFilterConfig->hasDestPort()) {
1021 ipAddress.dstPort = ipFilterConfig->getDestPort();
1022 }
1023 if (ipFilterConfig->getFirstSrcIpAddress()->getIsIpV4()) {
1024 data.resize(4);
1025 memcpy(data.data(), ipFilterConfig->getFirstSrcIpAddress()->getIp().data(), 4);
1026 ipAddress.srcIpAddress.set<DemuxIpAddressIpAddress::Tag::v4>(data);
1027 } else {
1028 data.resize(6);
1029 memcpy(data.data(), ipFilterConfig->getFirstSrcIpAddress()->getIp().data(), 6);
1030 ipAddress.srcIpAddress.set<DemuxIpAddressIpAddress::Tag::v6>(data);
1031 }
1032 if (ipFilterConfig->getFirstDestIpAddress()->getIsIpV4()) {
1033 data.resize(4);
1034 memcpy(data.data(), ipFilterConfig->getFirstDestIpAddress()->getIp().data(), 4);
1035 ipAddress.dstIpAddress.set<DemuxIpAddressIpAddress::Tag::v4>(data);
1036 } else {
1037 data.resize(6);
1038 memcpy(data.data(), ipFilterConfig->getFirstDestIpAddress()->getIp().data(), 6);
1039 ipAddress.dstIpAddress.set<DemuxIpAddressIpAddress::Tag::v6>(data);
1040 }
1041 return ipAddress;
1042 }
1043
1044 static bool readPassthroughSettings(Filter filterConfig) {
1045 if (!filterConfig.hasIpFilterConfig_optional()) {
1046 return false;
1047 }
1048 auto ipFilterConfig = filterConfig.getFirstIpFilterConfig_optional();
1049 if (ipFilterConfig->hasDataPassthrough()) {
1050 return ipFilterConfig->getDataPassthrough();
1051 }
1052 return false;
1053 }
1054
1055 static DemuxFilterSectionSettings readSectionFilterSettings(Filter filterConfig) {
1056 DemuxFilterSectionSettings settings;
1057 if (!filterConfig.hasSectionFilterSettings_optional()) {
1058 return settings;
1059 }
1060 auto section = filterConfig.getFirstSectionFilterSettings_optional();
1061 settings.isCheckCrc = section->getIsCheckCrc();
1062 settings.isRepeat = section->getIsRepeat();
1063 settings.isRaw = section->getIsRaw();
Hongguang494ba662022-01-05 22:08:10 -08001064 settings.bitWidthOfLengthField = section->getBitWidthOfLengthField();
Hongguang600a6ae2021-07-08 18:51:51 -07001065 return settings;
1066 }
1067
1068 static DemuxFilterAvSettings readAvFilterSettings(Filter filterConfig) {
1069 DemuxFilterAvSettings settings;
1070 if (!filterConfig.hasAvFilterSettings_optional()) {
1071 return settings;
1072 }
1073 auto av = filterConfig.getFirstAvFilterSettings_optional();
1074 settings.isPassthrough = av->getIsPassthrough();
Hongguang16dacc12021-11-01 15:51:52 -07001075 settings.isSecureMemory = av->getIsSecureMemory();
Hongguang600a6ae2021-07-08 18:51:51 -07001076 return settings;
1077 }
1078
1079 static DemuxFilterRecordSettings readRecordFilterSettings(Filter filterConfig) {
1080 DemuxFilterRecordSettings settings;
1081 if (!filterConfig.hasRecordFilterSettings_optional()) {
1082 return settings;
1083 }
1084 auto record = filterConfig.getFirstRecordFilterSettings_optional();
1085 settings.tsIndexMask = record->getTsIndexMask();
1086 settings.scIndexType = static_cast<DemuxRecordScIndexType>(record->getScIndexType());
1087 return settings;
1088 }
1089
1090 static PlaybackSettings readPlaybackSettings(Dvr dvrConfig) {
1091 ALOGW("[ConfigReader] dvr type is playback");
1092 PlaybackSettings playbackSettings{
Hongguang11da2cb2021-08-05 19:05:12 -07001093 .statusMask = static_cast<int8_t>(dvrConfig.getStatusMask()),
1094 .lowThreshold = static_cast<int64_t>(dvrConfig.getLowThreshold()),
1095 .highThreshold = static_cast<int64_t>(dvrConfig.getHighThreshold()),
Hongguang600a6ae2021-07-08 18:51:51 -07001096 .dataFormat = static_cast<DataFormat>(dvrConfig.getDataFormat()),
Hongguang11da2cb2021-08-05 19:05:12 -07001097 .packetSize = static_cast<int64_t>(dvrConfig.getPacketSize()),
Hongguang600a6ae2021-07-08 18:51:51 -07001098 };
1099 return playbackSettings;
1100 }
1101
1102 static RecordSettings readRecordSettings(Dvr dvrConfig) {
1103 ALOGW("[ConfigReader] dvr type is record");
1104 RecordSettings recordSettings{
Hongguang11da2cb2021-08-05 19:05:12 -07001105 .statusMask = static_cast<int8_t>(dvrConfig.getStatusMask()),
1106 .lowThreshold = static_cast<int64_t>(dvrConfig.getLowThreshold()),
1107 .highThreshold = static_cast<int64_t>(dvrConfig.getHighThreshold()),
Hongguang600a6ae2021-07-08 18:51:51 -07001108 .dataFormat = static_cast<DataFormat>(dvrConfig.getDataFormat()),
Hongguang11da2cb2021-08-05 19:05:12 -07001109 .packetSize = static_cast<int64_t>(dvrConfig.getPacketSize()),
Hongguang600a6ae2021-07-08 18:51:51 -07001110 };
1111 return recordSettings;
1112 }
1113
Hongguange106f472022-01-11 12:09:22 -08001114 static void getCiCamInfo(Frontend feConfig, bool& canConnectToCiCam, int32_t& ciCamId,
1115 int32_t& removePid) {
Hongguang600a6ae2021-07-08 18:51:51 -07001116 if (!feConfig.hasConnectToCicamId()) {
1117 canConnectToCiCam = false;
1118 ciCamId = -1;
Hongguange106f472022-01-11 12:09:22 -08001119 removePid = -1;
Gareth Fenn53ae3832021-10-15 17:19:00 +01001120 return;
Hongguang600a6ae2021-07-08 18:51:51 -07001121 }
1122 canConnectToCiCam = true;
1123 ciCamId = static_cast<int32_t>(feConfig.getConnectToCicamId());
Hongguange106f472022-01-11 12:09:22 -08001124 removePid = static_cast<int32_t>(feConfig.getRemoveOutputPid());
Hongguang600a6ae2021-07-08 18:51:51 -07001125 }
1126};