You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1095 lines
48 KiB
1095 lines
48 KiB
/**
|
|
* 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 "TunerFrontend"
|
|
|
|
#include "TunerFrontend.h"
|
|
#include "TunerLnb.h"
|
|
|
|
using ::aidl::android::media::tv::tuner::TunerFrontendAtsc3PlpSettings;
|
|
using ::aidl::android::media::tv::tuner::TunerFrontendScanAtsc3PlpInfo;
|
|
using ::aidl::android::media::tv::tuner::TunerFrontendStatusAtsc3PlpInfo;
|
|
using ::aidl::android::media::tv::tuner::TunerFrontendUnionSettings;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendAnalogSifStandard;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendAnalogType;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendAtscModulation;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendAtsc3Bandwidth;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendAtsc3CodeRate;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendAtsc3DemodOutputFormat;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendAtsc3Fec;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendAtsc3Modulation;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendAtsc3TimeInterleaveMode;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendDvbcAnnex;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendDvbcModulation;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendDvbcOuterFec;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendDvbcSpectralInversion;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendDvbsModulation;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendDvbsPilot;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendDvbsRolloff;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendDvbsSettings;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendDvbsStandard;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendDvbsVcmMode;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendDvbtBandwidth;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendDvbtCoderate;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendDvbtConstellation;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendDvbtGuardInterval;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendDvbtHierarchy;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendDvbtPlpMode;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendDvbtSettings;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendDvbtStandard;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendDvbtTransmissionMode;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendInnerFec;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbs3Coderate;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbs3Modulation;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbs3Rolloff;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbs3Settings;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbsCoderate;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbsModulation;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbsRolloff;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbsSettings;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbsStreamIdType;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbtBandwidth;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbtCoderate;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbtGuardInterval;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbtMode;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbtModulation;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbtSettings;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendModulationStatus;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendScanAtsc3PlpInfo;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendScanType;
|
|
using ::android::hardware::tv::tuner::V1_0::FrontendStatusType;
|
|
using ::android::hardware::tv::tuner::V1_0::Result;
|
|
using ::android::hardware::tv::tuner::V1_1::FrontendAnalogAftFlag;
|
|
using ::android::hardware::tv::tuner::V1_1::FrontendBandwidth;
|
|
using ::android::hardware::tv::tuner::V1_1::FrontendCableTimeInterleaveMode;
|
|
using ::android::hardware::tv::tuner::V1_1::FrontendDvbcBandwidth;
|
|
using ::android::hardware::tv::tuner::V1_1::FrontendDtmbBandwidth;
|
|
using ::android::hardware::tv::tuner::V1_1::FrontendDtmbCodeRate;
|
|
using ::android::hardware::tv::tuner::V1_1::FrontendDtmbGuardInterval;
|
|
using ::android::hardware::tv::tuner::V1_1::FrontendDtmbModulation;
|
|
using ::android::hardware::tv::tuner::V1_1::FrontendDtmbTimeInterleaveMode;
|
|
using ::android::hardware::tv::tuner::V1_1::FrontendDtmbTransmissionMode;
|
|
using ::android::hardware::tv::tuner::V1_1::FrontendDvbsScanType;
|
|
using ::android::hardware::tv::tuner::V1_1::FrontendGuardInterval;
|
|
using ::android::hardware::tv::tuner::V1_1::FrontendInterleaveMode;
|
|
using ::android::hardware::tv::tuner::V1_1::FrontendModulation;
|
|
using ::android::hardware::tv::tuner::V1_1::FrontendRollOff;
|
|
using ::android::hardware::tv::tuner::V1_1::FrontendTransmissionMode;
|
|
using ::android::hardware::tv::tuner::V1_1::FrontendSpectralInversion;
|
|
using ::android::hardware::tv::tuner::V1_1::FrontendStatusTypeExt1_1;
|
|
|
|
namespace android {
|
|
|
|
TunerFrontend::TunerFrontend(sp<IFrontend> frontend, int id) {
|
|
mFrontend = frontend;
|
|
mFrontend_1_1 = ::android::hardware::tv::tuner::V1_1::IFrontend::castFrom(mFrontend);
|
|
mId = id;
|
|
}
|
|
|
|
TunerFrontend::~TunerFrontend() {
|
|
mFrontend = NULL;
|
|
mFrontend_1_1 = NULL;
|
|
mId = -1;
|
|
}
|
|
|
|
Status TunerFrontend::setCallback(
|
|
const shared_ptr<ITunerFrontendCallback>& tunerFrontendCallback) {
|
|
if (mFrontend == NULL) {
|
|
ALOGE("IFrontend is not initialized");
|
|
return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
|
|
}
|
|
|
|
if (tunerFrontendCallback == NULL) {
|
|
return Status::fromServiceSpecificError(static_cast<int32_t>(Result::INVALID_ARGUMENT));
|
|
}
|
|
|
|
sp<IFrontendCallback> frontendCallback = new FrontendCallback(tunerFrontendCallback);
|
|
Result status = mFrontend->setCallback(frontendCallback);
|
|
if (status == Result::SUCCESS) {
|
|
return Status::ok();
|
|
}
|
|
|
|
return Status::fromServiceSpecificError(static_cast<int32_t>(status));
|
|
}
|
|
|
|
Status TunerFrontend::tune(const TunerFrontendSettings& settings) {
|
|
if (mFrontend == NULL) {
|
|
ALOGE("IFrontend is not initialized");
|
|
return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
|
|
}
|
|
|
|
Result status;
|
|
FrontendSettings frontendSettings = getHidlFrontendSettings(settings);
|
|
if (settings.isExtended) {
|
|
if (mFrontend_1_1 == NULL) {
|
|
ALOGE("IFrontend_1_1 is not initialized");
|
|
return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
|
|
}
|
|
FrontendSettingsExt1_1 frontendSettingsExt = getHidlFrontendSettingsExt(settings);
|
|
status = mFrontend_1_1->tune_1_1(frontendSettings, frontendSettingsExt);
|
|
} else {
|
|
status = mFrontend->tune(frontendSettings);
|
|
}
|
|
|
|
if (status == Result::SUCCESS) {
|
|
return Status::ok();
|
|
}
|
|
|
|
return Status::fromServiceSpecificError(static_cast<int32_t>(status));
|
|
}
|
|
|
|
Status TunerFrontend::stopTune() {
|
|
if (mFrontend == NULL) {
|
|
ALOGD("IFrontend is not initialized");
|
|
return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
|
|
}
|
|
|
|
Result status = mFrontend->stopTune();
|
|
if (status == Result::SUCCESS) {
|
|
return Status::ok();
|
|
}
|
|
|
|
return Status::fromServiceSpecificError(static_cast<int32_t>(status));
|
|
}
|
|
|
|
Status TunerFrontend::scan(const TunerFrontendSettings& settings, int frontendScanType) {
|
|
if (mFrontend == NULL) {
|
|
ALOGD("IFrontend is not initialized");
|
|
return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
|
|
}
|
|
|
|
Result status;
|
|
FrontendSettings frontendSettings = getHidlFrontendSettings(settings);
|
|
if (settings.isExtended) {
|
|
if (mFrontend_1_1 == NULL) {
|
|
ALOGE("IFrontend_1_1 is not initialized");
|
|
return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
|
|
}
|
|
FrontendSettingsExt1_1 frontendSettingsExt = getHidlFrontendSettingsExt(settings);
|
|
status = mFrontend_1_1->scan_1_1(frontendSettings,
|
|
static_cast<FrontendScanType>(frontendScanType), frontendSettingsExt);
|
|
} else {
|
|
status = mFrontend->scan(
|
|
frontendSettings, static_cast<FrontendScanType>(frontendScanType));
|
|
}
|
|
|
|
if (status == Result::SUCCESS) {
|
|
return Status::ok();
|
|
}
|
|
|
|
return Status::fromServiceSpecificError(static_cast<int32_t>(status));
|
|
}
|
|
|
|
Status TunerFrontend::stopScan() {
|
|
if (mFrontend == NULL) {
|
|
ALOGD("IFrontend is not initialized");
|
|
return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
|
|
}
|
|
|
|
Result status = mFrontend->stopScan();
|
|
if (status == Result::SUCCESS) {
|
|
return Status::ok();
|
|
}
|
|
|
|
return Status::fromServiceSpecificError(static_cast<int32_t>(status));
|
|
}
|
|
|
|
Status TunerFrontend::setLnb(const shared_ptr<ITunerLnb>& lnb) {
|
|
if (mFrontend == NULL) {
|
|
ALOGD("IFrontend is not initialized");
|
|
return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
|
|
}
|
|
|
|
Result status = mFrontend->setLnb(static_cast<TunerLnb*>(lnb.get())->getId());
|
|
if (status == Result::SUCCESS) {
|
|
return Status::ok();
|
|
}
|
|
|
|
return Status::fromServiceSpecificError(static_cast<int32_t>(status));
|
|
}
|
|
|
|
Status TunerFrontend::setLna(bool bEnable) {
|
|
if (mFrontend == NULL) {
|
|
ALOGD("IFrontend is not initialized");
|
|
return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
|
|
}
|
|
|
|
Result status = mFrontend->setLna(bEnable);
|
|
if (status == Result::SUCCESS) {
|
|
return Status::ok();
|
|
}
|
|
|
|
return Status::fromServiceSpecificError(static_cast<int32_t>(status));
|
|
}
|
|
|
|
Status TunerFrontend::linkCiCamToFrontend(int ciCamId, int32_t* _aidl_return) {
|
|
if (mFrontend_1_1 == NULL) {
|
|
ALOGD("IFrontend_1_1 is not initialized");
|
|
return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
|
|
}
|
|
|
|
int ltsId;
|
|
Result status;
|
|
mFrontend_1_1->linkCiCam(static_cast<uint32_t>(ciCamId),
|
|
[&](Result r, uint32_t id) {
|
|
status = r;
|
|
ltsId = id;
|
|
});
|
|
|
|
if (status == Result::SUCCESS) {
|
|
*_aidl_return = ltsId;
|
|
return Status::ok();
|
|
}
|
|
|
|
return Status::fromServiceSpecificError(static_cast<int32_t>(status));
|
|
}
|
|
|
|
Status TunerFrontend::unlinkCiCamToFrontend(int ciCamId) {
|
|
if (mFrontend_1_1 == NULL) {
|
|
ALOGD("IFrontend_1_1 is not initialized");
|
|
return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
|
|
}
|
|
|
|
Result status = mFrontend_1_1->unlinkCiCam(ciCamId);
|
|
if (status == Result::SUCCESS) {
|
|
return Status::ok();
|
|
}
|
|
|
|
return Status::fromServiceSpecificError(static_cast<int32_t>(status));
|
|
}
|
|
|
|
Status TunerFrontend::close() {
|
|
if (mFrontend == NULL) {
|
|
ALOGD("IFrontend is not initialized");
|
|
return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
|
|
}
|
|
|
|
Result status = mFrontend->close();
|
|
mFrontend = NULL;
|
|
mFrontend_1_1 = NULL;
|
|
|
|
if (status != Result::SUCCESS) {
|
|
return Status::fromServiceSpecificError(static_cast<int32_t>(status));
|
|
}
|
|
return Status::ok();
|
|
}
|
|
|
|
Status TunerFrontend::getStatus(const vector<int32_t>& statusTypes,
|
|
vector<TunerFrontendStatus>* _aidl_return) {
|
|
if (mFrontend == NULL) {
|
|
ALOGD("IFrontend is not initialized");
|
|
return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
|
|
}
|
|
|
|
Result res;
|
|
vector<FrontendStatus> status;
|
|
vector<FrontendStatusType> types;
|
|
for (auto s : statusTypes) {
|
|
types.push_back(static_cast<FrontendStatusType>(s));
|
|
}
|
|
|
|
mFrontend->getStatus(types, [&](Result r, const hidl_vec<FrontendStatus>& s) {
|
|
res = r;
|
|
status = s;
|
|
});
|
|
if (res != Result::SUCCESS) {
|
|
return Status::fromServiceSpecificError(static_cast<int32_t>(res));
|
|
}
|
|
|
|
getAidlFrontendStatus(status, *_aidl_return);
|
|
return Status::ok();
|
|
}
|
|
|
|
Status TunerFrontend::getStatusExtended_1_1(const vector<int32_t>& statusTypes,
|
|
vector<TunerFrontendStatus>* _aidl_return) {
|
|
if (mFrontend_1_1 == NULL) {
|
|
ALOGD("IFrontend_1_1 is not initialized");
|
|
return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
|
|
}
|
|
|
|
Result res;
|
|
vector<FrontendStatusExt1_1> status;
|
|
vector<FrontendStatusTypeExt1_1> types;
|
|
for (auto s : statusTypes) {
|
|
types.push_back(static_cast<FrontendStatusTypeExt1_1>(s));
|
|
}
|
|
|
|
mFrontend_1_1->getStatusExt1_1(types, [&](Result r, const hidl_vec<FrontendStatusExt1_1>& s) {
|
|
res = r;
|
|
status = s;
|
|
});
|
|
if (res != Result::SUCCESS) {
|
|
return Status::fromServiceSpecificError(static_cast<int32_t>(res));
|
|
}
|
|
|
|
getAidlFrontendStatusExt(status, *_aidl_return);
|
|
return Status::ok();
|
|
}
|
|
|
|
Status TunerFrontend::getFrontendId(int* _aidl_return) {
|
|
*_aidl_return = mId;
|
|
return Status::ok();
|
|
}
|
|
|
|
/////////////// FrontendCallback ///////////////////////
|
|
|
|
Return<void> TunerFrontend::FrontendCallback::onEvent(FrontendEventType frontendEventType) {
|
|
ALOGD("FrontendCallback::onEvent, type=%d", frontendEventType);
|
|
mTunerFrontendCallback->onEvent((int)frontendEventType);
|
|
return Void();
|
|
}
|
|
|
|
Return<void> TunerFrontend::FrontendCallback::onScanMessage(
|
|
FrontendScanMessageType type, const FrontendScanMessage& message) {
|
|
ALOGD("FrontendCallback::onScanMessage, type=%d", type);
|
|
TunerFrontendScanMessage scanMessage;
|
|
switch(type) {
|
|
case FrontendScanMessageType::LOCKED: {
|
|
scanMessage.set<TunerFrontendScanMessage::isLocked>(message.isLocked());
|
|
break;
|
|
}
|
|
case FrontendScanMessageType::END: {
|
|
scanMessage.set<TunerFrontendScanMessage::isEnd>(message.isEnd());
|
|
break;
|
|
}
|
|
case FrontendScanMessageType::PROGRESS_PERCENT: {
|
|
scanMessage.set<TunerFrontendScanMessage::progressPercent>(message.progressPercent());
|
|
break;
|
|
}
|
|
case FrontendScanMessageType::FREQUENCY: {
|
|
auto f = message.frequencies();
|
|
vector<int> frequencies(begin(f), end(f));
|
|
scanMessage.set<TunerFrontendScanMessage::frequencies>(frequencies);
|
|
break;
|
|
}
|
|
case FrontendScanMessageType::SYMBOL_RATE: {
|
|
auto s = message.symbolRates();
|
|
vector<int> symbolRates(begin(s), end(s));
|
|
scanMessage.set<TunerFrontendScanMessage::symbolRates>(symbolRates);
|
|
break;
|
|
}
|
|
case FrontendScanMessageType::HIERARCHY: {
|
|
scanMessage.set<TunerFrontendScanMessage::hierarchy>((int)message.hierarchy());
|
|
break;
|
|
}
|
|
case FrontendScanMessageType::ANALOG_TYPE: {
|
|
scanMessage.set<TunerFrontendScanMessage::analogType>((int)message.analogType());
|
|
break;
|
|
}
|
|
case FrontendScanMessageType::PLP_IDS: {
|
|
auto p = message.plpIds();
|
|
vector<uint8_t> plpIds(begin(p), end(p));
|
|
scanMessage.set<TunerFrontendScanMessage::plpIds>(plpIds);
|
|
break;
|
|
}
|
|
case FrontendScanMessageType::GROUP_IDS: {
|
|
auto g = message.groupIds();
|
|
vector<uint8_t> groupIds(begin(g), end(g));
|
|
scanMessage.set<TunerFrontendScanMessage::groupIds>(groupIds);
|
|
break;
|
|
}
|
|
case FrontendScanMessageType::INPUT_STREAM_IDS: {
|
|
auto i = message.inputStreamIds();
|
|
vector<char16_t> streamIds(begin(i), end(i));
|
|
scanMessage.set<TunerFrontendScanMessage::inputStreamIds>(streamIds);
|
|
break;
|
|
}
|
|
case FrontendScanMessageType::STANDARD: {
|
|
FrontendScanMessage::Standard std = message.std();
|
|
int standard;
|
|
if (std.getDiscriminator() == FrontendScanMessage::Standard::hidl_discriminator::sStd) {
|
|
standard = (int) std.sStd();
|
|
} else if (std.getDiscriminator() ==
|
|
FrontendScanMessage::Standard::hidl_discriminator::tStd) {
|
|
standard = (int) std.tStd();
|
|
} else if (std.getDiscriminator() ==
|
|
FrontendScanMessage::Standard::hidl_discriminator::sifStd) {
|
|
standard = (int) std.sifStd();
|
|
}
|
|
scanMessage.set<TunerFrontendScanMessage::std>(standard);
|
|
break;
|
|
}
|
|
case FrontendScanMessageType::ATSC3_PLP_INFO: {
|
|
vector<FrontendScanAtsc3PlpInfo> plpInfos = message.atsc3PlpInfos();
|
|
vector<TunerFrontendScanAtsc3PlpInfo> tunerPlpInfos;
|
|
for (int i = 0; i < plpInfos.size(); i++) {
|
|
auto info = plpInfos[i];
|
|
int8_t plpId = (int8_t) info.plpId;
|
|
bool lls = (bool) info.bLlsFlag;
|
|
TunerFrontendScanAtsc3PlpInfo plpInfo{
|
|
.plpId = plpId,
|
|
.llsFlag = lls,
|
|
};
|
|
tunerPlpInfos.push_back(plpInfo);
|
|
}
|
|
scanMessage.set<TunerFrontendScanMessage::atsc3PlpInfos>(tunerPlpInfos);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
mTunerFrontendCallback->onScanMessage((int)type, scanMessage);
|
|
return Void();
|
|
}
|
|
|
|
Return<void> TunerFrontend::FrontendCallback::onScanMessageExt1_1(
|
|
FrontendScanMessageTypeExt1_1 type, const FrontendScanMessageExt1_1& message) {
|
|
ALOGD("onScanMessageExt1_1::onScanMessage, type=%d", type);
|
|
TunerFrontendScanMessage scanMessage;
|
|
switch(type) {
|
|
case FrontendScanMessageTypeExt1_1::MODULATION: {
|
|
FrontendModulation m = message.modulation();
|
|
int modulation;
|
|
switch (m.getDiscriminator()) {
|
|
case FrontendModulation::hidl_discriminator::dvbc:
|
|
modulation = (int) m.dvbc();
|
|
break;
|
|
case FrontendModulation::hidl_discriminator::dvbt:
|
|
modulation = (int) m.dvbt();
|
|
break;
|
|
case FrontendModulation::hidl_discriminator::dvbs:
|
|
modulation = (int) m.dvbs();
|
|
break;
|
|
case FrontendModulation::hidl_discriminator::isdbs:
|
|
modulation = (int) m.isdbs();
|
|
break;
|
|
case FrontendModulation::hidl_discriminator::isdbs3:
|
|
modulation = (int) m.isdbs3();
|
|
break;
|
|
case FrontendModulation::hidl_discriminator::isdbt:
|
|
modulation = (int) m.isdbt();
|
|
break;
|
|
case FrontendModulation::hidl_discriminator::atsc:
|
|
modulation = (int) m.atsc();
|
|
break;
|
|
case FrontendModulation::hidl_discriminator::atsc3:
|
|
modulation = (int) m.atsc3();
|
|
break;
|
|
case FrontendModulation::hidl_discriminator::dtmb:
|
|
modulation = (int) m.dtmb();
|
|
break;
|
|
}
|
|
scanMessage.set<TunerFrontendScanMessage::modulation>(modulation);
|
|
break;
|
|
}
|
|
case FrontendScanMessageTypeExt1_1::DVBC_ANNEX: {
|
|
scanMessage.set<TunerFrontendScanMessage::annex>((int)message.annex());
|
|
break;
|
|
}
|
|
case FrontendScanMessageTypeExt1_1::HIGH_PRIORITY: {
|
|
scanMessage.set<TunerFrontendScanMessage::isHighPriority>(message.isHighPriority());
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
mTunerFrontendCallback->onScanMessage((int)type, scanMessage);
|
|
return Void();
|
|
}
|
|
|
|
/////////////// TunerFrontend Helper Methods ///////////////////////
|
|
|
|
void TunerFrontend::getAidlFrontendStatus(
|
|
vector<FrontendStatus>& hidlStatus, vector<TunerFrontendStatus>& aidlStatus) {
|
|
for (FrontendStatus s : hidlStatus) {
|
|
TunerFrontendStatus status;
|
|
switch (s.getDiscriminator()) {
|
|
case FrontendStatus::hidl_discriminator::isDemodLocked: {
|
|
status.set<TunerFrontendStatus::isDemodLocked>(s.isDemodLocked());
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatus::hidl_discriminator::snr: {
|
|
status.set<TunerFrontendStatus::snr>((int)s.snr());
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatus::hidl_discriminator::ber: {
|
|
status.set<TunerFrontendStatus::ber>((int)s.ber());
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatus::hidl_discriminator::per: {
|
|
status.set<TunerFrontendStatus::per>((int)s.per());
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatus::hidl_discriminator::preBer: {
|
|
status.set<TunerFrontendStatus::preBer>((int)s.preBer());
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatus::hidl_discriminator::signalQuality: {
|
|
status.set<TunerFrontendStatus::signalQuality>((int)s.signalQuality());
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatus::hidl_discriminator::signalStrength: {
|
|
status.set<TunerFrontendStatus::signalStrength>((int)s.signalStrength());
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatus::hidl_discriminator::symbolRate: {
|
|
status.set<TunerFrontendStatus::symbolRate>((int)s.symbolRate());
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatus::hidl_discriminator::innerFec: {
|
|
status.set<TunerFrontendStatus::innerFec>((long)s.innerFec());
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatus::hidl_discriminator::modulation: {
|
|
switch (s.modulation().getDiscriminator()) {
|
|
case FrontendModulationStatus::hidl_discriminator::dvbc:
|
|
status.set<TunerFrontendStatus::modulation>((int)s.modulation().dvbc());
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
case FrontendModulationStatus::hidl_discriminator::dvbs:
|
|
status.set<TunerFrontendStatus::modulation>((int)s.modulation().dvbs());
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
case FrontendModulationStatus::hidl_discriminator::isdbs:
|
|
status.set<TunerFrontendStatus::modulation>((int)s.modulation().isdbs());
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
case FrontendModulationStatus::hidl_discriminator::isdbs3:
|
|
status.set<TunerFrontendStatus::modulation>((int)s.modulation().isdbs3());
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
case FrontendModulationStatus::hidl_discriminator::isdbt:
|
|
status.set<TunerFrontendStatus::modulation>((int)s.modulation().isdbt());
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case FrontendStatus::hidl_discriminator::inversion: {
|
|
status.set<TunerFrontendStatus::inversion>((int)s.inversion());
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatus::hidl_discriminator::lnbVoltage: {
|
|
status.set<TunerFrontendStatus::lnbVoltage>((int)s.lnbVoltage());
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatus::hidl_discriminator::plpId: {
|
|
status.set<TunerFrontendStatus::plpId>((int8_t)s.plpId());
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatus::hidl_discriminator::isEWBS: {
|
|
status.set<TunerFrontendStatus::isEWBS>(s.isEWBS());
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatus::hidl_discriminator::agc: {
|
|
status.set<TunerFrontendStatus::agc>((int8_t)s.agc());
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatus::hidl_discriminator::isLnaOn: {
|
|
status.set<TunerFrontendStatus::isLnaOn>(s.isLnaOn());
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatus::hidl_discriminator::isLayerError: {
|
|
vector<bool> e(s.isLayerError().begin(), s.isLayerError().end());
|
|
status.set<TunerFrontendStatus::isLayerError>(e);
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatus::hidl_discriminator::mer: {
|
|
status.set<TunerFrontendStatus::mer>((int)s.mer());
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatus::hidl_discriminator::freqOffset: {
|
|
status.set<TunerFrontendStatus::freqOffset>((int)s.freqOffset());
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatus::hidl_discriminator::hierarchy: {
|
|
status.set<TunerFrontendStatus::hierarchy>((int)s.hierarchy());
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatus::hidl_discriminator::isRfLocked: {
|
|
status.set<TunerFrontendStatus::isRfLocked>(s.isRfLocked());
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatus::hidl_discriminator::plpInfo: {
|
|
vector<TunerFrontendStatusAtsc3PlpInfo> info;
|
|
for (auto i : s.plpInfo()) {
|
|
info.push_back({
|
|
.plpId = (int8_t)i.plpId,
|
|
.isLocked = i.isLocked,
|
|
.uec = (int)i.uec,
|
|
});
|
|
}
|
|
status.set<TunerFrontendStatus::plpInfo>(info);
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void TunerFrontend::getAidlFrontendStatusExt(
|
|
vector<FrontendStatusExt1_1>& hidlStatus, vector<TunerFrontendStatus>& aidlStatus) {
|
|
for (FrontendStatusExt1_1 s : hidlStatus) {
|
|
TunerFrontendStatus status;
|
|
switch (s.getDiscriminator()) {
|
|
case FrontendStatusExt1_1::hidl_discriminator::modulations: {
|
|
vector<int> aidlMod;
|
|
for (auto m : s.modulations()) {
|
|
switch (m.getDiscriminator()) {
|
|
case FrontendModulation::hidl_discriminator::dvbc:
|
|
aidlMod.push_back((int)m.dvbc());
|
|
break;
|
|
case FrontendModulation::hidl_discriminator::dvbs:
|
|
aidlMod.push_back((int)m.dvbs());
|
|
break;
|
|
case FrontendModulation::hidl_discriminator::dvbt:
|
|
aidlMod.push_back((int)m.dvbt());
|
|
break;
|
|
case FrontendModulation::hidl_discriminator::isdbs:
|
|
aidlMod.push_back((int)m.isdbs());
|
|
break;
|
|
case FrontendModulation::hidl_discriminator::isdbs3:
|
|
aidlMod.push_back((int)m.isdbs3());
|
|
break;
|
|
case FrontendModulation::hidl_discriminator::isdbt:
|
|
aidlMod.push_back((int)m.isdbt());
|
|
break;
|
|
case FrontendModulation::hidl_discriminator::atsc:
|
|
aidlMod.push_back((int)m.atsc());
|
|
break;
|
|
case FrontendModulation::hidl_discriminator::atsc3:
|
|
aidlMod.push_back((int)m.atsc3());
|
|
break;
|
|
case FrontendModulation::hidl_discriminator::dtmb:
|
|
aidlMod.push_back((int)m.dtmb());
|
|
break;
|
|
}
|
|
}
|
|
status.set<TunerFrontendStatus::modulations>(aidlMod);
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatusExt1_1::hidl_discriminator::bers: {
|
|
vector<int> b(s.bers().begin(), s.bers().end());
|
|
status.set<TunerFrontendStatus::bers>(b);
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatusExt1_1::hidl_discriminator::codeRates: {
|
|
vector<int64_t> codeRates;
|
|
for (auto c : s.codeRates()) {
|
|
codeRates.push_back((long)c);
|
|
}
|
|
status.set<TunerFrontendStatus::codeRates>(codeRates);
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatusExt1_1::hidl_discriminator::bandwidth: {
|
|
switch (s.bandwidth().getDiscriminator()) {
|
|
case FrontendBandwidth::hidl_discriminator::atsc3:
|
|
status.set<TunerFrontendStatus::bandwidth>((int)s.bandwidth().atsc3());
|
|
break;
|
|
case FrontendBandwidth::hidl_discriminator::dvbc:
|
|
status.set<TunerFrontendStatus::bandwidth>((int)s.bandwidth().dvbc());
|
|
break;
|
|
case FrontendBandwidth::hidl_discriminator::dvbt:
|
|
status.set<TunerFrontendStatus::bandwidth>((int)s.bandwidth().dvbt());
|
|
break;
|
|
case FrontendBandwidth::hidl_discriminator::isdbt:
|
|
status.set<TunerFrontendStatus::bandwidth>((int)s.bandwidth().isdbt());
|
|
break;
|
|
case FrontendBandwidth::hidl_discriminator::dtmb:
|
|
status.set<TunerFrontendStatus::bandwidth>((int)s.bandwidth().dtmb());
|
|
break;
|
|
}
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatusExt1_1::hidl_discriminator::interval: {
|
|
switch (s.interval().getDiscriminator()) {
|
|
case FrontendGuardInterval::hidl_discriminator::dvbt:
|
|
status.set<TunerFrontendStatus::interval>((int)s.interval().dvbt());
|
|
break;
|
|
case FrontendGuardInterval::hidl_discriminator::isdbt:
|
|
status.set<TunerFrontendStatus::interval>((int)s.interval().isdbt());
|
|
break;
|
|
case FrontendGuardInterval::hidl_discriminator::dtmb:
|
|
status.set<TunerFrontendStatus::interval>((int)s.interval().dtmb());
|
|
break;
|
|
}
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatusExt1_1::hidl_discriminator::transmissionMode: {
|
|
switch (s.transmissionMode().getDiscriminator()) {
|
|
case FrontendTransmissionMode::hidl_discriminator::dvbt:
|
|
status.set<TunerFrontendStatus::transmissionMode>(
|
|
(int)s.transmissionMode().dvbt());
|
|
break;
|
|
case FrontendTransmissionMode::hidl_discriminator::isdbt:
|
|
status.set<TunerFrontendStatus::transmissionMode>(
|
|
(int)s.transmissionMode().isdbt());
|
|
break;
|
|
case FrontendTransmissionMode::hidl_discriminator::dtmb:
|
|
status.set<TunerFrontendStatus::transmissionMode>(
|
|
(int)s.transmissionMode().dtmb());
|
|
break;
|
|
}
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatusExt1_1::hidl_discriminator::uec: {
|
|
status.set<TunerFrontendStatus::uec>((int)s.uec());
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatusExt1_1::hidl_discriminator::systemId: {
|
|
status.set<TunerFrontendStatus::systemId>((char16_t)s.systemId());
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatusExt1_1::hidl_discriminator::interleaving: {
|
|
vector<int> aidlInter;
|
|
for (auto i : s.interleaving()) {
|
|
switch (i.getDiscriminator()) {
|
|
case FrontendInterleaveMode::hidl_discriminator::atsc3:
|
|
aidlInter.push_back((int)i.atsc3());
|
|
break;
|
|
case FrontendInterleaveMode::hidl_discriminator::dvbc:
|
|
aidlInter.push_back((int)i.dvbc());
|
|
break;
|
|
case FrontendInterleaveMode::hidl_discriminator::dtmb:
|
|
aidlInter.push_back((int)i.dtmb());
|
|
break;
|
|
}
|
|
}
|
|
status.set<TunerFrontendStatus::interleaving>(aidlInter);
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatusExt1_1::hidl_discriminator::isdbtSegment: {
|
|
auto seg = s.isdbtSegment();
|
|
vector<uint8_t> i(seg.begin(), seg.end());
|
|
status.set<TunerFrontendStatus::isdbtSegment>(i);
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatusExt1_1::hidl_discriminator::tsDataRate: {
|
|
vector<int> ts(s.tsDataRate().begin(), s.tsDataRate().end());
|
|
status.set<TunerFrontendStatus::tsDataRate>(ts);
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatusExt1_1::hidl_discriminator::rollOff: {
|
|
switch (s.rollOff().getDiscriminator()) {
|
|
case FrontendRollOff::hidl_discriminator::dvbs:
|
|
status.set<TunerFrontendStatus::rollOff>((int)s.rollOff().dvbs());
|
|
break;
|
|
case FrontendRollOff::hidl_discriminator::isdbs:
|
|
status.set<TunerFrontendStatus::rollOff>((int)s.rollOff().isdbs());
|
|
break;
|
|
case FrontendRollOff::hidl_discriminator::isdbs3:
|
|
status.set<TunerFrontendStatus::rollOff>((int)s.rollOff().isdbs3());
|
|
break;
|
|
}
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatusExt1_1::hidl_discriminator::isMiso: {
|
|
status.set<TunerFrontendStatus::isMiso>(s.isMiso());
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatusExt1_1::hidl_discriminator::isLinear: {
|
|
status.set<TunerFrontendStatus::isLinear>(s.isLinear());
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
case FrontendStatusExt1_1::hidl_discriminator::isShortFrames: {
|
|
status.set<TunerFrontendStatus::isShortFrames>(s.isShortFrames());
|
|
aidlStatus.push_back(status);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
hidl_vec<FrontendAtsc3PlpSettings> TunerFrontend::getAtsc3PlpSettings(
|
|
const TunerFrontendAtsc3Settings& settings) {
|
|
int len = settings.plpSettings.size();
|
|
hidl_vec<FrontendAtsc3PlpSettings> plps = hidl_vec<FrontendAtsc3PlpSettings>(len);
|
|
// parse PLP settings
|
|
for (int i = 0; i < len; i++) {
|
|
uint8_t plpId = static_cast<uint8_t>(settings.plpSettings[i].plpId);
|
|
FrontendAtsc3Modulation modulation =
|
|
static_cast<FrontendAtsc3Modulation>(settings.plpSettings[i].modulation);
|
|
FrontendAtsc3TimeInterleaveMode interleaveMode =
|
|
static_cast<FrontendAtsc3TimeInterleaveMode>(
|
|
settings.plpSettings[i].interleaveMode);
|
|
FrontendAtsc3CodeRate codeRate =
|
|
static_cast<FrontendAtsc3CodeRate>(settings.plpSettings[i].codeRate);
|
|
FrontendAtsc3Fec fec =
|
|
static_cast<FrontendAtsc3Fec>(settings.plpSettings[i].fec);
|
|
FrontendAtsc3PlpSettings frontendAtsc3PlpSettings {
|
|
.plpId = plpId,
|
|
.modulation = modulation,
|
|
.interleaveMode = interleaveMode,
|
|
.codeRate = codeRate,
|
|
.fec = fec,
|
|
};
|
|
plps[i] = frontendAtsc3PlpSettings;
|
|
}
|
|
return plps;
|
|
}
|
|
|
|
FrontendDvbsCodeRate TunerFrontend::getDvbsCodeRate(const TunerFrontendDvbsCodeRate& codeRate) {
|
|
FrontendInnerFec innerFec = static_cast<FrontendInnerFec>(codeRate.fec);
|
|
bool isLinear = codeRate.isLinear;
|
|
bool isShortFrames = codeRate.isShortFrames;
|
|
uint32_t bitsPer1000Symbol = static_cast<uint32_t>(codeRate.bitsPer1000Symbol);
|
|
FrontendDvbsCodeRate coderate {
|
|
.fec = innerFec,
|
|
.isLinear = isLinear,
|
|
.isShortFrames = isShortFrames,
|
|
.bitsPer1000Symbol = bitsPer1000Symbol,
|
|
};
|
|
return coderate;
|
|
}
|
|
|
|
FrontendSettings TunerFrontend::getHidlFrontendSettings(const TunerFrontendSettings& aidlSettings) {
|
|
auto settings = aidlSettings.settings;
|
|
FrontendSettings frontendSettings;
|
|
|
|
switch (settings.getTag()) {
|
|
case TunerFrontendUnionSettings::analog: {
|
|
auto analog = settings.get<TunerFrontendUnionSettings::analog>();
|
|
frontendSettings.analog({
|
|
.frequency = static_cast<uint32_t>(analog.frequency),
|
|
.type = static_cast<FrontendAnalogType>(analog.signalType),
|
|
.sifStandard = static_cast<FrontendAnalogSifStandard>(analog.sifStandard),
|
|
});
|
|
break;
|
|
}
|
|
case TunerFrontendUnionSettings::atsc: {
|
|
auto atsc = settings.get<TunerFrontendUnionSettings::atsc>();
|
|
frontendSettings.atsc({
|
|
.frequency = static_cast<uint32_t>(atsc.frequency),
|
|
.modulation = static_cast<FrontendAtscModulation>(atsc.modulation),
|
|
});
|
|
break;
|
|
}
|
|
case TunerFrontendUnionSettings::atsc3: {
|
|
auto atsc3 = settings.get<TunerFrontendUnionSettings::atsc3>();
|
|
frontendSettings.atsc3({
|
|
.frequency = static_cast<uint32_t>(atsc3.frequency),
|
|
.bandwidth = static_cast<FrontendAtsc3Bandwidth>(atsc3.bandwidth),
|
|
.demodOutputFormat = static_cast<FrontendAtsc3DemodOutputFormat>(
|
|
atsc3.demodOutputFormat),
|
|
.plpSettings = getAtsc3PlpSettings(atsc3),
|
|
});
|
|
break;
|
|
}
|
|
case TunerFrontendUnionSettings::cable: {
|
|
auto dvbc = settings.get<TunerFrontendUnionSettings::cable>();
|
|
frontendSettings.dvbc({
|
|
.frequency = static_cast<uint32_t>(dvbc.frequency),
|
|
.modulation = static_cast<FrontendDvbcModulation>(dvbc.modulation),
|
|
.fec = static_cast<FrontendInnerFec>(dvbc.innerFec),
|
|
.symbolRate = static_cast<uint32_t>(dvbc.symbolRate),
|
|
.outerFec = static_cast<FrontendDvbcOuterFec>(dvbc.outerFec),
|
|
.annex = static_cast<FrontendDvbcAnnex>(dvbc.annex),
|
|
.spectralInversion = static_cast<FrontendDvbcSpectralInversion>(
|
|
dvbc.spectralInversion),
|
|
});
|
|
break;
|
|
}
|
|
case TunerFrontendUnionSettings::dvbs: {
|
|
auto dvbs = settings.get<TunerFrontendUnionSettings::dvbs>();
|
|
frontendSettings.dvbs({
|
|
.frequency = static_cast<uint32_t>(dvbs.frequency),
|
|
.modulation = static_cast<FrontendDvbsModulation>(dvbs.modulation),
|
|
.coderate = getDvbsCodeRate(dvbs.codeRate),
|
|
.symbolRate = static_cast<uint32_t>(dvbs.symbolRate),
|
|
.rolloff = static_cast<FrontendDvbsRolloff>(dvbs.rolloff),
|
|
.pilot = static_cast<FrontendDvbsPilot>(dvbs.pilot),
|
|
.inputStreamId = static_cast<uint32_t>(dvbs.inputStreamId),
|
|
.standard = static_cast<FrontendDvbsStandard>(dvbs.standard),
|
|
.vcmMode = static_cast<FrontendDvbsVcmMode>(dvbs.vcm),
|
|
});
|
|
break;
|
|
}
|
|
case TunerFrontendUnionSettings::dvbt: {
|
|
auto dvbt = settings.get<TunerFrontendUnionSettings::dvbt>();
|
|
frontendSettings.dvbt({
|
|
.frequency = static_cast<uint32_t>(dvbt.frequency),
|
|
.transmissionMode = static_cast<FrontendDvbtTransmissionMode>(
|
|
dvbt.transmissionMode),
|
|
.bandwidth = static_cast<FrontendDvbtBandwidth>(dvbt.bandwidth),
|
|
.constellation = static_cast<FrontendDvbtConstellation>(dvbt.constellation),
|
|
.hierarchy = static_cast<FrontendDvbtHierarchy>(dvbt.hierarchy),
|
|
.hpCoderate = static_cast<FrontendDvbtCoderate>(dvbt.hpCodeRate),
|
|
.lpCoderate = static_cast<FrontendDvbtCoderate>(dvbt.lpCodeRate),
|
|
.guardInterval = static_cast<FrontendDvbtGuardInterval>(dvbt.guardInterval),
|
|
.isHighPriority = dvbt.isHighPriority,
|
|
.standard = static_cast<FrontendDvbtStandard>(dvbt.standard),
|
|
.isMiso = dvbt.isMiso,
|
|
.plpMode = static_cast<FrontendDvbtPlpMode>(dvbt.plpMode),
|
|
.plpId = static_cast<uint8_t>(dvbt.plpId),
|
|
.plpGroupId = static_cast<uint8_t>(dvbt.plpGroupId),
|
|
});
|
|
break;
|
|
}
|
|
case TunerFrontendUnionSettings::isdbs: {
|
|
auto isdbs = settings.get<TunerFrontendUnionSettings::isdbs>();
|
|
frontendSettings.isdbs({
|
|
.frequency = static_cast<uint32_t>(isdbs.frequency),
|
|
.streamId = static_cast<uint16_t>(isdbs.streamId),
|
|
.streamIdType = static_cast<FrontendIsdbsStreamIdType>(isdbs.streamIdType),
|
|
.modulation = static_cast<FrontendIsdbsModulation>(isdbs.modulation),
|
|
.coderate = static_cast<FrontendIsdbsCoderate>(isdbs.codeRate),
|
|
.symbolRate = static_cast<uint32_t>(isdbs.symbolRate),
|
|
.rolloff = static_cast<FrontendIsdbsRolloff>(isdbs.rolloff),
|
|
});
|
|
break;
|
|
}
|
|
case TunerFrontendUnionSettings::isdbs3: {
|
|
auto isdbs3 = settings.get<TunerFrontendUnionSettings::isdbs3>();
|
|
frontendSettings.isdbs3({
|
|
.frequency = static_cast<uint32_t>(isdbs3.frequency),
|
|
.streamId = static_cast<uint16_t>(isdbs3.streamId),
|
|
.streamIdType = static_cast<FrontendIsdbsStreamIdType>(isdbs3.streamIdType),
|
|
.modulation = static_cast<FrontendIsdbs3Modulation>(isdbs3.modulation),
|
|
.coderate = static_cast<FrontendIsdbs3Coderate>(isdbs3.codeRate),
|
|
.symbolRate = static_cast<uint32_t>(isdbs3.symbolRate),
|
|
.rolloff = static_cast<FrontendIsdbs3Rolloff>(isdbs3.rolloff),
|
|
});
|
|
break;
|
|
}
|
|
case TunerFrontendUnionSettings::isdbt: {
|
|
auto isdbt = settings.get<TunerFrontendUnionSettings::isdbt>();
|
|
frontendSettings.isdbt({
|
|
.frequency = static_cast<uint32_t>(isdbt.frequency),
|
|
.modulation = static_cast<FrontendIsdbtModulation>(isdbt.modulation),
|
|
.bandwidth = static_cast<FrontendIsdbtBandwidth>(isdbt.bandwidth),
|
|
.mode = static_cast<FrontendIsdbtMode>(isdbt.mode),
|
|
.coderate = static_cast<FrontendIsdbtCoderate>(isdbt.codeRate),
|
|
.guardInterval = static_cast<FrontendIsdbtGuardInterval>(isdbt.guardInterval),
|
|
.serviceAreaId = static_cast<uint32_t>(isdbt.serviceAreaId),
|
|
});
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return frontendSettings;
|
|
}
|
|
|
|
FrontendSettingsExt1_1 TunerFrontend::getHidlFrontendSettingsExt(
|
|
const TunerFrontendSettings& aidlSettings) {
|
|
FrontendSettingsExt1_1 frontendSettingsExt{
|
|
.endFrequency = static_cast<uint32_t>(aidlSettings.endFrequency),
|
|
.inversion = static_cast<FrontendSpectralInversion>(aidlSettings.inversion),
|
|
};
|
|
|
|
auto settings = aidlSettings.settings;
|
|
switch (settings.getTag()) {
|
|
case TunerFrontendUnionSettings::analog: {
|
|
auto analog = settings.get<TunerFrontendUnionSettings::analog>();
|
|
if (analog.isExtended) {
|
|
frontendSettingsExt.settingExt.analog({
|
|
.aftFlag = static_cast<FrontendAnalogAftFlag>(analog.aftFlag),
|
|
});
|
|
} else {
|
|
frontendSettingsExt.settingExt.noinit();
|
|
}
|
|
break;
|
|
}
|
|
case TunerFrontendUnionSettings::cable: {
|
|
auto dvbc = settings.get<TunerFrontendUnionSettings::cable>();
|
|
if (dvbc.isExtended) {
|
|
frontendSettingsExt.settingExt.dvbc({
|
|
.interleaveMode = static_cast<FrontendCableTimeInterleaveMode>(
|
|
dvbc.interleaveMode),
|
|
.bandwidth = static_cast<FrontendDvbcBandwidth>(
|
|
dvbc.bandwidth),
|
|
});
|
|
} else {
|
|
frontendSettingsExt.settingExt.noinit();
|
|
}
|
|
break;
|
|
}
|
|
case TunerFrontendUnionSettings::dvbs: {
|
|
auto dvbs = settings.get<TunerFrontendUnionSettings::dvbs>();
|
|
if (dvbs.isExtended) {
|
|
frontendSettingsExt.settingExt.dvbs({
|
|
.scanType = static_cast<FrontendDvbsScanType>(dvbs.scanType),
|
|
.isDiseqcRxMessage = dvbs.isDiseqcRxMessage,
|
|
});
|
|
} else {
|
|
frontendSettingsExt.settingExt.noinit();
|
|
}
|
|
break;
|
|
}
|
|
case TunerFrontendUnionSettings::dvbt: {
|
|
auto dvbt = settings.get<TunerFrontendUnionSettings::dvbt>();
|
|
if (dvbt.isExtended) {
|
|
frontendSettingsExt.settingExt.dvbt({
|
|
.constellation =
|
|
static_cast<hardware::tv::tuner::V1_1::FrontendDvbtConstellation>(
|
|
dvbt.constellation),
|
|
.transmissionMode =
|
|
static_cast<hardware::tv::tuner::V1_1::FrontendDvbtTransmissionMode>(
|
|
dvbt.transmissionMode),
|
|
});
|
|
} else {
|
|
frontendSettingsExt.settingExt.noinit();
|
|
}
|
|
break;
|
|
}
|
|
case TunerFrontendUnionSettings::dtmb: {
|
|
auto dtmb = settings.get<TunerFrontendUnionSettings::dtmb>();
|
|
frontendSettingsExt.settingExt.dtmb({
|
|
.frequency = static_cast<uint32_t>(dtmb.frequency),
|
|
.transmissionMode = static_cast<FrontendDtmbTransmissionMode>(
|
|
dtmb.transmissionMode),
|
|
.bandwidth = static_cast<FrontendDtmbBandwidth>(dtmb.bandwidth),
|
|
.modulation = static_cast<FrontendDtmbModulation>(dtmb.modulation),
|
|
.codeRate = static_cast<FrontendDtmbCodeRate>(dtmb.codeRate),
|
|
.guardInterval = static_cast<FrontendDtmbGuardInterval>(dtmb.guardInterval),
|
|
.interleaveMode = static_cast<FrontendDtmbTimeInterleaveMode>(dtmb.interleaveMode),
|
|
});
|
|
break;
|
|
}
|
|
default:
|
|
frontendSettingsExt.settingExt.noinit();
|
|
break;
|
|
}
|
|
|
|
return frontendSettingsExt;
|
|
}
|
|
} // namespace android
|