diff options
Diffstat (limited to 'meta-bsp/recipes-vuplus/enigma2/enigma2/enigma2_vuplus_dvbs2x.patch')
| -rw-r--r-- | meta-bsp/recipes-vuplus/enigma2/enigma2/enigma2_vuplus_dvbs2x.patch | 1067 |
1 files changed, 1067 insertions, 0 deletions
diff --git a/meta-bsp/recipes-vuplus/enigma2/enigma2/enigma2_vuplus_dvbs2x.patch b/meta-bsp/recipes-vuplus/enigma2/enigma2/enigma2_vuplus_dvbs2x.patch new file mode 100644 index 0000000..5ff1247 --- /dev/null +++ b/meta-bsp/recipes-vuplus/enigma2/enigma2/enigma2_vuplus_dvbs2x.patch @@ -0,0 +1,1067 @@ +commit 8b323facfe629645939134a6422e4850425009ce +Author: hschang <chang@dev3> +Date: Mon Nov 27 11:45:33 2017 +0900 + + Support DVB-S2X + +diff --git a/lib/dvb/db.cpp b/lib/dvb/db.cpp +index 0f367be..ca43546 100755 +--- a/lib/dvb/db.cpp ++++ b/lib/dvb/db.cpp +@@ -512,7 +512,7 @@ void eDVBDB::saveServicelist(const char *file) + ch.m_frontendParameters->getFlags(flags); + if (!ch.m_frontendParameters->getDVBS(sat)) + { +- if (sat.system == eDVBFrontendParametersSatellite::System_DVB_S2) ++ if ((sat.system == eDVBFrontendParametersSatellite::System_DVB_S2) || (sat.system == eDVBFrontendParametersSatellite::System_DVB_S2X)) + { + fprintf(f, "\ts %d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d\n", + sat.frequency, sat.symbol_rate, +diff --git a/lib/dvb/dvb.cpp b/lib/dvb/dvb.cpp +index 852c403..67c3aa9 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); +@@ -456,6 +460,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/frontend.cpp b/lib/dvb/frontend.cpp +index 91c866c..a2eb0e8 100755 +--- 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 <dvbsi++/satellite_delivery_system_descriptor.h> + #include <dvbsi++/cable_delivery_system_descriptor.h> + #include <dvbsi++/terrestrial_delivery_system_descriptor.h> +@@ -132,23 +135,23 @@ void eDVBFrontendParametersSatellite::set(const SatelliteDeliverySystemDescripto + modulation=eDVBFrontendParametersSatellite::Modulation_QPSK; + } + rolloff = descriptor.getRollOff(); +- if (system == eDVBFrontendParametersSatellite::System_DVB_S2) ++ 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", + frequency, + polarisation ? "hor" : "vert", + orbital_position, +- symbol_rate, fec); ++ symbol_rate, fec, ++ modulation, ++ rolloff); + } + } + +@@ -1018,7 +1021,7 @@ 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); +@@ -1084,6 +1087,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"); +@@ -1094,7 +1098,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) + { +@@ -1112,17 +1121,16 @@ static void fillDictWithSatelliteData(ePyObject dict, struct dtv_property *p, lo + case PILOT_AUTO: tmp = eDVBFrontendParametersSatellite::Pilot_Unknown; break; + } + PutToDict(dict, "pilot", tmp); +- +- tmp = eDVBFrontendParametersSatellite::System_DVB_S2; break; + } +- } +- 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); + +@@ -1475,7 +1483,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"; + } +@@ -1973,12 +1981,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) + { +@@ -2002,7 +2014,7 @@ 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; +@@ -2116,8 +2128,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", + feparm.frequency, + feparm.polarisation, + feparm.symbol_rate, +@@ -2171,7 +2182,7 @@ RESULT eDVBFrontend::prepare_sat(const eDVBFrontendParametersSatellite &feparm, + break; + } + } +- else // DVB_S2 ++ else if (feparm.system == eDVBFrontendParametersSatellite::System_DVB_S2) + { + switch (feparm.fec) + { +@@ -2207,6 +2218,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 ) + { +@@ -2791,13 +2841,18 @@ int eDVBFrontend::isCompatibleWith(ePtr<iDVBFrontendParameters> &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; +@@ -2897,17 +2952,18 @@ void eDVBFrontend::setDeliverySystemWhitelist(const std::vector<fe_delivery_syst + + bool eDVBFrontend::setSlotInfo(ePyObject obj) + { +- ePyObject Id, Descr, Enabled, IsDVBS2, IsDVBT2, frontendId; +- if (!PyTuple_Check(obj) || PyTuple_Size(obj) != 6) ++ ePyObject Id, Descr, Enabled, IsDVBS2, IsDVBT2, IsDVBS2X, frontendId; ++ if (!PyTuple_Check(obj) || PyTuple_Size(obj) != 7) + goto arg_error; + Id = PyTuple_GET_ITEM(obj, 0); + Descr = PyTuple_GET_ITEM(obj, 1); + Enabled = PyTuple_GET_ITEM(obj, 2); + IsDVBS2 = PyTuple_GET_ITEM(obj, 3); + IsDVBT2 = PyTuple_GET_ITEM(obj, 4); +- frontendId = PyTuple_GET_ITEM(obj, 5); ++ IsDVBS2X = PyTuple_GET_ITEM(obj, 5); ++ frontendId = PyTuple_GET_ITEM(obj, 6); + m_slotid = PyInt_AsLong(Id); +- if (!PyInt_Check(Id) || !PyString_Check(Descr) || !PyBool_Check(Enabled) || !PyBool_Check(IsDVBS2) || !PyBool_Check(IsDVBT2) || !PyInt_Check(frontendId)) ++ if (!PyInt_Check(Id) || !PyString_Check(Descr) || !PyBool_Check(Enabled) || !PyBool_Check(IsDVBS2) || !PyBool_Check(IsDVBT2) || !PyBool_Check(IsDVBS2X) || !PyInt_Check(frontendId)) + goto arg_error; + strcpy(m_description, PyString_AS_STRING(Descr)); + if (PyInt_AsLong(frontendId) == -1 || PyInt_AsLong(frontendId) != m_dvbid) { +@@ -2931,9 +2987,14 @@ bool eDVBFrontend::setSlotInfo(ePyObject obj) + /* HACK for legacy dvb api without DELSYS support */ + m_delsys[SYS_DVBT2] = true; + } ++ if (IsDVBS2X == Py_True) ++ { ++ /* HACK for legacy dvb api without DELSYS support */ ++ m_delsys[SYS_DVBS2X] = true; ++ } + +- eDebugNoSimulate("setSlotInfo for dvb frontend %d to slotid %d, descr %s, need rotorworkaround %s, enabled %s, DVB-S2 %s, DVB-T2 %s", +- m_dvbid, m_slotid, m_description, m_need_rotor_workaround ? "Yes" : "No", Enabled == Py_True ? "Yes" : "No", IsDVBS2 == Py_True ? "Yes" : "No", IsDVBT2 == Py_True ? "Yes" : "No" ); ++ eDebugNoSimulate("setSlotInfo for dvb frontend %d to slotid %d, descr %s, need rotorworkaround %s, enabled %s, DVB-S2 %s, DVB-T2 %s, DVB-S2X %s", ++ m_dvbid, m_slotid, m_description, m_need_rotor_workaround ? "Yes" : "No", Enabled == Py_True ? "Yes" : "No", IsDVBS2 == Py_True ? "Yes" : "No", IsDVBT2 == Py_True ? "Yes" : "No", IsDVBS2X == Py_True ? "Yes" : "No"); + return true; + arg_error: + PyErr_SetString(PyExc_StandardError, +diff --git a/lib/dvb/frontendparms.h b/lib/dvb/frontendparms.h +index c4989fb..c941ca6 100644 +--- a/lib/dvb/frontendparms.h ++++ b/lib/dvb/frontendparms.h +@@ -21,15 +21,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 +diff --git a/lib/dvb/scan.cpp b/lib/dvb/scan.cpp +index 969ed9f..1f045df 100644 +--- a/lib/dvb/scan.cpp ++++ b/lib/dvb/scan.cpp +@@ -832,15 +832,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 +index b92ad92..d726fec 100755 +--- 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()] + +@@ -615,6 +617,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 +801,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: +@@ -908,6 +918,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 +933,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..7412386 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,11 @@ 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)) + elif tp_type == iDVBFrontend.feCable: + network = _("Cable") + tp = transponder.getDVBC() +diff --git a/lib/python/Plugins/SystemPlugins/Blindscan/plugin.py b/lib/python/Plugins/SystemPlugins/Blindscan/plugin.py +index 82ce819..5215a4b 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} +diff --git a/lib/python/Plugins/SystemPlugins/PositionerSetup/plugin.py b/lib/python/Plugins/SystemPlugins/PositionerSetup/plugin.py +index e097117..eb0fe51 100644 +--- a/lib/python/Plugins/SystemPlugins/PositionerSetup/plugin.py ++++ b/lib/python/Plugins/SystemPlugins/PositionerSetup/plugin.py +@@ -451,6 +451,21 @@ class TunerScreen(ScanSetup): + 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 self.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)) + elif tuning.type.value == "predefined_transponder": + self.list.append(getConfigListEntry(_("Transponder"), tuning.transponder)) + self["config"].list = self.list +@@ -499,30 +514,17 @@ 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) + +@@ -530,10 +532,26 @@ class TunerScreen(ScanSetup): + 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: ++ modulation = self.scan_sat.modulation.value ++ if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S: ++ fec = self.scan_sat.fec.value ++ elif self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2: + fec = self.scan_sat.fec_s2.value ++ elif self.scan_sat.system.value == 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.value ++ fec = self.scan_sat.fec_s2.value ++ + returnvalue = ( + self.scan_sat.frequency.value, + self.scan_sat.symbolrate.value, +@@ -542,7 +560,7 @@ class TunerScreen(ScanSetup): + self.scan_sat.inversion.value, + satpos, + self.scan_sat.system.value, +- self.scan_sat.modulation.value, ++ modulation, + self.scan_sat.rolloff.value, + self.scan_sat.pilot.value) + elif tuning.type.value == "predefined_transponder": +diff --git a/lib/python/Plugins/SystemPlugins/Satfinder/plugin.py b/lib/python/Plugins/SystemPlugins/Satfinder/plugin.py +index e611ca5..3e4a043 100644 +--- a/lib/python/Plugins/SystemPlugins/Satfinder/plugin.py ++++ b/lib/python/Plugins/SystemPlugins/Satfinder/plugin.py +@@ -89,6 +89,21 @@ class Satfinder(ScanSetup): + 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 self.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)) + elif self.tuning_transponder and self.tuning_type.value == "predefined_transponder": + self.list.append(getConfigListEntry(_("Transponder"), self.tuning_transponder)) + self["config"].list = self.list +@@ -110,10 +125,23 @@ class Satfinder(ScanSetup): + returnvalue = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0) + satpos = int(self.tuning_sat.value) + 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: ++ modulation = self.scan_sat.modulation.value ++ if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S: + fec = self.scan_sat.fec.value ++ elif self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2: ++ fec = self.scan_sat.fec_s2.value ++ elif self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2X: ++ modulation = 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 + returnvalue = ( + self.scan_sat.frequency.value, + self.scan_sat.symbolrate.value, +@@ -122,7 +150,7 @@ class Satfinder(ScanSetup): + self.scan_sat.inversion.value, + satpos, + self.scan_sat.system.value, +- self.scan_sat.modulation.value, ++ modulation, + self.scan_sat.rolloff.value, + self.scan_sat.pilot.value) + self.tune(returnvalue) +diff --git a/lib/python/Screens/ScanSetup.py b/lib/python/Screens/ScanSetup.py +index 9cc6dea..b7f5788 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 +@@ -601,7 +602,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 +619,34 @@ 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)) ++ + elif self.scan_type.value == "single_satellite": + self.updateSatList() + print self.scan_satselection[index_to_scan] +@@ -686,43 +713,18 @@ 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): + 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 +734,13 @@ 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} + defaultCab = { + "frequency": 466, + "inversion": eDVBFrontendParametersCable.Inversion_Unknown, +@@ -760,14 +768,34 @@ 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) ++ + elif ttype == "DVB-C": + defaultCab["frequency"] = frontendData.get("frequency", 0) / 1000 + defaultCab["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000 +@@ -822,9 +850,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"))] ++ ++ sat_choices_dvbs2x = [ + (eDVBFrontendParametersSatellite.System_DVB_S, _("DVB-S")), +- (eDVBFrontendParametersSatellite.System_DVB_S2, _("DVB-S2"))]) ++ (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 +890,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"), +@@ -1072,13 +1150,34 @@ 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 ++ + print "add sat transponder" + self.addSatTransponder(tlist, self.scan_sat.frequency.value, + self.scan_sat.symbolrate.value, +@@ -1086,8 +1185,8 @@ 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) + removeAll = False +diff --git a/lib/python/Tools/Transponder.py b/lib/python/Tools/Transponder.py +index a882981..2b46d0e 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", +@@ -83,6 +106,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 +116,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", |