| /* |
| * Copyright 2020 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #define LOG_TAG "TunerClient" |
| |
| #include <android/binder_manager.h> |
| #include <android-base/logging.h> |
| #include <utils/Log.h> |
| |
| #include "TunerClient.h" |
| |
| using ::aidl::android::media::tv::tuner::TunerFrontendCapabilities; |
| using ::aidl::android::media::tv::tuner::TunerFrontendDtmbCapabilities; |
| using ::android::hardware::tv::tuner::V1_0::FrontendId; |
| using ::android::hardware::tv::tuner::V1_0::FrontendStatusType; |
| using ::android::hardware::tv::tuner::V1_0::FrontendType; |
| |
| namespace android { |
| |
| sp<ITuner> TunerClient::mTuner; |
| sp<::android::hardware::tv::tuner::V1_1::ITuner> TunerClient::mTuner_1_1; |
| shared_ptr<ITunerService> TunerClient::mTunerService; |
| int TunerClient::mTunerVersion; |
| |
| /////////////// TunerClient /////////////////////// |
| |
| TunerClient::TunerClient() { |
| // Get HIDL Tuner in migration stage. |
| getHidlTuner(); |
| if (mTuner != NULL) { |
| updateTunerResources(); |
| } |
| // Connect with Tuner Service. |
| ::ndk::SpAIBinder binder(AServiceManager_getService("media.tuner")); |
| mTunerService = ITunerService::fromBinder(binder); |
| if (mTunerService == NULL) { |
| ALOGE("Failed to get tuner service"); |
| } else { |
| mTunerService->getTunerHalVersion(&mTunerVersion); |
| } |
| } |
| |
| TunerClient::~TunerClient() { |
| mTuner = NULL; |
| mTuner_1_1 = NULL; |
| mTunerVersion = 0; |
| mTunerService = NULL; |
| } |
| |
| vector<FrontendId> TunerClient::getFrontendIds() { |
| vector<FrontendId> ids; |
| |
| if (mTunerService != NULL) { |
| vector<int32_t> v; |
| Status s = mTunerService->getFrontendIds(&v); |
| if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS || v.size() == 0) { |
| ids.clear(); |
| return ids; |
| } |
| for (int32_t id : v) { |
| ids.push_back(static_cast<FrontendId>(id)); |
| } |
| return ids; |
| } |
| |
| if (mTuner != NULL) { |
| Result res; |
| mTuner->getFrontendIds([&](Result r, const hardware::hidl_vec<FrontendId>& frontendIds) { |
| res = r; |
| ids = frontendIds; |
| }); |
| if (res != Result::SUCCESS || ids.size() == 0) { |
| ALOGW("Frontend ids not available"); |
| ids.clear(); |
| return ids; |
| } |
| return ids; |
| } |
| |
| return ids; |
| } |
| |
| |
| sp<FrontendClient> TunerClient::openFrontend(int frontendHandle) { |
| if (mTunerService != NULL) { |
| shared_ptr<ITunerFrontend> tunerFrontend; |
| Status s = mTunerService->openFrontend(frontendHandle, &tunerFrontend); |
| if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS |
| || tunerFrontend == NULL) { |
| return NULL; |
| } |
| int id; |
| s = tunerFrontend->getFrontendId(&id); |
| if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS) { |
| return NULL; |
| } |
| TunerFrontendInfo aidlFrontendInfo; |
| s = mTunerService->getFrontendInfo(id, &aidlFrontendInfo); |
| if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS) { |
| return NULL; |
| } |
| return new FrontendClient(tunerFrontend, aidlFrontendInfo.type); |
| } |
| |
| if (mTuner != NULL) { |
| int id = getResourceIdFromHandle(frontendHandle, FRONTEND); |
| sp<IFrontend> hidlFrontend = openHidlFrontendById(id); |
| if (hidlFrontend != NULL) { |
| FrontendInfo hidlInfo; |
| Result res = getHidlFrontendInfo(id, hidlInfo); |
| if (res != Result::SUCCESS) { |
| return NULL; |
| } |
| sp<FrontendClient> frontendClient = new FrontendClient( |
| NULL, (int)hidlInfo.type); |
| frontendClient->setHidlFrontend(hidlFrontend); |
| frontendClient->setId(id); |
| return frontendClient; |
| } |
| } |
| |
| return NULL; |
| } |
| |
| shared_ptr<FrontendInfo> TunerClient::getFrontendInfo(int id) { |
| if (mTunerService != NULL) { |
| TunerFrontendInfo aidlFrontendInfo; |
| Status s = mTunerService->getFrontendInfo(id, &aidlFrontendInfo); |
| if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS) { |
| return NULL; |
| } |
| return make_shared<FrontendInfo>(frontendInfoAidlToHidl(aidlFrontendInfo)); |
| } |
| |
| if (mTuner != NULL) { |
| FrontendInfo hidlInfo; |
| Result res = getHidlFrontendInfo(id, hidlInfo); |
| if (res != Result::SUCCESS) { |
| return NULL; |
| } |
| return make_shared<FrontendInfo>(hidlInfo); |
| } |
| |
| return NULL; |
| } |
| |
| shared_ptr<FrontendDtmbCapabilities> TunerClient::getFrontendDtmbCapabilities(int id) { |
| if (mTunerService != NULL) { |
| TunerFrontendDtmbCapabilities dtmbCaps; |
| Status s = mTunerService->getFrontendDtmbCapabilities(id, &dtmbCaps); |
| if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS) { |
| return NULL; |
| } |
| FrontendDtmbCapabilities hidlCaps{ |
| .transmissionModeCap = static_cast<uint32_t>(dtmbCaps.transmissionModeCap), |
| .bandwidthCap = static_cast<uint32_t>(dtmbCaps.bandwidthCap), |
| .modulationCap = static_cast<uint32_t>(dtmbCaps.modulationCap), |
| .codeRateCap = static_cast<uint32_t>(dtmbCaps.codeRateCap), |
| .guardIntervalCap = static_cast<uint32_t>(dtmbCaps.guardIntervalCap), |
| .interleaveModeCap = static_cast<uint32_t>(dtmbCaps.interleaveModeCap), |
| }; |
| return make_shared<FrontendDtmbCapabilities>(hidlCaps); |
| } |
| |
| if (mTuner_1_1 != NULL) { |
| Result result; |
| FrontendDtmbCapabilities dtmbCaps; |
| mTuner_1_1->getFrontendDtmbCapabilities(id, |
| [&](Result r, const FrontendDtmbCapabilities& caps) { |
| dtmbCaps = caps; |
| result = r; |
| }); |
| if (result == Result::SUCCESS) { |
| return make_shared<FrontendDtmbCapabilities>(dtmbCaps); |
| } |
| } |
| |
| return NULL; |
| } |
| |
| sp<DemuxClient> TunerClient::openDemux(int demuxHandle) { |
| if (mTunerService != NULL) { |
| shared_ptr<ITunerDemux> tunerDemux; |
| Status s = mTunerService->openDemux(demuxHandle, &tunerDemux); |
| if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS) { |
| return NULL; |
| } |
| return new DemuxClient(tunerDemux); |
| } |
| |
| if (mTuner != NULL) { |
| sp<DemuxClient> demuxClient = new DemuxClient(NULL); |
| int demuxId; |
| sp<IDemux> hidlDemux = openHidlDemux(demuxId); |
| if (hidlDemux != NULL) { |
| demuxClient->setHidlDemux(hidlDemux); |
| demuxClient->setId(demuxId); |
| return demuxClient; |
| } |
| } |
| |
| return NULL; |
| } |
| |
| shared_ptr<DemuxCapabilities> TunerClient::getDemuxCaps() { |
| if (mTunerService != NULL) { |
| TunerDemuxCapabilities aidlCaps; |
| Status s = mTunerService->getDemuxCaps(&aidlCaps); |
| if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS) { |
| return NULL; |
| } |
| return make_shared<DemuxCapabilities>(getHidlDemuxCaps(aidlCaps)); |
| } |
| |
| if (mTuner != NULL) { |
| Result res; |
| DemuxCapabilities caps; |
| mTuner->getDemuxCaps([&](Result r, const DemuxCapabilities& demuxCaps) { |
| caps = demuxCaps; |
| res = r; |
| }); |
| if (res == Result::SUCCESS) { |
| return make_shared<DemuxCapabilities>(caps); |
| } |
| } |
| |
| return NULL; |
| } |
| |
| sp<DescramblerClient> TunerClient::openDescrambler(int descramblerHandle) { |
| if (mTunerService != NULL) { |
| shared_ptr<ITunerDescrambler> tunerDescrambler; |
| Status s = mTunerService->openDescrambler(descramblerHandle, &tunerDescrambler); |
| if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS) { |
| return NULL; |
| } |
| return new DescramblerClient(tunerDescrambler); |
| } |
| |
| if (mTuner != NULL) { |
| sp<DescramblerClient> descramblerClient = new DescramblerClient(NULL); |
| sp<IDescrambler> hidlDescrambler = openHidlDescrambler(); |
| if (hidlDescrambler != NULL) { |
| descramblerClient->setHidlDescrambler(hidlDescrambler); |
| return descramblerClient; |
| } |
| } |
| |
| return NULL; |
| } |
| |
| sp<LnbClient> TunerClient::openLnb(int lnbHandle) { |
| if (mTunerService != NULL) { |
| shared_ptr<ITunerLnb> tunerLnb; |
| Status s = mTunerService->openLnb(lnbHandle, &tunerLnb); |
| if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS) { |
| return NULL; |
| } |
| return new LnbClient(tunerLnb); |
| } |
| |
| if (mTuner != NULL) { |
| int id = getResourceIdFromHandle(lnbHandle, LNB); |
| sp<LnbClient> lnbClient = new LnbClient(NULL); |
| sp<ILnb> hidlLnb = openHidlLnbById(id); |
| if (hidlLnb != NULL) { |
| lnbClient->setHidlLnb(hidlLnb); |
| lnbClient->setId(id); |
| return lnbClient; |
| } |
| } |
| |
| return NULL; |
| } |
| |
| sp<LnbClient> TunerClient::openLnbByName(string lnbName) { |
| if (mTunerService != NULL) { |
| shared_ptr<ITunerLnb> tunerLnb; |
| Status s = mTunerService->openLnbByName(lnbName, &tunerLnb); |
| if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS) { |
| return NULL; |
| } |
| return new LnbClient(tunerLnb); |
| } |
| |
| if (mTuner != NULL) { |
| sp<LnbClient> lnbClient = new LnbClient(NULL); |
| LnbId id; |
| sp<ILnb> hidlLnb = openHidlLnbByName(lnbName, id); |
| if (hidlLnb != NULL) { |
| lnbClient->setHidlLnb(hidlLnb); |
| lnbClient->setId(id); |
| return lnbClient; |
| } |
| } |
| |
| return NULL; |
| } |
| |
| /////////////// TunerClient Helper Methods /////////////////////// |
| |
| void TunerClient::updateTunerResources() { |
| if (mTuner == NULL) { |
| return; |
| } |
| |
| // Connect with Tuner Resource Manager. |
| ::ndk::SpAIBinder binder(AServiceManager_getService("tv_tuner_resource_mgr")); |
| mTunerResourceManager = ITunerResourceManager::fromBinder(binder); |
| |
| updateFrontendResources(); |
| updateLnbResources(); |
| // TODO: update Demux, Descrambler. |
| } |
| |
| // TODO: remove after migration to Tuner Service is done. |
| void TunerClient::updateFrontendResources() { |
| vector<FrontendId> ids = getFrontendIds(); |
| if (ids.size() == 0) { |
| return; |
| } |
| vector<TunerFrontendInfo> infos; |
| for (int i = 0; i < ids.size(); i++) { |
| shared_ptr<FrontendInfo> frontendInfo = getFrontendInfo((int)ids[i]); |
| if (frontendInfo == NULL) { |
| continue; |
| } |
| TunerFrontendInfo tunerFrontendInfo{ |
| .handle = getResourceHandleFromId((int)ids[i], FRONTEND), |
| .type = static_cast<int>(frontendInfo->type), |
| .exclusiveGroupId = static_cast<int>(frontendInfo->exclusiveGroupId), |
| }; |
| infos.push_back(tunerFrontendInfo); |
| } |
| mTunerResourceManager->setFrontendInfoList(infos); |
| } |
| |
| void TunerClient::updateLnbResources() { |
| vector<int> handles = getLnbHandles(); |
| if (handles.size() == 0) { |
| return; |
| } |
| mTunerResourceManager->setLnbInfoList(handles); |
| } |
| |
| sp<ITuner> TunerClient::getHidlTuner() { |
| if (mTuner == NULL) { |
| mTunerVersion = TUNER_HAL_VERSION_UNKNOWN; |
| mTuner_1_1 = ::android::hardware::tv::tuner::V1_1::ITuner::getService(); |
| |
| if (mTuner_1_1 == NULL) { |
| ALOGW("Failed to get tuner 1.1 service."); |
| mTuner = ITuner::getService(); |
| if (mTuner == NULL) { |
| ALOGW("Failed to get tuner 1.0 service."); |
| } else { |
| mTunerVersion = TUNER_HAL_VERSION_1_0; |
| } |
| } else { |
| mTuner = static_cast<sp<ITuner>>(mTuner_1_1); |
| mTunerVersion = TUNER_HAL_VERSION_1_1; |
| } |
| } |
| return mTuner; |
| } |
| |
| sp<IFrontend> TunerClient::openHidlFrontendById(int id) { |
| sp<IFrontend> fe; |
| Result res; |
| mTuner->openFrontendById(id, [&](Result r, const sp<IFrontend>& frontend) { |
| fe = frontend; |
| res = r; |
| }); |
| if (res != Result::SUCCESS || fe == nullptr) { |
| ALOGE("Failed to open frontend"); |
| return NULL; |
| } |
| return fe; |
| } |
| |
| Result TunerClient::getHidlFrontendInfo(int id, FrontendInfo& feInfo) { |
| Result res; |
| mTuner->getFrontendInfo(id, [&](Result r, const FrontendInfo& info) { |
| feInfo = info; |
| res = r; |
| }); |
| return res; |
| } |
| |
| sp<IDemux> TunerClient::openHidlDemux(int& demuxId) { |
| sp<IDemux> demux; |
| Result res; |
| |
| mTuner->openDemux([&](Result result, uint32_t id, const sp<IDemux>& demuxSp) { |
| demux = demuxSp; |
| demuxId = id; |
| res = result; |
| }); |
| if (res != Result::SUCCESS || demux == nullptr) { |
| ALOGE("Failed to open demux"); |
| return NULL; |
| } |
| return demux; |
| } |
| |
| sp<ILnb> TunerClient::openHidlLnbById(int id) { |
| sp<ILnb> lnb; |
| Result res; |
| |
| mTuner->openLnbById(id, [&](Result r, const sp<ILnb>& lnbSp) { |
| res = r; |
| lnb = lnbSp; |
| }); |
| if (res != Result::SUCCESS || lnb == nullptr) { |
| ALOGE("Failed to open lnb by id"); |
| return NULL; |
| } |
| return lnb; |
| } |
| |
| sp<ILnb> TunerClient::openHidlLnbByName(string name, LnbId& lnbId) { |
| sp<ILnb> lnb; |
| Result res; |
| |
| mTuner->openLnbByName(name, [&](Result r, LnbId id, const sp<ILnb>& lnbSp) { |
| res = r; |
| lnb = lnbSp; |
| lnbId = id; |
| }); |
| if (res != Result::SUCCESS || lnb == nullptr) { |
| ALOGE("Failed to open lnb by name"); |
| return NULL; |
| } |
| return lnb; |
| } |
| |
| // TODO: remove after migration to Tuner Service is done. |
| vector<int> TunerClient::getLnbHandles() { |
| vector<int> lnbHandles; |
| if (mTuner != NULL) { |
| Result res; |
| vector<LnbId> lnbIds; |
| mTuner->getLnbIds([&](Result r, const hardware::hidl_vec<LnbId>& ids) { |
| lnbIds = ids; |
| res = r; |
| }); |
| if (res != Result::SUCCESS || lnbIds.size() == 0) { |
| ALOGW("Lnb isn't available"); |
| } else { |
| for (int i = 0; i < lnbIds.size(); i++) { |
| lnbHandles.push_back(getResourceHandleFromId((int)lnbIds[i], LNB)); |
| } |
| } |
| } |
| |
| return lnbHandles; |
| } |
| |
| sp<IDescrambler> TunerClient::openHidlDescrambler() { |
| sp<IDescrambler> descrambler; |
| Result res; |
| |
| mTuner->openDescrambler([&](Result r, const sp<IDescrambler>& descramblerSp) { |
| res = r; |
| descrambler = descramblerSp; |
| }); |
| |
| if (res != Result::SUCCESS || descrambler == NULL) { |
| return NULL; |
| } |
| |
| return descrambler; |
| } |
| |
| DemuxCapabilities TunerClient::getHidlDemuxCaps(TunerDemuxCapabilities& aidlCaps) { |
| DemuxCapabilities caps{ |
| .numDemux = (uint32_t)aidlCaps.numDemux, |
| .numRecord = (uint32_t)aidlCaps.numRecord, |
| .numPlayback = (uint32_t)aidlCaps.numPlayback, |
| .numTsFilter = (uint32_t)aidlCaps.numTsFilter, |
| .numSectionFilter = (uint32_t)aidlCaps.numSectionFilter, |
| .numAudioFilter = (uint32_t)aidlCaps.numAudioFilter, |
| .numVideoFilter = (uint32_t)aidlCaps.numVideoFilter, |
| .numPesFilter = (uint32_t)aidlCaps.numPesFilter, |
| .numPcrFilter = (uint32_t)aidlCaps.numPcrFilter, |
| .numBytesInSectionFilter = (uint32_t)aidlCaps.numBytesInSectionFilter, |
| .filterCaps = (uint32_t)aidlCaps.filterCaps, |
| .bTimeFilter = aidlCaps.bTimeFilter, |
| }; |
| caps.linkCaps.resize(aidlCaps.linkCaps.size()); |
| copy(aidlCaps.linkCaps.begin(), aidlCaps.linkCaps.end(), caps.linkCaps.begin()); |
| return caps; |
| } |
| |
| FrontendInfo TunerClient::frontendInfoAidlToHidl(TunerFrontendInfo aidlFrontendInfo) { |
| FrontendInfo hidlFrontendInfo { |
| .type = static_cast<FrontendType>(aidlFrontendInfo.type), |
| .minFrequency = static_cast<uint32_t>(aidlFrontendInfo.minFrequency), |
| .maxFrequency = static_cast<uint32_t>(aidlFrontendInfo.maxFrequency), |
| .minSymbolRate = static_cast<uint32_t>(aidlFrontendInfo.minSymbolRate), |
| .maxSymbolRate = static_cast<uint32_t>(aidlFrontendInfo.maxSymbolRate), |
| .acquireRange = static_cast<uint32_t>(aidlFrontendInfo.acquireRange), |
| .exclusiveGroupId = static_cast<uint32_t>(aidlFrontendInfo.exclusiveGroupId), |
| }; |
| |
| int size = aidlFrontendInfo.statusCaps.size(); |
| hidlFrontendInfo.statusCaps.resize(size); |
| for (int i = 0; i < size; i++) { |
| hidlFrontendInfo.statusCaps[i] = |
| static_cast<FrontendStatusType>(aidlFrontendInfo.statusCaps[i]); |
| } |
| |
| switch (aidlFrontendInfo.caps.getTag()) { |
| case TunerFrontendCapabilities::analogCaps: { |
| auto analog = aidlFrontendInfo.caps.get<TunerFrontendCapabilities::analogCaps>(); |
| hidlFrontendInfo.frontendCaps.analogCaps({ |
| .typeCap = static_cast<uint32_t>(analog.typeCap), |
| .sifStandardCap = static_cast<uint32_t>(analog.sifStandardCap), |
| }); |
| break; |
| } |
| case TunerFrontendCapabilities::atscCaps: { |
| auto atsc = aidlFrontendInfo.caps.get<TunerFrontendCapabilities::atscCaps>(); |
| hidlFrontendInfo.frontendCaps.atscCaps({ |
| .modulationCap = static_cast<uint32_t>(atsc.modulationCap), |
| }); |
| break; |
| } |
| case TunerFrontendCapabilities::atsc3Caps: { |
| auto atsc3 = aidlFrontendInfo.caps.get<TunerFrontendCapabilities::atsc3Caps>(); |
| hidlFrontendInfo.frontendCaps.atsc3Caps({ |
| .bandwidthCap = static_cast<uint32_t>(atsc3.bandwidthCap), |
| .modulationCap = static_cast<uint32_t>(atsc3.modulationCap), |
| .timeInterleaveModeCap = static_cast<uint32_t>(atsc3.timeInterleaveModeCap), |
| .codeRateCap = static_cast<uint32_t>(atsc3.codeRateCap), |
| .fecCap = static_cast<uint32_t>(atsc3.fecCap), |
| .demodOutputFormatCap = static_cast<uint8_t>(atsc3.demodOutputFormatCap), |
| }); |
| break; |
| } |
| case TunerFrontendCapabilities::cableCaps: { |
| auto cable = aidlFrontendInfo.caps.get<TunerFrontendCapabilities::cableCaps>(); |
| hidlFrontendInfo.frontendCaps.dvbcCaps({ |
| .modulationCap = static_cast<uint32_t>(cable.modulationCap), |
| .fecCap = static_cast<uint64_t>(cable.codeRateCap), |
| .annexCap = static_cast<uint8_t>(cable.annexCap), |
| }); |
| break; |
| } |
| case TunerFrontendCapabilities::dvbsCaps: { |
| auto dvbs = aidlFrontendInfo.caps.get<TunerFrontendCapabilities::dvbsCaps>(); |
| hidlFrontendInfo.frontendCaps.dvbsCaps({ |
| .modulationCap = static_cast<int32_t>(dvbs.modulationCap), |
| .innerfecCap = static_cast<uint64_t>(dvbs.codeRateCap), |
| .standard = static_cast<uint8_t>(dvbs.standard), |
| }); |
| break; |
| } |
| case TunerFrontendCapabilities::dvbtCaps: { |
| auto dvbt = aidlFrontendInfo.caps.get<TunerFrontendCapabilities::dvbtCaps>(); |
| hidlFrontendInfo.frontendCaps.dvbtCaps({ |
| .transmissionModeCap = static_cast<uint32_t>(dvbt.transmissionModeCap), |
| .bandwidthCap = static_cast<uint32_t>(dvbt.bandwidthCap), |
| .constellationCap = static_cast<uint32_t>(dvbt.constellationCap), |
| .coderateCap = static_cast<uint32_t>(dvbt.codeRateCap), |
| .hierarchyCap = static_cast<uint32_t>(dvbt.hierarchyCap), |
| .guardIntervalCap = static_cast<uint32_t>(dvbt.guardIntervalCap), |
| .isT2Supported = dvbt.isT2Supported, |
| .isMisoSupported = dvbt.isMisoSupported, |
| }); |
| break; |
| } |
| case TunerFrontendCapabilities::isdbsCaps: { |
| auto isdbs = aidlFrontendInfo.caps.get<TunerFrontendCapabilities::isdbsCaps>(); |
| hidlFrontendInfo.frontendCaps.isdbsCaps({ |
| .modulationCap = static_cast<uint32_t>(isdbs.modulationCap), |
| .coderateCap = static_cast<uint32_t>(isdbs.codeRateCap), |
| }); |
| break; |
| } |
| case TunerFrontendCapabilities::isdbs3Caps: { |
| auto isdbs3 = aidlFrontendInfo.caps.get<TunerFrontendCapabilities::isdbs3Caps>(); |
| hidlFrontendInfo.frontendCaps.isdbs3Caps({ |
| .modulationCap = static_cast<uint32_t>(isdbs3.modulationCap), |
| .coderateCap = static_cast<uint32_t>(isdbs3.codeRateCap), |
| }); |
| break; |
| } |
| case TunerFrontendCapabilities::isdbtCaps: { |
| auto isdbt = aidlFrontendInfo.caps.get<TunerFrontendCapabilities::isdbtCaps>(); |
| hidlFrontendInfo.frontendCaps.isdbtCaps({ |
| .modeCap = static_cast<uint32_t>(isdbt.modeCap), |
| .bandwidthCap = static_cast<uint32_t>(isdbt.bandwidthCap), |
| .modulationCap = static_cast<uint32_t>(isdbt.modulationCap), |
| .coderateCap = static_cast<uint32_t>(isdbt.codeRateCap), |
| .guardIntervalCap = static_cast<uint32_t>(isdbt.guardIntervalCap), |
| }); |
| break; |
| } |
| } |
| return hidlFrontendInfo; |
| } |
| |
| // TODO: remove after migration to Tuner Service is done. |
| int TunerClient::getResourceIdFromHandle(int handle, int /*resourceType*/) { |
| return (handle & 0x00ff0000) >> 16; |
| } |
| |
| // TODO: remove after migration to Tuner Service is done. |
| int TunerClient::getResourceHandleFromId(int id, int resourceType) { |
| return (resourceType & 0x000000ff) << 24 |
| | (id << 16) |
| | (mResourceRequestCount++ & 0xffff); |
| } |
| } // namespace android |
