Support DVB-S2X.

diff --git a/lib/dvb/db.cpp b/lib/dvb/db.cpp
index 0f367be..b2d21f4 100755 (executable)
--- a/lib/dvb/db.cpp
+++ b/lib/dvb/db.cpp
@@ -378,11 +378,17 @@ void eDVBDB::loadServicelist(const char *file)
                                        system=eDVBFrontendParametersSatellite::System_DVB_S,
                                        modulation=eDVBFrontendParametersSatellite::Modulation_QPSK,
                                        rolloff=eDVBFrontendParametersSatellite::RollOff_alpha_0_35,
                                        system=eDVBFrontendParametersSatellite::System_DVB_S,
                                        modulation=eDVBFrontendParametersSatellite::Modulation_QPSK,
                                        rolloff=eDVBFrontendParametersSatellite::RollOff_alpha_0_35,

-                                       pilot=eDVBFrontendParametersSatellite::Pilot_Unknown;
+                                       pilot=eDVBFrontendParametersSatellite::Pilot_Unknown,
+                                       is_id = NO_STREAM_ID_FILTER,
+                                       pls_code = 0,
+                                       pls_mode = eDVBFrontendParametersSatellite::PLS_Unknown;

                                if (version == 3)
                                        sscanf(line+3, "%d:%d:%d:%d:%d:%d:%d:%d:%d:%d", &frequency, &symbol_rate, &polarisation, &fec, &orbital_position, &inversion, &system, &modulation, &rolloff, &pilot);
                                else
                                if (version == 3)
                                        sscanf(line+3, "%d:%d:%d:%d:%d:%d:%d:%d:%d:%d", &frequency, &symbol_rate, &polarisation, &fec, &orbital_position, &inversion, &system, &modulation, &rolloff, &pilot);
                                else

-                                       sscanf(line+3, "%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d", &frequency, &symbol_rate, &polarisation, &fec, &orbital_position, &inversion, &flags, &system, &modulation, &rolloff, &pilot);
+                                       sscanf(line+3, "%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d",
+                                               &frequency, &symbol_rate, &polarisation, &fec, &orbital_position,
+                                               &inversion, &flags, &system, &modulation, &rolloff, &pilot,
+                                               &is_id, &pls_code, &pls_mode);

                                sat.frequency = frequency;
                                sat.symbol_rate = symbol_rate;
                                sat.polarisation = polarisation;
                                sat.frequency = frequency;
                                sat.symbol_rate = symbol_rate;
                                sat.polarisation = polarisation;


@@ -394,6 +400,9 @@ void eDVBDB::loadServicelist(const char *file)
                                sat.modulation = modulation;
                                sat.rolloff = rolloff;
                                sat.pilot = pilot;
                                sat.modulation = modulation;
                                sat.rolloff = rolloff;
                                sat.pilot = pilot;

+                               sat.is_id = is_id;
+                               sat.pls_mode = pls_mode & 3;
+                               sat.pls_code = pls_code & 0x3FFFF;

                                feparm->setDVBS(sat);
                                feparm->setFlags(flags);
                        } else if (line[1]=='t')
                                feparm->setDVBS(sat);
                                feparm->setFlags(flags);
                        } else if (line[1]=='t')


@@ -512,27 +521,23 @@ void eDVBDB::saveServicelist(const char *file)
                ch.m_frontendParameters->getFlags(flags);
                if (!ch.m_frontendParameters->getDVBS(sat))
                {
                ch.m_frontendParameters->getFlags(flags);
                if (!ch.m_frontendParameters->getDVBS(sat))
                {

-                       if (sat.system == eDVBFrontendParametersSatellite::System_DVB_S2)
-                       {
-                               fprintf(f, "\ts %d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d\n",
-                                       sat.frequency, sat.symbol_rate,
-                                       sat.polarisation, sat.fec,
-                                       sat.orbital_position > 1800 ? sat.orbital_position - 3600 : sat.orbital_position,
-                                       sat.inversion,
-                                       flags,
-                                       sat.system,
-                                       sat.modulation,
-                                       sat.rolloff,
-                                       sat.pilot);
-                       }
-                       else
+                       fprintf(f, "\ts %d:%d:%d:%d:%d:%d:%d",
+                               sat.frequency, sat.symbol_rate, sat.polarisation, sat.fec,
+                               sat.orbital_position > 1800 ? sat.orbital_position - 3600 : sat.orbital_position,
+                               sat.inversion, flags);
+
+                       if ((sat.system == eDVBFrontendParametersSatellite::System_DVB_S2) || (sat.system == eDVBFrontendParametersSatellite::System_DVB_S2X))

                        {
                        {

-                               fprintf(f, "\ts %d:%d:%d:%d:%d:%d:%d\n",
-                                       sat.frequency, sat.symbol_rate,
-                                       sat.polarisation, sat.fec,
-                                       sat.orbital_position > 1800 ? sat.orbital_position - 3600 : sat.orbital_position,
-                                       sat.inversion, flags);
+                               fprintf(f, ":%d:%d:%d:%d", sat.system, sat.modulation, sat.rolloff, sat.pilot);
+
+                               if (static_cast<unsigned int>(sat.is_id) != NO_STREAM_ID_FILTER ||
+                                       (sat.pls_code & 0x3FFFF) != 0 ||
+                                       (sat.pls_mode & 3) != eDVBFrontendParametersSatellite::PLS_Unknown)
+                               {
+                                       fprintf(f, ":%d:%d:%d", sat.is_id, sat.pls_code & 0x3FFFF, sat.pls_mode & 3);
+                               }

                        }
                        }

+                       fprintf(f, "\n");

                }
                else if (!ch.m_frontendParameters->getDVBT(ter))
                {
                }
                else if (!ch.m_frontendParameters->getDVBT(ter))
                {


@@ -792,7 +797,7 @@ PyObject *eDVBDB::readSatellites(ePyObject sat_list, ePyObject sat_dict, ePyObje
                return Py_False;
        }
        int tmp, *dest = NULL,
                return Py_False;
        }
        int tmp, *dest = NULL,

-               modulation, system, freq, sr, pol, fec, inv, pilot, rolloff, tsid, onid;
+               modulation, system, freq, sr, pol, fec, inv, pilot, rolloff, is_id, pls_code, pls_mode, tsid, onid;

        char *end_ptr;
        const Attribute *at;
        std::string name;
        char *end_ptr;
        const Attribute *at;
        std::string name;


@@ -857,6 +862,9 @@ PyObject *eDVBDB::readSatellites(ePyObject sat_list, ePyObject sat_dict, ePyObje
                                inv = eDVBFrontendParametersSatellite::Inversion_Unknown;
                                pilot = eDVBFrontendParametersSatellite::Pilot_Unknown;
                                rolloff = eDVBFrontendParametersSatellite::RollOff_alpha_0_35;
                                inv = eDVBFrontendParametersSatellite::Inversion_Unknown;
                                pilot = eDVBFrontendParametersSatellite::Pilot_Unknown;
                                rolloff = eDVBFrontendParametersSatellite::RollOff_alpha_0_35;

+                               is_id = NO_STREAM_ID_FILTER;
+                               pls_code = 0;
+                               pls_mode = eDVBFrontendParametersSatellite::PLS_Unknown;

                                tsid = -1;
                                onid = -1;
 
                                tsid = -1;
                                onid = -1;
 


@@ -874,6 +882,9 @@ PyObject *eDVBDB::readSatellites(ePyObject sat_list, ePyObject sat_dict, ePyObje
                                        else if (name == "inversion") dest = &inv;
                                        else if (name == "rolloff") dest = &rolloff;
                                        else if (name == "pilot") dest = &pilot;
                                        else if (name == "inversion") dest = &inv;
                                        else if (name == "rolloff") dest = &rolloff;
                                        else if (name == "pilot") dest = &pilot;

+                                       else if (name == "is_id") dest = &is_id;
+                                       else if (name == "pls_code") dest = &pls_code;
+                                       else if (name == "pls_mode") dest = &pls_mode;

                                        else if (name == "tsid") dest = &tsid;
                                        else if (name == "onid") dest = &onid;
                                        else continue;
                                        else if (name == "tsid") dest = &tsid;
                                        else if (name == "onid") dest = &onid;
                                        else continue;


@@ -887,7 +898,7 @@ PyObject *eDVBDB::readSatellites(ePyObject sat_list, ePyObject sat_dict, ePyObje
                                }
                                if (freq && sr && pol != -1)
                                {
                                }
                                if (freq && sr && pol != -1)
                                {

-                                       tuple = PyTuple_New(12);
+                                       tuple = PyTuple_New(15);

                                        PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(0));
                                        PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(freq));
                                        PyTuple_SET_ITEM(tuple, 2, PyInt_FromLong(sr));
                                        PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(0));
                                        PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(freq));
                                        PyTuple_SET_ITEM(tuple, 2, PyInt_FromLong(sr));


@@ -898,8 +909,11 @@ PyObject *eDVBDB::readSatellites(ePyObject sat_list, ePyObject sat_dict, ePyObje
                                        PyTuple_SET_ITEM(tuple, 7, PyInt_FromLong(inv));
                                        PyTuple_SET_ITEM(tuple, 8, PyInt_FromLong(rolloff));
                                        PyTuple_SET_ITEM(tuple, 9, PyInt_FromLong(pilot));
                                        PyTuple_SET_ITEM(tuple, 7, PyInt_FromLong(inv));
                                        PyTuple_SET_ITEM(tuple, 8, PyInt_FromLong(rolloff));
                                        PyTuple_SET_ITEM(tuple, 9, PyInt_FromLong(pilot));

-                                       PyTuple_SET_ITEM(tuple, 10, PyInt_FromLong(tsid));
-                                       PyTuple_SET_ITEM(tuple, 11, PyInt_FromLong(onid));
+                                       PyTuple_SET_ITEM(tuple, 10, PyInt_FromLong(is_id));
+                                       PyTuple_SET_ITEM(tuple, 11, PyInt_FromLong(pls_mode & 3));
+                                       PyTuple_SET_ITEM(tuple, 12, PyInt_FromLong(pls_code & 0x3FFFF));
+                                       PyTuple_SET_ITEM(tuple, 13, PyInt_FromLong(tsid));
+                                       PyTuple_SET_ITEM(tuple, 14, PyInt_FromLong(onid));

                                        PyList_Append(tplist, tuple);
                                        Py_DECREF(tuple);
                                }
                                        PyList_Append(tplist, tuple);
                                        Py_DECREF(tuple);
                                }

diff --git a/lib/dvb/dvb.cpp b/lib/dvb/dvb.cpp
index 852c403..5ebf10c 100644 (file)
--- a/lib/dvb/dvb.cpp
+++ b/lib/dvb/dvb.cpp
@@ -414,6 +414,10 @@ bool eDVBResourceManager::frontendIsCompatible(int index, const char *type)
        {
                if (i->m_frontend->getSlotID() == index)
                {
        {
                if (i->m_frontend->getSlotID() == index)
                {

+                       if (!strcmp(type, "DVB-S2X"))
+                       {
+                               return i->m_frontend->supportsDeliverySystem(SYS_DVBS2X, false);
+                       }

                        if (!strcmp(type, "DVB-S2"))
                        {
                                return i->m_frontend->supportsDeliverySystem(SYS_DVBS2, false);
                        if (!strcmp(type, "DVB-S2"))
                        {
                                return i->m_frontend->supportsDeliverySystem(SYS_DVBS2, false);


@@ -443,6 +447,18 @@ bool eDVBResourceManager::frontendIsCompatible(int index, const char *type)
        return false;
 }
 
        return false;
 }
 

+bool eDVBResourceManager::frontendIsMultistream(int index)
+{
+       for (eSmartPtrList<eDVBRegisteredFrontend>::iterator i(m_frontend.begin()); i != m_frontend.end(); ++i)
+       {
+               if (i->m_frontend->getSlotID() == index)
+               {
+                       return i->m_frontend->is_multistream();
+               }
+       }
+       return false;
+}
+

 void eDVBResourceManager::setFrontendType(int index, const char *type)
 {
        eDebug("[eDVBResourceManager::setFrontendType] index : %d, type : %s", index, type);
 void eDVBResourceManager::setFrontendType(int index, const char *type)
 {
        eDebug("[eDVBResourceManager::setFrontendType] index : %d, type : %s", index, type);


@@ -456,6 +472,8 @@ void eDVBResourceManager::setFrontendType(int index, const char *type)
                        {
                                whitelist.push_back(SYS_DVBS);
                                whitelist.push_back(SYS_DVBS2);
                        {
                                whitelist.push_back(SYS_DVBS);
                                whitelist.push_back(SYS_DVBS2);

+                               if (!strcmp(type, "DVB-S2X"))
+                                       whitelist.push_back(SYS_DVBS2X);

                        }
                        else if (!strcmp(type, "DVB-T2") || !strcmp(type, "DVB-T"))
                        {
                        }
                        else if (!strcmp(type, "DVB-T2") || !strcmp(type, "DVB-T"))
                        {

diff --git a/lib/dvb/dvb.h b/lib/dvb/dvb.h
index 3e9fc7f..f470fe1 100644 (file)
--- a/lib/dvb/dvb.h
+++ b/lib/dvb/dvb.h
@@ -224,6 +224,7 @@ public:
        SWIG_VOID(RESULT) allocateRawChannel(eUsePtr<iDVBChannel> &SWIG_OUTPUT, int slot_index);
        PyObject *setFrontendSlotInformations(SWIG_PYOBJECT(ePyObject) list);
        bool frontendIsCompatible(int index, const char *type);
        SWIG_VOID(RESULT) allocateRawChannel(eUsePtr<iDVBChannel> &SWIG_OUTPUT, int slot_index);
        PyObject *setFrontendSlotInformations(SWIG_PYOBJECT(ePyObject) list);
        bool frontendIsCompatible(int index, const char *type);

+       bool frontendIsMultistream(int index);

        void setFrontendType(int index, const char *type);
 };
 SWIG_TEMPLATE_TYPEDEF(ePtr<eDVBResourceManager>, eDVBResourceManager);
        void setFrontendType(int index, const char *type);
 };
 SWIG_TEMPLATE_TYPEDEF(ePtr<eDVBResourceManager>, eDVBResourceManager);

diff --git a/lib/dvb/frontend.cpp b/lib/dvb/frontend.cpp
old mode 100755 (executable)
new mode 100644 (file)
index ceecb6d..9d87118
--- a/lib/dvb/frontend.cpp
+++ b/lib/dvb/frontend.cpp
@@ -38,6 +38,9 @@
 #define FEC_S2_QPSK_4_5 (fe_code_rate_t)(FEC_4_5)
 #define FEC_S2_QPSK_9_10 (fe_code_rate_t)(FEC_9_10)
 
 #define FEC_S2_QPSK_4_5 (fe_code_rate_t)(FEC_4_5)
 #define FEC_S2_QPSK_9_10 (fe_code_rate_t)(FEC_9_10)
 

+/* DVB-S2X */
+#define FEC_S2_QPSK_13_45 (fe_code_rate_t)(FEC_13_45)
+

 #include <dvbsi++/satellite_delivery_system_descriptor.h>
 #include <dvbsi++/cable_delivery_system_descriptor.h>
 #include <dvbsi++/terrestrial_delivery_system_descriptor.h>
 #include <dvbsi++/satellite_delivery_system_descriptor.h>
 #include <dvbsi++/cable_delivery_system_descriptor.h>
 #include <dvbsi++/terrestrial_delivery_system_descriptor.h>


@@ -126,29 +129,35 @@ void eDVBFrontendParametersSatellite::set(const SatelliteDeliverySystemDescripto
                orbital_position = 3600 - orbital_position;
        system = descriptor.getModulationSystem();
        modulation = descriptor.getModulation();
                orbital_position = 3600 - orbital_position;
        system = descriptor.getModulationSystem();
        modulation = descriptor.getModulation();

-       if (system == eDVBFrontendParametersSatellite::System_DVB_S && modulation == eDVBFrontendParametersSatellite::Modulation_8PSK)
+       if (system == eDVBFrontendParametersSatellite::System_DVB_S && modulation != eDVBFrontendParametersSatellite::Modulation_QPSK)

        {
                eDebug("satellite_delivery_descriptor non valid modulation type.. force QPSK");
                modulation=eDVBFrontendParametersSatellite::Modulation_QPSK;
        }
        rolloff = descriptor.getRollOff();
        {
                eDebug("satellite_delivery_descriptor non valid modulation type.. force QPSK");
                modulation=eDVBFrontendParametersSatellite::Modulation_QPSK;
        }
        rolloff = descriptor.getRollOff();

-       if (system == eDVBFrontendParametersSatellite::System_DVB_S2)
+       is_id = NO_STREAM_ID_FILTER;
+       pls_mode = eDVBFrontendParametersSatellite::PLS_Unknown;
+       pls_code = 0;
+       if (system == eDVBFrontendParametersSatellite::System_DVB_S)

        {
        {

-               eDebug("SAT DVB-S2 freq %d, %s, pos %d, sr %d, fec %d, modulation %d, rolloff %d",
+               eDebug("SAT DVB-S freq %d, %s, pos %d, sr %d, fec %d",

                        frequency,
                        polarisation ? "hor" : "vert",
                        orbital_position,
                        frequency,
                        polarisation ? "hor" : "vert",
                        orbital_position,

-                       symbol_rate, fec,
-                       modulation,
-                       rolloff);
+                       symbol_rate, fec);

        }
        }

-       else
+       else // System_DVB_S2 or System_DVB_S2X

        {
        {

-               eDebug("SAT DVB-S freq %d, %s, pos %d, sr %d, fec %d",
+               eDebug("SAT DVB-S2 freq %d, %s, pos %d, sr %d, fec %d, modulation %d, rolloff %d, is_id %d, pls_mode %d, pls_code %d",

                        frequency,
                        polarisation ? "hor" : "vert",
                        orbital_position,
                        frequency,
                        polarisation ? "hor" : "vert",
                        orbital_position,

-                       symbol_rate, fec);
+                       symbol_rate, fec,
+                       modulation,
+                       rolloff,
+                       is_id,
+                       pls_mode,
+                       pls_code);

        }
 }
 
        }
 }
 


@@ -356,6 +365,12 @@ RESULT eDVBFrontendParameters::calculateDifference(const iDVBFrontendParameters
                        diff = 1<<29;
                else if (sat.polarisation != osat.polarisation)
                        diff = 1<<28;
                        diff = 1<<29;
                else if (sat.polarisation != osat.polarisation)
                        diff = 1<<28;

+               else if (sat.is_id != osat.is_id)
+                       diff = 1<<27;
+               else if (sat.pls_mode != osat.pls_mode)
+                       diff = 1<<27;
+               else if (sat.pls_code != osat.pls_code)
+                       diff = 1<<27;

                else if (exact && sat.fec != osat.fec && sat.fec != eDVBFrontendParametersSatellite::FEC_Auto && osat.fec != eDVBFrontendParametersSatellite::FEC_Auto)
                        diff = 1<<27;
                else if (exact && sat.modulation != osat.modulation && sat.modulation != eDVBFrontendParametersSatellite::Modulation_Auto && osat.modulation != eDVBFrontendParametersSatellite::Modulation_Auto)
                else if (exact && sat.fec != osat.fec && sat.fec != eDVBFrontendParametersSatellite::FEC_Auto && osat.fec != eDVBFrontendParametersSatellite::FEC_Auto)
                        diff = 1<<27;
                else if (exact && sat.modulation != osat.modulation && sat.modulation != eDVBFrontendParametersSatellite::Modulation_Auto && osat.modulation != eDVBFrontendParametersSatellite::Modulation_Auto)


@@ -527,7 +542,6 @@ int eDVBFrontend::openFrontend()
        m_state=stateIdle;
        m_tuning=0;
 
        m_state=stateIdle;
        m_tuning=0;
 

-       dvb_frontend_info fe_info;

        if (!m_simulate)
        {
                eDebug("opening frontend %d", m_dvbid);
        if (!m_simulate)
        {
                eDebug("opening frontend %d", m_dvbid);


@@ -545,6 +559,13 @@ int eDVBFrontend::openFrontend()
 
                if (m_delsys.empty())
                {
 
                if (m_delsys.empty())
                {

+                       if (::ioctl(m_fd, FE_GET_INFO, &fe_info) < 0)
+                       {
+                               eWarning("ioctl FE_GET_INFO failed");
+                               ::close(m_fd);
+                               m_fd = -1;
+                               return -1;
+                       }

 #ifdef DTV_ENUM_DELSYS
                        struct dtv_property p[1];
                        p[0].cmd = DTV_ENUM_DELSYS;
 #ifdef DTV_ENUM_DELSYS
                        struct dtv_property p[1];
                        p[0].cmd = DTV_ENUM_DELSYS;


@@ -561,48 +582,46 @@ int eDVBFrontend::openFrontend()
                                        m_delsys[delsys] = true;
                                }
                        }
                                        m_delsys[delsys] = true;
                                }
                        }

+                       else

 #else
 #else

-                       if (::ioctl(m_fd, FE_GET_INFO, &fe_info) < 0)
+                       /* no DTV_ENUM_DELSYS support */
+                       if (1)
+#endif

                        {
                        {

-                               eWarning("ioctl FE_GET_INFO failed");
-                               ::close(m_fd);
-                               m_fd = -1;
-                               return -1;
-                       }

                        /* old DVB API, fill delsys map with some defaults */
                        /* old DVB API, fill delsys map with some defaults */

-                       switch (fe_info.type)
-                       {
-                               case FE_QPSK:
+                               switch (fe_info.type)

                                {
                                {

-                                       m_delsys[SYS_DVBS] = true;
+                                       case FE_QPSK:
+                                       {
+                                               m_delsys[SYS_DVBS] = true;

 #if DVB_API_VERSION >= 5
 #if DVB_API_VERSION >= 5

-                                       if (fe_info.caps & FE_CAN_2G_MODULATION) m_delsys[SYS_DVBS2] = true;
+                                               if (fe_info.caps & FE_CAN_2G_MODULATION) m_delsys[SYS_DVBS2] = true;

 #endif
 #endif

-                                       break;
-                               }
-                               case FE_QAM:
-                               {
+                                               break;
+                                       }
+                                       case FE_QAM:
+                                       {

 #if defined SYS_DVBC_ANNEX_A
 #if defined SYS_DVBC_ANNEX_A

-                                       m_delsys[SYS_DVBC_ANNEX_A] = true;
+                                               m_delsys[SYS_DVBC_ANNEX_A] = true;

 #else
 #else

-                                       m_delsys[SYS_DVBC_ANNEX_AC] = true;
+                                               m_delsys[SYS_DVBC_ANNEX_AC] = true;

 #endif
 #endif

-                                       break;
-                               }
-                               case FE_OFDM:
-                               {
-                                       m_delsys[SYS_DVBT] = true;
+                                               break;
+                                       }
+                                       case FE_OFDM:
+                                       {
+                                               m_delsys[SYS_DVBT] = true;

 #if DVB_API_VERSION > 5 || DVB_API_VERSION == 5 && DVB_API_VERSION_MINOR >= 3
 #if DVB_API_VERSION > 5 || DVB_API_VERSION == 5 && DVB_API_VERSION_MINOR >= 3

-                                       if (fe_info.caps & FE_CAN_2G_MODULATION) m_delsys[SYS_DVBT2] = true;
+                                               if (fe_info.caps & FE_CAN_2G_MODULATION) m_delsys[SYS_DVBT2] = true;

 #endif
 #endif

-                                       break;
-                               }
-                               case FE_ATSC:   // placeholder to prevent warning
-                               {
-                                       break;
+                                               break;
+                                       }
+                                       case FE_ATSC:   // placeholder to prevent warning
+                                       {
+                                               break;
+                                       }

                                }
                        }
                                }
                        }

-#endif

                }
 
                if (m_simulate_fe)
                }
 
                if (m_simulate_fe)


@@ -613,6 +632,26 @@ int eDVBFrontend::openFrontend()
                m_sn = eSocketNotifier::create(eApp, m_fd, eSocketNotifier::Read, false);
                CONNECT(m_sn->activated, eDVBFrontend::feEvent);
        }
                m_sn = eSocketNotifier::create(eApp, m_fd, eSocketNotifier::Read, false);
                CONNECT(m_sn->activated, eDVBFrontend::feEvent);
        }

+       else
+       {
+               fe_info.frequency_min = 900000;
+               fe_info.frequency_max = 2200000;
+
+               eDebug("[eDVBFrontend] opening frontend %d", m_dvbid);
+               int tmp_fd = ::open(m_filename, O_RDONLY | O_NONBLOCK);
+               if (tmp_fd < 0)
+               {
+                       eWarning("[eDVBFrontend] opening %s failed: %m", m_filename);
+               }
+               else
+               {
+                       if (::ioctl(tmp_fd, FE_GET_INFO, &fe_info) < 0)
+                       {
+                               eWarning("[eDVBFrontend] ioctl FE_GET_INFO on frontend %s failed: %m", m_filename);
+                       }
+                       ::close(tmp_fd);
+               }
+       }

 
        setTone(iDVBFrontend::toneOff);
        setVoltage(iDVBFrontend::voltageOff);
 
        setTone(iDVBFrontend::toneOff);
        setVoltage(iDVBFrontend::voltageOff);


@@ -1054,10 +1093,13 @@ void PutSatelliteDataToDict(ePyObject &dict, eDVBFrontendParametersSatellite &fe
        PutToDict(dict, "fec_inner", feparm.fec);
        PutToDict(dict, "modulation", feparm.modulation);
        PutToDict(dict, "polarization", feparm.polarisation);
        PutToDict(dict, "fec_inner", feparm.fec);
        PutToDict(dict, "modulation", feparm.modulation);
        PutToDict(dict, "polarization", feparm.polarisation);

-       if (feparm.system == eDVBFrontendParametersSatellite::System_DVB_S2)
+       if ((feparm.system == eDVBFrontendParametersSatellite::System_DVB_S2) || (feparm.system == eDVBFrontendParametersSatellite::System_DVB_S2X))

        {
                PutToDict(dict, "rolloff", feparm.rolloff);
                PutToDict(dict, "pilot", feparm.pilot);
        {
                PutToDict(dict, "rolloff", feparm.rolloff);
                PutToDict(dict, "pilot", feparm.pilot);

+               PutToDict(dict, "is_id", feparm.is_id);
+               PutToDict(dict, "pls_mode", feparm.pls_mode);
+               PutToDict(dict, "pls_code", feparm.pls_code);

        }
        PutToDict(dict, "system", feparm.system);
 }
        }
        PutToDict(dict, "system", feparm.system);
 }


@@ -1091,7 +1133,7 @@ void PutCableDataToDict(ePyObject &dict, eDVBFrontendParametersCable &feparm)
        PutToDict(dict, "fec_inner", feparm.fec_inner);
 }
 
        PutToDict(dict, "fec_inner", feparm.fec_inner);
 }
 

-static void fillDictWithSatelliteData(ePyObject dict, struct dtv_property *p, long freq_offset, int orbital_position, int polarization)
+static void fillDictWithSatelliteData(ePyObject dict, struct dtv_property *p, long freq_offset, eDVBFrontendParametersSatellite &feparm)

 {
        long tmp=0;
        int p_system = p[0].u.data;
 {
        long tmp=0;
        int p_system = p[0].u.data;


@@ -1102,12 +1144,13 @@ static void fillDictWithSatelliteData(ePyObject dict, struct dtv_property *p, lo
        int p_inner_fec = p[5].u.data;
        int p_rolloff = p[6].u.data;
        int p_pilot = p[7].u.data;
        int p_inner_fec = p[5].u.data;
        int p_rolloff = p[6].u.data;
        int p_pilot = p[7].u.data;

+       int p_stream_id = p[8].u.data;

 
        int frequency = p_frequency + freq_offset;
        PutToDict(dict, "frequency", frequency);
        PutToDict(dict, "symbol_rate", p_symbolrate);
 
        int frequency = p_frequency + freq_offset;
        PutToDict(dict, "frequency", frequency);
        PutToDict(dict, "symbol_rate", p_symbolrate);

-       PutToDict(dict, "orbital_position", orbital_position);
-       PutToDict(dict, "polarization", polarization);
+       PutToDict(dict, "orbital_position", feparm.orbital_position);
+       PutToDict(dict, "polarization", feparm.polarisation);

 
        switch(p_inner_fec)
        {
 
        switch(p_inner_fec)
        {


@@ -1120,6 +1163,7 @@ static void fillDictWithSatelliteData(ePyObject dict, struct dtv_property *p, lo
        case FEC_7_8: tmp = eDVBFrontendParametersSatellite::FEC_7_8; break;
        case FEC_8_9: tmp = eDVBFrontendParametersSatellite::FEC_8_9; break;
        case FEC_9_10: tmp = eDVBFrontendParametersSatellite::FEC_9_10; break;
        case FEC_7_8: tmp = eDVBFrontendParametersSatellite::FEC_7_8; break;
        case FEC_8_9: tmp = eDVBFrontendParametersSatellite::FEC_8_9; break;
        case FEC_9_10: tmp = eDVBFrontendParametersSatellite::FEC_9_10; break;

+       case FEC_13_45 ... FEC_26_45_L: tmp = eDVBFrontendParametersSatellite::FEC_13_45 + (long)(p_inner_fec - FEC_13_45); break;

        case FEC_NONE: tmp = eDVBFrontendParametersSatellite::FEC_None; break;
        case FEC_AUTO: tmp = eDVBFrontendParametersSatellite::FEC_Auto; break;
        default: eDebug("got unsupported FEC from frontend! report as FEC_AUTO!\n");
        case FEC_NONE: tmp = eDVBFrontendParametersSatellite::FEC_None; break;
        case FEC_AUTO: tmp = eDVBFrontendParametersSatellite::FEC_Auto; break;
        default: eDebug("got unsupported FEC from frontend! report as FEC_AUTO!\n");


@@ -1130,7 +1174,12 @@ static void fillDictWithSatelliteData(ePyObject dict, struct dtv_property *p, lo
        {
        default: eDebug("got unsupported system from frontend! report as DVBS!");
        case SYS_DVBS: tmp = eDVBFrontendParametersSatellite::System_DVB_S; break;
        {
        default: eDebug("got unsupported system from frontend! report as DVBS!");
        case SYS_DVBS: tmp = eDVBFrontendParametersSatellite::System_DVB_S; break;

-       case SYS_DVBS2:
+       case SYS_DVBS2: tmp = eDVBFrontendParametersSatellite::System_DVB_S2; break;
+       case SYS_DVBS2X: tmp = eDVBFrontendParametersSatellite::System_DVB_S2X; break;
+       }
+       PutToDict(dict, "system", tmp);
+
+       if ((p_system == SYS_DVBS2) || (p_system == SYS_DVBS2X))

        {
                switch (p_rolloff)
                {
        {
                switch (p_rolloff)
                {


@@ -1149,16 +1198,19 @@ static void fillDictWithSatelliteData(ePyObject dict, struct dtv_property *p, lo
                }
                PutToDict(dict, "pilot", tmp);
 
                }
                PutToDict(dict, "pilot", tmp);
 

-               tmp = eDVBFrontendParametersSatellite::System_DVB_S2; break;
+               PutToDict(dict, "is_id", ((unsigned int)p_stream_id == NO_STREAM_ID_FILTER) ? feparm.is_id : (p_stream_id & 0xFF));
+               PutToDict(dict, "pls_mode", ((unsigned int)p_stream_id == NO_STREAM_ID_FILTER) ? feparm.pls_mode : ((p_stream_id >> 26) & 0x3));
+               PutToDict(dict, "pls_code", ((unsigned int)p_stream_id == NO_STREAM_ID_FILTER) ? feparm.pls_code : ((p_stream_id >> 8) & 0x3FFFF));

        }
        }

-       }
-       PutToDict(dict, "system", tmp);

 
        switch (p_modulation)
        {
        default: eDebug("got unsupported modulation from frontend! report as QPSK!");
        case QPSK: tmp = eDVBFrontendParametersSatellite::Modulation_QPSK; break;
        case PSK_8: tmp = eDVBFrontendParametersSatellite::Modulation_8PSK; break;
 
        switch (p_modulation)
        {
        default: eDebug("got unsupported modulation from frontend! report as QPSK!");
        case QPSK: tmp = eDVBFrontendParametersSatellite::Modulation_QPSK; break;
        case PSK_8: tmp = eDVBFrontendParametersSatellite::Modulation_8PSK; break;

+       case APSK_8: tmp = eDVBFrontendParametersSatellite::Modulation_8APSK; break;
+       case APSK_16: tmp = eDVBFrontendParametersSatellite::Modulation_16APSK; break;
+       case APSK_32: tmp = eDVBFrontendParametersSatellite::Modulation_32APSK; break;

        }
        PutToDict(dict, "modulation", tmp);
 
        }
        PutToDict(dict, "modulation", tmp);
 


@@ -1426,6 +1478,7 @@ void eDVBFrontend::getTransponderData(ePyObject dest, bool original)
                        p[cmdseq.num++].cmd = DTV_INNER_FEC;
                        p[cmdseq.num++].cmd = DTV_ROLLOFF;
                        p[cmdseq.num++].cmd = DTV_PILOT;
                        p[cmdseq.num++].cmd = DTV_INNER_FEC;
                        p[cmdseq.num++].cmd = DTV_ROLLOFF;
                        p[cmdseq.num++].cmd = DTV_PILOT;

+                       p[cmdseq.num++].cmd = DTV_STREAM_ID;

                }
                else if(type == feCable)
                {
                }
                else if(type == feCable)
                {


@@ -1485,13 +1538,12 @@ void eDVBFrontend::getTransponderData(ePyObject dest, bool original)
                }
                else
                {
                }
                else
                {

-                       FRONTENDPARAMETERS &parm = front;

                        switch(type)
                        {
                                case feSatellite:
                                        eDVBFrontendParametersSatellite sparm;
                                        oparm.getDVBS(sparm);
                        switch(type)
                        {
                                case feSatellite:
                                        eDVBFrontendParametersSatellite sparm;
                                        oparm.getDVBS(sparm);

-                                       fillDictWithSatelliteData(dest, p, m_data[FREQ_OFFSET], sparm.orbital_position, sparm.polarisation);
+                                       fillDictWithSatelliteData(dest, p, m_data[FREQ_OFFSET], sparm);

                                        break;
                                case feCable:
                                        fillDictWithCableData(dest, p);
                                        break;
                                case feCable:
                                        fillDictWithCableData(dest, p);


@@ -1511,7 +1563,7 @@ void eDVBFrontend::getFrontendData(ePyObject dest)
                const char *tmp=0;
                PutToDict(dest, "tuner_number", m_slotid);
 
                const char *tmp=0;
                PutToDict(dest, "tuner_number", m_slotid);
 

-               if (supportsDeliverySystem(SYS_DVBS, true) || supportsDeliverySystem(SYS_DVBS2, true))
+               if (supportsDeliverySystem(SYS_DVBS, true) || supportsDeliverySystem(SYS_DVBS2, true) || supportsDeliverySystem(SYS_DVBS2X, true))

                {
                        tmp = "DVB-S";
                }
                {
                        tmp = "DVB-S";
                }


@@ -2009,12 +2061,16 @@ void eDVBFrontend::setFrontend(bool recvEvents)
                        {
                        case eDVBFrontendParametersSatellite::System_DVB_S: system = SYS_DVBS; break;
                        case eDVBFrontendParametersSatellite::System_DVB_S2: system = SYS_DVBS2; break;
                        {
                        case eDVBFrontendParametersSatellite::System_DVB_S: system = SYS_DVBS; break;
                        case eDVBFrontendParametersSatellite::System_DVB_S2: system = SYS_DVBS2; break;

+                       case eDVBFrontendParametersSatellite::System_DVB_S2X: system = SYS_DVBS2X; break;

                        };
                        switch(sparm.modulation)
                        {
                        case eDVBFrontendParametersSatellite::Modulation_QPSK: modulation = QPSK; break;
                        case eDVBFrontendParametersSatellite::Modulation_8PSK: modulation = PSK_8; break;
                        case eDVBFrontendParametersSatellite::Modulation_QAM16: modulation = QAM_16; break;
                        };
                        switch(sparm.modulation)
                        {
                        case eDVBFrontendParametersSatellite::Modulation_QPSK: modulation = QPSK; break;
                        case eDVBFrontendParametersSatellite::Modulation_8PSK: modulation = PSK_8; break;
                        case eDVBFrontendParametersSatellite::Modulation_QAM16: modulation = QAM_16; break;

+                       case eDVBFrontendParametersSatellite::Modulation_8APSK: modulation = APSK_8; break;
+                       case eDVBFrontendParametersSatellite::Modulation_16APSK: modulation = APSK_16; break;
+                       case eDVBFrontendParametersSatellite::Modulation_32APSK: modulation = APSK_32; break;

                        };
                        switch(sparm.pilot)
                        {
                        };
                        switch(sparm.pilot)
                        {


@@ -2028,7 +2084,7 @@ void eDVBFrontend::setFrontend(bool recvEvents)
                        case eDVBFrontendParametersSatellite::RollOff_alpha_0_25: rolloff = ROLLOFF_25; break;
                        case eDVBFrontendParametersSatellite::RollOff_alpha_0_35: rolloff = ROLLOFF_35; break;
                        };
                        case eDVBFrontendParametersSatellite::RollOff_alpha_0_25: rolloff = ROLLOFF_25; break;
                        case eDVBFrontendParametersSatellite::RollOff_alpha_0_35: rolloff = ROLLOFF_35; break;
                        };

-                       struct dtv_property p[10];
+                       struct dtv_property p[11];

                        struct dtv_properties cmdseq;
                        cmdseq.props = p;
                        p[0].cmd = DTV_CLEAR;
                        struct dtv_properties cmdseq;
                        cmdseq.props = p;
                        p[0].cmd = DTV_CLEAR;


@@ -2038,12 +2094,13 @@ void eDVBFrontend::setFrontend(bool recvEvents)
                        p[4].cmd = DTV_SYMBOL_RATE,     p[4].u.data = parm_u_qpsk_symbol_rate;
                        p[5].cmd = DTV_INNER_FEC,       p[5].u.data = parm_u_qpsk_fec_inner;
                        p[6].cmd = DTV_INVERSION,       p[6].u.data = parm_inversion;
                        p[4].cmd = DTV_SYMBOL_RATE,     p[4].u.data = parm_u_qpsk_symbol_rate;
                        p[5].cmd = DTV_INNER_FEC,       p[5].u.data = parm_u_qpsk_fec_inner;
                        p[6].cmd = DTV_INVERSION,       p[6].u.data = parm_inversion;

-                       if (system == SYS_DVBS2)
+                       if ((system == SYS_DVBS2) || (system == SYS_DVBS2X))

                        {
                                p[7].cmd = DTV_ROLLOFF,         p[7].u.data = rolloff;
                                p[8].cmd = DTV_PILOT,           p[8].u.data = pilot;
                        {
                                p[7].cmd = DTV_ROLLOFF,         p[7].u.data = rolloff;
                                p[8].cmd = DTV_PILOT,           p[8].u.data = pilot;

-                               p[9].cmd = DTV_TUNE;
-                               cmdseq.num = 10;
+                               p[9].cmd = DTV_STREAM_ID,       p[9].u.data = sparm.is_id | (sparm.pls_code << 8) | (sparm.pls_mode << 26);
+                               p[10].cmd = DTV_TUNE;
+                               cmdseq.num = 11;

                        }
                        else
                        {
                        }
                        else
                        {


@@ -2152,8 +2209,7 @@ RESULT eDVBFrontend::prepare_sat(const eDVBFrontendParametersSatellite &feparm,
        res = m_sec->prepare(*this, parm, feparm, 1 << m_slotid, tunetimeout);
        if (!res)
        {
        res = m_sec->prepare(*this, parm, feparm, 1 << m_slotid, tunetimeout);
        if (!res)
        {

-               eDebugNoSimulate("prepare_sat System %d Freq %d Pol %d SR %d INV %d FEC %d orbpos %d system %d modulation %d pilot %d, rolloff %d",
-                       feparm.system,
+               eDebugNoSimulate("prepare_sat Freq %d Pol %d SR %d INV %d FEC %d orbpos %d system %d modulation %d pilot %d, rolloff %d, is_id %d, pls_mode %d, pls_code %d",

                        feparm.frequency,
                        feparm.polarisation,
                        feparm.symbol_rate,
                        feparm.frequency,
                        feparm.polarisation,
                        feparm.symbol_rate,


@@ -2163,7 +2219,10 @@ RESULT eDVBFrontend::prepare_sat(const eDVBFrontendParametersSatellite &feparm,
                        feparm.system,
                        feparm.modulation,
                        feparm.pilot,
                        feparm.system,
                        feparm.modulation,
                        feparm.pilot,

-                       feparm.rolloff);
+                       feparm.rolloff,
+                       feparm.is_id,
+                       feparm.pls_mode,
+                       feparm.pls_code);

                parm_u_qpsk_symbol_rate = feparm.symbol_rate;
                switch (feparm.inversion)
                {
                parm_u_qpsk_symbol_rate = feparm.symbol_rate;
                switch (feparm.inversion)
                {


@@ -2207,7 +2266,7 @@ RESULT eDVBFrontend::prepare_sat(const eDVBFrontendParametersSatellite &feparm,
                                        break;
                        }
                }
                                        break;
                        }
                }

-               else // DVB_S2
+               else if (feparm.system == eDVBFrontendParametersSatellite::System_DVB_S2)

                {
                        switch (feparm.fec)
                        {
                {
                        switch (feparm.fec)
                        {


@@ -2243,6 +2302,45 @@ RESULT eDVBFrontend::prepare_sat(const eDVBFrontendParametersSatellite &feparm,
                                        return -EINVAL;
                        }
                }
                                        return -EINVAL;
                        }
                }

+               else // DVB_S2X
+               {
+                       switch (feparm.fec)
+                       {
+                               case eDVBFrontendParametersSatellite::FEC_1_2:
+                                       parm_u_qpsk_fec_inner = FEC_S2_QPSK_1_2;
+                                       break;
+                               case eDVBFrontendParametersSatellite::FEC_2_3:
+                                       parm_u_qpsk_fec_inner = FEC_S2_QPSK_2_3;
+                                       break;
+                               case eDVBFrontendParametersSatellite::FEC_3_4:
+                                       parm_u_qpsk_fec_inner = FEC_S2_QPSK_3_4;
+                                       break;
+                               case eDVBFrontendParametersSatellite::FEC_3_5:
+                                       parm_u_qpsk_fec_inner = FEC_S2_QPSK_3_5;
+                                       break;
+                               case eDVBFrontendParametersSatellite::FEC_4_5:
+                                       parm_u_qpsk_fec_inner = FEC_S2_QPSK_4_5;
+                                       break;
+                               case eDVBFrontendParametersSatellite::FEC_5_6:
+                                       parm_u_qpsk_fec_inner = FEC_S2_QPSK_5_6;
+                                       break;
+                               case eDVBFrontendParametersSatellite::FEC_7_8:
+                                       parm_u_qpsk_fec_inner = FEC_S2_QPSK_7_8;
+                                       break;
+                               case eDVBFrontendParametersSatellite::FEC_8_9:
+                                       parm_u_qpsk_fec_inner = FEC_S2_QPSK_8_9;
+                                       break;
+                               case eDVBFrontendParametersSatellite::FEC_9_10:
+                                       parm_u_qpsk_fec_inner = FEC_S2_QPSK_9_10;
+                                       break;
+                               case eDVBFrontendParametersSatellite::FEC_13_45 ... eDVBFrontendParametersSatellite::FEC_26_45_L:
+                                       parm_u_qpsk_fec_inner = (fe_code_rate_t)((int)FEC_S2_QPSK_13_45 + (feparm.fec-eDVBFrontendParametersSatellite::FEC_13_45));
+                                       break;
+                               default:
+                                       eDebugNoSimulate("no valid fec for DVB-S2X set.. abort !!");
+                                       return -EINVAL;
+                       }
+               }

                // FIXME !!! get frequency range from tuner
                if ( parm_frequency < 900000 || parm_frequency > 2200000 )
                {
                // FIXME !!! get frequency range from tuner
                if ( parm_frequency < 900000 || parm_frequency > 2200000 )
                {


@@ -2827,13 +2925,18 @@ int eDVBFrontend::isCompatibleWith(ePtr<iDVBFrontendParameters> &feparm)
        if (type == eDVBFrontend::feSatellite)
        {
                eDVBFrontendParametersSatellite sat_parm;
        if (type == eDVBFrontend::feSatellite)
        {
                eDVBFrontendParametersSatellite sat_parm;

-               bool can_handle_dvbs, can_handle_dvbs2;
+               bool can_handle_dvbs, can_handle_dvbs2, can_handle_dvbs2x;

                can_handle_dvbs = supportsDeliverySystem(SYS_DVBS, true);
                can_handle_dvbs2 = supportsDeliverySystem(SYS_DVBS2, true);
                can_handle_dvbs = supportsDeliverySystem(SYS_DVBS, true);
                can_handle_dvbs2 = supportsDeliverySystem(SYS_DVBS2, true);

+               can_handle_dvbs2x = supportsDeliverySystem(SYS_DVBS2X, true);

                if (feparm->getDVBS(sat_parm) < 0)
                {
                        return 0;
                }
                if (feparm->getDVBS(sat_parm) < 0)
                {
                        return 0;
                }

+               if (sat_parm.system == eDVBFrontendParametersSatellite::System_DVB_S2X && !can_handle_dvbs2x)
+               {
+                       return 0;
+               }

                if (sat_parm.system == eDVBFrontendParametersSatellite::System_DVB_S2 && !can_handle_dvbs2)
                {
                        return 0;
                if (sat_parm.system == eDVBFrontendParametersSatellite::System_DVB_S2 && !can_handle_dvbs2)
                {
                        return 0;


@@ -2842,12 +2945,29 @@ int eDVBFrontend::isCompatibleWith(ePtr<iDVBFrontendParameters> &feparm)
                {
                        return 0;
                }
                {
                        return 0;
                }

+               bool multistream = (static_cast<unsigned int>(sat_parm.is_id) != NO_STREAM_ID_FILTER || (sat_parm.pls_code & 0x3FFFF) != 0 ||
+                                       (sat_parm.pls_mode & 3) != eDVBFrontendParametersSatellite::PLS_Unknown);
+
+               if (((sat_parm.system == eDVBFrontendParametersSatellite::System_DVB_S2)||(sat_parm.system == eDVBFrontendParametersSatellite::System_DVB_S2X)) && multistream && !is_multistream())
+               {
+                       return 0;
+               }

                score = m_sec ? m_sec->canTune(sat_parm, this, 1 << m_slotid) : 0;
                if (score > 1 && sat_parm.system == eDVBFrontendParametersSatellite::System_DVB_S && can_handle_dvbs2)
                {
                        /* prefer to use a S tuner, try to keep S2 free for S2 transponders */
                        score--;
                }
                score = m_sec ? m_sec->canTune(sat_parm, this, 1 << m_slotid) : 0;
                if (score > 1 && sat_parm.system == eDVBFrontendParametersSatellite::System_DVB_S && can_handle_dvbs2)
                {
                        /* prefer to use a S tuner, try to keep S2 free for S2 transponders */
                        score--;
                }

+               if (score > 1 && sat_parm.system == eDVBFrontendParametersSatellite::System_DVB_S2 && can_handle_dvbs2x)
+               {
+                       /* prefer to use a S2 tuner, try to keep S2X free for S2X transponders */
+                       score--;
+               }
+               if (score > 1 && is_multistream() && !multistream)
+               {
+                       /* prefer to use a non multistream tuner, try to keep multistream tuners free for multistream transponders */
+                       score--;
+               }

        }
 
        else if (type == eDVBFrontend::feCable)
        }
 
        else if (type == eDVBFrontend::feCable)


@@ -2933,17 +3053,18 @@ void eDVBFrontend::setDeliverySystemWhitelist(const std::vector<fe_delivery_syst
 
 bool eDVBFrontend::setSlotInfo(ePyObject obj)
 {
 
 bool eDVBFrontend::setSlotInfo(ePyObject obj)
 {

-       ePyObject Id, Descr, Enabled, IsDVBS2, IsDVBT2, frontendId;
-       if (!PyTuple_Check(obj) || PyTuple_Size(obj) != 6)
+       ePyObject Id, Descr, Enabled, IsDVBS2, IsDVBT2, IsDVBS2X, frontendId;
+       if (!PyTuple_Check(obj) || PyTuple_Size(obj) != 7)

                goto arg_error;
        Id = PyTuple_GET_ITEM(obj, 0);
        Descr = PyTuple_GET_ITEM(obj, 1);
        Enabled = PyTuple_GET_ITEM(obj, 2);
        IsDVBS2 = PyTuple_GET_ITEM(obj, 3);
        IsDVBT2 = PyTuple_GET_ITEM(obj, 4);
                goto arg_error;
        Id = PyTuple_GET_ITEM(obj, 0);
        Descr = PyTuple_GET_ITEM(obj, 1);
        Enabled = PyTuple_GET_ITEM(obj, 2);
        IsDVBS2 = PyTuple_GET_ITEM(obj, 3);
        IsDVBT2 = PyTuple_GET_ITEM(obj, 4);

-       frontendId = PyTuple_GET_ITEM(obj, 5);
+       IsDVBS2X = PyTuple_GET_ITEM(obj, 5);
+       frontendId = PyTuple_GET_ITEM(obj, 6);

        m_slotid = PyInt_AsLong(Id);
        m_slotid = PyInt_AsLong(Id);

-       if (!PyInt_Check(Id) || !PyString_Check(Descr) || !PyBool_Check(Enabled) || !PyBool_Check(IsDVBS2) || !PyBool_Check(IsDVBT2) || !PyInt_Check(frontendId))
+       if (!PyInt_Check(Id) || !PyString_Check(Descr) || !PyBool_Check(Enabled) || !PyBool_Check(IsDVBS2) || !PyBool_Check(IsDVBT2) || !PyBool_Check(IsDVBS2X) || !PyInt_Check(frontendId))

                goto arg_error;
        strcpy(m_description, PyString_AS_STRING(Descr));
        if (PyInt_AsLong(frontendId) == -1 || PyInt_AsLong(frontendId) != m_dvbid) {
                goto arg_error;
        strcpy(m_description, PyString_AS_STRING(Descr));
        if (PyInt_AsLong(frontendId) == -1 || PyInt_AsLong(frontendId) != m_dvbid) {


@@ -2967,12 +3088,23 @@ bool eDVBFrontend::setSlotInfo(ePyObject obj)
                /* HACK for legacy dvb api without DELSYS support */
                m_delsys[SYS_DVBT2] = true;
        }
                /* HACK for legacy dvb api without DELSYS support */
                m_delsys[SYS_DVBT2] = true;
        }

+       if (IsDVBS2X == Py_True)
+       {
+               /* HACK for legacy dvb api without DELSYS support */
+               m_delsys[SYS_DVBS2X] = true;
+       }

 
 

-       eDebugNoSimulate("setSlotInfo for dvb frontend %d to slotid %d, descr %s, need rotorworkaround %s, enabled %s, DVB-S2 %s, DVB-T2 %s",
-               m_dvbid, m_slotid, m_description, m_need_rotor_workaround ? "Yes" : "No", Enabled == Py_True ? "Yes" : "No", IsDVBS2 == Py_True ? "Yes" : "No", IsDVBT2 == Py_True ? "Yes" : "No" );
+       eDebugNoSimulate("setSlotInfo for dvb frontend %d to slotid %d, descr %s, need rotorworkaround %s, enabled %s, DVB-S2 %s, DVB-T2 %s, DVB-S2X %s",
+               m_dvbid, m_slotid, m_description, m_need_rotor_workaround ? "Yes" : "No", Enabled == Py_True ? "Yes" : "No", IsDVBS2 == Py_True ? "Yes" : "No", IsDVBT2 == Py_True ? "Yes" : "No", IsDVBS2X == Py_True ? "Yes" : "No");

        return true;
 arg_error:
        PyErr_SetString(PyExc_StandardError,
                "eDVBFrontend::setSlotInfo must get a tuple with first param slotid, second param slot description and third param enabled boolean");
        return false;
 }
        return true;
 arg_error:
        PyErr_SetString(PyExc_StandardError,
                "eDVBFrontend::setSlotInfo must get a tuple with first param slotid, second param slot description and third param enabled boolean");
        return false;
 }

+
+bool eDVBFrontend::is_multistream()
+{
+       return fe_info.caps & FE_CAN_MULTISTREAM;
+}
+

diff --git a/lib/dvb/frontend.h b/lib/dvb/frontend.h
index 6a8c39d..39d125a 100644 (file)
--- a/lib/dvb/frontend.h
+++ b/lib/dvb/frontend.h
@@ -87,6 +87,7 @@ private:
        std::map<fe_delivery_system_t, bool> m_delsys, m_delsys_whitelist;
        char m_filename[128];
        char m_description[128];
        std::map<fe_delivery_system_t, bool> m_delsys, m_delsys_whitelist;
        char m_filename[128];
        char m_description[128];

+       dvb_frontend_info fe_info;

        FRONTENDPARAMETERS parm;
        eDVBFrontendParameters oparm;
 
        FRONTENDPARAMETERS parm;
        eDVBFrontendParameters oparm;
 


@@ -163,6 +164,7 @@ public:
        bool isLoopTimerActive() { return m_tuneTimer->isActive(); }
        bool isScheduledSendDiseqc();
        void setUSBTuner(bool yesno) { m_is_usbtuner = yesno; }
        bool isLoopTimerActive() { return m_tuneTimer->isActive(); }
        bool isScheduledSendDiseqc();
        void setUSBTuner(bool yesno) { m_is_usbtuner = yesno; }

+       bool is_multistream();

 };
 
 #endif // SWIG
 };
 
 #endif // SWIG

diff --git a/lib/dvb/frontendparms.h b/lib/dvb/frontendparms.h
index b2a2cd7..5895023 100644 (file)
--- a/lib/dvb/frontendparms.h
+++ b/lib/dvb/frontendparms.h
@@ -22,15 +22,19 @@ struct eDVBFrontendParametersSatellite
        };
 
        enum {
        };
 
        enum {

-               FEC_Auto, FEC_1_2, FEC_2_3, FEC_3_4, FEC_5_6, FEC_7_8, FEC_8_9, FEC_3_5, FEC_4_5, FEC_9_10, FEC_None=15
+               FEC_Auto=0, FEC_1_2=1, FEC_2_3=2, FEC_3_4=3, FEC_5_6=4, FEC_7_8=5, FEC_8_9=6, FEC_3_5=7, FEC_4_5=8, FEC_9_10=9, FEC_None=15,
+               FEC_13_45=16, FEC_9_20=17, FEC_11_20=18, FEC_23_36=19, FEC_25_36=20,
+               FEC_13_18=21, FEC_26_45=22, FEC_28_45=23, FEC_7_9=24, FEC_77_90=25,
+               FEC_32_45=26, FEC_11_15=27, FEC_1_2_L=28, FEC_8_15_L=29, FEC_3_5_L=30,
+               FEC_2_3_L=31, FEC_5_9_L=32, FEC_26_45_L=33

        };
 
        enum {
        };
 
        enum {

-               System_DVB_S, System_DVB_S2
+               System_DVB_S, System_DVB_S2, System_DVB_S2X

        };
 
        enum {
        };
 
        enum {

-               Modulation_Auto, Modulation_QPSK, Modulation_8PSK, Modulation_QAM16
+               Modulation_Auto, Modulation_QPSK, Modulation_8PSK, Modulation_QAM16, Modulation_16APSK, Modulation_32APSK, Modulation_8APSK

        };
 
        // dvb-s2
        };
 
        // dvb-s2


@@ -42,9 +46,13 @@ struct eDVBFrontendParametersSatellite
                Pilot_Off, Pilot_On, Pilot_Unknown
        };
 
                Pilot_Off, Pilot_On, Pilot_Unknown
        };
 

+       enum {
+               PLS_Root, PLS_Gold, PLS_Combo, PLS_Unknown
+       };
+

        bool no_rotor_command_on_tune;
        unsigned int frequency, symbol_rate;
        bool no_rotor_command_on_tune;
        unsigned int frequency, symbol_rate;

-       int polarisation, fec, inversion, orbital_position, system, modulation, rolloff, pilot;
+       int polarisation, fec, inversion, orbital_position, system, modulation, rolloff, pilot, is_id, pls_mode, pls_code;

 };
 SWIG_ALLOW_OUTPUT_SIMPLE(eDVBFrontendParametersSatellite);
 
 };
 SWIG_ALLOW_OUTPUT_SIMPLE(eDVBFrontendParametersSatellite);
 

diff --git a/lib/dvb/scan.cpp b/lib/dvb/scan.cpp
index 46236dd..1906c12 100644 (file)
--- a/lib/dvb/scan.cpp
+++ b/lib/dvb/scan.cpp
@@ -868,15 +868,41 @@ void eDVBScan::channelDone()
                        {
                                case iDVBFrontend::feSatellite:
                                {
                        {
                                case iDVBFrontend::feSatellite:
                                {

+                                       char system_name[255];
+                                       char modulation_name[255];
+                                       memset(system_name, 0, sizeof(system_name));
+                                       memset(modulation_name, 0, sizeof(modulation_name));
+

                                        eDVBFrontendParametersSatellite parm;
                                        m_ch_current->getDVBS(parm);
                                        eDVBFrontendParametersSatellite parm;
                                        m_ch_current->getDVBS(parm);

+
+                                       if (parm.system == eDVBFrontendParametersSatellite::System_DVB_S2)
+                                               strcpy(system_name, "DVB-S2");
+                                       else if (parm.system == eDVBFrontendParametersSatellite::System_DVB_S2X)
+                                               strcpy(system_name, "DVB-S2X");
+                                       else
+                                               strcpy(system_name, "DVB-S");
+
+                                       if (parm.modulation == eDVBFrontendParametersSatellite::Modulation_QPSK)
+                                               strcpy(modulation_name, "QPSK");
+                                       else if (parm.modulation == eDVBFrontendParametersSatellite::Modulation_8PSK)
+                                               strcpy(modulation_name, "8PSK");
+                                       else if (parm.modulation == eDVBFrontendParametersSatellite::Modulation_8APSK)
+                                               strcpy(modulation_name, "8APSK");
+                                       else if (parm.modulation == eDVBFrontendParametersSatellite::Modulation_16APSK)
+                                               strcpy(modulation_name, "16APSK");
+                                       else if (parm.modulation == eDVBFrontendParametersSatellite::Modulation_32APSK)
+                                               strcpy(modulation_name, "32APSK");
+                                       else
+                                               strcpy(modulation_name, "8PSK");
+

                                        snprintf(sname, 255, "%d%c SID 0x%02x",
                                                        parm.frequency/1000,
                                                        parm.polarisation ? 'V' : 'H',
                                                        m_pmt_in_progress->first);
                                        snprintf(pname, 255, "%s %s %d%c %d.%d°%c",
                                        snprintf(sname, 255, "%d%c SID 0x%02x",
                                                        parm.frequency/1000,
                                                        parm.polarisation ? 'V' : 'H',
                                                        m_pmt_in_progress->first);
                                        snprintf(pname, 255, "%s %s %d%c %d.%d°%c",

-                                               parm.system ? "DVB-S2" : "DVB-S",
-                                               parm.modulation == 1 ? "QPSK" : "8PSK",
+                                               system_name,
+                                               modulation_name,

                                                parm.frequency/1000,
                                                parm.polarisation ? 'V' : 'H',
                                                parm.orbital_position/10,
                                                parm.frequency/1000,
                                                parm.polarisation ? 'V' : 'H',
                                                parm.orbital_position/10,

diff --git a/lib/python/Components/NimManager.py b/lib/python/Components/NimManager.py
old mode 100755 (executable)
new mode 100644 (file)
index b92ad92..017e57b
--- a/lib/python/Components/NimManager.py
+++ b/lib/python/Components/NimManager.py
@@ -153,7 +153,7 @@ class SecConfigure:
 
                for slot in nim_slots:
                        if slot.type is not None:
 
                for slot in nim_slots:
                        if slot.type is not None:

-                               used_nim_slots.append((slot.slot, slot.description, slot.config.configMode.value != "nothing" and True or False, slot.isCompatible("DVB-S2"), slot.isCompatible("DVB-T2"), slot.frontend_id is None and -1 or slot.frontend_id))
+                               used_nim_slots.append((slot.slot, slot.description, slot.config.configMode.value != "nothing" and True or False, slot.isCompatible("DVB-S2"), slot.isCompatible("DVB-T2"), slot.isCompatible("DVB-S2X"), slot.frontend_id is None and -1 or slot.frontend_id))

                eDVBResourceManager.getInstance().setFrontendSlotInformations(used_nim_slots)
 
                for slot in nim_slots:
                eDVBResourceManager.getInstance().setFrontendSlotInformations(used_nim_slots)
 
                for slot in nim_slots:


@@ -510,7 +510,7 @@ class NIM(object):
        def __init__(self, slot, type, description, has_outputs = True, internally_connectable = None, multi_type = {}, frontend_id = None, i2c = None, is_empty = False):
                self.slot = slot
 
        def __init__(self, slot, type, description, has_outputs = True, internally_connectable = None, multi_type = {}, frontend_id = None, i2c = None, is_empty = False):
                self.slot = slot
 

-               if type not in ("DVB-S", "DVB-C", "DVB-T", "DVB-S2", "DVB-T2", None):
+               if type not in ("DVB-S", "DVB-C", "DVB-T", "DVB-S2", "DVB-T2", "DVB-S2X", None):

                        print "warning: unknown NIM type %s, not using." % type
                        type = None
 
                        print "warning: unknown NIM type %s, not using." % type
                        type = None
 


@@ -528,7 +528,8 @@ class NIM(object):
                                "DVB-C": ("DVB-C", None),
                                "DVB-T": ("DVB-T", None),
                                "DVB-S2": ("DVB-S", "DVB-S2", None),
                                "DVB-C": ("DVB-C", None),
                                "DVB-T": ("DVB-T", None),
                                "DVB-S2": ("DVB-S", "DVB-S2", None),

-                               "DVB-T2": ("DVB-T", "DVB-T2", None)
+                               "DVB-T2": ("DVB-T", "DVB-T2", None),
+                               "DVB-S2X": ("DVB-S", "DVB-S2", "DVB-S2X", None),

                        }
 
        def getType(self):
                        }
 
        def getType(self):


@@ -558,7 +559,8 @@ class NIM(object):
                                "DVB-C": ("DVB-C",),
                                "DVB-T": ("DVB-T",),
                                "DVB-S2": ("DVB-S", "DVB-S2"),
                                "DVB-C": ("DVB-C",),
                                "DVB-T": ("DVB-T",),
                                "DVB-S2": ("DVB-S", "DVB-S2"),

-                               "DVB-T2": ("DVB-T", "DVB-T2",)
+                               "DVB-T2": ("DVB-T", "DVB-T2",),
+                               "DVB-S2X": ("DVB-S", "DVB-S2", "DVB-S2X"),

                        }
                return connectable[self.getType()]
 
                        }
                return connectable[self.getType()]
 


@@ -601,7 +603,16 @@ class NIM(object):
        # empty tuners are supported!
        def isSupported(self):
                return (self.frontend_id is not None) or self.__is_empty
        # empty tuners are supported!
        def isSupported(self):
                return (self.frontend_id is not None) or self.__is_empty

-       
+
+       def isMultistream(self):
+               multistream = self.frontend_id is not None and eDVBResourceManager.getInstance().frontendIsMultistream(self.frontend_id) or False
+               # HACK due to poor support for VTUNER_SET_FE_INFO
+               # When vtuner does not accept fe_info we have to fallback to detection using tuner name
+               # More tuner names will be added when confirmed as multistream (FE_CAN_MULTISTREAM)
+               if not multistream and "TBS" in self.description:
+                       multistream = True
+               return multistream
+

        # returns dict {<slotid>: <type>}
        def getMultiTypeList(self):
                return self.multi_type
        # returns dict {<slotid>: <type>}
        def getMultiTypeList(self):
                return self.multi_type


@@ -615,6 +626,7 @@ class NIM(object):
                        "DVB-C": "DVB-C",
                        "DVB-S2": "DVB-S2",
                        "DVB-T2": "DVB-T2",
                        "DVB-C": "DVB-C",
                        "DVB-S2": "DVB-S2",
                        "DVB-T2": "DVB-T2",

+                       "DVB-S2X": "DVB-S2X",

                        None: _("empty")
                        }[self.getType()]
 
                        None: _("empty")
                        }[self.getType()]
 


@@ -798,13 +810,20 @@ class NimManager:
 
                        # get MultiType from DTV_ENUM_DELSYS
                        if entry["frontend_device"] is not None:
 
                        # get MultiType from DTV_ENUM_DELSYS
                        if entry["frontend_device"] is not None:

-                               types = [type for type in ["DVB-C", "DVB-T2", "DVB-T", "DVB-S2", "DVB-S", "ATSC"] if eDVBResourceManager.getInstance().frontendIsCompatible(entry["frontend_device"], type)]
+                               types = [type for type in ["DVB-C", "DVB-T2", "DVB-T", "DVB-S2", "DVB-S", "ATSC", "DVB-S2X"] if eDVBResourceManager.getInstance().frontendIsCompatible(entry["frontend_device"], type)]

                                if "DVB-T2" in types and "DVB-T" in types:
                                        # DVB-T2 implies DVB-T support
                                        types.remove("DVB-T")
                                if "DVB-S2" in types and "DVB-S" in types:
                                        # DVB-S2 implies DVB-S support
                                        types.remove("DVB-S")
                                if "DVB-T2" in types and "DVB-T" in types:
                                        # DVB-T2 implies DVB-T support
                                        types.remove("DVB-T")
                                if "DVB-S2" in types and "DVB-S" in types:
                                        # DVB-S2 implies DVB-S support
                                        types.remove("DVB-S")

+                               if "DVB-S2X" in types:
+                                       if "DVB-S" in types:
+                                               # DVB-S2X implies DVB-S support
+                                               types.remove("DVB-S")
+                                       if "DVB-S2" in types:
+                                               # DVB-S2X implies DVB-S2 support
+                                               types.remove("DVB-S2")

                                if len(types) > 1:
                                        entry["multi_type"] = {}
                                        for type in types:
                                if len(types) > 1:
                                        entry["multi_type"] = {}
                                        for type in types:


@@ -841,6 +860,9 @@ class NimManager:
                                list.append(x.slot)
                return list
 
                                list.append(x.slot)
                return list
 

+       def isSupportMultistream(self, slotid):
+               return self.getNim(slotid).isMultistream()
+

        def __init__(self):
                self.satList = [ ]
                self.cablesList = []
        def __init__(self):
                self.satList = [ ]
                self.cablesList = []


@@ -908,6 +930,8 @@ class NimManager:
                        type = "DVB-S"
                elif type == "DVB-T2":
                        type = "DVB-T"
                        type = "DVB-S"
                elif type == "DVB-T2":
                        type = "DVB-T"

+               elif type == "DVB-S2X":
+                       type = "DVB-S"

                nimList = self.getNimListOfType(type, slotid)
                for nim in nimList[:]:
                        mode = self.getNimConfig(nim)
                nimList = self.getNimListOfType(type, slotid)
                for nim in nimList[:]:
                        mode = self.getNimConfig(nim)


@@ -921,6 +945,8 @@ class NimManager:
                        type = "DVB-S"
                elif type == "DVB-T2":
                        type = "DVB-T"
                        type = "DVB-S"
                elif type == "DVB-T2":
                        type = "DVB-T"

+               elif type == "DVB-S2X":
+                       type = "DVB-S"

                nimList = self.getNimListOfType(type, slotid)
                positionerList = []
                for nim in nimList[:]:
                nimList = self.getNimListOfType(type, slotid)
                positionerList = []
                for nim in nimList[:]:

diff --git a/lib/python/Components/ServiceScan.py b/lib/python/Components/ServiceScan.py
index 6a82ade..3a405f2 100644 (file)
--- a/lib/python/Components/ServiceScan.py
+++ b/lib/python/Components/ServiceScan.py
@@ -54,9 +54,11 @@ class ServiceScan:
                                                else:
                                                        network = ("%s %d.%d %s") % (sat_name, orb_pos / 10, orb_pos % 10, h)
                                                tp_text = ("%s %s %d%c / %d / %s") %( { tp.System_DVB_S : "DVB-S",
                                                else:
                                                        network = ("%s %d.%d %s") % (sat_name, orb_pos / 10, orb_pos % 10, h)
                                                tp_text = ("%s %s %d%c / %d / %s") %( { tp.System_DVB_S : "DVB-S",

-                                                       tp.System_DVB_S2 : "DVB-S2" }.get(tp.system, tp.System_DVB_S),
+                                                       tp.System_DVB_S2 : "DVB-S2" , tp.System_DVB_S2X : "DVB-S2X"}.get(tp.system, tp.System_DVB_S),

                                                        { tp.Modulation_Auto : "Auto", tp.Modulation_QPSK : "QPSK",
                                                        { tp.Modulation_Auto : "Auto", tp.Modulation_QPSK : "QPSK",

-                                                               tp.Modulation_8PSK : "8PSK", tp.Modulation_QAM16 : "QAM16" }.get(tp.modulation, tp.Modulation_QPSK),
+                                                               tp.Modulation_8PSK : "8PSK", tp.Modulation_QAM16 : "QAM16",
+                                                               tp.Modulation_8APSK : "8APSK", tp.Modulation_16APSK : "16APSK",
+                                                               tp.Modulation_32APSK : "32APSK"}.get(tp.modulation, tp.Modulation_QPSK),

                                                        tp.frequency/1000,
                                                        { tp.Polarisation_Horizontal : 'H', tp.Polarisation_Vertical : 'V', tp.Polarisation_CircularLeft : 'L',
                                                                tp.Polarisation_CircularRight : 'R' }.get(tp.polarisation, tp.Polarisation_Horizontal),
                                                        tp.frequency/1000,
                                                        { tp.Polarisation_Horizontal : 'H', tp.Polarisation_Vertical : 'V', tp.Polarisation_CircularLeft : 'L',
                                                                tp.Polarisation_CircularRight : 'R' }.get(tp.polarisation, tp.Polarisation_Horizontal),


@@ -64,7 +66,13 @@ class ServiceScan:
                                                        { tp.FEC_Auto : "AUTO", tp.FEC_1_2 : "1/2", tp.FEC_2_3 : "2/3",
                                                                tp.FEC_3_4 : "3/4", tp.FEC_5_6 : "5/6", tp.FEC_7_8 : "7/8",
                                                                tp.FEC_8_9 : "8/9", tp.FEC_3_5 : "3/5", tp.FEC_4_5 : "4/5",
                                                        { tp.FEC_Auto : "AUTO", tp.FEC_1_2 : "1/2", tp.FEC_2_3 : "2/3",
                                                                tp.FEC_3_4 : "3/4", tp.FEC_5_6 : "5/6", tp.FEC_7_8 : "7/8",
                                                                tp.FEC_8_9 : "8/9", tp.FEC_3_5 : "3/5", tp.FEC_4_5 : "4/5",

-                                                               tp.FEC_9_10 : "9/10", tp.FEC_None : "NONE" }.get(tp.fec, tp.FEC_Auto))
+                                                               tp.FEC_9_10 : "9/10", tp.FEC_None : "NONE",
+                                                               tp.FEC_13_45 : "13/45", tp.FEC_9_20 : "9/20", tp.FEC_11_20 : "11/20", tp.FEC_23_36 : "23/36", tp.FEC_25_36 : "25/36",
+                                                               tp.FEC_13_18 : "13/18", tp.FEC_26_45 : "26/45", tp.FEC_28_45 : "28/45", tp.FEC_7_9 : "7/9", tp.FEC_77_90 : "77/90",
+                                                               tp.FEC_32_45 : "32/45", tp.FEC_11_15 : "11/15", tp.FEC_1_2_L : "1/2-L", tp.FEC_8_15_L : "8/15-L", tp.FEC_3_5_L : "3/5-L",
+                                                               tp.FEC_2_3_L : "2/3-L", tp.FEC_5_9_L : "5/9-L", tp.FEC_26_45_L : "26/45-L"}.get(tp.fec, tp.FEC_Auto))
+                                               if tp.is_id > -1 and tp.system in (tp.System_DVB_S2, tp.System_DVB_S2X):
+                                                       tp_text = ("%s IS %d") % (tp_text, tp.is_id)

                                        elif tp_type == iDVBFrontend.feCable:
                                                network = _("Cable")
                                                tp = transponder.getDVBC()
                                        elif tp_type == iDVBFrontend.feCable:
                                                network = _("Cable")
                                                tp = transponder.getDVBC()

diff --git a/lib/python/Components/TuneTest.py b/lib/python/Components/TuneTest.py
index 44b1909..9fb5143 100644 (file)
--- a/lib/python/Components/TuneTest.py
+++ b/lib/python/Components/TuneTest.py
@@ -5,8 +5,7 @@ class Tuner:
                self.frontend = frontend
                self.ignore_rotor = ignore_rotor
 
                self.frontend = frontend
                self.ignore_rotor = ignore_rotor
 

-       # transponder = (frequency, symbolrate, polarisation, fec, inversion, orbpos, system, modulation, rolloff, pilot, tsid, onid)
-       #                    0         1             2         3       4         5       6        7          8       9      10    11
+       # transponder = (0:frequency 1:symbolrate 2:polarisation 3:fec 4:inversion 5:orbpos 6:system 7:modulation 8:rolloff 9:pilot 10:is_id 11:pls_mode 12:pls_code 13:tsid 14:onid)

        def tune(self, transponder):
                if self.frontend:
                        print "tuning to transponder with data", transponder
        def tune(self, transponder):
                if self.frontend:
                        print "tuning to transponder with data", transponder


@@ -21,6 +20,14 @@ class Tuner:
                        parm.modulation = transponder[7]
                        parm.rolloff = transponder[8]
                        parm.pilot = transponder[9]
                        parm.modulation = transponder[7]
                        parm.rolloff = transponder[8]
                        parm.pilot = transponder[9]

+                       if len(transponder) > 12:
+                               parm.is_id = transponder[10]
+                               parm.pls_mode = transponder[11]
+                               parm.pls_code = transponder[12]
+                       else:
+                               parm.is_id = -1
+                               parm.pls_mode = eDVBFrontendParametersSatellite.PLS_Unknown
+                               parm.pls_code = 0

                        feparm = eDVBFrontendParameters()
                        feparm.setDVBS(parm, self.ignore_rotor)
                        self.lastparm = feparm
                        feparm = eDVBFrontendParameters()
                        feparm.setDVBS(parm, self.ignore_rotor)
                        self.lastparm = feparm


@@ -103,8 +110,8 @@ class TuneTest:
                                pidsFailed = False
                                if self.checkPIDs:
                                        if self.currTuned is not None:
                                pidsFailed = False
                                if self.checkPIDs:
                                        if self.currTuned is not None:

-                                               if self.tsid != self.currTuned[10] or self.onid != self.currTuned[11]:
-                                                       self.failedTune.append([self.currTuned, self.oldTuned, "pids_failed", {"real": (self.tsid, self.onid), "expected": (self.currTuned[10], self.currTuned[11])}, dict])  # last parameter is the frontend status
+                                               if self.tsid != self.currTuned[13] or self.onid != self.currTuned[14]:
+                                                       self.failedTune.append([self.currTuned, self.oldTuned, "pids_failed", {"real": (self.tsid, self.onid), "expected": (self.currTuned[13], self.currTuned[14])}, dict])  # last parameter is the frontend status

                                                        pidsFailed = True
                                                else:
                                                        self.successfullyTune.append([self.currTuned, self.oldTuned, dict])  # 3rd parameter is the frontend status
                                                        pidsFailed = True
                                                else:
                                                        self.successfullyTune.append([self.currTuned, self.oldTuned, dict])  # 3rd parameter is the frontend status


@@ -141,7 +148,7 @@ class TuneTest:
                        # check for tsid != -1 and onid != -1 
                        print "index:", index
                        print "len(self.transponderlist):", len(self.transponderlist)
                        # check for tsid != -1 and onid != -1 
                        print "index:", index
                        print "len(self.transponderlist):", len(self.transponderlist)

-                       while (index < len(self.transponderlist) and (self.transponderlist[index][10] == -1 or self.transponderlist[index][11] == -1)):
+                       while (index < len(self.transponderlist) and (self.transponderlist[index][13] == -1 or self.transponderlist[index][14] == -1)):

                                index += 1
                print "FirstTransponder final index:", index
                return index
                                index += 1
                print "FirstTransponder final index:", index
                return index


@@ -154,7 +161,7 @@ class TuneTest:
                        # check for tsid != -1 and onid != -1 
                        print "index:", index
                        print "len(self.transponderlist):", len(self.transponderlist)
                        # check for tsid != -1 and onid != -1 
                        print "index:", index
                        print "len(self.transponderlist):", len(self.transponderlist)

-                       while (index < len(self.transponderlist) and (self.transponderlist[index][10] == -1 or self.transponderlist[index][11] == -1)):
+                       while (index < len(self.transponderlist) and (self.transponderlist[index][13] == -1 or self.transponderlist[index][14] == -1)):

                                index += 1
 
                print "next transponder index:", index
                                index += 1
 
                print "next transponder index:", index


@@ -204,8 +211,7 @@ class TuneTest:
                self.progressCallback((self.getProgressLength(), self.tuningtransponder, self.STATUS_START, self.currTuned))
                self.timer.start(100, True)
        
                self.progressCallback((self.getProgressLength(), self.tuningtransponder, self.STATUS_START, self.currTuned))
                self.timer.start(100, True)
        

-       # transponder = (frequency, symbolrate, polarisation, fec, inversion, orbpos, <system>, <modulation>, <rolloff>, <pilot>, <tsid>, <onid>)
-       #                    0         1             2         3       4         5       6        7              8         9        10       11
+       # transponder = (0:frequency 1:symbolrate 2:polarisation 3:fec 4:inversion 5:orbpos 6:system 7:modulation 8:rolloff 9:pilot 10:is_id 11:pls_mode 12:pls_code 13:tsid 14:onid)

        def addTransponder(self, transponder):
                self.transponderlist.append(transponder)
                
        def addTransponder(self, transponder):
                self.transponderlist.append(transponder)
                

diff --git a/lib/python/Plugins/SystemPlugins/Blindscan/plugin.py b/lib/python/Plugins/SystemPlugins/Blindscan/plugin.py
index 82ce819..aa80aa2 100644 (file)
--- a/lib/python/Plugins/SystemPlugins/Blindscan/plugin.py
+++ b/lib/python/Plugins/SystemPlugins/Blindscan/plugin.py
@@ -199,7 +199,7 @@ class Blindscan(ConfigListScreen, Screen):
                                defaultSat["inversion"] = frontendData.get("inversion", eDVBFrontendParametersSatellite.Inversion_Unknown)
                                defaultSat["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000
                                defaultSat["polarization"] = frontendData.get("polarization", eDVBFrontendParametersSatellite.Polarisation_Horizontal)
                                defaultSat["inversion"] = frontendData.get("inversion", eDVBFrontendParametersSatellite.Inversion_Unknown)
                                defaultSat["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000
                                defaultSat["polarization"] = frontendData.get("polarization", eDVBFrontendParametersSatellite.Polarisation_Horizontal)

-                               if defaultSat["system"] == eDVBFrontendParametersSatellite.System_DVB_S2:
+                               if defaultSat["system"] in (eDVBFrontendParametersSatellite.System_DVB_S2, eDVBFrontendParametersSatellite.System_DVB_S2X):

                                        defaultSat["fec_s2"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)
                                        defaultSat["rolloff"] = frontendData.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35)
                                        defaultSat["pilot"] = frontendData.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown)
                                        defaultSat["fec_s2"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)
                                        defaultSat["rolloff"] = frontendData.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35)
                                        defaultSat["pilot"] = frontendData.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown)


@@ -305,7 +305,7 @@ class Blindscan(ConfigListScreen, Screen):
                print "cur is", cur
                if cur == self.tunerEntry or \
                        cur == self.systemEntry or \
                print "cur is", cur
                if cur == self.tunerEntry or \
                        cur == self.systemEntry or \

-                       (self.modulationEntry and self.systemEntry[1].value == eDVBFrontendParametersSatellite.System_DVB_S2 and cur == self.modulationEntry):
+                       (self.modulationEntry and (self.systemEntry[1].value in (eDVBFrontendParametersSatellite.System_DVB_S2, eDVBFrontendParametersSatellite.System_DVB_S2X)) and cur == self.modulationEntry):

                        self.createSetup()
 
        def checkSettings(self):
                        self.createSetup()
 
        def checkSettings(self):


@@ -506,7 +506,8 @@ class Blindscan(ConfigListScreen, Screen):
                                if data[0] == 'OK':
                                        parm = eDVBFrontendParametersSatellite()
                                        sys = { "DVB-S" : eDVBFrontendParametersSatellite.System_DVB_S,
                                if data[0] == 'OK':
                                        parm = eDVBFrontendParametersSatellite()
                                        sys = { "DVB-S" : eDVBFrontendParametersSatellite.System_DVB_S,

-                                               "DVB-S2" : eDVBFrontendParametersSatellite.System_DVB_S2}
+                                               "DVB-S2" : eDVBFrontendParametersSatellite.System_DVB_S2,
+                                               "DVB-S2X" : eDVBFrontendParametersSatellite.System_DVB_S2X}

                                        qam = { "QPSK" : parm.Modulation_QPSK,
                                                "8PSK" : parm.Modulation_8PSK}
                                        inv = { "INVERSION_OFF" : parm.Inversion_Off,
                                        qam = { "QPSK" : parm.Modulation_QPSK,
                                                "8PSK" : parm.Modulation_8PSK}
                                        inv = { "INVERSION_OFF" : parm.Inversion_Off,


@@ -521,7 +522,11 @@ class Blindscan(ConfigListScreen, Screen):
                                                "FEC_8_9" : parm.FEC_8_9,
                                                "FEC_3_5" : parm.FEC_3_5,
                                                "FEC_9_10" : parm.FEC_9_10,
                                                "FEC_8_9" : parm.FEC_8_9,
                                                "FEC_3_5" : parm.FEC_3_5,
                                                "FEC_9_10" : parm.FEC_9_10,

-                                               "FEC_NONE" : parm.FEC_None}
+                                               "FEC_NONE" : parm.FEC_None, 
+                                               "FEC_13_45" : parm.FEC_13_45, "FEC_9_20" : parm.FEC_9_20, "FEC_11_20" : parm.FEC_11_20, "FEC_23_36" : parm.FEC_23_36, "FEC_25_36" : parm.FEC_25_36,
+                                               "FEC_13_18" : parm.FEC_13_18, "FEC_26_45" : parm.FEC_26_45, "FEC_28_45" : parm.FEC_28_45, "FEC_7_9" : parm.FEC_7_9, "FEC_77_90" : parm.FEC_77_90,
+                                               "FEC_32_45" : parm.FEC_32_45, "FEC_11_15" : parm.FEC_11_15, "FEC_1_2_L" : parm.FEC_1_2_L, "FEC_8_15_L" : parm.FEC_8_15_L, "FEC_3_5_L" : parm.FEC_3_5_L,
+                                               "FEC_2_3_L" : parm.FEC_2_3_L, "FEC_5_9_L" : parm.FEC_5_9_L, "FEC_26_45_L" : parm.FEC_26_45_L}

                                        roll ={ "ROLLOFF_20" : parm.RollOff_alpha_0_20,
                                                "ROLLOFF_25" : parm.RollOff_alpha_0_25,
                                                "ROLLOFF_35" : parm.RollOff_alpha_0_35}
                                        roll ={ "ROLLOFF_20" : parm.RollOff_alpha_0_20,
                                                "ROLLOFF_25" : parm.RollOff_alpha_0_25,
                                                "ROLLOFF_35" : parm.RollOff_alpha_0_35}


@@ -541,6 +546,9 @@ class Blindscan(ConfigListScreen, Screen):
                                                parm.fec = fec[data[7]]
                                                parm.modulation = qam[data[8]]
                                                parm.rolloff = roll[data[9]]
                                                parm.fec = fec[data[7]]
                                                parm.modulation = qam[data[8]]
                                                parm.rolloff = roll[data[9]]

+                                               parm.is_id = -1
+                                               parm.pls_mode = eDVBFrontendParametersSatellite.PLS_Unknown
+                                               parm.pls_code = 0

                                                self.tmp_tplist.append(parm)
                                        except: pass
                self.blindscan_session.close(True)
                                                self.tmp_tplist.append(parm)
                                        except: pass
                self.blindscan_session.close(True)

diff --git a/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py b/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py
index 4dcf6c6..acb2a2d 100644 (file)
--- a/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py
+++ b/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py
@@ -281,7 +281,7 @@ class DiseqcTester(Screen, TuneTest, ResultParser):
                for sat in nimmanager.getSatListForNim(self.feid):
                        for transponder in nimmanager.getTransponders(sat[0]):
                                #print transponder
                for sat in nimmanager.getSatListForNim(self.feid):
                        for transponder in nimmanager.getTransponders(sat[0]):
                                #print transponder

-                               mytransponder = (transponder[1] / 1000, transponder[2] / 1000, transponder[3], transponder[4], transponder[7], sat[0], transponder[5], transponder[6], transponder[8], transponder[9], transponder[10], transponder[11])
+                               mytransponder = (transponder[1] / 1000, transponder[2] / 1000, transponder[3], transponder[4], transponder[7], sat[0], transponder[5], transponder[6], transponder[8], transponder[9], transponder[10], transponder[11], transponder[12], transponder[13], transponder[14])

                                self.analyseTransponder(mytransponder)
 
        def getIndexForTransponder(self, transponder):
                                self.analyseTransponder(mytransponder)
 
        def getIndexForTransponder(self, transponder):

diff --git a/lib/python/Plugins/SystemPlugins/PositionerSetup/plugin.py b/lib/python/Plugins/SystemPlugins/PositionerSetup/plugin.py
index e097117..a900350 100644 (file)
--- a/lib/python/Plugins/SystemPlugins/PositionerSetup/plugin.py
+++ b/lib/python/Plugins/SystemPlugins/PositionerSetup/plugin.py
@@ -10,11 +10,13 @@ from Plugins.Plugin import PluginDescriptor
 from Components.Label import Label
 from Components.ConfigList import ConfigList
 from Components.TunerInfo import TunerInfo
 from Components.Label import Label
 from Components.ConfigList import ConfigList
 from Components.TunerInfo import TunerInfo

-from Components.ActionMap import ActionMap
+from Components.ActionMap import NumberActionMap, ActionMap

 from Components.NimManager import nimmanager
 from Components.MenuList import MenuList
 from Components.config import ConfigSatlist, ConfigNothing, ConfigSelection, ConfigSubsection, KEY_LEFT, KEY_RIGHT, getConfigListEntry
 from Components.TuneTest import Tuner
 from Components.NimManager import nimmanager
 from Components.MenuList import MenuList
 from Components.config import ConfigSatlist, ConfigNothing, ConfigSelection, ConfigSubsection, KEY_LEFT, KEY_RIGHT, getConfigListEntry
 from Components.TuneTest import Tuner

+from Components.ConfigList import ConfigListScreen
+from Components.config import config, ConfigSubsection, ConfigSelection, ConfigInteger, getConfigListEntry

 from Tools.Transponder import ConvertToHumanReadable
 
 from time import sleep
 from Tools.Transponder import ConvertToHumanReadable
 
 from time import sleep


@@ -88,7 +90,10 @@ class PositionerSetup(Screen):
                        cur.get("system", eDVBFrontendParametersSatellite.System_DVB_S),
                        cur.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK),
                        cur.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35),
                        cur.get("system", eDVBFrontendParametersSatellite.System_DVB_S),
                        cur.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK),
                        cur.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35),

-                       cur.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown))
+                       cur.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown),
+                       cur.get("is_id", -1),
+                       cur.get("pls_mode", eDVBFrontendParametersSatellite.PLS_Unknown),
+                       cur.get("pls_code", 0))

 
                self.tuner.tune(tp)
                self.createConfig()
 
                self.tuner.tune(tp)
                self.createConfig()


@@ -406,9 +411,7 @@ class Diseqc:
                                sleep(0.05)
                                self.frontend.sendDiseqc(cmd) # send 2nd time
 
                                sleep(0.05)
                                self.frontend.sendDiseqc(cmd) # send 2nd time
 

-tuning = None
-
-class TunerScreen(ScanSetup):
+class TunerScreen(ConfigListScreen, Screen):

        skin = """
                <screen position="90,100" size="520,400" title="Tune">
                        <widget name="config" position="20,10" size="460,350" scrollbarMode="showOnDemand" />
        skin = """
                <screen position="90,100" size="520,400" title="Tune">
                        <widget name="config" position="20,10" size="460,350" scrollbarMode="showOnDemand" />


@@ -418,24 +421,40 @@ class TunerScreen(ScanSetup):
        def __init__(self, session, feid, fe_data):
                self.feid = feid
                self.fe_data = fe_data
        def __init__(self, session, feid, fe_data):
                self.feid = feid
                self.fe_data = fe_data

-               ScanSetup.__init__(self, session)
-               self["introduction"].setText("")
+               Screen.__init__(self, session)
+               ConfigListScreen.__init__(self, None)
+               self.createConfig(fe_data)
+               self.createSetup()
+               self.tuning.sat.addNotifier(self.tuningSatChanged)
+               self.tuning.type.addNotifier(self.tuningTypeChanged)
+               self.scan_sat.system.addNotifier(self.systemChanged)
+               self.scan_sat.system_dvbs2x.addNotifier(self.systemChanged)
+               self.scan_sat.is_id_bool.addNotifier(self.isIdChanged, initial_call = False)
+               self.scan_sat.pls_mode.addNotifier(self.plsModeChanged, initial_call = False)
+
+               self["actions"] = NumberActionMap(["SetupActions"],
+               {
+                       "ok": self.keyGo,
+                       "cancel": self.keyCancel,
+               }, -2)
+
+               self["introduction"] = Label(_(" "))

 
        def createSetup(self):
 
        def createSetup(self):

-               self.typeOfTuningEntry = None
-               self.satEntry = None

                self.list = []
                self.list = []

-               self.typeOfTuningEntry = getConfigListEntry(_('Tune'), tuning.type)
-               self.list.append(self.typeOfTuningEntry)
-               self.satEntry = getConfigListEntry(_('Satellite'), tuning.sat)
-               self.list.append(self.satEntry)
+               self.list.append(getConfigListEntry(_('Tune'), self.tuning.type) )
+               self.list.append(getConfigListEntry(_('Satellite'), self.tuning.sat)    )
+
+               self.is_id_boolEntry = None
+               self.plsModeEntry = None

                nim = nimmanager.nim_slots[self.feid]
                nim = nimmanager.nim_slots[self.feid]

-               self.systemEntry = None
-               
-               if tuning.type.value == "manual_transponder":
-                       if nim.isCompatible("DVB-S2"):
-                               self.systemEntry = getConfigListEntry(_('System'), self.scan_sat.system)
-                               self.list.append(self.systemEntry)
+               if self.tuning.type.value == "manual_transponder":
+                       scan_sat_system_value = self.scan_sat.system.value
+                       if nim.isCompatible("DVB-S2X"):
+                               scan_sat_system_value = self.scan_sat.system_dvbs2x.value
+                               self.list.append(getConfigListEntry(_('System'), self.scan_sat.system_dvbs2x))
+                       elif nim.isCompatible("DVB-S2"):
+                               self.list.append(getConfigListEntry(_('System'), self.scan_sat.system))

                        else:
                                # downgrade to dvb-s, in case a -s2 config was active
                                self.scan_sat.system.value = eDVBFrontendParametersSatellite.System_DVB_S
                        else:
                                # downgrade to dvb-s, in case a -s2 config was active
                                self.scan_sat.system.value = eDVBFrontendParametersSatellite.System_DVB_S


@@ -443,49 +462,241 @@ class TunerScreen(ScanSetup):
                        self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion))
                        self.list.append(getConfigListEntry(_('Symbol rate'), self.scan_sat.symbolrate))
                        self.list.append(getConfigListEntry(_('Polarization'), self.scan_sat.polarization))
                        self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion))
                        self.list.append(getConfigListEntry(_('Symbol rate'), self.scan_sat.symbolrate))
                        self.list.append(getConfigListEntry(_('Polarization'), self.scan_sat.polarization))

-                       if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S:
+                       if scan_sat_system_value == eDVBFrontendParametersSatellite.System_DVB_S:

                                self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec))
                                self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec))

-                       elif self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2:
+                       elif scan_sat_system_value == eDVBFrontendParametersSatellite.System_DVB_S2:

                                self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2))
                                self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation)
                                self.list.append(self.modulationEntry)
                                self.list.append(getConfigListEntry(_('Roll-off'), self.scan_sat.rolloff))
                                self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot))
                                self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2))
                                self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation)
                                self.list.append(self.modulationEntry)
                                self.list.append(getConfigListEntry(_('Roll-off'), self.scan_sat.rolloff))
                                self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot))

-               elif tuning.type.value == "predefined_transponder":
-                       self.list.append(getConfigListEntry(_("Transponder"), tuning.transponder))
+                       elif scan_sat_system_value == eDVBFrontendParametersSatellite.System_DVB_S2X:
+                               if self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_QPSK:
+                                       self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_qpsk))
+                               elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_8PSK:
+                                       self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_8psk))
+                               elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_8APSK:
+                                       self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_8apsk))
+                               elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_16APSK:
+                                       self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_16apsk))
+                               elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_32APSK:
+                                       self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_32apsk))
+                               self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation_dvbs2x)
+                               self.list.append(self.modulationEntry)
+                               self.list.append(getConfigListEntry(_('Roll-off'), self.scan_sat.rolloff))
+                               self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot))
+                       if scan_sat_system_value in (eDVBFrontendParametersSatellite.System_DVB_S2, eDVBFrontendParametersSatellite.System_DVB_S2X):
+                               if nim.isMultistream():
+                                       self.is_id_boolEntry = getConfigListEntry(_('Transport Stream Type'), self.scan_sat.is_id_bool)
+                                       self.list.append(self.is_id_boolEntry)
+                                       if self.scan_sat.is_id_bool.value:
+                                               self.list.append(getConfigListEntry(_('Input Stream ID'), self.scan_sat.is_id))
+                                               self.plsModeEntry = getConfigListEntry(_('PLS Mode'), self.scan_sat.pls_mode)
+                                               self.list.append(self.plsModeEntry)
+                                               if self.scan_sat.pls_mode.value != eDVBFrontendParametersSatellite.PLS_Unknown:
+                                                       self.list.append(getConfigListEntry(_('PLS Code'), self.scan_sat.pls_code))
+               elif self.tuning.type.value == "predefined_transponder":
+                       self.list.append(getConfigListEntry(_("Transponder"), self.tuning.transponder))

                self["config"].list = self.list
                self["config"].l.setList(self.list)
 
                self["config"].list = self.list
                self["config"].l.setList(self.list)
 

-       def newConfig(self):
-               if self["config"].getCurrent() in (self.typeOfTuningEntry, self.satEntry, self.systemEntry):
-                       self.createSetup()
-
-       def createConfig(self, foo):
-               global tuning
-               if not tuning:
-                       tuning = ConfigSubsection()
-                       tuning.type = ConfigSelection(
-                               default = "manual_transponder",
-                               choices = { "manual_transponder" : _("Manual transponder"),
-                                                       "predefined_transponder" : _("Predefined transponder") } )
-                       tuning.sat = ConfigSatlist(list=nimmanager.getRotorSatListForNim(self.feid))
-                       tuning.sat.addNotifier(self.tuningSatChanged)
-                       self.updateTransponders()
+       def createConfig(self, frontendData):
+               satlist = nimmanager.getRotorSatListForNim(self.feid)

                orb_pos = self.fe_data.get("orbital_position", None)
                orb_pos = self.fe_data.get("orbital_position", None)

+               self.tuning = ConfigSubsection()
+               self.tuning.type = ConfigSelection(
+                       default = "manual_transponder",
+                       choices = { "manual_transponder" : _("Manual transponder"),
+                                               "predefined_transponder" : _("Predefined transponder") } )
+               self.tuning.sat = ConfigSatlist(list = satlist)

                if orb_pos is not None:
                if orb_pos is not None:

-                       for x in nimmanager.getRotorSatListForNim(self.feid):
+                       for x in satlist:

                                opos = str(orb_pos)
                                opos = str(orb_pos)

-                               if x[0] == orb_pos and tuning.sat.value != opos:
-                                       tuning.sat.value = opos
+                               if x[0] == orb_pos and self.tuning.sat.value != opos:
+                                       self.tuning.sat.value = opos

                        del self.fe_data["orbital_position"]
                        del self.fe_data["orbital_position"]

-               ScanSetup.createConfig(self, self.fe_data)
+
+               self.updateTransponders()
+
+               defaultSat = {
+                       "orbpos": 192,
+                       "system": eDVBFrontendParametersSatellite.System_DVB_S,
+                       "frequency": 11836,
+                       "inversion": eDVBFrontendParametersSatellite.Inversion_Unknown,
+                       "symbolrate": 27500,
+                       "polarization": eDVBFrontendParametersSatellite.Polarisation_Horizontal,
+                       "fec": eDVBFrontendParametersSatellite.FEC_Auto,
+                       "fec_s2": eDVBFrontendParametersSatellite.FEC_9_10,
+                       "fec_s2x_qpsk": eDVBFrontendParametersSatellite.FEC_13_45,
+                       "fec_s2x_8psk": eDVBFrontendParametersSatellite.FEC_23_36,
+                       "fec_s2x_8apsk": eDVBFrontendParametersSatellite.FEC_5_9_L,
+                       "fec_s2x_16apsk": eDVBFrontendParametersSatellite.FEC_1_2_L,
+                       "fec_s2x_32apsk": eDVBFrontendParametersSatellite.FEC_2_3_L,
+                       "modulation": eDVBFrontendParametersSatellite.Modulation_QPSK,
+                       "modulation_s2x": eDVBFrontendParametersSatellite.Modulation_QPSK,
+                       "is_id": -1,
+                       "pls_mode": eDVBFrontendParametersSatellite.PLS_Unknown,
+                       "pls_code": 0 }
+
+               if frontendData is not None:
+                       ttype = frontendData.get("tuner_type", "UNKNOWN")
+                       defaultSat["system"] = frontendData.get("system", eDVBFrontendParametersSatellite.System_DVB_S)
+                       defaultSat["frequency"] = frontendData.get("frequency", 0) / 1000
+                       defaultSat["inversion"] = frontendData.get("inversion", eDVBFrontendParametersSatellite.Inversion_Unknown)
+                       defaultSat["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000
+                       defaultSat["polarization"] = frontendData.get("polarization", eDVBFrontendParametersSatellite.Polarisation_Horizontal)
+                       defaultSat["orbpos"] = frontendData.get("orbital_position", 0)
+
+                       defaultSat["modulation"] = frontendData.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK)
+                       defaultSat["modulation_s2x"] = frontendData.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK)
+
+                       if defaultSat["modulation"] > eDVBFrontendParametersSatellite.Modulation_8PSK:
+                               defaultSat["modulation"] = eDVBFrontendParametersSatellite.Modulation_8PSK
+
+                       if defaultSat["system"] == eDVBFrontendParametersSatellite.System_DVB_S2:
+                               defaultSat["fec_s2"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)
+                       elif defaultSat["system"] == eDVBFrontendParametersSatellite.System_DVB_S2X:
+                               if defaultSat["modulation_s2x"] == eDVBFrontendParametersSatellite.Modulation_QPSK:
+                                       defaultSat["fec_s2x_qpsk"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_13_45)
+                               elif defaultSat["modulation_s2x"] == eDVBFrontendParametersSatellite.Modulation_8PSK:
+                                       defaultSat["fec_s2x_8psk"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_23_36)
+                               elif defaultSat["modulation_s2x"] == eDVBFrontendParametersSatellite.Modulation_8APSK:
+                                       defaultSat["fec_s2x_8apsk"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_5_9_L)
+                               elif defaultSat["modulation_s2x"] == eDVBFrontendParametersSatellite.Modulation_16APSK:
+                                       defaultSat["fec_s2x_16apsk"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_1_2_L)
+                               elif defaultSat["modulation_s2x"] == eDVBFrontendParametersSatellite.Modulation_32APSK:
+                                       defaultSat["fec_s2x_32apsk"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_2_3_L)
+                       else:
+                               defaultSat["fec"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)
+
+                       if defaultSat["system"] in (eDVBFrontendParametersSatellite.System_DVB_S2, eDVBFrontendParametersSatellite.System_DVB_S2X):
+                               defaultSat["rolloff"] = frontendData.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35)
+                               defaultSat["pilot"] = frontendData.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown)
+                               defaultSat["is_id"] = frontendData.get("is_id", defaultSat["is_id"])
+                               defaultSat["pls_mode"] = frontendData.get("pls_mode", defaultSat["pls_mode"])
+                               defaultSat["pls_code"] = frontendData.get("pls_code", defaultSat["pls_code"])
+
+               self.scan_sat = ConfigSubsection()
+
+               sat_choices = [
+                               (eDVBFrontendParametersSatellite.System_DVB_S, _("DVB-S")),
+                               (eDVBFrontendParametersSatellite.System_DVB_S2, _("DVB-S2"))]
+
+               sat_choices_dvbs2x = [
+                       (eDVBFrontendParametersSatellite.System_DVB_S, _("DVB-S")),
+                       (eDVBFrontendParametersSatellite.System_DVB_S2, _("DVB-S2")),
+                       (eDVBFrontendParametersSatellite.System_DVB_S2X, _("DVB-S2X"))]
+
+               self.scan_sat.system = ConfigSelection(default = defaultSat["system"], choices = sat_choices)
+               self.scan_sat.system_dvbs2x = ConfigSelection(default = defaultSat["system"], choices = sat_choices_dvbs2x)
+               self.scan_sat.frequency = ConfigInteger(default = defaultSat["frequency"], limits = (1, 99999))
+               self.scan_sat.inversion = ConfigSelection(default = defaultSat["inversion"], choices = [
+                       (eDVBFrontendParametersSatellite.Inversion_Off, _("Off")),
+                       (eDVBFrontendParametersSatellite.Inversion_On, _("On")),
+                       (eDVBFrontendParametersSatellite.Inversion_Unknown, _("Auto"))])
+               self.scan_sat.symbolrate = ConfigInteger(default = defaultSat["symbolrate"], limits = (1, 99999))
+               self.scan_sat.polarization = ConfigSelection(default = defaultSat["polarization"], choices = [
+                       (eDVBFrontendParametersSatellite.Polarisation_Horizontal, _("horizontal")),
+                       (eDVBFrontendParametersSatellite.Polarisation_Vertical, _("vertical")),
+                       (eDVBFrontendParametersSatellite.Polarisation_CircularLeft, _("circular left")),
+                       (eDVBFrontendParametersSatellite.Polarisation_CircularRight, _("circular right"))])
+               self.scan_sat.fec = ConfigSelection(default = defaultSat["fec"], choices = [
+                       (eDVBFrontendParametersSatellite.FEC_Auto, _("Auto")),
+                       (eDVBFrontendParametersSatellite.FEC_1_2, "1/2"),
+                       (eDVBFrontendParametersSatellite.FEC_2_3, "2/3"),
+                       (eDVBFrontendParametersSatellite.FEC_3_4, "3/4"),
+                       (eDVBFrontendParametersSatellite.FEC_5_6, "5/6"),
+                       (eDVBFrontendParametersSatellite.FEC_7_8, "7/8"),
+                       (eDVBFrontendParametersSatellite.FEC_None, _("None"))])
+               self.scan_sat.fec_s2 = ConfigSelection(default = defaultSat["fec_s2"], choices = [
+                       (eDVBFrontendParametersSatellite.FEC_1_2, "1/2"),
+                       (eDVBFrontendParametersSatellite.FEC_2_3, "2/3"),
+                       (eDVBFrontendParametersSatellite.FEC_3_4, "3/4"),
+                       (eDVBFrontendParametersSatellite.FEC_3_5, "3/5"),
+                       (eDVBFrontendParametersSatellite.FEC_4_5, "4/5"),
+                       (eDVBFrontendParametersSatellite.FEC_5_6, "5/6"),
+                       (eDVBFrontendParametersSatellite.FEC_7_8, "7/8"),
+                       (eDVBFrontendParametersSatellite.FEC_8_9, "8/9"),
+                       (eDVBFrontendParametersSatellite.FEC_9_10, "9/10")])
+               self.scan_sat.fec_s2x_qpsk = ConfigSelection(default = defaultSat["fec_s2x_qpsk"], choices = [
+                       (eDVBFrontendParametersSatellite.FEC_13_45, "13/45"),
+                       (eDVBFrontendParametersSatellite.FEC_9_20, "9/20"),
+                       (eDVBFrontendParametersSatellite.FEC_11_20, "11/20")])
+
+               self.scan_sat.fec_s2x_8psk = ConfigSelection(default = defaultSat["fec_s2x_8psk"], choices = [
+                       (eDVBFrontendParametersSatellite.FEC_23_36, "23/36"),
+                       (eDVBFrontendParametersSatellite.FEC_25_36, "25/36"),
+                       (eDVBFrontendParametersSatellite.FEC_13_18, "13/28")])
+
+               self.scan_sat.fec_s2x_8apsk = ConfigSelection(default = defaultSat["fec_s2x_8apsk"], choices = [
+                       (eDVBFrontendParametersSatellite.FEC_5_9_L, "5/9-L"),
+                       (eDVBFrontendParametersSatellite.FEC_26_45_L, "26/45-L")])
+
+               self.scan_sat.fec_s2x_16apsk = ConfigSelection(default = defaultSat["fec_s2x_16apsk"], choices = [
+                       (eDVBFrontendParametersSatellite.FEC_1_2_L, "1/2-L"),
+                       (eDVBFrontendParametersSatellite.FEC_8_15_L, "8/15-L"),
+                       (eDVBFrontendParametersSatellite.FEC_5_9_L, "5/9-L"),
+                       (eDVBFrontendParametersSatellite.FEC_26_45, "26/45"),
+                       (eDVBFrontendParametersSatellite.FEC_3_5, "3/5"),
+                       (eDVBFrontendParametersSatellite.FEC_3_5_L, "3/5-L"),
+                       (eDVBFrontendParametersSatellite.FEC_28_45, "28/45"),
+                       (eDVBFrontendParametersSatellite.FEC_23_36, "23/36"),
+                       (eDVBFrontendParametersSatellite.FEC_2_3_L, "2/3-L"),
+                       (eDVBFrontendParametersSatellite.FEC_25_36, "25/36"),
+                       (eDVBFrontendParametersSatellite.FEC_13_18, "13/18"),
+                       (eDVBFrontendParametersSatellite.FEC_7_9, "7/9"),
+                       (eDVBFrontendParametersSatellite.FEC_77_90, "77/90")])
+
+               self.scan_sat.fec_s2x_32apsk = ConfigSelection(default = defaultSat["fec_s2x_32apsk"], choices = [
+                       (eDVBFrontendParametersSatellite.FEC_2_3_L, "2/3-L"),
+                       (eDVBFrontendParametersSatellite.FEC_32_45, "32/45"),
+                       (eDVBFrontendParametersSatellite.FEC_11_15, "11/15"),
+                       (eDVBFrontendParametersSatellite.FEC_7_9, "7/9")])
+               self.scan_sat.modulation = ConfigSelection(default = defaultSat["modulation"], choices = [
+                       (eDVBFrontendParametersSatellite.Modulation_QPSK, "QPSK"),
+                       (eDVBFrontendParametersSatellite.Modulation_8PSK, "8PSK")])
+               self.scan_sat.modulation_dvbs2x = ConfigSelection(default = defaultSat["modulation_s2x"], choices = [
+                       (eDVBFrontendParametersSatellite.Modulation_QPSK, "QPSK"),
+                       (eDVBFrontendParametersSatellite.Modulation_8PSK, "8PSK"),
+                       (eDVBFrontendParametersSatellite.Modulation_8APSK, "8APSK"),
+                       (eDVBFrontendParametersSatellite.Modulation_16APSK, "16APSK"),
+                       (eDVBFrontendParametersSatellite.Modulation_32APSK, "32APSK")])
+               self.scan_sat.rolloff = ConfigSelection(default = defaultSat.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35), choices = [
+                       (eDVBFrontendParametersSatellite.RollOff_alpha_0_35, "0.35"),
+                       (eDVBFrontendParametersSatellite.RollOff_alpha_0_25, "0.25"),
+                       (eDVBFrontendParametersSatellite.RollOff_alpha_0_20, "0.20")])
+               self.scan_sat.pilot = ConfigSelection(default = defaultSat.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown), choices = [
+                       (eDVBFrontendParametersSatellite.Pilot_Off, _("Off")),
+                       (eDVBFrontendParametersSatellite.Pilot_On, _("On")),
+                       (eDVBFrontendParametersSatellite.Pilot_Unknown, _("Auto"))])
+               self.scan_sat.is_id = ConfigInteger(default = defaultSat["is_id"] if defaultSat["is_id"] != -1 else 0, limits = (0, 255))
+               self.scan_sat.is_id_bool = ConfigSelection(default = defaultSat["is_id"] != -1, choices = [(True, _("Multistream")),(False, _("Ordinary"))])
+               self.scan_sat.pls_mode = ConfigSelection(default = defaultSat["pls_mode"], choices = [
+                               (eDVBFrontendParametersSatellite.PLS_Root, _("Root")),
+                               (eDVBFrontendParametersSatellite.PLS_Gold, _("Gold")),
+                               (eDVBFrontendParametersSatellite.PLS_Combo, _("Combo")),
+                               (eDVBFrontendParametersSatellite.PLS_Unknown, _("Auto"))])
+               self.scan_sat.pls_code = ConfigInteger(default = defaultSat["pls_code"], limits = (0, 262143))

 
        def tuningSatChanged(self, *parm):
                self.updateTransponders()
 
        def tuningSatChanged(self, *parm):
                self.updateTransponders()

+               self.createSetup()
+
+       def tuningTypeChanged(self, *parm):
+               self.createSetup()
+
+       def systemChanged(self, *parm):
+               self.createSetup()
+
+       def isIdChanged(self, *parm):
+               self.createSetup()
+
+       def plsModeChanged(self, *parm):
+               self.createSetup()

 
        def updateTransponders(self):
 
        def updateTransponders(self):

-               if len(tuning.sat.choices):
-                       transponderlist = nimmanager.getTransponders(int(tuning.sat.value))
+               if len(self.tuning.sat.choices):
+                       transponderlist = nimmanager.getTransponders(int(self.tuning.sat.value))

                        tps = []
                        cnt=0
                        for x in transponderlist:
                        tps = []
                        cnt=0
                        for x in transponderlist:


@@ -499,41 +710,66 @@ class TunerScreen(ScanSetup):
                                        pol = "CR"
                                else:
                                        pol = "??"
                                        pol = "CR"
                                else:
                                        pol = "??"

-                               if x[4] == 0:
-                                       fec = "FEC Auto"
-                               elif x[4] == 1:
-                                       fec = "FEC 1/2"
-                               elif x[4] == 2:
-                                       fec = "FEC 2/3"
-                               elif x[4] == 3:
-                                       fec = "FEC 3/4"
-                               elif x[4] == 4:
-                                       fec = "FEC 5/6"
-                               elif x[4] == 5:
-                                       fec = "FEC 7/8"
-                               elif x[4] == 6:
-                                       fec = "FEC 8/9"
-                               elif x[4] == 7:
-                                       fec = "FEC 3/5"
-                               elif x[4] == 8:
-                                       fec = "FEC 4/5"
-                               elif x[4] == 9:
-                                       fec = "FEC 9/10"
-                               elif x[4] == 15:
-                                       fec = "FEC None"
-                               else:
+
+                               fec_desc = ("FEC Auto", "FEC 1/2", "FEC 2/3", "FEC 3/4", "FEC 5/6", "FEC 7/8", "FEC 8/9", "FEC 3/5", "FEC 4/5", "FEC 9/10", \
+                                                       "FEC Unknown", "FEC Unknown", "FEC Unknown", "FEC Unknown", "FEC Unknown", "FEC None", \
+                                                       "FEC_13_45", "FEC_9_20", "FEC_11_20", "FEC_23_36", "FEC_25_36", \
+                                                       "FEC_13_18", "FEC_26_45", "FEC_28_45", "FEC_7_9", "FEC_77_90", \
+                                                       "FEC_32_45", "FEC_11_15", "FEC_1_2_L", "FEC_8_15_L", "FEC_3_5_L", \
+                                                       "FEC_2_3_L", "FEC_5_9_L", "FEC_26_45_L")
+                               if x[4] > len(fec_desc)-1:

                                        fec = "FEC Unknown"
                                        fec = "FEC Unknown"

+                               else:
+                                       fec = fec_desc[x[4]]

                                tps.append(str(x[1]) + "," + str(x[2]) + "," + pol + "," + fec)
                                tps.append(str(x[1]) + "," + str(x[2]) + "," + pol + "," + fec)

-                       tuning.transponder = ConfigSelection(choices=tps)
+                       self.tuning.transponder = ConfigSelection(choices=tps)
+
+       def keyLeft(self):
+               ConfigListScreen.keyLeft(self)
+
+       def keyRight(self):
+               ConfigListScreen.keyRight(self)

 
        def keyGo(self):
 
        def keyGo(self):

-               returnvalue = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
-               satpos = int(tuning.sat.value)
-               if tuning.type.value == "manual_transponder":
-                       if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2:
+               returnvalue = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 3, 0)
+               satpos = int(self.tuning.sat.value)
+               nim = nimmanager.nim_slots[self.feid]
+               if self.tuning.type.value == "manual_transponder":
+                       system = self.scan_sat.system.value
+                       modulation = self.scan_sat.modulation.value
+                       if nim.isCompatible("DVB-S2X"):
+                               system = self.scan_sat.system_dvbs2x.value
+                               modulation = self.scan_sat.modulation_dvbs2x.value
+
+                       if system == eDVBFrontendParametersSatellite.System_DVB_S:
+                               fec = self.scan_sat.fec.value
+                       elif system == eDVBFrontendParametersSatellite.System_DVB_S2:

                                fec = self.scan_sat.fec_s2.value
                                fec = self.scan_sat.fec_s2.value

+                       elif system == eDVBFrontendParametersSatellite.System_DVB_S2X:
+                               if modulation == eDVBFrontendParametersSatellite.Modulation_QPSK:
+                                       fec = self.scan_sat.fec_s2x_qpsk.value
+                               elif modulation == eDVBFrontendParametersSatellite.Modulation_8PSK:
+                                       fec = self.scan_sat.fec_s2x_8psk.value
+                               elif modulation == eDVBFrontendParametersSatellite.Modulation_8APSK:
+                                       fec = self.scan_sat.fec_s2x_8apsk.value
+                               elif modulation == eDVBFrontendParametersSatellite.Modulation_16APSK:
+                                       fec = self.scan_sat.fec_s2x_16apsk.value
+                               elif modulation == eDVBFrontendParametersSatellite.Modulation_32APSK:
+                                       fec = self.scan_sat.fec_s2x_32apsk.value

                        else:
                                fec = self.scan_sat.fec.value
                        else:
                                fec = self.scan_sat.fec.value

+
+                       is_id = -1
+                       pls_mode = eDVBFrontendParametersSatellite.PLS_Unknown
+                       pls_code = 0
+                       if self.scan_sat.is_id_bool.value:
+                               is_id = self.scan_sat.is_id.value
+                               pls_mode = self.scan_sat.pls_mode.value
+                               if pls_mode == eDVBFrontendParametersSatellite.PLS_Unknown:
+                                       pls_code = 0
+                               else:
+                                       pls_code = self.scan_sat.pls_code.value
+

                        returnvalue = (
                                self.scan_sat.frequency.value,
                                self.scan_sat.symbolrate.value,
                        returnvalue = (
                                self.scan_sat.frequency.value,
                                self.scan_sat.symbolrate.value,


@@ -541,14 +777,17 @@ class TunerScreen(ScanSetup):
                                fec,
                                self.scan_sat.inversion.value,
                                satpos,
                                fec,
                                self.scan_sat.inversion.value,
                                satpos,

-                               self.scan_sat.system.value,
-                               self.scan_sat.modulation.value,
+                               system,
+                               modulation,

                                self.scan_sat.rolloff.value,
                                self.scan_sat.rolloff.value,

-                               self.scan_sat.pilot.value)
-               elif tuning.type.value == "predefined_transponder":
-                       transponder = nimmanager.getTransponders(satpos)[tuning.transponder.index]
+                               self.scan_sat.pilot.value,
+                               is_id,
+                               pls_mode,
+                               pls_code)
+               elif self.tuning.type.value == "predefined_transponder":
+                       transponder = nimmanager.getTransponders(satpos)[self.tuning.transponder.index]

                        returnvalue = (transponder[1] / 1000, transponder[2] / 1000,
                        returnvalue = (transponder[1] / 1000, transponder[2] / 1000,

-                               transponder[3], transponder[4], 2, satpos, transponder[5], transponder[6], transponder[8], transponder[9])
+                               transponder[3], transponder[4], 2, satpos, transponder[5], transponder[6], transponder[8], transponder[9], transponder[10], transponder[11], transponder[12])

                self.close(returnvalue)
 
        def keyCancel(self):
                self.close(returnvalue)
 
        def keyCancel(self):

diff --git a/lib/python/Plugins/SystemPlugins/Satfinder/plugin.py b/lib/python/Plugins/SystemPlugins/Satfinder/plugin.py
index e611ca5..ad1c450 100644 (file)
--- a/lib/python/Plugins/SystemPlugins/Satfinder/plugin.py
+++ b/lib/python/Plugins/SystemPlugins/Satfinder/plugin.py
@@ -59,19 +59,23 @@ class Satfinder(ScanSetup):
        def createSetup(self):
                self.typeOfTuningEntry = None
                self.satEntry = None
        def createSetup(self):
                self.typeOfTuningEntry = None
                self.satEntry = None

-               
+               self.systemEntry = None
+               self.is_id_boolEntry = None
+               self.plsModeEntry = None

                self.list = []
                self.list = []

-

                self.typeOfTuningEntry = getConfigListEntry(_('Tune'), self.tuning_type)
                self.list.append(self.typeOfTuningEntry)
                self.satEntry = getConfigListEntry(_('Satellite'), self.tuning_sat)
                self.list.append(self.satEntry)
 
                nim = nimmanager.nim_slots[self.feid]
                self.typeOfTuningEntry = getConfigListEntry(_('Tune'), self.tuning_type)
                self.list.append(self.typeOfTuningEntry)
                self.satEntry = getConfigListEntry(_('Satellite'), self.tuning_sat)
                self.list.append(self.satEntry)
 
                nim = nimmanager.nim_slots[self.feid]

-
-               self.systemEntry = None

                if self.tuning_type.value == "manual_transponder":
                if self.tuning_type.value == "manual_transponder":

-                       if nim.isCompatible("DVB-S2"):
+                       scan_sat_system_value = self.scan_sat.system.value
+                       if nim.isCompatible("DVB-S2X"):
+                                       scan_sat_system_value = self.scan_sat.system_dvbs2x.value
+                                       self.systemEntry = getConfigListEntry(_('System'), self.scan_sat.system_dvbs2x)
+                                       self.list.append(self.systemEntry)
+                       elif nim.isCompatible("DVB-S2"):

                                self.systemEntry = getConfigListEntry(_('System'), self.scan_sat.system)
                                self.list.append(self.systemEntry)
                        else:
                                self.systemEntry = getConfigListEntry(_('System'), self.scan_sat.system)
                                self.list.append(self.systemEntry)
                        else:


@@ -81,14 +85,39 @@ class Satfinder(ScanSetup):
                        self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion))
                        self.list.append(getConfigListEntry(_('Symbol rate'), self.scan_sat.symbolrate))
                        self.list.append(getConfigListEntry(_('Polarization'), self.scan_sat.polarization))
                        self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion))
                        self.list.append(getConfigListEntry(_('Symbol rate'), self.scan_sat.symbolrate))
                        self.list.append(getConfigListEntry(_('Polarization'), self.scan_sat.polarization))

-                       if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S:
+                       if scan_sat_system_value == eDVBFrontendParametersSatellite.System_DVB_S:

                                self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec))
                                self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec))

-                       elif self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2:
+                       elif scan_sat_system_value == eDVBFrontendParametersSatellite.System_DVB_S2:

                                self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2))
                                self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation)
                                self.list.append(self.modulationEntry)
                                self.list.append(getConfigListEntry(_('Roll-off'), self.scan_sat.rolloff))
                                self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot))
                                self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2))
                                self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation)
                                self.list.append(self.modulationEntry)
                                self.list.append(getConfigListEntry(_('Roll-off'), self.scan_sat.rolloff))
                                self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot))

+                       elif scan_sat_system_value == eDVBFrontendParametersSatellite.System_DVB_S2X:
+                               if self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_QPSK:
+                                       self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_qpsk))
+                               elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_8PSK:
+                                       self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_8psk))
+                               elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_8APSK:
+                                       self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_8apsk))
+                               elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_16APSK:
+                                       self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_16apsk))
+                               elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_32APSK:
+                                       self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_32apsk))
+                               self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation_dvbs2x)
+                               self.list.append(self.modulationEntry)
+                               self.list.append(getConfigListEntry(_('Roll-off'), self.scan_sat.rolloff))
+                               self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot))
+                       if scan_sat_system_value in (eDVBFrontendParametersSatellite.System_DVB_S2, eDVBFrontendParametersSatellite.System_DVB_S2X):
+                               if nim.isMultistream():
+                                       self.is_id_boolEntry = getConfigListEntry(_('Transport Stream Type'), self.scan_sat.is_id_bool)
+                                       self.list.append(self.is_id_boolEntry)
+                                       if self.scan_sat.is_id_bool.value:
+                                               self.list.append(getConfigListEntry(_('Input Stream ID'), self.scan_sat.is_id))
+                                               self.plsModeEntry = getConfigListEntry(_('PLS Mode'), self.scan_sat.pls_mode)
+                                               self.list.append(self.plsModeEntry)
+                                               if self.scan_sat.pls_mode.value != eDVBFrontendParametersSatellite.PLS_Unknown:
+                                                       self.list.append(getConfigListEntry(_('PLS Code'), self.scan_sat.pls_code))

                elif self.tuning_transponder and self.tuning_type.value == "predefined_transponder":
                        self.list.append(getConfigListEntry(_("Transponder"), self.tuning_transponder))
                self["config"].list = self.list
                elif self.tuning_transponder and self.tuning_type.value == "predefined_transponder":
                        self.list.append(getConfigListEntry(_("Transponder"), self.tuning_transponder))
                self["config"].list = self.list


@@ -96,24 +125,57 @@ class Satfinder(ScanSetup):
 
        def newConfig(self):
                cur = self["config"].getCurrent()
 
        def newConfig(self):
                cur = self["config"].getCurrent()

-               if cur in (self.typeOfTuningEntry, self.systemEntry):
+               if cur in (self.typeOfTuningEntry, self.systemEntry, self.is_id_boolEntry, self.plsModeEntry):

                        self.createSetup()
                elif cur == self.satEntry:
                        self.updateSats()
                        self.createSetup()
                        self.createSetup()
                elif cur == self.satEntry:
                        self.updateSats()
                        self.createSetup()

+               elif self.modulationEntry and (cur == self.modulationEntry) and \
+                       self.systemEntry and (self.systemEntry[1].value == eDVBFrontendParametersSatellite.System_DVB_S2X):
+                       self.createSetup()

 
        def sat_changed(self, config_element):
                self.newConfig()
                self.retune(config_element)
 
        def retune(self, configElement):
 
        def sat_changed(self, config_element):
                self.newConfig()
                self.retune(config_element)
 
        def retune(self, configElement):

-               returnvalue = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
+               returnvalue = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 3, 0)

                satpos = int(self.tuning_sat.value)
                satpos = int(self.tuning_sat.value)

+               nim = nimmanager.nim_slots[self.feid]

                if self.tuning_type.value == "manual_transponder":
                if self.tuning_type.value == "manual_transponder":

-                       if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2:
-                               fec = self.scan_sat.fec_s2.value
-                       else:
+                       system = self.scan_sat.system.value
+                       modulation = self.scan_sat.modulation.value
+                       if nim.isCompatible("DVB-S2X"):
+                               system = self.scan_sat.system_dvbs2x.value
+                               modulation = self.scan_sat.modulation_dvbs2x.value
+
+                       if system == eDVBFrontendParametersSatellite.System_DVB_S:

                                fec = self.scan_sat.fec.value
                                fec = self.scan_sat.fec.value

+                       elif system == eDVBFrontendParametersSatellite.System_DVB_S2:
+                               fec = self.scan_sat.fec_s2.value
+                       elif system == eDVBFrontendParametersSatellite.System_DVB_S2X:
+                               if modulation == eDVBFrontendParametersSatellite.Modulation_QPSK:
+                                       fec = self.scan_sat.fec_s2x_qpsk.value
+                               elif modulation == eDVBFrontendParametersSatellite.Modulation_8PSK:
+                                       fec = self.scan_sat.fec_s2x_8psk.value
+                               elif modulation == eDVBFrontendParametersSatellite.Modulation_8APSK:
+                                       fec = self.scan_sat.fec_s2x_8apsk.value
+                               elif modulation == eDVBFrontendParametersSatellite.Modulation_16APSK:
+                                       fec = self.scan_sat.fec_s2x_16apsk.value
+                               elif modulation == eDVBFrontendParametersSatellite.Modulation_32APSK:
+                                       fec = self.scan_sat.fec_s2x_32apsk.value
+
+                       is_id = -1
+                       pls_mode = eDVBFrontendParametersSatellite.PLS_Unknown
+                       pls_code = 0
+                       if self.scan_sat.is_id_bool.value:
+                               is_id = self.scan_sat.is_id.value
+                               pls_mode = self.scan_sat.pls_mode.value
+                               if pls_mode == eDVBFrontendParametersSatellite.PLS_Unknown:
+                                       pls_code = 0
+                               else:
+                                       pls_code = self.scan_sat.pls_code.value
+

                        returnvalue = (
                                self.scan_sat.frequency.value,
                                self.scan_sat.symbolrate.value,
                        returnvalue = (
                                self.scan_sat.frequency.value,
                                self.scan_sat.symbolrate.value,


@@ -121,10 +183,13 @@ class Satfinder(ScanSetup):
                                fec,
                                self.scan_sat.inversion.value,
                                satpos,
                                fec,
                                self.scan_sat.inversion.value,
                                satpos,

-                               self.scan_sat.system.value,
-                               self.scan_sat.modulation.value,
+                               system,
+                               modulation,

                                self.scan_sat.rolloff.value,
                                self.scan_sat.rolloff.value,

-                               self.scan_sat.pilot.value)
+                               self.scan_sat.pilot.value,
+                               is_id,
+                               pls_mode,
+                               pls_code)

                        self.tune(returnvalue)
                elif self.tuning_type.value == "predefined_transponder":
                        tps = nimmanager.getTransponders(satpos)
                        self.tune(returnvalue)
                elif self.tuning_type.value == "predefined_transponder":
                        tps = nimmanager.getTransponders(satpos)


@@ -132,7 +197,7 @@ class Satfinder(ScanSetup):
                        if l > self.tuning_transponder.index:
                                transponder = tps[self.tuning_transponder.index]
                                returnvalue = (transponder[1] / 1000, transponder[2] / 1000,
                        if l > self.tuning_transponder.index:
                                transponder = tps[self.tuning_transponder.index]
                                returnvalue = (transponder[1] / 1000, transponder[2] / 1000,

-                                       transponder[3], transponder[4], 2, satpos, transponder[5], transponder[6], transponder[8], transponder[9])
+                                       transponder[3], transponder[4], 2, satpos, transponder[5], transponder[6], transponder[8], transponder[9], transponder[10], transponder[11], transponder[12])

                                self.tune(returnvalue)
 
        def createConfig(self, foo):
                                self.tune(returnvalue)
 
        def createConfig(self, foo):


@@ -143,11 +208,20 @@ class Satfinder(ScanSetup):
                
                self.updateSats()
 
                
                self.updateSats()
 

-               for x in (self.tuning_type, self.tuning_sat, self.scan_sat.frequency,
+               setup_list = [self.tuning_type, self.tuning_sat, self.scan_sat.frequency,

                        self.scan_sat.inversion, self.scan_sat.symbolrate,
                        self.scan_sat.polarization, self.scan_sat.fec, self.scan_sat.pilot,
                        self.scan_sat.fec_s2, self.scan_sat.fec, self.scan_sat.modulation,
                        self.scan_sat.inversion, self.scan_sat.symbolrate,
                        self.scan_sat.polarization, self.scan_sat.fec, self.scan_sat.pilot,
                        self.scan_sat.fec_s2, self.scan_sat.fec, self.scan_sat.modulation,

-                       self.scan_sat.rolloff, self.scan_sat.system):
+                       self.scan_sat.rolloff, self.scan_sat.system,
+                       self.scan_sat.is_id_bool, self.scan_sat.is_id, self.scan_sat.pls_mode, self.scan_sat.pls_code]
+
+               nim = nimmanager.nim_slots[self.feid]
+               if nim.isCompatible("DVB-S2X"):
+                       dvbs2x_setup_list = [self.scan_sat.system_dvbs2x, self.scan_sat.modulation_dvbs2x, self.scan_sat.fec_s2x_qpsk,
+                               self.scan_sat.fec_s2x_8psk, self.scan_sat.fec_s2x_8apsk, self.scan_sat.fec_s2x_16apsk, self.scan_sat.fec_s2x_32apsk]
+                       setup_list.extend(dvbs2x_setup_list)
+
+               for x in setup_list:

                        x.addNotifier(self.retune, initial_call = False)
 
        def updateSats(self):
                        x.addNotifier(self.retune, initial_call = False)
 
        def updateSats(self):

diff --git a/lib/python/Screens/ScanSetup.py b/lib/python/Screens/ScanSetup.py
index 9cc6dea..fa3126b 100644 (file)
--- a/lib/python/Screens/ScanSetup.py
+++ b/lib/python/Screens/ScanSetup.py
@@ -7,6 +7,7 @@ from Components.ActionMap import NumberActionMap, ActionMap
 from Components.ConfigList import ConfigListScreen
 from Components.NimManager import nimmanager, getConfigSatlist
 from Components.Label import Label
 from Components.ConfigList import ConfigListScreen
 from Components.NimManager import nimmanager, getConfigSatlist
 from Components.Label import Label

+from Components.SystemInfo import SystemInfo

 from Tools.Directories import resolveFilename, SCOPE_DEFAULTPARTITIONMOUNTDIR, SCOPE_DEFAULTDIR, SCOPE_DEFAULTPARTITION
 from Tools.HardwareInfo import HardwareInfo
 from Screens.MessageBox import MessageBox
 from Tools.Directories import resolveFilename, SCOPE_DEFAULTPARTITIONMOUNTDIR, SCOPE_DEFAULTDIR, SCOPE_DEFAULTPARTITION
 from Tools.HardwareInfo import HardwareInfo
 from Screens.MessageBox import MessageBox


@@ -48,6 +49,9 @@ def getInitialTransponderList(tlist, pos):
                        parm.modulation = x[6]
                        parm.rolloff = x[8]
                        parm.pilot = x[9]
                        parm.modulation = x[6]
                        parm.rolloff = x[8]
                        parm.pilot = x[9]

+                       parm.is_id = x[10]
+                       parm.pls_mode = x[11]
+                       parm.pls_code = x[12]

                        tlist.append(parm)
 
 def getInitialCableTransponderList(tlist, nim):
                        tlist.append(parm)
 
 def getInitialCableTransponderList(tlist, nim):


@@ -586,6 +590,8 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
                self.typeOfScanEntry = None
                self.systemEntry = None
                self.modulationEntry = None
                self.typeOfScanEntry = None
                self.systemEntry = None
                self.modulationEntry = None

+               self.is_id_boolEntry = None
+               self.plsModeEntry = None

                nim = nimmanager.nim_slots[index_to_scan]
                if nim.isCompatible("DVB-S"):
                        self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), self.scan_type)
                nim = nimmanager.nim_slots[index_to_scan]
                if nim.isCompatible("DVB-S"):
                        self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), self.scan_type)


@@ -601,7 +607,13 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
                if nim.isCompatible("DVB-S"):
                        if self.scan_type.value == "single_transponder":
                                self.updateSatList()
                if nim.isCompatible("DVB-S"):
                        if self.scan_type.value == "single_transponder":
                                self.updateSatList()

-                               if nim.isCompatible("DVB-S2"):
+
+                               scan_sat_system_value = self.scan_sat.system.value
+                               if nim.isCompatible("DVB-S2X"):
+                                       scan_sat_system_value = self.scan_sat.system_dvbs2x.value
+                                       self.systemEntry = getConfigListEntry(_('System'), self.scan_sat.system_dvbs2x)
+                                       self.list.append(self.systemEntry)
+                               elif nim.isCompatible("DVB-S2"):

                                        self.systemEntry = getConfigListEntry(_('System'), self.scan_sat.system)
                                        self.list.append(self.systemEntry)
                                else:
                                        self.systemEntry = getConfigListEntry(_('System'), self.scan_sat.system)
                                        self.list.append(self.systemEntry)
                                else:


@@ -612,14 +624,45 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
                                self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion))
                                self.list.append(getConfigListEntry(_('Symbol rate'), self.scan_sat.symbolrate))
                                self.list.append(getConfigListEntry(_('Polarization'), self.scan_sat.polarization))
                                self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion))
                                self.list.append(getConfigListEntry(_('Symbol rate'), self.scan_sat.symbolrate))
                                self.list.append(getConfigListEntry(_('Polarization'), self.scan_sat.polarization))

-                               if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S:
-                                       self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec))
-                               elif self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2:
-                                       self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2))
+
+                               if scan_sat_system_value == eDVBFrontendParametersSatellite.System_DVB_S2:

                                        self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation)
                                        self.list.append(self.modulationEntry)
                                        self.list.append(getConfigListEntry(_('Roll-off'), self.scan_sat.rolloff))
                                        self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot))
                                        self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation)
                                        self.list.append(self.modulationEntry)
                                        self.list.append(getConfigListEntry(_('Roll-off'), self.scan_sat.rolloff))
                                        self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot))

+                               elif scan_sat_system_value == eDVBFrontendParametersSatellite.System_DVB_S2X:
+                                       self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation_dvbs2x)
+                                       self.list.append(self.modulationEntry)
+                                       self.list.append(getConfigListEntry(_('Roll-off'), self.scan_sat.rolloff))
+                                       self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot))
+
+                               if scan_sat_system_value == eDVBFrontendParametersSatellite.System_DVB_S:
+                                       self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec))
+                               elif scan_sat_system_value == eDVBFrontendParametersSatellite.System_DVB_S2:
+                                       self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2))
+                               elif scan_sat_system_value == eDVBFrontendParametersSatellite.System_DVB_S2X:
+                                       if self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_QPSK:
+                                               self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_qpsk))
+                                       elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_8PSK:
+                                               self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_8psk))
+                                       elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_8APSK:
+                                               self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_8apsk))
+                                       elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_16APSK:
+                                               self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_16apsk))
+                                       elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_32APSK:
+                                               self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_32apsk))
+
+                               if scan_sat_system_value in (eDVBFrontendParametersSatellite.System_DVB_S2, eDVBFrontendParametersSatellite.System_DVB_S2X):
+                                       if nim.isMultistream():
+                                               self.is_id_boolEntry = getConfigListEntry(_('Transport Stream Type'), self.scan_sat.is_id_bool)
+                                               self.list.append(self.is_id_boolEntry)
+                                               if self.scan_sat.is_id_bool.value:
+                                                       self.list.append(getConfigListEntry(_('Input Stream ID'), self.scan_sat.is_id))
+                                                       self.plsModeEntry = getConfigListEntry(_('PLS Mode'), self.scan_sat.pls_mode)
+                                                       self.list.append(self.plsModeEntry)
+                                                       if self.scan_sat.pls_mode.value != eDVBFrontendParametersSatellite.PLS_Unknown:
+                                                               self.list.append(getConfigListEntry(_('PLS Code'), self.scan_sat.pls_code))
+

                        elif self.scan_type.value == "single_satellite":
                                self.updateSatList()
                                print self.scan_satselection[index_to_scan]
                        elif self.scan_type.value == "single_satellite":
                                self.updateSatList()
                                print self.scan_satselection[index_to_scan]


@@ -686,43 +729,20 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
        def newConfig(self):
                cur = self["config"].getCurrent()
                print "cur is", cur
        def newConfig(self):
                cur = self["config"].getCurrent()
                print "cur is", cur

+               if cur is None:
+                       return
+

                if cur == self.typeOfScanEntry or \
                        cur == self.tunerEntry or \
                        cur == self.systemEntry or \
                if cur == self.typeOfScanEntry or \
                        cur == self.tunerEntry or \
                        cur == self.systemEntry or \

-                       (self.modulationEntry and self.systemEntry[1].value == eDVBFrontendParametersSatellite.System_DVB_S2 and cur == self.modulationEntry):
+                       (self.modulationEntry and \
+                       (self.systemEntry[1].value in (eDVBFrontendParametersSatellite.System_DVB_S2, eDVBFrontendParametersSatellite.System_DVB_S2X)) and \
+                       cur == self.modulationEntry) or \
+                       cur == self.is_id_boolEntry or \
+                       cur == self.plsModeEntry:

                        self.createSetup()
 
        def createConfig(self, frontendData):
                        self.createSetup()
 
        def createConfig(self, frontendData):

-                                                          #("Type", frontendData["system"], TYPE_TEXT),
-                                          #("Modulation", frontendData["modulation"], TYPE_TEXT),
-                                          #("Orbital position", frontendData["orbital_position"], TYPE_VALUE_DEC),
-                                          #("Frequency", frontendData["frequency"], TYPE_VALUE_DEC),
-                                          #("Symbolrate", frontendData["symbol_rate"], TYPE_VALUE_DEC),
-                                          #("Polarization", frontendData["polarization"], TYPE_TEXT),
-                                          #("Inversion", frontendData["inversion"], TYPE_TEXT),
-                                          #("FEC inner", frontendData["fec_inner"], TYPE_TEXT),
-                                               #)
-               #elif frontendData["tuner_type"] == "DVB-C":
-                       #return ( ("NIM", ['A', 'B', 'C', 'D'][frontendData["tuner_number"]], TYPE_TEXT),
-                                          #("Type", frontendData["tuner_type"], TYPE_TEXT),
-                                          #("Frequency", frontendData["frequency"], TYPE_VALUE_DEC),
-                                          #("Symbolrate", frontendData["symbol_rate"], TYPE_VALUE_DEC),
-                                          #("Modulation", frontendData["modulation"], TYPE_TEXT),
-                                          #("Inversion", frontendData["inversion"], TYPE_TEXT),
-                       #                  ("FEC inner", frontendData["fec_inner"], TYPE_TEXT),
-                                               #)
-               #elif frontendData["tuner_type"] == "DVB-T":
-                       #return ( ("NIM", ['A', 'B', 'C', 'D'][frontendData["tuner_number"]], TYPE_TEXT),
-                                          #("Type", frontendData["tuner_type"], TYPE_TEXT),
-                                          #("Frequency", frontendData["frequency"], TYPE_VALUE_DEC),
-                                          #("Inversion", frontendData["inversion"], TYPE_TEXT),
-                                          #("Bandwidth", frontendData["bandwidth"], TYPE_VALUE_DEC),
-                                          #("CodeRateLP", frontendData["code_rate_lp"], TYPE_TEXT),
-                                          #("CodeRateHP", frontendData["code_rate_hp"], TYPE_TEXT),
-                                          #("Constellation", frontendData["constellation"], TYPE_TEXT),
-                                          #("Transmission Mode", frontendData["transmission_mode"], TYPE_TEXT),
-                                          #("Guard Interval", frontendData["guard_interval"], TYPE_TEXT),
-                                          #("Hierarchy Inform.", frontendData["hierarchy_information"], TYPE_TEXT),

                        defaultSat = {
                                "orbpos": 192,
                                "system": eDVBFrontendParametersSatellite.System_DVB_S,
                        defaultSat = {
                                "orbpos": 192,
                                "system": eDVBFrontendParametersSatellite.System_DVB_S,


@@ -732,7 +752,16 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
                                "polarization": eDVBFrontendParametersSatellite.Polarisation_Horizontal,
                                "fec": eDVBFrontendParametersSatellite.FEC_Auto,
                                "fec_s2": eDVBFrontendParametersSatellite.FEC_9_10,
                                "polarization": eDVBFrontendParametersSatellite.Polarisation_Horizontal,
                                "fec": eDVBFrontendParametersSatellite.FEC_Auto,
                                "fec_s2": eDVBFrontendParametersSatellite.FEC_9_10,

-                               "modulation": eDVBFrontendParametersSatellite.Modulation_QPSK }
+                               "fec_s2x_qpsk": eDVBFrontendParametersSatellite.FEC_13_45,
+                               "fec_s2x_8psk": eDVBFrontendParametersSatellite.FEC_23_36,
+                               "fec_s2x_8apsk": eDVBFrontendParametersSatellite.FEC_5_9_L,
+                               "fec_s2x_16apsk": eDVBFrontendParametersSatellite.FEC_1_2_L,
+                               "fec_s2x_32apsk": eDVBFrontendParametersSatellite.FEC_2_3_L,
+                               "modulation": eDVBFrontendParametersSatellite.Modulation_QPSK,
+                               "modulation_s2x": eDVBFrontendParametersSatellite.Modulation_QPSK,
+                               "is_id": -1,
+                               "pls_mode": eDVBFrontendParametersSatellite.PLS_Unknown,
+                               "pls_code": 0 }

                        defaultCab = {
                                "frequency": 466,
                                "inversion": eDVBFrontendParametersCable.Inversion_Unknown,
                        defaultCab = {
                                "frequency": 466,
                                "inversion": eDVBFrontendParametersCable.Inversion_Unknown,


@@ -760,14 +789,37 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
                                        defaultSat["inversion"] = frontendData.get("inversion", eDVBFrontendParametersSatellite.Inversion_Unknown)
                                        defaultSat["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000
                                        defaultSat["polarization"] = frontendData.get("polarization", eDVBFrontendParametersSatellite.Polarisation_Horizontal)
                                        defaultSat["inversion"] = frontendData.get("inversion", eDVBFrontendParametersSatellite.Inversion_Unknown)
                                        defaultSat["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000
                                        defaultSat["polarization"] = frontendData.get("polarization", eDVBFrontendParametersSatellite.Polarisation_Horizontal)

+                                       defaultSat["orbpos"] = frontendData.get("orbital_position", 0)
+
+                                       defaultSat["modulation"] = frontendData.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK)
+                                       defaultSat["modulation_s2x"] = frontendData.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK)
+
+                                       if defaultSat["modulation"] > eDVBFrontendParametersSatellite.Modulation_8PSK:
+                                               defaultSat["modulation"] = eDVBFrontendParametersSatellite.Modulation_8PSK
+

                                        if defaultSat["system"] == eDVBFrontendParametersSatellite.System_DVB_S2:
                                                defaultSat["fec_s2"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)
                                        if defaultSat["system"] == eDVBFrontendParametersSatellite.System_DVB_S2:
                                                defaultSat["fec_s2"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)

-                                               defaultSat["rolloff"] = frontendData.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35)
-                                               defaultSat["pilot"] = frontendData.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown)
+                                       elif defaultSat["system"] == eDVBFrontendParametersSatellite.System_DVB_S2X:
+                                               if defaultSat["modulation_s2x"] == eDVBFrontendParametersSatellite.Modulation_QPSK:
+                                                       defaultSat["fec_s2x_qpsk"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_13_45)
+                                               elif defaultSat["modulation_s2x"] == eDVBFrontendParametersSatellite.Modulation_8PSK:
+                                                       defaultSat["fec_s2x_8psk"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_23_36)
+                                               elif defaultSat["modulation_s2x"] == eDVBFrontendParametersSatellite.Modulation_8APSK:
+                                                       defaultSat["fec_s2x_8apsk"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_5_9_L)
+                                               elif defaultSat["modulation_s2x"] == eDVBFrontendParametersSatellite.Modulation_16APSK:
+                                                       defaultSat["fec_s2x_16apsk"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_1_2_L)
+                                               elif defaultSat["modulation_s2x"] == eDVBFrontendParametersSatellite.Modulation_32APSK:
+                                                       defaultSat["fec_s2x_32apsk"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_2_3_L)

                                        else:
                                                defaultSat["fec"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)
                                        else:
                                                defaultSat["fec"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)

-                                       defaultSat["modulation"] = frontendData.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK)
-                                       defaultSat["orbpos"] = frontendData.get("orbital_position", 0)
+
+                                       if defaultSat["system"] in (eDVBFrontendParametersSatellite.System_DVB_S2, eDVBFrontendParametersSatellite.System_DVB_S2X):
+                                               defaultSat["rolloff"] = frontendData.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35)
+                                               defaultSat["pilot"] = frontendData.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown)
+                                               defaultSat["is_id"] = frontendData.get("is_id", defaultSat["is_id"])
+                                               defaultSat["pls_mode"] = frontendData.get("pls_mode", defaultSat["pls_mode"])
+                                               defaultSat["pls_code"] = frontendData.get("pls_code", defaultSat["pls_code"])
+

                                elif ttype == "DVB-C":
                                        defaultCab["frequency"] = frontendData.get("frequency", 0) / 1000
                                        defaultCab["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000
                                elif ttype == "DVB-C":
                                        defaultCab["frequency"] = frontendData.get("frequency", 0) / 1000
                                        defaultCab["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000


@@ -822,9 +874,17 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
                        self.scan_ber.enabled = False
 
                        # sat
                        self.scan_ber.enabled = False
 
                        # sat

-                       self.scan_sat.system = ConfigSelection(default = defaultSat["system"], choices = [
+                       sat_choices = [

                                (eDVBFrontendParametersSatellite.System_DVB_S, _("DVB-S")),
                                (eDVBFrontendParametersSatellite.System_DVB_S, _("DVB-S")),

-                               (eDVBFrontendParametersSatellite.System_DVB_S2, _("DVB-S2"))])
+                               (eDVBFrontendParametersSatellite.System_DVB_S2, _("DVB-S2"))]
+
+                       sat_choices_dvbs2x = [
+                               (eDVBFrontendParametersSatellite.System_DVB_S, _("DVB-S")),
+                               (eDVBFrontendParametersSatellite.System_DVB_S2, _("DVB-S2")),
+                               (eDVBFrontendParametersSatellite.System_DVB_S2X, _("DVB-S2X"))]
+
+                       self.scan_sat.system = ConfigSelection(default = defaultSat["system"], choices = sat_choices)
+                       self.scan_sat.system_dvbs2x = ConfigSelection(default = defaultSat["system"], choices = sat_choices_dvbs2x)

                        self.scan_sat.frequency = ConfigInteger(default = defaultSat["frequency"], limits = (1, 99999))
                        self.scan_sat.inversion = ConfigSelection(default = defaultSat["inversion"], choices = [
                                (eDVBFrontendParametersSatellite.Inversion_Off, _("Off")),
                        self.scan_sat.frequency = ConfigInteger(default = defaultSat["frequency"], limits = (1, 99999))
                        self.scan_sat.inversion = ConfigSelection(default = defaultSat["inversion"], choices = [
                                (eDVBFrontendParametersSatellite.Inversion_Off, _("Off")),


@@ -854,9 +914,51 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
                                (eDVBFrontendParametersSatellite.FEC_7_8, "7/8"),
                                (eDVBFrontendParametersSatellite.FEC_8_9, "8/9"),
                                (eDVBFrontendParametersSatellite.FEC_9_10, "9/10")])
                                (eDVBFrontendParametersSatellite.FEC_7_8, "7/8"),
                                (eDVBFrontendParametersSatellite.FEC_8_9, "8/9"),
                                (eDVBFrontendParametersSatellite.FEC_9_10, "9/10")])

+
+                       self.scan_sat.fec_s2x_qpsk = ConfigSelection(default = defaultSat["fec_s2x_qpsk"], choices = [
+                               (eDVBFrontendParametersSatellite.FEC_13_45, "13/45"),
+                               (eDVBFrontendParametersSatellite.FEC_9_20, "9/20"),
+                               (eDVBFrontendParametersSatellite.FEC_11_20, "11/20")])
+
+                       self.scan_sat.fec_s2x_8psk = ConfigSelection(default = defaultSat["fec_s2x_8psk"], choices = [
+                               (eDVBFrontendParametersSatellite.FEC_23_36, "23/36"),
+                               (eDVBFrontendParametersSatellite.FEC_25_36, "25/36"),
+                               (eDVBFrontendParametersSatellite.FEC_13_18, "13/28")])
+
+                       self.scan_sat.fec_s2x_8apsk = ConfigSelection(default = defaultSat["fec_s2x_8apsk"], choices = [
+                               (eDVBFrontendParametersSatellite.FEC_5_9_L, "5/9-L"),
+                               (eDVBFrontendParametersSatellite.FEC_26_45_L, "26/45-L")])
+
+                       self.scan_sat.fec_s2x_16apsk = ConfigSelection(default = defaultSat["fec_s2x_16apsk"], choices = [
+                               (eDVBFrontendParametersSatellite.FEC_1_2_L, "1/2-L"),
+                               (eDVBFrontendParametersSatellite.FEC_8_15_L, "8/15-L"),
+                               (eDVBFrontendParametersSatellite.FEC_5_9_L, "5/9-L"),
+                               (eDVBFrontendParametersSatellite.FEC_26_45, "26/45"),
+                               (eDVBFrontendParametersSatellite.FEC_3_5, "3/5"),
+                               (eDVBFrontendParametersSatellite.FEC_3_5_L, "3/5-L"),
+                               (eDVBFrontendParametersSatellite.FEC_28_45, "28/45"),
+                               (eDVBFrontendParametersSatellite.FEC_23_36, "23/36"),
+                               (eDVBFrontendParametersSatellite.FEC_2_3_L, "2/3-L"),
+                               (eDVBFrontendParametersSatellite.FEC_25_36, "25/36"),
+                               (eDVBFrontendParametersSatellite.FEC_13_18, "13/18"),
+                               (eDVBFrontendParametersSatellite.FEC_7_9, "7/9"),
+                               (eDVBFrontendParametersSatellite.FEC_77_90, "77/90")])
+
+                       self.scan_sat.fec_s2x_32apsk = ConfigSelection(default = defaultSat["fec_s2x_32apsk"], choices = [
+                               (eDVBFrontendParametersSatellite.FEC_2_3_L, "2/3-L"),
+                               (eDVBFrontendParametersSatellite.FEC_32_45, "32/45"),
+                               (eDVBFrontendParametersSatellite.FEC_11_15, "11/15"),
+                               (eDVBFrontendParametersSatellite.FEC_7_9, "7/9")])
+

                        self.scan_sat.modulation = ConfigSelection(default = defaultSat["modulation"], choices = [
                                (eDVBFrontendParametersSatellite.Modulation_QPSK, "QPSK"),
                                (eDVBFrontendParametersSatellite.Modulation_8PSK, "8PSK")])
                        self.scan_sat.modulation = ConfigSelection(default = defaultSat["modulation"], choices = [
                                (eDVBFrontendParametersSatellite.Modulation_QPSK, "QPSK"),
                                (eDVBFrontendParametersSatellite.Modulation_8PSK, "8PSK")])

+                       self.scan_sat.modulation_dvbs2x = ConfigSelection(default = defaultSat["modulation_s2x"], choices = [
+                               (eDVBFrontendParametersSatellite.Modulation_QPSK, "QPSK"),
+                               (eDVBFrontendParametersSatellite.Modulation_8PSK, "8PSK"),
+                               (eDVBFrontendParametersSatellite.Modulation_8APSK, "8APSK"),
+                               (eDVBFrontendParametersSatellite.Modulation_16APSK, "16APSK"),
+                               (eDVBFrontendParametersSatellite.Modulation_32APSK, "32APSK")])

                        self.scan_sat.rolloff = ConfigSelection(default = defaultSat.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35), choices = [
                                (eDVBFrontendParametersSatellite.RollOff_alpha_0_35, "0.35"),
                                (eDVBFrontendParametersSatellite.RollOff_alpha_0_25, "0.25"),
                        self.scan_sat.rolloff = ConfigSelection(default = defaultSat.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35), choices = [
                                (eDVBFrontendParametersSatellite.RollOff_alpha_0_35, "0.35"),
                                (eDVBFrontendParametersSatellite.RollOff_alpha_0_25, "0.25"),


@@ -865,6 +967,14 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
                                (eDVBFrontendParametersSatellite.Pilot_Off, _("Off")),
                                (eDVBFrontendParametersSatellite.Pilot_On, _("On")),
                                (eDVBFrontendParametersSatellite.Pilot_Unknown, _("Auto"))])
                                (eDVBFrontendParametersSatellite.Pilot_Off, _("Off")),
                                (eDVBFrontendParametersSatellite.Pilot_On, _("On")),
                                (eDVBFrontendParametersSatellite.Pilot_Unknown, _("Auto"))])

+                       self.scan_sat.is_id = ConfigInteger(default = defaultSat["is_id"] if defaultSat["is_id"] != -1 else 0, limits = (0, 255))
+                       self.scan_sat.is_id_bool = ConfigSelection(default = defaultSat["is_id"] != -1, choices = [(True, _("Multistream")),(False, _("Ordinary"))])
+                       self.scan_sat.pls_mode = ConfigSelection(default = defaultSat["pls_mode"], choices = [
+                               (eDVBFrontendParametersSatellite.PLS_Root, _("Root")),
+                               (eDVBFrontendParametersSatellite.PLS_Gold, _("Gold")),
+                               (eDVBFrontendParametersSatellite.PLS_Combo, _("Combo")),
+                               (eDVBFrontendParametersSatellite.PLS_Unknown, _("Auto"))])
+                       self.scan_sat.pls_code = ConfigInteger(default = defaultSat["pls_code"], limits = (0, 262143))

 
                        # cable
                        self.scan_cab.frequency = ConfigInteger(default = defaultCab["frequency"], limits = (50, 999))
 
                        # cable
                        self.scan_cab.frequency = ConfigInteger(default = defaultCab["frequency"], limits = (50, 999))


@@ -1014,8 +1124,8 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
        def updateStatus(self):
                print "updatestatus"
 
        def updateStatus(self):
                print "updatestatus"
 

-       def addSatTransponder(self, tlist, frequency, symbol_rate, polarisation, fec, inversion, orbital_position, system, modulation, rolloff, pilot):
-               print "Add Sat: frequ: " + str(frequency) + " symbol: " + str(symbol_rate) + " pol: " + str(polarisation) + " fec: " + str(fec) + " inversion: " + str(inversion) + " modulation: " + str(modulation) + " system: " + str(system) + " rolloff" + str(rolloff) + " pilot" + str(pilot)
+       def addSatTransponder(self, tlist, frequency, symbol_rate, polarisation, fec, inversion, orbital_position, system, modulation, rolloff, pilot, is_id, pls_mode, pls_code):
+               print "Add Sat: frequ: " + str(frequency) + " symbol: " + str(symbol_rate) + " pol: " + str(polarisation) + " fec: " + str(fec) + " inversion: " + str(inversion) + " modulation: " + str(modulation) + " system: " + str(system) + " rolloff" + str(rolloff) + " pilot" + str(pilot) + " is_id" + str(is_id) + " pls_mode" + str(pls_mode) + " pls_code" + str(pls_code)

                print "orbpos: " + str(orbital_position)
                parm = eDVBFrontendParametersSatellite()
                parm.modulation = modulation
                print "orbpos: " + str(orbital_position)
                parm = eDVBFrontendParametersSatellite()
                parm.modulation = modulation


@@ -1028,6 +1138,9 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
                parm.orbital_position = orbital_position
                parm.rolloff = rolloff
                parm.pilot = pilot
                parm.orbital_position = orbital_position
                parm.rolloff = rolloff
                parm.pilot = pilot

+               parm.is_id = is_id
+               parm.pls_mode = pls_mode
+               parm.pls_code = pls_code

                tlist.append(parm)
 
        def addCabTransponder(self, tlist, frequency, symbol_rate, modulation, fec, inversion):
                tlist.append(parm)
 
        def addCabTransponder(self, tlist, frequency, symbol_rate, modulation, fec, inversion):


@@ -1072,13 +1185,45 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
                                nimsats = self.satList[index_to_scan]
                                selsatidx = self.scan_satselection[index_to_scan].index
 
                                nimsats = self.satList[index_to_scan]
                                selsatidx = self.scan_satselection[index_to_scan].index
 

+                               modulation = self.scan_sat.modulation.value

                                # however, the satList itself could be empty. in that case, "index" is 0 (for "None").
                                if len(nimsats):
                                        orbpos = nimsats[selsatidx][0]
                                # however, the satList itself could be empty. in that case, "index" is 0 (for "None").
                                if len(nimsats):
                                        orbpos = nimsats[selsatidx][0]

-                                       if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S:
+
+                                       system = self.scan_sat.system.value
+                                       if nim.isCompatible("DVB-S2X"):
+                                               system = self.scan_sat.system_dvbs2x.value
+
+                                       if system == eDVBFrontendParametersSatellite.System_DVB_S:

                                                fec = self.scan_sat.fec.value
                                                fec = self.scan_sat.fec.value

+                                       elif system == eDVBFrontendParametersSatellite.System_DVB_S2:
+                                               fec = self.scan_sat.fec_s2.value
+                                       elif system == eDVBFrontendParametersSatellite.System_DVB_S2X:
+                                               modulation = self.scan_sat.modulation_dvbs2x.value
+                                               if modulation == eDVBFrontendParametersSatellite.Modulation_QPSK:
+                                                       fec = self.scan_sat.fec_s2x_qpsk.value
+                                               elif modulation == eDVBFrontendParametersSatellite.Modulation_8PSK:
+                                                       fec = self.scan_sat.fec_s2x_8psk.value
+                                               elif modulation == eDVBFrontendParametersSatellite.Modulation_8APSK:
+                                                       fec = self.scan_sat.fec_s2x_8apsk.value
+                                               elif modulation == eDVBFrontendParametersSatellite.Modulation_16APSK:
+                                                       fec = self.scan_sat.fec_s2x_16apsk.value
+                                               elif modulation == eDVBFrontendParametersSatellite.Modulation_32APSK:
+                                                       fec = self.scan_sat.fec_s2x_32apsk.value

                                        else:
                                                fec = self.scan_sat.fec_s2.value
                                        else:
                                                fec = self.scan_sat.fec_s2.value

+
+                                       is_id = -1
+                                       pls_mode = eDVBFrontendParametersSatellite.PLS_Unknown
+                                       pls_code = 0
+                                       if self.scan_sat.is_id_bool.value:
+                                               is_id = self.scan_sat.is_id.value
+                                               pls_mode = self.scan_sat.pls_mode.value
+                                               if pls_mode == eDVBFrontendParametersSatellite.PLS_Unknown:
+                                                       pls_code = 0
+                                               else:
+                                                       pls_code = self.scan_sat.pls_code.value
+

                                        print "add sat transponder"
                                        self.addSatTransponder(tlist, self.scan_sat.frequency.value,
                                                                self.scan_sat.symbolrate.value,
                                        print "add sat transponder"
                                        self.addSatTransponder(tlist, self.scan_sat.frequency.value,
                                                                self.scan_sat.symbolrate.value,


@@ -1086,10 +1231,13 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
                                                                fec,
                                                                self.scan_sat.inversion.value,
                                                                orbpos,
                                                                fec,
                                                                self.scan_sat.inversion.value,
                                                                orbpos,

-                                                               self.scan_sat.system.value,
-                                                               self.scan_sat.modulation.value,
+                                                               system,
+                                                               modulation,

                                                                self.scan_sat.rolloff.value,
                                                                self.scan_sat.rolloff.value,

-                                                               self.scan_sat.pilot.value)
+                                                               self.scan_sat.pilot.value,
+                                                               is_id,
+                                                               pls_mode,
+                                                               pls_code)

                                removeAll = False
                        elif self.scan_type.value == "single_satellite":
                                sat = self.satList[index_to_scan][self.scan_satselection[index_to_scan].index]
                                removeAll = False
                        elif self.scan_type.value == "single_satellite":
                                sat = self.satList[index_to_scan][self.scan_satselection[index_to_scan].index]

diff --git a/lib/python/Screens/ServiceInfo.py b/lib/python/Screens/ServiceInfo.py
index ffd288f..6e7b58e 100644 (file)
--- a/lib/python/Screens/ServiceInfo.py
+++ b/lib/python/Screens/ServiceInfo.py
@@ -6,6 +6,7 @@ from Components.Label import Label
 from ServiceReference import ServiceReference
 from enigma import eListboxPythonMultiContent, eListbox, gFont, iServiceInformation, eServiceCenter
 from Tools.Transponder import ConvertToHumanReadable
 from ServiceReference import ServiceReference
 from enigma import eListboxPythonMultiContent, eListbox, gFont, iServiceInformation, eServiceCenter
 from Tools.Transponder import ConvertToHumanReadable

+from Components.NimManager import nimmanager

 import skin
 
 RT_HALIGN_LEFT = 0
 import skin
 
 RT_HALIGN_LEFT = 0


@@ -187,7 +188,7 @@ class ServiceInfo(Screen):
                if frontendDataOrg and len(frontendDataOrg):
                        frontendData = ConvertToHumanReadable(frontendDataOrg)
                        if frontendDataOrg["tuner_type"] == "DVB-S":
                if frontendDataOrg and len(frontendDataOrg):
                        frontendData = ConvertToHumanReadable(frontendDataOrg)
                        if frontendDataOrg["tuner_type"] == "DVB-S":

-                               return ((_("NIM"), chr(ord('A')+int(frontendData["tuner_number"])), TYPE_TEXT),
+                               data = ((_("NIM"), chr(ord('A')+int(frontendData["tuner_number"])), TYPE_TEXT),

                                                (_("Type"), frontendData["tuner_type"], TYPE_TEXT),
                                                (_("System"), frontendData["system"], TYPE_TEXT),
                                                (_("Modulation"), frontendData["modulation"], TYPE_TEXT),
                                                (_("Type"), frontendData["tuner_type"], TYPE_TEXT),
                                                (_("System"), frontendData["system"], TYPE_TEXT),
                                                (_("Modulation"), frontendData["modulation"], TYPE_TEXT),


@@ -199,6 +200,11 @@ class ServiceInfo(Screen):
                                                (_("FEC"), frontendData["fec_inner"], TYPE_TEXT),
                                                (_("Pilot"), frontendData.get("pilot", None), TYPE_TEXT),
                                                (_("Roll-off"), frontendData.get("rolloff", None), TYPE_TEXT))
                                                (_("FEC"), frontendData["fec_inner"], TYPE_TEXT),
                                                (_("Pilot"), frontendData.get("pilot", None), TYPE_TEXT),
                                                (_("Roll-off"), frontendData.get("rolloff", None), TYPE_TEXT))

+                               if nimmanager.isSupportMultistream(int(frontendData["tuner_number"])):
+                                       data += ((_("Input Stream ID"), frontendData.get("is_id", 0), TYPE_VALUE_DEC),
+                                               (_("PLS Mode"), frontendData.get("pls_mode", None), TYPE_TEXT),
+                                               (_("PLS Code"), frontendData.get("pls_code", 0), TYPE_VALUE_DEC))
+                               return data

                        elif frontendDataOrg["tuner_type"] == "DVB-C":
                                return ((_("NIM"), chr(ord('A')+int(frontendData["tuner_number"])), TYPE_TEXT),
                                                (_("Type"), frontendData["tuner_type"], TYPE_TEXT),
                        elif frontendDataOrg["tuner_type"] == "DVB-C":
                                return ((_("NIM"), chr(ord('A')+int(frontendData["tuner_number"])), TYPE_TEXT),
                                                (_("Type"), frontendData["tuner_type"], TYPE_TEXT),

diff --git a/lib/python/Tools/Transponder.py b/lib/python/Tools/Transponder.py
index a882981..dffc3d2 100644 (file)
--- a/lib/python/Tools/Transponder.py
+++ b/lib/python/Tools/Transponder.py
@@ -22,12 +22,34 @@ def ConvertToHumanReadable(tp, type = None):
                        eDVBFrontendParametersSatellite.FEC_3_5 : "3/5",
                        eDVBFrontendParametersSatellite.FEC_4_5 : "4/5",
                        eDVBFrontendParametersSatellite.FEC_8_9 : "8/9",
                        eDVBFrontendParametersSatellite.FEC_3_5 : "3/5",
                        eDVBFrontendParametersSatellite.FEC_4_5 : "4/5",
                        eDVBFrontendParametersSatellite.FEC_8_9 : "8/9",

-                       eDVBFrontendParametersSatellite.FEC_9_10 : "9/10"}[tp["fec_inner"]]
+                       eDVBFrontendParametersSatellite.FEC_9_10 : "9/10",
+                       eDVBFrontendParametersSatellite.FEC_13_45 : "13/45",
+                       eDVBFrontendParametersSatellite.FEC_9_20 : "9/20",
+                       eDVBFrontendParametersSatellite.FEC_11_20 : "11/20",
+                       eDVBFrontendParametersSatellite.FEC_23_36 : "23/36",
+                       eDVBFrontendParametersSatellite.FEC_25_36 : "25/36",
+                       eDVBFrontendParametersSatellite.FEC_13_18 : "13/18",
+                       eDVBFrontendParametersSatellite.FEC_26_45 : "26/45",
+                       eDVBFrontendParametersSatellite.FEC_28_45 : "28/45",
+                       eDVBFrontendParametersSatellite.FEC_7_9 : "7/9",
+                       eDVBFrontendParametersSatellite.FEC_77_90 : "77/90",
+                       eDVBFrontendParametersSatellite.FEC_32_45 : "32/45",
+                       eDVBFrontendParametersSatellite.FEC_11_15 : "11/15",
+                       eDVBFrontendParametersSatellite.FEC_1_2_L : "1/2-L",
+                       eDVBFrontendParametersSatellite.FEC_8_15_L : "8/15-L",
+                       eDVBFrontendParametersSatellite.FEC_3_5_L : "3/5-L",
+                       eDVBFrontendParametersSatellite.FEC_2_3_L : "2/3-L",
+                       eDVBFrontendParametersSatellite.FEC_5_9_L : "5/9-L",
+                       eDVBFrontendParametersSatellite.FEC_26_45_L : "26/45-L"}[tp["fec_inner"]]

                ret["modulation"] = {
                        eDVBFrontendParametersSatellite.Modulation_Auto : _("Auto"),
                        eDVBFrontendParametersSatellite.Modulation_QPSK : "QPSK",
                        eDVBFrontendParametersSatellite.Modulation_QAM16 : "QAM16",
                ret["modulation"] = {
                        eDVBFrontendParametersSatellite.Modulation_Auto : _("Auto"),
                        eDVBFrontendParametersSatellite.Modulation_QPSK : "QPSK",
                        eDVBFrontendParametersSatellite.Modulation_QAM16 : "QAM16",

-                       eDVBFrontendParametersSatellite.Modulation_8PSK : "8PSK"}[tp["modulation"]]
+                       eDVBFrontendParametersSatellite.Modulation_8PSK : "8PSK",
+                       eDVBFrontendParametersSatellite.Modulation_16APSK : "16APSK",
+                       eDVBFrontendParametersSatellite.Modulation_32APSK : "32APSK",
+                       eDVBFrontendParametersSatellite.Modulation_8APSK : "8APSK",
+                       }[tp["modulation"]]

                ret["orbital_position"] = nimmanager.getSatName(int(tp["orbital_position"]))
                ret["polarization"] = {
                        eDVBFrontendParametersSatellite.Polarisation_Horizontal : _("Horizontal"),
                ret["orbital_position"] = nimmanager.getSatName(int(tp["orbital_position"]))
                ret["polarization"] = {
                        eDVBFrontendParametersSatellite.Polarisation_Horizontal : _("Horizontal"),


@@ -36,8 +58,9 @@ def ConvertToHumanReadable(tp, type = None):
                        eDVBFrontendParametersSatellite.Polarisation_CircularRight : _("Circular right")}[tp["polarization"]]
                ret["system"] = {
                        eDVBFrontendParametersSatellite.System_DVB_S : "DVB-S",
                        eDVBFrontendParametersSatellite.Polarisation_CircularRight : _("Circular right")}[tp["polarization"]]
                ret["system"] = {
                        eDVBFrontendParametersSatellite.System_DVB_S : "DVB-S",

-                       eDVBFrontendParametersSatellite.System_DVB_S2 : "DVB-S2"}[tp["system"]]
-               if ret["system"] == "DVB-S2":
+                       eDVBFrontendParametersSatellite.System_DVB_S2 : "DVB-S2",
+                       eDVBFrontendParametersSatellite.System_DVB_S2X : "DVB-S2X"}[tp["system"]]
+               if ret["system"] in ("DVB-S2", "DVB-S2X"):

                        ret["rolloff"] = {
                                eDVBFrontendParametersSatellite.RollOff_alpha_0_35 : "0.35",
                                eDVBFrontendParametersSatellite.RollOff_alpha_0_25 : "0.25",
                        ret["rolloff"] = {
                                eDVBFrontendParametersSatellite.RollOff_alpha_0_35 : "0.35",
                                eDVBFrontendParametersSatellite.RollOff_alpha_0_25 : "0.25",


@@ -46,6 +69,17 @@ def ConvertToHumanReadable(tp, type = None):
                                eDVBFrontendParametersSatellite.Pilot_Unknown : _("Auto"),
                                eDVBFrontendParametersSatellite.Pilot_On : _("On"),
                                eDVBFrontendParametersSatellite.Pilot_Off : _("Off")}[tp["pilot"]]
                                eDVBFrontendParametersSatellite.Pilot_Unknown : _("Auto"),
                                eDVBFrontendParametersSatellite.Pilot_On : _("On"),
                                eDVBFrontendParametersSatellite.Pilot_Off : _("Off")}[tp["pilot"]]

+                       ret["pls_mode"] = {
+                               eDVBFrontendParametersSatellite.PLS_Root : _("Root"),
+                               eDVBFrontendParametersSatellite.PLS_Gold : _("Gold"),
+                               eDVBFrontendParametersSatellite.PLS_Combo : _("Combo"),
+                               eDVBFrontendParametersSatellite.PLS_Unknown : _("Auto")}.get(tp.get("pls_mode"))
+                       #ret["is_id"] = tp.get("is_id")
+                       #ret["pls_code"] = tp.get("pls_code")
+               else:
+                       ret["pls_mode"] = None
+                       ret["is_id"] = None
+                       ret["pls_code"] = None

        elif type == "DVB-C":
                ret["tuner_type"] = _("Cable")
                ret["modulation"] = {
        elif type == "DVB-C":
                ret["tuner_type"] = _("Cable")
                ret["modulation"] = {


@@ -83,6 +117,7 @@ def ConvertToHumanReadable(tp, type = None):
                        eDVBFrontendParametersTerrestrial.FEC_1_2 : "1/2",
                        eDVBFrontendParametersTerrestrial.FEC_2_3 : "2/3",
                        eDVBFrontendParametersTerrestrial.FEC_3_4 : "3/4",
                        eDVBFrontendParametersTerrestrial.FEC_1_2 : "1/2",
                        eDVBFrontendParametersTerrestrial.FEC_2_3 : "2/3",
                        eDVBFrontendParametersTerrestrial.FEC_3_4 : "3/4",

+                       eDVBFrontendParametersTerrestrial.FEC_4_5 : "4/5",

                        eDVBFrontendParametersTerrestrial.FEC_5_6 : "5/6",
                        eDVBFrontendParametersTerrestrial.FEC_6_7 : "6/7",
                        eDVBFrontendParametersTerrestrial.FEC_7_8 : "7/8",
                        eDVBFrontendParametersTerrestrial.FEC_5_6 : "5/6",
                        eDVBFrontendParametersTerrestrial.FEC_6_7 : "6/7",
                        eDVBFrontendParametersTerrestrial.FEC_7_8 : "7/8",


@@ -92,6 +127,7 @@ def ConvertToHumanReadable(tp, type = None):
                        eDVBFrontendParametersTerrestrial.FEC_1_2 : "1/2",
                        eDVBFrontendParametersTerrestrial.FEC_2_3 : "2/3",
                        eDVBFrontendParametersTerrestrial.FEC_3_4 : "3/4",
                        eDVBFrontendParametersTerrestrial.FEC_1_2 : "1/2",
                        eDVBFrontendParametersTerrestrial.FEC_2_3 : "2/3",
                        eDVBFrontendParametersTerrestrial.FEC_3_4 : "3/4",

+                       eDVBFrontendParametersTerrestrial.FEC_4_5 : "4/5",

                        eDVBFrontendParametersTerrestrial.FEC_5_6 : "5/6",
                        eDVBFrontendParametersTerrestrial.FEC_6_7 : "6/7",
                        eDVBFrontendParametersTerrestrial.FEC_7_8 : "7/8",
                        eDVBFrontendParametersTerrestrial.FEC_5_6 : "5/6",
                        eDVBFrontendParametersTerrestrial.FEC_6_7 : "6/7",
                        eDVBFrontendParametersTerrestrial.FEC_7_8 : "7/8",