From c97ce12d8d2cff90adefbea0864df38e370d875a Mon Sep 17 00:00:00 2001 From: hschang Date: Mon, 16 Sep 2013 20:42:09 +0900 Subject: [PATCH] support DVB-T2 --- lib/dvb/db.cpp | 30 ++- lib/dvb/frontend.cpp | 471 +++++++++++++++++++++++++++++++---- lib/dvb/frontend.h | 1 + lib/dvb/frontendparms.h | 21 +- lib/python/Components/NimManager.py | 33 ++- lib/python/Components/ServiceScan.py | 26 +- lib/python/Screens/Satconfig.py | 4 +- lib/python/Screens/ScanSetup.py | 141 +++++++++-- lib/python/Screens/ServiceInfo.py | 5 +- lib/python/Tools/Transponder.py | 28 ++- 10 files changed, 657 insertions(+), 103 deletions(-) diff --git a/lib/dvb/db.cpp b/lib/dvb/db.cpp index ea0df97..fb0b66c 100755 --- a/lib/dvb/db.cpp +++ b/lib/dvb/db.cpp @@ -398,8 +398,9 @@ void eDVBDB::loadServicelist(const char *file) } else if (line[1]=='t') { eDVBFrontendParametersTerrestrial ter; - int frequency, bandwidth, code_rate_HP, code_rate_LP, modulation, transmission_mode, guard_interval, hierarchy, inversion, flags=0; - sscanf(line+3, "%d:%d:%d:%d:%d:%d:%d:%d:%d:%d", &frequency, &bandwidth, &code_rate_HP, &code_rate_LP, &modulation, &transmission_mode, &guard_interval, &hierarchy, &inversion, &flags); + int frequency, bandwidth, code_rate_HP, code_rate_LP, modulation, transmission_mode, guard_interval, hierarchy, inversion, flags = 0, plpid = 0; + int system=eDVBFrontendParametersTerrestrial::System_DVB_T; + sscanf(line+3, "%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d", &frequency, &bandwidth, &code_rate_HP, &code_rate_LP, &modulation, &transmission_mode, &guard_interval, &hierarchy, &inversion, &flags, &system, &plpid); ter.frequency = frequency; ter.bandwidth = bandwidth; ter.code_rate_HP = code_rate_HP; @@ -409,6 +410,8 @@ void eDVBDB::loadServicelist(const char *file) ter.guard_interval = guard_interval; ter.hierarchy = hierarchy; ter.inversion = inversion; + ter.system = system; + ter.plpid = plpid; feparm->setDVBT(ter); feparm->setFlags(flags); } else if (line[1]=='c') @@ -532,10 +535,10 @@ void eDVBDB::saveServicelist(const char *file) } else if (!ch.m_frontendParameters->getDVBT(ter)) { - fprintf(f, "\tt %d:%d:%d:%d:%d:%d:%d:%d:%d:%d\n", + fprintf(f, "\tt %d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d\n", ter.frequency, ter.bandwidth, ter.code_rate_HP, ter.code_rate_LP, ter.modulation, ter.transmission_mode, - ter.guard_interval, ter.hierarchy, ter.inversion, flags); + ter.guard_interval, ter.hierarchy, ter.inversion, flags, ter.system, ter.plpid); } else if (!ch.m_frontendParameters->getDVBC(cab)) { @@ -1058,7 +1061,8 @@ PyObject *eDVBDB::readTerrestrials(ePyObject ter_list, ePyObject tp_dict) const Attribute *at; std::string name; int tmp, *dest, - freq, bw, constellation, crh = 5, crl = 5, guard = 4, transm, hierarchy, inv = 2; +// freq, bw, constellation, crh = 5, crl = 5, guard = 4, transm, hierarchy, inv = 2; + freq, bw, constellation, crh, crl, guard, transm, hierarchy, inv, system, plpid; char *end_ptr; const ElementList &root_elements = root->getElementList(); for (ElementConstIterator it(root_elements.begin()); it != root_elements.end(); ++it) @@ -1108,6 +1112,8 @@ PyObject *eDVBDB::readTerrestrials(ePyObject ter_list, ePyObject tp_dict) transm = eDVBFrontendParametersTerrestrial::TransmissionMode_Auto; hierarchy = eDVBFrontendParametersTerrestrial::Hierarchy_Auto; inv = eDVBFrontendParametersTerrestrial::Inversion_Unknown; + system = eDVBFrontendParametersTerrestrial::System_DVB_T; + plpid = 0; for (AttributeConstIterator it(tp_attributes.begin()); it != end; ++it) { // eDebug("\t\tattr: %s", at->name().c_str()); @@ -1123,6 +1129,8 @@ PyObject *eDVBDB::readTerrestrials(ePyObject ter_list, ePyObject tp_dict) else if (name == "transmission_mode") dest = &transm; else if (name == "hierarchy_information") dest = &hierarchy; else if (name == "inversion") dest = &inv; + else if (name == "system") dest = &system; + else if (name == "plp_id") dest = &plpid; else continue; if (dest) { @@ -1133,11 +1141,11 @@ PyObject *eDVBDB::readTerrestrials(ePyObject ter_list, ePyObject tp_dict) } if (freq) { - if (crh > 5) // our terrestrial.xml is buggy... 6 for AUTO - crh = 5; - if (crl > 5) // our terrestrial.xml is buggy... 6 for AUTO - crl = 5; - tuple = PyTuple_New(10); + if (crh > eDVBFrontendParametersTerrestrial::FEC_8_9) + crh = eDVBFrontendParametersTerrestrial::FEC_Auto; + if (crl > eDVBFrontendParametersTerrestrial::FEC_8_9) + crl = eDVBFrontendParametersTerrestrial::FEC_Auto; + tuple = PyTuple_New(12); PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(2)); PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(freq)); PyTuple_SET_ITEM(tuple, 2, PyInt_FromLong(bw)); @@ -1148,6 +1156,8 @@ PyObject *eDVBDB::readTerrestrials(ePyObject ter_list, ePyObject tp_dict) PyTuple_SET_ITEM(tuple, 7, PyInt_FromLong(transm)); PyTuple_SET_ITEM(tuple, 8, PyInt_FromLong(hierarchy)); PyTuple_SET_ITEM(tuple, 9, PyInt_FromLong(inv)); + PyTuple_SET_ITEM(tuple, 10, PyInt_FromLong(system)); + PyTuple_SET_ITEM(tuple, 11, PyInt_FromLong(plpid)); PyList_Append(tplist, tuple); Py_DECREF(tuple); } diff --git a/lib/dvb/frontend.cpp b/lib/dvb/frontend.cpp index e980169..271df72 100644 --- a/lib/dvb/frontend.cpp +++ b/lib/dvb/frontend.cpp @@ -213,27 +213,67 @@ void eDVBFrontendParametersCable::set(const CableDeliverySystemDescriptor &descr void eDVBFrontendParametersTerrestrial::set(const TerrestrialDeliverySystemDescriptor &descriptor) { + /* EN 300 468 V1.11.1 DVB-SI SPEC */ frequency = descriptor.getCentreFrequency() * 10; - bandwidth = descriptor.getBandwidth(); - if ( bandwidth > 2 ) // 5Mhz forced to auto - bandwidth = eDVBFrontendParametersTerrestrial::Bandwidth_Auto; - code_rate_HP = descriptor.getCodeRateHpStream(); - if (code_rate_HP > 4) - code_rate_HP = eDVBFrontendParametersTerrestrial::FEC_Auto; - code_rate_LP = descriptor.getCodeRateLpStream(); - if (code_rate_LP > 4) - code_rate_LP = eDVBFrontendParametersTerrestrial::FEC_Auto; - transmission_mode = descriptor.getTransmissionMode(); - if (transmission_mode > 1) // TM4k forced to auto - transmission_mode = eDVBFrontendParametersTerrestrial::TransmissionMode_Auto; - guard_interval = descriptor.getGuardInterval(); - if (guard_interval > 3) - guard_interval = eDVBFrontendParametersTerrestrial::GuardInterval_Auto; + switch (descriptor.getBandwidth()) + { + case 0: bandwidth = eDVBFrontendParametersTerrestrial::Bandwidth_8MHz; break; + case 1: bandwidth = eDVBFrontendParametersTerrestrial::Bandwidth_7MHz; break; + case 2: bandwidth = eDVBFrontendParametersTerrestrial::Bandwidth_6MHz; break; + case 3: bandwidth = eDVBFrontendParametersTerrestrial::Bandwidth_5MHz; break; + case 4: bandwidth = eDVBFrontendParametersTerrestrial::Bandwidth_10MHz; break; + case 5: bandwidth = eDVBFrontendParametersTerrestrial::Bandwidth_1_712MHz; break; + default: bandwidth = eDVBFrontendParametersTerrestrial::Bandwidth_Auto; break; + } + switch (descriptor.getCodeRateHpStream()) + { + case 0: code_rate_HP = eDVBFrontendParametersTerrestrial::FEC_1_2; break; + case 1: code_rate_HP = eDVBFrontendParametersTerrestrial::FEC_2_3; break; + case 2: code_rate_HP = eDVBFrontendParametersTerrestrial::FEC_3_4; break; + case 3: code_rate_HP = eDVBFrontendParametersTerrestrial::FEC_5_6; break; + case 4: code_rate_HP = eDVBFrontendParametersTerrestrial::FEC_7_8; break; + default: code_rate_HP = eDVBFrontendParametersTerrestrial::FEC_Auto; break; + } + switch (descriptor.getCodeRateLpStream()) + { + case 0: code_rate_LP = eDVBFrontendParametersTerrestrial::FEC_1_2; break; + case 1: code_rate_LP = eDVBFrontendParametersTerrestrial::FEC_2_3; break; + case 2: code_rate_LP = eDVBFrontendParametersTerrestrial::FEC_3_4; break; + case 3: code_rate_LP = eDVBFrontendParametersTerrestrial::FEC_5_6; break; + case 4: code_rate_LP = eDVBFrontendParametersTerrestrial::FEC_7_8; break; + default: code_rate_LP = eDVBFrontendParametersTerrestrial::FEC_Auto; break; + } + switch (descriptor.getTransmissionMode()) + { + case 0: transmission_mode = eDVBFrontendParametersTerrestrial::TransmissionMode_2k; break; + case 1: transmission_mode = eDVBFrontendParametersTerrestrial::TransmissionMode_8k; break; + case 2: transmission_mode = eDVBFrontendParametersTerrestrial::TransmissionMode_4k; break; + case 3: transmission_mode = eDVBFrontendParametersTerrestrial::TransmissionMode_1k; break; + case 4: transmission_mode = eDVBFrontendParametersTerrestrial::TransmissionMode_16k; break; + case 5: transmission_mode = eDVBFrontendParametersTerrestrial::TransmissionMode_32k; break; + default: transmission_mode = eDVBFrontendParametersTerrestrial::TransmissionMode_Auto; break; + } + switch (descriptor.getGuardInterval()) + { + case 0: guard_interval = eDVBFrontendParametersTerrestrial::GuardInterval_1_32; break; + case 1: guard_interval = eDVBFrontendParametersTerrestrial::GuardInterval_1_16; break; + case 2: guard_interval = eDVBFrontendParametersTerrestrial::GuardInterval_1_8; break; + case 3: guard_interval = eDVBFrontendParametersTerrestrial::GuardInterval_1_4; break; + case 4: guard_interval = eDVBFrontendParametersTerrestrial::GuardInterval_1_128; break; + case 5: guard_interval = eDVBFrontendParametersTerrestrial::GuardInterval_19_128; break; + case 6: guard_interval = eDVBFrontendParametersTerrestrial::GuardInterval_19_256; break; + default: guard_interval = eDVBFrontendParametersTerrestrial::GuardInterval_Auto; break; + } +// hierarchy = descriptor.getHierarchyInformation(); hierarchy = descriptor.getHierarchyInformation()&3; + if (hierarchy > eDVBFrontendParametersTerrestrial::Hierarchy_4) + hierarchy = eDVBFrontendParametersTerrestrial::Hierarchy_Auto; modulation = descriptor.getConstellation(); - if (modulation > 2) + if (modulation > eDVBFrontendParametersTerrestrial::Modulation_QAM64) modulation = eDVBFrontendParametersTerrestrial::Modulation_Auto; inversion = eDVBFrontendParametersTerrestrial::Inversion_Unknown; + system = eDVBFrontendParametersTerrestrial::System_DVB_T; + plpid = 0; eDebug("Terr freq %d, bw %d, cr_hp %d, cr_lp %d, tm_mode %d, guard %d, hierarchy %d, const %d", frequency, bandwidth, code_rate_HP, code_rate_LP, transmission_mode, guard_interval, hierarchy, modulation); @@ -455,7 +495,7 @@ int eDVBFrontend::PriorityOrder=0; eDVBFrontend::eDVBFrontend(int adap, int fe, int &ok, bool simulate, eDVBFrontend *simulate_fe) :m_simulate(simulate), m_enabled(false), m_type(-1), m_simulate_fe(simulate_fe), m_dvbid(fe), m_slotid(fe) - ,m_fd(-1), m_rotor_mode(false), m_need_rotor_workaround(false), m_can_handle_dvbs2(false) + ,m_fd(-1), m_rotor_mode(false), m_need_rotor_workaround(false), m_can_handle_dvbs2(false), m_can_handle_dvbt2(false) ,m_state(stateClosed), m_timeout(0), m_tuneTimer(0) #if HAVE_DVB_API_VERSION < 3 ,m_secfd(-1) @@ -1055,6 +1095,8 @@ void PutTerrestrialDataToDict(ePyObject &dict, eDVBFrontendParametersTerrestrial PutToDict(dict, "guard_interval", feparm.guard_interval); PutToDict(dict, "hierarchy_information", feparm.hierarchy); PutToDict(dict, "inversion", feparm.inversion); + PutToDict(dict, "system", feparm.system); + PutToDict(dict, "plp_id", feparm.plpid); } void PutCableDataToDict(ePyObject &dict, eDVBFrontendParametersCable &feparm) @@ -1131,7 +1173,174 @@ static void fillDictWithSatelliteData(ePyObject dict, const FRONTENDPARAMETERS & PutToDict(dict, "modulation", tmp); } -#else +static void fillDictWithCableData(ePyObject dict, struct dtv_property *p) +{ + long tmp = 0; +// frequency + tmp = p[1].u.data/1000; + PutToDict(dict, "frequency", tmp); +// sysbolrate + PutToDict(dict, "symbol_rate", p[2].u.data); +// inner fec + switch (p[3].u.data) + { + case FEC_NONE: tmp = eDVBFrontendParametersCable::FEC_None; + case FEC_1_2: tmp = eDVBFrontendParametersCable::FEC_1_2; + case FEC_2_3: tmp = eDVBFrontendParametersCable::FEC_2_3; + case FEC_3_4: tmp = eDVBFrontendParametersCable::FEC_3_4; + case FEC_5_6: tmp = eDVBFrontendParametersCable::FEC_5_6; + case FEC_7_8: tmp = eDVBFrontendParametersCable::FEC_7_8; + case FEC_8_9: tmp = eDVBFrontendParametersCable::FEC_8_9; + default: + case FEC_AUTO: tmp = eDVBFrontendParametersCable::FEC_Auto; + } + PutToDict(dict, "fec_inner", tmp); +// modulation + switch (p[4].u.data) + { + case QAM_16: tmp = eDVBFrontendParametersCable::Modulation_QAM16; + case QAM_32: tmp = eDVBFrontendParametersCable::Modulation_QAM32; + case QAM_64: tmp = eDVBFrontendParametersCable::Modulation_QAM64; + case QAM_128: tmp = eDVBFrontendParametersCable::Modulation_QAM128; + case QAM_256: tmp = eDVBFrontendParametersCable::Modulation_QAM256; + default: + case QAM_AUTO: tmp = eDVBFrontendParametersCable::Modulation_Auto; + } + PutToDict(dict, "modulation", tmp); +// inversion + switch (p[5].u.data) + { + case INVERSION_OFF: tmp = eDVBFrontendParametersTerrestrial::Inversion_Off; + case INVERSION_ON: tmp = eDVBFrontendParametersTerrestrial::Inversion_On; + default: + case INVERSION_AUTO: tmp = eDVBFrontendParametersTerrestrial::Inversion_Unknown; + } + PutToDict(dict, "inversion", tmp); +} + +static void fillDictWithTerrestrialData(ePyObject dict, struct dtv_property *p) +{ + long tmp =0; +// system + switch (p[0].u.data) + { + default: + case SYS_DVBT: tmp = eDVBFrontendParametersTerrestrial::System_DVB_T; + case SYS_DVBT2: tmp = eDVBFrontendParametersTerrestrial::System_DVB_T2; + } + PutToDict(dict, "system", tmp); +// frequency + tmp = p[1].u.data/1000; + PutToDict(dict, "frequency", tmp); +// bandwidth + switch (p[2].u.data) + { + case 8000000: tmp = eDVBFrontendParametersTerrestrial::Bandwidth_8MHz; break; + case 7000000: tmp = eDVBFrontendParametersTerrestrial::Bandwidth_7MHz; break; + case 6000000: tmp = eDVBFrontendParametersTerrestrial::Bandwidth_6MHz; break; + case 5000000: tmp = eDVBFrontendParametersTerrestrial::Bandwidth_5MHz; break; + case 10000000: tmp = eDVBFrontendParametersTerrestrial::Bandwidth_10MHz; break; + case 1712000: tmp = eDVBFrontendParametersTerrestrial::Bandwidth_1_712MHz; break; + default: + case BANDWIDTH_AUTO: tmp = eDVBFrontendParametersTerrestrial::Bandwidth_Auto; break; + } + PutToDict(dict, "bandwidth", tmp); +// code rate LP + switch (p[3].u.data) + { + case FEC_1_2: tmp = eDVBFrontendParametersTerrestrial::FEC_1_2; break; + case FEC_2_3: tmp = eDVBFrontendParametersTerrestrial::FEC_2_3; break; + case FEC_3_4: tmp = eDVBFrontendParametersTerrestrial::FEC_3_4; break; + case FEC_4_5: tmp = eDVBFrontendParametersTerrestrial::FEC_4_5; break; + case FEC_5_6: tmp = eDVBFrontendParametersTerrestrial::FEC_5_6; break; + case FEC_6_7: tmp = eDVBFrontendParametersTerrestrial::FEC_6_7; break; + case FEC_7_8: tmp = eDVBFrontendParametersTerrestrial::FEC_7_8; break; + case FEC_8_9: tmp = eDVBFrontendParametersTerrestrial::FEC_8_9; break; + default: + case FEC_AUTO: tmp = eDVBFrontendParametersTerrestrial::FEC_Auto; break; + } + PutToDict(dict, "code_rate_lp", tmp); +// code rate HP + switch (p[4].u.data) + { + case FEC_1_2: tmp = eDVBFrontendParametersTerrestrial::FEC_1_2; break; + case FEC_2_3: tmp = eDVBFrontendParametersTerrestrial::FEC_2_3; break; + case FEC_3_4: tmp = eDVBFrontendParametersTerrestrial::FEC_3_4; break; + case FEC_4_5: tmp = eDVBFrontendParametersTerrestrial::FEC_4_5; break; + case FEC_5_6: tmp = eDVBFrontendParametersTerrestrial::FEC_5_6; break; + case FEC_6_7: tmp = eDVBFrontendParametersTerrestrial::FEC_6_7; break; + case FEC_7_8: tmp = eDVBFrontendParametersTerrestrial::FEC_7_8; break; + case FEC_8_9: tmp = eDVBFrontendParametersTerrestrial::FEC_8_9; break; + default: + case FEC_AUTO: tmp = eDVBFrontendParametersTerrestrial::FEC_Auto; break; + } + PutToDict(dict, "code_rate_hp", tmp); +// constellation + switch (p[5].u.data) + { + case QPSK: tmp = eDVBFrontendParametersTerrestrial::Modulation_QPSK; break; + case QAM_16: tmp = eDVBFrontendParametersTerrestrial::Modulation_QAM16; break; + case QAM_64: tmp = eDVBFrontendParametersTerrestrial::Modulation_QAM64; break; + case QAM_256: tmp = eDVBFrontendParametersTerrestrial::Modulation_QAM256; break; + default: + case QAM_AUTO: tmp = eDVBFrontendParametersTerrestrial::Modulation_Auto; break; + } + PutToDict(dict, "constellation", tmp); + +// transmission + switch (p[6].u.data) + { + case TRANSMISSION_MODE_1K: tmp = eDVBFrontendParametersTerrestrial::TransmissionMode_1k; break; + case TRANSMISSION_MODE_2K: tmp = eDVBFrontendParametersTerrestrial::TransmissionMode_2k; break; + case TRANSMISSION_MODE_4K: tmp = eDVBFrontendParametersTerrestrial::TransmissionMode_4k; break; + case TRANSMISSION_MODE_8K: tmp = eDVBFrontendParametersTerrestrial::TransmissionMode_8k; break; + case TRANSMISSION_MODE_16K: tmp = eDVBFrontendParametersTerrestrial::TransmissionMode_16k; break; + case TRANSMISSION_MODE_32K: tmp = eDVBFrontendParametersTerrestrial::TransmissionMode_32k; break; + default: + case TRANSMISSION_MODE_AUTO: tmp = eDVBFrontendParametersTerrestrial::TransmissionMode_Auto; break; + } + PutToDict(dict, "transmission_mode", tmp); +// guard interval + switch (p[7].u.data) + { + case GUARD_INTERVAL_19_256: tmp = eDVBFrontendParametersTerrestrial::GuardInterval_19_256; break; + case GUARD_INTERVAL_19_128: tmp = eDVBFrontendParametersTerrestrial::GuardInterval_19_128; break; + case GUARD_INTERVAL_1_128: tmp = eDVBFrontendParametersTerrestrial::GuardInterval_1_128; break; + case GUARD_INTERVAL_1_32: tmp = eDVBFrontendParametersTerrestrial::GuardInterval_1_32; break; + case GUARD_INTERVAL_1_16: tmp = eDVBFrontendParametersTerrestrial::GuardInterval_1_16; break; + case GUARD_INTERVAL_1_8: tmp = eDVBFrontendParametersTerrestrial::GuardInterval_1_8; break; + case GUARD_INTERVAL_1_4: tmp = eDVBFrontendParametersTerrestrial::GuardInterval_1_4; break; + default: + case GUARD_INTERVAL_AUTO: tmp = eDVBFrontendParametersTerrestrial::GuardInterval_Auto; break; + } + PutToDict(dict, "guard_interval", tmp); +// hierarchy + switch (p[8].u.data) + { + case HIERARCHY_NONE: tmp = eDVBFrontendParametersTerrestrial::Hierarchy_None; break; + case HIERARCHY_1: tmp = eDVBFrontendParametersTerrestrial::Hierarchy_1; break; + case HIERARCHY_2: tmp = eDVBFrontendParametersTerrestrial::Hierarchy_2; break; + case HIERARCHY_4: tmp = eDVBFrontendParametersTerrestrial::Hierarchy_4; break; + default: + case HIERARCHY_AUTO: tmp = eDVBFrontendParametersTerrestrial::Hierarchy_Auto; break; + } + PutToDict(dict, "hierarchy_information", tmp); +// inversion + switch (p[9].u.data) + { + case INVERSION_OFF: tmp = eDVBFrontendParametersTerrestrial::Inversion_Off; + case INVERSION_ON: tmp = eDVBFrontendParametersTerrestrial::Inversion_On; + default: + case INVERSION_AUTO: tmp = eDVBFrontendParametersTerrestrial::Inversion_Unknown; + } + PutToDict(dict, "inversion", tmp); +#ifdef DTV_DVBT2_PLP_ID + tmp = p[10].u.data; + PutToDict(dict, "plp_id", tmp); +#endif +} + +#else // #if HAVE_DVB_API_VERSION >= 5 static void fillDictWithSatelliteData(ePyObject dict, const FRONTENDPARAMETERS &parm, long freq_offset, int orb_pos, int polarization) { long tmp=0; @@ -1205,7 +1414,6 @@ static void fillDictWithSatelliteData(ePyObject dict, const FRONTENDPARAMETERS & #endif PutToDict(dict, "system", tmp); } -#endif static void fillDictWithCableData(ePyObject dict, const FRONTENDPARAMETERS &parm) { @@ -1318,6 +1526,8 @@ static void fillDictWithTerrestrialData(ePyObject dict, const FRONTENDPARAMETERS PutToDict(dict, "hierarchy_information", tmp); } +#endif // #if HAVE_DVB_API_VERSION >= 5 + void eDVBFrontend::getFrontendStatus(ePyObject dest) { if (dest && PyDict_Check(dest)) @@ -1365,32 +1575,66 @@ void eDVBFrontend::getTransponderData(ePyObject dest, bool original) { if (dest && PyDict_Check(dest)) { - FRONTENDPARAMETERS front; -#if HAVE_DVB_API_VERSION >= 5 - struct dtv_property p[4]; + struct dtv_property p[16]; struct dtv_properties cmdseq; cmdseq.props = p; - cmdseq.num = 4; - p[0].cmd = DTV_DELIVERY_SYSTEM; - p[1].cmd = DTV_MODULATION; - p[2].cmd = DTV_ROLLOFF; - p[3].cmd = DTV_PILOT; -#endif + cmdseq.num = 0; + FRONTENDPARAMETERS front; if (m_simulate || m_fd == -1 || original) original = true; #if HAVE_DVB_API_VERSION >= 5 - else if (m_type == feSatellite && // yet just use new api for DVB-S(2) only - ioctl(m_fd, FE_GET_PROPERTY, &cmdseq)<0) + else { - eDebug("FE_GET_PROPERTY failed (%m)"); - original = true; - } + switch(m_type) + { + case feSatellite: + p[0].cmd = DTV_DELIVERY_SYSTEM; + p[1].cmd = DTV_MODULATION; + p[2].cmd = DTV_ROLLOFF; + p[3].cmd = DTV_PILOT; + cmdseq.num = 4; + break; + case feCable: + p[0].cmd = DTV_DELIVERY_SYSTEM; + p[1].cmd = DTV_FREQUENCY; + p[2].cmd = DTV_SYMBOL_RATE; + p[3].cmd = DTV_INNER_FEC; + p[4].cmd = DTV_MODULATION; + p[5].cmd = DTV_INVERSION; + cmdseq.num = 6; + break; + case feTerrestrial: + p[0].cmd = DTV_DELIVERY_SYSTEM; + p[1].cmd = DTV_FREQUENCY; + p[2].cmd = DTV_BANDWIDTH_HZ; + p[3].cmd = DTV_CODE_RATE_LP; + p[4].cmd = DTV_CODE_RATE_HP; + p[5].cmd = DTV_MODULATION; + p[6].cmd = DTV_TRANSMISSION_MODE; + p[7].cmd = DTV_GUARD_INTERVAL; + p[8].cmd = DTV_HIERARCHY; + p[9].cmd = DTV_INVERSION; +#ifdef DTV_DVBT2_PLP_ID + p[10].cmd = DTV_DVBT2_PLP_ID; + cmdseq.num = 11; +#else + cmdseq.num = 10; #endif + break; + } + if (ioctl(m_fd, FE_GET_PROPERTY, &cmdseq)<0) + { + eDebug("FE_GET_PROPERTY failed (%m)"); + original = true; + } + } +#else else if (ioctl(m_fd, FE_GET_FRONTEND, &front)<0) { eDebug("FE_GET_FRONTEND failed (%m)"); original = true; } +#endif if (original) { switch(m_type) @@ -1423,12 +1667,18 @@ void eDVBFrontend::getTransponderData(ePyObject dest, bool original) PutToDict(dest, "inversion", tmp); switch(m_type) { - case feSatellite: #if HAVE_DVB_API_VERSION >= 5 + case feSatellite: fillDictWithSatelliteData(dest, parm, p, m_data[FREQ_OFFSET], oparm.sat.orbital_position, oparm.sat.polarisation); + case feCable: + fillDictWithCableData(dest, p); + break; + case feTerrestrial: + fillDictWithTerrestrialData(dest, p); + break; #else + case feSatellite: fillDictWithSatelliteData(dest, parm, m_data[FREQ_OFFSET], oparm.sat.orbital_position, oparm.sat.polarisation); -#endif break; case feCable: fillDictWithCableData(dest, parm); @@ -1436,6 +1686,7 @@ void eDVBFrontend::getTransponderData(ePyObject dest, bool original) case feTerrestrial: fillDictWithTerrestrialData(dest, parm); break; +#endif } } } @@ -1980,6 +2231,71 @@ void eDVBFrontend::setFrontend(bool recvEvents) return; } } + else if (m_type == iDVBFrontend::feCable) + { + struct dtv_property p[7]; + struct dtv_properties cmdseq; + cmdseq.props = p; + p[0].cmd = DTV_CLEAR; + p[1].cmd = DTV_FREQUENCY, p[1].u.data = parm_frequency; + p[2].cmd = DTV_MODULATION, p[2].u.data = parm_u_qam_modulation; + p[3].cmd = DTV_SYMBOL_RATE, p[3].u.data = parm_u_qam_symbol_rate; + p[4].cmd = DTV_INNER_FEC, p[4].u.data = parm_u_qam_fec_inner; + p[5].cmd = DTV_INVERSION, p[5].u.data = parm_inversion; + p[6].cmd = DTV_TUNE; + cmdseq.num = 7; + if (ioctl(m_fd, FE_SET_PROPERTY, &cmdseq) == -1) + { + perror("FE_SET_PROPERTY failed"); + return; + } + } + else if (m_type == iDVBFrontend::feTerrestrial) + { + fe_delivery_system_t system = SYS_DVBT; + switch (oparm.ter.system) + { + default: + case eDVBFrontendParametersTerrestrial::System_DVB_T: system = SYS_DVBT; break; + case eDVBFrontendParametersTerrestrial::System_DVB_T2: system = SYS_DVBT2; break; + } + int bandwidth = 0; + switch (oparm.ter.bandwidth) + { + case eDVBFrontendParametersTerrestrial::Bandwidth_8MHz: bandwidth = 8000000; break; + case eDVBFrontendParametersTerrestrial::Bandwidth_7MHz: bandwidth = 7000000; break; + case eDVBFrontendParametersTerrestrial::Bandwidth_6MHz: bandwidth = 6000000; break; + default: + case eDVBFrontendParametersTerrestrial::Bandwidth_Auto: bandwidth = 0; break; + case eDVBFrontendParametersTerrestrial::Bandwidth_5MHz: bandwidth = 5000000; break; + case eDVBFrontendParametersTerrestrial::Bandwidth_10MHz: bandwidth = 10000000; break; + case eDVBFrontendParametersTerrestrial::Bandwidth_1_712MHz: bandwidth = 1712000; break; + } + struct dtv_property p[13]; + struct dtv_properties cmdseq; + cmdseq.props = p; + cmdseq.num = 0; + p[cmdseq.num].cmd = DTV_CLEAR, cmdseq.num++; + p[cmdseq.num].cmd = DTV_DELIVERY_SYSTEM, p[cmdseq.num].u.data = system, cmdseq.num++; + p[cmdseq.num].cmd = DTV_FREQUENCY, p[cmdseq.num].u.data = parm_frequency, cmdseq.num++; + p[cmdseq.num].cmd = DTV_CODE_RATE_LP, p[cmdseq.num].u.data = parm_u_ofdm_code_rate_LP, cmdseq.num++; + p[cmdseq.num].cmd = DTV_CODE_RATE_HP, p[cmdseq.num].u.data = parm_u_ofdm_code_rate_HP, cmdseq.num++; + p[cmdseq.num].cmd = DTV_MODULATION, p[cmdseq.num].u.data = parm_u_ofdm_constellation, cmdseq.num++; + p[cmdseq.num].cmd = DTV_TRANSMISSION_MODE, p[cmdseq.num].u.data = parm_u_ofdm_transmission_mode, cmdseq.num++; + p[cmdseq.num].cmd = DTV_GUARD_INTERVAL, p[cmdseq.num].u.data = parm_u_ofdm_guard_interval, cmdseq.num++; + p[cmdseq.num].cmd = DTV_HIERARCHY, p[cmdseq.num].u.data = parm_u_ofdm_hierarchy_information, cmdseq.num++; + p[cmdseq.num].cmd = DTV_BANDWIDTH_HZ, p[cmdseq.num].u.data = bandwidth, cmdseq.num++; + p[cmdseq.num].cmd = DTV_INVERSION, p[cmdseq.num].u.data = parm_inversion, cmdseq.num++; + p[cmdseq.num].cmd = DTV_TUNE, cmdseq.num++; +#ifdef DTV_DVBT2_PLP_ID + p[cmdseq.num].cmd = DTV_DVBT2_PLP_ID , p[cmdseq.num].u.data = oparm.ter.plpid, cmdseq.num++; +#endif + if (ioctl(m_fd, FE_SET_PROPERTY, &cmdseq) == -1) + { + perror("FE_SET_PROPERTY failed"); + return; + } + } else #endif { @@ -2234,6 +2550,15 @@ RESULT eDVBFrontend::prepare_terrestrial(const eDVBFrontendParametersTerrestrial case eDVBFrontendParametersTerrestrial::Bandwidth_6MHz: parm_u_ofdm_bandwidth = BANDWIDTH_6_MHZ; break; + case eDVBFrontendParametersTerrestrial::Bandwidth_5MHz: + parm_u_ofdm_bandwidth = BANDWIDTH_5_MHZ; + break; + case eDVBFrontendParametersTerrestrial::Bandwidth_10MHz: + parm_u_ofdm_bandwidth = BANDWIDTH_10_MHZ; + break; + case eDVBFrontendParametersTerrestrial::Bandwidth_1_712MHz: + parm_u_ofdm_bandwidth = BANDWIDTH_1_712_MHZ; + break; default: case eDVBFrontendParametersTerrestrial::Bandwidth_Auto: parm_u_ofdm_bandwidth = BANDWIDTH_AUTO; @@ -2256,6 +2581,12 @@ RESULT eDVBFrontend::prepare_terrestrial(const eDVBFrontendParametersTerrestrial case eDVBFrontendParametersTerrestrial::FEC_7_8: parm_u_ofdm_code_rate_LP = FEC_7_8; break; + case eDVBFrontendParametersTerrestrial::FEC_6_7: + parm_u_ofdm_code_rate_LP = FEC_6_7; + break; + case eDVBFrontendParametersTerrestrial::FEC_8_9: + parm_u_ofdm_code_rate_LP = FEC_8_9; + break; default: case eDVBFrontendParametersTerrestrial::FEC_Auto: parm_u_ofdm_code_rate_LP = FEC_AUTO; @@ -2278,6 +2609,12 @@ RESULT eDVBFrontend::prepare_terrestrial(const eDVBFrontendParametersTerrestrial case eDVBFrontendParametersTerrestrial::FEC_7_8: parm_u_ofdm_code_rate_HP = FEC_7_8; break; + case eDVBFrontendParametersTerrestrial::FEC_6_7: + parm_u_ofdm_code_rate_HP = FEC_6_7; + break; + case eDVBFrontendParametersTerrestrial::FEC_8_9: + parm_u_ofdm_code_rate_HP = FEC_8_9; + break; default: case eDVBFrontendParametersTerrestrial::FEC_Auto: parm_u_ofdm_code_rate_HP = FEC_AUTO; @@ -2294,6 +2631,9 @@ RESULT eDVBFrontend::prepare_terrestrial(const eDVBFrontendParametersTerrestrial case eDVBFrontendParametersTerrestrial::Modulation_QAM64: parm_u_ofdm_constellation = QAM_64; break; + case eDVBFrontendParametersTerrestrial::Modulation_QAM256: + parm_u_ofdm_constellation = QAM_256; + break; default: case eDVBFrontendParametersTerrestrial::Modulation_Auto: parm_u_ofdm_constellation = QAM_AUTO; @@ -2307,6 +2647,18 @@ RESULT eDVBFrontend::prepare_terrestrial(const eDVBFrontendParametersTerrestrial case eDVBFrontendParametersTerrestrial::TransmissionMode_8k: parm_u_ofdm_transmission_mode = TRANSMISSION_MODE_8K; break; + case eDVBFrontendParametersTerrestrial::TransmissionMode_4k: + parm_u_ofdm_transmission_mode = TRANSMISSION_MODE_4K; + break; + case eDVBFrontendParametersTerrestrial::TransmissionMode_1k: + parm_u_ofdm_transmission_mode = TRANSMISSION_MODE_1K; + break; + case eDVBFrontendParametersTerrestrial::TransmissionMode_16k: + parm_u_ofdm_transmission_mode = TRANSMISSION_MODE_16K; + break; + case eDVBFrontendParametersTerrestrial::TransmissionMode_32k: + parm_u_ofdm_transmission_mode = TRANSMISSION_MODE_32K; + break; default: case eDVBFrontendParametersTerrestrial::TransmissionMode_Auto: parm_u_ofdm_transmission_mode = TRANSMISSION_MODE_AUTO; @@ -2326,6 +2678,15 @@ RESULT eDVBFrontend::prepare_terrestrial(const eDVBFrontendParametersTerrestrial case eDVBFrontendParametersTerrestrial::GuardInterval_1_4: parm_u_ofdm_guard_interval = GUARD_INTERVAL_1_4; break; + case eDVBFrontendParametersTerrestrial::GuardInterval_1_128: + parm_u_ofdm_guard_interval = GUARD_INTERVAL_1_128; + break; + case eDVBFrontendParametersTerrestrial::GuardInterval_19_128: + parm_u_ofdm_guard_interval = GUARD_INTERVAL_19_128; + break; + case eDVBFrontendParametersTerrestrial::GuardInterval_19_256: + parm_u_ofdm_guard_interval = GUARD_INTERVAL_19_256; + break; default: case eDVBFrontendParametersTerrestrial::GuardInterval_Auto: parm_u_ofdm_guard_interval = GUARD_INTERVAL_AUTO; @@ -2363,6 +2724,16 @@ RESULT eDVBFrontend::prepare_terrestrial(const eDVBFrontendParametersTerrestrial parm_inversion = INVERSION_AUTO; break; } + eDebug("tuning to %d khz, bandwidth %d, crl %d, crh %d, modulation %d, tm %d, guard %d, hierarchy %d, inversion %d", + parm_frequency/1000, + parm_u_ofdm_bandwidth, + parm_u_ofdm_code_rate_LP, + parm_u_ofdm_code_rate_HP, + parm_u_ofdm_constellation, + parm_u_ofdm_transmission_mode, + parm_u_ofdm_guard_interval, + parm_u_ofdm_hierarchy_information, + parm_inversion); oparm.ter = feparm; return 0; } @@ -2697,22 +3068,37 @@ int eDVBFrontend::isCompatibleWith(ePtr &feparm) else if (m_type == eDVBFrontend::feCable) return 2; // more prio for cable frontends else if (m_type == eDVBFrontend::feTerrestrial) - return 1; + { + eDVBFrontendParametersTerrestrial ter_parm; + if ( feparm->getDVBT(ter_parm) ) + { + return 0; + } + if (ter_parm.system == eDVBFrontendParametersTerrestrial::System_DVB_T2) + { + return m_can_handle_dvbt2 ? 1 : 0; + } + else // DVB-T + { + return m_can_handle_dvbt2 ? 1 : 2; + } + } return 0; } bool eDVBFrontend::setSlotInfo(ePyObject obj) { - ePyObject Id, Descr, Enabled, IsDVBS2, frontendId; - if (!PyTuple_Check(obj) || PyTuple_Size(obj) != 5) + ePyObject Id, Descr, Enabled, IsDVBS2, IsDVBT2, frontendId; + if (!PyTuple_Check(obj) || PyTuple_Size(obj) != 6) 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); - frontendId = PyTuple_GET_ITEM(obj, 4); + IsDVBT2 = PyTuple_GET_ITEM(obj, 4); + frontendId = PyTuple_GET_ITEM(obj, 5); m_slotid = PyInt_AsLong(Id); - if (!PyInt_Check(Id) || !PyString_Check(Descr) || !PyBool_Check(Enabled) || !PyBool_Check(IsDVBS2) || !PyInt_Check(frontendId)) + if (!PyInt_Check(Id) || !PyString_Check(Descr) || !PyBool_Check(Enabled) || !PyBool_Check(IsDVBS2) || !PyBool_Check(IsDVBT2) || !PyInt_Check(frontendId)) goto arg_error; strcpy(m_description, PyString_AS_STRING(Descr)); if (PyInt_AsLong(frontendId) == -1 || PyInt_AsLong(frontendId) != m_dvbid) { @@ -2727,8 +3113,9 @@ bool eDVBFrontend::setSlotInfo(ePyObject obj) !!strstr(m_description, "Alps -S") || !!strstr(m_description, "BCM4501"); m_can_handle_dvbs2 = IsDVBS2 == Py_True; - eDebugNoSimulate("setSlotInfo for dvb frontend %d to slotid %d, descr %s, need rotorworkaround %s, enabled %s, DVB-S2 %s", - m_dvbid, m_slotid, m_description, m_need_rotor_workaround ? "Yes" : "No", m_enabled ? "Yes" : "No", m_can_handle_dvbs2 ? "Yes" : "No" ); + m_can_handle_dvbt2 = IsDVBT2 == Py_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", m_enabled ? "Yes" : "No", m_can_handle_dvbs2 ? "Yes" : "No", m_can_handle_dvbt2 ? "Yes" : "No" ); return true; arg_error: PyErr_SetString(PyExc_StandardError, diff --git a/lib/dvb/frontend.h b/lib/dvb/frontend.h index 5887f40..da7be52 100644 --- a/lib/dvb/frontend.h +++ b/lib/dvb/frontend.h @@ -79,6 +79,7 @@ private: bool m_rotor_mode; bool m_need_rotor_workaround; bool m_can_handle_dvbs2; + bool m_can_handle_dvbt2; char m_filename[128]; char m_description[128]; #if HAVE_DVB_API_VERSION < 3 diff --git a/lib/dvb/frontendparms.h b/lib/dvb/frontendparms.h index b537963..0bae247 100644 --- a/lib/dvb/frontendparms.h +++ b/lib/dvb/frontendparms.h @@ -74,20 +74,21 @@ struct eDVBFrontendParametersTerrestrial #ifndef SWIG void set(const TerrestrialDeliverySystemDescriptor &); #endif + enum { - Bandwidth_8MHz, Bandwidth_7MHz, Bandwidth_6MHz, /*Bandwidth_5MHz,*/ Bandwidth_Auto - }; // Bw5Mhz nyi (compatibilty with enigma1) + Bandwidth_8MHz, Bandwidth_7MHz, Bandwidth_6MHz, Bandwidth_Auto, Bandwidth_5MHz, Bandwidth_10MHz, Bandwidth_1_712MHz + }; enum { - FEC_1_2, FEC_2_3, FEC_3_4, FEC_5_6, FEC_7_8, FEC_Auto + FEC_1_2, FEC_2_3, FEC_3_4, FEC_4_5, FEC_5_6, FEC_7_8, FEC_Auto, FEC_6_7, FEC_8_9 }; enum { - TransmissionMode_2k, TransmissionMode_8k, /*TransmissionMode_4k,*/ TransmissionMode_Auto - }; // TM4k nyi (compatibility with enigma1) + TransmissionMode_2k, TransmissionMode_8k, TransmissionMode_Auto, TransmissionMode_4k, TransmissionMode_1k, TransmissionMode_16k, TransmissionMode_32k + }; enum { - GuardInterval_1_32, GuardInterval_1_16, GuardInterval_1_8, GuardInterval_1_4, GuardInterval_Auto + GuardInterval_1_32, GuardInterval_1_16, GuardInterval_1_8, GuardInterval_1_4, GuardInterval_Auto, GuardInterval_1_128, GuardInterval_19_128, GuardInterval_19_256 }; enum { @@ -95,13 +96,17 @@ struct eDVBFrontendParametersTerrestrial }; enum { - Modulation_QPSK, Modulation_QAM16, Modulation_QAM64, Modulation_Auto + Modulation_QPSK, Modulation_QAM16, Modulation_QAM64, Modulation_Auto, Modulation_QAM256 }; enum { Inversion_Off, Inversion_On, Inversion_Unknown }; + enum { + System_DVB_T, System_DVB_T2 + }; + unsigned int frequency; int bandwidth; int code_rate_HP, code_rate_LP; @@ -110,6 +115,8 @@ struct eDVBFrontendParametersTerrestrial int guard_interval; int hierarchy; int inversion; + int system; + int plpid; }; SWIG_ALLOW_OUTPUT_SIMPLE(eDVBFrontendParametersTerrestrial); diff --git a/lib/python/Components/NimManager.py b/lib/python/Components/NimManager.py index 65f56e7..4b7ef8e 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.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.frontend_id is None and -1 or slot.frontend_id)) eDVBResourceManager.getInstance().setFrontendSlotInformations(used_nim_slots) for slot in nim_slots: @@ -488,7 +488,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", None): + if type not in ("DVB-S", "DVB-C", "DVB-T", "DVB-S2", "DVB-T2", None): print "warning: unknown NIM type %s, not using." % type type = None @@ -509,7 +509,8 @@ class NIM(object): "DVB-S": ("DVB-S", None), "DVB-C": ("DVB-C", None), "DVB-T": ("DVB-T", None), - "DVB-S2": ("DVB-S", "DVB-S2", None) + "DVB-S2": ("DVB-S", "DVB-S2", None), + "DVB-T2": ("DVB-T", "DVB-T2", None) } return what in compatible[self.type] @@ -521,7 +522,8 @@ class NIM(object): "DVB-S": ("DVB-S", "DVB-S2"), "DVB-C": ("DVB-C",), "DVB-T": ("DVB-T",), - "DVB-S2": ("DVB-S", "DVB-S2") + "DVB-S2": ("DVB-S", "DVB-S2"), + "DVB-T2": ("DVB-T", "DVB-T2",) } return connectable[self.type] @@ -575,8 +577,9 @@ class NIM(object): return { "DVB-S": "DVB-S", "DVB-T": "DVB-T", - "DVB-S2": "DVB-S2", "DVB-C": "DVB-C", + "DVB-S2": "DVB-S2", + "DVB-T2": "DVB-T2", None: _("empty") }[self.type] @@ -841,6 +844,8 @@ class NimManager: type = self.getNimType(slotid) if type == "DVB-S2": type = "DVB-S" + elif type == "DVB-T2": + type = "DVB-T" nimList = self.getNimListOfType(type, slotid) for nim in nimList[:]: mode = self.getNimConfig(nim) @@ -852,6 +857,8 @@ class NimManager: type = self.getNimType(slotid) if type == "DVB-S2": type = "DVB-S" + elif type == "DVB-T2": + type = "DVB-T" nimList = self.getNimListOfType(type, slotid) positionerList = [] for nim in nimList[:]: @@ -906,7 +913,7 @@ class NimManager: nim = config.Nims[slotid] configMode = nim.configMode.value - if self.nim_slots[slotid].isCompatible("DVB-S") or self.nim_slots[slotid].isCompatible("DVB-T") or self.nim_slots[slotid].isCompatible("DVB-C"): + if self.nim_slots[slotid].isCompatible("DVB-S") or self.nim_slots[slotid].isCompatible("DVB-T") or self.nim_slots[slotid].isCompatible("DVB-C") or self.nim_slots[slotid].isCompatible("DVB-T2"): return not (configMode == "nothing") def getSatListForNim(self, slotid): @@ -1507,6 +1514,20 @@ def InitNimManager(nimmgr): n += 1 nim.terrestrial = ConfigSelection(choices = list) nim.terrestrial_5V = ConfigOnOff() + elif slot.isCompatible("DVB-T2"): + nim.configMode = ConfigSelection( + choices = { + "enabled": _("enabled"), + "nothing": _("nothing connected"), + }, + default = "enabled") + list = [] + n = 0 + for x in nimmgr.terrestrialsList: + list.append((str(n), x[0])) + n += 1 + nim.terrestrial = ConfigSelection(choices = list) + nim.terrestrial_5V = ConfigOnOff() else: empty_slots += 1 nim.configMode = ConfigSelection(choices = { "nothing": _("disabled") }, default="nothing"); diff --git a/lib/python/Components/ServiceScan.py b/lib/python/Components/ServiceScan.py index 78cd758..0ca69cf 100644 --- a/lib/python/Components/ServiceScan.py +++ b/lib/python/Components/ServiceScan.py @@ -80,12 +80,28 @@ class ServiceScan: elif tp_type == iDVBFrontend.feTerrestrial: network = _("Terrestrial") tp = transponder.getDVBT() - tp_text = ("DVB-T %s %d %s") %( { tp.Modulation_QPSK : "QPSK", - tp.Modulation_QAM16 : "QAM16", tp.Modulation_QAM64 : "QAM64", - tp.Modulation_Auto : "AUTO" }.get(tp.modulation, tp.Modulation_Auto), + tp_text = ("%s %s %d %s") %( + { + tp.System_DVB_T : "DVB-T", + tp.System_DVB_T2 : "DVB-T2" + }.get(tp.system, ""), + { + tp.Modulation_QPSK : "QPSK", + tp.Modulation_QAM16 : "QAM16", + tp.Modulation_QAM64 : "QAM64", + tp.Modulation_QAM256 : "QAM256", + tp.Modulation_Auto : "AUTO" + }.get(tp.modulation, tp.Modulation_Auto), tp.frequency, - { tp.Bandwidth_8MHz : "Bw 8MHz", tp.Bandwidth_7MHz : "Bw 7MHz", tp.Bandwidth_6MHz : "Bw 6MHz", - tp.Bandwidth_Auto : "Bw Auto" }.get(tp.bandwidth, tp.Bandwidth_Auto)) + { + tp.Bandwidth_8MHz : "Bw 8MHz", + tp.Bandwidth_7MHz : "Bw 7MHz", + tp.Bandwidth_6MHz : "Bw 6MHz", + tp.Bandwidth_Auto : "Bw Auto", + tp.Bandwidth_5MHz : "Bw 5MHz", + tp.Bandwidth_10MHz : "Bw 10MHz", + tp.Bandwidth_1_712MHz : "Bw 1.712MHz" + }.get(tp.bandwidth, tp.Bandwidth_Auto)) else: print "unknown transponder type in scanStatusChanged" self.network.setText(network) diff --git a/lib/python/Screens/Satconfig.py b/lib/python/Screens/Satconfig.py index bce6525..0bc2303 100644 --- a/lib/python/Screens/Satconfig.py +++ b/lib/python/Screens/Satconfig.py @@ -190,7 +190,7 @@ class NimSetup(Screen, ConfigListScreen, ServiceStopScreen): self.list.append(getConfigListEntry(_("Scan additional SR"), self.nimConfig.cable.scan_sr_ext1)) self.list.append(getConfigListEntry(_("Scan additional SR"), self.nimConfig.cable.scan_sr_ext2)) self.have_advanced = False - elif self.nim.isCompatible("DVB-T"): + elif self.nim.isCompatible("DVB-T") or self.nim.isCompatible("DVB-T2"): self.configMode = getConfigListEntry(_("Configuration Mode"), self.nimConfig.configMode) self.list.append(self.configMode) self.have_advanced = False @@ -574,7 +574,7 @@ class NimSelection(Screen): text = _("simple") elif nimConfig.configMode.value == "advanced": text = _("advanced") - elif x.isCompatible("DVB-T") or x.isCompatible("DVB-C"): + elif x.isCompatible("DVB-T") or x.isCompatible("DVB-T2") or x.isCompatible("DVB-C"): if nimConfig.configMode.value == "nothing": text = _("nothing connected") elif nimConfig.configMode.value == "enabled": diff --git a/lib/python/Screens/ScanSetup.py b/lib/python/Screens/ScanSetup.py index f8bfeb7..923b494 100644 --- a/lib/python/Screens/ScanSetup.py +++ b/lib/python/Screens/ScanSetup.py @@ -17,7 +17,7 @@ from enigma import eTimer, eDVBFrontendParametersSatellite, eComponentScan, \ def buildTerTransponder(frequency, inversion=2, bandwidth = 3, fechigh = 6, feclow = 6, modulation = 2, transmission = 2, guard = 4, - hierarchy = 4): + hierarchy = 4, system = 0, plpid = 0): # print "freq", frequency, "inv", inversion, "bw", bandwidth, "fech", fechigh, "fecl", feclow, "mod", modulation, "tm", transmission, "guard", guard, "hierarchy", hierarchy parm = eDVBFrontendParametersTerrestrial() parm.frequency = frequency @@ -29,6 +29,8 @@ def buildTerTransponder(frequency, parm.transmission_mode = transmission parm.guard_interval = guard parm.hierarchy = hierarchy + parm.system = system + parm.plpid = plpid return parm def getInitialTransponderList(tlist, pos): @@ -46,6 +48,7 @@ def getInitialTransponderList(tlist, pos): parm.modulation = x[6] parm.rolloff = x[8] parm.pilot = x[9] + parm.system = x[10] tlist.append(parm) def getInitialCableTransponderList(tlist, nim): @@ -68,14 +71,14 @@ def getInitialCableTransponderList(tlist, nim): def getInitialTerrestrialTransponderList(tlist, region): list = nimmanager.getTranspondersTerrestrial(region) - #self.transponders[self.parsedTer].append((2,freq,bw,const,crh,crl,guard,transm,hierarchy,inv)) + #self.transponders[self.parsedTer].append((2,freq,bw,const,crh,crl,guard,transm,hierarchy,inv,system,plpid)) #def buildTerTransponder(frequency, inversion = 2, bandwidth = 3, fechigh = 6, feclow = 6, - #modulation = 2, transmission = 2, guard = 4, hierarchy = 4): + #modulation = 2, transmission = 2, guard = 4, hierarchy = 4, system = 0, plpid = 0):): for x in list: if x[0] == 2: #TERRESTRIAL - parm = buildTerTransponder(x[1], x[9], x[2], x[4], x[5], x[3], x[7], x[6], x[8]) + parm = buildTerTransponder(x[1], x[9], x[2], x[4], x[5], x[3], x[7], x[6], x[8], x[10], x[11]) tlist.append(parm) cable_bands = { @@ -396,15 +399,32 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): self.list.append(getConfigListEntry(_("FEC"), self.scan_cab.fec)) elif nim.isCompatible("DVB-T"): if self.scan_typeterrestrial.value == "single_transponder": - self.list.append(getConfigListEntry(_("Frequency"), self.scan_ter.frequency)) - self.list.append(getConfigListEntry(_("Inversion"), self.scan_ter.inversion)) - self.list.append(getConfigListEntry(_("Bandwidth"), self.scan_ter.bandwidth)) - self.list.append(getConfigListEntry(_("Code rate HP"), self.scan_ter.fechigh)) - self.list.append(getConfigListEntry(_("Code rate LP"), self.scan_ter.feclow)) - self.list.append(getConfigListEntry(_("Modulation"), self.scan_ter.modulation)) - self.list.append(getConfigListEntry(_("Transmission mode"), self.scan_ter.transmission)) - self.list.append(getConfigListEntry(_("Guard interval"), self.scan_ter.guard)) - self.list.append(getConfigListEntry(_("Hierarchy info"), self.scan_ter.hierarchy)) + if nim.isCompatible("DVB-T2"): + self.systemEntry = getConfigListEntry(_('System'), self.scan_ter.system) + self.list.append(self.systemEntry) + else: + self.scan_ter.system.value = eDVBFrontendParametersTerrestrial.System_DVB_T + if self.scan_ter.system.value == eDVBFrontendParametersTerrestrial.System_DVB_T: + self.list.append(getConfigListEntry(_("Frequency"), self.scan_ter.frequency)) + self.list.append(getConfigListEntry(_("Inversion"), self.scan_ter.inversion)) + self.list.append(getConfigListEntry(_("Bandwidth"), self.scan_ter.bandwidth)) + self.list.append(getConfigListEntry(_("Code rate HP"), self.scan_ter.fechigh)) + self.list.append(getConfigListEntry(_("Code rate LP"), self.scan_ter.feclow)) + self.list.append(getConfigListEntry(_("Modulation"), self.scan_ter.modulation)) + self.list.append(getConfigListEntry(_("Transmission mode"), self.scan_ter.transmission)) + self.list.append(getConfigListEntry(_("Guard interval"), self.scan_ter.guard)) + self.list.append(getConfigListEntry(_("Hierarchy info"), self.scan_ter.hierarchy)) + else: # DVB-T2 + self.list.append(getConfigListEntry(_("Frequency"), self.scan_ter.frequency)) + self.list.append(getConfigListEntry(_("Inversion"), self.scan_ter.inversion)) + self.list.append(getConfigListEntry(_("Bandwidth"), self.scan_ter.bandwidth_t2)) + self.list.append(getConfigListEntry(_("Code rate HP"), self.scan_ter.fechigh_t2)) + self.list.append(getConfigListEntry(_("Code rate LP"), self.scan_ter.feclow_t2)) + self.list.append(getConfigListEntry(_("Modulation"), self.scan_ter.modulation_t2)) + self.list.append(getConfigListEntry(_("Transmission mode"), self.scan_ter.transmission_t2)) + self.list.append(getConfigListEntry(_("Guard interval"), self.scan_ter.guard_t2)) + self.list.append(getConfigListEntry(_("Hierarchy info"), self.scan_ter.hierarchy)) + self.list.append(getConfigListEntry(_('PLP ID'), self.scan_ter.plp_id)) self.list.append(getConfigListEntry(_("Network scan"), self.scan_networkScan)) self.list.append(getConfigListEntry(_("Clear before scan"), self.scan_clearallservices)) self.list.append(getConfigListEntry(_("Only Free scan"), self.scan_onlyfree)) @@ -482,7 +502,9 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): "modulation" : eDVBFrontendParametersTerrestrial.Modulation_Auto, "transmission_mode" : eDVBFrontendParametersTerrestrial.TransmissionMode_Auto, "guard_interval" : eDVBFrontendParametersTerrestrial.GuardInterval_Auto, - "hierarchy": eDVBFrontendParametersTerrestrial.Hierarchy_Auto } + "hierarchy": eDVBFrontendParametersTerrestrial.Hierarchy_Auto, + "system": eDVBFrontendParametersTerrestrial.System_DVB_T, + "plp_id": 0 } if frontendData is not None: ttype = frontendData.get("tuner_type", "UNKNOWN") @@ -506,7 +528,7 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): defaultCab["inversion"] = frontendData.get("inversion", eDVBFrontendParametersCable.Inversion_Unknown) defaultCab["fec"] = frontendData.get("fec_inner", eDVBFrontendParametersCable.FEC_Auto) defaultCab["modulation"] = frontendData.get("modulation", eDVBFrontendParametersCable.Modulation_QAM16) - elif ttype == "DVB-T": + elif ttype == "DVB-T" : defaultTer["frequency"] = frontendData.get("frequency", 0) defaultTer["inversion"] = frontendData.get("inversion", eDVBFrontendParametersTerrestrial.Inversion_Unknown) defaultTer["bandwidth"] = frontendData.get("bandwidth", eDVBFrontendParametersTerrestrial.Bandwidth_7MHz) @@ -516,6 +538,7 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): defaultTer["transmission_mode"] = frontendData.get("transmission_mode", eDVBFrontendParametersTerrestrial.TransmissionMode_Auto) defaultTer["guard_interval"] = frontendData.get("guard_interval", eDVBFrontendParametersTerrestrial.GuardInterval_Auto) defaultTer["hierarchy"] = frontendData.get("hierarchy_information", eDVBFrontendParametersTerrestrial.Hierarchy_Auto) + defaultTer["system"] = frontendData.get("system", eDVBFrontendParametersTerrestrial.System_DVB_T) self.scan_sat = ConfigSubsection() self.scan_cab = ConfigSubsection() @@ -630,6 +653,13 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): (eDVBFrontendParametersTerrestrial.Bandwidth_8MHz, "8MHz"), (eDVBFrontendParametersTerrestrial.Bandwidth_7MHz, "7MHz"), (eDVBFrontendParametersTerrestrial.Bandwidth_6MHz, "6MHz")]) + self.scan_ter.bandwidth_t2 = ConfigSelection(default = defaultTer["bandwidth"], choices = [ + (eDVBFrontendParametersTerrestrial.Bandwidth_10MHz, "10MHz"), + (eDVBFrontendParametersTerrestrial.Bandwidth_8MHz, "8MHz"), + (eDVBFrontendParametersTerrestrial.Bandwidth_7MHz, "7MHz"), + (eDVBFrontendParametersTerrestrial.Bandwidth_6MHz, "6MHz"), + (eDVBFrontendParametersTerrestrial.Bandwidth_5MHz, "5MHz"), + (eDVBFrontendParametersTerrestrial.Bandwidth_1_712MHz, "1.712MHz")]) #, (eDVBFrontendParametersTerrestrial.Bandwidth_Auto, _("Auto")))) self.scan_ter.fechigh = ConfigSelection(default = defaultTer["fechigh"], choices = [ (eDVBFrontendParametersTerrestrial.FEC_1_2, "1/2"), @@ -638,6 +668,15 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): (eDVBFrontendParametersTerrestrial.FEC_5_6, "5/6"), (eDVBFrontendParametersTerrestrial.FEC_7_8, "7/8"), (eDVBFrontendParametersTerrestrial.FEC_Auto, _("Auto"))]) + self.scan_ter.fechigh_t2 = ConfigSelection(default = defaultTer["fechigh"], choices = [ + (eDVBFrontendParametersTerrestrial.FEC_1_2, "1/2"), + (eDVBFrontendParametersTerrestrial.FEC_2_3, "2/3"), + (eDVBFrontendParametersTerrestrial.FEC_3_4, "3/4"), + (eDVBFrontendParametersTerrestrial.FEC_5_6, "5/6"), + (eDVBFrontendParametersTerrestrial.FEC_6_7, "6/7"), + (eDVBFrontendParametersTerrestrial.FEC_7_8, "7/8"), + (eDVBFrontendParametersTerrestrial.FEC_8_9, "8/9"), + (eDVBFrontendParametersTerrestrial.FEC_Auto, _("Auto"))]) self.scan_ter.feclow = ConfigSelection(default = defaultTer["feclow"], choices = [ (eDVBFrontendParametersTerrestrial.FEC_1_2, "1/2"), (eDVBFrontendParametersTerrestrial.FEC_2_3, "2/3"), @@ -645,27 +684,63 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): (eDVBFrontendParametersTerrestrial.FEC_5_6, "5/6"), (eDVBFrontendParametersTerrestrial.FEC_7_8, "7/8"), (eDVBFrontendParametersTerrestrial.FEC_Auto, _("Auto"))]) + self.scan_ter.feclow_t2 = ConfigSelection(default = defaultTer["feclow"], choices = [ + (eDVBFrontendParametersTerrestrial.FEC_1_2, "1/2"), + (eDVBFrontendParametersTerrestrial.FEC_2_3, "2/3"), + (eDVBFrontendParametersTerrestrial.FEC_3_4, "3/4"), + (eDVBFrontendParametersTerrestrial.FEC_5_6, "5/6"), + (eDVBFrontendParametersTerrestrial.FEC_6_7, "6/7"), + (eDVBFrontendParametersTerrestrial.FEC_7_8, "7/8"), + (eDVBFrontendParametersTerrestrial.FEC_8_9, "8/9"), + (eDVBFrontendParametersTerrestrial.FEC_Auto, _("Auto"))]) self.scan_ter.modulation = ConfigSelection(default = defaultTer["modulation"], choices = [ (eDVBFrontendParametersTerrestrial.Modulation_QPSK, "QPSK"), (eDVBFrontendParametersTerrestrial.Modulation_QAM16, "QAM16"), (eDVBFrontendParametersTerrestrial.Modulation_QAM64, "QAM64"), (eDVBFrontendParametersTerrestrial.Modulation_Auto, _("Auto"))]) + self.scan_ter.modulation_t2 = ConfigSelection(default = defaultTer["modulation"], choices = [ + (eDVBFrontendParametersTerrestrial.Modulation_QPSK, "QPSK"), + (eDVBFrontendParametersTerrestrial.Modulation_QAM16, "QAM16"), + (eDVBFrontendParametersTerrestrial.Modulation_QAM64, "QAM64"), + (eDVBFrontendParametersTerrestrial.Modulation_QAM256, "QAM256"), + (eDVBFrontendParametersTerrestrial.Modulation_Auto, _("Auto"))]) self.scan_ter.transmission = ConfigSelection(default = defaultTer["transmission_mode"], choices = [ (eDVBFrontendParametersTerrestrial.TransmissionMode_2k, "2K"), (eDVBFrontendParametersTerrestrial.TransmissionMode_8k, "8K"), (eDVBFrontendParametersTerrestrial.TransmissionMode_Auto, _("Auto"))]) + self.scan_ter.transmission_t2 = ConfigSelection(default = defaultTer["transmission_mode"], choices = [ + (eDVBFrontendParametersTerrestrial.TransmissionMode_1k, "1K"), + (eDVBFrontendParametersTerrestrial.TransmissionMode_2k, "2K"), + (eDVBFrontendParametersTerrestrial.TransmissionMode_4k, "4K"), + (eDVBFrontendParametersTerrestrial.TransmissionMode_8k, "8K"), + (eDVBFrontendParametersTerrestrial.TransmissionMode_16k, "16K"), + (eDVBFrontendParametersTerrestrial.TransmissionMode_32k, "32K"), + (eDVBFrontendParametersTerrestrial.TransmissionMode_Auto, _("Auto"))]) self.scan_ter.guard = ConfigSelection(default = defaultTer["guard_interval"], choices = [ (eDVBFrontendParametersTerrestrial.GuardInterval_1_32, "1/32"), (eDVBFrontendParametersTerrestrial.GuardInterval_1_16, "1/16"), (eDVBFrontendParametersTerrestrial.GuardInterval_1_8, "1/8"), (eDVBFrontendParametersTerrestrial.GuardInterval_1_4, "1/4"), (eDVBFrontendParametersTerrestrial.GuardInterval_Auto, _("Auto"))]) + self.scan_ter.guard_t2 = ConfigSelection(default = defaultTer["guard_interval"], choices = [ + (eDVBFrontendParametersTerrestrial.GuardInterval_19_256, "19/256"), + (eDVBFrontendParametersTerrestrial.GuardInterval_19_128, "19/128"), + (eDVBFrontendParametersTerrestrial.GuardInterval_1_128, "1/128"), + (eDVBFrontendParametersTerrestrial.GuardInterval_1_32, "1/32"), + (eDVBFrontendParametersTerrestrial.GuardInterval_1_16, "1/16"), + (eDVBFrontendParametersTerrestrial.GuardInterval_1_8, "1/8"), + (eDVBFrontendParametersTerrestrial.GuardInterval_1_4, "1/4"), + (eDVBFrontendParametersTerrestrial.GuardInterval_Auto, _("Auto"))]) self.scan_ter.hierarchy = ConfigSelection(default = defaultTer["hierarchy"], choices = [ (eDVBFrontendParametersTerrestrial.Hierarchy_None, _("None")), (eDVBFrontendParametersTerrestrial.Hierarchy_1, "1"), (eDVBFrontendParametersTerrestrial.Hierarchy_2, "2"), (eDVBFrontendParametersTerrestrial.Hierarchy_4, "4"), (eDVBFrontendParametersTerrestrial.Hierarchy_Auto, _("Auto"))]) + self.scan_ter.system = ConfigSelection(default = defaultTer["system"], choices = [ + (eDVBFrontendParametersTerrestrial.System_DVB_T, _("DVB-T")), + (eDVBFrontendParametersTerrestrial.System_DVB_T2, _("DVB-T2"))]) + self.scan_ter.plp_id = ConfigInteger(default = defaultTer["plp_id"], limits = (0, 255)) self.scan_scansat = {} for sat in nimmanager.satList: @@ -791,16 +866,32 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): elif nim.isCompatible("DVB-T"): if self.scan_typeterrestrial.value == "single_transponder": - self.addTerTransponder(tlist, - self.scan_ter.frequency.value * 1000, - inversion = self.scan_ter.inversion.value, - bandwidth = self.scan_ter.bandwidth.value, - fechigh = self.scan_ter.fechigh.value, - feclow = self.scan_ter.feclow.value, - modulation = self.scan_ter.modulation.value, - transmission = self.scan_ter.transmission.value, - guard = self.scan_ter.guard.value, - hierarchy = self.scan_ter.hierarchy.value) + if self.scan_ter.system.value == eDVBFrontendParametersTerrestrial.System_DVB_T: + self.addTerTransponder(tlist, + self.scan_ter.frequency.value * 1000, + inversion = self.scan_ter.inversion.value, + bandwidth = self.scan_ter.bandwidth.value, + fechigh = self.scan_ter.fechigh.value, + feclow = self.scan_ter.feclow.value, + modulation = self.scan_ter.modulation.value, + transmission = self.scan_ter.transmission.value, + guard = self.scan_ter.guard.value, + hierarchy = self.scan_ter.hierarchy.value, + system = self.scan_ter.system.value, + plpid = self.scan_ter.plp_id.value) + else: + self.addTerTransponder(tlist, + self.scan_ter.frequency.value * 1000, + inversion = self.scan_ter.inversion.value, + bandwidth = self.scan_ter.bandwidth_t2.value, + fechigh = self.scan_ter.fechigh_t2.value, + feclow = self.scan_ter.feclow_t2.value, + modulation = self.scan_ter.modulation_t2.value, + transmission = self.scan_ter.transmission_t2.value, + guard = self.scan_ter.guard_t2.value, + hierarchy = self.scan_ter.hierarchy.value, + system = self.scan_ter.system.value, + plpid = self.scan_ter.plp_id.value) removeAll = False elif self.scan_typeterrestrial.value == "complete": getInitialTerrestrialTransponderList(tlist, nimmanager.getTerrestrialDescription(index_to_scan)) diff --git a/lib/python/Screens/ServiceInfo.py b/lib/python/Screens/ServiceInfo.py index a2a0460..79842e2 100644 --- a/lib/python/Screens/ServiceInfo.py +++ b/lib/python/Screens/ServiceInfo.py @@ -203,8 +203,9 @@ class ServiceInfo(Screen): (_("Inversion"), frontendData["inversion"], TYPE_TEXT), (_("FEC"), frontendData["fec_inner"], TYPE_TEXT)) elif frontendDataOrg["tuner_type"] == "DVB-T": - return ((_("NIM"), ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H')[frontendData["tuner_number"]], TYPE_TEXT), + data = ((_("NIM"), ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H')[frontendData["tuner_number"]], TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), + (_("System"), frontendData["system"], TYPE_TEXT), (_("Frequency"), frontendData["frequency"], TYPE_VALUE_DEC), (_("Inversion"), frontendData["inversion"], TYPE_TEXT), (_("Bandwidth"), frontendData["bandwidth"], TYPE_VALUE_DEC), @@ -214,6 +215,8 @@ class ServiceInfo(Screen): (_("Transmission mode"), frontendData["transmission_mode"], TYPE_TEXT), (_("Guard interval"), frontendData["guard_interval"], TYPE_TEXT), (_("Hierarchy info"), frontendData["hierarchy_information"], TYPE_TEXT)) + if frontendData.has_key("plp_id"): + data[len(data)] = ((_("PLP ID"), frontendData["plp_id"], TYPE_VALUE_DEC)) return [ ] def fillList(self, Labels): diff --git a/lib/python/Tools/Transponder.py b/lib/python/Tools/Transponder.py index 0b8b96a..f02806e 100644 --- a/lib/python/Tools/Transponder.py +++ b/lib/python/Tools/Transponder.py @@ -72,34 +72,49 @@ def ConvertToHumanReadable(tp, type = None): ret["tuner_type"] = _("Terrestrial") ret["bandwidth"] = { eDVBFrontendParametersTerrestrial.Bandwidth_Auto : _("Auto"), + eDVBFrontendParametersTerrestrial.Bandwidth_10MHz : "10 MHz", eDVBFrontendParametersTerrestrial.Bandwidth_8MHz : "8 MHz", eDVBFrontendParametersTerrestrial.Bandwidth_7MHz : "7 MHz", - eDVBFrontendParametersTerrestrial.Bandwidth_6MHz : "6 MHz"}[tp["bandwidth"]] + eDVBFrontendParametersTerrestrial.Bandwidth_6MHz : "6 MHz", + eDVBFrontendParametersTerrestrial.Bandwidth_5MHz : "5 MHz", + eDVBFrontendParametersTerrestrial.Bandwidth_1_712MHz : "1.172 MHz"}[tp["bandwidth"]] ret["code_rate_lp"] = { eDVBFrontendParametersTerrestrial.FEC_Auto : _("Auto"), eDVBFrontendParametersTerrestrial.FEC_1_2 : "1/2", eDVBFrontendParametersTerrestrial.FEC_2_3 : "2/3", eDVBFrontendParametersTerrestrial.FEC_3_4 : "3/4", eDVBFrontendParametersTerrestrial.FEC_5_6 : "5/6", - eDVBFrontendParametersTerrestrial.FEC_7_8 : "7/8"}[tp["code_rate_lp"]] + eDVBFrontendParametersTerrestrial.FEC_6_7 : "6/7", + eDVBFrontendParametersTerrestrial.FEC_7_8 : "7/8", + eDVBFrontendParametersTerrestrial.FEC_8_9 : "8/9"}.get(tp.get("code_rate_lp")) ret["code_rate_hp"] = { eDVBFrontendParametersTerrestrial.FEC_Auto : _("Auto"), eDVBFrontendParametersTerrestrial.FEC_1_2 : "1/2", eDVBFrontendParametersTerrestrial.FEC_2_3 : "2/3", eDVBFrontendParametersTerrestrial.FEC_3_4 : "3/4", eDVBFrontendParametersTerrestrial.FEC_5_6 : "5/6", - eDVBFrontendParametersTerrestrial.FEC_7_8 : "7/8"}[tp["code_rate_hp"]] + eDVBFrontendParametersTerrestrial.FEC_6_7 : "6/7", + eDVBFrontendParametersTerrestrial.FEC_7_8 : "7/8", + eDVBFrontendParametersTerrestrial.FEC_8_9 : "8/9"}.get(tp.get("code_rate_hp")) ret["constellation"] = { eDVBFrontendParametersTerrestrial.Modulation_Auto : _("Auto"), eDVBFrontendParametersTerrestrial.Modulation_QPSK : "QPSK", eDVBFrontendParametersTerrestrial.Modulation_QAM16 : "QAM16", - eDVBFrontendParametersTerrestrial.Modulation_QAM64 : "QAM64"}[tp["constellation"]] + eDVBFrontendParametersTerrestrial.Modulation_QAM64 : "QAM64", + eDVBFrontendParametersTerrestrial.Modulation_QAM256 : "QAM256"}.get(tp.get("constellation")) ret["transmission_mode"] = { eDVBFrontendParametersTerrestrial.TransmissionMode_Auto : _("Auto"), + eDVBFrontendParametersTerrestrial.TransmissionMode_1k : "1k", eDVBFrontendParametersTerrestrial.TransmissionMode_2k : "2k", - eDVBFrontendParametersTerrestrial.TransmissionMode_8k : "8k"}[tp["transmission_mode"]] + eDVBFrontendParametersTerrestrial.TransmissionMode_4k : "4k", + eDVBFrontendParametersTerrestrial.TransmissionMode_8k : "8k", + eDVBFrontendParametersTerrestrial.TransmissionMode_16k : "16k", + eDVBFrontendParametersTerrestrial.TransmissionMode_32k : "32k"}.get(tp.get("transmission_mode")) ret["guard_interval"] = { eDVBFrontendParametersTerrestrial.GuardInterval_Auto : _("Auto"), + eDVBFrontendParametersTerrestrial.GuardInterval_19_256 : "19/256", + eDVBFrontendParametersTerrestrial.GuardInterval_19_128 : "19/128", + eDVBFrontendParametersTerrestrial.GuardInterval_1_128 : "1/128", eDVBFrontendParametersTerrestrial.GuardInterval_1_32 : "1/32", eDVBFrontendParametersTerrestrial.GuardInterval_1_16 : "1/16", eDVBFrontendParametersTerrestrial.GuardInterval_1_8 : "1/8", @@ -114,6 +129,9 @@ def ConvertToHumanReadable(tp, type = None): eDVBFrontendParametersTerrestrial.Inversion_Unknown : _("Auto"), eDVBFrontendParametersTerrestrial.Inversion_On : _("On"), eDVBFrontendParametersTerrestrial.Inversion_Off : _("Off")}[tp["inversion"]] + ret["system"] = { + eDVBFrontendParametersTerrestrial.System_DVB_T : "DVB-T", + eDVBFrontendParametersTerrestrial.System_DVB_T2 : "DVB-T2"}.get(tp.get("system")) else: print "ConvertToHumanReadable: no or unknown type in tpdata dict!" for x in tp.keys(): -- 2.7.4