Complete Tuner Filter Events aidl interface and (7c2c2efb) · Commits · e / os / android_frameworks_av

services/tuner/TunerFilter.cpp

+292 −18

Original line number	Diff line number	Diff line
		@@ -25,6 +25,8 @@ using ::android::hardware::tv::tuner::V1_0::DemuxMmtpFilterType;
		using ::android::hardware::tv::tuner::V1_0::DemuxTsFilterSettings;
		using ::android::hardware::tv::tuner::V1_0::DemuxTsFilterType;
		using ::android::hardware::tv::tuner::V1_0::Result;
		using ::android::hardware::tv::tuner::V1_1::Constant;

		namespace android {

		TunerFilter::TunerFilter(
		@@ -209,6 +211,99 @@ sp<IFilter> TunerFilter::getHalFilter() {

		/////////////// FilterCallback ///////////////////////

		Return<void> TunerFilter::FilterCallback::onFilterStatus(DemuxFilterStatus status) {
		if (mTunerFilterCallback != NULL) {
		mTunerFilterCallback->onFilterStatus((int)status);
		}
		return Void();
		}

		Return<void> TunerFilter::FilterCallback::onFilterEvent(const DemuxFilterEvent& filterEvent) {
		std::vector<DemuxFilterEventExt::Event> emptyEventsExt;
		DemuxFilterEventExt emptyFilterEventExt {
		.events = emptyEventsExt,
		};
		onFilterEvent_1_1(filterEvent, emptyFilterEventExt);
		return Void();
		}

		Return<void> TunerFilter::FilterCallback::onFilterEvent_1_1(const DemuxFilterEvent& filterEvent,
		const DemuxFilterEventExt& filterEventExt) {
		if (mTunerFilterCallback != NULL) {
		std::vector<DemuxFilterEvent::Event> events = filterEvent.events;
		std::vector<DemuxFilterEventExt::Event> eventsExt = filterEventExt.events;
		std::vector<TunerFilterEvent> tunerEvent;

		getAidlFilterEvent(events, eventsExt, tunerEvent);
		mTunerFilterCallback->onFilterEvent(tunerEvent);
		}
		return Void();
		}

		/////////////// FilterCallback Helper Methods ///////////////////////

		void TunerFilter::FilterCallback::getAidlFilterEvent(std::vector<DemuxFilterEvent::Event>& events,
		std::vector<DemuxFilterEventExt::Event>& eventsExt,
		std::vector<TunerFilterEvent>& tunerEvent) {
		if (events.empty() && !eventsExt.empty()) {
		auto eventExt = eventsExt[0];
		switch (eventExt.getDiscriminator()) {
		case DemuxFilterEventExt::Event::hidl_discriminator::monitorEvent: {
		getMonitorEvent(eventsExt, tunerEvent);
		break;
		}
		case DemuxFilterEventExt::Event::hidl_discriminator::startId: {
		getRestartEvent(eventsExt, tunerEvent);
		break;
		}
		default: {
		break;
		}
		}
		}

		if (!events.empty()) {
		auto event = events[0];
		switch (event.getDiscriminator()) {
		case DemuxFilterEvent::Event::hidl_discriminator::media: {
		getMediaEvent(events, tunerEvent);
		break;
		}
		case DemuxFilterEvent::Event::hidl_discriminator::section: {
		getSectionEvent(events, tunerEvent);
		break;
		}
		case DemuxFilterEvent::Event::hidl_discriminator::pes: {
		getPesEvent(events, tunerEvent);
		break;
		}
		case DemuxFilterEvent::Event::hidl_discriminator::tsRecord: {
		getTsRecordEvent(events, eventsExt, tunerEvent);
		break;
		}
		case DemuxFilterEvent::Event::hidl_discriminator::mmtpRecord: {
		getMmtpRecordEvent(events, eventsExt, tunerEvent);
		break;
		}
		case DemuxFilterEvent::Event::hidl_discriminator::download: {
		getDownloadEvent(events, tunerEvent);
		break;
		}
		case DemuxFilterEvent::Event::hidl_discriminator::ipPayload: {
		getIpPayloadEvent(events, tunerEvent);
		break;
		}
		case DemuxFilterEvent::Event::hidl_discriminator::temi: {
		getTemiEvent(events, tunerEvent);
		break;
		}
		default: {
		break;
		}
		}
		}
		}

		void TunerFilter::FilterCallback::getMediaEvent(
		std::vector<DemuxFilterEvent::Event>& events, std::vector<TunerFilterEvent>& res) {
		for (DemuxFilterEvent::Event e : events) {
		@@ -225,6 +320,27 @@ void TunerFilter::FilterCallback::getMediaEvent(
		tunerMedia.mpuSequenceNumber = static_cast<int>(mediaEvent.mpuSequenceNumber);
		tunerMedia.isPesPrivateData = mediaEvent.isPesPrivateData;

		if (mediaEvent.extraMetaData.getDiscriminator() ==
		DemuxFilterMediaEvent::ExtraMetaData::hidl_discriminator::audio) {
		tunerMedia.isAudioExtraMetaData = true;
		tunerMedia.audio = {
		.adFade = static_cast<int8_t>(
		mediaEvent.extraMetaData.audio().adFade),
		.adPan = static_cast<int8_t>(
		mediaEvent.extraMetaData.audio().adPan),
		.versionTextTag = static_cast<int8_t>(
		mediaEvent.extraMetaData.audio().versionTextTag),
		.adGainCenter = static_cast<int8_t>(
		mediaEvent.extraMetaData.audio().adGainCenter),
		.adGainFront = static_cast<int8_t>(
		mediaEvent.extraMetaData.audio().adGainFront),
		.adGainSurround = static_cast<int8_t>(
		mediaEvent.extraMetaData.audio().adGainSurround),
		};
		} else {
		tunerMedia.isAudioExtraMetaData = false;
		}

		if (mediaEvent.avMemory.getNativeHandle() != nullptr) {
		tunerMedia.avMemory = dupToAidl(mediaEvent.avMemory.getNativeHandle());
		}
		@@ -235,30 +351,188 @@ void TunerFilter::FilterCallback::getMediaEvent(
		}
		}

		Return<void> TunerFilter::FilterCallback::onFilterStatus(DemuxFilterStatus status) {
		mTunerFilterCallback->onFilterStatus((int)status);
		return Void();
		void TunerFilter::FilterCallback::getSectionEvent(
		std::vector<DemuxFilterEvent::Event>& events, std::vector<TunerFilterEvent>& res) {
		for (DemuxFilterEvent::Event e : events) {
		DemuxFilterSectionEvent sectionEvent = e.section();
		TunerFilterSectionEvent tunerSection;

		tunerSection.tableId = static_cast<char>(sectionEvent.tableId);
		tunerSection.version = static_cast<char>(sectionEvent.version);
		tunerSection.sectionNum = static_cast<char>(sectionEvent.sectionNum);
		tunerSection.dataLength = static_cast<char>(sectionEvent.dataLength);

		TunerFilterEvent tunerEvent;
		tunerEvent.set<TunerFilterEvent::section>(std::move(tunerSection));
		res.push_back(std::move(tunerEvent));
		}
		}

		Return<void> TunerFilter::FilterCallback::onFilterEvent(const DemuxFilterEvent& filterEvent) {
		std::vector<DemuxFilterEvent::Event> events = filterEvent.events;
		std::vector<TunerFilterEvent> tunerEvent;
		void TunerFilter::FilterCallback::getPesEvent(
		std::vector<DemuxFilterEvent::Event>& events, std::vector<TunerFilterEvent>& res) {
		for (DemuxFilterEvent::Event e : events) {
		DemuxFilterPesEvent pesEvent = e.pes();
		TunerFilterPesEvent tunerPes;

		if (!events.empty()) {
		DemuxFilterEvent::Event event = events[0];
		switch (event.getDiscriminator()) {
		case DemuxFilterEvent::Event::hidl_discriminator::media: {
		getMediaEvent(events, tunerEvent);
		tunerPes.streamId = static_cast<char>(pesEvent.streamId);
		tunerPes.dataLength = static_cast<int>(pesEvent.dataLength);
		tunerPes.mpuSequenceNumber = static_cast<int>(pesEvent.mpuSequenceNumber);

		TunerFilterEvent tunerEvent;
		tunerEvent.set<TunerFilterEvent::pes>(std::move(tunerPes));
		res.push_back(std::move(tunerEvent));
		}
		}

		void TunerFilter::FilterCallback::getTsRecordEvent(std::vector<DemuxFilterEvent::Event>& events,
		std::vector<DemuxFilterEventExt::Event>& eventsExt, std::vector<TunerFilterEvent>& res) {
		for (int i = 0; i < events.size(); i++) {
		TunerFilterTsRecordEvent tunerTsRecord;
		DemuxFilterTsRecordEvent tsRecordEvent = events[i].tsRecord();

		TunerFilterScIndexMask scIndexMask;
		if (tsRecordEvent.scIndexMask.getDiscriminator()
		== DemuxFilterTsRecordEvent::ScIndexMask::hidl_discriminator::sc) {
		scIndexMask.set<TunerFilterScIndexMask::sc>(
		static_cast<int>(tsRecordEvent.scIndexMask.sc()));
		} else if (tsRecordEvent.scIndexMask.getDiscriminator()
		== DemuxFilterTsRecordEvent::ScIndexMask::hidl_discriminator::scHevc) {
		scIndexMask.set<TunerFilterScIndexMask::scHevc>(
		static_cast<int>(tsRecordEvent.scIndexMask.scHevc()));
		}

		if (tsRecordEvent.pid.getDiscriminator() == DemuxPid::hidl_discriminator::tPid) {
		tunerTsRecord.pid = static_cast<char>(tsRecordEvent.pid.tPid());
		} else {
		tunerTsRecord.pid = static_cast<char>(Constant::INVALID_TS_PID);
		}

		tunerTsRecord.scIndexMask = scIndexMask;
		tunerTsRecord.tsIndexMask = static_cast<int>(tsRecordEvent.tsIndexMask);
		tunerTsRecord.byteNumber = static_cast<long>(tsRecordEvent.byteNumber);

		if (eventsExt.size() > i && eventsExt[i].getDiscriminator() ==
		DemuxFilterEventExt::Event::hidl_discriminator::tsRecord) {
		tunerTsRecord.isExtended = true;
		tunerTsRecord.pts = static_cast<long>(eventsExt[i].tsRecord().pts);
		tunerTsRecord.firstMbInSlice = static_cast<int>(eventsExt[i].tsRecord().firstMbInSlice);
		} else {
		tunerTsRecord.isExtended = false;
		}

		TunerFilterEvent tunerEvent;
		tunerEvent.set<TunerFilterEvent::tsRecord>(std::move(tunerTsRecord));
		res.push_back(std::move(tunerEvent));
		}
		}

		void TunerFilter::FilterCallback::getMmtpRecordEvent(std::vector<DemuxFilterEvent::Event>& events,
		std::vector<DemuxFilterEventExt::Event>& eventsExt, std::vector<TunerFilterEvent>& res) {
		for (int i = 0; i < events.size(); i++) {
		TunerFilterMmtpRecordEvent tunerMmtpRecord;
		DemuxFilterMmtpRecordEvent mmtpRecordEvent = events[i].mmtpRecord();

		tunerMmtpRecord.scHevcIndexMask = static_cast<int>(mmtpRecordEvent.scHevcIndexMask);
		tunerMmtpRecord.byteNumber = static_cast<long>(mmtpRecordEvent.byteNumber);

		if (eventsExt.size() > i && eventsExt[i].getDiscriminator() ==
		DemuxFilterEventExt::Event::hidl_discriminator::mmtpRecord) {
		tunerMmtpRecord.isExtended = true;
		tunerMmtpRecord.pts = static_cast<long>(eventsExt[i].mmtpRecord().pts);
		tunerMmtpRecord.mpuSequenceNumber =
		static_cast<int>(eventsExt[i].mmtpRecord().mpuSequenceNumber);
		tunerMmtpRecord.firstMbInSlice =
		static_cast<int>(eventsExt[i].mmtpRecord().firstMbInSlice);
		tunerMmtpRecord.tsIndexMask = static_cast<int>(eventsExt[i].mmtpRecord().tsIndexMask);
		} else {
		tunerMmtpRecord.isExtended = false;
		}

		TunerFilterEvent tunerEvent;
		tunerEvent.set<TunerFilterEvent::mmtpRecord>(std::move(tunerMmtpRecord));
		res.push_back(std::move(tunerEvent));
		}
		}

		void TunerFilter::FilterCallback::getDownloadEvent(
		std::vector<DemuxFilterEvent::Event>& events, std::vector<TunerFilterEvent>& res) {
		for (DemuxFilterEvent::Event e : events) {
		DemuxFilterDownloadEvent downloadEvent = e.download();
		TunerFilterDownloadEvent tunerDownload;

		tunerDownload.itemId = static_cast<int>(downloadEvent.itemId);
		tunerDownload.itemFragmentIndex = static_cast<int>(downloadEvent.itemFragmentIndex);
		tunerDownload.mpuSequenceNumber = static_cast<int>(downloadEvent.mpuSequenceNumber);
		tunerDownload.lastItemFragmentIndex = static_cast<int>(downloadEvent.lastItemFragmentIndex);
		tunerDownload.dataLength = static_cast<char>(downloadEvent.dataLength);

		TunerFilterEvent tunerEvent;
		tunerEvent.set<TunerFilterEvent::download>(std::move(tunerDownload));
		res.push_back(std::move(tunerEvent));
		}
		}

		void TunerFilter::FilterCallback::getIpPayloadEvent(
		std::vector<DemuxFilterEvent::Event>& events, std::vector<TunerFilterEvent>& res) {
		for (DemuxFilterEvent::Event e : events) {
		DemuxFilterIpPayloadEvent ipPayloadEvent = e.ipPayload();
		TunerFilterIpPayloadEvent tunerIpPayload;

		tunerIpPayload.dataLength = static_cast<char>(ipPayloadEvent.dataLength);

		TunerFilterEvent tunerEvent;
		tunerEvent.set<TunerFilterEvent::ipPayload>(std::move(tunerIpPayload));
		res.push_back(std::move(tunerEvent));
		}
		}

		void TunerFilter::FilterCallback::getTemiEvent(
		std::vector<DemuxFilterEvent::Event>& events, std::vector<TunerFilterEvent>& res) {
		for (DemuxFilterEvent::Event e : events) {
		DemuxFilterTemiEvent temiEvent = e.temi();
		TunerFilterTemiEvent tunerTemi;

		tunerTemi.pts = static_cast<long>(temiEvent.pts);
		tunerTemi.descrTag = static_cast<int8_t>(temiEvent.descrTag);
		std::vector<uint8_t> descrData = temiEvent.descrData;
		tunerTemi.descrData.resize(descrData.size());
		copy(descrData.begin(), descrData.end(), tunerTemi.descrData.begin());

		TunerFilterEvent tunerEvent;
		tunerEvent.set<TunerFilterEvent::temi>(std::move(tunerTemi));
		res.push_back(std::move(tunerEvent));
		}
		}

		void TunerFilter::FilterCallback::getMonitorEvent(
		std::vector<DemuxFilterEventExt::Event>& eventsExt, std::vector<TunerFilterEvent>& res) {
		DemuxFilterMonitorEvent monitorEvent = eventsExt[0].monitorEvent();
		TunerFilterMonitorEvent tunerMonitor;

		switch (monitorEvent.getDiscriminator()) {
		case DemuxFilterMonitorEvent::hidl_discriminator::scramblingStatus: {
		tunerMonitor.set<TunerFilterMonitorEvent::scramblingStatus>(
		static_cast<int>(monitorEvent.scramblingStatus()));
		break;
		}
		default: {
		case DemuxFilterMonitorEvent::hidl_discriminator::cid: {
		tunerMonitor.set<TunerFilterMonitorEvent::cid>(static_cast<int>(monitorEvent.cid()));
		break;
		}
		default: {
		break;
		}
		}

		mTunerFilterCallback->onFilterEvent(tunerEvent);
		return Void();
		TunerFilterEvent tunerEvent;
		tunerEvent.set<TunerFilterEvent::monitor>(std::move(tunerMonitor));
		res.push_back(std::move(tunerEvent));
		}

		void TunerFilter::FilterCallback::getRestartEvent(
		std::vector<DemuxFilterEventExt::Event>& eventsExt, std::vector<TunerFilterEvent>& res) {
		TunerFilterEvent tunerEvent;
		tunerEvent.set<TunerFilterEvent::startId>(static_cast<int>(eventsExt[0].startId()));
		res.push_back(std::move(tunerEvent));
		}
		} // namespace android

services/tuner/TunerFilter.h

+55 −2

Original line number	Diff line number	Diff line
		@@ -20,26 +20,48 @@
		#include <aidl/android/media/tv/tuner/BnTunerFilter.h>
		#include <aidl/android/media/tv/tuner/ITunerFilterCallback.h>
		#include <aidlcommonsupport/NativeHandle.h>
		#include <android/hardware/tv/tuner/1.1/IFilter.h>
		#include <android/hardware/tv/tuner/1.0/ITuner.h>
		#include <android/hardware/tv/tuner/1.1/IFilter.h>
		#include <android/hardware/tv/tuner/1.1/IFilterCallback.h>
		#include <android/hardware/tv/tuner/1.1/types.h>
		#include <media/stagefright/foundation/ADebug.h>

		using Status = ::ndk::ScopedAStatus;
		using ::aidl::android::media::tv::tuner::BnTunerFilter;
		using ::aidl::android::media::tv::tuner::ITunerFilterCallback;
		using ::aidl::android::media::tv::tuner::TunerFilterConfiguration;
		using ::aidl::android::media::tv::tuner::TunerFilterDownloadEvent;
		using ::aidl::android::media::tv::tuner::TunerFilterIpPayloadEvent;
		using ::aidl::android::media::tv::tuner::TunerFilterEvent;
		using ::aidl::android::media::tv::tuner::TunerFilterMediaEvent;
		using ::aidl::android::media::tv::tuner::TunerFilterMmtpRecordEvent;
		using ::aidl::android::media::tv::tuner::TunerFilterMonitorEvent;
		using ::aidl::android::media::tv::tuner::TunerFilterPesEvent;
		using ::aidl::android::media::tv::tuner::TunerFilterScIndexMask;
		using ::aidl::android::media::tv::tuner::TunerFilterSectionEvent;
		using ::aidl::android::media::tv::tuner::TunerFilterSharedHandleInfo;
		using ::aidl::android::media::tv::tuner::TunerFilterSettings;
		using ::aidl::android::media::tv::tuner::TunerFilterTemiEvent;
		using ::aidl::android::media::tv::tuner::TunerFilterTsRecordEvent;
		using ::android::hardware::Return;
		using ::android::hardware::Void;
		using ::android::hardware::tv::tuner::V1_0::DemuxFilterAvSettings;
		using ::android::hardware::tv::tuner::V1_0::DemuxFilterDownloadEvent;
		using ::android::hardware::tv::tuner::V1_0::DemuxFilterIpPayloadEvent;
		using ::android::hardware::tv::tuner::V1_0::DemuxFilterEvent;
		using ::android::hardware::tv::tuner::V1_0::DemuxFilterMediaEvent;
		using ::android::hardware::tv::tuner::V1_0::DemuxFilterMmtpRecordEvent;
		using ::android::hardware::tv::tuner::V1_0::DemuxFilterPesEvent;
		using ::android::hardware::tv::tuner::V1_0::DemuxFilterSectionEvent;
		using ::android::hardware::tv::tuner::V1_0::DemuxFilterStatus;
		using ::android::hardware::tv::tuner::V1_0::DemuxFilterTemiEvent;
		using ::android::hardware::tv::tuner::V1_0::DemuxFilterTsRecordEvent;
		using ::android::hardware::tv::tuner::V1_0::DemuxPid;
		using ::android::hardware::tv::tuner::V1_0::IFilter;
		using ::android::hardware::tv::tuner::V1_0::IFilterCallback;
		using ::android::hardware::tv::tuner::V1_1::DemuxFilterEventExt;
		using ::android::hardware::tv::tuner::V1_1::DemuxFilterMonitorEvent;
		using ::android::hardware::tv::tuner::V1_1::DemuxFilterTsRecordEventExt;
		using ::android::hardware::tv::tuner::V1_1::IFilterCallback;

		namespace android {

		@@ -65,9 +87,40 @@ public:
		: mTunerFilterCallback(tunerFilterCallback) {};

		virtual Return<void> onFilterEvent(const DemuxFilterEvent& filterEvent);
		virtual Return<void> onFilterEvent_1_1(const DemuxFilterEvent& filterEvent,
		const DemuxFilterEventExt& filterEventExt);
		virtual Return<void> onFilterStatus(DemuxFilterStatus status);

		void getAidlFilterEvent(std::vector<DemuxFilterEvent::Event>& events,
		std::vector<DemuxFilterEventExt::Event>& eventsExt,
		std::vector<TunerFilterEvent>& tunerEvent);

		void getMediaEvent(
		std::vector<DemuxFilterEvent::Event>& events, std::vector<TunerFilterEvent>& res);
		void getSectionEvent(
		std::vector<DemuxFilterEvent::Event>& events, std::vector<TunerFilterEvent>& res);
		void getPesEvent(
		std::vector<DemuxFilterEvent::Event>& events, std::vector<TunerFilterEvent>& res);
		void getTsRecordEvent(
		std::vector<DemuxFilterEvent::Event>& events,
		std::vector<DemuxFilterEventExt::Event>& eventsExt,
		std::vector<TunerFilterEvent>& res);
		void getMmtpRecordEvent(
		std::vector<DemuxFilterEvent::Event>& events,
		std::vector<DemuxFilterEventExt::Event>& eventsExt,
		std::vector<TunerFilterEvent>& res);
		void getDownloadEvent(
		std::vector<DemuxFilterEvent::Event>& events, std::vector<TunerFilterEvent>& res);
		void getIpPayloadEvent(
		std::vector<DemuxFilterEvent::Event>& events, std::vector<TunerFilterEvent>& res);
		void getTemiEvent(
		std::vector<DemuxFilterEvent::Event>& events, std::vector<TunerFilterEvent>& res);
		void getMonitorEvent(
		std::vector<DemuxFilterEventExt::Event>& eventsExt,
		std::vector<TunerFilterEvent>& res);
		void getRestartEvent(
		std::vector<DemuxFilterEventExt::Event>& eventsExt,
		std::vector<TunerFilterEvent>& res);

		std::shared_ptr<ITunerFilterCallback> mTunerFilterCallback;
		};

services/tuner/aidl/android/media/tv/tuner/TunerAudioExtraMetaData.aidl

0 → 100644

+36 −0

Original line number	Diff line number	Diff line
		/**
		* Copyright 2021, 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.
		*/

		package android.media.tv.tuner;

		/**
		* Extra Meta Data from AD (Audio Descriptor) according to ETSI TS 101 154 V2.1.1.
		*
		* {@hide}
		*/
		parcelable TunerAudioExtraMetaData {
		byte adFade;

		byte adPan;

		byte versionTextTag;

		byte adGainCenter;

		byte adGainFront;

		byte adGainSurround;
		}

services/tuner/aidl/android/media/tv/tuner/TunerFilterDownloadEvent.aidl

0 → 100644

+40 −0

Original line number	Diff line number	Diff line
		/**
		* Copyright 2021, 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.
		*/

		package android.media.tv.tuner;

		/**
		* Filter Event for Download data.
		*
		* {@hide}
		*/
		parcelable TunerFilterDownloadEvent {
		int itemId;

		/**
		* MPU sequence number of filtered data (only for MMTP)
		*/
		int mpuSequenceNumber;

		int itemFragmentIndex;

		int lastItemFragmentIndex;

		/**
		* Data size in bytes of filtered data
		*/
		char dataLength;
		}

services/tuner/aidl/android/media/tv/tuner/TunerFilterEvent.aidl

+26 −0

Original line number	Diff line number	Diff line
		@@ -16,7 +16,15 @@

		package android.media.tv.tuner;

		import android.media.tv.tuner.TunerFilterDownloadEvent;
		import android.media.tv.tuner.TunerFilterIpPayloadEvent;
		import android.media.tv.tuner.TunerFilterMediaEvent;
		import android.media.tv.tuner.TunerFilterMmtpRecordEvent;
		import android.media.tv.tuner.TunerFilterMonitorEvent;
		import android.media.tv.tuner.TunerFilterPesEvent;
		import android.media.tv.tuner.TunerFilterSectionEvent;
		import android.media.tv.tuner.TunerFilterTemiEvent;
		import android.media.tv.tuner.TunerFilterTsRecordEvent;

		/**
		* Filter events.
		@@ -25,4 +33,22 @@ import android.media.tv.tuner.TunerFilterMediaEvent;
		*/
		union TunerFilterEvent {
		TunerFilterMediaEvent media;

		TunerFilterSectionEvent section;

		TunerFilterPesEvent pes;

		TunerFilterTsRecordEvent tsRecord;

		TunerFilterMmtpRecordEvent mmtpRecord;

		TunerFilterDownloadEvent download;

		TunerFilterIpPayloadEvent ipPayload;

		TunerFilterTemiEvent temi;

		TunerFilterMonitorEvent monitor;

		int startId;
		}