system=eDVBFrontendParametersSatellite::System_DVB_S,
modulation=eDVBFrontendParametersSatellite::Modulation_QPSK,
rolloff=eDVBFrontendParametersSatellite::RollOff_alpha_0_35,
- pilot=eDVBFrontendParametersSatellite::Pilot_Unknown;
+ pilot=eDVBFrontendParametersSatellite::Pilot_Unknown,
+ is_id = NO_STREAM_ID_FILTER,
+ pls_code = 0,
+ pls_mode = eDVBFrontendParametersSatellite::PLS_Unknown;
if (version == 3)
sscanf(line+3, "%d:%d:%d:%d:%d:%d:%d:%d:%d:%d", &frequency, &symbol_rate, &polarisation, &fec, &orbital_position, &inversion, &system, &modulation, &rolloff, &pilot);
else
- sscanf(line+3, "%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d", &frequency, &symbol_rate, &polarisation, &fec, &orbital_position, &inversion, &flags, &system, &modulation, &rolloff, &pilot);
+ sscanf(line+3, "%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d",
+ &frequency, &symbol_rate, &polarisation, &fec, &orbital_position,
+ &inversion, &flags, &system, &modulation, &rolloff, &pilot,
+ &is_id, &pls_code, &pls_mode);
sat.frequency = frequency;
sat.symbol_rate = symbol_rate;
sat.polarisation = polarisation;
sat.modulation = modulation;
sat.rolloff = rolloff;
sat.pilot = pilot;
+ sat.is_id = is_id;
+ sat.pls_mode = pls_mode & 3;
+ sat.pls_code = pls_code & 0x3FFFF;
feparm->setDVBS(sat);
feparm->setFlags(flags);
} else if (line[1]=='t')
ch.m_frontendParameters->getFlags(flags);
if (!ch.m_frontendParameters->getDVBS(sat))
{
- if (sat.system == eDVBFrontendParametersSatellite::System_DVB_S2)
- {
- fprintf(f, "\ts %d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d\n",
- sat.frequency, sat.symbol_rate,
- sat.polarisation, sat.fec,
- sat.orbital_position > 1800 ? sat.orbital_position - 3600 : sat.orbital_position,
- sat.inversion,
- flags,
- sat.system,
- sat.modulation,
- sat.rolloff,
- sat.pilot);
- }
- else
+ fprintf(f, "\ts %d:%d:%d:%d:%d:%d:%d",
+ sat.frequency, sat.symbol_rate, sat.polarisation, sat.fec,
+ sat.orbital_position > 1800 ? sat.orbital_position - 3600 : sat.orbital_position,
+ sat.inversion, flags);
+
+ if ((sat.system == eDVBFrontendParametersSatellite::System_DVB_S2) || (sat.system == eDVBFrontendParametersSatellite::System_DVB_S2X))
{
- fprintf(f, "\ts %d:%d:%d:%d:%d:%d:%d\n",
- sat.frequency, sat.symbol_rate,
- sat.polarisation, sat.fec,
- sat.orbital_position > 1800 ? sat.orbital_position - 3600 : sat.orbital_position,
- sat.inversion, flags);
+ fprintf(f, ":%d:%d:%d:%d", sat.system, sat.modulation, sat.rolloff, sat.pilot);
+
+ if (static_cast<unsigned int>(sat.is_id) != NO_STREAM_ID_FILTER ||
+ (sat.pls_code & 0x3FFFF) != 0 ||
+ (sat.pls_mode & 3) != eDVBFrontendParametersSatellite::PLS_Unknown)
+ {
+ fprintf(f, ":%d:%d:%d", sat.is_id, sat.pls_code & 0x3FFFF, sat.pls_mode & 3);
+ }
}
+ fprintf(f, "\n");
}
else if (!ch.m_frontendParameters->getDVBT(ter))
{
return Py_False;
}
int tmp, *dest = NULL,
- modulation, system, freq, sr, pol, fec, inv, pilot, rolloff, tsid, onid;
+ modulation, system, freq, sr, pol, fec, inv, pilot, rolloff, is_id, pls_code, pls_mode, tsid, onid;
char *end_ptr;
const Attribute *at;
std::string name;
inv = eDVBFrontendParametersSatellite::Inversion_Unknown;
pilot = eDVBFrontendParametersSatellite::Pilot_Unknown;
rolloff = eDVBFrontendParametersSatellite::RollOff_alpha_0_35;
+ is_id = NO_STREAM_ID_FILTER;
+ pls_code = 0;
+ pls_mode = eDVBFrontendParametersSatellite::PLS_Unknown;
tsid = -1;
onid = -1;
else if (name == "inversion") dest = &inv;
else if (name == "rolloff") dest = &rolloff;
else if (name == "pilot") dest = &pilot;
+ else if (name == "is_id") dest = &is_id;
+ else if (name == "pls_code") dest = &pls_code;
+ else if (name == "pls_mode") dest = &pls_mode;
else if (name == "tsid") dest = &tsid;
else if (name == "onid") dest = &onid;
else continue;
}
if (freq && sr && pol != -1)
{
- tuple = PyTuple_New(12);
+ tuple = PyTuple_New(15);
PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(0));
PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(freq));
PyTuple_SET_ITEM(tuple, 2, PyInt_FromLong(sr));
PyTuple_SET_ITEM(tuple, 7, PyInt_FromLong(inv));
PyTuple_SET_ITEM(tuple, 8, PyInt_FromLong(rolloff));
PyTuple_SET_ITEM(tuple, 9, PyInt_FromLong(pilot));
- PyTuple_SET_ITEM(tuple, 10, PyInt_FromLong(tsid));
- PyTuple_SET_ITEM(tuple, 11, PyInt_FromLong(onid));
+ PyTuple_SET_ITEM(tuple, 10, PyInt_FromLong(is_id));
+ PyTuple_SET_ITEM(tuple, 11, PyInt_FromLong(pls_mode & 3));
+ PyTuple_SET_ITEM(tuple, 12, PyInt_FromLong(pls_code & 0x3FFFF));
+ PyTuple_SET_ITEM(tuple, 13, PyInt_FromLong(tsid));
+ PyTuple_SET_ITEM(tuple, 14, PyInt_FromLong(onid));
PyList_Append(tplist, tuple);
Py_DECREF(tuple);
}
{
if (i->m_frontend->getSlotID() == index)
{
+ if (!strcmp(type, "DVB-S2X"))
+ {
+ return i->m_frontend->supportsDeliverySystem(SYS_DVBS2X, false);
+ }
if (!strcmp(type, "DVB-S2"))
{
return i->m_frontend->supportsDeliverySystem(SYS_DVBS2, false);
return false;
}
+bool eDVBResourceManager::frontendIsMultistream(int index)
+{
+ for (eSmartPtrList<eDVBRegisteredFrontend>::iterator i(m_frontend.begin()); i != m_frontend.end(); ++i)
+ {
+ if (i->m_frontend->getSlotID() == index)
+ {
+ return i->m_frontend->is_multistream();
+ }
+ }
+ return false;
+}
+
void eDVBResourceManager::setFrontendType(int index, const char *type)
{
eDebug("[eDVBResourceManager::setFrontendType] index : %d, type : %s", index, type);
{
whitelist.push_back(SYS_DVBS);
whitelist.push_back(SYS_DVBS2);
+ if (!strcmp(type, "DVB-S2X"))
+ whitelist.push_back(SYS_DVBS2X);
}
else if (!strcmp(type, "DVB-T2") || !strcmp(type, "DVB-T"))
{
SWIG_VOID(RESULT) allocateRawChannel(eUsePtr<iDVBChannel> &SWIG_OUTPUT, int slot_index);
PyObject *setFrontendSlotInformations(SWIG_PYOBJECT(ePyObject) list);
bool frontendIsCompatible(int index, const char *type);
+ bool frontendIsMultistream(int index);
void setFrontendType(int index, const char *type);
};
SWIG_TEMPLATE_TYPEDEF(ePtr<eDVBResourceManager>, eDVBResourceManager);
#define FEC_S2_QPSK_4_5 (fe_code_rate_t)(FEC_4_5)
#define FEC_S2_QPSK_9_10 (fe_code_rate_t)(FEC_9_10)
+/* DVB-S2X */
+#define FEC_S2_QPSK_13_45 (fe_code_rate_t)(FEC_13_45)
+
#include <dvbsi++/satellite_delivery_system_descriptor.h>
#include <dvbsi++/cable_delivery_system_descriptor.h>
#include <dvbsi++/terrestrial_delivery_system_descriptor.h>
orbital_position = 3600 - orbital_position;
system = descriptor.getModulationSystem();
modulation = descriptor.getModulation();
- if (system == eDVBFrontendParametersSatellite::System_DVB_S && modulation == eDVBFrontendParametersSatellite::Modulation_8PSK)
+ if (system == eDVBFrontendParametersSatellite::System_DVB_S && modulation != eDVBFrontendParametersSatellite::Modulation_QPSK)
{
eDebug("satellite_delivery_descriptor non valid modulation type.. force QPSK");
modulation=eDVBFrontendParametersSatellite::Modulation_QPSK;
}
rolloff = descriptor.getRollOff();
- if (system == eDVBFrontendParametersSatellite::System_DVB_S2)
+ is_id = NO_STREAM_ID_FILTER;
+ pls_mode = eDVBFrontendParametersSatellite::PLS_Unknown;
+ pls_code = 0;
+ if (system == eDVBFrontendParametersSatellite::System_DVB_S)
{
- eDebug("SAT DVB-S2 freq %d, %s, pos %d, sr %d, fec %d, modulation %d, rolloff %d",
+ eDebug("SAT DVB-S freq %d, %s, pos %d, sr %d, fec %d",
frequency,
polarisation ? "hor" : "vert",
orbital_position,
- symbol_rate, fec,
- modulation,
- rolloff);
+ symbol_rate, fec);
}
- else
+ else // System_DVB_S2 or System_DVB_S2X
{
- eDebug("SAT DVB-S freq %d, %s, pos %d, sr %d, fec %d",
+ eDebug("SAT DVB-S2 freq %d, %s, pos %d, sr %d, fec %d, modulation %d, rolloff %d, is_id %d, pls_mode %d, pls_code %d",
frequency,
polarisation ? "hor" : "vert",
orbital_position,
- symbol_rate, fec);
+ symbol_rate, fec,
+ modulation,
+ rolloff,
+ is_id,
+ pls_mode,
+ pls_code);
}
}
diff = 1<<29;
else if (sat.polarisation != osat.polarisation)
diff = 1<<28;
+ else if (sat.is_id != osat.is_id)
+ diff = 1<<27;
+ else if (sat.pls_mode != osat.pls_mode)
+ diff = 1<<27;
+ else if (sat.pls_code != osat.pls_code)
+ diff = 1<<27;
else if (exact && sat.fec != osat.fec && sat.fec != eDVBFrontendParametersSatellite::FEC_Auto && osat.fec != eDVBFrontendParametersSatellite::FEC_Auto)
diff = 1<<27;
else if (exact && sat.modulation != osat.modulation && sat.modulation != eDVBFrontendParametersSatellite::Modulation_Auto && osat.modulation != eDVBFrontendParametersSatellite::Modulation_Auto)
m_state=stateIdle;
m_tuning=0;
- dvb_frontend_info fe_info;
if (!m_simulate)
{
eDebug("opening frontend %d", m_dvbid);
if (m_delsys.empty())
{
+ if (::ioctl(m_fd, FE_GET_INFO, &fe_info) < 0)
+ {
+ eWarning("ioctl FE_GET_INFO failed");
+ ::close(m_fd);
+ m_fd = -1;
+ return -1;
+ }
#ifdef DTV_ENUM_DELSYS
struct dtv_property p[1];
p[0].cmd = DTV_ENUM_DELSYS;
m_delsys[delsys] = true;
}
}
+ else
#else
- if (::ioctl(m_fd, FE_GET_INFO, &fe_info) < 0)
+ /* no DTV_ENUM_DELSYS support */
+ if (1)
+#endif
{
- eWarning("ioctl FE_GET_INFO failed");
- ::close(m_fd);
- m_fd = -1;
- return -1;
- }
/* old DVB API, fill delsys map with some defaults */
- switch (fe_info.type)
- {
- case FE_QPSK:
+ switch (fe_info.type)
{
- m_delsys[SYS_DVBS] = true;
+ case FE_QPSK:
+ {
+ m_delsys[SYS_DVBS] = true;
#if DVB_API_VERSION >= 5
- if (fe_info.caps & FE_CAN_2G_MODULATION) m_delsys[SYS_DVBS2] = true;
+ if (fe_info.caps & FE_CAN_2G_MODULATION) m_delsys[SYS_DVBS2] = true;
#endif
- break;
- }
- case FE_QAM:
- {
+ break;
+ }
+ case FE_QAM:
+ {
#if defined SYS_DVBC_ANNEX_A
- m_delsys[SYS_DVBC_ANNEX_A] = true;
+ m_delsys[SYS_DVBC_ANNEX_A] = true;
#else
- m_delsys[SYS_DVBC_ANNEX_AC] = true;
+ m_delsys[SYS_DVBC_ANNEX_AC] = true;
#endif
- break;
- }
- case FE_OFDM:
- {
- m_delsys[SYS_DVBT] = true;
+ break;
+ }
+ case FE_OFDM:
+ {
+ m_delsys[SYS_DVBT] = true;
#if DVB_API_VERSION > 5 || DVB_API_VERSION == 5 && DVB_API_VERSION_MINOR >= 3
- if (fe_info.caps & FE_CAN_2G_MODULATION) m_delsys[SYS_DVBT2] = true;
+ if (fe_info.caps & FE_CAN_2G_MODULATION) m_delsys[SYS_DVBT2] = true;
#endif
- break;
- }
- case FE_ATSC: // placeholder to prevent warning
- {
- break;
+ break;
+ }
+ case FE_ATSC: // placeholder to prevent warning
+ {
+ break;
+ }
}
}
-#endif
}
if (m_simulate_fe)
m_sn = eSocketNotifier::create(eApp, m_fd, eSocketNotifier::Read, false);
CONNECT(m_sn->activated, eDVBFrontend::feEvent);
}
+ else
+ {
+ fe_info.frequency_min = 900000;
+ fe_info.frequency_max = 2200000;
+
+ eDebug("[eDVBFrontend] opening frontend %d", m_dvbid);
+ int tmp_fd = ::open(m_filename, O_RDONLY | O_NONBLOCK);
+ if (tmp_fd < 0)
+ {
+ eWarning("[eDVBFrontend] opening %s failed: %m", m_filename);
+ }
+ else
+ {
+ if (::ioctl(tmp_fd, FE_GET_INFO, &fe_info) < 0)
+ {
+ eWarning("[eDVBFrontend] ioctl FE_GET_INFO on frontend %s failed: %m", m_filename);
+ }
+ ::close(tmp_fd);
+ }
+ }
setTone(iDVBFrontend::toneOff);
setVoltage(iDVBFrontend::voltageOff);
PutToDict(dict, "fec_inner", feparm.fec);
PutToDict(dict, "modulation", feparm.modulation);
PutToDict(dict, "polarization", feparm.polarisation);
- if (feparm.system == eDVBFrontendParametersSatellite::System_DVB_S2)
+ if ((feparm.system == eDVBFrontendParametersSatellite::System_DVB_S2) || (feparm.system == eDVBFrontendParametersSatellite::System_DVB_S2X))
{
PutToDict(dict, "rolloff", feparm.rolloff);
PutToDict(dict, "pilot", feparm.pilot);
+ PutToDict(dict, "is_id", feparm.is_id);
+ PutToDict(dict, "pls_mode", feparm.pls_mode);
+ PutToDict(dict, "pls_code", feparm.pls_code);
}
PutToDict(dict, "system", feparm.system);
}
PutToDict(dict, "fec_inner", feparm.fec_inner);
}
-static void fillDictWithSatelliteData(ePyObject dict, struct dtv_property *p, long freq_offset, int orbital_position, int polarization)
+static void fillDictWithSatelliteData(ePyObject dict, struct dtv_property *p, long freq_offset, eDVBFrontendParametersSatellite &feparm)
{
long tmp=0;
int p_system = p[0].u.data;
int p_inner_fec = p[5].u.data;
int p_rolloff = p[6].u.data;
int p_pilot = p[7].u.data;
+ int p_stream_id = p[8].u.data;
int frequency = p_frequency + freq_offset;
PutToDict(dict, "frequency", frequency);
PutToDict(dict, "symbol_rate", p_symbolrate);
- PutToDict(dict, "orbital_position", orbital_position);
- PutToDict(dict, "polarization", polarization);
+ PutToDict(dict, "orbital_position", feparm.orbital_position);
+ PutToDict(dict, "polarization", feparm.polarisation);
switch(p_inner_fec)
{
case FEC_7_8: tmp = eDVBFrontendParametersSatellite::FEC_7_8; break;
case FEC_8_9: tmp = eDVBFrontendParametersSatellite::FEC_8_9; break;
case FEC_9_10: tmp = eDVBFrontendParametersSatellite::FEC_9_10; break;
+ case FEC_13_45 ... FEC_26_45_L: tmp = eDVBFrontendParametersSatellite::FEC_13_45 + (long)(p_inner_fec - FEC_13_45); break;
case FEC_NONE: tmp = eDVBFrontendParametersSatellite::FEC_None; break;
case FEC_AUTO: tmp = eDVBFrontendParametersSatellite::FEC_Auto; break;
default: eDebug("got unsupported FEC from frontend! report as FEC_AUTO!\n");
{
default: eDebug("got unsupported system from frontend! report as DVBS!");
case SYS_DVBS: tmp = eDVBFrontendParametersSatellite::System_DVB_S; break;
- case SYS_DVBS2:
+ case SYS_DVBS2: tmp = eDVBFrontendParametersSatellite::System_DVB_S2; break;
+ case SYS_DVBS2X: tmp = eDVBFrontendParametersSatellite::System_DVB_S2X; break;
+ }
+ PutToDict(dict, "system", tmp);
+
+ if ((p_system == SYS_DVBS2) || (p_system == SYS_DVBS2X))
{
switch (p_rolloff)
{
}
PutToDict(dict, "pilot", tmp);
- tmp = eDVBFrontendParametersSatellite::System_DVB_S2; break;
+ PutToDict(dict, "is_id", ((unsigned int)p_stream_id == NO_STREAM_ID_FILTER) ? feparm.is_id : (p_stream_id & 0xFF));
+ PutToDict(dict, "pls_mode", ((unsigned int)p_stream_id == NO_STREAM_ID_FILTER) ? feparm.pls_mode : ((p_stream_id >> 26) & 0x3));
+ PutToDict(dict, "pls_code", ((unsigned int)p_stream_id == NO_STREAM_ID_FILTER) ? feparm.pls_code : ((p_stream_id >> 8) & 0x3FFFF));
}
- }
- PutToDict(dict, "system", tmp);
switch (p_modulation)
{
default: eDebug("got unsupported modulation from frontend! report as QPSK!");
case QPSK: tmp = eDVBFrontendParametersSatellite::Modulation_QPSK; break;
case PSK_8: tmp = eDVBFrontendParametersSatellite::Modulation_8PSK; break;
+ case APSK_8: tmp = eDVBFrontendParametersSatellite::Modulation_8APSK; break;
+ case APSK_16: tmp = eDVBFrontendParametersSatellite::Modulation_16APSK; break;
+ case APSK_32: tmp = eDVBFrontendParametersSatellite::Modulation_32APSK; break;
}
PutToDict(dict, "modulation", tmp);
p[cmdseq.num++].cmd = DTV_INNER_FEC;
p[cmdseq.num++].cmd = DTV_ROLLOFF;
p[cmdseq.num++].cmd = DTV_PILOT;
+ p[cmdseq.num++].cmd = DTV_STREAM_ID;
}
else if(type == feCable)
{
}
else
{
- FRONTENDPARAMETERS &parm = front;
switch(type)
{
case feSatellite:
eDVBFrontendParametersSatellite sparm;
oparm.getDVBS(sparm);
- fillDictWithSatelliteData(dest, p, m_data[FREQ_OFFSET], sparm.orbital_position, sparm.polarisation);
+ fillDictWithSatelliteData(dest, p, m_data[FREQ_OFFSET], sparm);
break;
case feCable:
fillDictWithCableData(dest, p);
const char *tmp=0;
PutToDict(dest, "tuner_number", m_slotid);
- if (supportsDeliverySystem(SYS_DVBS, true) || supportsDeliverySystem(SYS_DVBS2, true))
+ if (supportsDeliverySystem(SYS_DVBS, true) || supportsDeliverySystem(SYS_DVBS2, true) || supportsDeliverySystem(SYS_DVBS2X, true))
{
tmp = "DVB-S";
}
{
case eDVBFrontendParametersSatellite::System_DVB_S: system = SYS_DVBS; break;
case eDVBFrontendParametersSatellite::System_DVB_S2: system = SYS_DVBS2; break;
+ case eDVBFrontendParametersSatellite::System_DVB_S2X: system = SYS_DVBS2X; break;
};
switch(sparm.modulation)
{
case eDVBFrontendParametersSatellite::Modulation_QPSK: modulation = QPSK; break;
case eDVBFrontendParametersSatellite::Modulation_8PSK: modulation = PSK_8; break;
case eDVBFrontendParametersSatellite::Modulation_QAM16: modulation = QAM_16; break;
+ case eDVBFrontendParametersSatellite::Modulation_8APSK: modulation = APSK_8; break;
+ case eDVBFrontendParametersSatellite::Modulation_16APSK: modulation = APSK_16; break;
+ case eDVBFrontendParametersSatellite::Modulation_32APSK: modulation = APSK_32; break;
};
switch(sparm.pilot)
{
case eDVBFrontendParametersSatellite::RollOff_alpha_0_25: rolloff = ROLLOFF_25; break;
case eDVBFrontendParametersSatellite::RollOff_alpha_0_35: rolloff = ROLLOFF_35; break;
};
- struct dtv_property p[10];
+ struct dtv_property p[11];
struct dtv_properties cmdseq;
cmdseq.props = p;
p[0].cmd = DTV_CLEAR;
p[4].cmd = DTV_SYMBOL_RATE, p[4].u.data = parm_u_qpsk_symbol_rate;
p[5].cmd = DTV_INNER_FEC, p[5].u.data = parm_u_qpsk_fec_inner;
p[6].cmd = DTV_INVERSION, p[6].u.data = parm_inversion;
- if (system == SYS_DVBS2)
+ if ((system == SYS_DVBS2) || (system == SYS_DVBS2X))
{
p[7].cmd = DTV_ROLLOFF, p[7].u.data = rolloff;
p[8].cmd = DTV_PILOT, p[8].u.data = pilot;
- p[9].cmd = DTV_TUNE;
- cmdseq.num = 10;
+ p[9].cmd = DTV_STREAM_ID, p[9].u.data = sparm.is_id | (sparm.pls_code << 8) | (sparm.pls_mode << 26);
+ p[10].cmd = DTV_TUNE;
+ cmdseq.num = 11;
}
else
{
res = m_sec->prepare(*this, parm, feparm, 1 << m_slotid, tunetimeout);
if (!res)
{
- eDebugNoSimulate("prepare_sat System %d Freq %d Pol %d SR %d INV %d FEC %d orbpos %d system %d modulation %d pilot %d, rolloff %d",
- feparm.system,
+ eDebugNoSimulate("prepare_sat Freq %d Pol %d SR %d INV %d FEC %d orbpos %d system %d modulation %d pilot %d, rolloff %d, is_id %d, pls_mode %d, pls_code %d",
feparm.frequency,
feparm.polarisation,
feparm.symbol_rate,
feparm.system,
feparm.modulation,
feparm.pilot,
- feparm.rolloff);
+ feparm.rolloff,
+ feparm.is_id,
+ feparm.pls_mode,
+ feparm.pls_code);
parm_u_qpsk_symbol_rate = feparm.symbol_rate;
switch (feparm.inversion)
{
break;
}
}
- else // DVB_S2
+ else if (feparm.system == eDVBFrontendParametersSatellite::System_DVB_S2)
{
switch (feparm.fec)
{
return -EINVAL;
}
}
+ else // DVB_S2X
+ {
+ switch (feparm.fec)
+ {
+ case eDVBFrontendParametersSatellite::FEC_1_2:
+ parm_u_qpsk_fec_inner = FEC_S2_QPSK_1_2;
+ break;
+ case eDVBFrontendParametersSatellite::FEC_2_3:
+ parm_u_qpsk_fec_inner = FEC_S2_QPSK_2_3;
+ break;
+ case eDVBFrontendParametersSatellite::FEC_3_4:
+ parm_u_qpsk_fec_inner = FEC_S2_QPSK_3_4;
+ break;
+ case eDVBFrontendParametersSatellite::FEC_3_5:
+ parm_u_qpsk_fec_inner = FEC_S2_QPSK_3_5;
+ break;
+ case eDVBFrontendParametersSatellite::FEC_4_5:
+ parm_u_qpsk_fec_inner = FEC_S2_QPSK_4_5;
+ break;
+ case eDVBFrontendParametersSatellite::FEC_5_6:
+ parm_u_qpsk_fec_inner = FEC_S2_QPSK_5_6;
+ break;
+ case eDVBFrontendParametersSatellite::FEC_7_8:
+ parm_u_qpsk_fec_inner = FEC_S2_QPSK_7_8;
+ break;
+ case eDVBFrontendParametersSatellite::FEC_8_9:
+ parm_u_qpsk_fec_inner = FEC_S2_QPSK_8_9;
+ break;
+ case eDVBFrontendParametersSatellite::FEC_9_10:
+ parm_u_qpsk_fec_inner = FEC_S2_QPSK_9_10;
+ break;
+ case eDVBFrontendParametersSatellite::FEC_13_45 ... eDVBFrontendParametersSatellite::FEC_26_45_L:
+ parm_u_qpsk_fec_inner = (fe_code_rate_t)((int)FEC_S2_QPSK_13_45 + (feparm.fec-eDVBFrontendParametersSatellite::FEC_13_45));
+ break;
+ default:
+ eDebugNoSimulate("no valid fec for DVB-S2X set.. abort !!");
+ return -EINVAL;
+ }
+ }
// FIXME !!! get frequency range from tuner
if ( parm_frequency < 900000 || parm_frequency > 2200000 )
{
if (type == eDVBFrontend::feSatellite)
{
eDVBFrontendParametersSatellite sat_parm;
- bool can_handle_dvbs, can_handle_dvbs2;
+ bool can_handle_dvbs, can_handle_dvbs2, can_handle_dvbs2x;
can_handle_dvbs = supportsDeliverySystem(SYS_DVBS, true);
can_handle_dvbs2 = supportsDeliverySystem(SYS_DVBS2, true);
+ can_handle_dvbs2x = supportsDeliverySystem(SYS_DVBS2X, true);
if (feparm->getDVBS(sat_parm) < 0)
{
return 0;
}
+ if (sat_parm.system == eDVBFrontendParametersSatellite::System_DVB_S2X && !can_handle_dvbs2x)
+ {
+ return 0;
+ }
if (sat_parm.system == eDVBFrontendParametersSatellite::System_DVB_S2 && !can_handle_dvbs2)
{
return 0;
{
return 0;
}
+ bool multistream = (static_cast<unsigned int>(sat_parm.is_id) != NO_STREAM_ID_FILTER || (sat_parm.pls_code & 0x3FFFF) != 0 ||
+ (sat_parm.pls_mode & 3) != eDVBFrontendParametersSatellite::PLS_Unknown);
+
+ if (((sat_parm.system == eDVBFrontendParametersSatellite::System_DVB_S2)||(sat_parm.system == eDVBFrontendParametersSatellite::System_DVB_S2X)) && multistream && !is_multistream())
+ {
+ return 0;
+ }
score = m_sec ? m_sec->canTune(sat_parm, this, 1 << m_slotid) : 0;
if (score > 1 && sat_parm.system == eDVBFrontendParametersSatellite::System_DVB_S && can_handle_dvbs2)
{
/* prefer to use a S tuner, try to keep S2 free for S2 transponders */
score--;
}
+ if (score > 1 && sat_parm.system == eDVBFrontendParametersSatellite::System_DVB_S2 && can_handle_dvbs2x)
+ {
+ /* prefer to use a S2 tuner, try to keep S2X free for S2X transponders */
+ score--;
+ }
+ if (score > 1 && is_multistream() && !multistream)
+ {
+ /* prefer to use a non multistream tuner, try to keep multistream tuners free for multistream transponders */
+ score--;
+ }
}
else if (type == eDVBFrontend::feCable)
bool eDVBFrontend::setSlotInfo(ePyObject obj)
{
- ePyObject Id, Descr, Enabled, IsDVBS2, IsDVBT2, frontendId;
- if (!PyTuple_Check(obj) || PyTuple_Size(obj) != 6)
+ ePyObject Id, Descr, Enabled, IsDVBS2, IsDVBT2, IsDVBS2X, frontendId;
+ if (!PyTuple_Check(obj) || PyTuple_Size(obj) != 7)
goto arg_error;
Id = PyTuple_GET_ITEM(obj, 0);
Descr = PyTuple_GET_ITEM(obj, 1);
Enabled = PyTuple_GET_ITEM(obj, 2);
IsDVBS2 = PyTuple_GET_ITEM(obj, 3);
IsDVBT2 = PyTuple_GET_ITEM(obj, 4);
- frontendId = PyTuple_GET_ITEM(obj, 5);
+ IsDVBS2X = PyTuple_GET_ITEM(obj, 5);
+ frontendId = PyTuple_GET_ITEM(obj, 6);
m_slotid = PyInt_AsLong(Id);
- if (!PyInt_Check(Id) || !PyString_Check(Descr) || !PyBool_Check(Enabled) || !PyBool_Check(IsDVBS2) || !PyBool_Check(IsDVBT2) || !PyInt_Check(frontendId))
+ if (!PyInt_Check(Id) || !PyString_Check(Descr) || !PyBool_Check(Enabled) || !PyBool_Check(IsDVBS2) || !PyBool_Check(IsDVBT2) || !PyBool_Check(IsDVBS2X) || !PyInt_Check(frontendId))
goto arg_error;
strcpy(m_description, PyString_AS_STRING(Descr));
if (PyInt_AsLong(frontendId) == -1 || PyInt_AsLong(frontendId) != m_dvbid) {
/* HACK for legacy dvb api without DELSYS support */
m_delsys[SYS_DVBT2] = true;
}
+ if (IsDVBS2X == Py_True)
+ {
+ /* HACK for legacy dvb api without DELSYS support */
+ m_delsys[SYS_DVBS2X] = true;
+ }
- eDebugNoSimulate("setSlotInfo for dvb frontend %d to slotid %d, descr %s, need rotorworkaround %s, enabled %s, DVB-S2 %s, DVB-T2 %s",
- m_dvbid, m_slotid, m_description, m_need_rotor_workaround ? "Yes" : "No", Enabled == Py_True ? "Yes" : "No", IsDVBS2 == Py_True ? "Yes" : "No", IsDVBT2 == Py_True ? "Yes" : "No" );
+ eDebugNoSimulate("setSlotInfo for dvb frontend %d to slotid %d, descr %s, need rotorworkaround %s, enabled %s, DVB-S2 %s, DVB-T2 %s, DVB-S2X %s",
+ m_dvbid, m_slotid, m_description, m_need_rotor_workaround ? "Yes" : "No", Enabled == Py_True ? "Yes" : "No", IsDVBS2 == Py_True ? "Yes" : "No", IsDVBT2 == Py_True ? "Yes" : "No", IsDVBS2X == Py_True ? "Yes" : "No");
return true;
arg_error:
PyErr_SetString(PyExc_StandardError,
"eDVBFrontend::setSlotInfo must get a tuple with first param slotid, second param slot description and third param enabled boolean");
return false;
}
+
+bool eDVBFrontend::is_multistream()
+{
+ return fe_info.caps & FE_CAN_MULTISTREAM;
+}
+
std::map<fe_delivery_system_t, bool> m_delsys, m_delsys_whitelist;
char m_filename[128];
char m_description[128];
+ dvb_frontend_info fe_info;
FRONTENDPARAMETERS parm;
eDVBFrontendParameters oparm;
bool isLoopTimerActive() { return m_tuneTimer->isActive(); }
bool isScheduledSendDiseqc();
void setUSBTuner(bool yesno) { m_is_usbtuner = yesno; }
+ bool is_multistream();
};
#endif // SWIG
};
enum {
- FEC_Auto, FEC_1_2, FEC_2_3, FEC_3_4, FEC_5_6, FEC_7_8, FEC_8_9, FEC_3_5, FEC_4_5, FEC_9_10, FEC_None=15
+ FEC_Auto=0, FEC_1_2=1, FEC_2_3=2, FEC_3_4=3, FEC_5_6=4, FEC_7_8=5, FEC_8_9=6, FEC_3_5=7, FEC_4_5=8, FEC_9_10=9, FEC_None=15,
+ FEC_13_45=16, FEC_9_20=17, FEC_11_20=18, FEC_23_36=19, FEC_25_36=20,
+ FEC_13_18=21, FEC_26_45=22, FEC_28_45=23, FEC_7_9=24, FEC_77_90=25,
+ FEC_32_45=26, FEC_11_15=27, FEC_1_2_L=28, FEC_8_15_L=29, FEC_3_5_L=30,
+ FEC_2_3_L=31, FEC_5_9_L=32, FEC_26_45_L=33
};
enum {
- System_DVB_S, System_DVB_S2
+ System_DVB_S, System_DVB_S2, System_DVB_S2X
};
enum {
- Modulation_Auto, Modulation_QPSK, Modulation_8PSK, Modulation_QAM16
+ Modulation_Auto, Modulation_QPSK, Modulation_8PSK, Modulation_QAM16, Modulation_16APSK, Modulation_32APSK, Modulation_8APSK
};
// dvb-s2
Pilot_Off, Pilot_On, Pilot_Unknown
};
+ enum {
+ PLS_Root, PLS_Gold, PLS_Combo, PLS_Unknown
+ };
+
bool no_rotor_command_on_tune;
unsigned int frequency, symbol_rate;
- int polarisation, fec, inversion, orbital_position, system, modulation, rolloff, pilot;
+ int polarisation, fec, inversion, orbital_position, system, modulation, rolloff, pilot, is_id, pls_mode, pls_code;
};
SWIG_ALLOW_OUTPUT_SIMPLE(eDVBFrontendParametersSatellite);
{
case iDVBFrontend::feSatellite:
{
+ char system_name[255];
+ char modulation_name[255];
+ memset(system_name, 0, sizeof(system_name));
+ memset(modulation_name, 0, sizeof(modulation_name));
+
eDVBFrontendParametersSatellite parm;
m_ch_current->getDVBS(parm);
+
+ if (parm.system == eDVBFrontendParametersSatellite::System_DVB_S2)
+ strcpy(system_name, "DVB-S2");
+ else if (parm.system == eDVBFrontendParametersSatellite::System_DVB_S2X)
+ strcpy(system_name, "DVB-S2X");
+ else
+ strcpy(system_name, "DVB-S");
+
+ if (parm.modulation == eDVBFrontendParametersSatellite::Modulation_QPSK)
+ strcpy(modulation_name, "QPSK");
+ else if (parm.modulation == eDVBFrontendParametersSatellite::Modulation_8PSK)
+ strcpy(modulation_name, "8PSK");
+ else if (parm.modulation == eDVBFrontendParametersSatellite::Modulation_8APSK)
+ strcpy(modulation_name, "8APSK");
+ else if (parm.modulation == eDVBFrontendParametersSatellite::Modulation_16APSK)
+ strcpy(modulation_name, "16APSK");
+ else if (parm.modulation == eDVBFrontendParametersSatellite::Modulation_32APSK)
+ strcpy(modulation_name, "32APSK");
+ else
+ strcpy(modulation_name, "8PSK");
+
snprintf(sname, 255, "%d%c SID 0x%02x",
parm.frequency/1000,
parm.polarisation ? 'V' : 'H',
m_pmt_in_progress->first);
snprintf(pname, 255, "%s %s %d%c %d.%d°%c",
- parm.system ? "DVB-S2" : "DVB-S",
- parm.modulation == 1 ? "QPSK" : "8PSK",
+ system_name,
+ modulation_name,
parm.frequency/1000,
parm.polarisation ? 'V' : 'H',
parm.orbital_position/10,
for slot in nim_slots:
if slot.type is not None:
- used_nim_slots.append((slot.slot, slot.description, slot.config.configMode.value != "nothing" and True or False, slot.isCompatible("DVB-S2"), slot.isCompatible("DVB-T2"), slot.frontend_id is None and -1 or slot.frontend_id))
+ used_nim_slots.append((slot.slot, slot.description, slot.config.configMode.value != "nothing" and True or False, slot.isCompatible("DVB-S2"), slot.isCompatible("DVB-T2"), slot.isCompatible("DVB-S2X"), slot.frontend_id is None and -1 or slot.frontend_id))
eDVBResourceManager.getInstance().setFrontendSlotInformations(used_nim_slots)
for slot in nim_slots:
def __init__(self, slot, type, description, has_outputs = True, internally_connectable = None, multi_type = {}, frontend_id = None, i2c = None, is_empty = False):
self.slot = slot
- if type not in ("DVB-S", "DVB-C", "DVB-T", "DVB-S2", "DVB-T2", None):
+ if type not in ("DVB-S", "DVB-C", "DVB-T", "DVB-S2", "DVB-T2", "DVB-S2X", None):
print "warning: unknown NIM type %s, not using." % type
type = None
"DVB-C": ("DVB-C", None),
"DVB-T": ("DVB-T", None),
"DVB-S2": ("DVB-S", "DVB-S2", None),
- "DVB-T2": ("DVB-T", "DVB-T2", None)
+ "DVB-T2": ("DVB-T", "DVB-T2", None),
+ "DVB-S2X": ("DVB-S", "DVB-S2", "DVB-S2X", None),
}
def getType(self):
"DVB-C": ("DVB-C",),
"DVB-T": ("DVB-T",),
"DVB-S2": ("DVB-S", "DVB-S2"),
- "DVB-T2": ("DVB-T", "DVB-T2",)
+ "DVB-T2": ("DVB-T", "DVB-T2",),
+ "DVB-S2X": ("DVB-S", "DVB-S2", "DVB-S2X"),
}
return connectable[self.getType()]
# empty tuners are supported!
def isSupported(self):
return (self.frontend_id is not None) or self.__is_empty
-
+
+ def isMultistream(self):
+ multistream = self.frontend_id is not None and eDVBResourceManager.getInstance().frontendIsMultistream(self.frontend_id) or False
+ # HACK due to poor support for VTUNER_SET_FE_INFO
+ # When vtuner does not accept fe_info we have to fallback to detection using tuner name
+ # More tuner names will be added when confirmed as multistream (FE_CAN_MULTISTREAM)
+ if not multistream and "TBS" in self.description:
+ multistream = True
+ return multistream
+
# returns dict {<slotid>: <type>}
def getMultiTypeList(self):
return self.multi_type
"DVB-C": "DVB-C",
"DVB-S2": "DVB-S2",
"DVB-T2": "DVB-T2",
+ "DVB-S2X": "DVB-S2X",
None: _("empty")
}[self.getType()]
# get MultiType from DTV_ENUM_DELSYS
if entry["frontend_device"] is not None:
- types = [type for type in ["DVB-C", "DVB-T2", "DVB-T", "DVB-S2", "DVB-S", "ATSC"] if eDVBResourceManager.getInstance().frontendIsCompatible(entry["frontend_device"], type)]
+ types = [type for type in ["DVB-C", "DVB-T2", "DVB-T", "DVB-S2", "DVB-S", "ATSC", "DVB-S2X"] if eDVBResourceManager.getInstance().frontendIsCompatible(entry["frontend_device"], type)]
if "DVB-T2" in types and "DVB-T" in types:
# DVB-T2 implies DVB-T support
types.remove("DVB-T")
if "DVB-S2" in types and "DVB-S" in types:
# DVB-S2 implies DVB-S support
types.remove("DVB-S")
+ if "DVB-S2X" in types:
+ if "DVB-S" in types:
+ # DVB-S2X implies DVB-S support
+ types.remove("DVB-S")
+ if "DVB-S2" in types:
+ # DVB-S2X implies DVB-S2 support
+ types.remove("DVB-S2")
if len(types) > 1:
entry["multi_type"] = {}
for type in types:
list.append(x.slot)
return list
+ def isSupportMultistream(self, slotid):
+ return self.getNim(slotid).isMultistream()
+
def __init__(self):
self.satList = [ ]
self.cablesList = []
type = "DVB-S"
elif type == "DVB-T2":
type = "DVB-T"
+ elif type == "DVB-S2X":
+ type = "DVB-S"
nimList = self.getNimListOfType(type, slotid)
for nim in nimList[:]:
mode = self.getNimConfig(nim)
type = "DVB-S"
elif type == "DVB-T2":
type = "DVB-T"
+ elif type == "DVB-S2X":
+ type = "DVB-S"
nimList = self.getNimListOfType(type, slotid)
positionerList = []
for nim in nimList[:]:
else:
network = ("%s %d.%d %s") % (sat_name, orb_pos / 10, orb_pos % 10, h)
tp_text = ("%s %s %d%c / %d / %s") %( { tp.System_DVB_S : "DVB-S",
- tp.System_DVB_S2 : "DVB-S2" }.get(tp.system, tp.System_DVB_S),
+ tp.System_DVB_S2 : "DVB-S2" , tp.System_DVB_S2X : "DVB-S2X"}.get(tp.system, tp.System_DVB_S),
{ tp.Modulation_Auto : "Auto", tp.Modulation_QPSK : "QPSK",
- tp.Modulation_8PSK : "8PSK", tp.Modulation_QAM16 : "QAM16" }.get(tp.modulation, tp.Modulation_QPSK),
+ tp.Modulation_8PSK : "8PSK", tp.Modulation_QAM16 : "QAM16",
+ tp.Modulation_8APSK : "8APSK", tp.Modulation_16APSK : "16APSK",
+ tp.Modulation_32APSK : "32APSK"}.get(tp.modulation, tp.Modulation_QPSK),
tp.frequency/1000,
{ tp.Polarisation_Horizontal : 'H', tp.Polarisation_Vertical : 'V', tp.Polarisation_CircularLeft : 'L',
tp.Polarisation_CircularRight : 'R' }.get(tp.polarisation, tp.Polarisation_Horizontal),
{ tp.FEC_Auto : "AUTO", tp.FEC_1_2 : "1/2", tp.FEC_2_3 : "2/3",
tp.FEC_3_4 : "3/4", tp.FEC_5_6 : "5/6", tp.FEC_7_8 : "7/8",
tp.FEC_8_9 : "8/9", tp.FEC_3_5 : "3/5", tp.FEC_4_5 : "4/5",
- tp.FEC_9_10 : "9/10", tp.FEC_None : "NONE" }.get(tp.fec, tp.FEC_Auto))
+ tp.FEC_9_10 : "9/10", tp.FEC_None : "NONE",
+ tp.FEC_13_45 : "13/45", tp.FEC_9_20 : "9/20", tp.FEC_11_20 : "11/20", tp.FEC_23_36 : "23/36", tp.FEC_25_36 : "25/36",
+ tp.FEC_13_18 : "13/18", tp.FEC_26_45 : "26/45", tp.FEC_28_45 : "28/45", tp.FEC_7_9 : "7/9", tp.FEC_77_90 : "77/90",
+ tp.FEC_32_45 : "32/45", tp.FEC_11_15 : "11/15", tp.FEC_1_2_L : "1/2-L", tp.FEC_8_15_L : "8/15-L", tp.FEC_3_5_L : "3/5-L",
+ tp.FEC_2_3_L : "2/3-L", tp.FEC_5_9_L : "5/9-L", tp.FEC_26_45_L : "26/45-L"}.get(tp.fec, tp.FEC_Auto))
+ if tp.is_id > -1 and tp.system in (tp.System_DVB_S2, tp.System_DVB_S2X):
+ tp_text = ("%s IS %d") % (tp_text, tp.is_id)
elif tp_type == iDVBFrontend.feCable:
network = _("Cable")
tp = transponder.getDVBC()
self.frontend = frontend
self.ignore_rotor = ignore_rotor
- # transponder = (frequency, symbolrate, polarisation, fec, inversion, orbpos, system, modulation, rolloff, pilot, tsid, onid)
- # 0 1 2 3 4 5 6 7 8 9 10 11
+ # transponder = (0:frequency 1:symbolrate 2:polarisation 3:fec 4:inversion 5:orbpos 6:system 7:modulation 8:rolloff 9:pilot 10:is_id 11:pls_mode 12:pls_code 13:tsid 14:onid)
def tune(self, transponder):
if self.frontend:
print "tuning to transponder with data", transponder
parm.modulation = transponder[7]
parm.rolloff = transponder[8]
parm.pilot = transponder[9]
+ if len(transponder) > 12:
+ parm.is_id = transponder[10]
+ parm.pls_mode = transponder[11]
+ parm.pls_code = transponder[12]
+ else:
+ parm.is_id = -1
+ parm.pls_mode = eDVBFrontendParametersSatellite.PLS_Unknown
+ parm.pls_code = 0
feparm = eDVBFrontendParameters()
feparm.setDVBS(parm, self.ignore_rotor)
self.lastparm = feparm
pidsFailed = False
if self.checkPIDs:
if self.currTuned is not None:
- if self.tsid != self.currTuned[10] or self.onid != self.currTuned[11]:
- self.failedTune.append([self.currTuned, self.oldTuned, "pids_failed", {"real": (self.tsid, self.onid), "expected": (self.currTuned[10], self.currTuned[11])}, dict]) # last parameter is the frontend status
+ if self.tsid != self.currTuned[13] or self.onid != self.currTuned[14]:
+ self.failedTune.append([self.currTuned, self.oldTuned, "pids_failed", {"real": (self.tsid, self.onid), "expected": (self.currTuned[13], self.currTuned[14])}, dict]) # last parameter is the frontend status
pidsFailed = True
else:
self.successfullyTune.append([self.currTuned, self.oldTuned, dict]) # 3rd parameter is the frontend status
# check for tsid != -1 and onid != -1
print "index:", index
print "len(self.transponderlist):", len(self.transponderlist)
- while (index < len(self.transponderlist) and (self.transponderlist[index][10] == -1 or self.transponderlist[index][11] == -1)):
+ while (index < len(self.transponderlist) and (self.transponderlist[index][13] == -1 or self.transponderlist[index][14] == -1)):
index += 1
print "FirstTransponder final index:", index
return index
# check for tsid != -1 and onid != -1
print "index:", index
print "len(self.transponderlist):", len(self.transponderlist)
- while (index < len(self.transponderlist) and (self.transponderlist[index][10] == -1 or self.transponderlist[index][11] == -1)):
+ while (index < len(self.transponderlist) and (self.transponderlist[index][13] == -1 or self.transponderlist[index][14] == -1)):
index += 1
print "next transponder index:", index
self.progressCallback((self.getProgressLength(), self.tuningtransponder, self.STATUS_START, self.currTuned))
self.timer.start(100, True)
- # transponder = (frequency, symbolrate, polarisation, fec, inversion, orbpos, <system>, <modulation>, <rolloff>, <pilot>, <tsid>, <onid>)
- # 0 1 2 3 4 5 6 7 8 9 10 11
+ # transponder = (0:frequency 1:symbolrate 2:polarisation 3:fec 4:inversion 5:orbpos 6:system 7:modulation 8:rolloff 9:pilot 10:is_id 11:pls_mode 12:pls_code 13:tsid 14:onid)
def addTransponder(self, transponder):
self.transponderlist.append(transponder)
defaultSat["inversion"] = frontendData.get("inversion", eDVBFrontendParametersSatellite.Inversion_Unknown)
defaultSat["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000
defaultSat["polarization"] = frontendData.get("polarization", eDVBFrontendParametersSatellite.Polarisation_Horizontal)
- if defaultSat["system"] == eDVBFrontendParametersSatellite.System_DVB_S2:
+ if defaultSat["system"] in (eDVBFrontendParametersSatellite.System_DVB_S2, eDVBFrontendParametersSatellite.System_DVB_S2X):
defaultSat["fec_s2"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)
defaultSat["rolloff"] = frontendData.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35)
defaultSat["pilot"] = frontendData.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown)
print "cur is", cur
if cur == self.tunerEntry or \
cur == self.systemEntry or \
- (self.modulationEntry and self.systemEntry[1].value == eDVBFrontendParametersSatellite.System_DVB_S2 and cur == self.modulationEntry):
+ (self.modulationEntry and (self.systemEntry[1].value in (eDVBFrontendParametersSatellite.System_DVB_S2, eDVBFrontendParametersSatellite.System_DVB_S2X)) and cur == self.modulationEntry):
self.createSetup()
def checkSettings(self):
if data[0] == 'OK':
parm = eDVBFrontendParametersSatellite()
sys = { "DVB-S" : eDVBFrontendParametersSatellite.System_DVB_S,
- "DVB-S2" : eDVBFrontendParametersSatellite.System_DVB_S2}
+ "DVB-S2" : eDVBFrontendParametersSatellite.System_DVB_S2,
+ "DVB-S2X" : eDVBFrontendParametersSatellite.System_DVB_S2X}
qam = { "QPSK" : parm.Modulation_QPSK,
"8PSK" : parm.Modulation_8PSK}
inv = { "INVERSION_OFF" : parm.Inversion_Off,
"FEC_8_9" : parm.FEC_8_9,
"FEC_3_5" : parm.FEC_3_5,
"FEC_9_10" : parm.FEC_9_10,
- "FEC_NONE" : parm.FEC_None}
+ "FEC_NONE" : parm.FEC_None,
+ "FEC_13_45" : parm.FEC_13_45, "FEC_9_20" : parm.FEC_9_20, "FEC_11_20" : parm.FEC_11_20, "FEC_23_36" : parm.FEC_23_36, "FEC_25_36" : parm.FEC_25_36,
+ "FEC_13_18" : parm.FEC_13_18, "FEC_26_45" : parm.FEC_26_45, "FEC_28_45" : parm.FEC_28_45, "FEC_7_9" : parm.FEC_7_9, "FEC_77_90" : parm.FEC_77_90,
+ "FEC_32_45" : parm.FEC_32_45, "FEC_11_15" : parm.FEC_11_15, "FEC_1_2_L" : parm.FEC_1_2_L, "FEC_8_15_L" : parm.FEC_8_15_L, "FEC_3_5_L" : parm.FEC_3_5_L,
+ "FEC_2_3_L" : parm.FEC_2_3_L, "FEC_5_9_L" : parm.FEC_5_9_L, "FEC_26_45_L" : parm.FEC_26_45_L}
roll ={ "ROLLOFF_20" : parm.RollOff_alpha_0_20,
"ROLLOFF_25" : parm.RollOff_alpha_0_25,
"ROLLOFF_35" : parm.RollOff_alpha_0_35}
parm.fec = fec[data[7]]
parm.modulation = qam[data[8]]
parm.rolloff = roll[data[9]]
+ parm.is_id = -1
+ parm.pls_mode = eDVBFrontendParametersSatellite.PLS_Unknown
+ parm.pls_code = 0
self.tmp_tplist.append(parm)
except: pass
self.blindscan_session.close(True)
for sat in nimmanager.getSatListForNim(self.feid):
for transponder in nimmanager.getTransponders(sat[0]):
#print transponder
- mytransponder = (transponder[1] / 1000, transponder[2] / 1000, transponder[3], transponder[4], transponder[7], sat[0], transponder[5], transponder[6], transponder[8], transponder[9], transponder[10], transponder[11])
+ mytransponder = (transponder[1] / 1000, transponder[2] / 1000, transponder[3], transponder[4], transponder[7], sat[0], transponder[5], transponder[6], transponder[8], transponder[9], transponder[10], transponder[11], transponder[12], transponder[13], transponder[14])
self.analyseTransponder(mytransponder)
def getIndexForTransponder(self, transponder):
from Components.Label import Label
from Components.ConfigList import ConfigList
from Components.TunerInfo import TunerInfo
-from Components.ActionMap import ActionMap
+from Components.ActionMap import NumberActionMap, ActionMap
from Components.NimManager import nimmanager
from Components.MenuList import MenuList
from Components.config import ConfigSatlist, ConfigNothing, ConfigSelection, ConfigSubsection, KEY_LEFT, KEY_RIGHT, getConfigListEntry
from Components.TuneTest import Tuner
+from Components.ConfigList import ConfigListScreen
+from Components.config import config, ConfigSubsection, ConfigSelection, ConfigInteger, getConfigListEntry
from Tools.Transponder import ConvertToHumanReadable
from time import sleep
cur.get("system", eDVBFrontendParametersSatellite.System_DVB_S),
cur.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK),
cur.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35),
- cur.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown))
+ cur.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown),
+ cur.get("is_id", -1),
+ cur.get("pls_mode", eDVBFrontendParametersSatellite.PLS_Unknown),
+ cur.get("pls_code", 0))
self.tuner.tune(tp)
self.createConfig()
sleep(0.05)
self.frontend.sendDiseqc(cmd) # send 2nd time
-tuning = None
-
-class TunerScreen(ScanSetup):
+class TunerScreen(ConfigListScreen, Screen):
skin = """
<screen position="90,100" size="520,400" title="Tune">
<widget name="config" position="20,10" size="460,350" scrollbarMode="showOnDemand" />
def __init__(self, session, feid, fe_data):
self.feid = feid
self.fe_data = fe_data
- ScanSetup.__init__(self, session)
- self["introduction"].setText("")
+ Screen.__init__(self, session)
+ ConfigListScreen.__init__(self, None)
+ self.createConfig(fe_data)
+ self.createSetup()
+ self.tuning.sat.addNotifier(self.tuningSatChanged)
+ self.tuning.type.addNotifier(self.tuningTypeChanged)
+ self.scan_sat.system.addNotifier(self.systemChanged)
+ self.scan_sat.system_dvbs2x.addNotifier(self.systemChanged)
+ self.scan_sat.is_id_bool.addNotifier(self.isIdChanged, initial_call = False)
+ self.scan_sat.pls_mode.addNotifier(self.plsModeChanged, initial_call = False)
+
+ self["actions"] = NumberActionMap(["SetupActions"],
+ {
+ "ok": self.keyGo,
+ "cancel": self.keyCancel,
+ }, -2)
+
+ self["introduction"] = Label(_(" "))
def createSetup(self):
- self.typeOfTuningEntry = None
- self.satEntry = None
self.list = []
- self.typeOfTuningEntry = getConfigListEntry(_('Tune'), tuning.type)
- self.list.append(self.typeOfTuningEntry)
- self.satEntry = getConfigListEntry(_('Satellite'), tuning.sat)
- self.list.append(self.satEntry)
+ self.list.append(getConfigListEntry(_('Tune'), self.tuning.type) )
+ self.list.append(getConfigListEntry(_('Satellite'), self.tuning.sat) )
+
+ self.is_id_boolEntry = None
+ self.plsModeEntry = None
nim = nimmanager.nim_slots[self.feid]
- self.systemEntry = None
-
- if tuning.type.value == "manual_transponder":
- if nim.isCompatible("DVB-S2"):
- self.systemEntry = getConfigListEntry(_('System'), self.scan_sat.system)
- self.list.append(self.systemEntry)
+ if self.tuning.type.value == "manual_transponder":
+ scan_sat_system_value = self.scan_sat.system.value
+ if nim.isCompatible("DVB-S2X"):
+ scan_sat_system_value = self.scan_sat.system_dvbs2x.value
+ self.list.append(getConfigListEntry(_('System'), self.scan_sat.system_dvbs2x))
+ elif nim.isCompatible("DVB-S2"):
+ self.list.append(getConfigListEntry(_('System'), self.scan_sat.system))
else:
# downgrade to dvb-s, in case a -s2 config was active
self.scan_sat.system.value = eDVBFrontendParametersSatellite.System_DVB_S
self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion))
self.list.append(getConfigListEntry(_('Symbol rate'), self.scan_sat.symbolrate))
self.list.append(getConfigListEntry(_('Polarization'), self.scan_sat.polarization))
- if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S:
+ if scan_sat_system_value == eDVBFrontendParametersSatellite.System_DVB_S:
self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec))
- elif self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2:
+ elif scan_sat_system_value == eDVBFrontendParametersSatellite.System_DVB_S2:
self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2))
self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation)
self.list.append(self.modulationEntry)
self.list.append(getConfigListEntry(_('Roll-off'), self.scan_sat.rolloff))
self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot))
- elif tuning.type.value == "predefined_transponder":
- self.list.append(getConfigListEntry(_("Transponder"), tuning.transponder))
+ elif scan_sat_system_value == eDVBFrontendParametersSatellite.System_DVB_S2X:
+ if self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_QPSK:
+ self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_qpsk))
+ elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_8PSK:
+ self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_8psk))
+ elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_8APSK:
+ self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_8apsk))
+ elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_16APSK:
+ self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_16apsk))
+ elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_32APSK:
+ self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_32apsk))
+ self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation_dvbs2x)
+ self.list.append(self.modulationEntry)
+ self.list.append(getConfigListEntry(_('Roll-off'), self.scan_sat.rolloff))
+ self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot))
+ if scan_sat_system_value in (eDVBFrontendParametersSatellite.System_DVB_S2, eDVBFrontendParametersSatellite.System_DVB_S2X):
+ if nim.isMultistream():
+ self.is_id_boolEntry = getConfigListEntry(_('Transport Stream Type'), self.scan_sat.is_id_bool)
+ self.list.append(self.is_id_boolEntry)
+ if self.scan_sat.is_id_bool.value:
+ self.list.append(getConfigListEntry(_('Input Stream ID'), self.scan_sat.is_id))
+ self.plsModeEntry = getConfigListEntry(_('PLS Mode'), self.scan_sat.pls_mode)
+ self.list.append(self.plsModeEntry)
+ if self.scan_sat.pls_mode.value != eDVBFrontendParametersSatellite.PLS_Unknown:
+ self.list.append(getConfigListEntry(_('PLS Code'), self.scan_sat.pls_code))
+ elif self.tuning.type.value == "predefined_transponder":
+ self.list.append(getConfigListEntry(_("Transponder"), self.tuning.transponder))
self["config"].list = self.list
self["config"].l.setList(self.list)
- def newConfig(self):
- if self["config"].getCurrent() in (self.typeOfTuningEntry, self.satEntry, self.systemEntry):
- self.createSetup()
-
- def createConfig(self, foo):
- global tuning
- if not tuning:
- tuning = ConfigSubsection()
- tuning.type = ConfigSelection(
- default = "manual_transponder",
- choices = { "manual_transponder" : _("Manual transponder"),
- "predefined_transponder" : _("Predefined transponder") } )
- tuning.sat = ConfigSatlist(list=nimmanager.getRotorSatListForNim(self.feid))
- tuning.sat.addNotifier(self.tuningSatChanged)
- self.updateTransponders()
+ def createConfig(self, frontendData):
+ satlist = nimmanager.getRotorSatListForNim(self.feid)
orb_pos = self.fe_data.get("orbital_position", None)
+ self.tuning = ConfigSubsection()
+ self.tuning.type = ConfigSelection(
+ default = "manual_transponder",
+ choices = { "manual_transponder" : _("Manual transponder"),
+ "predefined_transponder" : _("Predefined transponder") } )
+ self.tuning.sat = ConfigSatlist(list = satlist)
if orb_pos is not None:
- for x in nimmanager.getRotorSatListForNim(self.feid):
+ for x in satlist:
opos = str(orb_pos)
- if x[0] == orb_pos and tuning.sat.value != opos:
- tuning.sat.value = opos
+ if x[0] == orb_pos and self.tuning.sat.value != opos:
+ self.tuning.sat.value = opos
del self.fe_data["orbital_position"]
- ScanSetup.createConfig(self, self.fe_data)
+
+ self.updateTransponders()
+
+ defaultSat = {
+ "orbpos": 192,
+ "system": eDVBFrontendParametersSatellite.System_DVB_S,
+ "frequency": 11836,
+ "inversion": eDVBFrontendParametersSatellite.Inversion_Unknown,
+ "symbolrate": 27500,
+ "polarization": eDVBFrontendParametersSatellite.Polarisation_Horizontal,
+ "fec": eDVBFrontendParametersSatellite.FEC_Auto,
+ "fec_s2": eDVBFrontendParametersSatellite.FEC_9_10,
+ "fec_s2x_qpsk": eDVBFrontendParametersSatellite.FEC_13_45,
+ "fec_s2x_8psk": eDVBFrontendParametersSatellite.FEC_23_36,
+ "fec_s2x_8apsk": eDVBFrontendParametersSatellite.FEC_5_9_L,
+ "fec_s2x_16apsk": eDVBFrontendParametersSatellite.FEC_1_2_L,
+ "fec_s2x_32apsk": eDVBFrontendParametersSatellite.FEC_2_3_L,
+ "modulation": eDVBFrontendParametersSatellite.Modulation_QPSK,
+ "modulation_s2x": eDVBFrontendParametersSatellite.Modulation_QPSK,
+ "is_id": -1,
+ "pls_mode": eDVBFrontendParametersSatellite.PLS_Unknown,
+ "pls_code": 0 }
+
+ if frontendData is not None:
+ ttype = frontendData.get("tuner_type", "UNKNOWN")
+ defaultSat["system"] = frontendData.get("system", eDVBFrontendParametersSatellite.System_DVB_S)
+ defaultSat["frequency"] = frontendData.get("frequency", 0) / 1000
+ defaultSat["inversion"] = frontendData.get("inversion", eDVBFrontendParametersSatellite.Inversion_Unknown)
+ defaultSat["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000
+ defaultSat["polarization"] = frontendData.get("polarization", eDVBFrontendParametersSatellite.Polarisation_Horizontal)
+ defaultSat["orbpos"] = frontendData.get("orbital_position", 0)
+
+ defaultSat["modulation"] = frontendData.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK)
+ defaultSat["modulation_s2x"] = frontendData.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK)
+
+ if defaultSat["modulation"] > eDVBFrontendParametersSatellite.Modulation_8PSK:
+ defaultSat["modulation"] = eDVBFrontendParametersSatellite.Modulation_8PSK
+
+ if defaultSat["system"] == eDVBFrontendParametersSatellite.System_DVB_S2:
+ defaultSat["fec_s2"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)
+ elif defaultSat["system"] == eDVBFrontendParametersSatellite.System_DVB_S2X:
+ if defaultSat["modulation_s2x"] == eDVBFrontendParametersSatellite.Modulation_QPSK:
+ defaultSat["fec_s2x_qpsk"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_13_45)
+ elif defaultSat["modulation_s2x"] == eDVBFrontendParametersSatellite.Modulation_8PSK:
+ defaultSat["fec_s2x_8psk"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_23_36)
+ elif defaultSat["modulation_s2x"] == eDVBFrontendParametersSatellite.Modulation_8APSK:
+ defaultSat["fec_s2x_8apsk"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_5_9_L)
+ elif defaultSat["modulation_s2x"] == eDVBFrontendParametersSatellite.Modulation_16APSK:
+ defaultSat["fec_s2x_16apsk"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_1_2_L)
+ elif defaultSat["modulation_s2x"] == eDVBFrontendParametersSatellite.Modulation_32APSK:
+ defaultSat["fec_s2x_32apsk"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_2_3_L)
+ else:
+ defaultSat["fec"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)
+
+ if defaultSat["system"] in (eDVBFrontendParametersSatellite.System_DVB_S2, eDVBFrontendParametersSatellite.System_DVB_S2X):
+ defaultSat["rolloff"] = frontendData.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35)
+ defaultSat["pilot"] = frontendData.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown)
+ defaultSat["is_id"] = frontendData.get("is_id", defaultSat["is_id"])
+ defaultSat["pls_mode"] = frontendData.get("pls_mode", defaultSat["pls_mode"])
+ defaultSat["pls_code"] = frontendData.get("pls_code", defaultSat["pls_code"])
+
+ self.scan_sat = ConfigSubsection()
+
+ sat_choices = [
+ (eDVBFrontendParametersSatellite.System_DVB_S, _("DVB-S")),
+ (eDVBFrontendParametersSatellite.System_DVB_S2, _("DVB-S2"))]
+
+ sat_choices_dvbs2x = [
+ (eDVBFrontendParametersSatellite.System_DVB_S, _("DVB-S")),
+ (eDVBFrontendParametersSatellite.System_DVB_S2, _("DVB-S2")),
+ (eDVBFrontendParametersSatellite.System_DVB_S2X, _("DVB-S2X"))]
+
+ self.scan_sat.system = ConfigSelection(default = defaultSat["system"], choices = sat_choices)
+ self.scan_sat.system_dvbs2x = ConfigSelection(default = defaultSat["system"], choices = sat_choices_dvbs2x)
+ self.scan_sat.frequency = ConfigInteger(default = defaultSat["frequency"], limits = (1, 99999))
+ self.scan_sat.inversion = ConfigSelection(default = defaultSat["inversion"], choices = [
+ (eDVBFrontendParametersSatellite.Inversion_Off, _("Off")),
+ (eDVBFrontendParametersSatellite.Inversion_On, _("On")),
+ (eDVBFrontendParametersSatellite.Inversion_Unknown, _("Auto"))])
+ self.scan_sat.symbolrate = ConfigInteger(default = defaultSat["symbolrate"], limits = (1, 99999))
+ self.scan_sat.polarization = ConfigSelection(default = defaultSat["polarization"], choices = [
+ (eDVBFrontendParametersSatellite.Polarisation_Horizontal, _("horizontal")),
+ (eDVBFrontendParametersSatellite.Polarisation_Vertical, _("vertical")),
+ (eDVBFrontendParametersSatellite.Polarisation_CircularLeft, _("circular left")),
+ (eDVBFrontendParametersSatellite.Polarisation_CircularRight, _("circular right"))])
+ self.scan_sat.fec = ConfigSelection(default = defaultSat["fec"], choices = [
+ (eDVBFrontendParametersSatellite.FEC_Auto, _("Auto")),
+ (eDVBFrontendParametersSatellite.FEC_1_2, "1/2"),
+ (eDVBFrontendParametersSatellite.FEC_2_3, "2/3"),
+ (eDVBFrontendParametersSatellite.FEC_3_4, "3/4"),
+ (eDVBFrontendParametersSatellite.FEC_5_6, "5/6"),
+ (eDVBFrontendParametersSatellite.FEC_7_8, "7/8"),
+ (eDVBFrontendParametersSatellite.FEC_None, _("None"))])
+ self.scan_sat.fec_s2 = ConfigSelection(default = defaultSat["fec_s2"], choices = [
+ (eDVBFrontendParametersSatellite.FEC_1_2, "1/2"),
+ (eDVBFrontendParametersSatellite.FEC_2_3, "2/3"),
+ (eDVBFrontendParametersSatellite.FEC_3_4, "3/4"),
+ (eDVBFrontendParametersSatellite.FEC_3_5, "3/5"),
+ (eDVBFrontendParametersSatellite.FEC_4_5, "4/5"),
+ (eDVBFrontendParametersSatellite.FEC_5_6, "5/6"),
+ (eDVBFrontendParametersSatellite.FEC_7_8, "7/8"),
+ (eDVBFrontendParametersSatellite.FEC_8_9, "8/9"),
+ (eDVBFrontendParametersSatellite.FEC_9_10, "9/10")])
+ self.scan_sat.fec_s2x_qpsk = ConfigSelection(default = defaultSat["fec_s2x_qpsk"], choices = [
+ (eDVBFrontendParametersSatellite.FEC_13_45, "13/45"),
+ (eDVBFrontendParametersSatellite.FEC_9_20, "9/20"),
+ (eDVBFrontendParametersSatellite.FEC_11_20, "11/20")])
+
+ self.scan_sat.fec_s2x_8psk = ConfigSelection(default = defaultSat["fec_s2x_8psk"], choices = [
+ (eDVBFrontendParametersSatellite.FEC_23_36, "23/36"),
+ (eDVBFrontendParametersSatellite.FEC_25_36, "25/36"),
+ (eDVBFrontendParametersSatellite.FEC_13_18, "13/28")])
+
+ self.scan_sat.fec_s2x_8apsk = ConfigSelection(default = defaultSat["fec_s2x_8apsk"], choices = [
+ (eDVBFrontendParametersSatellite.FEC_5_9_L, "5/9-L"),
+ (eDVBFrontendParametersSatellite.FEC_26_45_L, "26/45-L")])
+
+ self.scan_sat.fec_s2x_16apsk = ConfigSelection(default = defaultSat["fec_s2x_16apsk"], choices = [
+ (eDVBFrontendParametersSatellite.FEC_1_2_L, "1/2-L"),
+ (eDVBFrontendParametersSatellite.FEC_8_15_L, "8/15-L"),
+ (eDVBFrontendParametersSatellite.FEC_5_9_L, "5/9-L"),
+ (eDVBFrontendParametersSatellite.FEC_26_45, "26/45"),
+ (eDVBFrontendParametersSatellite.FEC_3_5, "3/5"),
+ (eDVBFrontendParametersSatellite.FEC_3_5_L, "3/5-L"),
+ (eDVBFrontendParametersSatellite.FEC_28_45, "28/45"),
+ (eDVBFrontendParametersSatellite.FEC_23_36, "23/36"),
+ (eDVBFrontendParametersSatellite.FEC_2_3_L, "2/3-L"),
+ (eDVBFrontendParametersSatellite.FEC_25_36, "25/36"),
+ (eDVBFrontendParametersSatellite.FEC_13_18, "13/18"),
+ (eDVBFrontendParametersSatellite.FEC_7_9, "7/9"),
+ (eDVBFrontendParametersSatellite.FEC_77_90, "77/90")])
+
+ self.scan_sat.fec_s2x_32apsk = ConfigSelection(default = defaultSat["fec_s2x_32apsk"], choices = [
+ (eDVBFrontendParametersSatellite.FEC_2_3_L, "2/3-L"),
+ (eDVBFrontendParametersSatellite.FEC_32_45, "32/45"),
+ (eDVBFrontendParametersSatellite.FEC_11_15, "11/15"),
+ (eDVBFrontendParametersSatellite.FEC_7_9, "7/9")])
+ self.scan_sat.modulation = ConfigSelection(default = defaultSat["modulation"], choices = [
+ (eDVBFrontendParametersSatellite.Modulation_QPSK, "QPSK"),
+ (eDVBFrontendParametersSatellite.Modulation_8PSK, "8PSK")])
+ self.scan_sat.modulation_dvbs2x = ConfigSelection(default = defaultSat["modulation_s2x"], choices = [
+ (eDVBFrontendParametersSatellite.Modulation_QPSK, "QPSK"),
+ (eDVBFrontendParametersSatellite.Modulation_8PSK, "8PSK"),
+ (eDVBFrontendParametersSatellite.Modulation_8APSK, "8APSK"),
+ (eDVBFrontendParametersSatellite.Modulation_16APSK, "16APSK"),
+ (eDVBFrontendParametersSatellite.Modulation_32APSK, "32APSK")])
+ self.scan_sat.rolloff = ConfigSelection(default = defaultSat.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35), choices = [
+ (eDVBFrontendParametersSatellite.RollOff_alpha_0_35, "0.35"),
+ (eDVBFrontendParametersSatellite.RollOff_alpha_0_25, "0.25"),
+ (eDVBFrontendParametersSatellite.RollOff_alpha_0_20, "0.20")])
+ self.scan_sat.pilot = ConfigSelection(default = defaultSat.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown), choices = [
+ (eDVBFrontendParametersSatellite.Pilot_Off, _("Off")),
+ (eDVBFrontendParametersSatellite.Pilot_On, _("On")),
+ (eDVBFrontendParametersSatellite.Pilot_Unknown, _("Auto"))])
+ self.scan_sat.is_id = ConfigInteger(default = defaultSat["is_id"] if defaultSat["is_id"] != -1 else 0, limits = (0, 255))
+ self.scan_sat.is_id_bool = ConfigSelection(default = defaultSat["is_id"] != -1, choices = [(True, _("Multistream")),(False, _("Ordinary"))])
+ self.scan_sat.pls_mode = ConfigSelection(default = defaultSat["pls_mode"], choices = [
+ (eDVBFrontendParametersSatellite.PLS_Root, _("Root")),
+ (eDVBFrontendParametersSatellite.PLS_Gold, _("Gold")),
+ (eDVBFrontendParametersSatellite.PLS_Combo, _("Combo")),
+ (eDVBFrontendParametersSatellite.PLS_Unknown, _("Auto"))])
+ self.scan_sat.pls_code = ConfigInteger(default = defaultSat["pls_code"], limits = (0, 262143))
def tuningSatChanged(self, *parm):
self.updateTransponders()
+ self.createSetup()
+
+ def tuningTypeChanged(self, *parm):
+ self.createSetup()
+
+ def systemChanged(self, *parm):
+ self.createSetup()
+
+ def isIdChanged(self, *parm):
+ self.createSetup()
+
+ def plsModeChanged(self, *parm):
+ self.createSetup()
def updateTransponders(self):
- if len(tuning.sat.choices):
- transponderlist = nimmanager.getTransponders(int(tuning.sat.value))
+ if len(self.tuning.sat.choices):
+ transponderlist = nimmanager.getTransponders(int(self.tuning.sat.value))
tps = []
cnt=0
for x in transponderlist:
pol = "CR"
else:
pol = "??"
- if x[4] == 0:
- fec = "FEC Auto"
- elif x[4] == 1:
- fec = "FEC 1/2"
- elif x[4] == 2:
- fec = "FEC 2/3"
- elif x[4] == 3:
- fec = "FEC 3/4"
- elif x[4] == 4:
- fec = "FEC 5/6"
- elif x[4] == 5:
- fec = "FEC 7/8"
- elif x[4] == 6:
- fec = "FEC 8/9"
- elif x[4] == 7:
- fec = "FEC 3/5"
- elif x[4] == 8:
- fec = "FEC 4/5"
- elif x[4] == 9:
- fec = "FEC 9/10"
- elif x[4] == 15:
- fec = "FEC None"
- else:
+
+ fec_desc = ("FEC Auto", "FEC 1/2", "FEC 2/3", "FEC 3/4", "FEC 5/6", "FEC 7/8", "FEC 8/9", "FEC 3/5", "FEC 4/5", "FEC 9/10", \
+ "FEC Unknown", "FEC Unknown", "FEC Unknown", "FEC Unknown", "FEC Unknown", "FEC None", \
+ "FEC_13_45", "FEC_9_20", "FEC_11_20", "FEC_23_36", "FEC_25_36", \
+ "FEC_13_18", "FEC_26_45", "FEC_28_45", "FEC_7_9", "FEC_77_90", \
+ "FEC_32_45", "FEC_11_15", "FEC_1_2_L", "FEC_8_15_L", "FEC_3_5_L", \
+ "FEC_2_3_L", "FEC_5_9_L", "FEC_26_45_L")
+ if x[4] > len(fec_desc)-1:
fec = "FEC Unknown"
+ else:
+ fec = fec_desc[x[4]]
tps.append(str(x[1]) + "," + str(x[2]) + "," + pol + "," + fec)
- tuning.transponder = ConfigSelection(choices=tps)
+ self.tuning.transponder = ConfigSelection(choices=tps)
+
+ def keyLeft(self):
+ ConfigListScreen.keyLeft(self)
+
+ def keyRight(self):
+ ConfigListScreen.keyRight(self)
def keyGo(self):
- returnvalue = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
- satpos = int(tuning.sat.value)
- if tuning.type.value == "manual_transponder":
- if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2:
+ returnvalue = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 3, 0)
+ satpos = int(self.tuning.sat.value)
+ nim = nimmanager.nim_slots[self.feid]
+ if self.tuning.type.value == "manual_transponder":
+ system = self.scan_sat.system.value
+ modulation = self.scan_sat.modulation.value
+ if nim.isCompatible("DVB-S2X"):
+ system = self.scan_sat.system_dvbs2x.value
+ modulation = self.scan_sat.modulation_dvbs2x.value
+
+ if system == eDVBFrontendParametersSatellite.System_DVB_S:
+ fec = self.scan_sat.fec.value
+ elif system == eDVBFrontendParametersSatellite.System_DVB_S2:
fec = self.scan_sat.fec_s2.value
+ elif system == eDVBFrontendParametersSatellite.System_DVB_S2X:
+ if modulation == eDVBFrontendParametersSatellite.Modulation_QPSK:
+ fec = self.scan_sat.fec_s2x_qpsk.value
+ elif modulation == eDVBFrontendParametersSatellite.Modulation_8PSK:
+ fec = self.scan_sat.fec_s2x_8psk.value
+ elif modulation == eDVBFrontendParametersSatellite.Modulation_8APSK:
+ fec = self.scan_sat.fec_s2x_8apsk.value
+ elif modulation == eDVBFrontendParametersSatellite.Modulation_16APSK:
+ fec = self.scan_sat.fec_s2x_16apsk.value
+ elif modulation == eDVBFrontendParametersSatellite.Modulation_32APSK:
+ fec = self.scan_sat.fec_s2x_32apsk.value
else:
fec = self.scan_sat.fec.value
+
+ is_id = -1
+ pls_mode = eDVBFrontendParametersSatellite.PLS_Unknown
+ pls_code = 0
+ if self.scan_sat.is_id_bool.value:
+ is_id = self.scan_sat.is_id.value
+ pls_mode = self.scan_sat.pls_mode.value
+ if pls_mode == eDVBFrontendParametersSatellite.PLS_Unknown:
+ pls_code = 0
+ else:
+ pls_code = self.scan_sat.pls_code.value
+
returnvalue = (
self.scan_sat.frequency.value,
self.scan_sat.symbolrate.value,
fec,
self.scan_sat.inversion.value,
satpos,
- self.scan_sat.system.value,
- self.scan_sat.modulation.value,
+ system,
+ modulation,
self.scan_sat.rolloff.value,
- self.scan_sat.pilot.value)
- elif tuning.type.value == "predefined_transponder":
- transponder = nimmanager.getTransponders(satpos)[tuning.transponder.index]
+ self.scan_sat.pilot.value,
+ is_id,
+ pls_mode,
+ pls_code)
+ elif self.tuning.type.value == "predefined_transponder":
+ transponder = nimmanager.getTransponders(satpos)[self.tuning.transponder.index]
returnvalue = (transponder[1] / 1000, transponder[2] / 1000,
- transponder[3], transponder[4], 2, satpos, transponder[5], transponder[6], transponder[8], transponder[9])
+ transponder[3], transponder[4], 2, satpos, transponder[5], transponder[6], transponder[8], transponder[9], transponder[10], transponder[11], transponder[12])
self.close(returnvalue)
def keyCancel(self):
def createSetup(self):
self.typeOfTuningEntry = None
self.satEntry = None
-
+ self.systemEntry = None
+ self.is_id_boolEntry = None
+ self.plsModeEntry = None
self.list = []
-
self.typeOfTuningEntry = getConfigListEntry(_('Tune'), self.tuning_type)
self.list.append(self.typeOfTuningEntry)
self.satEntry = getConfigListEntry(_('Satellite'), self.tuning_sat)
self.list.append(self.satEntry)
nim = nimmanager.nim_slots[self.feid]
-
- self.systemEntry = None
if self.tuning_type.value == "manual_transponder":
- if nim.isCompatible("DVB-S2"):
+ scan_sat_system_value = self.scan_sat.system.value
+ if nim.isCompatible("DVB-S2X"):
+ scan_sat_system_value = self.scan_sat.system_dvbs2x.value
+ self.systemEntry = getConfigListEntry(_('System'), self.scan_sat.system_dvbs2x)
+ self.list.append(self.systemEntry)
+ elif nim.isCompatible("DVB-S2"):
self.systemEntry = getConfigListEntry(_('System'), self.scan_sat.system)
self.list.append(self.systemEntry)
else:
self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion))
self.list.append(getConfigListEntry(_('Symbol rate'), self.scan_sat.symbolrate))
self.list.append(getConfigListEntry(_('Polarization'), self.scan_sat.polarization))
- if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S:
+ if scan_sat_system_value == eDVBFrontendParametersSatellite.System_DVB_S:
self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec))
- elif self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2:
+ elif scan_sat_system_value == eDVBFrontendParametersSatellite.System_DVB_S2:
self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2))
self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation)
self.list.append(self.modulationEntry)
self.list.append(getConfigListEntry(_('Roll-off'), self.scan_sat.rolloff))
self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot))
+ elif scan_sat_system_value == eDVBFrontendParametersSatellite.System_DVB_S2X:
+ if self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_QPSK:
+ self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_qpsk))
+ elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_8PSK:
+ self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_8psk))
+ elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_8APSK:
+ self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_8apsk))
+ elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_16APSK:
+ self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_16apsk))
+ elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_32APSK:
+ self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_32apsk))
+ self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation_dvbs2x)
+ self.list.append(self.modulationEntry)
+ self.list.append(getConfigListEntry(_('Roll-off'), self.scan_sat.rolloff))
+ self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot))
+ if scan_sat_system_value in (eDVBFrontendParametersSatellite.System_DVB_S2, eDVBFrontendParametersSatellite.System_DVB_S2X):
+ if nim.isMultistream():
+ self.is_id_boolEntry = getConfigListEntry(_('Transport Stream Type'), self.scan_sat.is_id_bool)
+ self.list.append(self.is_id_boolEntry)
+ if self.scan_sat.is_id_bool.value:
+ self.list.append(getConfigListEntry(_('Input Stream ID'), self.scan_sat.is_id))
+ self.plsModeEntry = getConfigListEntry(_('PLS Mode'), self.scan_sat.pls_mode)
+ self.list.append(self.plsModeEntry)
+ if self.scan_sat.pls_mode.value != eDVBFrontendParametersSatellite.PLS_Unknown:
+ self.list.append(getConfigListEntry(_('PLS Code'), self.scan_sat.pls_code))
elif self.tuning_transponder and self.tuning_type.value == "predefined_transponder":
self.list.append(getConfigListEntry(_("Transponder"), self.tuning_transponder))
self["config"].list = self.list
def newConfig(self):
cur = self["config"].getCurrent()
- if cur in (self.typeOfTuningEntry, self.systemEntry):
+ if cur in (self.typeOfTuningEntry, self.systemEntry, self.is_id_boolEntry, self.plsModeEntry):
self.createSetup()
elif cur == self.satEntry:
self.updateSats()
self.createSetup()
+ elif self.modulationEntry and (cur == self.modulationEntry) and \
+ self.systemEntry and (self.systemEntry[1].value == eDVBFrontendParametersSatellite.System_DVB_S2X):
+ self.createSetup()
def sat_changed(self, config_element):
self.newConfig()
self.retune(config_element)
def retune(self, configElement):
- returnvalue = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
+ returnvalue = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 3, 0)
satpos = int(self.tuning_sat.value)
+ nim = nimmanager.nim_slots[self.feid]
if self.tuning_type.value == "manual_transponder":
- if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2:
- fec = self.scan_sat.fec_s2.value
- else:
+ system = self.scan_sat.system.value
+ modulation = self.scan_sat.modulation.value
+ if nim.isCompatible("DVB-S2X"):
+ system = self.scan_sat.system_dvbs2x.value
+ modulation = self.scan_sat.modulation_dvbs2x.value
+
+ if system == eDVBFrontendParametersSatellite.System_DVB_S:
fec = self.scan_sat.fec.value
+ elif system == eDVBFrontendParametersSatellite.System_DVB_S2:
+ fec = self.scan_sat.fec_s2.value
+ elif system == eDVBFrontendParametersSatellite.System_DVB_S2X:
+ if modulation == eDVBFrontendParametersSatellite.Modulation_QPSK:
+ fec = self.scan_sat.fec_s2x_qpsk.value
+ elif modulation == eDVBFrontendParametersSatellite.Modulation_8PSK:
+ fec = self.scan_sat.fec_s2x_8psk.value
+ elif modulation == eDVBFrontendParametersSatellite.Modulation_8APSK:
+ fec = self.scan_sat.fec_s2x_8apsk.value
+ elif modulation == eDVBFrontendParametersSatellite.Modulation_16APSK:
+ fec = self.scan_sat.fec_s2x_16apsk.value
+ elif modulation == eDVBFrontendParametersSatellite.Modulation_32APSK:
+ fec = self.scan_sat.fec_s2x_32apsk.value
+
+ is_id = -1
+ pls_mode = eDVBFrontendParametersSatellite.PLS_Unknown
+ pls_code = 0
+ if self.scan_sat.is_id_bool.value:
+ is_id = self.scan_sat.is_id.value
+ pls_mode = self.scan_sat.pls_mode.value
+ if pls_mode == eDVBFrontendParametersSatellite.PLS_Unknown:
+ pls_code = 0
+ else:
+ pls_code = self.scan_sat.pls_code.value
+
returnvalue = (
self.scan_sat.frequency.value,
self.scan_sat.symbolrate.value,
fec,
self.scan_sat.inversion.value,
satpos,
- self.scan_sat.system.value,
- self.scan_sat.modulation.value,
+ system,
+ modulation,
self.scan_sat.rolloff.value,
- self.scan_sat.pilot.value)
+ self.scan_sat.pilot.value,
+ is_id,
+ pls_mode,
+ pls_code)
self.tune(returnvalue)
elif self.tuning_type.value == "predefined_transponder":
tps = nimmanager.getTransponders(satpos)
if l > self.tuning_transponder.index:
transponder = tps[self.tuning_transponder.index]
returnvalue = (transponder[1] / 1000, transponder[2] / 1000,
- transponder[3], transponder[4], 2, satpos, transponder[5], transponder[6], transponder[8], transponder[9])
+ transponder[3], transponder[4], 2, satpos, transponder[5], transponder[6], transponder[8], transponder[9], transponder[10], transponder[11], transponder[12])
self.tune(returnvalue)
def createConfig(self, foo):
self.updateSats()
- for x in (self.tuning_type, self.tuning_sat, self.scan_sat.frequency,
+ setup_list = [self.tuning_type, self.tuning_sat, self.scan_sat.frequency,
self.scan_sat.inversion, self.scan_sat.symbolrate,
self.scan_sat.polarization, self.scan_sat.fec, self.scan_sat.pilot,
self.scan_sat.fec_s2, self.scan_sat.fec, self.scan_sat.modulation,
- self.scan_sat.rolloff, self.scan_sat.system):
+ self.scan_sat.rolloff, self.scan_sat.system,
+ self.scan_sat.is_id_bool, self.scan_sat.is_id, self.scan_sat.pls_mode, self.scan_sat.pls_code]
+
+ nim = nimmanager.nim_slots[self.feid]
+ if nim.isCompatible("DVB-S2X"):
+ dvbs2x_setup_list = [self.scan_sat.system_dvbs2x, self.scan_sat.modulation_dvbs2x, self.scan_sat.fec_s2x_qpsk,
+ self.scan_sat.fec_s2x_8psk, self.scan_sat.fec_s2x_8apsk, self.scan_sat.fec_s2x_16apsk, self.scan_sat.fec_s2x_32apsk]
+ setup_list.extend(dvbs2x_setup_list)
+
+ for x in setup_list:
x.addNotifier(self.retune, initial_call = False)
def updateSats(self):
from Components.ConfigList import ConfigListScreen
from Components.NimManager import nimmanager, getConfigSatlist
from Components.Label import Label
+from Components.SystemInfo import SystemInfo
from Tools.Directories import resolveFilename, SCOPE_DEFAULTPARTITIONMOUNTDIR, SCOPE_DEFAULTDIR, SCOPE_DEFAULTPARTITION
from Tools.HardwareInfo import HardwareInfo
from Screens.MessageBox import MessageBox
parm.modulation = x[6]
parm.rolloff = x[8]
parm.pilot = x[9]
+ parm.is_id = x[10]
+ parm.pls_mode = x[11]
+ parm.pls_code = x[12]
tlist.append(parm)
def getInitialCableTransponderList(tlist, nim):
self.typeOfScanEntry = None
self.systemEntry = None
self.modulationEntry = None
+ self.is_id_boolEntry = None
+ self.plsModeEntry = None
nim = nimmanager.nim_slots[index_to_scan]
if nim.isCompatible("DVB-S"):
self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), self.scan_type)
if nim.isCompatible("DVB-S"):
if self.scan_type.value == "single_transponder":
self.updateSatList()
- if nim.isCompatible("DVB-S2"):
+
+ scan_sat_system_value = self.scan_sat.system.value
+ if nim.isCompatible("DVB-S2X"):
+ scan_sat_system_value = self.scan_sat.system_dvbs2x.value
+ self.systemEntry = getConfigListEntry(_('System'), self.scan_sat.system_dvbs2x)
+ self.list.append(self.systemEntry)
+ elif nim.isCompatible("DVB-S2"):
self.systemEntry = getConfigListEntry(_('System'), self.scan_sat.system)
self.list.append(self.systemEntry)
else:
self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion))
self.list.append(getConfigListEntry(_('Symbol rate'), self.scan_sat.symbolrate))
self.list.append(getConfigListEntry(_('Polarization'), self.scan_sat.polarization))
- if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S:
- self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec))
- elif self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2:
- self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2))
+
+ if scan_sat_system_value == eDVBFrontendParametersSatellite.System_DVB_S2:
self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation)
self.list.append(self.modulationEntry)
self.list.append(getConfigListEntry(_('Roll-off'), self.scan_sat.rolloff))
self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot))
+ elif scan_sat_system_value == eDVBFrontendParametersSatellite.System_DVB_S2X:
+ self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation_dvbs2x)
+ self.list.append(self.modulationEntry)
+ self.list.append(getConfigListEntry(_('Roll-off'), self.scan_sat.rolloff))
+ self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot))
+
+ if scan_sat_system_value == eDVBFrontendParametersSatellite.System_DVB_S:
+ self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec))
+ elif scan_sat_system_value == eDVBFrontendParametersSatellite.System_DVB_S2:
+ self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2))
+ elif scan_sat_system_value == eDVBFrontendParametersSatellite.System_DVB_S2X:
+ if self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_QPSK:
+ self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_qpsk))
+ elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_8PSK:
+ self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_8psk))
+ elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_8APSK:
+ self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_8apsk))
+ elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_16APSK:
+ self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_16apsk))
+ elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_32APSK:
+ self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_32apsk))
+
+ if scan_sat_system_value in (eDVBFrontendParametersSatellite.System_DVB_S2, eDVBFrontendParametersSatellite.System_DVB_S2X):
+ if nim.isMultistream():
+ self.is_id_boolEntry = getConfigListEntry(_('Transport Stream Type'), self.scan_sat.is_id_bool)
+ self.list.append(self.is_id_boolEntry)
+ if self.scan_sat.is_id_bool.value:
+ self.list.append(getConfigListEntry(_('Input Stream ID'), self.scan_sat.is_id))
+ self.plsModeEntry = getConfigListEntry(_('PLS Mode'), self.scan_sat.pls_mode)
+ self.list.append(self.plsModeEntry)
+ if self.scan_sat.pls_mode.value != eDVBFrontendParametersSatellite.PLS_Unknown:
+ self.list.append(getConfigListEntry(_('PLS Code'), self.scan_sat.pls_code))
+
elif self.scan_type.value == "single_satellite":
self.updateSatList()
print self.scan_satselection[index_to_scan]
def newConfig(self):
cur = self["config"].getCurrent()
print "cur is", cur
+ if cur is None:
+ return
+
if cur == self.typeOfScanEntry or \
cur == self.tunerEntry or \
cur == self.systemEntry or \
- (self.modulationEntry and self.systemEntry[1].value == eDVBFrontendParametersSatellite.System_DVB_S2 and cur == self.modulationEntry):
+ (self.modulationEntry and \
+ (self.systemEntry[1].value in (eDVBFrontendParametersSatellite.System_DVB_S2, eDVBFrontendParametersSatellite.System_DVB_S2X)) and \
+ cur == self.modulationEntry) or \
+ cur == self.is_id_boolEntry or \
+ cur == self.plsModeEntry:
self.createSetup()
def createConfig(self, frontendData):
- #("Type", frontendData["system"], TYPE_TEXT),
- #("Modulation", frontendData["modulation"], TYPE_TEXT),
- #("Orbital position", frontendData["orbital_position"], TYPE_VALUE_DEC),
- #("Frequency", frontendData["frequency"], TYPE_VALUE_DEC),
- #("Symbolrate", frontendData["symbol_rate"], TYPE_VALUE_DEC),
- #("Polarization", frontendData["polarization"], TYPE_TEXT),
- #("Inversion", frontendData["inversion"], TYPE_TEXT),
- #("FEC inner", frontendData["fec_inner"], TYPE_TEXT),
- #)
- #elif frontendData["tuner_type"] == "DVB-C":
- #return ( ("NIM", ['A', 'B', 'C', 'D'][frontendData["tuner_number"]], TYPE_TEXT),
- #("Type", frontendData["tuner_type"], TYPE_TEXT),
- #("Frequency", frontendData["frequency"], TYPE_VALUE_DEC),
- #("Symbolrate", frontendData["symbol_rate"], TYPE_VALUE_DEC),
- #("Modulation", frontendData["modulation"], TYPE_TEXT),
- #("Inversion", frontendData["inversion"], TYPE_TEXT),
- # ("FEC inner", frontendData["fec_inner"], TYPE_TEXT),
- #)
- #elif frontendData["tuner_type"] == "DVB-T":
- #return ( ("NIM", ['A', 'B', 'C', 'D'][frontendData["tuner_number"]], TYPE_TEXT),
- #("Type", frontendData["tuner_type"], TYPE_TEXT),
- #("Frequency", frontendData["frequency"], TYPE_VALUE_DEC),
- #("Inversion", frontendData["inversion"], TYPE_TEXT),
- #("Bandwidth", frontendData["bandwidth"], TYPE_VALUE_DEC),
- #("CodeRateLP", frontendData["code_rate_lp"], TYPE_TEXT),
- #("CodeRateHP", frontendData["code_rate_hp"], TYPE_TEXT),
- #("Constellation", frontendData["constellation"], TYPE_TEXT),
- #("Transmission Mode", frontendData["transmission_mode"], TYPE_TEXT),
- #("Guard Interval", frontendData["guard_interval"], TYPE_TEXT),
- #("Hierarchy Inform.", frontendData["hierarchy_information"], TYPE_TEXT),
defaultSat = {
"orbpos": 192,
"system": eDVBFrontendParametersSatellite.System_DVB_S,
"polarization": eDVBFrontendParametersSatellite.Polarisation_Horizontal,
"fec": eDVBFrontendParametersSatellite.FEC_Auto,
"fec_s2": eDVBFrontendParametersSatellite.FEC_9_10,
- "modulation": eDVBFrontendParametersSatellite.Modulation_QPSK }
+ "fec_s2x_qpsk": eDVBFrontendParametersSatellite.FEC_13_45,
+ "fec_s2x_8psk": eDVBFrontendParametersSatellite.FEC_23_36,
+ "fec_s2x_8apsk": eDVBFrontendParametersSatellite.FEC_5_9_L,
+ "fec_s2x_16apsk": eDVBFrontendParametersSatellite.FEC_1_2_L,
+ "fec_s2x_32apsk": eDVBFrontendParametersSatellite.FEC_2_3_L,
+ "modulation": eDVBFrontendParametersSatellite.Modulation_QPSK,
+ "modulation_s2x": eDVBFrontendParametersSatellite.Modulation_QPSK,
+ "is_id": -1,
+ "pls_mode": eDVBFrontendParametersSatellite.PLS_Unknown,
+ "pls_code": 0 }
defaultCab = {
"frequency": 466,
"inversion": eDVBFrontendParametersCable.Inversion_Unknown,
defaultSat["inversion"] = frontendData.get("inversion", eDVBFrontendParametersSatellite.Inversion_Unknown)
defaultSat["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000
defaultSat["polarization"] = frontendData.get("polarization", eDVBFrontendParametersSatellite.Polarisation_Horizontal)
+ defaultSat["orbpos"] = frontendData.get("orbital_position", 0)
+
+ defaultSat["modulation"] = frontendData.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK)
+ defaultSat["modulation_s2x"] = frontendData.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK)
+
+ if defaultSat["modulation"] > eDVBFrontendParametersSatellite.Modulation_8PSK:
+ defaultSat["modulation"] = eDVBFrontendParametersSatellite.Modulation_8PSK
+
if defaultSat["system"] == eDVBFrontendParametersSatellite.System_DVB_S2:
defaultSat["fec_s2"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)
- defaultSat["rolloff"] = frontendData.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35)
- defaultSat["pilot"] = frontendData.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown)
+ elif defaultSat["system"] == eDVBFrontendParametersSatellite.System_DVB_S2X:
+ if defaultSat["modulation_s2x"] == eDVBFrontendParametersSatellite.Modulation_QPSK:
+ defaultSat["fec_s2x_qpsk"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_13_45)
+ elif defaultSat["modulation_s2x"] == eDVBFrontendParametersSatellite.Modulation_8PSK:
+ defaultSat["fec_s2x_8psk"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_23_36)
+ elif defaultSat["modulation_s2x"] == eDVBFrontendParametersSatellite.Modulation_8APSK:
+ defaultSat["fec_s2x_8apsk"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_5_9_L)
+ elif defaultSat["modulation_s2x"] == eDVBFrontendParametersSatellite.Modulation_16APSK:
+ defaultSat["fec_s2x_16apsk"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_1_2_L)
+ elif defaultSat["modulation_s2x"] == eDVBFrontendParametersSatellite.Modulation_32APSK:
+ defaultSat["fec_s2x_32apsk"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_2_3_L)
else:
defaultSat["fec"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)
- defaultSat["modulation"] = frontendData.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK)
- defaultSat["orbpos"] = frontendData.get("orbital_position", 0)
+
+ if defaultSat["system"] in (eDVBFrontendParametersSatellite.System_DVB_S2, eDVBFrontendParametersSatellite.System_DVB_S2X):
+ defaultSat["rolloff"] = frontendData.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35)
+ defaultSat["pilot"] = frontendData.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown)
+ defaultSat["is_id"] = frontendData.get("is_id", defaultSat["is_id"])
+ defaultSat["pls_mode"] = frontendData.get("pls_mode", defaultSat["pls_mode"])
+ defaultSat["pls_code"] = frontendData.get("pls_code", defaultSat["pls_code"])
+
elif ttype == "DVB-C":
defaultCab["frequency"] = frontendData.get("frequency", 0) / 1000
defaultCab["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000
self.scan_ber.enabled = False
# sat
- self.scan_sat.system = ConfigSelection(default = defaultSat["system"], choices = [
+ sat_choices = [
(eDVBFrontendParametersSatellite.System_DVB_S, _("DVB-S")),
- (eDVBFrontendParametersSatellite.System_DVB_S2, _("DVB-S2"))])
+ (eDVBFrontendParametersSatellite.System_DVB_S2, _("DVB-S2"))]
+
+ sat_choices_dvbs2x = [
+ (eDVBFrontendParametersSatellite.System_DVB_S, _("DVB-S")),
+ (eDVBFrontendParametersSatellite.System_DVB_S2, _("DVB-S2")),
+ (eDVBFrontendParametersSatellite.System_DVB_S2X, _("DVB-S2X"))]
+
+ self.scan_sat.system = ConfigSelection(default = defaultSat["system"], choices = sat_choices)
+ self.scan_sat.system_dvbs2x = ConfigSelection(default = defaultSat["system"], choices = sat_choices_dvbs2x)
self.scan_sat.frequency = ConfigInteger(default = defaultSat["frequency"], limits = (1, 99999))
self.scan_sat.inversion = ConfigSelection(default = defaultSat["inversion"], choices = [
(eDVBFrontendParametersSatellite.Inversion_Off, _("Off")),
(eDVBFrontendParametersSatellite.FEC_7_8, "7/8"),
(eDVBFrontendParametersSatellite.FEC_8_9, "8/9"),
(eDVBFrontendParametersSatellite.FEC_9_10, "9/10")])
+
+ self.scan_sat.fec_s2x_qpsk = ConfigSelection(default = defaultSat["fec_s2x_qpsk"], choices = [
+ (eDVBFrontendParametersSatellite.FEC_13_45, "13/45"),
+ (eDVBFrontendParametersSatellite.FEC_9_20, "9/20"),
+ (eDVBFrontendParametersSatellite.FEC_11_20, "11/20")])
+
+ self.scan_sat.fec_s2x_8psk = ConfigSelection(default = defaultSat["fec_s2x_8psk"], choices = [
+ (eDVBFrontendParametersSatellite.FEC_23_36, "23/36"),
+ (eDVBFrontendParametersSatellite.FEC_25_36, "25/36"),
+ (eDVBFrontendParametersSatellite.FEC_13_18, "13/28")])
+
+ self.scan_sat.fec_s2x_8apsk = ConfigSelection(default = defaultSat["fec_s2x_8apsk"], choices = [
+ (eDVBFrontendParametersSatellite.FEC_5_9_L, "5/9-L"),
+ (eDVBFrontendParametersSatellite.FEC_26_45_L, "26/45-L")])
+
+ self.scan_sat.fec_s2x_16apsk = ConfigSelection(default = defaultSat["fec_s2x_16apsk"], choices = [
+ (eDVBFrontendParametersSatellite.FEC_1_2_L, "1/2-L"),
+ (eDVBFrontendParametersSatellite.FEC_8_15_L, "8/15-L"),
+ (eDVBFrontendParametersSatellite.FEC_5_9_L, "5/9-L"),
+ (eDVBFrontendParametersSatellite.FEC_26_45, "26/45"),
+ (eDVBFrontendParametersSatellite.FEC_3_5, "3/5"),
+ (eDVBFrontendParametersSatellite.FEC_3_5_L, "3/5-L"),
+ (eDVBFrontendParametersSatellite.FEC_28_45, "28/45"),
+ (eDVBFrontendParametersSatellite.FEC_23_36, "23/36"),
+ (eDVBFrontendParametersSatellite.FEC_2_3_L, "2/3-L"),
+ (eDVBFrontendParametersSatellite.FEC_25_36, "25/36"),
+ (eDVBFrontendParametersSatellite.FEC_13_18, "13/18"),
+ (eDVBFrontendParametersSatellite.FEC_7_9, "7/9"),
+ (eDVBFrontendParametersSatellite.FEC_77_90, "77/90")])
+
+ self.scan_sat.fec_s2x_32apsk = ConfigSelection(default = defaultSat["fec_s2x_32apsk"], choices = [
+ (eDVBFrontendParametersSatellite.FEC_2_3_L, "2/3-L"),
+ (eDVBFrontendParametersSatellite.FEC_32_45, "32/45"),
+ (eDVBFrontendParametersSatellite.FEC_11_15, "11/15"),
+ (eDVBFrontendParametersSatellite.FEC_7_9, "7/9")])
+
self.scan_sat.modulation = ConfigSelection(default = defaultSat["modulation"], choices = [
(eDVBFrontendParametersSatellite.Modulation_QPSK, "QPSK"),
(eDVBFrontendParametersSatellite.Modulation_8PSK, "8PSK")])
+ self.scan_sat.modulation_dvbs2x = ConfigSelection(default = defaultSat["modulation_s2x"], choices = [
+ (eDVBFrontendParametersSatellite.Modulation_QPSK, "QPSK"),
+ (eDVBFrontendParametersSatellite.Modulation_8PSK, "8PSK"),
+ (eDVBFrontendParametersSatellite.Modulation_8APSK, "8APSK"),
+ (eDVBFrontendParametersSatellite.Modulation_16APSK, "16APSK"),
+ (eDVBFrontendParametersSatellite.Modulation_32APSK, "32APSK")])
self.scan_sat.rolloff = ConfigSelection(default = defaultSat.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35), choices = [
(eDVBFrontendParametersSatellite.RollOff_alpha_0_35, "0.35"),
(eDVBFrontendParametersSatellite.RollOff_alpha_0_25, "0.25"),
(eDVBFrontendParametersSatellite.Pilot_Off, _("Off")),
(eDVBFrontendParametersSatellite.Pilot_On, _("On")),
(eDVBFrontendParametersSatellite.Pilot_Unknown, _("Auto"))])
+ self.scan_sat.is_id = ConfigInteger(default = defaultSat["is_id"] if defaultSat["is_id"] != -1 else 0, limits = (0, 255))
+ self.scan_sat.is_id_bool = ConfigSelection(default = defaultSat["is_id"] != -1, choices = [(True, _("Multistream")),(False, _("Ordinary"))])
+ self.scan_sat.pls_mode = ConfigSelection(default = defaultSat["pls_mode"], choices = [
+ (eDVBFrontendParametersSatellite.PLS_Root, _("Root")),
+ (eDVBFrontendParametersSatellite.PLS_Gold, _("Gold")),
+ (eDVBFrontendParametersSatellite.PLS_Combo, _("Combo")),
+ (eDVBFrontendParametersSatellite.PLS_Unknown, _("Auto"))])
+ self.scan_sat.pls_code = ConfigInteger(default = defaultSat["pls_code"], limits = (0, 262143))
# cable
self.scan_cab.frequency = ConfigInteger(default = defaultCab["frequency"], limits = (50, 999))
def updateStatus(self):
print "updatestatus"
- def addSatTransponder(self, tlist, frequency, symbol_rate, polarisation, fec, inversion, orbital_position, system, modulation, rolloff, pilot):
- print "Add Sat: frequ: " + str(frequency) + " symbol: " + str(symbol_rate) + " pol: " + str(polarisation) + " fec: " + str(fec) + " inversion: " + str(inversion) + " modulation: " + str(modulation) + " system: " + str(system) + " rolloff" + str(rolloff) + " pilot" + str(pilot)
+ def addSatTransponder(self, tlist, frequency, symbol_rate, polarisation, fec, inversion, orbital_position, system, modulation, rolloff, pilot, is_id, pls_mode, pls_code):
+ print "Add Sat: frequ: " + str(frequency) + " symbol: " + str(symbol_rate) + " pol: " + str(polarisation) + " fec: " + str(fec) + " inversion: " + str(inversion) + " modulation: " + str(modulation) + " system: " + str(system) + " rolloff" + str(rolloff) + " pilot" + str(pilot) + " is_id" + str(is_id) + " pls_mode" + str(pls_mode) + " pls_code" + str(pls_code)
print "orbpos: " + str(orbital_position)
parm = eDVBFrontendParametersSatellite()
parm.modulation = modulation
parm.orbital_position = orbital_position
parm.rolloff = rolloff
parm.pilot = pilot
+ parm.is_id = is_id
+ parm.pls_mode = pls_mode
+ parm.pls_code = pls_code
tlist.append(parm)
def addCabTransponder(self, tlist, frequency, symbol_rate, modulation, fec, inversion):
nimsats = self.satList[index_to_scan]
selsatidx = self.scan_satselection[index_to_scan].index
+ modulation = self.scan_sat.modulation.value
# however, the satList itself could be empty. in that case, "index" is 0 (for "None").
if len(nimsats):
orbpos = nimsats[selsatidx][0]
- if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S:
+
+ system = self.scan_sat.system.value
+ if nim.isCompatible("DVB-S2X"):
+ system = self.scan_sat.system_dvbs2x.value
+
+ if system == eDVBFrontendParametersSatellite.System_DVB_S:
fec = self.scan_sat.fec.value
+ elif system == eDVBFrontendParametersSatellite.System_DVB_S2:
+ fec = self.scan_sat.fec_s2.value
+ elif system == eDVBFrontendParametersSatellite.System_DVB_S2X:
+ modulation = self.scan_sat.modulation_dvbs2x.value
+ if modulation == eDVBFrontendParametersSatellite.Modulation_QPSK:
+ fec = self.scan_sat.fec_s2x_qpsk.value
+ elif modulation == eDVBFrontendParametersSatellite.Modulation_8PSK:
+ fec = self.scan_sat.fec_s2x_8psk.value
+ elif modulation == eDVBFrontendParametersSatellite.Modulation_8APSK:
+ fec = self.scan_sat.fec_s2x_8apsk.value
+ elif modulation == eDVBFrontendParametersSatellite.Modulation_16APSK:
+ fec = self.scan_sat.fec_s2x_16apsk.value
+ elif modulation == eDVBFrontendParametersSatellite.Modulation_32APSK:
+ fec = self.scan_sat.fec_s2x_32apsk.value
else:
fec = self.scan_sat.fec_s2.value
+
+ is_id = -1
+ pls_mode = eDVBFrontendParametersSatellite.PLS_Unknown
+ pls_code = 0
+ if self.scan_sat.is_id_bool.value:
+ is_id = self.scan_sat.is_id.value
+ pls_mode = self.scan_sat.pls_mode.value
+ if pls_mode == eDVBFrontendParametersSatellite.PLS_Unknown:
+ pls_code = 0
+ else:
+ pls_code = self.scan_sat.pls_code.value
+
print "add sat transponder"
self.addSatTransponder(tlist, self.scan_sat.frequency.value,
self.scan_sat.symbolrate.value,
fec,
self.scan_sat.inversion.value,
orbpos,
- self.scan_sat.system.value,
- self.scan_sat.modulation.value,
+ system,
+ modulation,
self.scan_sat.rolloff.value,
- self.scan_sat.pilot.value)
+ self.scan_sat.pilot.value,
+ is_id,
+ pls_mode,
+ pls_code)
removeAll = False
elif self.scan_type.value == "single_satellite":
sat = self.satList[index_to_scan][self.scan_satselection[index_to_scan].index]
from ServiceReference import ServiceReference
from enigma import eListboxPythonMultiContent, eListbox, gFont, iServiceInformation, eServiceCenter
from Tools.Transponder import ConvertToHumanReadable
+from Components.NimManager import nimmanager
import skin
RT_HALIGN_LEFT = 0
if frontendDataOrg and len(frontendDataOrg):
frontendData = ConvertToHumanReadable(frontendDataOrg)
if frontendDataOrg["tuner_type"] == "DVB-S":
- return ((_("NIM"), chr(ord('A')+int(frontendData["tuner_number"])), TYPE_TEXT),
+ data = ((_("NIM"), chr(ord('A')+int(frontendData["tuner_number"])), TYPE_TEXT),
(_("Type"), frontendData["tuner_type"], TYPE_TEXT),
(_("System"), frontendData["system"], TYPE_TEXT),
(_("Modulation"), frontendData["modulation"], TYPE_TEXT),
(_("FEC"), frontendData["fec_inner"], TYPE_TEXT),
(_("Pilot"), frontendData.get("pilot", None), TYPE_TEXT),
(_("Roll-off"), frontendData.get("rolloff", None), TYPE_TEXT))
+ if nimmanager.isSupportMultistream(int(frontendData["tuner_number"])):
+ data += ((_("Input Stream ID"), frontendData.get("is_id", 0), TYPE_VALUE_DEC),
+ (_("PLS Mode"), frontendData.get("pls_mode", None), TYPE_TEXT),
+ (_("PLS Code"), frontendData.get("pls_code", 0), TYPE_VALUE_DEC))
+ return data
elif frontendDataOrg["tuner_type"] == "DVB-C":
return ((_("NIM"), chr(ord('A')+int(frontendData["tuner_number"])), TYPE_TEXT),
(_("Type"), frontendData["tuner_type"], TYPE_TEXT),
eDVBFrontendParametersSatellite.FEC_3_5 : "3/5",
eDVBFrontendParametersSatellite.FEC_4_5 : "4/5",
eDVBFrontendParametersSatellite.FEC_8_9 : "8/9",
- eDVBFrontendParametersSatellite.FEC_9_10 : "9/10"}[tp["fec_inner"]]
+ eDVBFrontendParametersSatellite.FEC_9_10 : "9/10",
+ eDVBFrontendParametersSatellite.FEC_13_45 : "13/45",
+ eDVBFrontendParametersSatellite.FEC_9_20 : "9/20",
+ eDVBFrontendParametersSatellite.FEC_11_20 : "11/20",
+ eDVBFrontendParametersSatellite.FEC_23_36 : "23/36",
+ eDVBFrontendParametersSatellite.FEC_25_36 : "25/36",
+ eDVBFrontendParametersSatellite.FEC_13_18 : "13/18",
+ eDVBFrontendParametersSatellite.FEC_26_45 : "26/45",
+ eDVBFrontendParametersSatellite.FEC_28_45 : "28/45",
+ eDVBFrontendParametersSatellite.FEC_7_9 : "7/9",
+ eDVBFrontendParametersSatellite.FEC_77_90 : "77/90",
+ eDVBFrontendParametersSatellite.FEC_32_45 : "32/45",
+ eDVBFrontendParametersSatellite.FEC_11_15 : "11/15",
+ eDVBFrontendParametersSatellite.FEC_1_2_L : "1/2-L",
+ eDVBFrontendParametersSatellite.FEC_8_15_L : "8/15-L",
+ eDVBFrontendParametersSatellite.FEC_3_5_L : "3/5-L",
+ eDVBFrontendParametersSatellite.FEC_2_3_L : "2/3-L",
+ eDVBFrontendParametersSatellite.FEC_5_9_L : "5/9-L",
+ eDVBFrontendParametersSatellite.FEC_26_45_L : "26/45-L"}[tp["fec_inner"]]
ret["modulation"] = {
eDVBFrontendParametersSatellite.Modulation_Auto : _("Auto"),
eDVBFrontendParametersSatellite.Modulation_QPSK : "QPSK",
eDVBFrontendParametersSatellite.Modulation_QAM16 : "QAM16",
- eDVBFrontendParametersSatellite.Modulation_8PSK : "8PSK"}[tp["modulation"]]
+ eDVBFrontendParametersSatellite.Modulation_8PSK : "8PSK",
+ eDVBFrontendParametersSatellite.Modulation_16APSK : "16APSK",
+ eDVBFrontendParametersSatellite.Modulation_32APSK : "32APSK",
+ eDVBFrontendParametersSatellite.Modulation_8APSK : "8APSK",
+ }[tp["modulation"]]
ret["orbital_position"] = nimmanager.getSatName(int(tp["orbital_position"]))
ret["polarization"] = {
eDVBFrontendParametersSatellite.Polarisation_Horizontal : _("Horizontal"),
eDVBFrontendParametersSatellite.Polarisation_CircularRight : _("Circular right")}[tp["polarization"]]
ret["system"] = {
eDVBFrontendParametersSatellite.System_DVB_S : "DVB-S",
- eDVBFrontendParametersSatellite.System_DVB_S2 : "DVB-S2"}[tp["system"]]
- if ret["system"] == "DVB-S2":
+ eDVBFrontendParametersSatellite.System_DVB_S2 : "DVB-S2",
+ eDVBFrontendParametersSatellite.System_DVB_S2X : "DVB-S2X"}[tp["system"]]
+ if ret["system"] in ("DVB-S2", "DVB-S2X"):
ret["rolloff"] = {
eDVBFrontendParametersSatellite.RollOff_alpha_0_35 : "0.35",
eDVBFrontendParametersSatellite.RollOff_alpha_0_25 : "0.25",
eDVBFrontendParametersSatellite.Pilot_Unknown : _("Auto"),
eDVBFrontendParametersSatellite.Pilot_On : _("On"),
eDVBFrontendParametersSatellite.Pilot_Off : _("Off")}[tp["pilot"]]
+ ret["pls_mode"] = {
+ eDVBFrontendParametersSatellite.PLS_Root : _("Root"),
+ eDVBFrontendParametersSatellite.PLS_Gold : _("Gold"),
+ eDVBFrontendParametersSatellite.PLS_Combo : _("Combo"),
+ eDVBFrontendParametersSatellite.PLS_Unknown : _("Auto")}.get(tp.get("pls_mode"))
+ #ret["is_id"] = tp.get("is_id")
+ #ret["pls_code"] = tp.get("pls_code")
+ else:
+ ret["pls_mode"] = None
+ ret["is_id"] = None
+ ret["pls_code"] = None
elif type == "DVB-C":
ret["tuner_type"] = _("Cable")
ret["modulation"] = {
eDVBFrontendParametersTerrestrial.FEC_1_2 : "1/2",
eDVBFrontendParametersTerrestrial.FEC_2_3 : "2/3",
eDVBFrontendParametersTerrestrial.FEC_3_4 : "3/4",
+ eDVBFrontendParametersTerrestrial.FEC_4_5 : "4/5",
eDVBFrontendParametersTerrestrial.FEC_5_6 : "5/6",
eDVBFrontendParametersTerrestrial.FEC_6_7 : "6/7",
eDVBFrontendParametersTerrestrial.FEC_7_8 : "7/8",
eDVBFrontendParametersTerrestrial.FEC_1_2 : "1/2",
eDVBFrontendParametersTerrestrial.FEC_2_3 : "2/3",
eDVBFrontendParametersTerrestrial.FEC_3_4 : "3/4",
+ eDVBFrontendParametersTerrestrial.FEC_4_5 : "4/5",
eDVBFrontendParametersTerrestrial.FEC_5_6 : "5/6",
eDVBFrontendParametersTerrestrial.FEC_6_7 : "6/7",
eDVBFrontendParametersTerrestrial.FEC_7_8 : "7/8",
projects / vuplus_dvbapp / commitdiff