blob: 45f3dfafccc364578cdb116302aa4d3765c5c5f0 [file] [log] [blame]
Hongguang4092f2f2021-07-08 18:49:12 -07001/*
2 * Copyright 2021 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17//#define LOG_NDEBUG 0
18#define LOG_TAG "android.hardware.tv.tuner-service.example-Tuner"
19
Hongguange423acd2021-07-27 16:56:47 -070020#include <aidl/android/hardware/tv/tuner/Result.h>
Hongguang4092f2f2021-07-08 18:49:12 -070021#include <utils/Log.h>
Hongguange423acd2021-07-27 16:56:47 -070022
Hongguang4092f2f2021-07-08 18:49:12 -070023#include "Demux.h"
24#include "Descrambler.h"
25#include "Frontend.h"
26#include "Lnb.h"
Hongguange423acd2021-07-27 16:56:47 -070027#include "Tuner.h"
Hongguang4092f2f2021-07-08 18:49:12 -070028
29namespace aidl {
30namespace android {
31namespace hardware {
32namespace tv {
33namespace tuner {
34
Hongguang Chenff2c6b02021-08-07 00:12:26 +000035Tuner::Tuner() {}
36
37void Tuner::init() {
Hongguang4092f2f2021-07-08 18:49:12 -070038 // Static Frontends array to maintain local frontends information
39 // Array index matches their FrontendId in the default impl
40 mFrontendSize = 10;
Hongguang Chenff2c6b02021-08-07 00:12:26 +000041 mFrontends[0] = ndk::SharedRefBase::make<Frontend>(FrontendType::ISDBS, 0, this->ref<Tuner>());
42 mFrontends[1] = ndk::SharedRefBase::make<Frontend>(FrontendType::ATSC3, 1, this->ref<Tuner>());
43 mFrontends[2] = ndk::SharedRefBase::make<Frontend>(FrontendType::DVBC, 2, this->ref<Tuner>());
44 mFrontends[3] = ndk::SharedRefBase::make<Frontend>(FrontendType::DVBS, 3, this->ref<Tuner>());
45 mFrontends[4] = ndk::SharedRefBase::make<Frontend>(FrontendType::DVBT, 4, this->ref<Tuner>());
46 mFrontends[5] = ndk::SharedRefBase::make<Frontend>(FrontendType::ISDBT, 5, this->ref<Tuner>());
47 mFrontends[6] = ndk::SharedRefBase::make<Frontend>(FrontendType::ANALOG, 6, this->ref<Tuner>());
48 mFrontends[7] = ndk::SharedRefBase::make<Frontend>(FrontendType::ATSC, 7, this->ref<Tuner>());
49 mFrontends[8] = ndk::SharedRefBase::make<Frontend>(FrontendType::ISDBS3, 8, this->ref<Tuner>());
50 mFrontends[9] = ndk::SharedRefBase::make<Frontend>(FrontendType::DTMB, 9, this->ref<Tuner>());
Hongguang4092f2f2021-07-08 18:49:12 -070051
52 vector<FrontendStatusType> statusCaps;
53
54 FrontendCapabilities capsIsdbs;
55 capsIsdbs.set<FrontendCapabilities::Tag::isdbsCaps>(FrontendIsdbsCapabilities());
56 mFrontendCaps[0] = capsIsdbs;
57 statusCaps = {
Hongguang2ecfc392021-11-23 10:29:15 -080058 FrontendStatusType::DEMOD_LOCK,
59 FrontendStatusType::SNR,
60 FrontendStatusType::FEC,
61 FrontendStatusType::MODULATION,
62 FrontendStatusType::MODULATIONS,
63 FrontendStatusType::ROLL_OFF,
64 FrontendStatusType::STREAM_ID_LIST,
Hongguang4092f2f2021-07-08 18:49:12 -070065 };
66 mFrontendStatusCaps[0] = statusCaps;
67
68 FrontendCapabilities capsAtsc3;
69 capsAtsc3.set<FrontendCapabilities::Tag::atsc3Caps>(FrontendAtsc3Capabilities());
70 mFrontendCaps[1] = capsAtsc3;
71 statusCaps = {
72 FrontendStatusType::BER,
73 FrontendStatusType::PER,
74 FrontendStatusType::ATSC3_PLP_INFO,
75 FrontendStatusType::MODULATIONS,
76 FrontendStatusType::BERS,
77 FrontendStatusType::INTERLEAVINGS,
78 FrontendStatusType::BANDWIDTH,
79 };
80 mFrontendStatusCaps[1] = statusCaps;
81
82 FrontendCapabilities capsDvbc;
83 capsDvbc.set<FrontendCapabilities::Tag::dvbcCaps>(FrontendDvbcCapabilities());
84 mFrontendCaps[2] = capsDvbc;
85 statusCaps = {
86 FrontendStatusType::PRE_BER, FrontendStatusType::SIGNAL_QUALITY,
87 FrontendStatusType::MODULATION, FrontendStatusType::SPECTRAL,
88 FrontendStatusType::MODULATIONS, FrontendStatusType::CODERATES,
89 FrontendStatusType::INTERLEAVINGS, FrontendStatusType::BANDWIDTH,
90 };
91 mFrontendStatusCaps[2] = statusCaps;
92
93 FrontendCapabilities capsDvbs;
94 capsDvbs.set<FrontendCapabilities::Tag::dvbsCaps>(FrontendDvbsCapabilities());
95 mFrontendCaps[3] = capsDvbs;
96 statusCaps = {
97 FrontendStatusType::SIGNAL_STRENGTH, FrontendStatusType::SYMBOL_RATE,
98 FrontendStatusType::MODULATION, FrontendStatusType::MODULATIONS,
99 FrontendStatusType::ROLL_OFF, FrontendStatusType::IS_MISO,
100 };
101 mFrontendStatusCaps[3] = statusCaps;
102
103 FrontendCapabilities capsDvbt;
104 capsDvbt.set<FrontendCapabilities::Tag::dvbtCaps>(FrontendDvbtCapabilities());
105 mFrontendCaps[4] = capsDvbt;
106 statusCaps = {
107 FrontendStatusType::EWBS,
108 FrontendStatusType::PLP_ID,
109 FrontendStatusType::HIERARCHY,
110 FrontendStatusType::MODULATIONS,
111 FrontendStatusType::BANDWIDTH,
112 FrontendStatusType::GUARD_INTERVAL,
113 FrontendStatusType::TRANSMISSION_MODE,
114 FrontendStatusType::T2_SYSTEM_ID,
Hongguang7eda7822021-12-20 14:48:14 -0800115 FrontendStatusType::DVBT_CELL_IDS,
Hongguang4092f2f2021-07-08 18:49:12 -0700116 };
117 mFrontendStatusCaps[4] = statusCaps;
118
119 FrontendCapabilities capsIsdbt;
120 FrontendIsdbtCapabilities isdbtCaps{
121 .modeCap = (int)FrontendIsdbtMode::MODE_1 | (int)FrontendIsdbtMode::MODE_2,
122 .bandwidthCap = (int)FrontendIsdbtBandwidth::BANDWIDTH_6MHZ,
123 .modulationCap = (int)FrontendIsdbtModulation::MOD_16QAM,
Hongguange69a3b22021-08-03 14:23:42 -0700124 .coderateCap = (int)FrontendIsdbtCoderate::CODERATE_4_5 |
125 (int)FrontendIsdbtCoderate::CODERATE_6_7,
126 .guardIntervalCap = (int)FrontendIsdbtGuardInterval::INTERVAL_1_128,
Hongguang788284f2021-10-28 15:03:29 -0700127 .timeInterleaveCap = (int)FrontendIsdbtTimeInterleaveMode::AUTO |
128 (int)FrontendIsdbtTimeInterleaveMode::INTERLEAVE_1_0,
129 .isSegmentAuto = true,
130 .isFullSegment = true,
Hongguang4092f2f2021-07-08 18:49:12 -0700131 };
132 capsIsdbt.set<FrontendCapabilities::Tag::isdbtCaps>(isdbtCaps);
133 mFrontendCaps[5] = capsIsdbt;
134 statusCaps = {
135 FrontendStatusType::AGC,
136 FrontendStatusType::LNA,
137 FrontendStatusType::MODULATION,
138 FrontendStatusType::MODULATIONS,
139 FrontendStatusType::BANDWIDTH,
140 FrontendStatusType::GUARD_INTERVAL,
141 FrontendStatusType::TRANSMISSION_MODE,
142 FrontendStatusType::ISDBT_SEGMENTS,
Hongguang788284f2021-10-28 15:03:29 -0700143 FrontendStatusType::ISDBT_MODE,
144 FrontendStatusType::ISDBT_PARTIAL_RECEPTION_FLAG,
145 FrontendStatusType::INTERLEAVINGS,
Hongguang4092f2f2021-07-08 18:49:12 -0700146 };
147 mFrontendStatusCaps[5] = statusCaps;
148
149 FrontendCapabilities capsAnalog;
150 capsAnalog.set<FrontendCapabilities::Tag::analogCaps>(FrontendAnalogCapabilities());
151 mFrontendCaps[6] = capsAnalog;
152 statusCaps = {
153 FrontendStatusType::LAYER_ERROR,
154 FrontendStatusType::MER,
155 FrontendStatusType::UEC,
156 FrontendStatusType::TS_DATA_RATES,
157 };
158 mFrontendStatusCaps[6] = statusCaps;
159
160 FrontendCapabilities capsAtsc;
161 capsAtsc.set<FrontendCapabilities::Tag::atscCaps>(FrontendAtscCapabilities());
162 mFrontendCaps[7] = capsAtsc;
163 statusCaps = {
164 FrontendStatusType::FREQ_OFFSET,
165 FrontendStatusType::RF_LOCK,
166 FrontendStatusType::MODULATIONS,
167 FrontendStatusType::IS_LINEAR,
168 };
169 mFrontendStatusCaps[7] = statusCaps;
170
171 FrontendCapabilities capsIsdbs3;
172 capsIsdbs3.set<FrontendCapabilities::Tag::isdbs3Caps>(FrontendIsdbs3Capabilities());
173 mFrontendCaps[8] = capsIsdbs3;
174 statusCaps = {
175 FrontendStatusType::DEMOD_LOCK, FrontendStatusType::MODULATION,
176 FrontendStatusType::MODULATIONS, FrontendStatusType::ROLL_OFF,
Hongguang2ecfc392021-11-23 10:29:15 -0800177 FrontendStatusType::IS_SHORT_FRAMES, FrontendStatusType::STREAM_ID_LIST,
Hongguang4092f2f2021-07-08 18:49:12 -0700178 };
179 mFrontendStatusCaps[8] = statusCaps;
180
181 FrontendCapabilities capsDtmb;
182 capsDtmb.set<FrontendCapabilities::Tag::dtmbCaps>(FrontendDtmbCapabilities());
183 mFrontendCaps[9] = capsDtmb;
184 statusCaps = {
185 FrontendStatusType::MODULATIONS, FrontendStatusType::INTERLEAVINGS,
186 FrontendStatusType::BANDWIDTH, FrontendStatusType::GUARD_INTERVAL,
187 FrontendStatusType::TRANSMISSION_MODE,
188 };
189 mFrontendStatusCaps[9] = statusCaps;
190
191 mLnbs.resize(2);
192 mLnbs[0] = ndk::SharedRefBase::make<Lnb>(0);
193 mLnbs[1] = ndk::SharedRefBase::make<Lnb>(1);
194}
195
196Tuner::~Tuner() {}
197
198::ndk::ScopedAStatus Tuner::getFrontendIds(std::vector<int32_t>* _aidl_return) {
199 ALOGV("%s", __FUNCTION__);
200
201 _aidl_return->resize(mFrontendSize);
202 for (int i = 0; i < mFrontendSize; i++) {
203 (*_aidl_return)[i] = mFrontends[i]->getFrontendId();
204 }
205
206 return ::ndk::ScopedAStatus::ok();
207}
208
209::ndk::ScopedAStatus Tuner::openFrontendById(int32_t in_frontendId,
210 std::shared_ptr<IFrontend>* _aidl_return) {
211 ALOGV("%s", __FUNCTION__);
212
213 if (in_frontendId >= mFrontendSize || in_frontendId < 0) {
214 ALOGW("[ WARN ] Frontend with id %d isn't available", in_frontendId);
215 *_aidl_return = nullptr;
Hongguange423acd2021-07-27 16:56:47 -0700216 return ::ndk::ScopedAStatus::fromServiceSpecificError(
217 static_cast<int32_t>(Result::INVALID_ARGUMENT));
Hongguang4092f2f2021-07-08 18:49:12 -0700218 }
219
220 *_aidl_return = mFrontends[in_frontendId];
221 return ::ndk::ScopedAStatus::ok();
222}
223
224::ndk::ScopedAStatus Tuner::openDemux(std::vector<int32_t>* out_demuxId,
225 std::shared_ptr<IDemux>* _aidl_return) {
226 ALOGV("%s", __FUNCTION__);
227
228 mLastUsedId += 1;
Hongguang Chenff2c6b02021-08-07 00:12:26 +0000229 mDemuxes[mLastUsedId] = ndk::SharedRefBase::make<Demux>(mLastUsedId, this->ref<Tuner>());
Hongguang4092f2f2021-07-08 18:49:12 -0700230
231 out_demuxId->push_back(mLastUsedId);
232 *_aidl_return = mDemuxes[mLastUsedId];
233
234 return ::ndk::ScopedAStatus::ok();
235}
236
237::ndk::ScopedAStatus Tuner::getDemuxCaps(DemuxCapabilities* _aidl_return) {
238 ALOGV("%s", __FUNCTION__);
239
240 // IP filter can be an MMTP filter's data source.
241 _aidl_return->linkCaps = {0x00, 0x00, 0x02, 0x00, 0x00};
242 // Support time filter testing
243 _aidl_return->bTimeFilter = true;
244
245 return ::ndk::ScopedAStatus::ok();
246}
247
248::ndk::ScopedAStatus Tuner::openDescrambler(std::shared_ptr<IDescrambler>* _aidl_return) {
249 ALOGV("%s", __FUNCTION__);
250
251 *_aidl_return = ndk::SharedRefBase::make<Descrambler>();
252
253 return ndk::ScopedAStatus::ok();
254}
255
256::ndk::ScopedAStatus Tuner::getFrontendInfo(int32_t in_frontendId, FrontendInfo* _aidl_return) {
257 ALOGV("%s", __FUNCTION__);
258
259 if (in_frontendId >= mFrontendSize) {
Hongguange423acd2021-07-27 16:56:47 -0700260 return ::ndk::ScopedAStatus::fromServiceSpecificError(
261 static_cast<int32_t>(Result::INVALID_ARGUMENT));
Hongguang4092f2f2021-07-08 18:49:12 -0700262 }
263
264 // assign randomly selected values for testing.
265 *_aidl_return = {
266 .type = mFrontends[in_frontendId]->getFrontendType(),
Gareth Fenn282fb372021-09-27 15:14:11 +0100267 .minFrequency = 139000000,
268 .maxFrequency = 1139000000,
Hongguang4092f2f2021-07-08 18:49:12 -0700269 .minSymbolRate = 45,
270 .maxSymbolRate = 1145,
271 .acquireRange = 30,
272 .exclusiveGroupId = 57,
273 .statusCaps = mFrontendStatusCaps[in_frontendId],
274 .frontendCaps = mFrontendCaps[in_frontendId],
275 };
276
277 return ::ndk::ScopedAStatus::ok();
278}
279
280::ndk::ScopedAStatus Tuner::getLnbIds(std::vector<int32_t>* _aidl_return) {
281 ALOGV("%s", __FUNCTION__);
282
283 _aidl_return->resize(mLnbs.size());
284 for (int i = 0; i < mLnbs.size(); i++) {
285 (*_aidl_return)[i] = mLnbs[i]->getId();
286 }
287
288 return ::ndk::ScopedAStatus::ok();
289}
290
291::ndk::ScopedAStatus Tuner::openLnbById(int32_t in_lnbId, std::shared_ptr<ILnb>* _aidl_return) {
292 ALOGV("%s", __FUNCTION__);
293
294 if (in_lnbId >= mLnbs.size()) {
295 *_aidl_return = nullptr;
Hongguange423acd2021-07-27 16:56:47 -0700296 return ::ndk::ScopedAStatus::fromServiceSpecificError(
297 static_cast<int32_t>(Result::INVALID_ARGUMENT));
Hongguang4092f2f2021-07-08 18:49:12 -0700298 }
299
300 *_aidl_return = mLnbs[in_lnbId];
301 return ::ndk::ScopedAStatus::ok();
302}
303
304std::shared_ptr<Frontend> Tuner::getFrontendById(int32_t frontendId) {
305 ALOGV("%s", __FUNCTION__);
306
307 return mFrontends[frontendId];
308}
309
310::ndk::ScopedAStatus Tuner::openLnbByName(const std::string& /* in_lnbName */,
311 std::vector<int32_t>* out_lnbId,
312 std::shared_ptr<ILnb>* _aidl_return) {
313 ALOGV("%s", __FUNCTION__);
314
315 out_lnbId->push_back(1234);
316 *_aidl_return = ndk::SharedRefBase::make<Lnb>();
317
318 return ::ndk::ScopedAStatus::ok();
319}
320
Hongguangfcedda02021-12-13 17:08:02 -0800321::ndk::ScopedAStatus Tuner::setLna(bool /* in_bEnable */) {
322 ALOGV("%s", __FUNCTION__);
323
324 return ::ndk::ScopedAStatus::ok();
325}
326
Hongguang2ecfc392021-11-23 10:29:15 -0800327binder_status_t Tuner::dump(int fd, const char** args, uint32_t numArgs) {
328 ALOGV("%s", __FUNCTION__);
329 {
330 dprintf(fd, "Frontends:\n");
331 for (int i = 0; i < mFrontendSize; i++) {
332 mFrontends[i]->dump(fd, args, numArgs);
333 for (int j = 0; j < mFrontendStatusCaps[i].size(); j++) {
334 dprintf(fd, " statusCap: %d\n", mFrontendStatusCaps[i][j]);
335 }
336 }
337 }
338 {
339 dprintf(fd, "Demuxs:\n");
340 map<int32_t, std::shared_ptr<Demux>>::iterator it;
341 for (it = mDemuxes.begin(); it != mDemuxes.end(); it++) {
342 it->second->dump(fd, args, numArgs);
343 }
344 }
345 {
346 dprintf(fd, "Lnbs:\n");
347 for (int i = 0; i < mLnbs.size(); i++) {
348 mLnbs[i]->dump(fd, args, numArgs);
349 }
350 }
351 return STATUS_OK;
352}
353
Hongguang4092f2f2021-07-08 18:49:12 -0700354void Tuner::setFrontendAsDemuxSource(int32_t frontendId, int32_t demuxId) {
355 mFrontendToDemux[frontendId] = demuxId;
356 if (mFrontends[frontendId] != nullptr && mFrontends[frontendId]->isLocked()) {
357 mDemuxes[demuxId]->startFrontendInputLoop();
358 }
359}
360
361void Tuner::removeDemux(int32_t demuxId) {
362 map<int32_t, int32_t>::iterator it;
363 for (it = mFrontendToDemux.begin(); it != mFrontendToDemux.end(); it++) {
364 if (it->second == demuxId) {
365 it = mFrontendToDemux.erase(it);
366 break;
367 }
368 }
369 mDemuxes.erase(demuxId);
370}
371
372void Tuner::removeFrontend(int32_t frontendId) {
Hongguang2ecfc392021-11-23 10:29:15 -0800373 map<int32_t, int32_t>::iterator it = mFrontendToDemux.find(frontendId);
374 if (it != mFrontendToDemux.end()) {
375 mDemuxes.erase(it->second);
376 }
Hongguang4092f2f2021-07-08 18:49:12 -0700377 mFrontendToDemux.erase(frontendId);
378}
379
380void Tuner::frontendStopTune(int32_t frontendId) {
381 map<int32_t, int32_t>::iterator it = mFrontendToDemux.find(frontendId);
382 int32_t demuxId;
383 if (it != mFrontendToDemux.end()) {
384 demuxId = it->second;
385 mDemuxes[demuxId]->stopFrontendInput();
386 }
387}
388
389void Tuner::frontendStartTune(int32_t frontendId) {
390 map<int32_t, int32_t>::iterator it = mFrontendToDemux.find(frontendId);
391 int32_t demuxId;
392 if (it != mFrontendToDemux.end()) {
393 demuxId = it->second;
394 mDemuxes[demuxId]->startFrontendInputLoop();
395 }
396}
397
398} // namespace tuner
399} // namespace tv
400} // namespace hardware
401} // namespace android
402} // namespace aidl