Add default implementation of Tuner HAL 1.1 (bb94eeb4) · Commits · e / os / android_hardware_interfaces

tv/tuner/1.1/default/Android.bp

0 → 100644

+52 −0

Original line number	Original line	Diff line number	Diff line
			cc_defaults {
			name: "tuner_service_defaults@1.1",
			defaults: ["hidl_defaults"],
			vendor: true,
			relative_install_path: "hw",
			srcs: [
			"Filter.cpp",
			"Frontend.cpp",
			"Descrambler.cpp",
			"Demux.cpp",
			"Dvr.cpp",
			"TimeFilter.cpp",
			"Tuner.cpp",
			"Lnb.cpp",
			"service.cpp",
			],

			compile_multilib: "first",

			shared_libs: [
			"android.hardware.tv.tuner@1.0",
			"android.hardware.tv.tuner@1.1",
			"android.hidl.memory@1.0",
			"libcutils",
			"libfmq",
			"libhidlbase",
			"libhidlmemory",
			"libion",
			"liblog",
			"libstagefright_foundation",
			"libutils",
			],
			header_libs: [
			"media_plugin_headers",
			],
			}

			cc_binary {
			name: "android.hardware.tv.tuner@1.1-service",
			vintf_fragments: ["android.hardware.tv.tuner@1.1-service.xml"],
			defaults: ["tuner_service_defaults@1.1"],
			init_rc: ["android.hardware.tv.tuner@1.1-service.rc"],
			}

			cc_binary {
			name: "android.hardware.tv.tuner@1.1-service-lazy",
			vintf_fragments: ["android.hardware.tv.tuner@1.1-service-lazy.xml"],
			overrides: ["android.hardware.tv.tuner@1.1-service"],
			defaults: ["tuner_service_defaults@1.1"],
			init_rc: ["android.hardware.tv.tuner@1.1-service-lazy.rc"],
			cflags: ["-DLAZY_SERVICE"],
			}

tv/tuner/1.1/default/Demux.cpp

0 → 100644

+395 −0

Original line number	Original line	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 "android.hardware.tv.tuner@1.1-Demux"

			#include "Demux.h"
			#include <utils/Log.h>

			namespace android {
			namespace hardware {
			namespace tv {
			namespace tuner {
			namespace V1_0 {
			namespace implementation {

			#define WAIT_TIMEOUT 3000000000
			Demux::Demux(uint32_t demuxId, sp<Tuner> tuner) {
			mDemuxId = demuxId;
			mTunerService = tuner;
			}

			Demux::~Demux() {}

			Return<Result> Demux::setFrontendDataSource(uint32_t frontendId) {
			ALOGV("%s", __FUNCTION__);

			if (mTunerService == nullptr) {
			return Result::NOT_INITIALIZED;
			}

			mFrontend = mTunerService->getFrontendById(frontendId);

			if (mFrontend == nullptr) {
			return Result::INVALID_STATE;
			}

			mTunerService->setFrontendAsDemuxSource(frontendId, mDemuxId);

			return Result::SUCCESS;
			}

			Return<void> Demux::openFilter(const DemuxFilterType& type, uint32_t bufferSize,
			const sp<IFilterCallback>& cb, openFilter_cb _hidl_cb) {
			ALOGV("%s", __FUNCTION__);

			uint64_t filterId;
			filterId = ++mLastUsedFilterId;

			if (cb == nullptr) {
			ALOGW("[Demux] callback can't be null");
			_hidl_cb(Result::INVALID_ARGUMENT, new Filter());
			return Void();
			}

			sp<Filter> filter = new Filter(type, filterId, bufferSize, cb, this);

			if (!filter->createFilterMQ()) {
			_hidl_cb(Result::UNKNOWN_ERROR, filter);
			return Void();
			}

			mFilters[filterId] = filter;
			if (filter->isPcrFilter()) {
			mPcrFilterIds.insert(filterId);
			}
			bool result = true;
			if (!filter->isRecordFilter()) {
			// Only save non-record filters for now. Record filters are saved when the
			// IDvr.attacheFilter is called.
			mPlaybackFilterIds.insert(filterId);
			if (mDvrPlayback != nullptr) {
			result = mDvrPlayback->addPlaybackFilter(filterId, filter);
			}
			}

			_hidl_cb(result ? Result::SUCCESS : Result::INVALID_ARGUMENT, filter);
			return Void();
			}

			Return<void> Demux::openTimeFilter(openTimeFilter_cb _hidl_cb) {
			ALOGV("%s", __FUNCTION__);

			mTimeFilter = new TimeFilter(this);

			_hidl_cb(Result::SUCCESS, mTimeFilter);
			return Void();
			}

			Return<void> Demux::getAvSyncHwId(const sp<IFilter>& filter, getAvSyncHwId_cb _hidl_cb) {
			ALOGV("%s", __FUNCTION__);

			uint32_t avSyncHwId = -1;
			uint64_t id;
			Result status;

			sp<V1_1::IFilter> filter_v1_1 = V1_1::IFilter::castFrom(filter);
			if (filter_v1_1 != NULL) {
			filter_v1_1->getId64Bit([&](Result result, uint64_t filterId) {
			id = filterId;
			status = result;
			});
			} else {
			filter->getId([&](Result result, uint32_t filterId) {
			id = filterId;
			status = result;
			});
			}

			if (status != Result::SUCCESS) {
			ALOGE("[Demux] Can't get filter Id.");
			_hidl_cb(Result::INVALID_STATE, avSyncHwId);
			return Void();
			}

			if (!mFilters[id]->isMediaFilter()) {
			ALOGE("[Demux] Given filter is not a media filter.");
			_hidl_cb(Result::INVALID_ARGUMENT, avSyncHwId);
			return Void();
			}

			if (!mPcrFilterIds.empty()) {
			// Return the lowest pcr filter id in the default implementation as the av sync id
			_hidl_cb(Result::SUCCESS, *mPcrFilterIds.begin());
			return Void();
			}

			ALOGE("[Demux] No PCR filter opened.");
			_hidl_cb(Result::INVALID_STATE, avSyncHwId);
			return Void();
			}

			Return<void> Demux::getAvSyncTime(AvSyncHwId avSyncHwId, getAvSyncTime_cb _hidl_cb) {
			ALOGV("%s", __FUNCTION__);

			uint64_t avSyncTime = -1;
			if (mPcrFilterIds.empty()) {
			_hidl_cb(Result::INVALID_STATE, avSyncTime);
			return Void();
			}
			if (avSyncHwId != *mPcrFilterIds.begin()) {
			_hidl_cb(Result::INVALID_ARGUMENT, avSyncTime);
			return Void();
			}

			_hidl_cb(Result::SUCCESS, avSyncTime);
			return Void();
			}

			Return<Result> Demux::close() {
			ALOGV("%s", __FUNCTION__);

			set<uint64_t>::iterator it;
			for (it = mPlaybackFilterIds.begin(); it != mPlaybackFilterIds.end(); it++) {
			mDvrPlayback->removePlaybackFilter(*it);
			}
			mPlaybackFilterIds.clear();
			mRecordFilterIds.clear();
			mFilters.clear();
			mLastUsedFilterId = -1;

			return Result::SUCCESS;
			}

			Return<void> Demux::openDvr(DvrType type, uint32_t bufferSize, const sp<IDvrCallback>& cb,
			openDvr_cb _hidl_cb) {
			ALOGV("%s", __FUNCTION__);

			if (cb == nullptr) {
			ALOGW("[Demux] DVR callback can't be null");
			_hidl_cb(Result::INVALID_ARGUMENT, new Dvr());
			return Void();
			}

			set<uint64_t>::iterator it;
			switch (type) {
			case DvrType::PLAYBACK:
			mDvrPlayback = new Dvr(type, bufferSize, cb, this);
			if (!mDvrPlayback->createDvrMQ()) {
			_hidl_cb(Result::UNKNOWN_ERROR, mDvrPlayback);
			return Void();
			}

			for (it = mPlaybackFilterIds.begin(); it != mPlaybackFilterIds.end(); it++) {
			if (!mDvrPlayback->addPlaybackFilter(it, mFilters[it])) {
			ALOGE("[Demux] Can't get filter info for DVR playback");
			_hidl_cb(Result::UNKNOWN_ERROR, mDvrPlayback);
			return Void();
			}
			}

			_hidl_cb(Result::SUCCESS, mDvrPlayback);
			return Void();
			case DvrType::RECORD:
			mDvrRecord = new Dvr(type, bufferSize, cb, this);
			if (!mDvrRecord->createDvrMQ()) {
			_hidl_cb(Result::UNKNOWN_ERROR, mDvrRecord);
			return Void();
			}

			_hidl_cb(Result::SUCCESS, mDvrRecord);
			return Void();
			default:
			_hidl_cb(Result::INVALID_ARGUMENT, nullptr);
			return Void();
			}
			}

			Return<Result> Demux::connectCiCam(uint32_t ciCamId) {
			ALOGV("%s", __FUNCTION__);

			mCiCamId = ciCamId;

			return Result::SUCCESS;
			}

			Return<Result> Demux::disconnectCiCam() {
			ALOGV("%s", __FUNCTION__);

			return Result::SUCCESS;
			}

			Result Demux::removeFilter(uint64_t filterId) {
			ALOGV("%s", __FUNCTION__);

			if (mDvrPlayback != nullptr) {
			mDvrPlayback->removePlaybackFilter(filterId);
			}
			mPlaybackFilterIds.erase(filterId);
			mRecordFilterIds.erase(filterId);
			mFilters.erase(filterId);

			return Result::SUCCESS;
			}

			void Demux::startBroadcastTsFilter(vector<uint8_t> data) {
			set<uint64_t>::iterator it;
			uint16_t pid = ((data[1] & 0x1f) << 8) \| ((data[2] & 0xff));
			if (DEBUG_DEMUX) {
			ALOGW("[Demux] start ts filter pid: %d", pid);
			}
			for (it = mPlaybackFilterIds.begin(); it != mPlaybackFilterIds.end(); it++) {
			if (pid == mFilters[*it]->getTpid()) {
			mFilters[*it]->updateFilterOutput(data);
			}
			}
			}

			void Demux::sendFrontendInputToRecord(vector<uint8_t> data) {
			set<uint64_t>::iterator it;
			if (DEBUG_DEMUX) {
			ALOGW("[Demux] update record filter output");
			}
			for (it = mRecordFilterIds.begin(); it != mRecordFilterIds.end(); it++) {
			mFilters[*it]->updateRecordOutput(data);
			}
			}

			bool Demux::startBroadcastFilterDispatcher() {
			set<uint64_t>::iterator it;

			// Handle the output data per filter type
			for (it = mPlaybackFilterIds.begin(); it != mPlaybackFilterIds.end(); it++) {
			if (mFilters[*it]->startFilterHandler() != Result::SUCCESS) {
			return false;
			}
			}

			return true;
			}

			bool Demux::startRecordFilterDispatcher() {
			set<uint64_t>::iterator it;

			for (it = mRecordFilterIds.begin(); it != mRecordFilterIds.end(); it++) {
			if (mFilters[*it]->startRecordFilterHandler() != Result::SUCCESS) {
			return false;
			}
			}

			return true;
			}

			Result Demux::startFilterHandler(uint64_t filterId) {
			return mFilters[filterId]->startFilterHandler();
			}

			void Demux::updateFilterOutput(uint64_t filterId, vector<uint8_t> data) {
			mFilters[filterId]->updateFilterOutput(data);
			}

			void Demux::updateMediaFilterOutput(uint64_t filterId, vector<uint8_t> data, uint64_t pts) {
			updateFilterOutput(filterId, data);
			mFilters[filterId]->updatePts(pts);
			}

			uint16_t Demux::getFilterTpid(uint64_t filterId) {
			return mFilters[filterId]->getTpid();
			}

			void Demux::startFrontendInputLoop() {
			pthread_create(&mFrontendInputThread, NULL, __threadLoopFrontend, this);
			pthread_setname_np(mFrontendInputThread, "frontend_input_thread");
			}

			void* Demux::__threadLoopFrontend(void* user) {
			Demux* const self = static_cast<Demux*>(user);
			self->frontendInputThreadLoop();
			return 0;
			}

			void Demux::frontendInputThreadLoop() {
			std::lock_guard<std::mutex> lock(mFrontendInputThreadLock);
			mFrontendInputThreadRunning = true;

			while (mFrontendInputThreadRunning) {
			uint32_t efState = 0;
			status_t status = mDvrPlayback->getDvrEventFlag()->wait(
			static_cast<uint32_t>(DemuxQueueNotifyBits::DATA_READY), &efState, WAIT_TIMEOUT,
			true /* retry on spurious wake */);
			if (status != OK) {
			ALOGD("[Demux] wait for data ready on the playback FMQ");
			continue;
			}
			if (mDvrPlayback->getSettings().playback().dataFormat == DataFormat::ES) {
			if (!mDvrPlayback->processEsDataOnPlayback(true /isVirtualFrontend/, mIsRecording)) {
			ALOGE("[Demux] playback es data failed to be filtered. Ending thread");
			break;
			}
			}
			// Our current implementation filter the data and write it into the filter FMQ immediately
			// after the DATA_READY from the VTS/framework
			if (!mDvrPlayback->readPlaybackFMQ(true /isVirtualFrontend/, mIsRecording) \|\|
			!mDvrPlayback->startFilterDispatcher(true /isVirtualFrontend/, mIsRecording)) {
			ALOGE("[Demux] playback data failed to be filtered. Ending thread");
			break;
			}
			}

			mFrontendInputThreadRunning = false;
			ALOGW("[Demux] Frontend Input thread end.");
			}

			void Demux::stopFrontendInput() {
			ALOGD("[Demux] stop frontend on demux");
			mKeepFetchingDataFromFrontend = false;
			mFrontendInputThreadRunning = false;
			std::lock_guard<std::mutex> lock(mFrontendInputThreadLock);
			}

			void Demux::setIsRecording(bool isRecording) {
			mIsRecording = isRecording;
			}

			bool Demux::attachRecordFilter(uint64_t filterId) {
			if (mFilters[filterId] == nullptr \|\| mDvrRecord == nullptr \|\|
			!mFilters[filterId]->isRecordFilter()) {
			return false;
			}

			mRecordFilterIds.insert(filterId);
			mFilters[filterId]->attachFilterToRecord(mDvrRecord);

			return true;
			}

			bool Demux::detachRecordFilter(uint64_t filterId) {
			if (mFilters[filterId] == nullptr \|\| mDvrRecord == nullptr) {
			return false;
			}

			mRecordFilterIds.erase(filterId);
			mFilters[filterId]->detachFilterFromRecord();

			return true;
			}

			} // namespace implementation
			} // namespace V1_0
			} // namespace tuner
			} // namespace tv
			} // namespace hardware
			} // namespace android

tv/tuner/1.1/default/Demux.h

0 → 100644

+197 −0

Original line number	Original line	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.
			*/

			#ifndef ANDROID_HARDWARE_TV_TUNER_V1_1_DEMUX_H_
			#define ANDROID_HARDWARE_TV_TUNER_V1_1_DEMUX_H_

			#include <fmq/MessageQueue.h>
			#include <math.h>
			#include <set>
			#include "Dvr.h"
			#include "Filter.h"
			#include "Frontend.h"
			#include "TimeFilter.h"
			#include "Tuner.h"

			using namespace std;

			namespace android {
			namespace hardware {
			namespace tv {
			namespace tuner {
			namespace V1_0 {
			namespace implementation {

			using ::android::hardware::EventFlag;
			using ::android::hardware::kSynchronizedReadWrite;
			using ::android::hardware::MessageQueue;
			using ::android::hardware::MQDescriptorSync;

			using FilterMQ = MessageQueue<uint8_t, kSynchronizedReadWrite>;

			class Dvr;
			class Filter;
			class Frontend;
			class TimeFilter;
			class Tuner;

			class Demux : public IDemux {
			public:
			Demux(uint32_t demuxId, sp<Tuner> tuner);

			~Demux();

			virtual Return<Result> setFrontendDataSource(uint32_t frontendId) override;

			virtual Return<void> openFilter(const DemuxFilterType& type, uint32_t bufferSize,
			const sp<IFilterCallback>& cb, openFilter_cb _hidl_cb) override;

			virtual Return<void> openTimeFilter(openTimeFilter_cb _hidl_cb) override;

			virtual Return<void> getAvSyncHwId(const sp<IFilter>& filter,
			getAvSyncHwId_cb _hidl_cb) override;

			virtual Return<void> getAvSyncTime(AvSyncHwId avSyncHwId, getAvSyncTime_cb _hidl_cb) override;

			virtual Return<Result> close() override;

			virtual Return<void> openDvr(DvrType type, uint32_t bufferSize, const sp<IDvrCallback>& cb,
			openDvr_cb _hidl_cb) override;

			virtual Return<Result> connectCiCam(uint32_t ciCamId) override;

			virtual Return<Result> disconnectCiCam() override;

			// Functions interacts with Tuner Service
			void stopFrontendInput();
			Result removeFilter(uint64_t filterId);
			bool attachRecordFilter(uint64_t filterId);
			bool detachRecordFilter(uint64_t filterId);
			Result startFilterHandler(uint64_t filterId);
			void updateFilterOutput(uint64_t filterId, vector<uint8_t> data);
			void updateMediaFilterOutput(uint64_t filterId, vector<uint8_t> data, uint64_t pts);
			uint16_t getFilterTpid(uint64_t filterId);
			void setIsRecording(bool isRecording);
			void startFrontendInputLoop();

			/**
			* A dispatcher to read and dispatch input data to all the started filters.
			* Each filter handler handles the data filtering/output writing/filterEvent updating.
			* Note that recording filters are not included.
			*/
			bool startBroadcastFilterDispatcher();
			void startBroadcastTsFilter(vector<uint8_t> data);

			void sendFrontendInputToRecord(vector<uint8_t> data);
			bool startRecordFilterDispatcher();

			private:
			// Tuner service
			sp<Tuner> mTunerService;

			// Frontend source
			sp<Frontend> mFrontend;

			// A struct that passes the arguments to a newly created filter thread
			struct ThreadArgs {
			Demux* user;
			uint64_t filterId;
			};

			static void* __threadLoopFrontend(void* user);
			void frontendInputThreadLoop();

			/**
			* To create a FilterMQ with the next available Filter ID.
			* Creating Event Flag at the same time.
			* Add the successfully created/saved FilterMQ into the local list.
			*
			* Return false is any of the above processes fails.
			*/
			void deleteEventFlag();
			bool readDataFromMQ();

			uint32_t mDemuxId = -1;
			uint32_t mCiCamId;
			set<uint64_t> mPcrFilterIds;
			/**
			* Record the last used filter id. Initial value is -1.
			* Filter Id starts with 0.
			*/
			uint64_t mLastUsedFilterId = -1;
			/**
			* Record all the used playback filter Ids.
			* Any removed filter id should be removed from this set.
			*/
			set<uint64_t> mPlaybackFilterIds;
			/**
			* Record all the attached record filter Ids.
			* Any removed filter id should be removed from this set.
			*/
			set<uint64_t> mRecordFilterIds;
			/**
			* A list of created Filter sp.
			* The array number is the filter ID.
			*/
			std::map<uint64_t, sp<Filter>> mFilters;

			/**
			* Local reference to the opened Timer Filter instance.
			*/
			sp<TimeFilter> mTimeFilter;

			/**
			* Local reference to the opened DVR object.
			*/
			sp<Dvr> mDvrPlayback;
			sp<Dvr> mDvrRecord;

			// Thread handlers
			pthread_t mFrontendInputThread;
			/**
			* If a specific filter's writing loop is still running
			*/
			bool mFrontendInputThreadRunning;
			bool mKeepFetchingDataFromFrontend;
			/**
			* If the dvr recording is running.
			*/
			bool mIsRecording = false;
			/**
			* Lock to protect writes to the FMQs
			*/
			std::mutex mWriteLock;
			/**
			* Lock to protect writes to the input status
			*/
			std::mutex mFrontendInputThreadLock;

			// temp handle single PES filter
			// TODO handle mulptiple Pes filters
			int mPesSizeLeft = 0;
			vector<uint8_t> mPesOutput;

			const bool DEBUG_DEMUX = false;
			};

			} // namespace implementation
			} // namespace V1_0
			} // namespace tuner
			} // namespace tv
			} // namespace hardware
			} // namespace android

			#endif // ANDROID_HARDWARE_TV_TUNER_V1_1_DEMUX_H_

tv/tuner/1.1/default/Descrambler.cpp

0 → 100644

+80 −0

Original line number	Original line	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 "android.hardware.tv.tuner@1.1-Descrambler"

			#include <android/hardware/tv/tuner/1.0/IFrontendCallback.h>
			#include <utils/Log.h>

			#include "Descrambler.h"

			namespace android {
			namespace hardware {
			namespace tv {
			namespace tuner {
			namespace V1_0 {
			namespace implementation {

			Descrambler::Descrambler() {}

			Descrambler::~Descrambler() {}

			Return<Result> Descrambler::setDemuxSource(uint32_t demuxId) {
			ALOGV("%s", __FUNCTION__);
			if (mDemuxSet) {
			ALOGW("[ WARN ] Descrambler has already been set with a demux id %" PRIu32,
			mSourceDemuxId);
			return Result::INVALID_STATE;
			}
			mDemuxSet = true;
			mSourceDemuxId = static_cast<uint32_t>(demuxId);

			return Result::SUCCESS;
			}

			Return<Result> Descrambler::setKeyToken(const hidl_vec<uint8_t>& /* keyToken */) {
			ALOGV("%s", __FUNCTION__);

			return Result::SUCCESS;
			}

			Return<Result> Descrambler::addPid(const DemuxPid& /* pid */,
			const sp<IFilter>& /* optionalSourceFilter */) {
			ALOGV("%s", __FUNCTION__);

			return Result::SUCCESS;
			}

			Return<Result> Descrambler::removePid(const DemuxPid& /* pid */,
			const sp<IFilter>& /* optionalSourceFilter */) {
			ALOGV("%s", __FUNCTION__);

			return Result::SUCCESS;
			}

			Return<Result> Descrambler::close() {
			ALOGV("%s", __FUNCTION__);
			mDemuxSet = false;

			return Result::SUCCESS;
			}

			} // namespace implementation
			} // namespace V1_0
			} // namespace tuner
			} // namespace tv
			} // namespace hardware
			} // namespace android

tv/tuner/1.1/default/Descrambler.h

0 → 100644

+62 −0

Original line number	Original line	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.
			*/

			#ifndef ANDROID_HARDWARE_TV_TUNER_V1_1_DESCRAMBLER_H_
			#define ANDROID_HARDWARE_TV_TUNER_V1_1_DESCRAMBLER_H_

			#include <android/hardware/tv/tuner/1.0/IDescrambler.h>
			#include <android/hardware/tv/tuner/1.1/ITuner.h>
			#include <inttypes.h>

			using namespace std;

			namespace android {
			namespace hardware {
			namespace tv {
			namespace tuner {
			namespace V1_0 {
			namespace implementation {

			class Descrambler : public IDescrambler {
			public:
			Descrambler();

			virtual Return<Result> setDemuxSource(uint32_t demuxId) override;

			virtual Return<Result> setKeyToken(const hidl_vec<uint8_t>& keyToken) override;

			virtual Return<Result> addPid(const DemuxPid& pid,
			const sp<IFilter>& optionalSourceFilter) override;

			virtual Return<Result> removePid(const DemuxPid& pid,
			const sp<IFilter>& optionalSourceFilter) override;

			virtual Return<Result> close() override;

			private:
			virtual ~Descrambler();
			uint32_t mSourceDemuxId;
			bool mDemuxSet = false;
			};

			} // namespace implementation
			} // namespace V1_0
			} // namespace tuner
			} // namespace tv
			} // namespace hardware
			} // namespace android

			#endif // ANDROID_HARDWARE_TV_TUNER_V1_DESCRAMBLER_H_