Merge changes from topic "tuner_aidl_fw" (09b22d1a) · Commits · e / os / android_frameworks_av

services/tuner/.clang-format

0 → 100644

+33 −0

Original line number	Diff line number	Diff line
		---
		BasedOnStyle: Google
		AllowShortFunctionsOnASingleLine: Inline
		AllowShortIfStatementsOnASingleLine: true
		AllowShortLoopsOnASingleLine: true
		BinPackArguments: true
		BinPackParameters: true
		CommentPragmas: NOLINT:.*
		ContinuationIndentWidth: 8
		DerivePointerAlignment: false
		IndentWidth: 4
		PointerAlignment: Left
		TabWidth: 4

		# Deviations from the above file:
		# "Don't indent the section label"
		AccessModifierOffset: -4
		# "Each line of text in your code should be at most 100 columns long."
		ColumnLimit: 100
		# "Constructor initializer lists can be all on one line or with subsequent
		# lines indented eight spaces.". clang-format does not support having the colon
		# on the same line as the constructor function name, so this is the best
		# approximation of that rule, which makes all entries in the list (except the
		# first one) have an eight space indentation.
		ConstructorInitializerIndentWidth: 6
		# There is nothing in go/droidcppstyle about case labels, but there seems to be
		# more code that does not indent the case labels in frameworks/base.
		IndentCaseLabels: false
		# There have been some bugs in which subsequent formatting operations introduce
		# weird comment jumps.
		ReflowComments: false
		# Android does support C++11 now.
		Standard: Cpp11
		No newline at end of file

services/tuner/Android.bp

+4 −47

Original line number	Diff line number	Diff line
		@@ -7,33 +7,15 @@ package {
		default_applicable_licenses: ["frameworks_av_license"],
		}

		filegroup {
		name: "tv_tuner_aidl",
		srcs: [
		"aidl/android/media/tv/tuner/*.aidl",
		],
		path: "aidl",
		}

		filegroup {
		name: "tv_tuner_frontend_info",
		srcs: [
		"aidl/android/media/tv/tuner/TunerFrontendInfo.aidl",
		"aidl/android/media/tv/tuner/TunerFrontend*Capabilities.aidl",
		],
		path: "aidl",
		}

		aidl_interface {
		name: "tv_tuner_aidl_interface",
		unstable: true,
		local_include_dir: "aidl",
		srcs: [
		":tv_tuner_aidl",
		],
		srcs: ["aidl/android/media/tv/tuner/*.aidl"],
		imports: [
		"android.hardware.common-V2",
		"android.hardware.common.fmq-V1",
		"android.hardware.tv.tuner-V1",
		],

		backend: {
		@@ -49,27 +31,6 @@ aidl_interface {
		},
		}

		aidl_interface {
		name: "tv_tuner_frontend_info_aidl_interface",
		unstable: true,
		local_include_dir: "aidl",
		srcs: [
		":tv_tuner_frontend_info",
		],

		backend: {
		java: {
		enabled: true,
		},
		cpp: {
		enabled: true,
		},
		ndk: {
		enabled: true,
		},
		},
		}

		cc_library {
		name: "libtunerservice",

		@@ -78,8 +39,7 @@ cc_library {
		],

		shared_libs: [
		"android.hardware.tv.tuner@1.0",
		"android.hardware.tv.tuner@1.1",
		"android.hardware.tv.tuner-V1-ndk",
		"libbase",
		"libbinder",
		"libbinder_ndk",
		@@ -91,7 +51,6 @@ cc_library {
		"libutils",
		"tv_tuner_aidl_interface-ndk",
		"tv_tuner_resource_manager_aidl_interface-ndk",
		"tv_tuner_resource_manager_aidl_interface-cpp",
		],

		static_libs: [
		@@ -120,8 +79,7 @@ cc_binary {
		],

		shared_libs: [
		"android.hardware.tv.tuner@1.0",
		"android.hardware.tv.tuner@1.1",
		"android.hardware.tv.tuner-V1-ndk",
		"libbase",
		"libbinder",
		"libfmq",
		@@ -129,7 +87,6 @@ cc_binary {
		"libtunerservice",
		"libutils",
		"tv_tuner_resource_manager_aidl_interface-ndk",
		"tv_tuner_resource_manager_aidl_interface-cpp",
		],

		static_libs: [

services/tuner/OWNERS

+1 −1

Original line number	Diff line number	Diff line
		nchalko@google.com
		hgchen@google.com
		quxiangfang@google.com

services/tuner/TunerDemux.cpp

+91 −146

Original line number	Diff line number	Diff line
		@@ -16,23 +16,32 @@

		#define LOG_TAG "TunerDemux"

		#include "TunerDvr.h"
		#include "TunerDemux.h"

		#include <aidl/android/hardware/tv/tuner/IDvr.h>
		#include <aidl/android/hardware/tv/tuner/IDvrCallback.h>
		#include <aidl/android/hardware/tv/tuner/IFilter.h>
		#include <aidl/android/hardware/tv/tuner/IFilterCallback.h>
		#include <aidl/android/hardware/tv/tuner/ITimeFilter.h>
		#include <aidl/android/hardware/tv/tuner/Result.h>

		#include "TunerDvr.h"
		#include "TunerTimeFilter.h"

		using ::android::hardware::tv::tuner::V1_0::DemuxAlpFilterType;
		using ::android::hardware::tv::tuner::V1_0::DemuxFilterMainType;
		using ::android::hardware::tv::tuner::V1_0::DemuxFilterType;
		using ::android::hardware::tv::tuner::V1_0::DemuxIpFilterType;
		using ::android::hardware::tv::tuner::V1_0::DemuxMmtpFilterType;
		using ::android::hardware::tv::tuner::V1_0::DemuxTlvFilterType;
		using ::android::hardware::tv::tuner::V1_0::DemuxTsFilterType;
		using ::android::hardware::tv::tuner::V1_0::DvrType;
		using ::android::hardware::tv::tuner::V1_0::Result;
		using ::aidl::android::hardware::tv::tuner::IDvr;
		using ::aidl::android::hardware::tv::tuner::IDvrCallback;
		using ::aidl::android::hardware::tv::tuner::IFilter;
		using ::aidl::android::hardware::tv::tuner::IFilterCallback;
		using ::aidl::android::hardware::tv::tuner::ITimeFilter;
		using ::aidl::android::hardware::tv::tuner::Result;

		namespace aidl {
		namespace android {
		namespace media {
		namespace tv {
		namespace tuner {

		TunerDemux::TunerDemux(sp<IDemux> demux, int id) {
		TunerDemux::TunerDemux(shared_ptr<IDemux> demux, int id) {
		mDemux = demux;
		mDemuxId = id;
		}
		@@ -41,205 +50,141 @@ TunerDemux::~TunerDemux() {
		mDemux = nullptr;
		}

		Status TunerDemux::setFrontendDataSource(const std::shared_ptr<ITunerFrontend>& frontend) {
		::ndk::ScopedAStatus TunerDemux::setFrontendDataSource(
		const shared_ptr<ITunerFrontend>& in_frontend) {
		if (mDemux == nullptr) {
		ALOGE("IDemux is not initialized");
		return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		int frontendId;
		frontend->getFrontendId(&frontendId);
		Result res = mDemux->setFrontendDataSource(frontendId);
		if (res != Result::SUCCESS) {
		return ::ndk::ScopedAStatus::fromServiceSpecificError(static_cast<int32_t>(res));
		}
		return Status::ok();
		in_frontend->getFrontendId(&frontendId);

		return mDemux->setFrontendDataSource(frontendId);
		}

		Status TunerDemux::setFrontendDataSourceById(int frontendId) {
		::ndk::ScopedAStatus TunerDemux::setFrontendDataSourceById(int frontendId) {
		if (mDemux == nullptr) {
		ALOGE("IDemux is not initialized");
		return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		Result res = mDemux->setFrontendDataSource(frontendId);
		if (res != Result::SUCCESS) {
		return ::ndk::ScopedAStatus::fromServiceSpecificError(static_cast<int32_t>(res));
		}
		return Status::ok();
		return mDemux->setFrontendDataSource(frontendId);
		}

		Status TunerDemux::openFilter(
		int type, int subType, int bufferSize, const std::shared_ptr<ITunerFilterCallback>& cb,
		std::shared_ptr<ITunerFilter>* _aidl_return) {
		::ndk::ScopedAStatus TunerDemux::openFilter(const DemuxFilterType& in_type, int32_t in_bufferSize,
		const shared_ptr<ITunerFilterCallback>& in_cb,
		shared_ptr<ITunerFilter>* _aidl_return) {
		if (mDemux == nullptr) {
		ALOGE("IDemux is not initialized.");
		return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
		}

		DemuxFilterMainType mainType = static_cast<DemuxFilterMainType>(type);
		DemuxFilterType filterType {
		.mainType = mainType,
		};

		switch(mainType) {
		case DemuxFilterMainType::TS:
		filterType.subType.tsFilterType(static_cast<DemuxTsFilterType>(subType));
		break;
		case DemuxFilterMainType::MMTP:
		filterType.subType.mmtpFilterType(static_cast<DemuxMmtpFilterType>(subType));
		break;
		case DemuxFilterMainType::IP:
		filterType.subType.ipFilterType(static_cast<DemuxIpFilterType>(subType));
		break;
		case DemuxFilterMainType::TLV:
		filterType.subType.tlvFilterType(static_cast<DemuxTlvFilterType>(subType));
		break;
		case DemuxFilterMainType::ALP:
		filterType.subType.alpFilterType(static_cast<DemuxAlpFilterType>(subType));
		break;
		}
		Result status;
		sp<IFilter> filterSp;
		sp<IFilterCallback> cbSp = new TunerFilter::FilterCallback(cb);
		mDemux->openFilter(filterType, bufferSize, cbSp,
		[&](Result r, const sp<IFilter>& filter) {
		filterSp = filter;
		status = r;
		});
		if (status != Result::SUCCESS) {
		return Status::fromServiceSpecificError(static_cast<int32_t>(status));
		}

		*_aidl_return = ::ndk::SharedRefBase::make<TunerFilter>(filterSp, type, subType);
		return Status::ok();
		}

		Status TunerDemux::openTimeFilter(shared_ptr<ITunerTimeFilter>* _aidl_return) {
		if (mDemux == nullptr) {
		ALOGE("IDemux is not initialized.");
		return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
		ALOGE("IDemux is not initialized");
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		Result status;
		sp<ITimeFilter> filterSp;
		mDemux->openTimeFilter([&](Result r, const sp<ITimeFilter>& filter) {
		filterSp = filter;
		status = r;
		});
		if (status != Result::SUCCESS) {
		return Status::fromServiceSpecificError(static_cast<int32_t>(status));
		shared_ptr<IFilter> filter;
		shared_ptr<IFilterCallback> cb = ::ndk::SharedRefBase::make<TunerFilter::FilterCallback>(in_cb);
		auto status = mDemux->openFilter(in_type, in_bufferSize, cb, &filter);
		if (status.isOk()) {
		*_aidl_return = ::ndk::SharedRefBase::make<TunerFilter>(filter, in_type);
		}

		*_aidl_return = ::ndk::SharedRefBase::make<TunerTimeFilter>(filterSp);
		return Status::ok();
		return status;
		}

		Status TunerDemux::getAvSyncHwId(const shared_ptr<ITunerFilter>& tunerFilter, int* _aidl_return) {
		::ndk::ScopedAStatus TunerDemux::openTimeFilter(shared_ptr<ITunerTimeFilter>* _aidl_return) {
		if (mDemux == nullptr) {
		ALOGE("IDemux is not initialized.");
		return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		uint32_t avSyncHwId;
		Result res;
		sp<IFilter> halFilter = static_cast<TunerFilter*>(tunerFilter.get())->getHalFilter();
		mDemux->getAvSyncHwId(halFilter,
		[&](Result r, uint32_t id) {
		res = r;
		avSyncHwId = id;
		});
		if (res != Result::SUCCESS) {
		return Status::fromServiceSpecificError(static_cast<int32_t>(res));
		shared_ptr<ITimeFilter> filter;
		auto status = mDemux->openTimeFilter(&filter);
		if (status.isOk()) {
		*_aidl_return = ::ndk::SharedRefBase::make<TunerTimeFilter>(filter);
		}

		*_aidl_return = (int)avSyncHwId;
		return Status::ok();
		return status;
		}

		Status TunerDemux::getAvSyncTime(int avSyncHwId, int64_t* _aidl_return) {
		::ndk::ScopedAStatus TunerDemux::getAvSyncHwId(const shared_ptr<ITunerFilter>& tunerFilter,
		int32_t* _aidl_return) {
		if (mDemux == nullptr) {
		ALOGE("IDemux is not initialized.");
		return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		shared_ptr<IFilter> halFilter = (static_cast<TunerFilter*>(tunerFilter.get()))->getHalFilter();
		return mDemux->getAvSyncHwId(halFilter, _aidl_return);
		}

		uint64_t time;
		Result res;
		mDemux->getAvSyncTime(static_cast<uint32_t>(avSyncHwId),
		[&](Result r, uint64_t ts) {
		res = r;
		time = ts;
		});
		if (res != Result::SUCCESS) {
		return Status::fromServiceSpecificError(static_cast<int32_t>(res));
		::ndk::ScopedAStatus TunerDemux::getAvSyncTime(int32_t avSyncHwId, int64_t* _aidl_return) {
		if (mDemux == nullptr) {
		ALOGE("IDemux is not initialized.");
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		*_aidl_return = (int64_t)time;
		return Status::ok();
		return mDemux->getAvSyncTime(avSyncHwId, _aidl_return);
		}

		Status TunerDemux::openDvr(int dvrType, int bufferSize, const shared_ptr<ITunerDvrCallback>& cb,
		::ndk::ScopedAStatus TunerDemux::openDvr(DvrType in_dvbType, int32_t in_bufferSize,
		const shared_ptr<ITunerDvrCallback>& in_cb,
		shared_ptr<ITunerDvr>* _aidl_return) {
		if (mDemux == nullptr) {
		ALOGE("IDemux is not initialized.");
		return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		Result res;
		sp<IDvrCallback> callback = new TunerDvr::DvrCallback(cb);
		sp<IDvr> hidlDvr;
		mDemux->openDvr(static_cast<DvrType>(dvrType), bufferSize, callback,
		[&](Result r, const sp<IDvr>& dvr) {
		hidlDvr = dvr;
		res = r;
		});
		if (res != Result::SUCCESS) {
		*_aidl_return = NULL;
		return Status::fromServiceSpecificError(static_cast<int32_t>(res));
		shared_ptr<IDvrCallback> callback = ::ndk::SharedRefBase::make<TunerDvr::DvrCallback>(in_cb);
		shared_ptr<IDvr> halDvr;
		auto res = mDemux->openDvr(in_dvbType, in_bufferSize, callback, &halDvr);
		if (res.isOk()) {
		*_aidl_return = ::ndk::SharedRefBase::make<TunerDvr>(halDvr, in_dvbType);
		}

		*_aidl_return = ::ndk::SharedRefBase::make<TunerDvr>(hidlDvr, dvrType);
		return Status::ok();
		return res;
		}

		Status TunerDemux::connectCiCam(int ciCamId) {
		::ndk::ScopedAStatus TunerDemux::connectCiCam(int32_t ciCamId) {
		if (mDemux == nullptr) {
		ALOGE("IDemux is not initialized.");
		return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		Result res = mDemux->connectCiCam(static_cast<uint32_t>(ciCamId));
		if (res != Result::SUCCESS) {
		return Status::fromServiceSpecificError(static_cast<int32_t>(res));
		}
		return Status::ok();
		return mDemux->connectCiCam(ciCamId);
		}

		Status TunerDemux::disconnectCiCam() {
		::ndk::ScopedAStatus TunerDemux::disconnectCiCam() {
		if (mDemux == nullptr) {
		ALOGE("IDemux is not initialized.");
		return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		Result res = mDemux->disconnectCiCam();
		if (res != Result::SUCCESS) {
		return Status::fromServiceSpecificError(static_cast<int32_t>(res));
		}
		return Status::ok();
		return mDemux->disconnectCiCam();
		}

		Status TunerDemux::close() {
		::ndk::ScopedAStatus TunerDemux::close() {
		if (mDemux == nullptr) {
		ALOGE("IDemux is not initialized.");
		return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		Result res = mDemux->close();
		mDemux = NULL;
		auto res = mDemux->close();
		mDemux = nullptr;

		if (res != Result::SUCCESS) {
		return Status::fromServiceSpecificError(static_cast<int32_t>(res));
		}
		return Status::ok();
		return res;
		}

		} // namespace tuner
		} // namespace tv
		} // namespace media
		} // namespace android
		} // namespace aidl

services/tuner/TunerDemux.h

+32 −30

Original line number	Diff line number	Diff line
		@@ -17,53 +17,55 @@
		#ifndef ANDROID_MEDIA_TUNERDEMUX_H
		#define ANDROID_MEDIA_TUNERDEMUX_H

		#include <aidl/android/hardware/tv/tuner/IDemux.h>
		#include <aidl/android/media/tv/tuner/BnTunerDemux.h>
		#include <android/hardware/tv/tuner/1.0/ITuner.h>

		using Status = ::ndk::ScopedAStatus;
		using ::aidl::android::media::tv::tuner::BnTunerDemux;
		using ::aidl::android::media::tv::tuner::ITunerDvr;
		using ::aidl::android::media::tv::tuner::ITunerDvrCallback;
		using ::aidl::android::media::tv::tuner::ITunerFilter;
		using ::aidl::android::media::tv::tuner::ITunerFilterCallback;
		using ::aidl::android::media::tv::tuner::ITunerFrontend;
		using ::aidl::android::media::tv::tuner::ITunerTimeFilter;
		using ::android::hardware::tv::tuner::V1_0::IDemux;
		using ::android::hardware::tv::tuner::V1_0::IDvr;
		using ::android::hardware::tv::tuner::V1_0::IDvrCallback;
		using ::android::hardware::tv::tuner::V1_0::ITimeFilter;
		using ::aidl::android::hardware::tv::tuner::DemuxFilterType;
		using ::aidl::android::hardware::tv::tuner::DvrType;
		using ::aidl::android::hardware::tv::tuner::IDemux;

		using namespace std;

		namespace aidl {
		namespace android {
		namespace media {
		namespace tv {
		namespace tuner {

		class TunerDemux : public BnTunerDemux {

		public:
		TunerDemux(sp<IDemux> demux, int demuxId);
		TunerDemux(shared_ptr<IDemux> demux, int demuxId);
		virtual ~TunerDemux();
		Status setFrontendDataSource(const shared_ptr<ITunerFrontend>& frontend) override;
		Status setFrontendDataSourceById(int frontendId) override;
		Status openFilter(
		int mainType, int subtype, int bufferSize, const shared_ptr<ITunerFilterCallback>& cb,

		::ndk::ScopedAStatus setFrontendDataSource(
		const shared_ptr<ITunerFrontend>& in_frontend) override;
		::ndk::ScopedAStatus setFrontendDataSourceById(int frontendId) override;
		::ndk::ScopedAStatus openFilter(const DemuxFilterType& in_type, int32_t in_bufferSize,
		const shared_ptr<ITunerFilterCallback>& in_cb,
		shared_ptr<ITunerFilter>* _aidl_return) override;
		Status openTimeFilter(shared_ptr<ITunerTimeFilter>* _aidl_return) override;
		Status getAvSyncHwId(const shared_ptr<ITunerFilter>& tunerFilter, int* _aidl_return) override;
		Status getAvSyncTime(int avSyncHwId, int64_t* _aidl_return) override;
		Status openDvr(
		int dvbType, int bufferSize, const shared_ptr<ITunerDvrCallback>& cb,
		::ndk::ScopedAStatus openTimeFilter(shared_ptr<ITunerTimeFilter>* _aidl_return) override;
		::ndk::ScopedAStatus getAvSyncHwId(const shared_ptr<ITunerFilter>& in_tunerFilter,
		int32_t* _aidl_return) override;
		::ndk::ScopedAStatus getAvSyncTime(int32_t in_avSyncHwId, int64_t* _aidl_return) override;
		::ndk::ScopedAStatus openDvr(DvrType in_dvbType, int32_t in_bufferSize,
		const shared_ptr<ITunerDvrCallback>& in_cb,
		shared_ptr<ITunerDvr>* _aidl_return) override;
		Status connectCiCam(int ciCamId) override;
		Status disconnectCiCam() override;
		Status close() override;
		::ndk::ScopedAStatus connectCiCam(int32_t in_ciCamId) override;
		::ndk::ScopedAStatus disconnectCiCam() override;
		::ndk::ScopedAStatus close() override;

		int getId() { return mDemuxId; }

		private:
		sp<IDemux> mDemux;
		shared_ptr<IDemux> mDemux;
		int mDemuxId;
		};

		} // namespace tuner
		} // namespace tv
		} // namespace media
		} // namespace android
		} // namespace aidl

		#endif // ANDROID_MEDIA_TUNERDEMUX_H