Add aidl interfaces for Frontend Settings and Frontend Callbacks (0f04c453) · Commits · e / os / android_frameworks_av

services/tuner/Android.bp

+18 −1

Original line number	Diff line number	Diff line
		filegroup {
		name: "tv_tuner_aidl",
		srcs: [
		"aidl/android/media/tv/tuner/ITunerFrontend.aidl",
		"aidl/android/media/tv/tuner/ITunerFrontendCallback.aidl",
		"aidl/android/media/tv/tuner/ITunerService.aidl",
		"aidl/android/media/tv/tuner/TunerAtsc3PlpInfo.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendAnalogCapabilities.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendAtscCapabilities.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendAtsc3Capabilities.aidl",
		@@ -12,6 +15,19 @@ filegroup {
		"aidl/android/media/tv/tuner/TunerFrontendIsdbsCapabilities.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendIsdbs3Capabilities.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendIsdbtCapabilities.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendAnalogSettings.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendAtsc3PlpSettings.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendAtsc3Settings.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendAtscSettings.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendCableSettings.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendDvbsCodeRate.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendDvbsSettings.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendDvbtSettings.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendIsdbs3Settings.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendIsdbsSettings.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendIsdbtSettings.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendSettings.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendStatus.aidl",
		"aidl/android/media/tv/tuner/TunerServiceFrontendInfo.aidl",
		],
		path: "aidl",
		@@ -31,6 +47,7 @@ cc_library {

		srcs: [
		"TunerService.cpp",
		"TunerFrontend.cpp"
		],

		shared_libs: [

services/tuner/TunerFrontend.cpp

0 → 100644

+463 −0

Original line number	Diff line number	Diff line
		/**
		* 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 "TunerService.h"

		using ::aidl::android::media::tv::tuner::TunerAtsc3PlpInfo;
		using ::aidl::android::media::tv::tuner::TunerFrontendAtsc3PlpSettings;
		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::FrontendScanAtsc3PlpInfo;
		using ::android::hardware::tv::tuner::V1_0::FrontendScanType;
		using ::android::hardware::tv::tuner::V1_0::FrontendSettings;;
		using ::android::hardware::tv::tuner::V1_0::Result;

		namespace android {

		TunerFrontend::TunerFrontend(sp<ITuner> tuner, int frontendHandle) {
		mTuner = tuner;
		mId = TunerService::getResourceIdFromHandle(frontendHandle);

		if (mTuner != NULL) {
		Result status;
		mTuner->openFrontendById(mId, [&](Result result, const sp<IFrontend>& frontend) {
		mFrontend = frontend;
		status = result;
		});
		if (status != Result::SUCCESS) {
		mFrontend = NULL;
		}
		}
		}

		TunerFrontend::~TunerFrontend() {}

		Status TunerFrontend::setCallback(
		const std::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/) {
		return Status::ok();
		}

		Status TunerFrontend::stopTune() {
		return Status::ok();
		}

		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));
		}

		FrontendSettings frontendSettings;
		switch (settings.getTag()) {
		case TunerFrontendSettings::analog:
		frontendSettings.analog({
		.frequency = static_cast<uint32_t>(
		settings.get<TunerFrontendSettings::analog>().frequency),
		.type = static_cast<FrontendAnalogType>(
		settings.get<TunerFrontendSettings::analog>().signalType),
		.sifStandard = static_cast<FrontendAnalogSifStandard>(
		settings.get<TunerFrontendSettings::analog>().sifStandard),
		});
		break;
		case TunerFrontendSettings::atsc:
		frontendSettings.atsc({
		.frequency = static_cast<uint32_t>(
		settings.get<TunerFrontendSettings::atsc>().frequency),
		.modulation = static_cast<FrontendAtscModulation>(
		settings.get<TunerFrontendSettings::atsc>().modulation),
		});
		break;
		case TunerFrontendSettings::atsc3:
		frontendSettings.atsc3({
		.frequency = static_cast<uint32_t>(
		settings.get<TunerFrontendSettings::atsc3>().frequency),
		.bandwidth = static_cast<FrontendAtsc3Bandwidth>(
		settings.get<TunerFrontendSettings::atsc3>().bandwidth),
		.demodOutputFormat = static_cast<FrontendAtsc3DemodOutputFormat>(
		settings.get<TunerFrontendSettings::atsc3>().demodOutputFormat),
		.plpSettings = getAtsc3PlpSettings(settings.get<TunerFrontendSettings::atsc3>()),
		});
		break;
		case TunerFrontendSettings::cable:
		frontendSettings.dvbc({
		.frequency = static_cast<uint32_t>(
		settings.get<TunerFrontendSettings::cable>().frequency),
		.modulation = static_cast<FrontendDvbcModulation>(
		settings.get<TunerFrontendSettings::cable>().modulation),
		.fec = static_cast<FrontendInnerFec>(
		settings.get<TunerFrontendSettings::cable>().innerFec),
		.symbolRate = static_cast<uint32_t>(
		settings.get<TunerFrontendSettings::cable>().symbolRate),
		.outerFec = static_cast<FrontendDvbcOuterFec>(
		settings.get<TunerFrontendSettings::cable>().outerFec),
		.annex = static_cast<FrontendDvbcAnnex>(
		settings.get<TunerFrontendSettings::cable>().annex),
		.spectralInversion = static_cast<FrontendDvbcSpectralInversion>(
		settings.get<TunerFrontendSettings::cable>().spectralInversion),
		});
		break;
		case TunerFrontendSettings::dvbs:
		frontendSettings.dvbs({
		.frequency = static_cast<uint32_t>(
		settings.get<TunerFrontendSettings::dvbs>().frequency),
		.modulation = static_cast<FrontendDvbsModulation>(
		settings.get<TunerFrontendSettings::dvbs>().modulation),
		.coderate = getDvbsCodeRate(
		settings.get<TunerFrontendSettings::dvbs>().codeRate),
		.symbolRate = static_cast<uint32_t>(
		settings.get<TunerFrontendSettings::dvbs>().symbolRate),
		.rolloff = static_cast<FrontendDvbsRolloff>(
		settings.get<TunerFrontendSettings::dvbs>().rolloff),
		.pilot = static_cast<FrontendDvbsPilot>(
		settings.get<TunerFrontendSettings::dvbs>().pilot),
		.inputStreamId = static_cast<uint32_t>(
		settings.get<TunerFrontendSettings::dvbs>().inputStreamId),
		.standard = static_cast<FrontendDvbsStandard>(
		settings.get<TunerFrontendSettings::dvbs>().standard),
		.vcmMode = static_cast<FrontendDvbsVcmMode>(
		settings.get<TunerFrontendSettings::dvbs>().vcm),
		});
		break;
		case TunerFrontendSettings::dvbt:
		frontendSettings.dvbt({
		.frequency = static_cast<uint32_t>(
		settings.get<TunerFrontendSettings::dvbt>().frequency),
		.transmissionMode = static_cast<FrontendDvbtTransmissionMode>(
		settings.get<TunerFrontendSettings::dvbt>().transmissionMode),
		.bandwidth = static_cast<FrontendDvbtBandwidth>(
		settings.get<TunerFrontendSettings::dvbt>().bandwidth),
		.constellation = static_cast<FrontendDvbtConstellation>(
		settings.get<TunerFrontendSettings::dvbt>().constellation),
		.hierarchy = static_cast<FrontendDvbtHierarchy>(
		settings.get<TunerFrontendSettings::dvbt>().hierarchy),
		.hpCoderate = static_cast<FrontendDvbtCoderate>(
		settings.get<TunerFrontendSettings::dvbt>().hpCodeRate),
		.lpCoderate = static_cast<FrontendDvbtCoderate>(
		settings.get<TunerFrontendSettings::dvbt>().lpCodeRate),
		.guardInterval = static_cast<FrontendDvbtGuardInterval>(
		settings.get<TunerFrontendSettings::dvbt>().guardInterval),
		.isHighPriority = settings.get<TunerFrontendSettings::dvbt>().isHighPriority,
		.standard = static_cast<FrontendDvbtStandard>(
		settings.get<TunerFrontendSettings::dvbt>().standard),
		.isMiso = settings.get<TunerFrontendSettings::dvbt>().isMiso,
		.plpMode = static_cast<FrontendDvbtPlpMode>(
		settings.get<TunerFrontendSettings::dvbt>().plpMode),
		.plpId = static_cast<uint8_t>(
		settings.get<TunerFrontendSettings::dvbt>().plpId),
		.plpGroupId = static_cast<uint8_t>(
		settings.get<TunerFrontendSettings::dvbt>().plpGroupId),
		});
		break;
		case TunerFrontendSettings::isdbs:
		frontendSettings.isdbs({
		.frequency = static_cast<uint32_t>(
		settings.get<TunerFrontendSettings::isdbs>().frequency),
		.streamId = static_cast<uint16_t>(
		settings.get<TunerFrontendSettings::isdbs>().streamId),
		.streamIdType = static_cast<FrontendIsdbsStreamIdType>(
		settings.get<TunerFrontendSettings::isdbs>().streamIdType),
		.modulation = static_cast<FrontendIsdbsModulation>(
		settings.get<TunerFrontendSettings::isdbs>().modulation),
		.coderate = static_cast<FrontendIsdbsCoderate>(
		settings.get<TunerFrontendSettings::isdbs>().codeRate),
		.symbolRate = static_cast<uint32_t>(
		settings.get<TunerFrontendSettings::isdbs>().symbolRate),
		.rolloff = static_cast<FrontendIsdbsRolloff>(
		settings.get<TunerFrontendSettings::isdbs>().rolloff),
		});
		break;
		case TunerFrontendSettings::isdbs3:
		frontendSettings.isdbs3({
		.frequency = static_cast<uint32_t>(
		settings.get<TunerFrontendSettings::isdbs3>().frequency),
		.streamId = static_cast<uint16_t>(
		settings.get<TunerFrontendSettings::isdbs3>().streamId),
		.streamIdType = static_cast<FrontendIsdbsStreamIdType>(
		settings.get<TunerFrontendSettings::isdbs3>().streamIdType),
		.modulation = static_cast<FrontendIsdbs3Modulation>(
		settings.get<TunerFrontendSettings::isdbs3>().modulation),
		.coderate = static_cast<FrontendIsdbs3Coderate>(
		settings.get<TunerFrontendSettings::isdbs3>().codeRate),
		.symbolRate = static_cast<uint32_t>(
		settings.get<TunerFrontendSettings::isdbs3>().symbolRate),
		.rolloff = static_cast<FrontendIsdbs3Rolloff>(
		settings.get<TunerFrontendSettings::isdbs3>().rolloff),
		});
		break;
		case TunerFrontendSettings::isdbt:
		frontendSettings.isdbt({
		.frequency = static_cast<uint32_t>(
		settings.get<TunerFrontendSettings::isdbt>().frequency),
		.modulation = static_cast<FrontendIsdbtModulation>(
		settings.get<TunerFrontendSettings::isdbt>().modulation),
		.bandwidth = static_cast<FrontendIsdbtBandwidth>(
		settings.get<TunerFrontendSettings::isdbt>().bandwidth),
		.mode = static_cast<FrontendIsdbtMode>(
		settings.get<TunerFrontendSettings::isdbt>().mode),
		.coderate = static_cast<FrontendIsdbtCoderate>(
		settings.get<TunerFrontendSettings::isdbt>().codeRate),
		.guardInterval = static_cast<FrontendIsdbtGuardInterval>(
		settings.get<TunerFrontendSettings::isdbt>().guardInterval),
		.serviceAreaId = static_cast<uint32_t>(
		settings.get<TunerFrontendSettings::isdbt>().serviceAreaId),
		});
		break;
		default:
		break;
		}
		Result 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() {
		return Status::ok();
		}

		Status TunerFrontend::setLnb(int /lnbHandle/) {
		return Status::ok();
		}

		Status TunerFrontend::setLna(bool /bEnable/) {
		return Status::ok();
		}

		Status TunerFrontend::close() {
		return Status::ok();
		}

		Status TunerFrontend::getStatus(const std::vector<int32_t>& /statusTypes/,
		std::vector<TunerFrontendStatus>* /_aidl_return/) {
		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);
		switch(type) {
		case FrontendScanMessageType::LOCKED: {
		if (message.isLocked()) {
		mTunerFrontendCallback->onLocked();
		}
		break;
		}
		case FrontendScanMessageType::END: {
		if (message.isEnd()) {
		mTunerFrontendCallback->onScanStopped();
		}
		break;
		}
		case FrontendScanMessageType::PROGRESS_PERCENT: {
		mTunerFrontendCallback->onProgress((int)message.progressPercent());
		break;
		}
		case FrontendScanMessageType::FREQUENCY: {
		auto f = message.frequencies();
		std::vector<int32_t> frequencies(std::begin(f), std::end(f));
		mTunerFrontendCallback->onFrequenciesReport(frequencies);
		break;
		}
		case FrontendScanMessageType::SYMBOL_RATE: {
		auto s = message.symbolRates();
		std::vector<int32_t> symbolRates(std::begin(s), std::end(s));
		mTunerFrontendCallback->onSymbolRates(symbolRates);
		break;
		}
		case FrontendScanMessageType::HIERARCHY: {
		mTunerFrontendCallback->onHierarchy((int)message.hierarchy());
		break;
		}
		case FrontendScanMessageType::ANALOG_TYPE: {
		mTunerFrontendCallback->onSignalType((int)message.analogType());
		break;
		}
		case FrontendScanMessageType::PLP_IDS: {
		auto p = message.plpIds();
		std::vector<int32_t> plpIds(std::begin(p), std::end(p));
		mTunerFrontendCallback->onPlpIds(plpIds);
		break;
		}
		case FrontendScanMessageType::GROUP_IDS: {
		auto g = message.groupIds();
		std::vector<int32_t> groupIds(std::begin(g), std::end(g));
		mTunerFrontendCallback->onGroupIds(groupIds);
		break;
		}
		case FrontendScanMessageType::INPUT_STREAM_IDS: {
		auto i = message.inputStreamIds();
		std::vector<int32_t> streamIds(std::begin(i), std::end(i));
		mTunerFrontendCallback->onInputStreamIds(streamIds);
		break;
		}
		case FrontendScanMessageType::STANDARD: {
		FrontendScanMessage::Standard std = message.std();
		int standard;
		if (std.getDiscriminator() == FrontendScanMessage::Standard::hidl_discriminator::sStd) {
		standard = (int) std.sStd();
		mTunerFrontendCallback->onDvbsStandard(standard);
		} else if (std.getDiscriminator() ==
		FrontendScanMessage::Standard::hidl_discriminator::tStd) {
		standard = (int) std.tStd();
		mTunerFrontendCallback->onDvbsStandard(standard);
		} else if (std.getDiscriminator() ==
		FrontendScanMessage::Standard::hidl_discriminator::sifStd) {
		standard = (int) std.sifStd();
		mTunerFrontendCallback->onAnalogSifStandard(standard);
		}
		break;
		}
		case FrontendScanMessageType::ATSC3_PLP_INFO: {
		std::vector<FrontendScanAtsc3PlpInfo> plpInfos = message.atsc3PlpInfos();
		std::vector<TunerAtsc3PlpInfo> tunerPlpInfos;
		for (int i = 0; i < plpInfos.size(); i++) {
		auto info = plpInfos[i];
		int plpId = (int) info.plpId;
		bool lls = (bool) info.bLlsFlag;
		TunerAtsc3PlpInfo plpInfo{
		.plpId = plpId,
		.llsFlag = lls,
		};
		tunerPlpInfos.push_back(plpInfo);
		}
		mTunerFrontendCallback->onAtsc3PlpInfos(tunerPlpInfos);
		break;
		}
		default:
		break;
		}
		return Void();
		}

		////////////////////////////////////////////////////////////////////////////////

		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;
		}
		} // namespace android