werunplugged/unplugged-system
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
06ee9615ad
unplugged-system/hardware/interfaces/tv/tuner/aidl/default/Tuner.cpp

366 lines
12 KiB
C++
Raw Blame History

/*
* 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.
*/
//#define LOG_NDEBUG 0
#define LOG_TAG "android.hardware.tv.tuner-service.example-Tuner"
#include <aidl/android/hardware/tv/tuner/DemuxFilterMainType.h>
#include <aidl/android/hardware/tv/tuner/Result.h>
#include <utils/Log.h>
#include "Demux.h"
#include "Descrambler.h"
#include "Frontend.h"
#include "Lnb.h"
#include "Tuner.h"
namespace aidl {
namespace android {
namespace hardware {
namespace tv {
namespace tuner {
Tuner::Tuner() {}
void Tuner::init() {
// Static Frontends array to maintain local frontends information
// Array index matches their FrontendId in the default impl
mFrontendSize = 11;
mFrontends[0] = ndk::SharedRefBase::make<Frontend>(FrontendType::ISDBS, 0);
mFrontends[1] = ndk::SharedRefBase::make<Frontend>(FrontendType::ATSC3, 1);
mFrontends[2] = ndk::SharedRefBase::make<Frontend>(FrontendType::DVBC, 2);
mFrontends[3] = ndk::SharedRefBase::make<Frontend>(FrontendType::DVBS, 3);
mFrontends[4] = ndk::SharedRefBase::make<Frontend>(FrontendType::DVBT, 4);
mFrontends[5] = ndk::SharedRefBase::make<Frontend>(FrontendType::ISDBT, 5);
mFrontends[6] = ndk::SharedRefBase::make<Frontend>(FrontendType::ANALOG, 6);
mFrontends[7] = ndk::SharedRefBase::make<Frontend>(FrontendType::ATSC, 7);
mFrontends[8] = ndk::SharedRefBase::make<Frontend>(FrontendType::ISDBS3, 8);
mFrontends[9] = ndk::SharedRefBase::make<Frontend>(FrontendType::DTMB, 9);
mFrontends[10] = ndk::SharedRefBase::make<Frontend>(FrontendType::IPTV, 10);
mMaxUsableFrontends[FrontendType::ISDBS] = 1;
mMaxUsableFrontends[FrontendType::ATSC3] = 1;
mMaxUsableFrontends[FrontendType::DVBC] = 1;
mMaxUsableFrontends[FrontendType::DVBS] = 1;
mMaxUsableFrontends[FrontendType::DVBT] = 1;
mMaxUsableFrontends[FrontendType::ISDBT] = 1;
mMaxUsableFrontends[FrontendType::ANALOG] = 1;
mMaxUsableFrontends[FrontendType::ATSC] = 1;
mMaxUsableFrontends[FrontendType::ISDBS3] = 1;
mMaxUsableFrontends[FrontendType::DTMB] = 1;
mMaxUsableFrontends[FrontendType::IPTV] = 1;
mDemuxes[0] =
ndk::SharedRefBase::make<Demux>(0, (static_cast<int32_t>(DemuxFilterMainType::TS) |
static_cast<int32_t>(DemuxFilterMainType::MMTP) |
static_cast<int32_t>(DemuxFilterMainType::TLV)));
mDemuxes[1] =
ndk::SharedRefBase::make<Demux>(1, (static_cast<int32_t>(DemuxFilterMainType::MMTP) |
static_cast<int32_t>(DemuxFilterMainType::TLV)));
mDemuxes[2] = ndk::SharedRefBase::make<Demux>(2, static_cast<int32_t>(DemuxFilterMainType::IP));
mDemuxes[3] = ndk::SharedRefBase::make<Demux>(3, static_cast<int32_t>(DemuxFilterMainType::TS));
mLnbs.resize(2);
mLnbs[0] = ndk::SharedRefBase::make<Lnb>(0);
mLnbs[1] = ndk::SharedRefBase::make<Lnb>(1);
}
Tuner::~Tuner() {}
::ndk::ScopedAStatus Tuner::getFrontendIds(std::vector<int32_t>* _aidl_return) {
ALOGV("%s", __FUNCTION__);
_aidl_return->resize(mFrontendSize);
for (int i = 0; i < mFrontendSize; i++) {
(*_aidl_return)[i] = mFrontends[i]->getFrontendId();
}
return ::ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus Tuner::getDemuxInfo(int32_t in_demuxId, DemuxInfo* _aidl_return) {
if (mDemuxes.find(in_demuxId) == mDemuxes.end()) {
return ::ndk::ScopedAStatus::fromServiceSpecificError(
static_cast<int32_t>(Result::INVALID_ARGUMENT));
} else {
mDemuxes[in_demuxId]->getDemuxInfo(_aidl_return);
return ::ndk::ScopedAStatus::ok();
}
}
::ndk::ScopedAStatus Tuner::getDemuxIds(std::vector<int32_t>* _aidl_return) {
ALOGV("%s", __FUNCTION__);
int numOfDemuxes = mDemuxes.size();
_aidl_return->resize(numOfDemuxes);
int i = 0;
for (auto e = mDemuxes.begin(); e != mDemuxes.end(); e++) {
(*_aidl_return)[i++] = e->first;
}
return ::ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus Tuner::openFrontendById(int32_t in_frontendId,
std::shared_ptr<IFrontend>* _aidl_return) {
ALOGV("%s", __FUNCTION__);
if (in_frontendId >= mFrontendSize || in_frontendId < 0) {
ALOGW("[ WARN ] Frontend with id %d isn't available", in_frontendId);
*_aidl_return = nullptr;
return ::ndk::ScopedAStatus::fromServiceSpecificError(
static_cast<int32_t>(Result::INVALID_ARGUMENT));
}
mFrontends[in_frontendId]->setTunerService(this->ref<Tuner>());
*_aidl_return = mFrontends[in_frontendId];
return ::ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus Tuner::openDemuxById(int32_t in_demuxId,
std::shared_ptr<IDemux>* _aidl_return) {
ALOGV("%s", __FUNCTION__);
if (mDemuxes.find(in_demuxId) == mDemuxes.end()) {
ALOGW("[ WARN ] Demux with id %d isn't available", in_demuxId);
*_aidl_return = nullptr;
return ::ndk::ScopedAStatus::fromServiceSpecificError(
static_cast<int32_t>(Result::INVALID_ARGUMENT));
}
if (mDemuxes[in_demuxId]->isInUse()) {
return ::ndk::ScopedAStatus::fromServiceSpecificError(
static_cast<int32_t>(Result::UNAVAILABLE));
} else {
mDemuxes[in_demuxId]->setTunerService(this->ref<Tuner>());
mDemuxes[in_demuxId]->setInUse(true);
*_aidl_return = mDemuxes[in_demuxId];
return ::ndk::ScopedAStatus::ok();
}
}
::ndk::ScopedAStatus Tuner::openDemux(std::vector<int32_t>* out_demuxId,
std::shared_ptr<IDemux>* _aidl_return) {
ALOGV("%s", __FUNCTION__);
bool found = false;
int32_t demuxId = 0;
for (auto e = mDemuxes.begin(); e != mDemuxes.end(); e++) {
if (!e->second->isInUse()) {
found = true;
demuxId = e->second->getDemuxId();
}
}
if (found) {
out_demuxId->push_back(demuxId);
return openDemuxById(demuxId, _aidl_return);
} else {
return ::ndk::ScopedAStatus::fromServiceSpecificError(
static_cast<int32_t>(Result::UNAVAILABLE));
}
}
::ndk::ScopedAStatus Tuner::getDemuxCaps(DemuxCapabilities* _aidl_return) {
ALOGV("%s", __FUNCTION__);
// IP filter can be an MMTP filter's data source.
_aidl_return->linkCaps = {0x00, 0x00, 0x02, 0x00, 0x00};
// Support time filter testing
_aidl_return->bTimeFilter = true;
// set filterCaps as the bitwize OR of all the demux' caps
std::vector<int32_t> demuxIds;
getDemuxIds(&demuxIds);
int32_t filterCaps = 0;
for (int i = 0; i < demuxIds.size(); i++) {
DemuxInfo demuxInfo;
getDemuxInfo(demuxIds[i], &demuxInfo);
filterCaps |= demuxInfo.filterTypes;
}
_aidl_return->filterCaps = filterCaps;
return ::ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus Tuner::openDescrambler(std::shared_ptr<IDescrambler>* _aidl_return) {
ALOGV("%s", __FUNCTION__);
*_aidl_return = ndk::SharedRefBase::make<Descrambler>();
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus Tuner::getFrontendInfo(int32_t in_frontendId, FrontendInfo* _aidl_return) {
ALOGV("%s", __FUNCTION__);
if (in_frontendId < 0 || in_frontendId >= mFrontendSize) {
return ::ndk::ScopedAStatus::fromServiceSpecificError(
static_cast<int32_t>(Result::INVALID_ARGUMENT));
}
mFrontends[in_frontendId]->getFrontendInfo(_aidl_return);
return ::ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus Tuner::getLnbIds(std::vector<int32_t>* _aidl_return) {
ALOGV("%s", __FUNCTION__);
_aidl_return->resize(mLnbs.size());
for (int i = 0; i < mLnbs.size(); i++) {
(*_aidl_return)[i] = mLnbs[i]->getId();
}
return ::ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus Tuner::openLnbById(int32_t in_lnbId, std::shared_ptr<ILnb>* _aidl_return) {
ALOGV("%s", __FUNCTION__);
if (in_lnbId >= mLnbs.size()) {
*_aidl_return = nullptr;
return ::ndk::ScopedAStatus::fromServiceSpecificError(
static_cast<int32_t>(Result::INVALID_ARGUMENT));
}
*_aidl_return = mLnbs[in_lnbId];
return ::ndk::ScopedAStatus::ok();
}
std::shared_ptr<Frontend> Tuner::getFrontendById(int32_t frontendId) {
ALOGV("%s", __FUNCTION__);
return mFrontends[frontendId];
}
::ndk::ScopedAStatus Tuner::openLnbByName(const std::string& /* in_lnbName */,
std::vector<int32_t>* out_lnbId,
std::shared_ptr<ILnb>* _aidl_return) {
ALOGV("%s", __FUNCTION__);
out_lnbId->push_back(1234);
*_aidl_return = ndk::SharedRefBase::make<Lnb>();
return ::ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus Tuner::setLna(bool /* in_bEnable */) {
ALOGV("%s", __FUNCTION__);
return ::ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus Tuner::setMaxNumberOfFrontends(FrontendType in_frontendType,
int32_t in_maxNumber) {
ALOGV("%s", __FUNCTION__);
// In the default implementation, every type only has one frontend.
if (in_maxNumber < 0 || in_maxNumber > 1) {
return ::ndk::ScopedAStatus::fromServiceSpecificError(
static_cast<int32_t>(Result::INVALID_ARGUMENT));
}
mMaxUsableFrontends[in_frontendType] = in_maxNumber;
return ::ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus Tuner::getMaxNumberOfFrontends(FrontendType in_frontendType,
int32_t* _aidl_return) {
*_aidl_return = mMaxUsableFrontends[in_frontendType];
return ::ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus Tuner::isLnaSupported(bool* _aidl_return) {
ALOGV("%s", __FUNCTION__);
*_aidl_return = true;
return ::ndk::ScopedAStatus::ok();
}
binder_status_t Tuner::dump(int fd, const char** args, uint32_t numArgs) {
ALOGV("%s", __FUNCTION__);
{
dprintf(fd, "Frontends:\n");
for (int i = 0; i < mFrontendSize; i++) {
mFrontends[i]->dump(fd, args, numArgs);
}
}
{
dprintf(fd, "Demuxs:\n");
map<int32_t, std::shared_ptr<Demux>>::iterator it;
for (it = mDemuxes.begin(); it != mDemuxes.end(); it++) {
it->second->dump(fd, args, numArgs);
}
}
{
dprintf(fd, "Lnbs:\n");
for (int i = 0; i < mLnbs.size(); i++) {
mLnbs[i]->dump(fd, args, numArgs);
}
}
return STATUS_OK;
}
void Tuner::setFrontendAsDemuxSource(int32_t frontendId, int32_t demuxId) {
mFrontendToDemux[frontendId] = demuxId;
if (mFrontends[frontendId] != nullptr && mFrontends[frontendId]->isLocked()) {
mDemuxes[demuxId]->startFrontendInputLoop();
}
}
void Tuner::removeDemux(int32_t demuxId) {
map<int32_t, int32_t>::iterator it;
for (it = mFrontendToDemux.begin(); it != mFrontendToDemux.end(); it++) {
if (it->second == demuxId) {
it = mFrontendToDemux.erase(it);
break;
}
}
mDemuxes[demuxId]->setInUse(false);
}
void Tuner::removeFrontend(int32_t frontendId) {
map<int32_t, int32_t>::iterator it = mFrontendToDemux.find(frontendId);
if (it != mFrontendToDemux.end()) {
mDemuxes[it->second]->setInUse(false);
}
mFrontendToDemux.erase(frontendId);
}
void Tuner::frontendStopTune(int32_t frontendId) {
map<int32_t, int32_t>::iterator it = mFrontendToDemux.find(frontendId);
int32_t demuxId;
if (it != mFrontendToDemux.end()) {
demuxId = it->second;
mDemuxes[demuxId]->stopFrontendInput();
}
}
void Tuner::frontendStartTune(int32_t frontendId) {
map<int32_t, int32_t>::iterator it = mFrontendToDemux.find(frontendId);
int32_t demuxId;
if (it != mFrontendToDemux.end()) {
demuxId = it->second;
mDemuxes[demuxId]->startFrontendInputLoop();
}
}
} // namespace tuner
} // namespace tv
} // namespace hardware
} // namespace android
} // namespace aidl
Reference in New Issue View Git Blame Copy Permalink