1 /**
2  * Copyright 2021, The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #define LOG_TAG "TunerFilter"
18 
19 #include "TunerFilter.h"
20 
21 using ::aidl::android::media::tv::tuner::TunerFilterSectionCondition;
22 
23 using ::android::hardware::hidl_handle;
24 using ::android::hardware::tv::tuner::V1_0::DemuxAlpLengthType;
25 using ::android::hardware::tv::tuner::V1_0::DemuxFilterMainType;
26 using ::android::hardware::tv::tuner::V1_0::DemuxIpAddress;
27 using ::android::hardware::tv::tuner::V1_0::DemuxMmtpFilterType;
28 using ::android::hardware::tv::tuner::V1_0::DemuxMmtpPid;
29 using ::android::hardware::tv::tuner::V1_0::DemuxRecordScIndexType;
30 using ::android::hardware::tv::tuner::V1_0::DemuxStreamId;
31 using ::android::hardware::tv::tuner::V1_0::DemuxTsFilterType;
32 using ::android::hardware::tv::tuner::V1_0::Result;
33 using ::android::hardware::tv::tuner::V1_1::AudioStreamType;
34 using ::android::hardware::tv::tuner::V1_1::Constant;
35 using ::android::hardware::tv::tuner::V1_1::VideoStreamType;
36 
37 namespace android {
38 
39 using namespace std;
40 
TunerFilter(sp<IFilter> filter,int mainType,int subType)41 TunerFilter::TunerFilter(
42         sp<IFilter> filter, int mainType, int subType) {
43     mFilter = filter;
44     mFilter_1_1 = ::android::hardware::tv::tuner::V1_1::IFilter::castFrom(filter);
45     mMainType = mainType;
46     mSubType = subType;
47 }
48 
~TunerFilter()49 TunerFilter::~TunerFilter() {
50     mFilter = nullptr;
51     mFilter_1_1 = nullptr;
52 }
53 
getQueueDesc(AidlMQDesc * _aidl_return)54 Status TunerFilter::getQueueDesc(AidlMQDesc* _aidl_return) {
55     if (mFilter == NULL) {
56         ALOGE("IFilter is not initialized");
57         return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
58     }
59 
60     MQDesc filterMQDesc;
61     Result res;
62     mFilter->getQueueDesc([&](Result r, const MQDesc& desc) {
63         filterMQDesc = desc;
64         res = r;
65     });
66     if (res != Result::SUCCESS) {
67         return Status::fromServiceSpecificError(static_cast<int32_t>(res));
68     }
69 
70     AidlMQDesc aidlMQDesc;
71     unsafeHidlToAidlMQDescriptor<uint8_t, int8_t, SynchronizedReadWrite>(
72                 filterMQDesc,  &aidlMQDesc);
73     *_aidl_return = move(aidlMQDesc);
74     return Status::ok();
75 }
76 
getId(int32_t * _aidl_return)77 Status TunerFilter::getId(int32_t* _aidl_return) {
78     if (mFilter == nullptr) {
79         ALOGE("IFilter is not initialized");
80         return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
81     }
82 
83     Result res;
84     mFilter->getId([&](Result r, uint32_t filterId) {
85         res = r;
86         mId = filterId;
87     });
88     if (res != Result::SUCCESS) {
89         return Status::fromServiceSpecificError(static_cast<int32_t>(res));
90     }
91     *_aidl_return = mId;
92     return Status::ok();
93 }
94 
getId64Bit(int64_t * _aidl_return)95 Status TunerFilter::getId64Bit(int64_t* _aidl_return) {
96     if (mFilter_1_1 == nullptr) {
97         ALOGE("IFilter_1_1 is not initialized");
98         return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
99     }
100 
101     Result res;
102     mFilter_1_1->getId64Bit([&](Result r, uint64_t filterId) {
103         res = r;
104         mId64Bit = filterId;
105     });
106     if (res != Result::SUCCESS) {
107         return ::ndk::ScopedAStatus::fromServiceSpecificError(static_cast<int32_t>(res));
108     }
109     *_aidl_return = mId64Bit;
110     return Status::ok();
111 }
112 
configure(const TunerFilterConfiguration & config)113 Status TunerFilter::configure(const TunerFilterConfiguration& config) {
114     if (mFilter == nullptr) {
115         ALOGE("IFilter is not initialized");
116         return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
117     }
118 
119     DemuxFilterSettings settings;
120     switch (config.getTag()) {
121         case TunerFilterConfiguration::ts: {
122             getHidlTsSettings(config, settings);
123             break;
124         }
125         case TunerFilterConfiguration::mmtp: {
126             getHidlMmtpSettings(config, settings);
127             break;
128         }
129         case TunerFilterConfiguration::ip: {
130             getHidlIpSettings(config, settings);
131             break;
132         }
133         case TunerFilterConfiguration::tlv: {
134             getHidlTlvSettings(config, settings);
135             break;
136         }
137         case TunerFilterConfiguration::alp: {
138             getHidlAlpSettings(config, settings);
139             break;
140         }
141     }
142 
143     Result res = mFilter->configure(settings);
144     if (res != Result::SUCCESS) {
145         return Status::fromServiceSpecificError(static_cast<int32_t>(res));
146     }
147     return Status::ok();
148 }
149 
configureMonitorEvent(int monitorEventType)150 Status TunerFilter::configureMonitorEvent(int monitorEventType) {
151     if (mFilter_1_1 == nullptr) {
152         ALOGE("IFilter_1_1 is not initialized");
153         return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
154     }
155 
156     Result res = mFilter_1_1->configureMonitorEvent(monitorEventType);
157     if (res != Result::SUCCESS) {
158         return Status::fromServiceSpecificError(static_cast<int32_t>(res));
159     }
160     return Status::ok();
161 }
162 
configureIpFilterContextId(int cid)163 Status TunerFilter::configureIpFilterContextId(int cid) {
164     if (mFilter_1_1 == nullptr) {
165         ALOGE("IFilter_1_1 is not initialized");
166         return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
167     }
168 
169     Result res = mFilter_1_1->configureIpCid(cid);
170     if (res != Result::SUCCESS) {
171         return Status::fromServiceSpecificError(static_cast<int32_t>(res));
172     }
173     return Status::ok();
174 }
175 
configureAvStreamType(int avStreamType)176 Status TunerFilter::configureAvStreamType(int avStreamType) {
177     if (mFilter_1_1 == nullptr) {
178         ALOGE("IFilter_1_1 is not initialized");
179         return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
180     }
181 
182     AvStreamType type;
183     if (!getHidlAvStreamType(avStreamType, type)) {
184         return Status::fromServiceSpecificError(static_cast<int32_t>(Result::INVALID_STATE));
185     }
186 
187     Result res = mFilter_1_1->configureAvStreamType(type);
188     if (res != Result::SUCCESS) {
189         return Status::fromServiceSpecificError(static_cast<int32_t>(res));
190     }
191     return Status::ok();
192 }
193 
setDataSource(const shared_ptr<ITunerFilter> & filter)194 Status TunerFilter::setDataSource(const shared_ptr<ITunerFilter>& filter) {
195     if (mFilter == nullptr) {
196         ALOGE("IFilter is not initialized");
197         return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
198     }
199 
200     ITunerFilter* tunerFilter = filter.get();
201     sp<IFilter> hidlFilter = static_cast<TunerFilter*>(tunerFilter)->getHalFilter();
202     Result res = mFilter->setDataSource(hidlFilter);
203     if (res != Result::SUCCESS) {
204         return Status::fromServiceSpecificError(static_cast<int32_t>(res));
205     }
206     return Status::ok();
207 }
208 
getHidlTsSettings(const TunerFilterConfiguration & config,DemuxFilterSettings & settings)209 void TunerFilter::getHidlTsSettings(
210         const TunerFilterConfiguration& config, DemuxFilterSettings& settings) {
211     auto tsConf = config.get<TunerFilterConfiguration::ts>();
212     DemuxTsFilterSettings ts{
213         .tpid = static_cast<uint16_t>(tsConf.tpid),
214     };
215 
216     TunerFilterSettings tunerSettings = tsConf.filterSettings;
217     switch (tunerSettings.getTag()) {
218         case TunerFilterSettings::av: {
219             ts.filterSettings.av(getAvSettings(tunerSettings));
220             break;
221         }
222         case TunerFilterSettings::section: {
223             ts.filterSettings.section(getSectionSettings(tunerSettings));
224             break;
225         }
226         case TunerFilterSettings::pesData: {
227             ts.filterSettings.pesData(getPesDataSettings(tunerSettings));
228             break;
229         }
230         case TunerFilterSettings::record: {
231             ts.filterSettings.record(getRecordSettings(tunerSettings));
232             break;
233         }
234         default: {
235             ts.filterSettings.noinit();
236             break;
237         }
238     }
239     settings.ts(ts);
240 }
241 
getHidlMmtpSettings(const TunerFilterConfiguration & config,DemuxFilterSettings & settings)242 void TunerFilter::getHidlMmtpSettings(
243         const TunerFilterConfiguration& config, DemuxFilterSettings& settings) {
244     auto mmtpConf = config.get<TunerFilterConfiguration::mmtp>();
245     DemuxMmtpFilterSettings mmtp{
246         .mmtpPid = static_cast<DemuxMmtpPid>(mmtpConf.mmtpPid),
247     };
248 
249     TunerFilterSettings tunerSettings = mmtpConf.filterSettings;
250     switch (tunerSettings.getTag()) {
251         case TunerFilterSettings::av: {
252             mmtp.filterSettings.av(getAvSettings(tunerSettings));
253             break;
254         }
255         case TunerFilterSettings::section: {
256             mmtp.filterSettings.section(getSectionSettings(tunerSettings));
257             break;
258         }
259         case TunerFilterSettings::pesData: {
260             mmtp.filterSettings.pesData(getPesDataSettings(tunerSettings));
261             break;
262         }
263         case TunerFilterSettings::record: {
264             mmtp.filterSettings.record(getRecordSettings(tunerSettings));
265             break;
266         }
267         case TunerFilterSettings::download: {
268             mmtp.filterSettings.download(getDownloadSettings(tunerSettings));
269             break;
270         }
271         default: {
272             mmtp.filterSettings.noinit();
273             break;
274         }
275     }
276     settings.mmtp(mmtp);
277 }
278 
getHidlIpSettings(const TunerFilterConfiguration & config,DemuxFilterSettings & settings)279 void TunerFilter::getHidlIpSettings(
280         const TunerFilterConfiguration& config, DemuxFilterSettings& settings) {
281     auto ipConf = config.get<TunerFilterConfiguration::ip>();
282     DemuxIpAddress ipAddr{
283         .srcPort = static_cast<uint16_t>(ipConf.ipAddr.srcPort),
284         .dstPort = static_cast<uint16_t>(ipConf.ipAddr.dstPort),
285     };
286 
287     ipConf.ipAddr.srcIpAddress.isIpV6
288             ? ipAddr.srcIpAddress.v6(getIpV6Address(ipConf.ipAddr.srcIpAddress))
289             : ipAddr.srcIpAddress.v4(getIpV4Address(ipConf.ipAddr.srcIpAddress));
290     ipConf.ipAddr.dstIpAddress.isIpV6
291             ? ipAddr.dstIpAddress.v6(getIpV6Address(ipConf.ipAddr.dstIpAddress))
292             : ipAddr.dstIpAddress.v4(getIpV4Address(ipConf.ipAddr.dstIpAddress));
293     DemuxIpFilterSettings ip{
294         .ipAddr = ipAddr,
295     };
296 
297     TunerFilterSettings tunerSettings = ipConf.filterSettings;
298     switch (tunerSettings.getTag()) {
299         case TunerFilterSettings::section: {
300             ip.filterSettings.section(getSectionSettings(tunerSettings));
301             break;
302         }
303         case TunerFilterSettings::isPassthrough: {
304             ip.filterSettings.bPassthrough(tunerSettings.isPassthrough);
305             break;
306         }
307         default: {
308             ip.filterSettings.noinit();
309             break;
310         }
311     }
312     settings.ip(ip);
313 }
314 
getIpV6Address(TunerDemuxIpAddress addr)315 hidl_array<uint8_t, IP_V6_LENGTH> TunerFilter::getIpV6Address(TunerDemuxIpAddress addr) {
316     hidl_array<uint8_t, IP_V6_LENGTH> ip;
317     if (addr.addr.size() != IP_V6_LENGTH) {
318         return ip;
319     }
320     copy(addr.addr.begin(), addr.addr.end(), ip.data());
321     return ip;
322 }
323 
getIpV4Address(TunerDemuxIpAddress addr)324 hidl_array<uint8_t, IP_V4_LENGTH> TunerFilter::getIpV4Address(TunerDemuxIpAddress addr) {
325     hidl_array<uint8_t, IP_V4_LENGTH> ip;
326     if (addr.addr.size() != IP_V4_LENGTH) {
327         return ip;
328     }
329     copy(addr.addr.begin(), addr.addr.end(), ip.data());
330     return ip;
331 }
332 
getHidlTlvSettings(const TunerFilterConfiguration & config,DemuxFilterSettings & settings)333 void TunerFilter::getHidlTlvSettings(
334         const TunerFilterConfiguration& config, DemuxFilterSettings& settings) {
335     auto tlvConf = config.get<TunerFilterConfiguration::tlv>();
336     DemuxTlvFilterSettings tlv{
337         .packetType = static_cast<uint8_t>(tlvConf.packetType),
338         .isCompressedIpPacket = tlvConf.isCompressedIpPacket,
339     };
340 
341     TunerFilterSettings tunerSettings = tlvConf.filterSettings;
342     switch (tunerSettings.getTag()) {
343         case TunerFilterSettings::section: {
344             tlv.filterSettings.section(getSectionSettings(tunerSettings));
345             break;
346         }
347         case TunerFilterSettings::isPassthrough: {
348             tlv.filterSettings.bPassthrough(tunerSettings.isPassthrough);
349             break;
350         }
351         default: {
352             tlv.filterSettings.noinit();
353             break;
354         }
355     }
356     settings.tlv(tlv);
357 }
358 
getHidlAlpSettings(const TunerFilterConfiguration & config,DemuxFilterSettings & settings)359 void TunerFilter::getHidlAlpSettings(
360         const TunerFilterConfiguration& config, DemuxFilterSettings& settings) {
361     auto alpConf = config.get<TunerFilterConfiguration::alp>();
362     DemuxAlpFilterSettings alp{
363         .packetType = static_cast<uint8_t>(alpConf.packetType),
364         .lengthType = static_cast<DemuxAlpLengthType>(alpConf.lengthType),
365     };
366 
367     TunerFilterSettings tunerSettings = alpConf.filterSettings;
368     switch (tunerSettings.getTag()) {
369         case TunerFilterSettings::section: {
370             alp.filterSettings.section(getSectionSettings(tunerSettings));
371             break;
372         }
373         default: {
374             alp.filterSettings.noinit();
375             break;
376         }
377     }
378     settings.alp(alp);
379 }
380 
getAvSettings(const TunerFilterSettings & settings)381 DemuxFilterAvSettings TunerFilter::getAvSettings(const TunerFilterSettings& settings) {
382     DemuxFilterAvSettings av {
383         .isPassthrough = settings.get<TunerFilterSettings::av>().isPassthrough,
384     };
385     return av;
386 }
387 
getSectionSettings(const TunerFilterSettings & settings)388 DemuxFilterSectionSettings TunerFilter::getSectionSettings(const TunerFilterSettings& settings) {
389     auto s = settings.get<TunerFilterSettings::section>();
390     DemuxFilterSectionSettings section{
391         .isCheckCrc = s.isCheckCrc,
392         .isRepeat = s.isRepeat,
393         .isRaw = s.isRaw,
394     };
395 
396     switch (s.condition.getTag()) {
397         case TunerFilterSectionCondition::sectionBits: {
398             auto sectionBits = s.condition.get<TunerFilterSectionCondition::sectionBits>();
399             vector<uint8_t> filter(sectionBits.filter.begin(), sectionBits.filter.end());
400             vector<uint8_t> mask(sectionBits.mask.begin(), sectionBits.mask.end());
401             vector<uint8_t> mode(sectionBits.mode.begin(), sectionBits.mode.end());
402             section.condition.sectionBits({
403                 .filter = filter,
404                 .mask = mask,
405                 .mode = mode,
406             });
407             break;
408         }
409         case TunerFilterSectionCondition::tableInfo: {
410             auto tableInfo = s.condition.get<TunerFilterSectionCondition::tableInfo>();
411             section.condition.tableInfo({
412                 .tableId = static_cast<uint16_t>(tableInfo.tableId),
413                 .version = static_cast<uint16_t>(tableInfo.version),
414             });
415             break;
416         }
417         default: {
418             break;
419         }
420     }
421     return section;
422 }
423 
getPesDataSettings(const TunerFilterSettings & settings)424 DemuxFilterPesDataSettings TunerFilter::getPesDataSettings(const TunerFilterSettings& settings) {
425     DemuxFilterPesDataSettings pes{
426         .streamId = static_cast<DemuxStreamId>(
427                 settings.get<TunerFilterSettings::pesData>().streamId),
428         .isRaw = settings.get<TunerFilterSettings::pesData>().isRaw,
429     };
430     return pes;
431 }
432 
getRecordSettings(const TunerFilterSettings & settings)433 DemuxFilterRecordSettings TunerFilter::getRecordSettings(const TunerFilterSettings& settings) {
434     auto r = settings.get<TunerFilterSettings::record>();
435     DemuxFilterRecordSettings record{
436         .tsIndexMask = static_cast<uint32_t>(r.tsIndexMask),
437         .scIndexType = static_cast<DemuxRecordScIndexType>(r.scIndexType),
438     };
439 
440     switch (r.scIndexMask.getTag()) {
441         case TunerFilterScIndexMask::sc: {
442             record.scIndexMask.sc(static_cast<uint32_t>(
443                     r.scIndexMask.get<TunerFilterScIndexMask::sc>()));
444             break;
445         }
446         case TunerFilterScIndexMask::scHevc: {
447             record.scIndexMask.scHevc(static_cast<uint32_t>(
448                     r.scIndexMask.get<TunerFilterScIndexMask::scHevc>()));
449             break;
450         }
451     }
452     return record;
453 }
454 
getDownloadSettings(const TunerFilterSettings & settings)455 DemuxFilterDownloadSettings TunerFilter::getDownloadSettings(const TunerFilterSettings& settings) {
456     DemuxFilterDownloadSettings download {
457         .downloadId = static_cast<uint32_t>(
458                 settings.get<TunerFilterSettings::download>().downloadId),
459     };
460     return download;
461 }
462 
getAvSharedHandleInfo(TunerFilterSharedHandleInfo * _aidl_return)463 Status TunerFilter::getAvSharedHandleInfo(TunerFilterSharedHandleInfo* _aidl_return) {
464     if (mFilter_1_1 == nullptr) {
465         ALOGE("IFilter_1_1 is not initialized");
466         return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
467     }
468 
469     Result res;
470     mFilter_1_1->getAvSharedHandle([&](Result r, hidl_handle avMemory, uint64_t avMemSize) {
471         res = r;
472         if (res == Result::SUCCESS) {
473             TunerFilterSharedHandleInfo info{
474                 .handle = dupToAidl(avMemory),
475                 .size = static_cast<int64_t>(avMemSize),
476             };
477             *_aidl_return = move(info);
478         } else {
479             _aidl_return = NULL;
480         }
481     });
482 
483     if (res != Result::SUCCESS) {
484         return Status::fromServiceSpecificError(static_cast<int32_t>(res));
485     }
486     return Status::ok();
487 }
488 
releaseAvHandle(const::aidl::android::hardware::common::NativeHandle & handle,int64_t avDataId)489 Status TunerFilter::releaseAvHandle(
490         const ::aidl::android::hardware::common::NativeHandle& handle, int64_t avDataId) {
491     if (mFilter == nullptr) {
492         ALOGE("IFilter is not initialized");
493         return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
494     }
495 
496     Result res = mFilter->releaseAvHandle(hidl_handle(makeFromAidl(handle)), avDataId);
497     if (res != Result::SUCCESS) {
498         return Status::fromServiceSpecificError(static_cast<int32_t>(res));
499     }
500     return Status::ok();
501 }
502 
start()503 Status TunerFilter::start() {
504     if (mFilter == nullptr) {
505         ALOGE("IFilter is not initialized");
506         return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
507     }
508     Result res = mFilter->start();
509     if (res != Result::SUCCESS) {
510         return Status::fromServiceSpecificError(static_cast<int32_t>(res));
511     }
512     return Status::ok();
513 }
514 
stop()515 Status TunerFilter::stop() {
516     if (mFilter == nullptr) {
517         ALOGE("IFilter is not initialized");
518         return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
519     }
520     Result res = mFilter->stop();
521     if (res != Result::SUCCESS) {
522         return Status::fromServiceSpecificError(static_cast<int32_t>(res));
523     }
524     return Status::ok();
525 }
526 
flush()527 Status TunerFilter::flush() {
528     if (mFilter == nullptr) {
529         ALOGE("IFilter is not initialized");
530         return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
531     }
532     Result res = mFilter->flush();
533     if (res != Result::SUCCESS) {
534         return Status::fromServiceSpecificError(static_cast<int32_t>(res));
535     }
536     return Status::ok();
537 }
538 
close()539 Status TunerFilter::close() {
540     if (mFilter == nullptr) {
541         ALOGE("IFilter is not initialized");
542         return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
543     }
544     Result res = mFilter->close();
545     mFilter = NULL;
546     mFilter_1_1 = NULL;
547 
548     if (res != Result::SUCCESS) {
549         return Status::fromServiceSpecificError(static_cast<int32_t>(res));
550     }
551     return Status::ok();
552 }
553 
getHalFilter()554 sp<IFilter> TunerFilter::getHalFilter() {
555     return mFilter;
556 }
557 
isAudioFilter()558 bool TunerFilter::isAudioFilter() {
559     return (mMainType == (int)DemuxFilterMainType::TS
560                     && mSubType == (int)DemuxTsFilterType::AUDIO)
561             || (mMainType == (int)DemuxFilterMainType::MMTP
562                     && mSubType == (int)DemuxMmtpFilterType::AUDIO);
563 }
564 
isVideoFilter()565 bool TunerFilter::isVideoFilter() {
566     return (mMainType == (int)DemuxFilterMainType::TS
567                     && mSubType == (int)DemuxTsFilterType::VIDEO)
568             || (mMainType == (int)DemuxFilterMainType::MMTP
569                     && mSubType == (int)DemuxMmtpFilterType::VIDEO);
570 }
571 
getHidlAvStreamType(int avStreamType,AvStreamType & type)572 bool TunerFilter::getHidlAvStreamType(int avStreamType, AvStreamType& type) {
573     if (isAudioFilter()) {
574         type.audio(static_cast<AudioStreamType>(avStreamType));
575         return true;
576     }
577 
578     if (isVideoFilter()) {
579         type.video(static_cast<VideoStreamType>(avStreamType));
580         return true;
581     }
582 
583     return false;
584 }
585 
586 /////////////// FilterCallback ///////////////////////
587 
onFilterStatus(DemuxFilterStatus status)588 Return<void> TunerFilter::FilterCallback::onFilterStatus(DemuxFilterStatus status) {
589     if (mTunerFilterCallback != NULL) {
590         mTunerFilterCallback->onFilterStatus((int)status);
591     }
592     return Void();
593 }
594 
onFilterEvent(const DemuxFilterEvent & filterEvent)595 Return<void> TunerFilter::FilterCallback::onFilterEvent(const DemuxFilterEvent& filterEvent) {
596     vector<DemuxFilterEventExt::Event> emptyEventsExt;
597     DemuxFilterEventExt emptyFilterEventExt {
598             .events = emptyEventsExt,
599     };
600     onFilterEvent_1_1(filterEvent, emptyFilterEventExt);
601     return Void();
602 }
603 
onFilterEvent_1_1(const DemuxFilterEvent & filterEvent,const DemuxFilterEventExt & filterEventExt)604 Return<void> TunerFilter::FilterCallback::onFilterEvent_1_1(const DemuxFilterEvent& filterEvent,
605         const DemuxFilterEventExt& filterEventExt) {
606     if (mTunerFilterCallback != NULL) {
607         vector<DemuxFilterEvent::Event> events = filterEvent.events;
608         vector<DemuxFilterEventExt::Event> eventsExt = filterEventExt.events;
609         vector<TunerFilterEvent> tunerEvent;
610 
611         getAidlFilterEvent(events, eventsExt, tunerEvent);
612         mTunerFilterCallback->onFilterEvent(tunerEvent);
613     }
614     return Void();
615 }
616 
617 /////////////// FilterCallback Helper Methods ///////////////////////
618 
getAidlFilterEvent(vector<DemuxFilterEvent::Event> & events,vector<DemuxFilterEventExt::Event> & eventsExt,vector<TunerFilterEvent> & tunerEvent)619 void TunerFilter::FilterCallback::getAidlFilterEvent(vector<DemuxFilterEvent::Event>& events,
620         vector<DemuxFilterEventExt::Event>& eventsExt,
621         vector<TunerFilterEvent>& tunerEvent) {
622     if (events.empty() && !eventsExt.empty()) {
623         auto eventExt = eventsExt[0];
624         switch (eventExt.getDiscriminator()) {
625             case DemuxFilterEventExt::Event::hidl_discriminator::monitorEvent: {
626                 getMonitorEvent(eventsExt, tunerEvent);
627                 return;
628             }
629             case DemuxFilterEventExt::Event::hidl_discriminator::startId: {
630                 getRestartEvent(eventsExt, tunerEvent);
631                 return;
632             }
633             default: {
634                 break;
635             }
636         }
637         return;
638     }
639 
640     if (!events.empty()) {
641         auto event = events[0];
642         switch (event.getDiscriminator()) {
643             case DemuxFilterEvent::Event::hidl_discriminator::media: {
644                 getMediaEvent(events, tunerEvent);
645                 break;
646             }
647             case DemuxFilterEvent::Event::hidl_discriminator::section: {
648                 getSectionEvent(events, tunerEvent);
649                 break;
650             }
651             case DemuxFilterEvent::Event::hidl_discriminator::pes: {
652                 getPesEvent(events, tunerEvent);
653                 break;
654             }
655             case DemuxFilterEvent::Event::hidl_discriminator::tsRecord: {
656                 getTsRecordEvent(events, eventsExt, tunerEvent);
657                 break;
658             }
659             case DemuxFilterEvent::Event::hidl_discriminator::mmtpRecord: {
660                 getMmtpRecordEvent(events, eventsExt, tunerEvent);
661                 break;
662             }
663             case DemuxFilterEvent::Event::hidl_discriminator::download: {
664                 getDownloadEvent(events, tunerEvent);
665                 break;
666             }
667             case DemuxFilterEvent::Event::hidl_discriminator::ipPayload: {
668                 getIpPayloadEvent(events, tunerEvent);
669                 break;
670             }
671             case DemuxFilterEvent::Event::hidl_discriminator::temi: {
672                 getTemiEvent(events, tunerEvent);
673                 break;
674             }
675             default: {
676                 break;
677             }
678         }
679     }
680 }
681 
getMediaEvent(vector<DemuxFilterEvent::Event> & events,vector<TunerFilterEvent> & res)682 void TunerFilter::FilterCallback::getMediaEvent(
683         vector<DemuxFilterEvent::Event>& events, vector<TunerFilterEvent>& res) {
684     for (DemuxFilterEvent::Event e : events) {
685         DemuxFilterMediaEvent mediaEvent = e.media();
686         TunerFilterMediaEvent tunerMedia;
687 
688         tunerMedia.streamId = static_cast<char16_t>(mediaEvent.streamId);
689         tunerMedia.isPtsPresent = mediaEvent.isPtsPresent;
690         tunerMedia.pts = static_cast<long>(mediaEvent.pts);
691         tunerMedia.dataLength = static_cast<int>(mediaEvent.dataLength);
692         tunerMedia.offset = static_cast<int>(mediaEvent.offset);
693         tunerMedia.isSecureMemory = mediaEvent.isSecureMemory;
694         tunerMedia.avDataId = static_cast<long>(mediaEvent.avDataId);
695         tunerMedia.mpuSequenceNumber = static_cast<int>(mediaEvent.mpuSequenceNumber);
696         tunerMedia.isPesPrivateData = mediaEvent.isPesPrivateData;
697 
698         if (mediaEvent.extraMetaData.getDiscriminator() ==
699                 DemuxFilterMediaEvent::ExtraMetaData::hidl_discriminator::audio) {
700             tunerMedia.isAudioExtraMetaData = true;
701             tunerMedia.audio = {
702                 .adFade = static_cast<int8_t>(
703                         mediaEvent.extraMetaData.audio().adFade),
704                 .adPan = static_cast<int8_t>(
705                         mediaEvent.extraMetaData.audio().adPan),
706                 .versionTextTag = static_cast<int8_t>(
707                         mediaEvent.extraMetaData.audio().versionTextTag),
708                 .adGainCenter = static_cast<int8_t>(
709                         mediaEvent.extraMetaData.audio().adGainCenter),
710                 .adGainFront = static_cast<int8_t>(
711                         mediaEvent.extraMetaData.audio().adGainFront),
712                 .adGainSurround = static_cast<int8_t>(
713                         mediaEvent.extraMetaData.audio().adGainSurround),
714             };
715         } else {
716             tunerMedia.isAudioExtraMetaData = false;
717         }
718 
719         if (mediaEvent.avMemory.getNativeHandle() != nullptr) {
720             tunerMedia.avMemory = dupToAidl(mediaEvent.avMemory.getNativeHandle());
721         }
722 
723         TunerFilterEvent tunerEvent;
724         tunerEvent.set<TunerFilterEvent::media>(move(tunerMedia));
725         res.push_back(move(tunerEvent));
726     }
727 }
728 
getSectionEvent(vector<DemuxFilterEvent::Event> & events,vector<TunerFilterEvent> & res)729 void TunerFilter::FilterCallback::getSectionEvent(
730         vector<DemuxFilterEvent::Event>& events, vector<TunerFilterEvent>& res) {
731     for (DemuxFilterEvent::Event e : events) {
732         DemuxFilterSectionEvent sectionEvent = e.section();
733         TunerFilterSectionEvent tunerSection;
734 
735         tunerSection.tableId = static_cast<char16_t>(sectionEvent.tableId);
736         tunerSection.version = static_cast<char16_t>(sectionEvent.version);
737         tunerSection.sectionNum = static_cast<char16_t>(sectionEvent.sectionNum);
738         tunerSection.dataLength = static_cast<char16_t>(sectionEvent.dataLength);
739 
740         TunerFilterEvent tunerEvent;
741         tunerEvent.set<TunerFilterEvent::section>(move(tunerSection));
742         res.push_back(move(tunerEvent));
743     }
744 }
745 
getPesEvent(vector<DemuxFilterEvent::Event> & events,vector<TunerFilterEvent> & res)746 void TunerFilter::FilterCallback::getPesEvent(
747         vector<DemuxFilterEvent::Event>& events, vector<TunerFilterEvent>& res) {
748     for (DemuxFilterEvent::Event e : events) {
749         DemuxFilterPesEvent pesEvent = e.pes();
750         TunerFilterPesEvent tunerPes;
751 
752         tunerPes.streamId = static_cast<char16_t>(pesEvent.streamId);
753         tunerPes.dataLength = static_cast<char16_t>(pesEvent.dataLength);
754         tunerPes.mpuSequenceNumber = static_cast<int>(pesEvent.mpuSequenceNumber);
755 
756         TunerFilterEvent tunerEvent;
757         tunerEvent.set<TunerFilterEvent::pes>(move(tunerPes));
758         res.push_back(move(tunerEvent));
759     }
760 }
761 
getTsRecordEvent(vector<DemuxFilterEvent::Event> & events,vector<DemuxFilterEventExt::Event> & eventsExt,vector<TunerFilterEvent> & res)762 void TunerFilter::FilterCallback::getTsRecordEvent(vector<DemuxFilterEvent::Event>& events,
763         vector<DemuxFilterEventExt::Event>& eventsExt, vector<TunerFilterEvent>& res) {
764     for (int i = 0; i < events.size(); i++) {
765         TunerFilterTsRecordEvent tunerTsRecord;
766         DemuxFilterTsRecordEvent tsRecordEvent = events[i].tsRecord();
767 
768         TunerFilterScIndexMask scIndexMask;
769         if (tsRecordEvent.scIndexMask.getDiscriminator()
770                 == DemuxFilterTsRecordEvent::ScIndexMask::hidl_discriminator::sc) {
771             scIndexMask.set<TunerFilterScIndexMask::sc>(
772                     static_cast<int>(tsRecordEvent.scIndexMask.sc()));
773         } else if (tsRecordEvent.scIndexMask.getDiscriminator()
774                 == DemuxFilterTsRecordEvent::ScIndexMask::hidl_discriminator::scHevc) {
775             scIndexMask.set<TunerFilterScIndexMask::scHevc>(
776                     static_cast<int>(tsRecordEvent.scIndexMask.scHevc()));
777         }
778 
779         if (tsRecordEvent.pid.getDiscriminator() == DemuxPid::hidl_discriminator::tPid) {
780             tunerTsRecord.pid = static_cast<char16_t>(tsRecordEvent.pid.tPid());
781         } else {
782             tunerTsRecord.pid = static_cast<char16_t>(Constant::INVALID_TS_PID);
783         }
784 
785         tunerTsRecord.scIndexMask = scIndexMask;
786         tunerTsRecord.tsIndexMask = static_cast<int>(tsRecordEvent.tsIndexMask);
787         tunerTsRecord.byteNumber = static_cast<long>(tsRecordEvent.byteNumber);
788 
789         if (eventsExt.size() > i && eventsExt[i].getDiscriminator() ==
790                     DemuxFilterEventExt::Event::hidl_discriminator::tsRecord) {
791             tunerTsRecord.isExtended = true;
792             tunerTsRecord.pts = static_cast<long>(eventsExt[i].tsRecord().pts);
793             tunerTsRecord.firstMbInSlice = static_cast<int>(eventsExt[i].tsRecord().firstMbInSlice);
794         } else {
795             tunerTsRecord.isExtended = false;
796         }
797 
798         TunerFilterEvent tunerEvent;
799         tunerEvent.set<TunerFilterEvent::tsRecord>(move(tunerTsRecord));
800         res.push_back(move(tunerEvent));
801     }
802 }
803 
getMmtpRecordEvent(vector<DemuxFilterEvent::Event> & events,vector<DemuxFilterEventExt::Event> & eventsExt,vector<TunerFilterEvent> & res)804 void TunerFilter::FilterCallback::getMmtpRecordEvent(vector<DemuxFilterEvent::Event>& events,
805         vector<DemuxFilterEventExt::Event>& eventsExt, vector<TunerFilterEvent>& res) {
806     for (int i = 0; i < events.size(); i++) {
807         TunerFilterMmtpRecordEvent tunerMmtpRecord;
808         DemuxFilterMmtpRecordEvent mmtpRecordEvent = events[i].mmtpRecord();
809 
810         tunerMmtpRecord.scHevcIndexMask = static_cast<int>(mmtpRecordEvent.scHevcIndexMask);
811         tunerMmtpRecord.byteNumber = static_cast<long>(mmtpRecordEvent.byteNumber);
812 
813         if (eventsExt.size() > i && eventsExt[i].getDiscriminator() ==
814                     DemuxFilterEventExt::Event::hidl_discriminator::mmtpRecord) {
815             tunerMmtpRecord.isExtended = true;
816             tunerMmtpRecord.pts = static_cast<long>(eventsExt[i].mmtpRecord().pts);
817             tunerMmtpRecord.mpuSequenceNumber =
818                     static_cast<int>(eventsExt[i].mmtpRecord().mpuSequenceNumber);
819             tunerMmtpRecord.firstMbInSlice =
820                     static_cast<int>(eventsExt[i].mmtpRecord().firstMbInSlice);
821             tunerMmtpRecord.tsIndexMask = static_cast<int>(eventsExt[i].mmtpRecord().tsIndexMask);
822         } else {
823             tunerMmtpRecord.isExtended = false;
824         }
825 
826         TunerFilterEvent tunerEvent;
827         tunerEvent.set<TunerFilterEvent::mmtpRecord>(move(tunerMmtpRecord));
828         res.push_back(move(tunerEvent));
829     }
830 }
831 
getDownloadEvent(vector<DemuxFilterEvent::Event> & events,vector<TunerFilterEvent> & res)832 void TunerFilter::FilterCallback::getDownloadEvent(
833         vector<DemuxFilterEvent::Event>& events, vector<TunerFilterEvent>& res) {
834     for (DemuxFilterEvent::Event e : events) {
835         DemuxFilterDownloadEvent downloadEvent = e.download();
836         TunerFilterDownloadEvent tunerDownload;
837 
838         tunerDownload.itemId = static_cast<int>(downloadEvent.itemId);
839         tunerDownload.itemFragmentIndex = static_cast<int>(downloadEvent.itemFragmentIndex);
840         tunerDownload.mpuSequenceNumber = static_cast<int>(downloadEvent.mpuSequenceNumber);
841         tunerDownload.lastItemFragmentIndex = static_cast<int>(downloadEvent.lastItemFragmentIndex);
842         tunerDownload.dataLength = static_cast<char16_t>(downloadEvent.dataLength);
843 
844         TunerFilterEvent tunerEvent;
845         tunerEvent.set<TunerFilterEvent::download>(move(tunerDownload));
846         res.push_back(move(tunerEvent));
847     }
848 }
849 
getIpPayloadEvent(vector<DemuxFilterEvent::Event> & events,vector<TunerFilterEvent> & res)850 void TunerFilter::FilterCallback::getIpPayloadEvent(
851         vector<DemuxFilterEvent::Event>& events, vector<TunerFilterEvent>& res) {
852     for (DemuxFilterEvent::Event e : events) {
853         DemuxFilterIpPayloadEvent ipPayloadEvent = e.ipPayload();
854         TunerFilterIpPayloadEvent tunerIpPayload;
855 
856         tunerIpPayload.dataLength = static_cast<char16_t>(ipPayloadEvent.dataLength);
857 
858         TunerFilterEvent tunerEvent;
859         tunerEvent.set<TunerFilterEvent::ipPayload>(move(tunerIpPayload));
860         res.push_back(move(tunerEvent));
861     }
862 }
863 
getTemiEvent(vector<DemuxFilterEvent::Event> & events,vector<TunerFilterEvent> & res)864 void TunerFilter::FilterCallback::getTemiEvent(
865         vector<DemuxFilterEvent::Event>& events, vector<TunerFilterEvent>& res) {
866     for (DemuxFilterEvent::Event e : events) {
867         DemuxFilterTemiEvent temiEvent = e.temi();
868         TunerFilterTemiEvent tunerTemi;
869 
870         tunerTemi.pts = static_cast<long>(temiEvent.pts);
871         tunerTemi.descrTag = static_cast<int8_t>(temiEvent.descrTag);
872         vector<uint8_t> descrData = temiEvent.descrData;
873         tunerTemi.descrData.resize(descrData.size());
874         copy(descrData.begin(), descrData.end(), tunerTemi.descrData.begin());
875 
876         TunerFilterEvent tunerEvent;
877         tunerEvent.set<TunerFilterEvent::temi>(move(tunerTemi));
878         res.push_back(move(tunerEvent));
879     }
880 }
881 
getMonitorEvent(vector<DemuxFilterEventExt::Event> & eventsExt,vector<TunerFilterEvent> & res)882 void TunerFilter::FilterCallback::getMonitorEvent(
883         vector<DemuxFilterEventExt::Event>& eventsExt, vector<TunerFilterEvent>& res) {
884     DemuxFilterMonitorEvent monitorEvent = eventsExt[0].monitorEvent();
885     TunerFilterMonitorEvent tunerMonitor;
886 
887     switch (monitorEvent.getDiscriminator()) {
888         case DemuxFilterMonitorEvent::hidl_discriminator::scramblingStatus: {
889             tunerMonitor.set<TunerFilterMonitorEvent::scramblingStatus>(
890                     static_cast<int>(monitorEvent.scramblingStatus()));
891             break;
892         }
893         case DemuxFilterMonitorEvent::hidl_discriminator::cid: {
894             tunerMonitor.set<TunerFilterMonitorEvent::cid>(static_cast<int>(monitorEvent.cid()));
895             break;
896         }
897     }
898 
899     TunerFilterEvent tunerEvent;
900     tunerEvent.set<TunerFilterEvent::monitor>(move(tunerMonitor));
901     res.push_back(move(tunerEvent));
902 }
903 
getRestartEvent(vector<DemuxFilterEventExt::Event> & eventsExt,vector<TunerFilterEvent> & res)904 void TunerFilter::FilterCallback::getRestartEvent(
905         vector<DemuxFilterEventExt::Event>& eventsExt, vector<TunerFilterEvent>& res) {
906     TunerFilterEvent tunerEvent;
907     tunerEvent.set<TunerFilterEvent::startId>(static_cast<int>(eventsExt[0].startId()));
908     res.push_back(move(tunerEvent));
909 }
910 }  // namespace android
911