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 "TunerHidlFilter"
18
19 #include "TunerHidlFilter.h"
20
21 #include <aidl/android/hardware/tv/tuner/Constant.h>
22 #include <aidl/android/hardware/tv/tuner/DemuxScIndex.h>
23 #include <aidl/android/hardware/tv/tuner/Result.h>
24 #include <aidlcommonsupport/NativeHandle.h>
25 #include <binder/IPCThreadState.h>
26 #include <fmq/ConvertMQDescriptors.h>
27
28 #include "TunerHelper.h"
29 #include "TunerHidlService.h"
30
31 using ::aidl::android::hardware::tv::tuner::AudioExtraMetaData;
32 using ::aidl::android::hardware::tv::tuner::AudioStreamType;
33 using ::aidl::android::hardware::tv::tuner::Constant;
34 using ::aidl::android::hardware::tv::tuner::DemuxAlpFilterSettings;
35 using ::aidl::android::hardware::tv::tuner::DemuxAlpFilterSettingsFilterSettings;
36 using ::aidl::android::hardware::tv::tuner::DemuxFilterDownloadEvent;
37 using ::aidl::android::hardware::tv::tuner::DemuxFilterIpPayloadEvent;
38 using ::aidl::android::hardware::tv::tuner::DemuxFilterMainType;
39 using ::aidl::android::hardware::tv::tuner::DemuxFilterMediaEvent;
40 using ::aidl::android::hardware::tv::tuner::DemuxFilterMediaEventExtraMetaData;
41 using ::aidl::android::hardware::tv::tuner::DemuxFilterMmtpRecordEvent;
42 using ::aidl::android::hardware::tv::tuner::DemuxFilterMonitorEvent;
43 using ::aidl::android::hardware::tv::tuner::DemuxFilterPesEvent;
44 using ::aidl::android::hardware::tv::tuner::DemuxFilterScIndexMask;
45 using ::aidl::android::hardware::tv::tuner::DemuxFilterSectionBits;
46 using ::aidl::android::hardware::tv::tuner::DemuxFilterSectionEvent;
47 using ::aidl::android::hardware::tv::tuner::DemuxFilterSectionSettingsCondition;
48 using ::aidl::android::hardware::tv::tuner::DemuxFilterSectionSettingsConditionTableInfo;
49 using ::aidl::android::hardware::tv::tuner::DemuxFilterSubType;
50 using ::aidl::android::hardware::tv::tuner::DemuxFilterTemiEvent;
51 using ::aidl::android::hardware::tv::tuner::DemuxFilterTsRecordEvent;
52 using ::aidl::android::hardware::tv::tuner::DemuxIpAddress;
53 using ::aidl::android::hardware::tv::tuner::DemuxIpAddressIpAddress;
54 using ::aidl::android::hardware::tv::tuner::DemuxIpFilterSettings;
55 using ::aidl::android::hardware::tv::tuner::DemuxIpFilterSettingsFilterSettings;
56 using ::aidl::android::hardware::tv::tuner::DemuxMmtpFilterSettings;
57 using ::aidl::android::hardware::tv::tuner::DemuxMmtpFilterSettingsFilterSettings;
58 using ::aidl::android::hardware::tv::tuner::DemuxMmtpFilterType;
59 using ::aidl::android::hardware::tv::tuner::DemuxPid;
60 using ::aidl::android::hardware::tv::tuner::DemuxScIndex;
61 using ::aidl::android::hardware::tv::tuner::DemuxTlvFilterSettings;
62 using ::aidl::android::hardware::tv::tuner::DemuxTlvFilterSettingsFilterSettings;
63 using ::aidl::android::hardware::tv::tuner::DemuxTsFilterSettings;
64 using ::aidl::android::hardware::tv::tuner::DemuxTsFilterSettingsFilterSettings;
65 using ::aidl::android::hardware::tv::tuner::DemuxTsFilterType;
66 using ::aidl::android::hardware::tv::tuner::Result;
67 using ::aidl::android::hardware::tv::tuner::ScramblingStatus;
68 using ::android::dupToAidl;
69 using ::android::IPCThreadState;
70 using ::android::makeFromAidl;
71 using ::android::unsafeHidlToAidlMQDescriptor;
72 using ::android::hardware::hidl_handle;
73
74 using HidlDemuxAlpLengthType = ::android::hardware::tv::tuner::V1_0::DemuxAlpLengthType;
75 using HidlDemuxFilterMainType = ::android::hardware::tv::tuner::V1_0::DemuxFilterMainType;
76 using HidlDemuxIpAddress = ::android::hardware::tv::tuner::V1_0::DemuxIpAddress;
77 using HidlDemuxMmtpFilterType = ::android::hardware::tv::tuner::V1_0::DemuxMmtpFilterType;
78 using HidlDemuxMmtpPid = ::android::hardware::tv::tuner::V1_0::DemuxMmtpPid;
79 using HidlDemuxRecordScIndexType = ::android::hardware::tv::tuner::V1_0::DemuxRecordScIndexType;
80 using HidlDemuxStreamId = ::android::hardware::tv::tuner::V1_0::DemuxStreamId;
81 using HidlDemuxTsFilterType = ::android::hardware::tv::tuner::V1_0::DemuxTsFilterType;
82 using HidlResult = ::android::hardware::tv::tuner::V1_0::Result;
83 using HidlAudioStreamType = ::android::hardware::tv::tuner::V1_1::AudioStreamType;
84 using HidlConstant = ::android::hardware::tv::tuner::V1_1::Constant;
85 using HidlVideoStreamType = ::android::hardware::tv::tuner::V1_1::VideoStreamType;
86
87 using namespace std;
88
89 namespace aidl {
90 namespace android {
91 namespace media {
92 namespace tv {
93 namespace tuner {
94
TunerHidlFilter(const sp<HidlIFilter> filter,const sp<FilterCallback> cb,const DemuxFilterType type,const shared_ptr<TunerHidlService> tuner)95 TunerHidlFilter::TunerHidlFilter(const sp<HidlIFilter> filter, const sp<FilterCallback> cb,
96 const DemuxFilterType type,
97 const shared_ptr<TunerHidlService> tuner)
98 : mFilter(filter),
99 mType(type),
100 mStarted(false),
101 mShared(false),
102 mClientPid(-1),
103 mFilterCallback(cb),
104 mTunerService(tuner) {
105 mFilter_1_1 = ::android::hardware::tv::tuner::V1_1::IFilter::castFrom(filter);
106 }
107
~TunerHidlFilter()108 TunerHidlFilter::~TunerHidlFilter() {
109 freeSharedFilterToken("");
110
111 {
112 Mutex::Autolock _l(mLock);
113 mFilter = nullptr;
114 mFilter_1_1 = nullptr;
115 mTunerService = nullptr;
116 }
117 }
118
getQueueDesc(AidlMQDesc * _aidl_return)119 ::ndk::ScopedAStatus TunerHidlFilter::getQueueDesc(AidlMQDesc* _aidl_return) {
120 Mutex::Autolock _l(mLock);
121 if (mShared) {
122 IPCThreadState* ipc = IPCThreadState::self();
123 int32_t callingPid = ipc->getCallingPid();
124 if (callingPid == mClientPid) {
125 ALOGD("%s is called in wrong process", __FUNCTION__);
126 return ::ndk::ScopedAStatus::fromServiceSpecificError(
127 static_cast<int32_t>(Result::INVALID_STATE));
128 }
129 }
130
131 MQDesc filterMQDesc;
132 HidlResult res;
133 mFilter->getQueueDesc([&](HidlResult r, const MQDesc& desc) {
134 filterMQDesc = desc;
135 res = r;
136 });
137 if (res != HidlResult::SUCCESS) {
138 return ::ndk::ScopedAStatus::fromServiceSpecificError(static_cast<int32_t>(res));
139 }
140
141 AidlMQDesc aidlMQDesc;
142 unsafeHidlToAidlMQDescriptor<uint8_t, int8_t, SynchronizedReadWrite>(filterMQDesc, &aidlMQDesc);
143 *_aidl_return = std::move(aidlMQDesc);
144
145 return ::ndk::ScopedAStatus::ok();
146 }
147
getId(int32_t * _aidl_return)148 ::ndk::ScopedAStatus TunerHidlFilter::getId(int32_t* _aidl_return) {
149 Mutex::Autolock _l(mLock);
150 if (mShared) {
151 ALOGD("%s is called on a shared filter", __FUNCTION__);
152 return ::ndk::ScopedAStatus::fromServiceSpecificError(
153 static_cast<int32_t>(Result::INVALID_STATE));
154 }
155
156 HidlResult res;
157 mFilter->getId([&](HidlResult r, uint32_t filterId) {
158 res = r;
159 mId = filterId;
160 });
161 if (res != HidlResult::SUCCESS) {
162 return ::ndk::ScopedAStatus::fromServiceSpecificError(static_cast<int32_t>(res));
163 }
164 *_aidl_return = mId;
165
166 return ::ndk::ScopedAStatus::ok();
167 }
168
getId64Bit(int64_t * _aidl_return)169 ::ndk::ScopedAStatus TunerHidlFilter::getId64Bit(int64_t* _aidl_return) {
170 Mutex::Autolock _l(mLock);
171 if (mFilter_1_1 == nullptr) {
172 ALOGE("IFilter_1_1 is not initialized");
173 return ::ndk::ScopedAStatus::fromServiceSpecificError(
174 static_cast<int32_t>(Result::UNAVAILABLE));
175 }
176
177 if (mShared) {
178 ALOGD("%s is called on a shared filter", __FUNCTION__);
179 return ::ndk::ScopedAStatus::fromServiceSpecificError(
180 static_cast<int32_t>(Result::INVALID_STATE));
181 }
182
183 HidlResult res;
184 mFilter_1_1->getId64Bit([&](HidlResult r, uint64_t filterId) {
185 res = r;
186 mId64Bit = filterId;
187 });
188 if (res != HidlResult::SUCCESS) {
189 return ::ndk::ScopedAStatus::fromServiceSpecificError(static_cast<int32_t>(res));
190 }
191 *_aidl_return = mId64Bit;
192
193 return ::ndk::ScopedAStatus::ok();
194 }
195
configure(const DemuxFilterSettings & in_settings)196 ::ndk::ScopedAStatus TunerHidlFilter::configure(const DemuxFilterSettings& in_settings) {
197 Mutex::Autolock _l(mLock);
198 if (mShared) {
199 ALOGD("%s is called on a shared filter", __FUNCTION__);
200 return ::ndk::ScopedAStatus::fromServiceSpecificError(
201 static_cast<int32_t>(Result::INVALID_STATE));
202 }
203
204 HidlDemuxFilterSettings settings;
205 switch (in_settings.getTag()) {
206 case DemuxFilterSettings::ts: {
207 getHidlTsSettings(in_settings, settings);
208 break;
209 }
210 case DemuxFilterSettings::mmtp: {
211 getHidlMmtpSettings(in_settings, settings);
212 break;
213 }
214 case DemuxFilterSettings::ip: {
215 getHidlIpSettings(in_settings, settings);
216 break;
217 }
218 case DemuxFilterSettings::tlv: {
219 getHidlTlvSettings(in_settings, settings);
220 break;
221 }
222 case DemuxFilterSettings::alp: {
223 getHidlAlpSettings(in_settings, settings);
224 break;
225 }
226 }
227
228 HidlResult res = mFilter->configure(settings);
229 if (res != HidlResult::SUCCESS) {
230 return ::ndk::ScopedAStatus::fromServiceSpecificError(static_cast<int32_t>(res));
231 }
232
233 return ::ndk::ScopedAStatus::ok();
234 }
235
configureMonitorEvent(int32_t monitorEventType)236 ::ndk::ScopedAStatus TunerHidlFilter::configureMonitorEvent(int32_t monitorEventType) {
237 Mutex::Autolock _l(mLock);
238 if (mFilter_1_1 == nullptr) {
239 ALOGE("IFilter_1_1 is not initialized");
240 return ::ndk::ScopedAStatus::fromServiceSpecificError(
241 static_cast<int32_t>(Result::UNAVAILABLE));
242 }
243
244 if (mShared) {
245 ALOGD("%s is called on a shared filter", __FUNCTION__);
246 return ::ndk::ScopedAStatus::fromServiceSpecificError(
247 static_cast<int32_t>(Result::INVALID_STATE));
248 }
249
250 HidlResult res = mFilter_1_1->configureMonitorEvent(monitorEventType);
251 if (res != HidlResult::SUCCESS) {
252 return ::ndk::ScopedAStatus::fromServiceSpecificError(static_cast<int32_t>(res));
253 }
254
255 return ::ndk::ScopedAStatus::ok();
256 }
257
configureIpFilterContextId(int32_t cid)258 ::ndk::ScopedAStatus TunerHidlFilter::configureIpFilterContextId(int32_t cid) {
259 Mutex::Autolock _l(mLock);
260 if (mFilter_1_1 == nullptr) {
261 ALOGE("IFilter_1_1 is not initialized");
262 return ::ndk::ScopedAStatus::fromServiceSpecificError(
263 static_cast<int32_t>(Result::UNAVAILABLE));
264 }
265
266 if (mShared) {
267 ALOGD("%s is called on a shared filter", __FUNCTION__);
268 return ::ndk::ScopedAStatus::fromServiceSpecificError(
269 static_cast<int32_t>(Result::INVALID_STATE));
270 }
271
272 HidlResult res = mFilter_1_1->configureIpCid(cid);
273 if (res != HidlResult::SUCCESS) {
274 return ::ndk::ScopedAStatus::fromServiceSpecificError(static_cast<int32_t>(res));
275 }
276
277 return ::ndk::ScopedAStatus::ok();
278 }
279
configureAvStreamType(const AvStreamType & in_avStreamType)280 ::ndk::ScopedAStatus TunerHidlFilter::configureAvStreamType(const AvStreamType& in_avStreamType) {
281 Mutex::Autolock _l(mLock);
282 if (mFilter_1_1 == nullptr) {
283 ALOGE("IFilter_1_1 is not initialized");
284 return ::ndk::ScopedAStatus::fromServiceSpecificError(
285 static_cast<int32_t>(Result::UNAVAILABLE));
286 }
287
288 if (mShared) {
289 ALOGD("%s is called on a shared filter", __FUNCTION__);
290 return ::ndk::ScopedAStatus::fromServiceSpecificError(
291 static_cast<int32_t>(Result::INVALID_STATE));
292 }
293
294 HidlAvStreamType type;
295 if (!getHidlAvStreamType(in_avStreamType, type)) {
296 return ::ndk::ScopedAStatus::fromServiceSpecificError(
297 static_cast<int32_t>(Result::INVALID_STATE));
298 }
299
300 HidlResult res = mFilter_1_1->configureAvStreamType(type);
301 if (res != HidlResult::SUCCESS) {
302 return ::ndk::ScopedAStatus::fromServiceSpecificError(static_cast<int32_t>(res));
303 }
304
305 return ::ndk::ScopedAStatus::ok();
306 }
307
setDataSource(const shared_ptr<ITunerFilter> & filter)308 ::ndk::ScopedAStatus TunerHidlFilter::setDataSource(const shared_ptr<ITunerFilter>& filter) {
309 Mutex::Autolock _l(mLock);
310 if (filter == nullptr) {
311 return ::ndk::ScopedAStatus::fromServiceSpecificError(
312 static_cast<int32_t>(Result::INVALID_ARGUMENT));
313 }
314
315 if (mShared) {
316 ALOGD("%s is called on a shared filter", __FUNCTION__);
317 return ::ndk::ScopedAStatus::fromServiceSpecificError(
318 static_cast<int32_t>(Result::INVALID_STATE));
319 }
320
321 sp<HidlIFilter> hidlFilter = static_cast<TunerHidlFilter*>(filter.get())->getHalFilter();
322 HidlResult res = mFilter->setDataSource(hidlFilter);
323 if (res != HidlResult::SUCCESS) {
324 return ::ndk::ScopedAStatus::fromServiceSpecificError(static_cast<int32_t>(res));
325 }
326
327 return ::ndk::ScopedAStatus::ok();
328 }
329
getAvSharedHandle(NativeHandle * out_avMemory,int64_t * _aidl_return)330 ::ndk::ScopedAStatus TunerHidlFilter::getAvSharedHandle(NativeHandle* out_avMemory,
331 int64_t* _aidl_return) {
332 Mutex::Autolock _l(mLock);
333 if (mFilter_1_1 == nullptr) {
334 ALOGE("IFilter_1_1 is not initialized");
335 return ::ndk::ScopedAStatus::fromServiceSpecificError(
336 static_cast<int32_t>(Result::UNAVAILABLE));
337 }
338
339 if (mShared) {
340 ALOGD("%s is called on a shared filter", __FUNCTION__);
341 return ::ndk::ScopedAStatus::fromServiceSpecificError(
342 static_cast<int32_t>(Result::INVALID_STATE));
343 }
344
345 HidlResult res;
346 mFilter_1_1->getAvSharedHandle([&](HidlResult r, hidl_handle avMemory, uint64_t avMemSize) {
347 res = r;
348 if (res == HidlResult::SUCCESS) {
349 *out_avMemory = dupToAidl(avMemory);
350 *_aidl_return = static_cast<int64_t>(avMemSize);
351 }
352 });
353
354 if (res != HidlResult::SUCCESS) {
355 return ::ndk::ScopedAStatus::fromServiceSpecificError(static_cast<int32_t>(res));
356 }
357
358 return ::ndk::ScopedAStatus::ok();
359 }
360
releaseAvHandle(const NativeHandle & in_handle,int64_t in_avDataId)361 ::ndk::ScopedAStatus TunerHidlFilter::releaseAvHandle(const NativeHandle& in_handle,
362 int64_t in_avDataId) {
363 Mutex::Autolock _l(mLock);
364 if (mShared) {
365 ALOGD("%s is called on a shared filter", __FUNCTION__);
366 return ::ndk::ScopedAStatus::fromServiceSpecificError(
367 static_cast<int32_t>(Result::INVALID_STATE));
368 }
369
370 hidl_handle handle;
371 handle.setTo(makeFromAidl(in_handle));
372 HidlResult res = mFilter->releaseAvHandle(handle, in_avDataId);
373 if (res != HidlResult::SUCCESS) {
374 return ::ndk::ScopedAStatus::fromServiceSpecificError(static_cast<int32_t>(res));
375 }
376
377 // Call to HAL to make sure the transport FD was able to be closed by binder.
378 // This is a tricky workaround for a problem in Binder.
379 // TODO:[b/192048842] When that problem is fixed we may be able to remove or change this code.
380 mFilter->getId([&](HidlResult /* r */, uint32_t /* filterId*/){});
381
382 return ::ndk::ScopedAStatus::ok();
383 }
384
start()385 ::ndk::ScopedAStatus TunerHidlFilter::start() {
386 Mutex::Autolock _l(mLock);
387 if (mShared) {
388 IPCThreadState* ipc = IPCThreadState::self();
389 int32_t callingPid = ipc->getCallingPid();
390 if (callingPid == mClientPid) {
391 ALOGD("%s is called in wrong process", __FUNCTION__);
392 return ::ndk::ScopedAStatus::fromServiceSpecificError(
393 static_cast<int32_t>(Result::INVALID_STATE));
394 }
395 }
396
397 HidlResult res = mFilter->start();
398 if (res != HidlResult::SUCCESS) {
399 return ::ndk::ScopedAStatus::fromServiceSpecificError(static_cast<int32_t>(res));
400 }
401 mStarted = true;
402
403 return ::ndk::ScopedAStatus::ok();
404 }
405
stop()406 ::ndk::ScopedAStatus TunerHidlFilter::stop() {
407 Mutex::Autolock _l(mLock);
408 if (mShared) {
409 IPCThreadState* ipc = IPCThreadState::self();
410 int32_t callingPid = ipc->getCallingPid();
411 if (callingPid == mClientPid) {
412 ALOGD("%s is called in wrong process", __FUNCTION__);
413 return ::ndk::ScopedAStatus::fromServiceSpecificError(
414 static_cast<int32_t>(Result::INVALID_STATE));
415 }
416 }
417
418 HidlResult res = mFilter->stop();
419 mStarted = false;
420 if (res != HidlResult::SUCCESS) {
421 return ::ndk::ScopedAStatus::fromServiceSpecificError(static_cast<int32_t>(res));
422 }
423
424 return ::ndk::ScopedAStatus::ok();
425 }
426
flush()427 ::ndk::ScopedAStatus TunerHidlFilter::flush() {
428 Mutex::Autolock _l(mLock);
429 if (mShared) {
430 IPCThreadState* ipc = IPCThreadState::self();
431 int32_t callingPid = ipc->getCallingPid();
432 if (callingPid == mClientPid) {
433 ALOGD("%s is called in wrong process", __FUNCTION__);
434 return ::ndk::ScopedAStatus::fromServiceSpecificError(
435 static_cast<int32_t>(Result::INVALID_STATE));
436 }
437 }
438
439 HidlResult res = mFilter->flush();
440 if (res != HidlResult::SUCCESS) {
441 return ::ndk::ScopedAStatus::fromServiceSpecificError(static_cast<int32_t>(res));
442 }
443
444 return ::ndk::ScopedAStatus::ok();
445 }
446
close()447 ::ndk::ScopedAStatus TunerHidlFilter::close() {
448 Mutex::Autolock _l(mLock);
449 if (mShared) {
450 IPCThreadState* ipc = IPCThreadState::self();
451 int32_t callingPid = ipc->getCallingPid();
452 if (callingPid == mClientPid) {
453 if (mFilterCallback != nullptr) {
454 mFilterCallback->sendSharedFilterStatus(STATUS_INACCESSIBLE);
455 mFilterCallback->detachSharedFilterCallback();
456 }
457 mTunerService->removeSharedFilter(this->ref<TunerHidlFilter>());
458 } else {
459 // Calling from shared process, do not really close this filter.
460 if (mFilterCallback != nullptr) {
461 mFilterCallback->detachSharedFilterCallback();
462 }
463 mStarted = false;
464 return ::ndk::ScopedAStatus::ok();
465 }
466 }
467
468 if (mFilterCallback != nullptr) {
469 mFilterCallback->detachCallbacks();
470 }
471 HidlResult res = mFilter->close();
472 mStarted = false;
473 mShared = false;
474 mClientPid = -1;
475
476 if (res != HidlResult::SUCCESS) {
477 return ::ndk::ScopedAStatus::fromServiceSpecificError(static_cast<int32_t>(res));
478 }
479
480 return ::ndk::ScopedAStatus::ok();
481 }
482
acquireSharedFilterToken(string * _aidl_return)483 ::ndk::ScopedAStatus TunerHidlFilter::acquireSharedFilterToken(string* _aidl_return) {
484 Mutex::Autolock _l(mLock);
485 if (mShared || mStarted) {
486 ALOGD("create SharedFilter in wrong state");
487 return ::ndk::ScopedAStatus::fromServiceSpecificError(
488 static_cast<int32_t>(Result::INVALID_STATE));
489 }
490
491 IPCThreadState* ipc = IPCThreadState::self();
492 mClientPid = ipc->getCallingPid();
493 string token = mTunerService->addFilterToShared(this->ref<TunerHidlFilter>());
494 _aidl_return->assign(token);
495 mShared = true;
496
497 return ::ndk::ScopedAStatus::ok();
498 }
499
freeSharedFilterToken(const string &)500 ::ndk::ScopedAStatus TunerHidlFilter::freeSharedFilterToken(const string& /* in_filterToken */) {
501 Mutex::Autolock _l(mLock);
502 if (!mShared) {
503 // The filter is not shared or the shared filter has been closed.
504 return ::ndk::ScopedAStatus::ok();
505 }
506
507 if (mFilterCallback != nullptr) {
508 mFilterCallback->sendSharedFilterStatus(STATUS_INACCESSIBLE);
509 mFilterCallback->detachSharedFilterCallback();
510 }
511
512 mTunerService->removeSharedFilter(this->ref<TunerHidlFilter>());
513 mShared = false;
514
515 return ::ndk::ScopedAStatus::ok();
516 }
517
getFilterType(DemuxFilterType * _aidl_return)518 ::ndk::ScopedAStatus TunerHidlFilter::getFilterType(DemuxFilterType* _aidl_return) {
519 *_aidl_return = mType;
520 return ::ndk::ScopedAStatus::ok();
521 }
522
setDelayHint(const FilterDelayHint &)523 ::ndk::ScopedAStatus TunerHidlFilter::setDelayHint(const FilterDelayHint&) {
524 // setDelayHint is not supported in HIDL HAL
525 return ::ndk::ScopedAStatus::fromServiceSpecificError(
526 static_cast<int32_t>(Result::UNAVAILABLE));
527 }
528
isSharedFilterAllowed(int callingPid)529 bool TunerHidlFilter::isSharedFilterAllowed(int callingPid) {
530 return mShared && mClientPid != callingPid;
531 }
532
attachSharedFilterCallback(const shared_ptr<ITunerFilterCallback> & in_cb)533 void TunerHidlFilter::attachSharedFilterCallback(const shared_ptr<ITunerFilterCallback>& in_cb) {
534 if (mFilterCallback != nullptr) {
535 mFilterCallback->attachSharedFilterCallback(in_cb);
536 }
537 }
538
getHalFilter()539 sp<HidlIFilter> TunerHidlFilter::getHalFilter() {
540 return mFilter;
541 }
542
getHidlAvStreamType(const AvStreamType avStreamType,HidlAvStreamType & type)543 bool TunerHidlFilter::getHidlAvStreamType(const AvStreamType avStreamType, HidlAvStreamType& type) {
544 if (isAudioFilter()) {
545 AudioStreamType audio = avStreamType.get<AvStreamType::audio>();
546 if (static_cast<int32_t>(audio) > static_cast<int32_t>(HidlAudioStreamType::DRA)) {
547 return false;
548 }
549 type.audio(static_cast<HidlAudioStreamType>(audio));
550 return true;
551 }
552
553 if (isVideoFilter()) {
554 type.video(static_cast<HidlVideoStreamType>(avStreamType.get<AvStreamType::video>()));
555 return true;
556 }
557
558 return false;
559 }
560
isAudioFilter()561 bool TunerHidlFilter::isAudioFilter() {
562 return (mType.mainType == DemuxFilterMainType::TS &&
563 mType.subType.get<DemuxFilterSubType::tsFilterType>() == DemuxTsFilterType::AUDIO) ||
564 (mType.mainType == DemuxFilterMainType::MMTP &&
565 mType.subType.get<DemuxFilterSubType::mmtpFilterType>() == DemuxMmtpFilterType::AUDIO);
566 }
567
isVideoFilter()568 bool TunerHidlFilter::isVideoFilter() {
569 return (mType.mainType == DemuxFilterMainType::TS &&
570 mType.subType.get<DemuxFilterSubType::tsFilterType>() == DemuxTsFilterType::VIDEO) ||
571 (mType.mainType == DemuxFilterMainType::MMTP &&
572 mType.subType.get<DemuxFilterSubType::mmtpFilterType>() == DemuxMmtpFilterType::VIDEO);
573 }
574
getHidlTsSettings(const DemuxFilterSettings & settings,HidlDemuxFilterSettings & hidlSettings)575 void TunerHidlFilter::getHidlTsSettings(const DemuxFilterSettings& settings,
576 HidlDemuxFilterSettings& hidlSettings) {
577 const DemuxTsFilterSettings& tsConf = settings.get<DemuxFilterSettings::ts>();
578 HidlDemuxTsFilterSettings ts{
579 .tpid = static_cast<uint16_t>(tsConf.tpid),
580 };
581
582 switch (tsConf.filterSettings.getTag()) {
583 case DemuxTsFilterSettingsFilterSettings::av: {
584 ts.filterSettings.av(getHidlAvSettings(
585 tsConf.filterSettings.get<DemuxTsFilterSettingsFilterSettings::av>()));
586 break;
587 }
588 case DemuxTsFilterSettingsFilterSettings::section: {
589 ts.filterSettings.section(getHidlSectionSettings(
590 tsConf.filterSettings.get<DemuxTsFilterSettingsFilterSettings::section>()));
591 break;
592 }
593 case DemuxTsFilterSettingsFilterSettings::pesData: {
594 ts.filterSettings.pesData(getHidlPesDataSettings(
595 tsConf.filterSettings.get<DemuxTsFilterSettingsFilterSettings::pesData>()));
596 break;
597 }
598 case DemuxTsFilterSettingsFilterSettings::record: {
599 ts.filterSettings.record(getHidlRecordSettings(
600 tsConf.filterSettings.get<DemuxTsFilterSettingsFilterSettings::record>()));
601 break;
602 }
603 default: {
604 ts.filterSettings.noinit();
605 break;
606 }
607 }
608 hidlSettings.ts(ts);
609 }
610
getHidlMmtpSettings(const DemuxFilterSettings & settings,HidlDemuxFilterSettings & hidlSettings)611 void TunerHidlFilter::getHidlMmtpSettings(const DemuxFilterSettings& settings,
612 HidlDemuxFilterSettings& hidlSettings) {
613 const DemuxMmtpFilterSettings& mmtpConf = settings.get<DemuxFilterSettings::mmtp>();
614 HidlDemuxMmtpFilterSettings mmtp{
615 .mmtpPid = static_cast<HidlDemuxMmtpPid>(mmtpConf.mmtpPid),
616 };
617
618 switch (mmtpConf.filterSettings.getTag()) {
619 case DemuxMmtpFilterSettingsFilterSettings::av: {
620 mmtp.filterSettings.av(getHidlAvSettings(
621 mmtpConf.filterSettings.get<DemuxMmtpFilterSettingsFilterSettings::av>()));
622 break;
623 }
624 case DemuxMmtpFilterSettingsFilterSettings::section: {
625 mmtp.filterSettings.section(getHidlSectionSettings(
626 mmtpConf.filterSettings.get<DemuxMmtpFilterSettingsFilterSettings::section>()));
627 break;
628 }
629 case DemuxMmtpFilterSettingsFilterSettings::pesData: {
630 mmtp.filterSettings.pesData(getHidlPesDataSettings(
631 mmtpConf.filterSettings.get<DemuxMmtpFilterSettingsFilterSettings::pesData>()));
632 break;
633 }
634 case DemuxMmtpFilterSettingsFilterSettings::record: {
635 mmtp.filterSettings.record(getHidlRecordSettings(
636 mmtpConf.filterSettings.get<DemuxMmtpFilterSettingsFilterSettings::record>()));
637 break;
638 }
639 case DemuxMmtpFilterSettingsFilterSettings::download: {
640 mmtp.filterSettings.download(getHidlDownloadSettings(
641 mmtpConf.filterSettings.get<DemuxMmtpFilterSettingsFilterSettings::download>()));
642 break;
643 }
644 default: {
645 mmtp.filterSettings.noinit();
646 break;
647 }
648 }
649 hidlSettings.mmtp(mmtp);
650 }
651
getHidlIpSettings(const DemuxFilterSettings & settings,HidlDemuxFilterSettings & hidlSettings)652 void TunerHidlFilter::getHidlIpSettings(const DemuxFilterSettings& settings,
653 HidlDemuxFilterSettings& hidlSettings) {
654 const DemuxIpFilterSettings& ipConf = settings.get<DemuxFilterSettings::ip>();
655 HidlDemuxIpAddress ipAddr{
656 .srcPort = static_cast<uint16_t>(ipConf.ipAddr.srcPort),
657 .dstPort = static_cast<uint16_t>(ipConf.ipAddr.dstPort),
658 };
659
660 ipConf.ipAddr.srcIpAddress.getTag() == DemuxIpAddressIpAddress::v6
661 ? ipAddr.srcIpAddress.v6(getIpV6Address(ipConf.ipAddr.srcIpAddress))
662 : ipAddr.srcIpAddress.v4(getIpV4Address(ipConf.ipAddr.srcIpAddress));
663 ipConf.ipAddr.dstIpAddress.getTag() == DemuxIpAddressIpAddress::v6
664 ? ipAddr.dstIpAddress.v6(getIpV6Address(ipConf.ipAddr.dstIpAddress))
665 : ipAddr.dstIpAddress.v4(getIpV4Address(ipConf.ipAddr.dstIpAddress));
666
667 HidlDemuxIpFilterSettings ip;
668 ip.ipAddr = ipAddr;
669
670 switch (ipConf.filterSettings.getTag()) {
671 case DemuxIpFilterSettingsFilterSettings::section: {
672 ip.filterSettings.section(getHidlSectionSettings(
673 ipConf.filterSettings.get<DemuxIpFilterSettingsFilterSettings::section>()));
674 break;
675 }
676 case DemuxIpFilterSettingsFilterSettings::bPassthrough: {
677 ip.filterSettings.bPassthrough(
678 ipConf.filterSettings.get<DemuxIpFilterSettingsFilterSettings::bPassthrough>());
679 break;
680 }
681 default: {
682 ip.filterSettings.noinit();
683 break;
684 }
685 }
686 hidlSettings.ip(ip);
687 }
688
getIpV6Address(const DemuxIpAddressIpAddress & addr)689 hidl_array<uint8_t, IP_V6_LENGTH> TunerHidlFilter::getIpV6Address(
690 const DemuxIpAddressIpAddress& addr) {
691 hidl_array<uint8_t, IP_V6_LENGTH> ip;
692 if (addr.get<DemuxIpAddressIpAddress::v6>().size() != IP_V6_LENGTH) {
693 return ip;
694 }
695 copy(addr.get<DemuxIpAddressIpAddress::v6>().begin(),
696 addr.get<DemuxIpAddressIpAddress::v6>().end(), ip.data());
697 return ip;
698 }
699
getIpV4Address(const DemuxIpAddressIpAddress & addr)700 hidl_array<uint8_t, IP_V4_LENGTH> TunerHidlFilter::getIpV4Address(
701 const DemuxIpAddressIpAddress& addr) {
702 hidl_array<uint8_t, IP_V4_LENGTH> ip;
703 if (addr.get<DemuxIpAddressIpAddress::v4>().size() != IP_V4_LENGTH) {
704 return ip;
705 }
706 copy(addr.get<DemuxIpAddressIpAddress::v4>().begin(),
707 addr.get<DemuxIpAddressIpAddress::v4>().end(), ip.data());
708 return ip;
709 }
710
getHidlTlvSettings(const DemuxFilterSettings & settings,HidlDemuxFilterSettings & hidlSettings)711 void TunerHidlFilter::getHidlTlvSettings(const DemuxFilterSettings& settings,
712 HidlDemuxFilterSettings& hidlSettings) {
713 const DemuxTlvFilterSettings& tlvConf = settings.get<DemuxFilterSettings::tlv>();
714 HidlDemuxTlvFilterSettings tlv{
715 .packetType = static_cast<uint8_t>(tlvConf.packetType),
716 .isCompressedIpPacket = tlvConf.isCompressedIpPacket,
717 };
718
719 switch (tlvConf.filterSettings.getTag()) {
720 case DemuxTlvFilterSettingsFilterSettings::section: {
721 tlv.filterSettings.section(getHidlSectionSettings(
722 tlvConf.filterSettings.get<DemuxTlvFilterSettingsFilterSettings::section>()));
723 break;
724 }
725 case DemuxTlvFilterSettingsFilterSettings::bPassthrough: {
726 tlv.filterSettings.bPassthrough(
727 tlvConf.filterSettings.get<DemuxTlvFilterSettingsFilterSettings::bPassthrough>());
728 break;
729 }
730 default: {
731 tlv.filterSettings.noinit();
732 break;
733 }
734 }
735 hidlSettings.tlv(tlv);
736 }
737
getHidlAlpSettings(const DemuxFilterSettings & settings,HidlDemuxFilterSettings & hidlSettings)738 void TunerHidlFilter::getHidlAlpSettings(const DemuxFilterSettings& settings,
739 HidlDemuxFilterSettings& hidlSettings) {
740 const DemuxAlpFilterSettings& alpConf = settings.get<DemuxFilterSettings::alp>();
741 HidlDemuxAlpFilterSettings alp{
742 .packetType = static_cast<uint8_t>(alpConf.packetType),
743 .lengthType = static_cast<HidlDemuxAlpLengthType>(alpConf.lengthType),
744 };
745
746 switch (alpConf.filterSettings.getTag()) {
747 case DemuxAlpFilterSettingsFilterSettings::section: {
748 alp.filterSettings.section(getHidlSectionSettings(
749 alpConf.filterSettings.get<DemuxAlpFilterSettingsFilterSettings::section>()));
750 break;
751 }
752 default: {
753 alp.filterSettings.noinit();
754 break;
755 }
756 }
757 hidlSettings.alp(alp);
758 }
759
getHidlAvSettings(const DemuxFilterAvSettings & settings)760 HidlDemuxFilterAvSettings TunerHidlFilter::getHidlAvSettings(
761 const DemuxFilterAvSettings& settings) {
762 HidlDemuxFilterAvSettings av{
763 .isPassthrough = settings.isPassthrough,
764 };
765 return av;
766 }
767
getHidlSectionSettings(const DemuxFilterSectionSettings & settings)768 HidlDemuxFilterSectionSettings TunerHidlFilter::getHidlSectionSettings(
769 const DemuxFilterSectionSettings& settings) {
770 HidlDemuxFilterSectionSettings section{
771 .isCheckCrc = settings.isCheckCrc,
772 .isRepeat = settings.isRepeat,
773 .isRaw = settings.isRaw,
774 };
775
776 switch (settings.condition.getTag()) {
777 case DemuxFilterSectionSettingsCondition::sectionBits: {
778 const DemuxFilterSectionBits& sectionBits =
779 settings.condition.get<DemuxFilterSectionSettingsCondition::sectionBits>();
780 vector<uint8_t> filter(sectionBits.filter.begin(), sectionBits.filter.end());
781 vector<uint8_t> mask(sectionBits.mask.begin(), sectionBits.mask.end());
782 vector<uint8_t> mode(sectionBits.mode.begin(), sectionBits.mode.end());
783 section.condition.sectionBits({
784 .filter = filter,
785 .mask = mask,
786 .mode = mode,
787 });
788 break;
789 }
790 case DemuxFilterSectionSettingsCondition::tableInfo: {
791 const DemuxFilterSectionSettingsConditionTableInfo& tableInfo =
792 settings.condition.get<DemuxFilterSectionSettingsCondition::tableInfo>();
793 section.condition.tableInfo({
794 .tableId = static_cast<uint16_t>(tableInfo.tableId),
795 .version = static_cast<uint16_t>(tableInfo.version),
796 });
797 break;
798 }
799 default: {
800 break;
801 }
802 }
803 return section;
804 }
805
getHidlPesDataSettings(const DemuxFilterPesDataSettings & settings)806 HidlDemuxFilterPesDataSettings TunerHidlFilter::getHidlPesDataSettings(
807 const DemuxFilterPesDataSettings& settings) {
808 HidlDemuxFilterPesDataSettings pes{
809 .streamId = static_cast<HidlDemuxStreamId>(settings.streamId),
810 .isRaw = settings.isRaw,
811 };
812 return pes;
813 }
814
getHidlRecordSettings(const DemuxFilterRecordSettings & settings)815 HidlDemuxFilterRecordSettings TunerHidlFilter::getHidlRecordSettings(
816 const DemuxFilterRecordSettings& settings) {
817 HidlDemuxFilterRecordSettings record{
818 .tsIndexMask = static_cast<uint32_t>(settings.tsIndexMask),
819 };
820
821 switch (settings.scIndexMask.getTag()) {
822 case DemuxFilterScIndexMask::scIndex: {
823 record.scIndexType = static_cast<HidlDemuxRecordScIndexType>(settings.scIndexType);
824 record.scIndexMask.sc(
825 static_cast<uint32_t>(settings.scIndexMask.get<DemuxFilterScIndexMask::scIndex>()));
826 break;
827 }
828 case DemuxFilterScIndexMask::scAvc: {
829 record.scIndexType = HidlDemuxRecordScIndexType::SC;
830 uint32_t index =
831 static_cast<uint32_t>(settings.scIndexMask.get<DemuxFilterScIndexMask::scAvc>());
832 // HIDL HAL starting from 1 << 4; AIDL starting from 1 << 0.
833 index = index << 4;
834 record.scIndexMask.sc(index);
835 break;
836 }
837 case DemuxFilterScIndexMask::scHevc: {
838 record.scIndexType = static_cast<HidlDemuxRecordScIndexType>(settings.scIndexType);
839 record.scIndexMask.scHevc(
840 static_cast<uint32_t>(settings.scIndexMask.get<DemuxFilterScIndexMask::scHevc>()));
841 break;
842 }
843 case DemuxFilterScIndexMask::scVvc: {
844 // Shouldn't be here.
845 break;
846 }
847 }
848 return record;
849 }
850
getHidlDownloadSettings(const DemuxFilterDownloadSettings & settings)851 HidlDemuxFilterDownloadSettings TunerHidlFilter::getHidlDownloadSettings(
852 const DemuxFilterDownloadSettings& settings) {
853 HidlDemuxFilterDownloadSettings download{
854 .downloadId = static_cast<uint32_t>(settings.downloadId),
855 };
856 return download;
857 }
858
859 /////////////// FilterCallback ///////////////////////
onFilterStatus(HidlDemuxFilterStatus status)860 Return<void> TunerHidlFilter::FilterCallback::onFilterStatus(HidlDemuxFilterStatus status) {
861 Mutex::Autolock _l(mCallbackLock);
862 if (mTunerFilterCallback != nullptr) {
863 mTunerFilterCallback->onFilterStatus(static_cast<DemuxFilterStatus>(status));
864 }
865 return Void();
866 }
867
onFilterEvent(const HidlDemuxFilterEvent & filterEvent)868 Return<void> TunerHidlFilter::FilterCallback::onFilterEvent(
869 const HidlDemuxFilterEvent& filterEvent) {
870 vector<HidlDemuxFilterEventExt::Event> emptyEventsExt;
871 HidlDemuxFilterEventExt emptyFilterEventExt{
872 .events = emptyEventsExt,
873 };
874 onFilterEvent_1_1(filterEvent, emptyFilterEventExt);
875 return Void();
876 }
877
onFilterEvent_1_1(const HidlDemuxFilterEvent & filterEvent,const HidlDemuxFilterEventExt & filterEventExt)878 Return<void> TunerHidlFilter::FilterCallback::onFilterEvent_1_1(
879 const HidlDemuxFilterEvent& filterEvent, const HidlDemuxFilterEventExt& filterEventExt) {
880 Mutex::Autolock _l(mCallbackLock);
881 if (mTunerFilterCallback != nullptr) {
882 vector<HidlDemuxFilterEvent::Event> events = filterEvent.events;
883 vector<HidlDemuxFilterEventExt::Event> eventsExt = filterEventExt.events;
884 vector<DemuxFilterEvent> tunerEvents;
885
886 getAidlFilterEvent(events, eventsExt, tunerEvents);
887 mTunerFilterCallback->onFilterEvent(tunerEvents);
888 }
889 return Void();
890 }
891
sendSharedFilterStatus(int32_t status)892 void TunerHidlFilter::FilterCallback::sendSharedFilterStatus(int32_t status) {
893 Mutex::Autolock _l(mCallbackLock);
894 if (mTunerFilterCallback != nullptr && mOriginalCallback != nullptr) {
895 mTunerFilterCallback->onFilterStatus(static_cast<DemuxFilterStatus>(status));
896 }
897 }
898
attachSharedFilterCallback(const shared_ptr<ITunerFilterCallback> & in_cb)899 void TunerHidlFilter::FilterCallback::attachSharedFilterCallback(
900 const shared_ptr<ITunerFilterCallback>& in_cb) {
901 Mutex::Autolock _l(mCallbackLock);
902 mOriginalCallback = mTunerFilterCallback;
903 mTunerFilterCallback = in_cb;
904 }
905
detachSharedFilterCallback()906 void TunerHidlFilter::FilterCallback::detachSharedFilterCallback() {
907 Mutex::Autolock _l(mCallbackLock);
908 if (mTunerFilterCallback != nullptr && mOriginalCallback != nullptr) {
909 mTunerFilterCallback = mOriginalCallback;
910 mOriginalCallback = nullptr;
911 }
912 }
913
detachCallbacks()914 void TunerHidlFilter::FilterCallback::detachCallbacks() {
915 Mutex::Autolock _l(mCallbackLock);
916 mOriginalCallback = nullptr;
917 mTunerFilterCallback = nullptr;
918 }
919
920 /////////////// FilterCallback Helper Methods ///////////////////////
getAidlFilterEvent(const vector<HidlDemuxFilterEvent::Event> & events,const vector<HidlDemuxFilterEventExt::Event> & eventsExt,vector<DemuxFilterEvent> & aidlEvents)921 void TunerHidlFilter::FilterCallback::getAidlFilterEvent(
922 const vector<HidlDemuxFilterEvent::Event>& events,
923 const vector<HidlDemuxFilterEventExt::Event>& eventsExt,
924 vector<DemuxFilterEvent>& aidlEvents) {
925 if (events.empty() && !eventsExt.empty()) {
926 switch (eventsExt[0].getDiscriminator()) {
927 case HidlDemuxFilterEventExt::Event::hidl_discriminator::monitorEvent: {
928 getMonitorEvent(eventsExt, aidlEvents);
929 break;
930 }
931 case HidlDemuxFilterEventExt::Event::hidl_discriminator::startId: {
932 getRestartEvent(eventsExt, aidlEvents);
933 break;
934 }
935 default: {
936 break;
937 }
938 }
939 }
940
941 if (!events.empty()) {
942 switch (events[0].getDiscriminator()) {
943 case HidlDemuxFilterEvent::Event::hidl_discriminator::media: {
944 getMediaEvent(events, aidlEvents);
945 break;
946 }
947 case HidlDemuxFilterEvent::Event::hidl_discriminator::section: {
948 getSectionEvent(events, aidlEvents);
949 break;
950 }
951 case HidlDemuxFilterEvent::Event::hidl_discriminator::pes: {
952 getPesEvent(events, aidlEvents);
953 break;
954 }
955 case HidlDemuxFilterEvent::Event::hidl_discriminator::tsRecord: {
956 getTsRecordEvent(events, eventsExt, aidlEvents);
957 break;
958 }
959 case HidlDemuxFilterEvent::Event::hidl_discriminator::mmtpRecord: {
960 getMmtpRecordEvent(events, eventsExt, aidlEvents);
961 break;
962 }
963 case HidlDemuxFilterEvent::Event::hidl_discriminator::download: {
964 getDownloadEvent(events, aidlEvents);
965 break;
966 }
967 case HidlDemuxFilterEvent::Event::hidl_discriminator::ipPayload: {
968 getIpPayloadEvent(events, aidlEvents);
969 break;
970 }
971 case HidlDemuxFilterEvent::Event::hidl_discriminator::temi: {
972 getTemiEvent(events, aidlEvents);
973 break;
974 }
975 default: {
976 break;
977 }
978 }
979 }
980 }
981
getMediaEvent(const vector<HidlDemuxFilterEvent::Event> & events,vector<DemuxFilterEvent> & res)982 void TunerHidlFilter::FilterCallback::getMediaEvent(
983 const vector<HidlDemuxFilterEvent::Event>& events, vector<DemuxFilterEvent>& res) {
984 for (int i = 0; i < events.size(); i++) {
985 const HidlDemuxFilterMediaEvent& mediaEvent = events[i].media();
986 DemuxFilterMediaEvent media;
987
988 media.streamId = static_cast<int32_t>(mediaEvent.streamId);
989 media.isPtsPresent = mediaEvent.isPtsPresent;
990 media.pts = static_cast<int64_t>(mediaEvent.pts);
991 media.isDtsPresent = false;
992 media.dts = static_cast<int64_t>(-1);
993 media.dataLength = static_cast<int64_t>(mediaEvent.dataLength);
994 media.offset = static_cast<int64_t>(mediaEvent.offset);
995 media.isSecureMemory = mediaEvent.isSecureMemory;
996 media.avDataId = static_cast<int64_t>(mediaEvent.avDataId);
997 media.mpuSequenceNumber = static_cast<int32_t>(mediaEvent.mpuSequenceNumber);
998 media.isPesPrivateData = mediaEvent.isPesPrivateData;
999 media.scIndexMask.set<DemuxFilterScIndexMask::scIndex>(
1000 static_cast<int32_t>(DemuxScIndex::UNDEFINED));
1001
1002 if (mediaEvent.extraMetaData.getDiscriminator() ==
1003 HidlDemuxFilterMediaEvent::ExtraMetaData::hidl_discriminator::audio) {
1004 AudioExtraMetaData audio;
1005 audio.adFade = static_cast<int8_t>(mediaEvent.extraMetaData.audio().adFade);
1006 audio.adPan = static_cast<int8_t>(mediaEvent.extraMetaData.audio().adPan);
1007 audio.versionTextTag =
1008 static_cast<int16_t>(mediaEvent.extraMetaData.audio().versionTextTag);
1009 audio.adGainCenter = static_cast<int8_t>(mediaEvent.extraMetaData.audio().adGainCenter);
1010 audio.adGainFront = static_cast<int8_t>(mediaEvent.extraMetaData.audio().adGainFront);
1011 audio.adGainSurround =
1012 static_cast<int8_t>(mediaEvent.extraMetaData.audio().adGainSurround);
1013 media.extraMetaData.set<DemuxFilterMediaEventExtraMetaData::audio>(audio);
1014 } else {
1015 media.extraMetaData.set<DemuxFilterMediaEventExtraMetaData::noinit>(true);
1016 }
1017
1018 if (mediaEvent.avMemory.getNativeHandle() != nullptr) {
1019 media.avMemory = dupToAidl(mediaEvent.avMemory.getNativeHandle());
1020 }
1021
1022 DemuxFilterEvent filterEvent;
1023 filterEvent.set<DemuxFilterEvent::media>(std::move(media));
1024 res.push_back(std::move(filterEvent));
1025 }
1026 }
1027
getSectionEvent(const vector<HidlDemuxFilterEvent::Event> & events,vector<DemuxFilterEvent> & res)1028 void TunerHidlFilter::FilterCallback::getSectionEvent(
1029 const vector<HidlDemuxFilterEvent::Event>& events, vector<DemuxFilterEvent>& res) {
1030 for (int i = 0; i < events.size(); i++) {
1031 const HidlDemuxFilterSectionEvent& sectionEvent = events[i].section();
1032 DemuxFilterSectionEvent section;
1033
1034 section.tableId = static_cast<int32_t>(sectionEvent.tableId);
1035 section.version = static_cast<int32_t>(sectionEvent.version);
1036 section.sectionNum = static_cast<int32_t>(sectionEvent.sectionNum);
1037 section.dataLength = static_cast<int64_t>(sectionEvent.dataLength);
1038
1039 DemuxFilterEvent filterEvent;
1040 filterEvent.set<DemuxFilterEvent::section>(std::move(section));
1041 res.push_back(std::move(filterEvent));
1042 }
1043 }
1044
getPesEvent(const vector<HidlDemuxFilterEvent::Event> & events,vector<DemuxFilterEvent> & res)1045 void TunerHidlFilter::FilterCallback::getPesEvent(const vector<HidlDemuxFilterEvent::Event>& events,
1046 vector<DemuxFilterEvent>& res) {
1047 for (int i = 0; i < events.size(); i++) {
1048 const HidlDemuxFilterPesEvent& pesEvent = events[i].pes();
1049 DemuxFilterPesEvent pes;
1050
1051 pes.streamId = static_cast<int32_t>(pesEvent.streamId);
1052 pes.dataLength = static_cast<int32_t>(pesEvent.dataLength);
1053 pes.mpuSequenceNumber = static_cast<int32_t>(pesEvent.mpuSequenceNumber);
1054
1055 DemuxFilterEvent filterEvent;
1056 filterEvent.set<DemuxFilterEvent::pes>(std::move(pes));
1057 res.push_back(std::move(filterEvent));
1058 }
1059 }
1060
getTsRecordEvent(const vector<HidlDemuxFilterEvent::Event> & events,const vector<HidlDemuxFilterEventExt::Event> & eventsExt,vector<DemuxFilterEvent> & res)1061 void TunerHidlFilter::FilterCallback::getTsRecordEvent(
1062 const vector<HidlDemuxFilterEvent::Event>& events,
1063 const vector<HidlDemuxFilterEventExt::Event>& eventsExt, vector<DemuxFilterEvent>& res) {
1064 for (int i = 0; i < events.size(); i++) {
1065 DemuxFilterTsRecordEvent tsRecord;
1066 const HidlDemuxFilterTsRecordEvent& tsRecordEvent = events[i].tsRecord();
1067
1068 DemuxFilterScIndexMask scIndexMask;
1069 if (tsRecordEvent.scIndexMask.getDiscriminator() ==
1070 HidlDemuxFilterTsRecordEvent::ScIndexMask::hidl_discriminator::sc) {
1071 int32_t hidlScIndex = static_cast<int32_t>(tsRecordEvent.scIndexMask.sc());
1072 if (hidlScIndex <= static_cast<int32_t>(DemuxScIndex::SEQUENCE)) {
1073 scIndexMask.set<DemuxFilterScIndexMask::scIndex>(hidlScIndex);
1074 } else {
1075 // HIDL HAL starting from 1 << 4; AIDL starting from 1 << 0.
1076 scIndexMask.set<DemuxFilterScIndexMask::scAvc>(hidlScIndex >> 4);
1077 }
1078 } else if (tsRecordEvent.scIndexMask.getDiscriminator() ==
1079 HidlDemuxFilterTsRecordEvent::ScIndexMask::hidl_discriminator::scHevc) {
1080 scIndexMask.set<DemuxFilterScIndexMask::scHevc>(
1081 static_cast<int32_t>(tsRecordEvent.scIndexMask.scHevc()));
1082 }
1083
1084 if (tsRecordEvent.pid.getDiscriminator() == HidlDemuxPid::hidl_discriminator::tPid) {
1085 DemuxPid pid;
1086 pid.set<DemuxPid::tPid>(static_cast<int32_t>(tsRecordEvent.pid.tPid()));
1087 tsRecord.pid = pid;
1088 } else {
1089 DemuxPid pid;
1090 pid.set<DemuxPid::tPid>(static_cast<int32_t>(Constant::INVALID_TS_PID));
1091 tsRecord.pid = pid;
1092 }
1093
1094 tsRecord.scIndexMask = scIndexMask;
1095 tsRecord.tsIndexMask = static_cast<int32_t>(tsRecordEvent.tsIndexMask);
1096 tsRecord.byteNumber = static_cast<int64_t>(tsRecordEvent.byteNumber);
1097
1098 if (eventsExt.size() > i &&
1099 eventsExt[i].getDiscriminator() ==
1100 HidlDemuxFilterEventExt::Event::hidl_discriminator::tsRecord) {
1101 tsRecord.pts = static_cast<int64_t>(eventsExt[i].tsRecord().pts);
1102 tsRecord.firstMbInSlice = static_cast<int32_t>(eventsExt[i].tsRecord().firstMbInSlice);
1103 }
1104
1105 DemuxFilterEvent filterEvent;
1106 filterEvent.set<DemuxFilterEvent::tsRecord>(std::move(tsRecord));
1107 res.push_back(std::move(filterEvent));
1108 }
1109 }
1110
getMmtpRecordEvent(const vector<HidlDemuxFilterEvent::Event> & events,const vector<HidlDemuxFilterEventExt::Event> & eventsExt,vector<DemuxFilterEvent> & res)1111 void TunerHidlFilter::FilterCallback::getMmtpRecordEvent(
1112 const vector<HidlDemuxFilterEvent::Event>& events,
1113 const vector<HidlDemuxFilterEventExt::Event>& eventsExt, vector<DemuxFilterEvent>& res) {
1114 for (int i = 0; i < events.size(); i++) {
1115 DemuxFilterMmtpRecordEvent mmtpRecord;
1116 const HidlDemuxFilterMmtpRecordEvent& mmtpRecordEvent = events[i].mmtpRecord();
1117
1118 mmtpRecord.scHevcIndexMask = static_cast<int32_t>(mmtpRecordEvent.scHevcIndexMask);
1119 mmtpRecord.byteNumber = static_cast<int64_t>(mmtpRecordEvent.byteNumber);
1120
1121 if (eventsExt.size() > i &&
1122 eventsExt[i].getDiscriminator() ==
1123 HidlDemuxFilterEventExt::Event::hidl_discriminator::mmtpRecord) {
1124 mmtpRecord.pts = static_cast<int64_t>(eventsExt[i].mmtpRecord().pts);
1125 mmtpRecord.mpuSequenceNumber =
1126 static_cast<int32_t>(eventsExt[i].mmtpRecord().mpuSequenceNumber);
1127 mmtpRecord.firstMbInSlice =
1128 static_cast<int32_t>(eventsExt[i].mmtpRecord().firstMbInSlice);
1129 mmtpRecord.tsIndexMask = static_cast<int32_t>(eventsExt[i].mmtpRecord().tsIndexMask);
1130 }
1131
1132 DemuxFilterEvent filterEvent;
1133 filterEvent.set<DemuxFilterEvent::mmtpRecord>(std::move(mmtpRecord));
1134 res.push_back(std::move(filterEvent));
1135 }
1136 }
1137
getDownloadEvent(const vector<HidlDemuxFilterEvent::Event> & events,vector<DemuxFilterEvent> & res)1138 void TunerHidlFilter::FilterCallback::getDownloadEvent(
1139 const vector<HidlDemuxFilterEvent::Event>& events, vector<DemuxFilterEvent>& res) {
1140 for (int i = 0; i < events.size(); i++) {
1141 const HidlDemuxFilterDownloadEvent& downloadEvent = events[i].download();
1142 DemuxFilterDownloadEvent download;
1143
1144 download.itemId = static_cast<int32_t>(downloadEvent.itemId);
1145 download.downloadId = -1;
1146 download.itemFragmentIndex = static_cast<int32_t>(downloadEvent.itemFragmentIndex);
1147 download.mpuSequenceNumber = static_cast<int32_t>(downloadEvent.mpuSequenceNumber);
1148 download.lastItemFragmentIndex = static_cast<int32_t>(downloadEvent.lastItemFragmentIndex);
1149 download.dataLength = static_cast<int32_t>(downloadEvent.dataLength);
1150
1151 DemuxFilterEvent filterEvent;
1152 filterEvent.set<DemuxFilterEvent::download>(std::move(download));
1153 res.push_back(std::move(filterEvent));
1154 }
1155 }
1156
getIpPayloadEvent(const vector<HidlDemuxFilterEvent::Event> & events,vector<DemuxFilterEvent> & res)1157 void TunerHidlFilter::FilterCallback::getIpPayloadEvent(
1158 const vector<HidlDemuxFilterEvent::Event>& events, vector<DemuxFilterEvent>& res) {
1159 for (int i = 0; i < events.size(); i++) {
1160 const HidlDemuxFilterIpPayloadEvent& ipPayloadEvent = events[i].ipPayload();
1161 DemuxFilterIpPayloadEvent ipPayload;
1162
1163 ipPayload.dataLength = static_cast<int32_t>(ipPayloadEvent.dataLength);
1164
1165 DemuxFilterEvent filterEvent;
1166 filterEvent.set<DemuxFilterEvent::ipPayload>(std::move(ipPayload));
1167 res.push_back(std::move(filterEvent));
1168 }
1169 }
1170
getTemiEvent(const vector<HidlDemuxFilterEvent::Event> & events,vector<DemuxFilterEvent> & res)1171 void TunerHidlFilter::FilterCallback::getTemiEvent(
1172 const vector<HidlDemuxFilterEvent::Event>& events, vector<DemuxFilterEvent>& res) {
1173 for (int i = 0; i < events.size(); i++) {
1174 const HidlDemuxFilterTemiEvent& temiEvent = events[i].temi();
1175 DemuxFilterTemiEvent temi;
1176
1177 temi.pts = static_cast<int64_t>(temiEvent.pts);
1178 temi.descrTag = static_cast<int8_t>(temiEvent.descrTag);
1179 vector<uint8_t> descrData = temiEvent.descrData;
1180 temi.descrData.resize(descrData.size());
1181 copy(descrData.begin(), descrData.end(), temi.descrData.begin());
1182
1183 DemuxFilterEvent filterEvent;
1184 filterEvent.set<DemuxFilterEvent::temi>(std::move(temi));
1185 res.push_back(std::move(filterEvent));
1186 }
1187 }
1188
getMonitorEvent(const vector<HidlDemuxFilterEventExt::Event> & eventsExt,vector<DemuxFilterEvent> & res)1189 void TunerHidlFilter::FilterCallback::getMonitorEvent(
1190 const vector<HidlDemuxFilterEventExt::Event>& eventsExt, vector<DemuxFilterEvent>& res) {
1191 HidlDemuxFilterMonitorEvent monitorEvent = eventsExt[0].monitorEvent();
1192 DemuxFilterMonitorEvent monitor;
1193
1194 switch (monitorEvent.getDiscriminator()) {
1195 case HidlDemuxFilterMonitorEvent::hidl_discriminator::scramblingStatus: {
1196 monitor.set<DemuxFilterMonitorEvent::scramblingStatus>(
1197 static_cast<ScramblingStatus>(monitorEvent.scramblingStatus()));
1198 break;
1199 }
1200 case HidlDemuxFilterMonitorEvent::hidl_discriminator::cid: {
1201 monitor.set<DemuxFilterMonitorEvent::cid>(static_cast<int32_t>(monitorEvent.cid()));
1202 break;
1203 }
1204 }
1205
1206 DemuxFilterEvent filterEvent;
1207 filterEvent.set<DemuxFilterEvent::monitorEvent>(std::move(monitor));
1208 res.push_back(std::move(filterEvent));
1209 }
1210
getRestartEvent(const vector<HidlDemuxFilterEventExt::Event> & eventsExt,vector<DemuxFilterEvent> & res)1211 void TunerHidlFilter::FilterCallback::getRestartEvent(
1212 const vector<HidlDemuxFilterEventExt::Event>& eventsExt, vector<DemuxFilterEvent>& res) {
1213 DemuxFilterEvent filterEvent;
1214 filterEvent.set<DemuxFilterEvent::startId>(static_cast<int32_t>(eventsExt[0].startId()));
1215 res.push_back(std::move(filterEvent));
1216 }
1217
1218 } // namespace tuner
1219 } // namespace tv
1220 } // namespace media
1221 } // namespace android
1222 } // namespace aidl
1223