} 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;
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')
}
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))
{
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)
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());
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)
{
}
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));
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);
}
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);
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)
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)
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;
#endif
PutToDict(dict, "system", tmp);
}
-#endif
static void fillDictWithCableData(ePyObject dict, const FRONTENDPARAMETERS &parm)
{
PutToDict(dict, "hierarchy_information", tmp);
}
+#endif // #if HAVE_DVB_API_VERSION >= 5
+
void eDVBFrontend::getFrontendStatus(ePyObject dest)
{
if (dest && PyDict_Check(dest))
{
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)
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);
case feTerrestrial:
fillDictWithTerrestrialData(dest, parm);
break;
+#endif
}
}
}
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
{
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;
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;
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;
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;
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;
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;
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;
}
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) {
!!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,
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
#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 {
};
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;
int guard_interval;
int hierarchy;
int inversion;
+ int system;
+ int plpid;
};
SWIG_ALLOW_OUTPUT_SIMPLE(eDVBFrontendParametersTerrestrial);
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:
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
"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]
"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]
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]
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)
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[:]:
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):
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");
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)
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
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":
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
parm.transmission_mode = transmission
parm.guard_interval = guard
parm.hierarchy = hierarchy
+ parm.system = system
+ parm.plpid = plpid
return parm
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):
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 = {
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))
"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")
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)
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()
(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"),
(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"),
(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:
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))
(_("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),
(_("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):
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",
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():