From: hschang Date: Wed, 28 Feb 2018 06:53:32 +0000 (+0900) Subject: Support DVB-S2X. X-Git-Url: http://code.vuplus.com/gitweb/?p=vuplus_dvbapp;a=commitdiff_plain;h=faaf85f037e9d29dd9f5178016caf7c80776d55b Support DVB-S2X. --- diff --git a/lib/dvb/db.cpp b/lib/dvb/db.cpp index 0f367be..b2d21f4 100755 --- a/lib/dvb/db.cpp +++ b/lib/dvb/db.cpp @@ -378,11 +378,17 @@ void eDVBDB::loadServicelist(const char *file) 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; @@ -394,6 +400,9 @@ void eDVBDB::loadServicelist(const char *file) 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') @@ -512,27 +521,23 @@ void eDVBDB::saveServicelist(const char *file) 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(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)) { @@ -792,7 +797,7 @@ PyObject *eDVBDB::readSatellites(ePyObject sat_list, ePyObject sat_dict, ePyObje 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; @@ -857,6 +862,9 @@ PyObject *eDVBDB::readSatellites(ePyObject sat_list, ePyObject sat_dict, ePyObje 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; @@ -874,6 +882,9 @@ PyObject *eDVBDB::readSatellites(ePyObject sat_list, ePyObject sat_dict, ePyObje 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; @@ -887,7 +898,7 @@ PyObject *eDVBDB::readSatellites(ePyObject sat_list, ePyObject sat_dict, ePyObje } 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)); @@ -898,8 +909,11 @@ PyObject *eDVBDB::readSatellites(ePyObject sat_list, ePyObject sat_dict, ePyObje 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); } diff --git a/lib/dvb/dvb.cpp b/lib/dvb/dvb.cpp index 852c403..5ebf10c 100644 --- a/lib/dvb/dvb.cpp +++ b/lib/dvb/dvb.cpp @@ -414,6 +414,10 @@ bool eDVBResourceManager::frontendIsCompatible(int index, const char *type) { 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); @@ -443,6 +447,18 @@ bool eDVBResourceManager::frontendIsCompatible(int index, const char *type) return false; } +bool eDVBResourceManager::frontendIsMultistream(int index) +{ + for (eSmartPtrList::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); @@ -456,6 +472,8 @@ void eDVBResourceManager::setFrontendType(int index, const char *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")) { diff --git a/lib/dvb/dvb.h b/lib/dvb/dvb.h index 3e9fc7f..f470fe1 100644 --- a/lib/dvb/dvb.h +++ b/lib/dvb/dvb.h @@ -224,6 +224,7 @@ public: SWIG_VOID(RESULT) allocateRawChannel(eUsePtr &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); diff --git a/lib/dvb/frontend.cpp b/lib/dvb/frontend.cpp old mode 100755 new mode 100644 index ceecb6d..9d87118 --- a/lib/dvb/frontend.cpp +++ b/lib/dvb/frontend.cpp @@ -38,6 +38,9 @@ #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 #include #include @@ -126,29 +129,35 @@ void eDVBFrontendParametersSatellite::set(const SatelliteDeliverySystemDescripto 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); } } @@ -356,6 +365,12 @@ RESULT eDVBFrontendParameters::calculateDifference(const iDVBFrontendParameters 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) @@ -527,7 +542,6 @@ int eDVBFrontend::openFrontend() m_state=stateIdle; m_tuning=0; - dvb_frontend_info fe_info; if (!m_simulate) { eDebug("opening frontend %d", m_dvbid); @@ -545,6 +559,13 @@ int eDVBFrontend::openFrontend() 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; @@ -561,48 +582,46 @@ int eDVBFrontend::openFrontend() 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) @@ -613,6 +632,26 @@ int eDVBFrontend::openFrontend() 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); @@ -1054,10 +1093,13 @@ void PutSatelliteDataToDict(ePyObject &dict, eDVBFrontendParametersSatellite &fe 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); } @@ -1091,7 +1133,7 @@ void PutCableDataToDict(ePyObject &dict, eDVBFrontendParametersCable &feparm) 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; @@ -1102,12 +1144,13 @@ static void fillDictWithSatelliteData(ePyObject dict, struct dtv_property *p, lo 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) { @@ -1120,6 +1163,7 @@ static void fillDictWithSatelliteData(ePyObject dict, struct dtv_property *p, lo 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"); @@ -1130,7 +1174,12 @@ static void fillDictWithSatelliteData(ePyObject dict, struct dtv_property *p, lo { 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) { @@ -1149,16 +1198,19 @@ static void fillDictWithSatelliteData(ePyObject dict, struct dtv_property *p, lo } 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); @@ -1426,6 +1478,7 @@ void eDVBFrontend::getTransponderData(ePyObject dest, bool original) 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) { @@ -1485,13 +1538,12 @@ void eDVBFrontend::getTransponderData(ePyObject dest, bool original) } 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); @@ -1511,7 +1563,7 @@ void eDVBFrontend::getFrontendData(ePyObject dest) 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"; } @@ -2009,12 +2061,16 @@ void eDVBFrontend::setFrontend(bool recvEvents) { 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) { @@ -2028,7 +2084,7 @@ void eDVBFrontend::setFrontend(bool recvEvents) 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; @@ -2038,12 +2094,13 @@ void eDVBFrontend::setFrontend(bool recvEvents) 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 { @@ -2152,8 +2209,7 @@ RESULT eDVBFrontend::prepare_sat(const eDVBFrontendParametersSatellite &feparm, 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, @@ -2163,7 +2219,10 @@ RESULT eDVBFrontend::prepare_sat(const eDVBFrontendParametersSatellite &feparm, 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) { @@ -2207,7 +2266,7 @@ RESULT eDVBFrontend::prepare_sat(const eDVBFrontendParametersSatellite &feparm, break; } } - else // DVB_S2 + else if (feparm.system == eDVBFrontendParametersSatellite::System_DVB_S2) { switch (feparm.fec) { @@ -2243,6 +2302,45 @@ RESULT eDVBFrontend::prepare_sat(const eDVBFrontendParametersSatellite &feparm, 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 ) { @@ -2827,13 +2925,18 @@ int eDVBFrontend::isCompatibleWith(ePtr &feparm) 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; @@ -2842,12 +2945,29 @@ int eDVBFrontend::isCompatibleWith(ePtr &feparm) { return 0; } + bool multistream = (static_cast(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) @@ -2933,17 +3053,18 @@ void eDVBFrontend::setDeliverySystemWhitelist(const std::vector m_delsys, m_delsys_whitelist; char m_filename[128]; char m_description[128]; + dvb_frontend_info fe_info; FRONTENDPARAMETERS parm; eDVBFrontendParameters oparm; @@ -163,6 +164,7 @@ public: bool isLoopTimerActive() { return m_tuneTimer->isActive(); } bool isScheduledSendDiseqc(); void setUSBTuner(bool yesno) { m_is_usbtuner = yesno; } + bool is_multistream(); }; #endif // SWIG diff --git a/lib/dvb/frontendparms.h b/lib/dvb/frontendparms.h index b2a2cd7..5895023 100644 --- a/lib/dvb/frontendparms.h +++ b/lib/dvb/frontendparms.h @@ -22,15 +22,19 @@ struct eDVBFrontendParametersSatellite }; 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 @@ -42,9 +46,13 @@ struct eDVBFrontendParametersSatellite 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); diff --git a/lib/dvb/scan.cpp b/lib/dvb/scan.cpp index 46236dd..1906c12 100644 --- a/lib/dvb/scan.cpp +++ b/lib/dvb/scan.cpp @@ -868,15 +868,41 @@ void eDVBScan::channelDone() { 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, diff --git a/lib/python/Components/NimManager.py b/lib/python/Components/NimManager.py old mode 100755 new mode 100644 index b92ad92..017e57b --- a/lib/python/Components/NimManager.py +++ b/lib/python/Components/NimManager.py @@ -153,7 +153,7 @@ class SecConfigure: 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: @@ -510,7 +510,7 @@ class NIM(object): 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 @@ -528,7 +528,8 @@ class NIM(object): "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): @@ -558,7 +559,8 @@ class NIM(object): "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()] @@ -601,7 +603,16 @@ class NIM(object): # 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 {: } def getMultiTypeList(self): return self.multi_type @@ -615,6 +626,7 @@ class NIM(object): "DVB-C": "DVB-C", "DVB-S2": "DVB-S2", "DVB-T2": "DVB-T2", + "DVB-S2X": "DVB-S2X", None: _("empty") }[self.getType()] @@ -798,13 +810,20 @@ class NimManager: # 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: @@ -841,6 +860,9 @@ class NimManager: list.append(x.slot) return list + def isSupportMultistream(self, slotid): + return self.getNim(slotid).isMultistream() + def __init__(self): self.satList = [ ] self.cablesList = [] @@ -908,6 +930,8 @@ class NimManager: 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) @@ -921,6 +945,8 @@ class NimManager: 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[:]: diff --git a/lib/python/Components/ServiceScan.py b/lib/python/Components/ServiceScan.py index 6a82ade..3a405f2 100644 --- a/lib/python/Components/ServiceScan.py +++ b/lib/python/Components/ServiceScan.py @@ -54,9 +54,11 @@ class ServiceScan: 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), @@ -64,7 +66,13 @@ class ServiceScan: { 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() diff --git a/lib/python/Components/TuneTest.py b/lib/python/Components/TuneTest.py index 44b1909..9fb5143 100644 --- a/lib/python/Components/TuneTest.py +++ b/lib/python/Components/TuneTest.py @@ -5,8 +5,7 @@ class Tuner: 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 @@ -21,6 +20,14 @@ class Tuner: 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 @@ -103,8 +110,8 @@ class TuneTest: 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 @@ -141,7 +148,7 @@ class TuneTest: # 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 @@ -154,7 +161,7 @@ class TuneTest: # 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 @@ -204,8 +211,7 @@ class TuneTest: self.progressCallback((self.getProgressLength(), self.tuningtransponder, self.STATUS_START, self.currTuned)) self.timer.start(100, True) - # transponder = (frequency, symbolrate, polarisation, fec, inversion, orbpos, , , , , , ) - # 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) diff --git a/lib/python/Plugins/SystemPlugins/Blindscan/plugin.py b/lib/python/Plugins/SystemPlugins/Blindscan/plugin.py index 82ce819..aa80aa2 100644 --- a/lib/python/Plugins/SystemPlugins/Blindscan/plugin.py +++ b/lib/python/Plugins/SystemPlugins/Blindscan/plugin.py @@ -199,7 +199,7 @@ class Blindscan(ConfigListScreen, Screen): 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) @@ -305,7 +305,7 @@ class Blindscan(ConfigListScreen, Screen): 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): @@ -506,7 +506,8 @@ class Blindscan(ConfigListScreen, Screen): 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, @@ -521,7 +522,11 @@ class Blindscan(ConfigListScreen, Screen): "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} @@ -541,6 +546,9 @@ class Blindscan(ConfigListScreen, Screen): 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) diff --git a/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py b/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py index 4dcf6c6..acb2a2d 100644 --- a/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py +++ b/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py @@ -281,7 +281,7 @@ class DiseqcTester(Screen, TuneTest, ResultParser): 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): diff --git a/lib/python/Plugins/SystemPlugins/PositionerSetup/plugin.py b/lib/python/Plugins/SystemPlugins/PositionerSetup/plugin.py index e097117..a900350 100644 --- a/lib/python/Plugins/SystemPlugins/PositionerSetup/plugin.py +++ b/lib/python/Plugins/SystemPlugins/PositionerSetup/plugin.py @@ -10,11 +10,13 @@ from Plugins.Plugin import PluginDescriptor 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 @@ -88,7 +90,10 @@ class PositionerSetup(Screen): 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() @@ -406,9 +411,7 @@ class Diseqc: sleep(0.05) self.frontend.sendDiseqc(cmd) # send 2nd time -tuning = None - -class TunerScreen(ScanSetup): +class TunerScreen(ConfigListScreen, Screen): skin = """ @@ -418,24 +421,40 @@ class TunerScreen(ScanSetup): 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 @@ -443,49 +462,241 @@ class TunerScreen(ScanSetup): 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: @@ -499,41 +710,66 @@ class TunerScreen(ScanSetup): 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, @@ -541,14 +777,17 @@ class TunerScreen(ScanSetup): 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): diff --git a/lib/python/Plugins/SystemPlugins/Satfinder/plugin.py b/lib/python/Plugins/SystemPlugins/Satfinder/plugin.py index e611ca5..ad1c450 100644 --- a/lib/python/Plugins/SystemPlugins/Satfinder/plugin.py +++ b/lib/python/Plugins/SystemPlugins/Satfinder/plugin.py @@ -59,19 +59,23 @@ class Satfinder(ScanSetup): 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: @@ -81,14 +85,39 @@ class Satfinder(ScanSetup): 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 @@ -96,24 +125,57 @@ class Satfinder(ScanSetup): 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, @@ -121,10 +183,13 @@ class Satfinder(ScanSetup): 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) @@ -132,7 +197,7 @@ class Satfinder(ScanSetup): 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): @@ -143,11 +208,20 @@ class Satfinder(ScanSetup): 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): diff --git a/lib/python/Screens/ScanSetup.py b/lib/python/Screens/ScanSetup.py index 9cc6dea..fa3126b 100644 --- a/lib/python/Screens/ScanSetup.py +++ b/lib/python/Screens/ScanSetup.py @@ -7,6 +7,7 @@ from Components.ActionMap import NumberActionMap, ActionMap 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 @@ -48,6 +49,9 @@ def getInitialTransponderList(tlist, pos): 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): @@ -586,6 +590,8 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest 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) @@ -601,7 +607,13 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest 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: @@ -612,14 +624,45 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest 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] @@ -686,43 +729,20 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest 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, @@ -732,7 +752,16 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest "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, @@ -760,14 +789,37 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest 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 @@ -822,9 +874,17 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest 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")), @@ -854,9 +914,51 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest (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"), @@ -865,6 +967,14 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest (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)) @@ -1014,8 +1124,8 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest 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 @@ -1028,6 +1138,9 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest 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): @@ -1072,13 +1185,45 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest 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, @@ -1086,10 +1231,13 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest 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] diff --git a/lib/python/Screens/ServiceInfo.py b/lib/python/Screens/ServiceInfo.py index ffd288f..6e7b58e 100644 --- a/lib/python/Screens/ServiceInfo.py +++ b/lib/python/Screens/ServiceInfo.py @@ -6,6 +6,7 @@ from Components.Label import Label 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 @@ -187,7 +188,7 @@ class ServiceInfo(Screen): 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), @@ -199,6 +200,11 @@ class ServiceInfo(Screen): (_("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), diff --git a/lib/python/Tools/Transponder.py b/lib/python/Tools/Transponder.py index a882981..dffc3d2 100644 --- a/lib/python/Tools/Transponder.py +++ b/lib/python/Tools/Transponder.py @@ -22,12 +22,34 @@ def ConvertToHumanReadable(tp, type = None): 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"), @@ -36,8 +58,9 @@ def ConvertToHumanReadable(tp, type = None): 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", @@ -46,6 +69,17 @@ def ConvertToHumanReadable(tp, type = None): 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"] = { @@ -83,6 +117,7 @@ def ConvertToHumanReadable(tp, type = None): 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", @@ -92,6 +127,7 @@ def ConvertToHumanReadable(tp, type = None): 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",