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