From 4424c6e20a3f643beb79e934e236333a80a29c23 Mon Sep 17 00:00:00 2001 From: Amy Date: Fri, 16 Aug 2019 16:01:27 -0700 Subject: [PATCH 1/2] Tuner HAL default implementation for Demux and Descrambler Interface. Bug: 135709325 Test: Manual Change-Id: I38a92abb761d2d39e8e6a495f2d93dee5f1c9d90 Merged-In: I38a92abb761d2d39e8e6a495f2d93dee5f1c9d90 --- tv/tuner/1.0/default/Android.bp | 2 + tv/tuner/1.0/default/Demux.cpp | 55 ++++++++++++++++++++++++++ tv/tuner/1.0/default/Demux.h | 55 ++++++++++++++++++++++++++ tv/tuner/1.0/default/Descrambler.cpp | 59 ++++++++++++++++++++++++++++ tv/tuner/1.0/default/Descrambler.h | 56 ++++++++++++++++++++++++++ tv/tuner/1.0/default/Tuner.cpp | 9 +++-- tv/tuner/1.0/default/Tuner.h | 3 ++ 7 files changed, 236 insertions(+), 3 deletions(-) create mode 100644 tv/tuner/1.0/default/Demux.cpp create mode 100644 tv/tuner/1.0/default/Demux.h create mode 100644 tv/tuner/1.0/default/Descrambler.cpp create mode 100644 tv/tuner/1.0/default/Descrambler.h diff --git a/tv/tuner/1.0/default/Android.bp b/tv/tuner/1.0/default/Android.bp index cc8d1f50e6..21c9f1b6c2 100644 --- a/tv/tuner/1.0/default/Android.bp +++ b/tv/tuner/1.0/default/Android.bp @@ -5,6 +5,8 @@ cc_defaults { relative_install_path: "hw", srcs: [ "Frontend.cpp", + "Descrambler.cpp", + "Demux.cpp", "Tuner.cpp", "service.cpp", ], diff --git a/tv/tuner/1.0/default/Demux.cpp b/tv/tuner/1.0/default/Demux.cpp new file mode 100644 index 0000000000..6f7c68bfb4 --- /dev/null +++ b/tv/tuner/1.0/default/Demux.cpp @@ -0,0 +1,55 @@ +/* + * Copyright (C) 2019 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.0-Demux" + +#include "Demux.h" +#include + +namespace android { +namespace hardware { +namespace tv { +namespace tuner { +namespace V1_0 { +namespace implementation { + +Demux::Demux(uint32_t demuxId) { + mDemuxId = demuxId; +} + +Demux::~Demux() {} + +Return Demux::setFrontendDataSource(uint32_t frontendId) { + ALOGV("%s", __FUNCTION__); + + mSourceFrontendId = frontendId; + + return Result::SUCCESS; +} + +Return Demux::close() { + ALOGV("%s", __FUNCTION__); + + return Result::SUCCESS; + ; +} + +} // namespace implementation +} // namespace V1_0 +} // namespace tuner +} // namespace tv +} // namespace hardware +} // namespace android diff --git a/tv/tuner/1.0/default/Demux.h b/tv/tuner/1.0/default/Demux.h new file mode 100644 index 0000000000..52f39336bd --- /dev/null +++ b/tv/tuner/1.0/default/Demux.h @@ -0,0 +1,55 @@ +/* + * Copyright (C) 2019 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_0_DEMUX_H_ +#define ANDROID_HARDWARE_TV_TUNER_V1_0_DEMUX_H_ + +#include + +using namespace std; + +namespace android { +namespace hardware { +namespace tv { +namespace tuner { +namespace V1_0 { +namespace implementation { + +using ::android::hardware::tv::tuner::V1_0::IDemux; +using ::android::hardware::tv::tuner::V1_0::Result; + +class Demux : public IDemux { + public: + Demux(uint32_t demuxId); + + virtual Return setFrontendDataSource(uint32_t frontendId) override; + + virtual Return close() override; + + private: + virtual ~Demux(); + uint32_t mDemuxId; + uint32_t mSourceFrontendId; +}; + +} // namespace implementation +} // namespace V1_0 +} // namespace tuner +} // namespace tv +} // namespace hardware +} // namespace android + +#endif // ANDROID_HARDWARE_TV_TUNER_V1_0_DEMUX_H_ diff --git a/tv/tuner/1.0/default/Descrambler.cpp b/tv/tuner/1.0/default/Descrambler.cpp new file mode 100644 index 0000000000..1af1a2c995 --- /dev/null +++ b/tv/tuner/1.0/default/Descrambler.cpp @@ -0,0 +1,59 @@ +/* + * Copyright (C) 2019 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.0-Descrambler" + +#include +#include + +#include "Descrambler.h" + +namespace android { +namespace hardware { +namespace tv { +namespace tuner { +namespace V1_0 { +namespace implementation { + +Descrambler::Descrambler() {} + +Descrambler::~Descrambler() {} + +Return Descrambler::setDemuxSource(uint32_t demuxId) { + ALOGV("%s", __FUNCTION__); + if (mDemuxSet) { + ALOGW("[ WARN ] Descrambler has already been set with a demux id %d", mSourceDemuxId); + return Result::INVALID_STATE; + } + mDemuxSet = true; + mSourceDemuxId = demuxId; + + return Result::SUCCESS; +} + +Return Descrambler::close() { + ALOGV("%s", __FUNCTION__); + mDemuxSet = false; + + return Result::SUCCESS; +} + +} // namespace implementation +} // namespace V1_0 +} // namespace tuner +} // namespace tv +} // namespace hardware +} // namespace android diff --git a/tv/tuner/1.0/default/Descrambler.h b/tv/tuner/1.0/default/Descrambler.h new file mode 100644 index 0000000000..2ec8412a6d --- /dev/null +++ b/tv/tuner/1.0/default/Descrambler.h @@ -0,0 +1,56 @@ +/* + * Copyright (C) 2019 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_0_DESCRAMBLER_H_ +#define ANDROID_HARDWARE_TV_TUNER_V1_0_DESCRAMBLER_H_ + +#include +#include + +using namespace std; + +namespace android { +namespace hardware { +namespace tv { +namespace tuner { +namespace V1_0 { +namespace implementation { + +using ::android::hardware::tv::tuner::V1_0::IDescrambler; +using ::android::hardware::tv::tuner::V1_0::Result; + +class Descrambler : public IDescrambler { + public: + Descrambler(); + + virtual Return setDemuxSource(uint32_t demuxId) override; + + virtual Return 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_ diff --git a/tv/tuner/1.0/default/Tuner.cpp b/tv/tuner/1.0/default/Tuner.cpp index 6bb7aa9af8..68b34368ee 100644 --- a/tv/tuner/1.0/default/Tuner.cpp +++ b/tv/tuner/1.0/default/Tuner.cpp @@ -19,6 +19,8 @@ #include "Tuner.h" #include #include +#include "Demux.h" +#include "Descrambler.h" #include "Frontend.h" namespace android { @@ -76,8 +78,9 @@ Return Tuner::openFrontendById(uint32_t frontendId, openFrontendById_cb _h Return Tuner::openDemux(openDemux_cb _hidl_cb) { ALOGV("%s", __FUNCTION__); - sp demux; - DemuxId demuxId = 0; + DemuxId demuxId = mLastUsedId + 1; + mLastUsedId += 1; + sp demux = new Demux(demuxId); _hidl_cb(Result::SUCCESS, demuxId, demux); return Void(); @@ -86,7 +89,7 @@ Return Tuner::openDemux(openDemux_cb _hidl_cb) { Return Tuner::openDescrambler(openDescrambler_cb _hidl_cb) { ALOGV("%s", __FUNCTION__); - sp descrambler; + sp descrambler = new Descrambler(); _hidl_cb(Result::SUCCESS, descrambler); return Void(); diff --git a/tv/tuner/1.0/default/Tuner.h b/tv/tuner/1.0/default/Tuner.h index 1ca7671f1f..12e959406a 100644 --- a/tv/tuner/1.0/default/Tuner.h +++ b/tv/tuner/1.0/default/Tuner.h @@ -47,6 +47,9 @@ class Tuner : public ITuner { vector> mFrontends; // To maintain how many Frontends we have int mFrontendSize; + // The last used demux id. Initial value is -1. + // First used id will be 0. + int mLastUsedId = -1; }; } // namespace implementation From 4a93c03793808db491ee8bd1e9772cc55641b601 Mon Sep 17 00:00:00 2001 From: Amy Date: Mon, 19 Aug 2019 13:12:17 -0700 Subject: [PATCH 2/2] Tuner HAL VTS for Demux and Descrambler Interface. Bug: 135708935 Test: Manual Change-Id: I1f2c9bfe6036dc6070dbf88d9728645f2568dcde Merged-In: I1f2c9bfe6036dc6070dbf88d9728645f2568dcde --- .../VtsHalTvTunerV1_0TargetTest.cpp | 130 ++++++++++++++++++ 1 file changed, 130 insertions(+) diff --git a/tv/tuner/1.0/vts/functional/VtsHalTvTunerV1_0TargetTest.cpp b/tv/tuner/1.0/vts/functional/VtsHalTvTunerV1_0TargetTest.cpp index 4840a02e25..c652944fee 100644 --- a/tv/tuner/1.0/vts/functional/VtsHalTvTunerV1_0TargetTest.cpp +++ b/tv/tuner/1.0/vts/functional/VtsHalTvTunerV1_0TargetTest.cpp @@ -19,6 +19,9 @@ #include #include #include +#include +#include +#include #include #include #include @@ -52,6 +55,9 @@ using android::hardware::tv::tuner::V1_0::FrontendEventType; using android::hardware::tv::tuner::V1_0::FrontendId; using android::hardware::tv::tuner::V1_0::FrontendInnerFec; using android::hardware::tv::tuner::V1_0::FrontendSettings; +using android::hardware::tv::tuner::V1_0::IDemux; +using android::hardware::tv::tuner::V1_0::IDemuxCallback; +using android::hardware::tv::tuner::V1_0::IDescrambler; using android::hardware::tv::tuner::V1_0::IFrontend; using android::hardware::tv::tuner::V1_0::IFrontendCallback; using android::hardware::tv::tuner::V1_0::ITuner; @@ -146,11 +152,19 @@ class TunerHidlTest : public ::testing::VtsHalHidlTargetTestBase { sp mFrontend; sp mFrontendCallback; + sp mDescrambler; + sp mDemux; + uint32_t mDemuxId; ::testing::AssertionResult createFrontend(int32_t frontendId); ::testing::AssertionResult tuneFrontend(int32_t frontendId); ::testing::AssertionResult stopTuneFrontend(int32_t frontendId); ::testing::AssertionResult closeFrontend(int32_t frontendId); + ::testing::AssertionResult createDemux(); + ::testing::AssertionResult createDemuxWithFrontend(int32_t frontendId); + ::testing::AssertionResult closeDemux(); + ::testing::AssertionResult createDescrambler(); + ::testing::AssertionResult closeDescrambler(); }; ::testing::AssertionResult TunerHidlTest::createFrontend(int32_t frontendId) { @@ -215,6 +229,78 @@ class TunerHidlTest : public ::testing::VtsHalHidlTargetTestBase { return ::testing::AssertionResult(status == Result::SUCCESS); } +::testing::AssertionResult TunerHidlTest::createDemux() { + Result status; + + mService->openDemux([&](Result result, uint32_t demuxId, const sp& demux) { + mDemux = demux; + mDemuxId = demuxId; + status = result; + }); + return ::testing::AssertionResult(status == Result::SUCCESS); +} + +::testing::AssertionResult TunerHidlTest::createDemuxWithFrontend(int32_t frontendId) { + Result status; + + if (createDemux() == ::testing::AssertionFailure()) { + return ::testing::AssertionFailure(); + } + + if (createFrontend(frontendId) == ::testing::AssertionFailure()) { + return ::testing::AssertionFailure(); + } + + status = mDemux->setFrontendDataSource(frontendId); + + return ::testing::AssertionResult(status == Result::SUCCESS); +} + +::testing::AssertionResult TunerHidlTest::closeDemux() { + Result status; + if (createDemux() == ::testing::AssertionFailure()) { + return ::testing::AssertionFailure(); + } + + status = mDemux->close(); + return ::testing::AssertionResult(status == Result::SUCCESS); +} + +::testing::AssertionResult TunerHidlTest::createDescrambler() { + Result status; + + mService->openDescrambler([&](Result result, const sp& descrambler) { + mDescrambler = descrambler; + status = result; + }); + if (status != Result::SUCCESS) { + return ::testing::AssertionFailure(); + } + + if (createDemux() == ::testing::AssertionFailure()) { + return ::testing::AssertionFailure(); + } + + status = mDescrambler->setDemuxSource(mDemuxId); + if (status != Result::SUCCESS) { + return ::testing::AssertionFailure(); + } + + // Test if demux source can be set more than once. + status = mDescrambler->setDemuxSource(mDemuxId); + return ::testing::AssertionResult(status == Result::INVALID_STATE); +} + +::testing::AssertionResult TunerHidlTest::closeDescrambler() { + Result status; + if (createDescrambler() == ::testing::AssertionFailure()) { + return ::testing::AssertionFailure(); + } + + status = mDescrambler->close(); + return ::testing::AssertionResult(status == Result::SUCCESS); +} + TEST_F(TunerHidlTest, CreateFrontend) { Result status; hidl_vec feIds; @@ -295,6 +381,50 @@ TEST_F(TunerHidlTest, CloseFrontend) { } } +TEST_F(TunerHidlTest, CreateDemux) { + description("Create Demux"); + + ASSERT_TRUE(createDemux()); +} + +TEST_F(TunerHidlTest, CreateDemuxWithFrontend) { + Result status; + hidl_vec feIds; + + description("Create Demux with Frontend"); + mService->getFrontendIds([&](Result result, const hidl_vec& frontendIds) { + status = result; + feIds = frontendIds; + }); + + if (feIds.size() == 0) { + ALOGW("[ WARN ] Frontend isn't available"); + return; + } + + for (size_t i = 0; i < feIds.size(); i++) { + ASSERT_TRUE(createDemuxWithFrontend(feIds[i])); + } +} + +TEST_F(TunerHidlTest, CloseDemux) { + description("Close Demux"); + + ASSERT_TRUE(closeDemux()); +} + +TEST_F(TunerHidlTest, CreateDescrambler) { + description("Create Descrambler"); + + ASSERT_TRUE(createDescrambler()); +} + +TEST_F(TunerHidlTest, CloseDescrambler) { + description("Close Descrambler"); + + ASSERT_TRUE(closeDescrambler()); +} + } // namespace int main(int argc, char** argv) {