587 lines
19 KiB
C++
587 lines
19 KiB
C++
/*
|
|
* Copyright (C) 2015 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.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <errno.h>
|
|
#include <unistd.h>
|
|
#include <limits.h>
|
|
#include <string.h>
|
|
#include <fcntl.h>
|
|
#include <sys/poll.h>
|
|
#include <sys/ioctl.h>
|
|
#include <linux/dvb/dmx.h>
|
|
#include <linux/dvb/frontend.h>
|
|
|
|
#define LOG_TAG "DvbManager"
|
|
#include "logging.h"
|
|
|
|
#include "DvbManager.h"
|
|
|
|
static double currentTimeMillis() {
|
|
struct timeval tv;
|
|
gettimeofday(&tv, (struct timezone *) NULL);
|
|
return tv.tv_sec * 1000.0 + tv.tv_usec / 1000.0;
|
|
}
|
|
|
|
DvbManager::DvbManager(JNIEnv *env, jobject)
|
|
: mFeFd(-1),
|
|
mDvrFd(-1),
|
|
mPatFilterFd(-1),
|
|
mDvbApiVersion(DVB_API_VERSION_UNDEFINED),
|
|
mFeHasLock(false),
|
|
mHasPendingTune(false) {
|
|
jclass clazz = env->FindClass("com/android/tv/tuner/TunerHal");
|
|
mOpenDvbFrontEndMethodID =
|
|
env->GetMethodID(clazz, "openDvbFrontEndFd", "()I");
|
|
mOpenDvbDemuxMethodID = env->GetMethodID(clazz, "openDvbDemuxFd", "()I");
|
|
mOpenDvbDvrMethodID = env->GetMethodID(clazz, "openDvbDvrFd", "()I");
|
|
memset(&mDeliverySystemTypes, DELIVERY_SYSTEM_UNDEFINED,
|
|
sizeof(mDeliverySystemTypes));
|
|
}
|
|
|
|
DvbManager::~DvbManager() {
|
|
reset();
|
|
}
|
|
|
|
bool DvbManager::isFeLocked() {
|
|
if (mDvbApiVersion == DVB_API_VERSION5) {
|
|
fe_status_t status;
|
|
if (ioctl(mFeFd, FE_READ_STATUS, &status) < 0) {
|
|
return false;
|
|
}
|
|
if (status & FE_HAS_LOCK) {
|
|
return true;
|
|
}
|
|
} else {
|
|
struct pollfd pollFd;
|
|
pollFd.fd = mFeFd;
|
|
pollFd.events = POLLIN;
|
|
pollFd.revents = 0;
|
|
int poll_result = poll(&pollFd, NUM_POLLFDS, FE_POLL_TIMEOUT_MS);
|
|
if (poll_result > 0 && (pollFd.revents & POLLIN)) {
|
|
struct dvb_frontend_event kevent;
|
|
memset(&kevent, 0, sizeof(kevent));
|
|
if (ioctl(mFeFd, FE_GET_EVENT, &kevent) == 0) {
|
|
return (kevent.status & FE_HAS_LOCK);
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// This function gets the signal strength from tuner.
|
|
// Output can be:
|
|
// -3 means File Descriptor invalid,
|
|
// or DVB version is not supported,
|
|
// or ERROR while communicate with hardware via ioctl.
|
|
// int signal returns the raw signal strength value.
|
|
int DvbManager::getSignalStrength() {
|
|
// TODO(b/74197177): add support for DVB V5.
|
|
if (mFeFd == -1 || mDvbApiVersion != DVB_API_VERSION3) {
|
|
return -3;
|
|
}
|
|
uint16_t strength = 0;
|
|
// ERROR code from ioctl can be:
|
|
// EBADF means fd is not a valid open file descriptor
|
|
// EFAULT means status points to invalid address
|
|
// ENOSIGNAL means there is no signal, thus no meaningful signal strength
|
|
// ENOSYS means function not available for this device
|
|
//
|
|
// The function used to communicate with tuner in DVB v3 is
|
|
// ioctl(fd, request, &strength)
|
|
// int fd is the File Descriptor, can't be -1
|
|
// int request is the request type,
|
|
// FE_READ_SIGNAL_STRENGTH for getting signal strength
|
|
// uint16_t *strength stores the strength value returned from tuner
|
|
if (ioctl(mFeFd, FE_READ_SIGNAL_STRENGTH, &strength) == -1) {
|
|
ALOGD("FE_READ_SIGNAL_STRENGTH failed, %s", strerror(errno));
|
|
return -3;
|
|
}
|
|
return strength;
|
|
}
|
|
|
|
int DvbManager::tune(JNIEnv *env, jobject thiz,
|
|
const int frequency, const char *modulationStr, int timeout_ms) {
|
|
return tuneInternal(env, thiz, DELIVERY_SYSTEM_UNDEFINED, frequency,
|
|
modulationStr, timeout_ms);
|
|
}
|
|
|
|
int DvbManager::tune(JNIEnv *env, jobject thiz,
|
|
const int deliverySystemType, const int frequency,
|
|
const char *modulationStr, int timeout_ms) {
|
|
return tuneInternal(env, thiz, deliverySystemType, frequency,
|
|
modulationStr, timeout_ms);
|
|
}
|
|
|
|
int DvbManager::tuneInternal(JNIEnv *env, jobject thiz,
|
|
const int deliverySystemType, const int frequency,
|
|
const char *modulationStr, int timeout_ms) {
|
|
resetExceptFe();
|
|
|
|
if (openDvbFe(env, thiz) != 0) {
|
|
return -1;
|
|
}
|
|
|
|
if (frequency < 0) {
|
|
return -1;
|
|
}
|
|
|
|
if (mDvbApiVersion == DVB_API_VERSION_UNDEFINED) {
|
|
struct dtv_property testProps[1] = {
|
|
{ .cmd = DTV_DELIVERY_SYSTEM }
|
|
};
|
|
struct dtv_properties feProp = {
|
|
.num = 1, .props = testProps
|
|
};
|
|
// On fugu, DVB_API_VERSION is 5 but it doesn't support FE_SET_PROPERTY. Checking the device
|
|
// support FE_GET_PROPERTY or not to determine the DVB API version is greater than 5 or not.
|
|
if (ioctl(mFeFd, FE_GET_PROPERTY, &feProp) == -1) {
|
|
ALOGD("FE_GET_PROPERTY failed, %s", strerror(errno));
|
|
mDvbApiVersion = DVB_API_VERSION3;
|
|
} else {
|
|
mDvbApiVersion = DVB_API_VERSION5;
|
|
}
|
|
}
|
|
|
|
if (mDvbApiVersion == DVB_API_VERSION5) {
|
|
struct dtv_property deliverySystemProperty = {
|
|
.cmd = DTV_DELIVERY_SYSTEM
|
|
};
|
|
switch (deliverySystemType) {
|
|
case DELIVERY_SYSTEM_DVBT:
|
|
deliverySystemProperty.u.data = SYS_DVBT;
|
|
break;
|
|
case DELIVERY_SYSTEM_DVBT2:
|
|
deliverySystemProperty.u.data = SYS_DVBT2;
|
|
break;
|
|
case DELIVERY_SYSTEM_DVBS:
|
|
deliverySystemProperty.u.data = SYS_DVBS;
|
|
break;
|
|
case DELIVERY_SYSTEM_DVBS2:
|
|
deliverySystemProperty.u.data = SYS_DVBS2;
|
|
break;
|
|
case DELIVERY_SYSTEM_DVBC:
|
|
deliverySystemProperty.u.data = SYS_DVBC_ANNEX_A;
|
|
break;
|
|
case DELIVERY_SYSTEM_ATSC:
|
|
case DELIVERY_SYSTEM_UNDEFINED:
|
|
deliverySystemProperty.u.data = SYS_ATSC;
|
|
break;
|
|
default:
|
|
ALOGE("Unrecognized delivery system type");
|
|
return -1;
|
|
}
|
|
struct dtv_property frequencyProperty = {
|
|
.cmd = DTV_FREQUENCY
|
|
};
|
|
struct dtv_property bandwidthProperty = {
|
|
.cmd = DTV_BANDWIDTH_HZ, .u.data = 8000000
|
|
};
|
|
frequencyProperty.u.data = static_cast<__u32>(frequency);
|
|
struct dtv_property modulationProperty = { .cmd = DTV_MODULATION };
|
|
if (strncmp(modulationStr, "QAM", 3) == 0) {
|
|
modulationProperty.u.data = QAM_AUTO;
|
|
} else if (strcmp(modulationStr, "8VSB") == 0) {
|
|
modulationProperty.u.data = VSB_8;
|
|
} else {
|
|
ALOGE("Unrecognized modulation mode : %s", modulationStr);
|
|
return -1;
|
|
}
|
|
struct dtv_property tuneProperty = { .cmd = DTV_TUNE };
|
|
|
|
struct dtv_property props[] = {
|
|
deliverySystemProperty, frequencyProperty, modulationProperty,
|
|
bandwidthProperty, tuneProperty
|
|
};
|
|
struct dtv_properties dtvProperty = {
|
|
.num = sizeof(props)/sizeof(dtv_property), .props = props
|
|
};
|
|
|
|
if (mHasPendingTune) {
|
|
return -1;
|
|
}
|
|
if (ioctl(mFeFd, FE_SET_PROPERTY, &dtvProperty) != 0) {
|
|
ALOGD("Can't set Frontend : %s", strerror(errno));
|
|
return -1;
|
|
}
|
|
} else {
|
|
struct dvb_frontend_parameters feParams;
|
|
memset(&feParams, 0, sizeof(struct dvb_frontend_parameters));
|
|
feParams.frequency = frequency;
|
|
feParams.inversion = INVERSION_AUTO;
|
|
/* Check frontend capability */
|
|
struct dvb_frontend_info feInfo;
|
|
if (ioctl(mFeFd, FE_GET_INFO, &feInfo) != -1) {
|
|
if (!(feInfo.caps & FE_CAN_INVERSION_AUTO)) {
|
|
// FE can't do INVERSION_AUTO, trying INVERSION_OFF instead
|
|
feParams.inversion = INVERSION_OFF;
|
|
}
|
|
}
|
|
switch (feInfo.type) {
|
|
case FE_ATSC:
|
|
if (strcmp(modulationStr, "8VSB") == 0) {
|
|
feParams.u.vsb.modulation = VSB_8;
|
|
} else if (strncmp(modulationStr, "QAM", 3) == 0) {
|
|
feParams.u.vsb.modulation = QAM_AUTO;
|
|
} else {
|
|
ALOGE("Unrecognized modulation mode : %s", modulationStr);
|
|
return -1;
|
|
}
|
|
break;
|
|
case FE_OFDM:
|
|
if (strcmp(modulationStr, "8VSB") == 0) {
|
|
feParams.u.ofdm.constellation = VSB_8;
|
|
} else if (strcmp(modulationStr, "QAM16") == 0) {
|
|
feParams.u.ofdm.constellation = QAM_16;
|
|
} else if (strcmp(modulationStr, "QAM64") == 0) {
|
|
feParams.u.ofdm.constellation = QAM_64;
|
|
} else if (strcmp(modulationStr, "QAM256") == 0) {
|
|
feParams.u.ofdm.constellation = QAM_256;
|
|
} else if (strcmp(modulationStr, "QPSK") == 0) {
|
|
feParams.u.ofdm.constellation = QPSK;
|
|
} else {
|
|
ALOGE("Unrecognized modulation mode : %s", modulationStr);
|
|
return -1;
|
|
}
|
|
feParams.u.ofdm.code_rate_HP = FEC_AUTO;
|
|
feParams.u.ofdm.code_rate_LP = FEC_AUTO;
|
|
feParams.u.ofdm.transmission_mode = TRANSMISSION_MODE_AUTO;
|
|
break;
|
|
default:
|
|
ALOGE("Unsupported delivery system.");
|
|
return -1;
|
|
}
|
|
|
|
if (mHasPendingTune) {
|
|
return -1;
|
|
}
|
|
|
|
if (ioctl(mFeFd, FE_SET_FRONTEND, &feParams) != 0) {
|
|
ALOGD("Can't set Frontend : %s", strerror(errno));
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
int lockSuccessCount = 0;
|
|
double tuneClock = currentTimeMillis();
|
|
while (currentTimeMillis() - tuneClock < timeout_ms) {
|
|
if (mHasPendingTune) {
|
|
// Return 0 here since we already call FE_SET_FRONTEND, and return due to having pending
|
|
// tune request. And the frontend setting could be successful.
|
|
mFeHasLock = true;
|
|
return 0;
|
|
}
|
|
bool lockStatus = isFeLocked();
|
|
if (lockStatus) {
|
|
lockSuccessCount++;
|
|
} else {
|
|
lockSuccessCount = 0;
|
|
}
|
|
ALOGI("Lock status : %s", lockStatus ? "true" : "false");
|
|
if (lockSuccessCount >= FE_CONSECUTIVE_LOCK_SUCCESS_COUNT) {
|
|
mFeHasLock = true;
|
|
openDvbDvr(env, thiz);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
int DvbManager::stopTune() {
|
|
reset();
|
|
usleep(DVB_TUNE_STOP_DELAY_MS);
|
|
return 0;
|
|
}
|
|
|
|
int DvbManager::openDvbFeFromSystemApi(JNIEnv *env, jobject thiz) {
|
|
int fd = (int) env->CallIntMethod(thiz, mOpenDvbFrontEndMethodID);
|
|
fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
|
|
return fd;
|
|
}
|
|
|
|
int DvbManager::openDvbDemuxFromSystemApi(JNIEnv *env, jobject thiz) {
|
|
int fd = (int) env->CallIntMethod(thiz, mOpenDvbDemuxMethodID);
|
|
fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
|
|
return fd;
|
|
}
|
|
|
|
int DvbManager::openDvbDvrFromSystemApi(JNIEnv *env, jobject thiz) {
|
|
int fd = (int) env->CallIntMethod(thiz, mOpenDvbDvrMethodID);
|
|
fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
|
|
return fd;
|
|
}
|
|
|
|
int DvbManager::openDvbFe(JNIEnv *env, jobject thiz) {
|
|
if (mFeFd == -1) {
|
|
if ((mFeFd = openDvbFeFromSystemApi(env, thiz)) < 0) {
|
|
ALOGD("Can't open FE file : %s", strerror(errno));
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
struct dvb_frontend_info info;
|
|
if (ioctl(mFeFd, FE_GET_INFO, &info) == 0) {
|
|
const char *types;
|
|
switch (info.type) {
|
|
case FE_QPSK:
|
|
types = "DVB-S";
|
|
break;
|
|
case FE_QAM:
|
|
types = "DVB-C";
|
|
break;
|
|
case FE_OFDM:
|
|
types = "DVB-T";
|
|
break;
|
|
case FE_ATSC:
|
|
types = "ATSC";
|
|
break;
|
|
default:
|
|
types = "Unknown";
|
|
}
|
|
ALOGI("Using frontend \"%s\", type %s", info.name, types);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int DvbManager::startTsPidFilter(JNIEnv *env, jobject thiz, int pid, int filterType) {
|
|
Mutex::Autolock autoLock(mFilterLock);
|
|
|
|
if (mPidFilters.find(pid) != mPidFilters.end() || (mPatFilterFd != -1 && pid == PAT_PID)) {
|
|
return 0;
|
|
}
|
|
|
|
if (mHasPendingTune) {
|
|
return -1;
|
|
}
|
|
|
|
int demuxFd;
|
|
if ((demuxFd = openDvbDemuxFromSystemApi(env, thiz)) < 0) {
|
|
ALOGD("Can't open DEMUX file : %s", strerror(errno));
|
|
return -1;
|
|
}
|
|
|
|
struct dmx_pes_filter_params filter;
|
|
memset(&filter, 0, sizeof(filter));
|
|
filter.pid = pid;
|
|
filter.input = DMX_IN_FRONTEND;
|
|
switch (filterType) {
|
|
case FILTER_TYPE_AUDIO:
|
|
filter.pes_type = DMX_PES_AUDIO;
|
|
break;
|
|
case FILTER_TYPE_VIDEO:
|
|
filter.pes_type = DMX_PES_VIDEO;
|
|
break;
|
|
case FILTER_TYPE_PCR:
|
|
filter.pes_type = DMX_PES_PCR;
|
|
break;
|
|
default:
|
|
filter.pes_type = DMX_PES_OTHER;
|
|
break;
|
|
}
|
|
filter.output = DMX_OUT_TS_TAP;
|
|
filter.flags |= (DMX_CHECK_CRC | DMX_IMMEDIATE_START);
|
|
|
|
// create a pes filter
|
|
if (ioctl(demuxFd, DMX_SET_PES_FILTER, &filter)) {
|
|
close(demuxFd);
|
|
return -1;
|
|
}
|
|
|
|
if (mDvbApiVersion == DVB_API_VERSION5) {
|
|
ioctl(demuxFd, DMX_START, 0);
|
|
}
|
|
|
|
if (pid != PAT_PID) {
|
|
mPidFilters.insert(std::pair<int, int>(pid, demuxFd));
|
|
} else {
|
|
mPatFilterFd = demuxFd;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void DvbManager::closeAllDvbPidFilter() {
|
|
// Close all dvb pid filters except PAT filter to maintain the opening status of the device.
|
|
Mutex::Autolock autoLock(mFilterLock);
|
|
|
|
for (std::map<int, int>::iterator it(mPidFilters.begin());
|
|
it != mPidFilters.end(); it++) {
|
|
close(it->second);
|
|
}
|
|
mPidFilters.clear();
|
|
// Close mDvrFd to make sure there is not buffer from previous channel left.
|
|
closeDvbDvr();
|
|
}
|
|
|
|
void DvbManager::closePatFilter() {
|
|
Mutex::Autolock autoLock(mFilterLock);
|
|
|
|
if (mPatFilterFd != -1) {
|
|
close(mPatFilterFd);
|
|
mPatFilterFd = -1;
|
|
}
|
|
}
|
|
|
|
int DvbManager::openDvbDvr(JNIEnv *env, jobject thiz) {
|
|
if ((mDvrFd = openDvbDvrFromSystemApi(env, thiz)) < 0) {
|
|
ALOGD("Can't open DVR file : %s", strerror(errno));
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void DvbManager::closeDvbFe() {
|
|
if (mFeFd != -1) {
|
|
close(mFeFd);
|
|
mFeFd = -1;
|
|
}
|
|
}
|
|
|
|
void DvbManager::closeDvbDvr() {
|
|
if (mDvrFd != -1) {
|
|
close(mDvrFd);
|
|
mDvrFd = -1;
|
|
}
|
|
}
|
|
|
|
void DvbManager::reset() {
|
|
mFeHasLock = false;
|
|
closeDvbDvr();
|
|
closeAllDvbPidFilter();
|
|
closePatFilter();
|
|
closeDvbFe();
|
|
}
|
|
|
|
void DvbManager::resetExceptFe() {
|
|
mFeHasLock = false;
|
|
closeDvbDvr();
|
|
closeAllDvbPidFilter();
|
|
closePatFilter();
|
|
}
|
|
|
|
int DvbManager::readTsStream(JNIEnv *env, jobject thiz,
|
|
uint8_t *tsBuffer, int tsBufferSize, int timeout_ms) {
|
|
if (!mFeHasLock) {
|
|
usleep(DVB_ERROR_RETRY_INTERVAL_MS);
|
|
return -1;
|
|
}
|
|
|
|
if (mDvrFd == -1) {
|
|
openDvbDvr(env, thiz);
|
|
}
|
|
|
|
struct pollfd pollFd;
|
|
pollFd.fd = mDvrFd;
|
|
pollFd.events = POLLIN|POLLPRI|POLLERR;
|
|
pollFd.revents = 0;
|
|
int poll_result = poll(&pollFd, NUM_POLLFDS, timeout_ms);
|
|
if (poll_result == 0) {
|
|
return 0;
|
|
} else if (poll_result == -1 || pollFd.revents & POLLERR) {
|
|
ALOGD("Can't read DVR : %s", strerror(errno));
|
|
// TODO: Find how to recover this situation correctly.
|
|
closeDvbDvr();
|
|
usleep(DVB_ERROR_RETRY_INTERVAL_MS);
|
|
return -1;
|
|
}
|
|
return read(mDvrFd, tsBuffer, tsBufferSize);
|
|
}
|
|
|
|
void DvbManager::setHasPendingTune(bool hasPendingTune) {
|
|
mHasPendingTune = hasPendingTune;
|
|
}
|
|
|
|
int DvbManager::getDeliverySystemType(JNIEnv *env, jobject thiz) {
|
|
getDeliverySystemTypes(env, thiz);
|
|
return mDeliverySystemTypes[0];
|
|
}
|
|
|
|
int* DvbManager::getDeliverySystemTypes(JNIEnv *env, jobject thiz) {
|
|
ALOGE("getDeliverySystemTypes");
|
|
if (mDeliverySystemTypes[0] != DELIVERY_SYSTEM_UNDEFINED) {
|
|
return mDeliverySystemTypes;
|
|
}
|
|
if (mFeFd == -1) {
|
|
if ((mFeFd = openDvbFeFromSystemApi(env, thiz)) < 0) {
|
|
ALOGD("Can't open FE file : %s", strerror(errno));
|
|
return mDeliverySystemTypes;
|
|
}
|
|
}
|
|
struct dtv_property testProps[1] = {
|
|
{ .cmd = DTV_ENUM_DELSYS }
|
|
};
|
|
struct dtv_properties feProp = {
|
|
.num = 1, .props = testProps
|
|
};
|
|
if (ioctl(mFeFd, FE_GET_PROPERTY, &feProp) == -1) {
|
|
mDvbApiVersion = DVB_API_VERSION3;
|
|
if (openDvbFe(env, thiz) == 0) {
|
|
struct dvb_frontend_info info;
|
|
if (ioctl(mFeFd, FE_GET_INFO, &info) == 0) {
|
|
switch (info.type) {
|
|
case FE_QPSK:
|
|
mDeliverySystemTypes[0] = DELIVERY_SYSTEM_DVBS;
|
|
break;
|
|
case FE_QAM:
|
|
mDeliverySystemTypes[0] = DELIVERY_SYSTEM_DVBC;
|
|
break;
|
|
case FE_OFDM:
|
|
mDeliverySystemTypes[0] = DELIVERY_SYSTEM_DVBT;
|
|
break;
|
|
case FE_ATSC:
|
|
mDeliverySystemTypes[0] = DELIVERY_SYSTEM_ATSC;
|
|
break;
|
|
default:
|
|
mDeliverySystemTypes[0] = DELIVERY_SYSTEM_UNDEFINED;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
mDvbApiVersion = DVB_API_VERSION5;
|
|
for (unsigned int i = 0; i < feProp.props[0].u.buffer.len; i++) {
|
|
switch (feProp.props[0].u.buffer.data[i]) {
|
|
case SYS_DVBT:
|
|
mDeliverySystemTypes[i] = DELIVERY_SYSTEM_DVBT;
|
|
break;
|
|
case SYS_DVBT2:
|
|
mDeliverySystemTypes[i] = DELIVERY_SYSTEM_DVBT2;
|
|
break;
|
|
case SYS_DVBS:
|
|
mDeliverySystemTypes[i] = DELIVERY_SYSTEM_DVBS;
|
|
break;
|
|
case SYS_DVBS2:
|
|
mDeliverySystemTypes[i] = DELIVERY_SYSTEM_DVBS2;
|
|
break;
|
|
case SYS_DVBC_ANNEX_A:
|
|
case SYS_DVBC_ANNEX_B:
|
|
case SYS_DVBC_ANNEX_C:
|
|
mDeliverySystemTypes[i] = DELIVERY_SYSTEM_DVBC;
|
|
break;
|
|
case SYS_ATSC:
|
|
mDeliverySystemTypes[i] = DELIVERY_SYSTEM_ATSC;
|
|
break;
|
|
default:
|
|
mDeliverySystemTypes[i] = DELIVERY_SYSTEM_UNDEFINED;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return mDeliverySystemTypes;
|
|
}
|