Merge "Connect FilterSettings between TunerFilter and FilterClient" into sc-dev (76629499) · Commits · e / os / android_frameworks_base

media/jni/tuner/FilterClient.cpp

+308 −26

Original line number	Diff line number	Diff line
		@@ -22,17 +22,24 @@

		#include "FilterClient.h"

		using ::aidl::android::media::tv::tuner::TunerFilterAvSettings;
		using ::aidl::android::media::tv::tuner::TunerDemuxIpAddressSettings;
		using ::aidl::android::media::tv::tuner::TunerFilterAlpConfiguration;
		using ::aidl::android::media::tv::tuner::TunerFilterIpConfiguration;
		using ::aidl::android::media::tv::tuner::TunerFilterMmtpConfiguration;
		using ::aidl::android::media::tv::tuner::TunerFilterMonitorEvent;
		using ::aidl::android::media::tv::tuner::TunerFilterScIndexMask;
		using ::aidl::android::media::tv::tuner::TunerFilterSectionBits;
		using ::aidl::android::media::tv::tuner::TunerFilterSectionCondition;
		using ::aidl::android::media::tv::tuner::TunerFilterSectionTableInfo;
		using ::aidl::android::media::tv::tuner::TunerFilterSharedHandleInfo;
		using ::aidl::android::media::tv::tuner::TunerFilterTlvConfiguration;
		using ::aidl::android::media::tv::tuner::TunerFilterTsConfiguration;

		using ::android::hardware::tv::tuner::V1_0::DemuxQueueNotifyBits;
		using ::android::hardware::tv::tuner::V1_0::DemuxFilterMainType;
		using ::android::hardware::tv::tuner::V1_0::DemuxMmtpFilterType;
		using ::android::hardware::tv::tuner::V1_0::DemuxTpid;
		using ::android::hardware::tv::tuner::V1_0::DemuxQueueNotifyBits;
		using ::android::hardware::tv::tuner::V1_0::DemuxStreamId;
		using ::android::hardware::tv::tuner::V1_0::DemuxTpid;
		using ::android::hardware::tv::tuner::V1_0::DemuxTsFilterSettings;
		using ::android::hardware::tv::tuner::V1_0::DemuxTsFilterType;
		using ::android::hardware::tv::tuner::V1_1::ScramblingStatus;
		@@ -318,42 +325,317 @@ Status TunerFilterCallback::onFilterEvent(const vector<TunerFilterEvent>& filter

		TunerFilterConfiguration FilterClient::getAidlFilterSettings(DemuxFilterSettings configure) {
		TunerFilterConfiguration config;
		// TODO: complete filter setting conversion
		switch (configure.getDiscriminator()) {
		case DemuxFilterSettings::hidl_discriminator::ts: {
		case DemuxFilterSettings::hidl_discriminator::ts:
		return getAidlTsSettings(configure.ts());
		case DemuxFilterSettings::hidl_discriminator::mmtp:
		return getAidlMmtpSettings(configure.mmtp());
		case DemuxFilterSettings::hidl_discriminator::ip:
		return getAidlIpSettings(configure.ip());
		case DemuxFilterSettings::hidl_discriminator::tlv:
		return getAidlTlvSettings(configure.tlv());
		case DemuxFilterSettings::hidl_discriminator::alp:
		return getAidlAlpSettings(configure.alp());
		default:
		break;
		}
		ALOGE("Wrong DemuxFilterSettings union.");
		return config;
		}

		TunerFilterConfiguration FilterClient::getAidlTsSettings(DemuxTsFilterSettings ts) {
		TunerFilterConfiguration config;
		TunerFilterSettings filterSettings;
		switch (configure.ts().filterSettings.getDiscriminator()) {
		switch (ts.filterSettings.getDiscriminator()) {
		case DemuxTsFilterSettings::FilterSettings::hidl_discriminator::av: {
		TunerFilterAvSettings av{
		.isPassthrough = configure.ts().filterSettings.av().isPassthrough,
		filterSettings.set<TunerFilterSettings::av>(
		getAidlAvSettings(ts.filterSettings.av()));
		break;
		}
		case DemuxTsFilterSettings::FilterSettings::hidl_discriminator::section: {
		filterSettings.set<TunerFilterSettings::section>(
		getAidlSectionSettings(ts.filterSettings.section()));
		break;
		}
		case DemuxTsFilterSettings::FilterSettings::hidl_discriminator::pesData: {
		filterSettings.set<TunerFilterSettings::pesData>(
		getAidlPesDataSettings(ts.filterSettings.pesData()));
		break;
		}
		case DemuxTsFilterSettings::FilterSettings::hidl_discriminator::record: {
		filterSettings.set<TunerFilterSettings::record>(
		getAidlRecordSettings(ts.filterSettings.record()));
		break;
		}
		default:
		filterSettings.set<TunerFilterSettings::nothing>(true);
		break;
		}

		TunerFilterTsConfiguration aidlTs{
		.tpid = static_cast<char16_t>(ts.tpid),
		.filterSettings = filterSettings,
		};
		filterSettings.set<TunerFilterSettings::av>(av);
		config.set<TunerFilterConfiguration::ts>(aidlTs);

		return config;
		}

		TunerFilterConfiguration FilterClient::getAidlMmtpSettings(DemuxMmtpFilterSettings mmtp) {
		TunerFilterConfiguration config;
		TunerFilterSettings filterSettings;
		switch (mmtp.filterSettings.getDiscriminator()) {
		case DemuxMmtpFilterSettings::FilterSettings::hidl_discriminator::av: {
		filterSettings.set<TunerFilterSettings::av>(
		getAidlAvSettings(mmtp.filterSettings.av()));
		break;
		}
		case DemuxMmtpFilterSettings::FilterSettings::hidl_discriminator::section: {
		filterSettings.set<TunerFilterSettings::section>(
		getAidlSectionSettings(mmtp.filterSettings.section()));
		break;
		}
		case DemuxMmtpFilterSettings::FilterSettings::hidl_discriminator::pesData: {
		filterSettings.set<TunerFilterSettings::pesData>(
		getAidlPesDataSettings(mmtp.filterSettings.pesData()));
		break;
		}
		case DemuxMmtpFilterSettings::FilterSettings::hidl_discriminator::record: {
		filterSettings.set<TunerFilterSettings::record>(
		getAidlRecordSettings(mmtp.filterSettings.record()));
		break;
		}
		case DemuxMmtpFilterSettings::FilterSettings::hidl_discriminator::download: {
		filterSettings.set<TunerFilterSettings::download>(
		getAidlDownloadSettings(mmtp.filterSettings.download()));
		break;
		}
		default:
		filterSettings.set<TunerFilterSettings::nothing>(true);
		break;
		}

		TunerFilterTsConfiguration ts{
		.tpid = configure.ts().tpid,
		TunerFilterMmtpConfiguration aidlMmtp{
		.mmtpPid = static_cast<char16_t>(mmtp.mmtpPid),
		.filterSettings = filterSettings,
		};
		config.set<TunerFilterConfiguration::ts>(ts);
		config.set<TunerFilterConfiguration::mmtp>(aidlMmtp);

		return config;
		}
		case DemuxFilterSettings::hidl_discriminator::mmtp:

		TunerFilterConfiguration FilterClient::getAidlIpSettings(DemuxIpFilterSettings ip) {
		TunerFilterConfiguration config;
		TunerFilterSettings filterSettings;
		switch (ip.filterSettings.getDiscriminator()) {
		case DemuxIpFilterSettings::FilterSettings::hidl_discriminator::section: {
		filterSettings.set<TunerFilterSettings::section>(
		getAidlSectionSettings(ip.filterSettings.section()));
		break;
		case DemuxFilterSettings::hidl_discriminator::ip:
		}
		case DemuxIpFilterSettings::FilterSettings::hidl_discriminator::bPassthrough: {
		filterSettings.set<TunerFilterSettings::isPassthrough>(
		ip.filterSettings.bPassthrough());
		break;
		case DemuxFilterSettings::hidl_discriminator::tlv:
		}
		default:
		filterSettings.set<TunerFilterSettings::nothing>(true);
		break;
		}

		TunerDemuxIpAddressSettings ipAddr{
		.srcPort = static_cast<char16_t>(ip.ipAddr.srcPort),
		.dstPort = static_cast<char16_t>(ip.ipAddr.dstPort),
		};
		getAidlIpAddress(ip.ipAddr, ipAddr.srcIpAddress, ipAddr.dstIpAddress);

		TunerFilterIpConfiguration aidlIp{
		.ipAddr = ipAddr,
		.filterSettings = filterSettings,
		};
		config.set<TunerFilterConfiguration::ip>(aidlIp);

		return config;
		}

		void FilterClient::getAidlIpAddress(DemuxIpAddress ipAddr,
		TunerDemuxIpAddress& srcIpAddress, TunerDemuxIpAddress& dstIpAddress) {
		switch (ipAddr.srcIpAddress.getDiscriminator()) {
		case DemuxIpAddress::SrcIpAddress::hidl_discriminator::v4: {
		int size = ipAddr.srcIpAddress.v4().size();
		srcIpAddress.isIpV6 = false;
		srcIpAddress.addr.resize(ipAddr.srcIpAddress.v4().size());
		copy(&ipAddr.srcIpAddress.v4()[0], &ipAddr.srcIpAddress.v4()[size],
		srcIpAddress.addr.begin());
		break;
		}
		case DemuxIpAddress::SrcIpAddress::hidl_discriminator::v6: {
		int size = ipAddr.srcIpAddress.v6().size();
		srcIpAddress.isIpV6 = true;
		srcIpAddress.addr.resize(size);
		copy(&ipAddr.srcIpAddress.v6()[0], &ipAddr.srcIpAddress.v6()[size],
		srcIpAddress.addr.begin());
		break;
		}
		default:
		break;
		}
		switch (ipAddr.dstIpAddress.getDiscriminator()) {
		case DemuxIpAddress::DstIpAddress::hidl_discriminator::v4: {
		int size = ipAddr.dstIpAddress.v4().size();
		dstIpAddress.isIpV6 = false;
		dstIpAddress.addr.resize(size);
		copy(&ipAddr.dstIpAddress.v4()[0], &ipAddr.dstIpAddress.v4()[size],
		dstIpAddress.addr.begin());
		break;
		}
		case DemuxIpAddress::DstIpAddress::hidl_discriminator::v6: {
		int size = ipAddr.dstIpAddress.v6().size();
		dstIpAddress.isIpV6 = true;
		dstIpAddress.addr.resize(size);
		copy(&ipAddr.dstIpAddress.v6()[0], &ipAddr.dstIpAddress.v6()[size],
		dstIpAddress.addr.begin());
		break;
		}
		default:
		break;
		}
		}

		TunerFilterConfiguration FilterClient::getAidlTlvSettings(DemuxTlvFilterSettings tlv) {
		TunerFilterConfiguration config;
		TunerFilterSettings filterSettings;
		switch (tlv.filterSettings.getDiscriminator()) {
		case DemuxTlvFilterSettings::FilterSettings::hidl_discriminator::section: {
		filterSettings.set<TunerFilterSettings::section>(
		getAidlSectionSettings(tlv.filterSettings.section()));
		break;
		}
		case DemuxTlvFilterSettings::FilterSettings::hidl_discriminator::bPassthrough: {
		filterSettings.set<TunerFilterSettings::isPassthrough>(
		tlv.filterSettings.bPassthrough());
		break;
		}
		default:
		filterSettings.set<TunerFilterSettings::nothing>(true);
		break;
		}

		TunerFilterTlvConfiguration aidlTlv{
		.packetType = static_cast<int8_t>(tlv.packetType),
		.isCompressedIpPacket = tlv.isCompressedIpPacket,
		.filterSettings = filterSettings,
		};
		config.set<TunerFilterConfiguration::tlv>(aidlTlv);

		return config;
		}

		TunerFilterConfiguration FilterClient::getAidlAlpSettings(DemuxAlpFilterSettings alp) {
		TunerFilterConfiguration config;
		TunerFilterSettings filterSettings;
		switch (alp.filterSettings.getDiscriminator()) {
		case DemuxAlpFilterSettings::FilterSettings::hidl_discriminator::section: {
		filterSettings.set<TunerFilterSettings::section>(
		getAidlSectionSettings(alp.filterSettings.section()));
		break;
		}
		default:
		filterSettings.set<TunerFilterSettings::nothing>(true);
		break;
		}

		TunerFilterAlpConfiguration aidlAlp{
		.packetType = static_cast<int8_t>(alp.packetType),
		.lengthType = static_cast<int8_t>(alp.lengthType),
		.filterSettings = filterSettings,
		};
		config.set<TunerFilterConfiguration::alp>(aidlAlp);

		return config;
		}

		TunerFilterAvSettings FilterClient::getAidlAvSettings(DemuxFilterAvSettings hidlAv) {
		TunerFilterAvSettings aidlAv{
		.isPassthrough = hidlAv.isPassthrough,
		};
		return aidlAv;
		}

		TunerFilterSectionSettings FilterClient::getAidlSectionSettings(
		DemuxFilterSectionSettings hidlSection) {
		TunerFilterSectionSettings aidlSection;

		switch (hidlSection.condition.getDiscriminator()) {
		case DemuxFilterSectionSettings::Condition::hidl_discriminator::sectionBits: {
		TunerFilterSectionBits sectionBits;
		auto hidlSectionBits = hidlSection.condition.sectionBits();
		sectionBits.filter.resize(hidlSectionBits.filter.size());
		sectionBits.mask.resize(hidlSectionBits.mask.size());
		sectionBits.mode.resize(hidlSectionBits.mode.size());
		copy(hidlSectionBits.filter.begin(), hidlSectionBits.filter.end(),
		hidlSectionBits.filter.begin());
		copy(hidlSectionBits.mask.begin(), hidlSectionBits.mask.end(),
		hidlSectionBits.mask.begin());
		copy(hidlSectionBits.mode.begin(), hidlSectionBits.mode.end(),
		hidlSectionBits.mode.begin());
		aidlSection.condition.set<TunerFilterSectionCondition::sectionBits>(sectionBits);
		break;
		}
		case DemuxFilterSectionSettings::Condition::hidl_discriminator::tableInfo: {
		TunerFilterSectionTableInfo tableInfo{
		.tableId = static_cast<char16_t>(hidlSection.condition.tableInfo().tableId),
		.version = static_cast<char16_t>(hidlSection.condition.tableInfo().version),
		};
		aidlSection.condition.set<TunerFilterSectionCondition::tableInfo>(tableInfo);
		break;
		}
		}
		aidlSection.isCheckCrc = hidlSection.isCheckCrc;
		aidlSection.isRepeat = hidlSection.isRepeat;
		aidlSection.isRaw = hidlSection.isRaw;
		return aidlSection;
		}

		TunerFilterPesDataSettings FilterClient::getAidlPesDataSettings(
		DemuxFilterPesDataSettings hidlPesData) {
		TunerFilterPesDataSettings aidlPesData{
		.streamId = static_cast<char16_t>(hidlPesData.streamId),
		.isRaw = hidlPesData.isRaw,
		};
		return aidlPesData;
		}

		TunerFilterRecordSettings FilterClient::getAidlRecordSettings(
		DemuxFilterRecordSettings hidlRecord) {
		TunerFilterScIndexMask mask;
		switch (hidlRecord.scIndexMask.getDiscriminator()) {
		case DemuxFilterRecordSettings::ScIndexMask::hidl_discriminator::sc: {
		mask.set<TunerFilterScIndexMask::sc>(hidlRecord.scIndexMask.sc());
		break;
		}
		case DemuxFilterRecordSettings::ScIndexMask::hidl_discriminator::scHevc: {
		mask.set<TunerFilterScIndexMask::scHevc>(hidlRecord.scIndexMask.scHevc());
		break;
		}
		default:
		break;
		}
		TunerFilterRecordSettings aidlRecord{
		.tsIndexMask = static_cast<int32_t>(hidlRecord.tsIndexMask),
		.scIndexType = static_cast<int32_t>(hidlRecord.scIndexType),
		.scIndexMask = mask,
		};
		return aidlRecord;
		}

		TunerFilterDownloadSettings FilterClient::getAidlDownloadSettings(
		DemuxFilterDownloadSettings hidlDownload) {
		TunerFilterDownloadSettings aidlDownload{
		.downloadId = static_cast<int32_t>(hidlDownload.downloadId),
		};
		return aidlDownload;
		}

		void TunerFilterCallback::getHidlFilterEvent(const vector<TunerFilterEvent>& filterEvents,
		DemuxFilterEvent& event, DemuxFilterEventExt& eventExt) {

media/jni/tuner/FilterClient.h

+32 −0

Original line number	Diff line number	Diff line
		@@ -33,8 +33,14 @@
		using Status = ::ndk::ScopedAStatus;
		using ::aidl::android::media::tv::tuner::BnTunerFilterCallback;
		using ::aidl::android::media::tv::tuner::ITunerFilter;
		using ::aidl::android::media::tv::tuner::TunerDemuxIpAddress;
		using ::aidl::android::media::tv::tuner::TunerFilterAvSettings;
		using ::aidl::android::media::tv::tuner::TunerFilterConfiguration;
		using ::aidl::android::media::tv::tuner::TunerFilterDownloadSettings;
		using ::aidl::android::media::tv::tuner::TunerFilterEvent;
		using ::aidl::android::media::tv::tuner::TunerFilterPesDataSettings;
		using ::aidl::android::media::tv::tuner::TunerFilterRecordSettings;
		using ::aidl::android::media::tv::tuner::TunerFilterSectionSettings;
		using ::aidl::android::media::tv::tuner::TunerFilterSettings;

		using ::android::hardware::EventFlag;
		@@ -43,8 +49,19 @@ using ::android::hardware::MQDescriptorSync;
		using ::android::hardware::Return;
		using ::android::hardware::Void;
		using ::android::hardware::hidl_handle;
		using ::android::hardware::tv::tuner::V1_0::DemuxAlpFilterSettings;
		using ::android::hardware::tv::tuner::V1_0::DemuxMmtpFilterSettings;
		using ::android::hardware::tv::tuner::V1_0::DemuxFilterAvSettings;
		using ::android::hardware::tv::tuner::V1_0::DemuxFilterDownloadSettings;
		using ::android::hardware::tv::tuner::V1_0::DemuxFilterPesDataSettings;
		using ::android::hardware::tv::tuner::V1_0::DemuxFilterRecordSettings;
		using ::android::hardware::tv::tuner::V1_0::DemuxFilterSectionSettings;
		using ::android::hardware::tv::tuner::V1_0::DemuxFilterSettings;
		using ::android::hardware::tv::tuner::V1_0::DemuxFilterType;
		using ::android::hardware::tv::tuner::V1_0::DemuxIpAddress;
		using ::android::hardware::tv::tuner::V1_0::DemuxIpFilterSettings;
		using ::android::hardware::tv::tuner::V1_0::DemuxTlvFilterSettings;
		using ::android::hardware::tv::tuner::V1_0::DemuxTsFilterSettings;
		using ::android::hardware::tv::tuner::V1_0::IFilter;
		using ::android::hardware::tv::tuner::V1_0::Result;
		using ::android::hardware::tv::tuner::V1_1::AvStreamType;
		@@ -201,6 +218,21 @@ public:

		private:
		TunerFilterConfiguration getAidlFilterSettings(DemuxFilterSettings configure);

		TunerFilterConfiguration getAidlTsSettings(DemuxTsFilterSettings configure);
		TunerFilterConfiguration getAidlMmtpSettings(DemuxMmtpFilterSettings mmtp);
		TunerFilterConfiguration getAidlIpSettings(DemuxIpFilterSettings ip);
		TunerFilterConfiguration getAidlTlvSettings(DemuxTlvFilterSettings tlv);
		TunerFilterConfiguration getAidlAlpSettings(DemuxAlpFilterSettings alp);

		TunerFilterAvSettings getAidlAvSettings(DemuxFilterAvSettings hidlAv);
		TunerFilterSectionSettings getAidlSectionSettings(DemuxFilterSectionSettings hidlSection);
		TunerFilterPesDataSettings getAidlPesDataSettings(DemuxFilterPesDataSettings hidlPesData);
		TunerFilterRecordSettings getAidlRecordSettings(DemuxFilterRecordSettings hidlRecord);
		TunerFilterDownloadSettings getAidlDownloadSettings(DemuxFilterDownloadSettings hidlDownload);

		void getAidlIpAddress(DemuxIpAddress ipAddr,
		TunerDemuxIpAddress& srcIpAddress, TunerDemuxIpAddress& dstIpAddress);
		Result getFilterMq();
		int copyData(uint8_t* buffer, int size);
		void checkIsMediaFilter(DemuxFilterType type);