remove nested structures because of the fact that swig cannot handle this
authorghost <andreas.monzner@multimedia-labs.de>
Mon, 19 Jan 2009 20:05:45 +0000 (21:05 +0100)
committerghost <andreas.monzner@multimedia-labs.de>
Mon, 19 Jan 2009 20:05:45 +0000 (21:05 +0100)
now we no more need the bad duplicate definitions of eDVBFrontendParametersSatellite/Cables/Terrestrial content
i.e. eDVBFrontendParametersSatellite.System_DVB_S or eDVBFrontendParametersSatellite.FEC_Auto....

lib/dvb/db.cpp
lib/dvb/frontend.cpp
lib/dvb/frontendparms.h
lib/dvb/sec.cpp
lib/python/Plugins/SystemPlugins/PositionerSetup/plugin.py
lib/python/Plugins/SystemPlugins/Satfinder/plugin.py
lib/python/Screens/ScanSetup.py
lib/service/servicedvb.cpp

index e5a9439..719ff35 100644 (file)
@@ -327,10 +327,10 @@ void eDVBDB::loadServicelist(const char *file)
                                eDVBFrontendParametersSatellite sat;
                                int frequency, symbol_rate, polarisation, fec, orbital_position, inversion,
                                        flags=0,
-                                       system=eDVBFrontendParametersSatellite::System::DVB_S,
-                                       modulation=eDVBFrontendParametersSatellite::Modulation::QPSK,
-                                       rolloff=eDVBFrontendParametersSatellite::RollOff::alpha_0_35,
-                                       pilot=eDVBFrontendParametersSatellite::Pilot::Unknown;
+                                       system=eDVBFrontendParametersSatellite::System_DVB_S,
+                                       modulation=eDVBFrontendParametersSatellite::Modulation_QPSK,
+                                       rolloff=eDVBFrontendParametersSatellite::RollOff_alpha_0_35,
+                                       pilot=eDVBFrontendParametersSatellite::Pilot_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
@@ -368,9 +368,9 @@ void eDVBDB::loadServicelist(const char *file)
                        {
                                eDVBFrontendParametersCable cab;
                                int frequency, symbol_rate,
-                                       inversion=eDVBFrontendParametersCable::Inversion::Unknown,
-                                       modulation=eDVBFrontendParametersCable::Modulation::Auto,
-                                       fec_inner=eDVBFrontendParametersCable::FEC::fAuto,
+                                       inversion=eDVBFrontendParametersCable::Inversion_Unknown,
+                                       modulation=eDVBFrontendParametersCable::Modulation_Auto,
+                                       fec_inner=eDVBFrontendParametersCable::FEC_Auto,
                                        flags=0;
                                sscanf(line+3, "%d:%d:%d:%d:%d:%d", &frequency, &symbol_rate, &inversion, &modulation, &fec_inner, &flags);
                                cab.frequency = frequency;
@@ -495,7 +495,7 @@ void eDVBDB::saveServicelist(const char *file)
                ch.m_frontendParameters->getFlags(flags);
                if (!ch.m_frontendParameters->getDVBS(sat))
                {
-                       if (sat.system == eDVBFrontendParametersSatellite::System::DVB_S2)
+                       if (sat.system == eDVBFrontendParametersSatellite::System_DVB_S2)
                        {
                                fprintf(f, "\ts %d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d\n",
                                        sat.frequency, sat.symbol_rate,
index aae7bbc..5fe3799 100644 (file)
@@ -1,4 +1,5 @@
 #include <lib/dvb/dvb.h>
+#include <lib/dvb/frontendparms.h>
 #include <lib/base/eerror.h>
 #include <lib/base/nconfig.h> // access to python config
 #include <errno.h>
@@ -148,10 +149,10 @@ void eDVBFrontendParametersSatellite::set(const SatelliteDeliverySystemDescripto
        symbol_rate  = descriptor.getSymbolRate() * 100;
        polarisation = descriptor.getPolarization();
        fec = descriptor.getFecInner();
-       if ( fec != FEC::fNone && fec > FEC::f9_10 )
-               fec = FEC::fAuto;
-       inversion = Inversion::Unknown;
-       pilot = Pilot::Unknown;
+       if ( fec != eDVBFrontendParametersSatellite::FEC_None && fec > eDVBFrontendParametersSatellite::FEC_9_10 )
+               fec = eDVBFrontendParametersSatellite::FEC_Auto;
+       inversion = eDVBFrontendParametersSatellite::Inversion_Unknown;
+       pilot = eDVBFrontendParametersSatellite::Pilot_Unknown;
        orbital_position  = ((descriptor.getOrbitalPosition() >> 12) & 0xF) * 1000;
        orbital_position += ((descriptor.getOrbitalPosition() >> 8) & 0xF) * 100;
        orbital_position += ((descriptor.getOrbitalPosition() >> 4) & 0xF) * 10;
@@ -160,13 +161,13 @@ void eDVBFrontendParametersSatellite::set(const SatelliteDeliverySystemDescripto
                orbital_position = 3600 - orbital_position;
        system = descriptor.getModulationSystem();
        modulation = descriptor.getModulation();
-       if (system == System::DVB_S && modulation == Modulation::M8PSK)
+       if (system == eDVBFrontendParametersSatellite::System_DVB_S && modulation == eDVBFrontendParametersSatellite::Modulation_8PSK)
        {
                eDebug("satellite_delivery_descriptor non valid modulation type.. force QPSK");
-               modulation=QPSK;
+               modulation=eDVBFrontendParametersSatellite::Modulation_QPSK;
        }
        rolloff = descriptor.getRollOff();
-       if (system == System::DVB_S2)
+       if (system == eDVBFrontendParametersSatellite::System_DVB_S2)
        {
                eDebug("SAT DVB-S2 freq %d, %s, pos %d, sr %d, fec %d, modulation %d, rolloff %d",
                        frequency,
@@ -192,11 +193,11 @@ void eDVBFrontendParametersCable::set(const CableDeliverySystemDescriptor &descr
        symbol_rate = descriptor.getSymbolRate() * 100;
        fec_inner = descriptor.getFecInner();
        if ( fec_inner == 0xF )
-               fec_inner = FEC::fNone;
+               fec_inner = eDVBFrontendParametersCable::FEC_None;
        modulation = descriptor.getModulation();
        if ( modulation > 0x5 )
-               modulation = Modulation::Auto;
-       inversion = Inversion::Unknown;
+               modulation = eDVBFrontendParametersCable::Modulation_Auto;
+       inversion = eDVBFrontendParametersCable::Inversion_Unknown;
        eDebug("Cable freq %d, mod %d, sr %d, fec %d",
                frequency,
                modulation, symbol_rate, fec_inner);
@@ -207,24 +208,24 @@ void eDVBFrontendParametersTerrestrial::set(const TerrestrialDeliverySystemDescr
        frequency = descriptor.getCentreFrequency() * 10;
        bandwidth = descriptor.getBandwidth();
        if ( bandwidth > 2 ) // 5Mhz forced to auto
-               bandwidth = Bandwidth::BwAuto;
+               bandwidth = eDVBFrontendParametersTerrestrial::Bandwidth_Auto;
        code_rate_HP = descriptor.getCodeRateHpStream();
        if (code_rate_HP > 4)
-               code_rate_HP = FEC::fAuto;
+               code_rate_HP = eDVBFrontendParametersTerrestrial::FEC_Auto;
        code_rate_LP = descriptor.getCodeRateLpStream();
        if (code_rate_LP > 4)
-               code_rate_LP = FEC::fAuto;
+               code_rate_LP = eDVBFrontendParametersTerrestrial::FEC_Auto;
        transmission_mode = descriptor.getTransmissionMode();
        if (transmission_mode > 1) // TM4k forced to auto
-               transmission_mode = TransmissionMode::TMAuto;
+               transmission_mode = eDVBFrontendParametersTerrestrial::TransmissionMode_Auto;
        guard_interval = descriptor.getGuardInterval();
        if (guard_interval > 3)
-               guard_interval = GuardInterval::GI_Auto;
+               guard_interval = eDVBFrontendParametersTerrestrial::GuardInterval_Auto;
        hierarchy = descriptor.getHierarchyInformation()&3;
        modulation = descriptor.getConstellation();
        if (modulation > 2)
-               modulation = Modulation::Auto;
-       inversion = Inversion::Unknown;
+               modulation = eDVBFrontendParametersTerrestrial::Modulation_Auto;
+       inversion = eDVBFrontendParametersTerrestrial::Inversion_Unknown;
        eDebug("Terr freq %d, bw %d, cr_hp %d, cr_lp %d, tm_mode %d, guard %d, hierarchy %d, const %d",
                frequency, bandwidth, code_rate_HP, code_rate_LP, transmission_mode,
                guard_interval, hierarchy, modulation);
@@ -316,9 +317,9 @@ RESULT eDVBFrontendParameters::calculateDifference(const iDVBFrontendParameters
                        diff = 1<<29;
                else if (sat.polarisation != osat.polarisation)
                        diff = 1<<28;
-               else if (exact && sat.fec != osat.fec && sat.fec != eDVBFrontendParametersSatellite::FEC::fAuto && osat.fec != eDVBFrontendParametersSatellite::FEC::fAuto)
+               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.modulation != osat.modulation && sat.modulation != eDVBFrontendParametersSatellite::Modulation_Auto && osat.modulation != eDVBFrontendParametersSatellite::Modulation_Auto)
                        diff = 1<<27;
                else
                {
@@ -333,10 +334,10 @@ RESULT eDVBFrontendParameters::calculateDifference(const iDVBFrontendParameters
                        return -2;
 
                if (exact && cable.modulation != ocable.modulation
-                       && cable.modulation != eDVBFrontendParametersCable::Modulation::Auto
-                       && ocable.modulation != eDVBFrontendParametersCable::Modulation::Auto)
+                       && cable.modulation != eDVBFrontendParametersCable::Modulation_Auto
+                       && ocable.modulation != eDVBFrontendParametersCable::Modulation_Auto)
                        diff = 1 << 29;
-               else if (exact && cable.fec_inner != ocable.fec_inner && cable.fec_inner != eDVBFrontendParametersCable::FEC::fAuto && ocable.fec_inner != eDVBFrontendParametersCable::FEC::fAuto)
+               else if (exact && cable.fec_inner != ocable.fec_inner && cable.fec_inner != eDVBFrontendParametersCable::FEC_Auto && ocable.fec_inner != eDVBFrontendParametersCable::FEC_Auto)
                        diff = 1 << 27;
                else
                {
@@ -350,32 +351,32 @@ RESULT eDVBFrontendParameters::calculateDifference(const iDVBFrontendParameters
                        return -2;
 
                if (exact && oterrestrial.bandwidth != terrestrial.bandwidth &&
-                       oterrestrial.bandwidth != eDVBFrontendParametersTerrestrial::Bandwidth::BwAuto &&
-                       terrestrial.bandwidth != eDVBFrontendParametersTerrestrial::Bandwidth::BwAuto)
+                       oterrestrial.bandwidth != eDVBFrontendParametersTerrestrial::Bandwidth_Auto &&
+                       terrestrial.bandwidth != eDVBFrontendParametersTerrestrial::Bandwidth_Auto)
                        diff = 1 << 30;
                else if (exact && oterrestrial.modulation != terrestrial.modulation &&
-                       oterrestrial.modulation != eDVBFrontendParametersTerrestrial::Modulation::Auto &&
-                       terrestrial.modulation != eDVBFrontendParametersTerrestrial::Modulation::Auto)
+                       oterrestrial.modulation != eDVBFrontendParametersTerrestrial::Modulation_Auto &&
+                       terrestrial.modulation != eDVBFrontendParametersTerrestrial::Modulation_Auto)
                        diff = 1 << 30;
                else if (exact && oterrestrial.transmission_mode != terrestrial.transmission_mode &&
-                       oterrestrial.transmission_mode != eDVBFrontendParametersTerrestrial::TransmissionMode::TMAuto &&
-                       terrestrial.transmission_mode != eDVBFrontendParametersTerrestrial::TransmissionMode::TMAuto)
+                       oterrestrial.transmission_mode != eDVBFrontendParametersTerrestrial::TransmissionMode_Auto &&
+                       terrestrial.transmission_mode != eDVBFrontendParametersTerrestrial::TransmissionMode_Auto)
                        diff = 1 << 30;
                else if (exact && oterrestrial.guard_interval != terrestrial.guard_interval &&
-                       oterrestrial.guard_interval != eDVBFrontendParametersTerrestrial::GuardInterval::GI_Auto &&
-                       terrestrial.guard_interval != eDVBFrontendParametersTerrestrial::GuardInterval::GI_Auto)
+                       oterrestrial.guard_interval != eDVBFrontendParametersTerrestrial::GuardInterval_Auto &&
+                       terrestrial.guard_interval != eDVBFrontendParametersTerrestrial::GuardInterval_Auto)
                        diff = 1 << 30;
                else if (exact && oterrestrial.hierarchy != terrestrial.hierarchy &&
-                       oterrestrial.hierarchy != eDVBFrontendParametersTerrestrial::Hierarchy::HAuto &&
-                       terrestrial.hierarchy != eDVBFrontendParametersTerrestrial::Hierarchy::HAuto)
+                       oterrestrial.hierarchy != eDVBFrontendParametersTerrestrial::Hierarchy_Auto &&
+                       terrestrial.hierarchy != eDVBFrontendParametersTerrestrial::Hierarchy_Auto)
                        diff = 1 << 30;
                else if (exact && oterrestrial.code_rate_LP != terrestrial.code_rate_LP &&
-                       oterrestrial.code_rate_LP != eDVBFrontendParametersTerrestrial::FEC::fAuto &&
-                       terrestrial.code_rate_LP != eDVBFrontendParametersTerrestrial::FEC::fAuto)
+                       oterrestrial.code_rate_LP != eDVBFrontendParametersTerrestrial::FEC_Auto &&
+                       terrestrial.code_rate_LP != eDVBFrontendParametersTerrestrial::FEC_Auto)
                        diff = 1 << 30;
                else if (exact && oterrestrial.code_rate_HP != terrestrial.code_rate_HP &&
-                       oterrestrial.code_rate_HP != eDVBFrontendParametersTerrestrial::FEC::fAuto &&
-                       terrestrial.code_rate_HP != eDVBFrontendParametersTerrestrial::FEC::fAuto)
+                       oterrestrial.code_rate_HP != eDVBFrontendParametersTerrestrial::FEC_Auto &&
+                       terrestrial.code_rate_HP != eDVBFrontendParametersTerrestrial::FEC_Auto)
                        diff = 1 << 30;
                else
                        diff = abs(terrestrial.frequency - oterrestrial.frequency);
@@ -963,120 +964,79 @@ void PutToDict(ePyObject &dict, const char*key, const char *value)
 void fillDictWithSatelliteData(ePyObject dict, const FRONTENDPARAMETERS &parm, eDVBFrontend *fe)
 {
        long freq_offset=0;
-       const char *tmp=0;
+       long tmp=0;
        fe->getData(eDVBFrontend::FREQ_OFFSET, freq_offset);
        int frequency = parm_frequency + freq_offset;
        PutToDict(dict, "frequency", frequency);
        PutToDict(dict, "symbol_rate", parm_u_qpsk_symbol_rate);
        switch(parm_u_qpsk_fec_inner)
        {
-       case FEC_1_2:
-               tmp = "FEC_1_2";
-               break;
-       case FEC_2_3:
-               tmp = "FEC_2_3";
-               break;
-       case FEC_3_4:
-               tmp = "FEC_3_4";
-               break;
-       case FEC_5_6:
-               tmp = "FEC_5_6";
-               break;
-       case FEC_7_8:
-               tmp = "FEC_7_8";
-               break;
-       case FEC_NONE:
-               tmp = "FEC_NONE";
+       case FEC_1_2: tmp = eDVBFrontendParametersSatellite::FEC_1_2; break;
+       case FEC_2_3: tmp = eDVBFrontendParametersSatellite::FEC_2_3; break;
+       case FEC_3_4: tmp = eDVBFrontendParametersSatellite::FEC_3_4; break;
+       case FEC_5_6: tmp = eDVBFrontendParametersSatellite::FEC_5_6; break;
+       case FEC_7_8: tmp = eDVBFrontendParametersSatellite::FEC_7_8; break;
+       case FEC_NONE: tmp = eDVBFrontendParametersSatellite::FEC_None; break;
        default:
-       case FEC_AUTO:
-               tmp = "FEC_AUTO";
-               break;
+       case FEC_AUTO: tmp = eDVBFrontendParametersSatellite::FEC_Auto; break;
 #if HAVE_DVB_API_VERSION >=3
-       case FEC_S2_8PSK_1_2:
-       case FEC_S2_QPSK_1_2:
-               tmp = "FEC_1_2";
-               break;
+       case FEC_S2_8PSK_1_2: 
+       case FEC_S2_QPSK_1_2: tmp = eDVBFrontendParametersSatellite::FEC_1_2; break;
        case FEC_S2_8PSK_2_3:
-       case FEC_S2_QPSK_2_3:
-               tmp = "FEC_2_3";
-               break;
+       case FEC_S2_QPSK_2_3: tmp = eDVBFrontendParametersSatellite::FEC_2_3; break;
        case FEC_S2_8PSK_3_4:
-       case FEC_S2_QPSK_3_4:
-               tmp = "FEC_3_4";
-               break;
+       case FEC_S2_QPSK_3_4: tmp = eDVBFrontendParametersSatellite::FEC_3_4; break;
        case FEC_S2_8PSK_5_6:
-       case FEC_S2_QPSK_5_6:
-               tmp = "FEC_5_6";
-               break;
+       case FEC_S2_QPSK_5_6: tmp = eDVBFrontendParametersSatellite::FEC_5_6; break;
        case FEC_S2_8PSK_7_8:
-       case FEC_S2_QPSK_7_8:
-               tmp = "FEC_7_8";
-               break;
+       case FEC_S2_QPSK_7_8: tmp = eDVBFrontendParametersSatellite::FEC_7_8; break;
        case FEC_S2_8PSK_8_9:
-       case FEC_S2_QPSK_8_9:
-               tmp = "FEC_8_9";
-               break;
+       case FEC_S2_QPSK_8_9: tmp = eDVBFrontendParametersSatellite::FEC_8_9; break;
        case FEC_S2_8PSK_3_5:
-       case FEC_S2_QPSK_3_5:
-               tmp = "FEC_3_5";
-               break;
+       case FEC_S2_QPSK_3_5: tmp = eDVBFrontendParametersSatellite::FEC_3_5; break;
        case FEC_S2_8PSK_4_5:
-       case FEC_S2_QPSK_4_5:
-               tmp = "FEC_4_5";
-               break;
+       case FEC_S2_QPSK_4_5: tmp = eDVBFrontendParametersSatellite::FEC_4_5; break;
        case FEC_S2_8PSK_9_10:
-       case FEC_S2_QPSK_9_10:
-               tmp = "FEC_9_10";
-               break;
+       case FEC_S2_QPSK_9_10: tmp = eDVBFrontendParametersSatellite::FEC_9_10; break;
 #endif
        }
        PutToDict(dict, "fec_inner", tmp);
 #if HAVE_DVB_API_VERSION >=3
        PutToDict(dict, "modulation",
-               parm_u_qpsk_fec_inner > FEC_S2_QPSK_9_10 ? "8PSK": "QPSK" );
+               parm_u_qpsk_fec_inner > FEC_S2_QPSK_9_10 ?
+                       eDVBFrontendParametersSatellite::Modulation_8PSK :
+                       eDVBFrontendParametersSatellite::Modulation_QPSK );
        if (parm_u_qpsk_fec_inner > FEC_AUTO)
        {
                switch(parm_inversion & 0xc)
                {
                default: // unknown rolloff
-               case 0: // 0.35
-                       tmp = "ROLLOFF_0_35";
-                       break;
-               case 4: // 0.25
-                       tmp = "ROLLOFF_0_25";
-                       break;
-               case 8: // 0.20
-                       tmp = "ROLLOFF_0_20";
-                       break;
+               case 0: tmp = eDVBFrontendParametersSatellite::RollOff_alpha_0_35; break;
+               case 4: tmp = eDVBFrontendParametersSatellite::RollOff_alpha_0_25; break;
+               case 8: tmp = eDVBFrontendParametersSatellite::RollOff_alpha_0_20; break;
                }
                PutToDict(dict, "rolloff", tmp);
                switch(parm_inversion & 0x30)
                {
-               case 0: // pilot off
-                       tmp = "PILOT_OFF";
-                       break;
-               case 0x10: // pilot on
-                       tmp = "PILOT_ON";
-                       break;
-               case 0x20: // pilot auto
-                       tmp = "PILOT_AUTO";
-                       break;
+               case 0: tmp = eDVBFrontendParametersSatellite::Pilot_Off; break;
+               case 0x10: tmp = eDVBFrontendParametersSatellite::Pilot_On; break;
+               case 0x20: tmp = eDVBFrontendParametersSatellite::Pilot_Unknown; break;
                }
                PutToDict(dict, "pilot", tmp);
-               tmp = "DVB-S2";
+               tmp = eDVBFrontendParametersSatellite::System_DVB_S2;
        }
        else
-               tmp = "DVB-S";
+               tmp = eDVBFrontendParametersSatellite::System_DVB_S;
 #else
-       PutToDict(dict, "modulation", "QPSK" );
-       tmp = "DVB-S";
+       PutToDict(dict, "modulation", eDVBFrontendParametersSatellite::Modulation_QPSK );
+       tmp = eDVBFrontendParametersSatellite::System_DVB_S;
 #endif
        PutToDict(dict, "system", tmp);
 }
 
 void fillDictWithCableData(ePyObject dict, const FRONTENDPARAMETERS &parm)
 {
-       const char *tmp=0;
+       long tmp=0;
 #if HAVE_DVB_API_VERSION < 3
        PutToDict(dict, "frequency", parm_frequency);
 #else
@@ -1085,196 +1045,102 @@ void fillDictWithCableData(ePyObject dict, const FRONTENDPARAMETERS &parm)
        PutToDict(dict, "symbol_rate", parm_u_qam_symbol_rate);
        switch(parm_u_qam_fec_inner)
        {
-       case FEC_NONE:
-               tmp = "FEC_NONE";
-               break;
-       case FEC_1_2:
-               tmp = "FEC_1_2";
-               break;
-       case FEC_2_3:
-               tmp = "FEC_2_3";
-               break;
-       case FEC_3_4:
-               tmp = "FEC_3_4";
-               break;
-       case FEC_5_6:
-               tmp = "FEC_5_6";
-               break;
-       case FEC_7_8:
-               tmp = "FEC_7_8";
-               break;
+       case FEC_NONE: tmp = eDVBFrontendParametersCable::FEC_None; break;
+       case FEC_1_2: tmp = eDVBFrontendParametersCable::FEC_1_2; break;
+       case FEC_2_3: tmp = eDVBFrontendParametersCable::FEC_2_3; break;
+       case FEC_3_4: tmp = eDVBFrontendParametersCable::FEC_3_4; break;
+       case FEC_5_6: tmp = eDVBFrontendParametersCable::FEC_5_6; break;
+       case FEC_7_8: tmp = eDVBFrontendParametersCable::FEC_7_8; break;
 #if HAVE_DVB_API_VERSION >= 3
-       case FEC_8_9:
-               tmp = "FEC_8_9";
-               break;
+       case FEC_8_9: tmp = eDVBFrontendParametersCable::FEC_7_8; break;
 #endif
        default:
-       case FEC_AUTO:
-               tmp = "FEC_AUTO";
-               break;
+       case FEC_AUTO: tmp = eDVBFrontendParametersCable::FEC_Auto; break;
        }
        PutToDict(dict, "fec_inner", tmp);
        switch(parm_u_qam_modulation)
        {
-       case QAM_16:
-               tmp = "QAM_16";
-               break;
-       case QAM_32:
-               tmp = "QAM_32";
-               break;
-       case QAM_64:
-               tmp = "QAM_64";
-               break;
-       case QAM_128:
-               tmp = "QAM_128";
-               break;
-       case QAM_256:
-               tmp = "QAM_256";
-               break;
+       case QAM_16: tmp = eDVBFrontendParametersCable::Modulation_QAM16; break;
+       case QAM_32: tmp = eDVBFrontendParametersCable::Modulation_QAM32; break;
+       case QAM_64: tmp = eDVBFrontendParametersCable::Modulation_QAM64; break;
+       case QAM_128: tmp = eDVBFrontendParametersCable::Modulation_QAM128; break;
+       case QAM_256: tmp = eDVBFrontendParametersCable::Modulation_QAM256; break;
        default:
-       case QAM_AUTO:
-               tmp = "QAM_AUTO";
-               break;
+       case QAM_AUTO:   tmp = eDVBFrontendParametersCable::Modulation_Auto; break;
        }
        PutToDict(dict, "modulation", tmp);
 }
 
 void fillDictWithTerrestrialData(ePyObject dict, const FRONTENDPARAMETERS &parm)
 {
-       const char *tmp=0;
+       long tmp=0;
        PutToDict(dict, "frequency", parm_frequency);
        switch (parm_u_ofdm_bandwidth)
        {
-       case BANDWIDTH_8_MHZ:
-               tmp = "BANDWIDTH_8_MHZ";
-               break;
-       case BANDWIDTH_7_MHZ:
-               tmp = "BANDWIDTH_7_MHZ";
-               break;
-       case BANDWIDTH_6_MHZ:
-               tmp = "BANDWIDTH_6_MHZ";
-               break;
+       case BANDWIDTH_8_MHZ: tmp = eDVBFrontendParametersTerrestrial::Bandwidth_8MHz; break;
+       case BANDWIDTH_7_MHZ: tmp = eDVBFrontendParametersTerrestrial::Bandwidth_7MHz; break;
+       case BANDWIDTH_6_MHZ: tmp = eDVBFrontendParametersTerrestrial::Bandwidth_6MHz; break;
        default:
-       case BANDWIDTH_AUTO:
-               tmp = "BANDWIDTH_AUTO";
-               break;
+       case BANDWIDTH_AUTO: tmp = eDVBFrontendParametersTerrestrial::Bandwidth_Auto; break;
        }
        PutToDict(dict, "bandwidth", tmp);
        switch (parm_u_ofdm_code_rate_LP)
        {
-       case FEC_1_2:
-               tmp = "FEC_1_2";
-               break;
-       case FEC_2_3:
-               tmp = "FEC_2_3";
-               break;
-       case FEC_3_4:
-               tmp = "FEC_3_4";
-               break;
-       case FEC_5_6:
-               tmp = "FEC_5_6";
-               break;
-       case FEC_7_8:
-               tmp = "FEC_7_8";
-               break;
+       case FEC_1_2: tmp = eDVBFrontendParametersTerrestrial::FEC_1_2; break;
+       case FEC_2_3: tmp = eDVBFrontendParametersTerrestrial::FEC_2_3; break;
+       case FEC_3_4: tmp = eDVBFrontendParametersTerrestrial::FEC_3_4; break;
+       case FEC_5_6: tmp = eDVBFrontendParametersTerrestrial::FEC_5_6; break;
+       case FEC_7_8: tmp = eDVBFrontendParametersTerrestrial::FEC_7_8; break;
        default:
-       case FEC_AUTO:
-               tmp = "FEC_AUTO";
-               break;
+       case FEC_AUTO: tmp = eDVBFrontendParametersTerrestrial::FEC_Auto; break;
        }
        PutToDict(dict, "code_rate_lp", tmp);
        switch (parm_u_ofdm_code_rate_HP)
        {
-       case FEC_1_2:
-               tmp = "FEC_1_2";
-               break;
-       case FEC_2_3:
-               tmp = "FEC_2_3";
-               break;
-       case FEC_3_4:
-               tmp = "FEC_3_4";
-               break;
-       case FEC_5_6:
-               tmp = "FEC_5_6";
-               break;
-       case FEC_7_8:
-               tmp = "FEC_7_8";
-               break;
+       case FEC_1_2: tmp = eDVBFrontendParametersTerrestrial::FEC_1_2; break;
+       case FEC_2_3: tmp = eDVBFrontendParametersTerrestrial::FEC_2_3; break;
+       case FEC_3_4: tmp = eDVBFrontendParametersTerrestrial::FEC_3_4; break;
+       case FEC_5_6: tmp = eDVBFrontendParametersTerrestrial::FEC_5_6; break;
+       case FEC_7_8: tmp = eDVBFrontendParametersTerrestrial::FEC_7_8; break;
        default:
-       case FEC_AUTO:
-               tmp = "FEC_AUTO";
-               break;
+       case FEC_AUTO: tmp = eDVBFrontendParametersTerrestrial::FEC_Auto; break;
        }
        PutToDict(dict, "code_rate_hp", tmp);
        switch (parm_u_ofdm_constellation)
        {
-       case QPSK:
-               tmp = "QPSK";
-               break;
-       case QAM_16:
-               tmp = "QAM_16";
-               break;
-       case QAM_64:
-               tmp = "QAM_64";
-               break;
+       case QPSK: tmp = eDVBFrontendParametersTerrestrial::Modulation_QPSK; break;
+       case QAM_16: tmp = eDVBFrontendParametersTerrestrial::Modulation_QAM16; break;
+       case QAM_64: tmp = eDVBFrontendParametersTerrestrial::Modulation_QAM64; break;
        default:
-       case QAM_AUTO:
-               tmp = "QAM_AUTO";
-               break;
+       case QAM_AUTO: tmp = eDVBFrontendParametersTerrestrial::Modulation_Auto; break;
        }
        PutToDict(dict, "constellation", tmp);
        switch (parm_u_ofdm_transmission_mode)
        {
-       case TRANSMISSION_MODE_2K:
-               tmp = "TRANSMISSION_MODE_2K";
-               break;
-       case TRANSMISSION_MODE_8K:
-               tmp = "TRANSMISSION_MODE_8K";
-               break;
+       case TRANSMISSION_MODE_2K: tmp = eDVBFrontendParametersTerrestrial::TransmissionMode_2k; break;
+       case TRANSMISSION_MODE_8K: tmp = eDVBFrontendParametersTerrestrial::TransmissionMode_8k; break;
        default:
-       case TRANSMISSION_MODE_AUTO:
-               tmp = "TRANSMISSION_MODE_AUTO";
-               break;
+       case TRANSMISSION_MODE_AUTO: tmp = eDVBFrontendParametersTerrestrial::TransmissionMode_Auto; break;
        }
        PutToDict(dict, "transmission_mode", tmp);
        switch (parm_u_ofdm_guard_interval)
        {
-               case GUARD_INTERVAL_1_32:
-                       tmp = "GUARD_INTERVAL_1_32";
-                       break;
-               case GUARD_INTERVAL_1_16:
-                       tmp = "GUARD_INTERVAL_1_16";
-                       break;
-               case GUARD_INTERVAL_1_8:
-                       tmp = "GUARD_INTERVAL_1_8";
-                       break;
-               case GUARD_INTERVAL_1_4:
-                       tmp = "GUARD_INTERVAL_1_4";
-                       break;
+               case GUARD_INTERVAL_1_32: tmp = eDVBFrontendParametersTerrestrial::GuardInterval_1_32; break;
+               case GUARD_INTERVAL_1_16: tmp = eDVBFrontendParametersTerrestrial::GuardInterval_1_16; break;
+               case GUARD_INTERVAL_1_8: tmp = eDVBFrontendParametersTerrestrial::GuardInterval_1_8; break;
+               case GUARD_INTERVAL_1_4: tmp = eDVBFrontendParametersTerrestrial::GuardInterval_1_4; break;
                default:
-               case GUARD_INTERVAL_AUTO:
-                       tmp = "GUARD_INTERVAL_AUTO";
-                       break;
+               case GUARD_INTERVAL_AUTO: tmp = eDVBFrontendParametersTerrestrial::GuardInterval_Auto; break;
        }
        PutToDict(dict, "guard_interval", tmp);
        switch (parm_u_ofdm_hierarchy_information)
        {
-               case HIERARCHY_NONE:
-                       tmp = "HIERARCHY_NONE";
-                       break;
-               case HIERARCHY_1:
-                       tmp = "HIERARCHY_1";
-                       break;
-               case HIERARCHY_2:
-                       tmp = "HIERARCHY_2";
-                       break;
-               case HIERARCHY_4:
-                       tmp = "HIERARCHY_4";
-                       break;
+               case HIERARCHY_NONE: tmp = eDVBFrontendParametersTerrestrial::Hierarchy_None; break;
+               case HIERARCHY_1: tmp = eDVBFrontendParametersTerrestrial::Hierarchy_1; break;
+               case HIERARCHY_2: tmp = eDVBFrontendParametersTerrestrial::Hierarchy_2; break;
+               case HIERARCHY_4: tmp = eDVBFrontendParametersTerrestrial::Hierarchy_4; break;
                default:
-               case HIERARCHY_AUTO:
-                       tmp = "HIERARCHY_AUTO";
-                       break;
+               case HIERARCHY_AUTO: tmp = eDVBFrontendParametersTerrestrial::Hierarchy_Auto; break;
        }
        PutToDict(dict, "hierarchy_information", tmp);
 }
@@ -1342,20 +1208,18 @@ void eDVBFrontend::getTransponderData(ePyObject dest, bool original)
                                }
                                {
                                        const FRONTENDPARAMETERS &parm = original || m_simulate ? this->parm : front;
-                                       const char *tmp = "INVERSION_AUTO";
+                                       long tmp = eDVBFrontendParametersSatellite::Inversion_Unknown;
                                        switch(parm_inversion & 3)
                                        {
                                                case INVERSION_ON:
-                                                       tmp = "INVERSION_ON";
+                                                       tmp = eDVBFrontendParametersSatellite::Inversion_On;
                                                        break;
                                                case INVERSION_OFF:
-                                                       tmp = "INVERSION_OFF";
-                                                       break;
+                                                       tmp = eDVBFrontendParametersSatellite::Inversion_Off;
                                                default:
                                                        break;
                                        }
-                                       if (tmp)
-                                               PutToDict(dest, "inversion", tmp);
+                                       PutToDict(dest, "inversion", tmp);
 
                                        switch(m_type)
                                        {
@@ -1889,41 +1753,41 @@ RESULT eDVBFrontend::prepare_sat(const eDVBFrontendParametersSatellite &feparm,
                parm_u_qpsk_symbol_rate = feparm.symbol_rate;
                switch (feparm.inversion)
                {
-                       case eDVBFrontendParametersSatellite::Inversion::On:
+                       case eDVBFrontendParametersSatellite::Inversion_On:
                                parm_inversion = INVERSION_ON;
                                break;
-                       case eDVBFrontendParametersSatellite::Inversion::Off:
+                       case eDVBFrontendParametersSatellite::Inversion_Off:
                                parm_inversion = INVERSION_OFF;
                                break;
                        default:
-                       case eDVBFrontendParametersSatellite::Inversion::Unknown:
+                       case eDVBFrontendParametersSatellite::Inversion_Unknown:
                                parm_inversion = INVERSION_AUTO;
                                break;
                }
-               if (feparm.system == eDVBFrontendParametersSatellite::System::DVB_S)
+               if (feparm.system == eDVBFrontendParametersSatellite::System_DVB_S)
                        switch (feparm.fec)
                        {
-                               case eDVBFrontendParametersSatellite::FEC::fNone:
+                               case eDVBFrontendParametersSatellite::FEC_None:
                                        parm_u_qpsk_fec_inner = FEC_NONE;
                                        break;
-                               case eDVBFrontendParametersSatellite::FEC::f1_2:
+                               case eDVBFrontendParametersSatellite::FEC_1_2:
                                        parm_u_qpsk_fec_inner = FEC_1_2;
                                        break;
-                               case eDVBFrontendParametersSatellite::FEC::f2_3:
+                               case eDVBFrontendParametersSatellite::FEC_2_3:
                                        parm_u_qpsk_fec_inner = FEC_2_3;
                                        break;
-                               case eDVBFrontendParametersSatellite::FEC::f3_4:
+                               case eDVBFrontendParametersSatellite::FEC_3_4:
                                        parm_u_qpsk_fec_inner = FEC_3_4;
                                        break;
-                               case eDVBFrontendParametersSatellite::FEC::f5_6:
+                               case eDVBFrontendParametersSatellite::FEC_5_6:
                                        parm_u_qpsk_fec_inner = FEC_5_6;
                                        break;
-                               case eDVBFrontendParametersSatellite::FEC::f7_8:
+                               case eDVBFrontendParametersSatellite::FEC_7_8:
                                        parm_u_qpsk_fec_inner = FEC_7_8;
                                        break;
                                default:
                                        eDebugNoSimulate("no valid fec for DVB-S set.. assume auto");
-                               case eDVBFrontendParametersSatellite::FEC::fAuto:
+                               case eDVBFrontendParametersSatellite::FEC_Auto:
                                        parm_u_qpsk_fec_inner = FEC_AUTO;
                                        break;
                        }
@@ -1932,31 +1796,31 @@ RESULT eDVBFrontend::prepare_sat(const eDVBFrontendParametersSatellite &feparm,
                {
                        switch (feparm.fec)
                        {
-                               case eDVBFrontendParametersSatellite::FEC::f1_2:
+                               case eDVBFrontendParametersSatellite::FEC_1_2:
                                        parm_u_qpsk_fec_inner = FEC_S2_QPSK_1_2;
                                        break;
-                               case eDVBFrontendParametersSatellite::FEC::f2_3:
+                               case eDVBFrontendParametersSatellite::FEC_2_3:
                                        parm_u_qpsk_fec_inner = FEC_S2_QPSK_2_3;
                                        break;
-                               case eDVBFrontendParametersSatellite::FEC::f3_4:
+                               case eDVBFrontendParametersSatellite::FEC_3_4:
                                        parm_u_qpsk_fec_inner = FEC_S2_QPSK_3_4;
                                        break;
-                               case eDVBFrontendParametersSatellite::FEC::f3_5:
+                               case eDVBFrontendParametersSatellite::FEC_3_5:
                                        parm_u_qpsk_fec_inner = FEC_S2_QPSK_3_5;
                                        break;
-                               case eDVBFrontendParametersSatellite::FEC::f4_5:
+                               case eDVBFrontendParametersSatellite::FEC_4_5:
                                        parm_u_qpsk_fec_inner = FEC_S2_QPSK_4_5;
                                        break;
-                               case eDVBFrontendParametersSatellite::FEC::f5_6:
+                               case eDVBFrontendParametersSatellite::FEC_5_6:
                                        parm_u_qpsk_fec_inner = FEC_S2_QPSK_5_6;
                                        break;
-                               case eDVBFrontendParametersSatellite::FEC::f7_8:
+                               case eDVBFrontendParametersSatellite::FEC_7_8:
                                        parm_u_qpsk_fec_inner = FEC_S2_QPSK_7_8;
                                        break;
-                               case eDVBFrontendParametersSatellite::FEC::f8_9:
+                               case eDVBFrontendParametersSatellite::FEC_8_9:
                                        parm_u_qpsk_fec_inner = FEC_S2_QPSK_8_9;
                                        break;
-                               case eDVBFrontendParametersSatellite::FEC::f9_10:
+                               case eDVBFrontendParametersSatellite::FEC_9_10:
                                        parm_u_qpsk_fec_inner = FEC_S2_QPSK_9_10;
                                        break;
                                default:
@@ -1965,7 +1829,7 @@ RESULT eDVBFrontend::prepare_sat(const eDVBFrontendParametersSatellite &feparm,
                        }
                        parm_inversion |= (feparm.rolloff << 2); // Hack.. we use bit 2..3 of inversion param for rolloff
                        parm_inversion |= (feparm.pilot << 4); // Hack.. we use bit 4..5 of inversion param for pilot
-                       if (feparm.modulation == eDVBFrontendParametersSatellite::Modulation::M8PSK) {
+                       if (feparm.modulation == eDVBFrontendParametersSatellite::Modulation_8PSK) {
                                parm_u_qpsk_fec_inner = (fe_code_rate_t)((int)parm_u_qpsk_fec_inner+9);
                                // 8PSK fec driver values are decimal 9 bigger
                        }
@@ -1992,66 +1856,66 @@ RESULT eDVBFrontend::prepare_cable(const eDVBFrontendParametersCable &feparm)
        parm_u_qam_symbol_rate = feparm.symbol_rate;
        switch (feparm.modulation)
        {
-       case eDVBFrontendParametersCable::Modulation::QAM16:
+       case eDVBFrontendParametersCable::Modulation_QAM16:
                parm_u_qam_modulation = QAM_16;
                break;
-       case eDVBFrontendParametersCable::Modulation::QAM32:
+       case eDVBFrontendParametersCable::Modulation_QAM32:
                parm_u_qam_modulation = QAM_32;
                break;
-       case eDVBFrontendParametersCable::Modulation::QAM64:
+       case eDVBFrontendParametersCable::Modulation_QAM64:
                parm_u_qam_modulation = QAM_64;
                break;
-       case eDVBFrontendParametersCable::Modulation::QAM128:
+       case eDVBFrontendParametersCable::Modulation_QAM128:
                parm_u_qam_modulation = QAM_128;
                break;
-       case eDVBFrontendParametersCable::Modulation::QAM256:
+       case eDVBFrontendParametersCable::Modulation_QAM256:
                parm_u_qam_modulation = QAM_256;
                break;
        default:
-       case eDVBFrontendParametersCable::Modulation::Auto:
+       case eDVBFrontendParametersCable::Modulation_Auto:
                parm_u_qam_modulation = QAM_AUTO;
                break;
        }
        switch (feparm.inversion)
        {
-       case eDVBFrontendParametersCable::Inversion::On:
+       case eDVBFrontendParametersCable::Inversion_On:
                parm_inversion = INVERSION_ON;
                break;
-       case eDVBFrontendParametersCable::Inversion::Off:
+       case eDVBFrontendParametersCable::Inversion_Off:
                parm_inversion = INVERSION_OFF;
                break;
        default:
-       case eDVBFrontendParametersCable::Inversion::Unknown:
+       case eDVBFrontendParametersCable::Inversion_Unknown:
                parm_inversion = INVERSION_AUTO;
                break;
        }
        switch (feparm.fec_inner)
        {
-       case eDVBFrontendParametersCable::FEC::fNone:
+       case eDVBFrontendParametersCable::FEC_None:
                parm_u_qam_fec_inner = FEC_NONE;
                break;
-       case eDVBFrontendParametersCable::FEC::f1_2:
+       case eDVBFrontendParametersCable::FEC_1_2:
                parm_u_qam_fec_inner = FEC_1_2;
                break;
-       case eDVBFrontendParametersCable::FEC::f2_3:
+       case eDVBFrontendParametersCable::FEC_2_3:
                parm_u_qam_fec_inner = FEC_2_3;
                break;
-       case eDVBFrontendParametersCable::FEC::f3_4:
+       case eDVBFrontendParametersCable::FEC_3_4:
                parm_u_qam_fec_inner = FEC_3_4;
                break;
-       case eDVBFrontendParametersCable::FEC::f5_6:
+       case eDVBFrontendParametersCable::FEC_5_6:
                parm_u_qam_fec_inner = FEC_5_6;
                break;
-       case eDVBFrontendParametersCable::FEC::f7_8:
+       case eDVBFrontendParametersCable::FEC_7_8:
                parm_u_qam_fec_inner = FEC_7_8;
                break;
 #if HAVE_DVB_API_VERSION >= 3
-       case eDVBFrontendParametersCable::FEC::f8_9:
+       case eDVBFrontendParametersCable::FEC_8_9:
                parm_u_qam_fec_inner = FEC_8_9;
                break;
 #endif
        default:
-       case eDVBFrontendParametersCable::FEC::fAuto:
+       case eDVBFrontendParametersCable::FEC_Auto:
                parm_u_qam_fec_inner = FEC_AUTO;
                break;
        }
@@ -2070,141 +1934,141 @@ RESULT eDVBFrontend::prepare_terrestrial(const eDVBFrontendParametersTerrestrial
 
        switch (feparm.bandwidth)
        {
-       case eDVBFrontendParametersTerrestrial::Bandwidth::Bw8MHz:
+       case eDVBFrontendParametersTerrestrial::Bandwidth_8MHz:
                parm_u_ofdm_bandwidth = BANDWIDTH_8_MHZ;
                break;
-       case eDVBFrontendParametersTerrestrial::Bandwidth::Bw7MHz:
+       case eDVBFrontendParametersTerrestrial::Bandwidth_7MHz:
                parm_u_ofdm_bandwidth = BANDWIDTH_7_MHZ;
                break;
-       case eDVBFrontendParametersTerrestrial::Bandwidth::Bw6MHz:
+       case eDVBFrontendParametersTerrestrial::Bandwidth_6MHz:
                parm_u_ofdm_bandwidth = BANDWIDTH_6_MHZ;
                break;
        default:
-       case eDVBFrontendParametersTerrestrial::Bandwidth::BwAuto:
+       case eDVBFrontendParametersTerrestrial::Bandwidth_Auto:
                parm_u_ofdm_bandwidth = BANDWIDTH_AUTO;
                break;
        }
        switch (feparm.code_rate_LP)
        {
-       case eDVBFrontendParametersTerrestrial::FEC::f1_2:
+       case eDVBFrontendParametersTerrestrial::FEC_1_2:
                parm_u_ofdm_code_rate_LP = FEC_1_2;
                break;
-       case eDVBFrontendParametersTerrestrial::FEC::f2_3:
+       case eDVBFrontendParametersTerrestrial::FEC_2_3:
                parm_u_ofdm_code_rate_LP = FEC_2_3;
                break;
-       case eDVBFrontendParametersTerrestrial::FEC::f3_4:
+       case eDVBFrontendParametersTerrestrial::FEC_3_4:
                parm_u_ofdm_code_rate_LP = FEC_3_4;
                break;
-       case eDVBFrontendParametersTerrestrial::FEC::f5_6:
+       case eDVBFrontendParametersTerrestrial::FEC_5_6:
                parm_u_ofdm_code_rate_LP = FEC_5_6;
                break;
-       case eDVBFrontendParametersTerrestrial::FEC::f7_8:
+       case eDVBFrontendParametersTerrestrial::FEC_7_8:
                parm_u_ofdm_code_rate_LP = FEC_7_8;
                break;
        default:
-       case eDVBFrontendParametersTerrestrial::FEC::fAuto:
+       case eDVBFrontendParametersTerrestrial::FEC_Auto:
                parm_u_ofdm_code_rate_LP = FEC_AUTO;
                break;
        }
        switch (feparm.code_rate_HP)
        {
-       case eDVBFrontendParametersTerrestrial::FEC::f1_2:
+       case eDVBFrontendParametersTerrestrial::FEC_1_2:
                parm_u_ofdm_code_rate_HP = FEC_1_2;
                break;
-       case eDVBFrontendParametersTerrestrial::FEC::f2_3:
+       case eDVBFrontendParametersTerrestrial::FEC_2_3:
                parm_u_ofdm_code_rate_HP = FEC_2_3;
                break;
-       case eDVBFrontendParametersTerrestrial::FEC::f3_4:
+       case eDVBFrontendParametersTerrestrial::FEC_3_4:
                parm_u_ofdm_code_rate_HP = FEC_3_4;
                break;
-       case eDVBFrontendParametersTerrestrial::FEC::f5_6:
+       case eDVBFrontendParametersTerrestrial::FEC_5_6:
                parm_u_ofdm_code_rate_HP = FEC_5_6;
                break;
-       case eDVBFrontendParametersTerrestrial::FEC::f7_8:
+       case eDVBFrontendParametersTerrestrial::FEC_7_8:
                parm_u_ofdm_code_rate_HP = FEC_7_8;
                break;
        default:
-       case eDVBFrontendParametersTerrestrial::FEC::fAuto:
+       case eDVBFrontendParametersTerrestrial::FEC_Auto:
                parm_u_ofdm_code_rate_HP = FEC_AUTO;
                break;
        }
        switch (feparm.modulation)
        {
-       case eDVBFrontendParametersTerrestrial::Modulation::QPSK:
+       case eDVBFrontendParametersTerrestrial::Modulation_QPSK:
                parm_u_ofdm_constellation = QPSK;
                break;
-       case eDVBFrontendParametersTerrestrial::Modulation::QAM16:
+       case eDVBFrontendParametersTerrestrial::Modulation_QAM16:
                parm_u_ofdm_constellation = QAM_16;
                break;
-       case eDVBFrontendParametersTerrestrial::Modulation::QAM64:
+       case eDVBFrontendParametersTerrestrial::Modulation_QAM64:
                parm_u_ofdm_constellation = QAM_64;
                break;
        default:
-       case eDVBFrontendParametersTerrestrial::Modulation::Auto:
+       case eDVBFrontendParametersTerrestrial::Modulation_Auto:
                parm_u_ofdm_constellation = QAM_AUTO;
                break;
        }
        switch (feparm.transmission_mode)
        {
-       case eDVBFrontendParametersTerrestrial::TransmissionMode::TM2k:
+       case eDVBFrontendParametersTerrestrial::TransmissionMode_2k:
                parm_u_ofdm_transmission_mode = TRANSMISSION_MODE_2K;
                break;
-       case eDVBFrontendParametersTerrestrial::TransmissionMode::TM8k:
+       case eDVBFrontendParametersTerrestrial::TransmissionMode_8k:
                parm_u_ofdm_transmission_mode = TRANSMISSION_MODE_8K;
                break;
        default:
-       case eDVBFrontendParametersTerrestrial::TransmissionMode::TMAuto:
+       case eDVBFrontendParametersTerrestrial::TransmissionMode_Auto:
                parm_u_ofdm_transmission_mode = TRANSMISSION_MODE_AUTO;
                break;
        }
        switch (feparm.guard_interval)
        {
-               case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_32:
+               case eDVBFrontendParametersTerrestrial::GuardInterval_1_32:
                        parm_u_ofdm_guard_interval = GUARD_INTERVAL_1_32;
                        break;
-               case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_16:
+               case eDVBFrontendParametersTerrestrial::GuardInterval_1_16:
                        parm_u_ofdm_guard_interval = GUARD_INTERVAL_1_16;
                        break;
-               case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_8:
+               case eDVBFrontendParametersTerrestrial::GuardInterval_1_8:
                        parm_u_ofdm_guard_interval = GUARD_INTERVAL_1_8;
                        break;
-               case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_4:
+               case eDVBFrontendParametersTerrestrial::GuardInterval_1_4:
                        parm_u_ofdm_guard_interval = GUARD_INTERVAL_1_4;
                        break;
                default:
-               case eDVBFrontendParametersTerrestrial::GuardInterval::GI_Auto:
+               case eDVBFrontendParametersTerrestrial::GuardInterval_Auto:
                        parm_u_ofdm_guard_interval = GUARD_INTERVAL_AUTO;
                        break;
        }
        switch (feparm.hierarchy)
        {
-               case eDVBFrontendParametersTerrestrial::Hierarchy::HNone:
+               case eDVBFrontendParametersTerrestrial::Hierarchy_None:
                        parm_u_ofdm_hierarchy_information = HIERARCHY_NONE;
                        break;
-               case eDVBFrontendParametersTerrestrial::Hierarchy::H1:
+               case eDVBFrontendParametersTerrestrial::Hierarchy_1:
                        parm_u_ofdm_hierarchy_information = HIERARCHY_1;
                        break;
-               case eDVBFrontendParametersTerrestrial::Hierarchy::H2:
+               case eDVBFrontendParametersTerrestrial::Hierarchy_2:
                        parm_u_ofdm_hierarchy_information = HIERARCHY_2;
                        break;
-               case eDVBFrontendParametersTerrestrial::Hierarchy::H4:
+               case eDVBFrontendParametersTerrestrial::Hierarchy_4:
                        parm_u_ofdm_hierarchy_information = HIERARCHY_4;
                        break;
                default:
-               case eDVBFrontendParametersTerrestrial::Hierarchy::HAuto:
+               case eDVBFrontendParametersTerrestrial::Hierarchy_Auto:
                        parm_u_ofdm_hierarchy_information = HIERARCHY_AUTO;
                        break;
        }
        switch (feparm.inversion)
        {
-       case eDVBFrontendParametersTerrestrial::Inversion::On:
+       case eDVBFrontendParametersTerrestrial::Inversion_On:
                parm_inversion = INVERSION_ON;
                break;
-       case eDVBFrontendParametersTerrestrial::Inversion::Off:
+       case eDVBFrontendParametersTerrestrial::Inversion_Off:
                parm_inversion = INVERSION_OFF;
                break;
        default:
-       case eDVBFrontendParametersTerrestrial::Inversion::Unknown:
+       case eDVBFrontendParametersTerrestrial::Inversion_Unknown:
                parm_inversion = INVERSION_AUTO;
                break;
        }
@@ -2514,10 +2378,10 @@ int eDVBFrontend::isCompatibleWith(ePtr<iDVBFrontendParameters> &feparm)
                eDVBFrontendParametersSatellite sat_parm;
                int ret = feparm->getDVBS(sat_parm);
                ASSERT(!ret);
-               if (sat_parm.system == eDVBFrontendParametersSatellite::System::DVB_S2 && !m_can_handle_dvbs2)
+               if (sat_parm.system == eDVBFrontendParametersSatellite::System_DVB_S2 && !m_can_handle_dvbs2)
                        return 0;
                ret = m_sec->canTune(sat_parm, this, 1 << m_slotid);
-               if (ret > 1 && sat_parm.system == eDVBFrontendParametersSatellite::System::DVB_S && m_can_handle_dvbs2)
+               if (ret > 1 && sat_parm.system == eDVBFrontendParametersSatellite::System_DVB_S && m_can_handle_dvbs2)
                        ret -= 1;
                return ret;
        }
index 961dfd0..b537963 100644 (file)
@@ -12,42 +12,35 @@ struct eDVBFrontendParametersSatellite
 #ifndef SWIG
        void set(const SatelliteDeliverySystemDescriptor  &);
 #endif
-       struct Polarisation {
-               enum {
-                       Horizontal, Vertical, CircularLeft, CircularRight
-               };
+       enum {
+               Polarisation_Horizontal, Polarisation_Vertical, Polarisation_CircularLeft, Polarisation_CircularRight
        };
-       struct Inversion {
-               enum {
-                       Off, On, Unknown
-               };
+
+       enum {
+               Inversion_Off, Inversion_On, Inversion_Unknown
        };
-       struct FEC {
-               enum {
-                       fAuto, f1_2, f2_3, f3_4, f5_6, f7_8, f8_9, f3_5, f4_5, f9_10, fNone=15
-               };
+
+       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
        };
-       struct System {
-               enum {
-                       DVB_S, DVB_S2
-               };
+
+       enum {
+               System_DVB_S, System_DVB_S2
        };
-       struct Modulation {
-               enum {
-                       Auto, QPSK, M8PSK, QAM_16
-               };
+
+       enum {
+               Modulation_Auto, Modulation_QPSK, Modulation_8PSK, Modulation_QAM16
        };
+
        // dvb-s2
-       struct RollOff {
-               enum {
-                       alpha_0_35, alpha_0_25, alpha_0_20
-               };
+       enum {
+               RollOff_alpha_0_35, RollOff_alpha_0_25, RollOff_alpha_0_20
        };
-       struct Pilot {  
-               enum {
-                       Off, On, Unknown
-               };
+
+       enum {
+               Pilot_Off, Pilot_On, Pilot_Unknown
        };
+
        bool no_rotor_command_on_tune;
        unsigned int frequency, symbol_rate;
        int polarisation, fec, inversion, orbital_position, system, modulation, rolloff, pilot;
@@ -59,21 +52,18 @@ struct eDVBFrontendParametersCable
 #ifndef SWIG
        void set(const CableDeliverySystemDescriptor  &);
 #endif
-       struct Inversion {
-               enum {
-                       Off, On, Unknown
-               };
+       enum {
+               Inversion_Off, Inversion_On, Inversion_Unknown
        };
-       struct FEC {
-               enum {
-                       fAuto, f1_2, f2_3, f3_4, f5_6, f7_8, f8_9, fNone=15
-               };
+
+       enum {
+               FEC_Auto, FEC_1_2, FEC_2_3, FEC_3_4, FEC_5_6, FEC_7_8, FEC_8_9, FEC_None=15
        };
-       struct Modulation {
-               enum {
-                       Auto, QAM16, QAM32, QAM64, QAM128, QAM256
-               };
+
+       enum {
+               Modulation_Auto, Modulation_QAM16, Modulation_QAM32, Modulation_QAM64, Modulation_QAM128, Modulation_QAM256
        };
+
        unsigned int frequency, symbol_rate;
        int modulation, inversion, fec_inner;
 };
@@ -84,42 +74,34 @@ struct eDVBFrontendParametersTerrestrial
 #ifndef SWIG
        void set(const TerrestrialDeliverySystemDescriptor  &);
 #endif
-       struct Bandwidth {
-               enum {
-                       Bw8MHz, Bw7MHz, Bw6MHz, /*Bw5MHz,*/ BwAuto
-               }; // Bw5Mhz nyi (compatibilty with enigma1)
-       };
-       struct FEC {
-               enum {
-                       f1_2, f2_3, f3_4, f5_6, f7_8, fAuto
-               };
-       };
-       struct TransmissionMode {
-               enum {
-                       TM2k, TM8k, /*TM4k,*/ TMAuto
-               }; // TM4k nyi (compatibility with enigma1)
+       enum {
+               Bandwidth_8MHz, Bandwidth_7MHz, Bandwidth_6MHz, /*Bandwidth_5MHz,*/ Bandwidth_Auto
+       }; // Bw5Mhz nyi (compatibilty with enigma1)
+
+       enum {
+               FEC_1_2, FEC_2_3, FEC_3_4, FEC_5_6, FEC_7_8, FEC_Auto
        };
-       struct GuardInterval {
-               enum {
-                       GI_1_32, GI_1_16, GI_1_8, GI_1_4, GI_Auto
-               };
+
+       enum {
+               TransmissionMode_2k, TransmissionMode_8k, /*TransmissionMode_4k,*/ TransmissionMode_Auto
+       }; // TM4k nyi (compatibility with enigma1)
+
+       enum {
+               GuardInterval_1_32, GuardInterval_1_16, GuardInterval_1_8, GuardInterval_1_4, GuardInterval_Auto
        };
-       struct Hierarchy {
-               enum {
-                       HNone, H1, H2, H4, HAuto
-               };
+
+       enum {
+               Hierarchy_None, Hierarchy_1, Hierarchy_2, Hierarchy_4, Hierarchy_Auto
        };
-       struct Modulation {
-               enum {
-                       QPSK, QAM16, QAM64, Auto
-               };
+
+       enum {
+               Modulation_QPSK, Modulation_QAM16, Modulation_QAM64, Modulation_Auto
        };
-       struct Inversion
-       {
-               enum {
-                       Off, On, Unknown
-               };
+
+       enum {
+               Inversion_Off, Inversion_On, Inversion_Unknown
        };
+
        unsigned int frequency;
        int bandwidth;
        int code_rate_HP, code_rate_LP;
index 6f64cf5..ac1a202 100644 (file)
@@ -99,7 +99,7 @@ int eDVBSatelliteEquipmentControl::canTune(const eDVBFrontendParametersSatellite
 
                                if ( sat.frequency > lnb_param.m_lof_threshold )
                                        band |= 1;
-                               if (!(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical))
+                               if (!(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation_Vertical))
                                        band |= 2;
 
                                if (di_param.m_diseqc_mode >= eDVBSatelliteDiseqcParameters::V1_0)
@@ -373,7 +373,7 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
 
                        if ( sat.frequency > lnb_param.m_lof_threshold )
                                band |= 1;
-                       if (!(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical))
+                       if (!(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation_Vertical))
                                band |= 2;
 
                        int lof = (band&1)?lnb_param.m_lof_hi:lnb_param.m_lof_lo;
@@ -390,11 +390,11 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
                                frontend.setData(eDVBFrontend::FREQ_OFFSET, sat.frequency - parm.FREQUENCY);
 
                                if ( voltage_mode == eDVBSatelliteSwitchParameters::_14V
-                                       || ( sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical
+                                       || ( sat.polarisation & eDVBFrontendParametersSatellite::Polarisation_Vertical
                                                && voltage_mode == eDVBSatelliteSwitchParameters::HV )  )
                                        voltage = VOLTAGE(13);
                                else if ( voltage_mode == eDVBSatelliteSwitchParameters::_18V
-                                       || ( !(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical)
+                                       || ( !(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation_Vertical)
                                                && voltage_mode == eDVBSatelliteSwitchParameters::HV )  )
                                        voltage = VOLTAGE(18);
                                if ( (sw_param.m_22khz_signal == eDVBSatelliteSwitchParameters::ON)
@@ -936,12 +936,12 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
        eDebugNoSimulate("found no useable satellite configuration for %s freq %d%s %s on orbital position (%d)",
                sat.system ? "DVB-S2" : "DVB-S",
                sat.frequency,
-               sat.polarisation == eDVBFrontendParametersSatellite::Polarisation::Horizontal ? "H" :
-                       eDVBFrontendParametersSatellite::Polarisation::Vertical ? "V" :
-                       eDVBFrontendParametersSatellite::Polarisation::CircularLeft ? "CL" : "CR",
-               sat.modulation == eDVBFrontendParametersSatellite::Modulation::Auto ? "AUTO" :
-                       eDVBFrontendParametersSatellite::Modulation::QPSK ? "QPSK" :
-                       eDVBFrontendParametersSatellite::Modulation::M8PSK ? "8PSK" : "QAM16",
+               sat.polarisation == eDVBFrontendParametersSatellite::Polarisation_Horizontal ? "H" :
+                       eDVBFrontendParametersSatellite::Polarisation_Vertical ? "V" :
+                       eDVBFrontendParametersSatellite::Polarisation_CircularLeft ? "CL" : "CR",
+               sat.modulation == eDVBFrontendParametersSatellite::Modulation_Auto ? "AUTO" :
+                       eDVBFrontendParametersSatellite::Modulation_QPSK ? "QPSK" :
+                       eDVBFrontendParametersSatellite::Modulation_8PSK ? "8PSK" : "QAM16",
                sat.orbital_position );
        return -1;
 }
index d371444..69ef377 100644 (file)
@@ -478,14 +478,14 @@ class TunerScreen(ScanSetup):
                                self.list.append(self.systemEntry)
                        else:
                                # downgrade to dvb-s, in case a -s2 config was active
-                               self.scan_sat.system.value = "dvb-s"
+                               self.scan_sat.system.value = eDVBFrontendParametersSatellite.System_DVB_S
                        self.list.append(getConfigListEntry(_('Frequency'), self.scan_sat.frequency))
                        self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion))
                        self.list.append(getConfigListEntry(_('Symbol Rate'), self.scan_sat.symbolrate))
                        self.list.append(getConfigListEntry(_("Polarity"), self.scan_sat.polarization))
-                       if self.scan_sat.system.value == "dvb-s":
+                       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 == "dvb-s2":
+                       elif self.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)
@@ -570,31 +570,21 @@ class TunerScreen(ScanSetup):
                returnvalue = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
                satpos = int(tuning.sat.value)
                if tuning.type.value == "manual_transponder":
-                       if self.scan_sat.system.value == "dvb-s2":
+                       if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2:
                                fec = self.scan_sat.fec_s2.value
                        else:
                                fec = self.scan_sat.fec.value
                        returnvalue = (
                                self.scan_sat.frequency.value,
                                self.scan_sat.symbolrate.value,
-                               self.scan_sat.polarization.index,
-                               { "auto": 0,
-                                  "1_2": 1,
-                                  "2_3": 2,
-                                  "3_4": 3,
-                                  "5_6": 4,
-                                  "7_8": 5,
-                                  "8_9": 6,
-                                  "3_5": 7,
-                                  "4_5": 8,
-                                  "9_10": 9,
-                                  "none": 15 }[fec],
-                               self.scan_sat.inversion.index,
+                               self.scan_sat.polarization.value,
+                               fec,
+                               self.scan_sat.inversion.value,
                                satpos,
-                               self.scan_sat.system.index,
-                               self.scan_sat.modulation.index == 1 and 2 or 1,
-                               self.scan_sat.rolloff.index,
-                               self.scan_sat.pilot.index)
+                               self.scan_sat.system.value,
+                               self.scan_sat.modulation.value,
+                               self.scan_sat.rolloff.value,
+                               self.scan_sat.pilot.value)
                elif tuning.type.value == "predefined_transponder":
                        transponder = nimmanager.getTransponders(satpos)[tuning.transponder.index]
                        returnvalue = (transponder[1] / 1000, transponder[2] / 1000,
index 87dc81e..8174eb6 100644 (file)
@@ -77,14 +77,14 @@ class Satfinder(ScanSetup):
                                self.list.append(self.systemEntry)
                        else:
                                # downgrade to dvb-s, in case a -s2 config was active
-                               self.scan_sat.system.value = "dvb-s"
+                               self.scan_sat.system.value = eDVBFrontendParametersSatellite.System_DVB_S
                        self.list.append(getConfigListEntry(_('Frequency'), self.scan_sat.frequency))
                        self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion))
                        self.list.append(getConfigListEntry(_('Symbol Rate'), self.scan_sat.symbolrate))
                        self.list.append(getConfigListEntry(_("Polarity"), self.scan_sat.polarization))
-                       if self.scan_sat.system.value == "dvb-s":
+                       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 == "dvb-s2":
+                       elif self.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)
@@ -111,31 +111,21 @@ class Satfinder(ScanSetup):
                returnvalue = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
                satpos = int(self.tuning_sat.value)
                if self.tuning_type.value == "manual_transponder":
-                       if self.scan_sat.system.value == "dvb-s2":
+                       if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2:
                                fec = self.scan_sat.fec_s2.value
                        else:
                                fec = self.scan_sat.fec.value
                        returnvalue = (
                                self.scan_sat.frequency.value,
                                self.scan_sat.symbolrate.value,
-                               self.scan_sat.polarization.index,
-                               { "auto": 0,
-                                  "1_2": 1,
-                                  "2_3": 2,
-                                  "3_4": 3,
-                                  "5_6": 4,
-                                  "7_8": 5,
-                                  "8_9": 6,
-                                  "3_5": 7,
-                                  "4_5": 8,
-                                  "9_10": 9,
-                                  "none": 15 }[fec],
-                               self.scan_sat.inversion.index,
+                               self.scan_sat.polarization.value,
+                               fec,
+                               self.scan_sat.inversion.value,
                                satpos,
-                               self.scan_sat.system.index,
-                               self.scan_sat.modulation.index == 1 and 2 or 1,
-                               self.scan_sat.rolloff.index,
-                               self.scan_sat.pilot.index)
+                               self.scan_sat.system.value,
+                               self.scan_sat.modulation.value,
+                               self.scan_sat.rolloff.value,
+                               self.scan_sat.pilot.value)
                        self.tune(returnvalue)
                elif self.tuning_type.value == "predefined_transponder":
                        tps = nimmanager.getTransponders(satpos)
index f32904a..7089074 100644 (file)
@@ -17,64 +17,17 @@ def buildTerTransponder(frequency,
                inversion=2, bandwidth = 3, fechigh = 6, feclow = 6,
                modulation = 2, transmission = 2, guard = 4,
                hierarchy = 4):
-
 #      print "freq", frequency, "inv", inversion, "bw", bandwidth, "fech", fechigh, "fecl", feclow, "mod", modulation, "tm", transmission, "guard", guard, "hierarchy", hierarchy
-
-       # WARNING: normally, enums are working directly.
-       # Don't copy this (very bad)!! Instead either fix swig (good) or
-       # move this into a central place.
-       Bw8MHz = 0
-       Bw7MHz = 1
-       Bw6MHz = 2
-       #Bw5MHz = 3 #not implemented for e1 compatibilty
-       BwAuto = 3
-       
-       f1_2 = 0
-       f2_3 = 1
-       f3_4 = 2
-       f5_6 = 3
-       f7_8 = 4
-       fAuto = 5
-       
-       TM2k = 0
-       TM8k = 1
-       #TM4k = 2  #not implemented for e1 compatibilty
-       TMAuto = 2
-       
-       GI_1_32 = 0
-       GI_1_16 = 1
-       GI_1_8 = 2
-       GI_1_4 = 3
-       GI_Auto = 4
-       
-       HNone = 0
-       H1 = 1
-       H2 = 2
-       H4 = 3
-       HAuto = 4
-
-       QPSK = 0
-       QAM16 = 1
-       QAM64 = 2
-       Auto = 3
-       
-       Off = 0
-       On = 1
-       Unknown = 2
-
        parm = eDVBFrontendParametersTerrestrial()
-
        parm.frequency = frequency
-
-       parm.inversion = [Off, On, Unknown][inversion]
-       parm.bandwidth = [Bw8MHz, Bw7MHz, Bw6MHz, BwAuto][bandwidth] # Bw5MHz unsupported
-       parm.code_rate_HP = [f1_2, f2_3, f3_4, f5_6, f7_8, fAuto][fechigh]
-       parm.code_rate_LP = [f1_2, f2_3, f3_4, f5_6, f7_8, fAuto][feclow]
-       parm.modulation = [QPSK, QAM16, QAM64, Auto][modulation]
-       parm.transmission_mode = [TM2k, TM8k, TMAuto][transmission] # TM4k unsupported
-       parm.guard_interval = [GI_1_32, GI_1_16, GI_1_8, GI_1_4, GI_Auto][guard]
-       parm.hierarchy = [HNone, H1, H2, H4, HAuto][hierarchy]
-       
+       parm.inversion = inversion
+       parm.bandwidth = bandwidth
+       parm.code_rate_HP = fechigh
+       parm.code_rate_LP = feclow
+       parm.modulation = modulation
+       parm.transmission_mode = transmission
+       parm.guard_interval = guard
+       parm.hierarchy = hierarchy
        return parm
 
 def getInitialTransponderList(tlist, pos):
@@ -103,7 +56,7 @@ def getInitialCableTransponderList(tlist, nim):
                        parm.symbol_rate = x[2]
                        parm.modulation = x[3]
                        parm.fec_inner = x[4]
-                       parm.inversion = 2 # AUTO
+                       parm.inversion = parm.Inversion_Unknown
                        #print "frequency:", x[1]
                        #print "symbol_rate:", x[2]
                        #print "modulation:", x[3]
@@ -178,10 +131,22 @@ class CableTransponderSearchSupport:
                if len(data):
                        if data[0] == 'OK':
                                print str
-                               qam = { "QAM16" : 1, "QAM32" : 2, "QAM64" : 3, "QAM128" : 4, "QAM256" : 5 }
-                               inv = { "INVERSION_OFF" : 0, "INVERSION_ON" : 1 }
-                               fec = { "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_NONE" : 15 }
                                parm = eDVBFrontendParametersCable()
+                               qam = { "QAM16" : parm.Modulation_QAM16,
+                                       "QAM32" : parm.Modulation_QAM32,
+                                       "QAM64" : parm.Modulation_QAM64,
+                                       "QAM128" : parm.Modulation_QAM128,
+                                       "QAM256" : parm.Modulation_QAM256 }
+                               inv = { "INVERSION_OFF" : parm.Inversion_Off,
+                                       "INVERSION_ON" : parm.Inversion_On }
+                               fec = { "FEC_AUTO" : parm.FEC_Auto,
+                                       "FEC_1_2" : parm.FEC_1_2,
+                                       "FEC_2_3" : parm.FEC_2_3,
+                                       "FEC_3_4" : parm.FEC_3_4,
+                                       "FEC_5_6": parm.FEC_5_6,
+                                       "FEC_7_8" : parm.FEC_7_8,
+                                       "FEC_8_9" : parm.FEC_8_9,
+                                       "FEC_NONE" : parm.FEC_None }
                                parm.frequency = int(data[1])
                                parm.symbol_rate = int(data[2])
                                parm.fec_inner = fec[data[3]]
@@ -381,15 +346,15 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                                        self.list.append(self.systemEntry)
                                else:
                                        # downgrade to dvb-s, in case a -s2 config was active
-                                       self.scan_sat.system.value = "dvb-s"
+                                       self.scan_sat.system.value = eDVBFrontendParametersSatellite.System_DVB_S
                                self.list.append(getConfigListEntry(_('Satellite'), self.scan_satselection[index_to_scan]))
                                self.list.append(getConfigListEntry(_('Frequency'), self.scan_sat.frequency))
                                self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion))
                                self.list.append(getConfigListEntry(_('Symbol Rate'), self.scan_sat.symbolrate))
                                self.list.append(getConfigListEntry(_("Polarity"), self.scan_sat.polarization))
-                               if self.scan_sat.system.value == "dvb-s":
+                               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 == "dvb-s2":
+                               elif self.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)
@@ -447,7 +412,7 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                if cur == self.typeOfScanEntry or \
                        cur == self.tunerEntry or \
                        cur == self.systemEntry or \
-                       (self.modulationEntry and self.systemEntry[1].value == "dvb-s2" and cur == self.modulationEntry):
+                       (self.modulationEntry and self.systemEntry[1].value == eDVBFrontendParametersSatellite.System_DVB_S2 and cur == self.modulationEntry):
                        self.createSetup()
 
        def createConfig(self, frontendData):
@@ -481,34 +446,65 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                                           #("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": "dvb-s", "frequency": 11836, "inversion": "auto", "symbolrate": 27500, "polarization": "horizontal", "fec": "auto", "fec_s2": "9_10", "modulation": "qpsk" }
-                       defaultCab = {"frequency": 466, "inversion": "auto", "modulation": "64qam", "fec": "auto", "symbolrate": 6900}
+                       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,
+                               "modulation": eDVBFrontendParametersSatellite.Modulation_QPSK }
+                       defaultCab = {
+                               "frequency": 466,
+                               "inversion": eDVBFrontendParametersCable.Inversion_Unknown,
+                               "modulation": eDVBFrontendParametersCable.Modulation_QAM64,
+                               "fec": eDVBFrontendParametersCable.FEC_Auto,
+                               "symbolrate": 6900 }
+                       defaultTer = {
+                               "frequency" : 466000,
+                               "inversion" : eDVBFrontendParametersTerrestrial.Inversion_Unknown,
+                               "bandwidth" : eDVBFrontendParametersTerrestrial.Bandwidth_7MHz,
+                               "fechigh" : eDVBFrontendParametersTerrestrial.FEC_Auto,
+                               "feclow" : eDVBFrontendParametersTerrestrial.FEC_Auto,
+                               "modulation" : eDVBFrontendParametersTerrestrial.Modulation_Auto,
+                               "transmission_mode" : eDVBFrontendParametersTerrestrial.TransmissionMode_Auto,
+                               "guard_interval" : eDVBFrontendParametersTerrestrial.GuardInterval_Auto,
+                               "hierarchy": eDVBFrontendParametersTerrestrial.Hierarchy_Auto }
+
                        if frontendData is not None:
                                ttype = frontendData.get("tuner_type", "UNKNOWN")
                                if ttype == "DVB-S":
-                                       defaultSat["system"] = {"DVB-S": "dvb-s", "DVB-S2": "dvb-s2"}[frontendData.get("system", "DVB-S")]
+                                       defaultSat["system"] = frontendData.get("system", eDVBFrontendParametersSatellite.System_DVB_S)
                                        defaultSat["frequency"] = frontendData.get("frequency", 0) / 1000
-                                       defaultSat["inversion"] = {"INVERSION_OFF": "off", "INVERSION_ON": "on", "INVERSION_AUTO": "auto"}[frontendData.get("inversion", "INVERSION_AUTO")]
+                                       defaultSat["inversion"] = frontendData.get("inversion", eDVBFrontendParametersSatellite.Inversion_Unknown)
                                        defaultSat["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000
-                                       defaultSat["polarization"] = {"HORIZONTAL": "horizontal", "VERTICAL": "vertical", "CIRCULAR_LEFT": "circular_left", "CIRCULAR_RIGHT": "circular_right", "UNKNOWN": None}[frontendData.get("polarization", "HORIZONTAL")]
-
-                                       if frontendData.get("system", "DVB-S") == "DVB-S2":
-                                               defaultSat["fec_s2"] = {"FEC_1_2": "1_2", "FEC_2_3": "2_3", "FEC_3_4": "3_4", "FEC_4_5": "4_5", "FEC_5_6": "5_6", "FEC_7_8": "7_8", "FEC_8_9": "8_9", "FEC_9_10": "9_10"} \
-                                                                                       [frontendData.get("fec_inner", "FEC_AUTO")]
-                                               defaultSat["rolloff"] = {"ROLLOFF_0_35" : "0_35", "ROLLOFF_0_25" : "0_25", "ROLLOFF_0_20" : "0_20"}[frontendData.get("rolloff", "ROLLOFF_0_35")]
-                                               defaultSat["pilot"] = {"PILOT_ON" : "on", "PILOT_OFF" : "off", "PILOT_AUTO" : "auto"}[frontendData.get("pilot", "PILOT_AUTO")]
+                                       defaultSat["polarization"] = frontendData.get("polarization", eDVBFrontendParametersSatellite.Polarisation_Horizontal)
+                                       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)
                                        else:
-                                               defaultSat["fec"] = {"FEC_AUTO": "auto", "FEC_1_2": "1_2", "FEC_2_3": "2_3", "FEC_3_4": "3_4", "FEC_5_6": "5_6", "FEC_7_8": "7_8", "FEC_NONE": "none"} \
-                                                       [frontendData.get("fec_inner", "FEC_AUTO")]
-
-                                       defaultSat["modulation"] = {"QPSK": "qpsk", "8PSK": "8psk"}[frontendData.get("modulation", "QPSK")]
+                                               defaultSat["fec"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)
+                                       defaultSat["modulation"] = frontendData.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK)
                                        defaultSat["orbpos"] = frontendData.get("orbital_position", 0)
                                elif ttype == "DVB-C":
                                        defaultCab["frequency"] = frontendData.get("frequency", 0) / 1000
                                        defaultCab["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000
-                                       defaultCab["inversion"] = {"INVERSION_OFF": "off", "INVERSION_ON": "on", "INVERSION_AUTO": "auto"}[frontendData.get("inversion", "INVERSION_AUTO")]
-                                       defaultCab["fec"] = {"FEC_AUTO": "auto", "FEC_1_2": "1_2", "FEC_2_3": "2_3", "FEC_3_4": "3_4", "FEC_5_6": "5_6", "FEC_7_8": "7_8", "FEC_8_9": "8_9", "FEC_NONE": "none"}[frontendData.get("fec_inner", "FEC_AUTO")]
-                                       defaultCab["modulation"] = {"QAM_AUTO": "auto", "QAM_16": "16qam", "QAM_32": "32qam", "QAM_64": "64qam", "QAM_128": "128qam", "QAM_256": "256qam"}[frontendData.get("modulation", "QAM_16")]
+                                       defaultCab["inversion"] = frontendData.get("inversion", eDVBFrontendParametersCable.Inversion_Unknown)
+                                       defaultCab["fec"] = frontendData.get("fec_inner", eDVBFrontendParametersCable.FEC_Auto)
+                                       defaultCab["modulation"] = frontendData.get("modulation", eDVBFrontendParametersCable.Modulation_QAM16)
+                               elif ttype == "DVB-T":
+                                       defaultTer["frequency"] = frontendData.get("frequency", 0)
+                                       defaultTer["inversion"] = frontendData.get("inversion", eDVBFrontendParametersTerrestrial.Inversion_Unknown)
+                                       defaultTer["bandwidth"] = frontendData.get("bandwidth", eDVBFrontendParametersTerrestrial.Bandwidth_7MHz)
+                                       defaultTer["fechigh"] = frontendData.get("code_rate_hp", eDVBFrontendParametersTerrestrial.FEC_Auto)
+                                       defaultTer["feclow"] = frontendData.get("code_rate_lp", eDVBFrontendParametersTerrestrial.FEC_Auto)
+                                       defaultTer["modulation"] = frontendData.get("constellation", eDVBFrontendParametersTerrestrial.Modulation_Auto)
+                                       defaultTer["transmission_mode"] = frontendData.get("transmission_mode", eDVBFrontendParametersTerrestrial.TransmissionMode_Auto)
+                                       defaultTer["guard_interval"] = frontendData.get("guard_interval", eDVBFrontendParametersTerrestrial.GuardInterval_Auto)
+                                       defaultTer["hierarchy"] = frontendData.get("hierarchy_information", eDVBFrontendParametersTerrestrial.Hierarchy_Auto)
 
                        self.scan_sat = ConfigSubsection()
                        self.scan_cab = ConfigSubsection()
@@ -538,36 +534,120 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                        self.scan_ber.enabled = False
 
                        # sat
-                       self.scan_sat.system = ConfigSelection(default = defaultSat["system"], choices = [("dvb-s", _("DVB-S")), ("dvb-s2", _("DVB-S2"))])
+                       self.scan_sat.system = ConfigSelection(default = defaultSat["system"], choices = [
+                               (eDVBFrontendParametersSatellite.System_DVB_S, _("DVB-S")),
+                               (eDVBFrontendParametersSatellite.System_DVB_S2, _("DVB-S2"))])
                        self.scan_sat.frequency = ConfigInteger(default = defaultSat["frequency"], limits = (1, 99999))
-                       self.scan_sat.inversion = ConfigSelection(default = defaultSat["inversion"], choices = [("off", _("off")), ("on", _("on")), ("auto", _("Auto"))])
+                       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 = [("horizontal", _("horizontal")), ("vertical", _("vertical")),  ("circular_left", _("circular left")), ("circular_right", _("circular right"))])
-                       self.scan_sat.fec = ConfigSelection(default = defaultSat["fec"], choices = [("auto", _("Auto")), ("1_2", "1/2"), ("2_3", "2/3"), ("3_4", "3/4"), ("5_6", "5/6"), ("7_8", "7/8"), ("none", _("None"))])
-                       self.scan_sat.fec_s2 = ConfigSelection(default = defaultSat["fec_s2"], choices = [("1_2", "1/2"), ("2_3", "2/3"), ("3_4", "3/4"), ("3_5", "3/5"), ("4_5", "4/5"), ("5_6", "5/6"), ("7_8", "7/8"), ("8_9", "8/9"), ("9_10", "9/10")])
-                       self.scan_sat.modulation = ConfigSelection(default = defaultSat["modulation"], choices = [("qpsk", "QPSK"), ("8psk", "8PSK")])
-                       self.scan_sat.rolloff = ConfigSelection(default = defaultSat.get("rolloff", "0_35"), choices = [("0_35", "0.35"), ("0_25", "0.25"), ("0_20", "0.20")])
-                       self.scan_sat.pilot = ConfigSelection(default = defaultSat.get("pilot", "auto"), choices = [("off", _("off")), ("on", _("on")), ("auto", _("Auto"))])
+                       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.modulation = ConfigSelection(default = defaultSat["modulation"], choices = [
+                               (eDVBFrontendParametersSatellite.Modulation_QPSK, "QPSK"),
+                               (eDVBFrontendParametersSatellite.Modulation_8PSK, "8PSK")])
+                       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"))])
 
                        # cable
                        self.scan_cab.frequency = ConfigInteger(default = defaultCab["frequency"], limits = (50, 999))
-                       self.scan_cab.inversion = ConfigSelection(default = defaultCab["inversion"], choices = [("off", _("off")), ("on", _("on")), ("auto", _("Auto"))])
-                       self.scan_cab.modulation = ConfigSelection(default = defaultCab["modulation"], choices = [("16qam", "16-QAM"), ("32qam", "32-QAM"), ("64qam", "64-QAM"), ("128qam", "128-QAM"), ("256qam", "256-QAM")])
-                       self.scan_cab.fec = ConfigSelection(default = defaultCab["fec"], choices = [("auto", _("Auto")), ("1_2", "1/2"), ("2_3", "2/3"), ("3_4", "3/4"), ("5_6", "5/6"), ("7_8", "7/8"), ("8_9", "8/9"), ("none", _("None"))])
+                       self.scan_cab.inversion = ConfigSelection(default = defaultCab["inversion"], choices = [
+                               (eDVBFrontendParametersCable.Inversion_Off, _("off")),
+                               (eDVBFrontendParametersCable.Inversion_On, _("on")),
+                               (eDVBFrontendParametersCable.Inversion_Unknown, _("Auto"))])
+                       self.scan_cab.modulation = ConfigSelection(default = defaultCab["modulation"], choices = [
+                               (eDVBFrontendParametersCable.Modulation_QAM16, "16-QAM"),
+                               (eDVBFrontendParametersCable.Modulation_QAM32, "32-QAM"),
+                               (eDVBFrontendParametersCable.Modulation_QAM64, "64-QAM"),
+                               (eDVBFrontendParametersCable.Modulation_QAM128, "128-QAM"),
+                               (eDVBFrontendParametersCable.Modulation_QAM256, "256-QAM")])
+                       self.scan_cab.fec = ConfigSelection(default = defaultCab["fec"], choices = [
+                               (eDVBFrontendParametersCable.FEC_Auto, _("Auto")),
+                               (eDVBFrontendParametersCable.FEC_1_2, "1/2"),
+                               (eDVBFrontendParametersCable.FEC_2_3, "2/3"),
+                               (eDVBFrontendParametersCable.FEC_3_4, "3/4"),
+                               (eDVBFrontendParametersCable.FEC_5_6, "5/6"),
+                               (eDVBFrontendParametersCable.FEC_7_8, "7/8"),
+                               (eDVBFrontendParametersCable.FEC_8_9, "8/9"),
+                               (eDVBFrontendParametersCable.FEC_None, _("None"))])
                        self.scan_cab.symbolrate = ConfigInteger(default = defaultCab["symbolrate"], limits = (1, 99999))
 
                        # terrestial
                        self.scan_ter.frequency = ConfigInteger(default = 466000, limits = (50000, 999000))
-                       self.scan_ter.inversion = ConfigSelection(default = "auto", choices = [("off", _("off")), ("on", _("on")), ("auto", _("Auto"))])
+                       self.scan_ter.inversion = ConfigSelection(default = defaultTer["inversion"], choices = [
+                               (eDVBFrontendParametersTerrestrial.Inversion_Off, _("off")),
+                               (eDVBFrontendParametersTerrestrial.Inversion_On, _("on")),
+                               (eDVBFrontendParametersTerrestrial.Inversion_Unknown, _("Auto"))])
                        # WORKAROUND: we can't use BW-auto
-                       self.scan_ter.bandwidth = ConfigSelection(default = "8MHz", choices = [("8MHz", "8MHz"), ("7MHz", "7MHz"), ("6MHz", "6MHz")])
-                       #, ("auto", _("Auto"))))
-                       self.scan_ter.fechigh = ConfigSelection(default = "auto", choices = [("1_2", "1/2"), ("2_3", "2/3"), ("3_4", "3/4"), ("5_6", "5/6"), ("7_8", "7/8"), ("auto", _("Auto"))])
-                       self.scan_ter.feclow = ConfigSelection(default = "auto", choices = [("1_2", "1/2"), ("2_3", "2/3"), ("3_4", "3/4"), ("5_6", "5/6"), ("7_8", "7/8"), ("auto", _("Auto"))])
-                       self.scan_ter.modulation = ConfigSelection(default = "auto", choices = [("qpsk", "QPSK"), ("qam16", "QAM16"), ("qam64", "QAM64"), ("auto", _("Auto"))])
-                       self.scan_ter.transmission = ConfigSelection(default = "auto", choices = [("2k", "2K"), ("8k", "8K"), ("auto", _("Auto"))])
-                       self.scan_ter.guard = ConfigSelection(default = "auto", choices = [("1_32", "1/32"), ("1_16", "1/16"), ("1_8", "1/8"), ("1_4", "1/4"), ("auto", _("Auto"))])
-                       self.scan_ter.hierarchy = ConfigSelection(default = "auto", choices = [("none", _("None")), ("1", "1"), ("2", "2"), ("4", "4"), ("auto", _("Auto"))])
+                       self.scan_ter.bandwidth = ConfigSelection(default = defaultTer["bandwidth"], choices = [
+                               (eDVBFrontendParametersTerrestrial.Bandwidth_8MHz, "8MHz"),
+                               (eDVBFrontendParametersTerrestrial.Bandwidth_7MHz, "7MHz"),
+                               (eDVBFrontendParametersTerrestrial.Bandwidth_6MHz, "6MHz")])
+                       #, (eDVBFrontendParametersTerrestrial.Bandwidth_Auto, _("Auto"))))
+                       self.scan_ter.fechigh = ConfigSelection(default = defaultTer["fechigh"], choices = [
+                               (eDVBFrontendParametersTerrestrial.FEC_1_2, "1/2"),
+                               (eDVBFrontendParametersTerrestrial.FEC_2_3, "2/3"),
+                               (eDVBFrontendParametersTerrestrial.FEC_3_4, "3/4"),
+                               (eDVBFrontendParametersTerrestrial.FEC_5_6, "5/6"),
+                               (eDVBFrontendParametersTerrestrial.FEC_7_8, "7/8"),
+                               (eDVBFrontendParametersTerrestrial.FEC_Auto, _("Auto"))])
+                       self.scan_ter.feclow = ConfigSelection(default = defaultTer["feclow"], choices = [
+                               (eDVBFrontendParametersTerrestrial.FEC_1_2, "1/2"),
+                               (eDVBFrontendParametersTerrestrial.FEC_2_3, "2/3"),
+                               (eDVBFrontendParametersTerrestrial.FEC_3_4, "3/4"),
+                               (eDVBFrontendParametersTerrestrial.FEC_5_6, "5/6"),
+                               (eDVBFrontendParametersTerrestrial.FEC_7_8, "7/8"),
+                               (eDVBFrontendParametersTerrestrial.FEC_Auto, _("Auto"))])
+                       self.scan_ter.modulation = ConfigSelection(default = defaultTer["modulation"], choices = [
+                               (eDVBFrontendParametersTerrestrial.Modulation_QPSK, "QPSK"),
+                               (eDVBFrontendParametersTerrestrial.Modulation_QAM16, "QAM16"),
+                               (eDVBFrontendParametersTerrestrial.Modulation_QAM64, "QAM64"),
+                               (eDVBFrontendParametersTerrestrial.Modulation_Auto, _("Auto"))])
+                       self.scan_ter.transmission = ConfigSelection(default = defaultTer["transmission_mode"], choices = [
+                               (eDVBFrontendParametersTerrestrial.TransmissionMode_2k, "2K"),
+                               (eDVBFrontendParametersTerrestrial.TransmissionMode_8k, "8K"),
+                               (eDVBFrontendParametersTerrestrial.TransmissionMode_Auto, _("Auto"))])
+                       self.scan_ter.guard = ConfigSelection(default = defaultTer["guard_interval"], choices = [
+                               (eDVBFrontendParametersTerrestrial.GuardInterval_1_32, "1/32"),
+                               (eDVBFrontendParametersTerrestrial.GuardInterval_1_16, "1/16"),
+                               (eDVBFrontendParametersTerrestrial.GuardInterval_1_8, "1/8"),
+                               (eDVBFrontendParametersTerrestrial.GuardInterval_1_4, "1/4"),
+                               (eDVBFrontendParametersTerrestrial.GuardInterval_Auto, _("Auto"))])
+                       self.scan_ter.hierarchy = ConfigSelection(default = defaultTer["hierarchy"], choices = [
+                               (eDVBFrontendParametersTerrestrial.Hierarchy_None, _("None")),
+                               (eDVBFrontendParametersTerrestrial.Hierarchy_1, "1"),
+                               (eDVBFrontendParametersTerrestrial.Hierarchy_2, "2"),
+                               (eDVBFrontendParametersTerrestrial.Hierarchy_4, "4"),
+                               (eDVBFrontendParametersTerrestrial.Hierarchy_Auto, _("Auto"))])
 
                        self.scan_scansat = {}
                        for sat in nimmanager.satList:
@@ -594,32 +674,16 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
        def updateStatus(self):
                print "updatestatus"
 
-       fecmap = { "auto": 0,
-                          "1_2": 1,
-                          "2_3": 2,
-                          "3_4": 3,
-                          "5_6": 4,
-                          "7_8": 5,
-                          "8_9": 6,
-                          "3_5": 7,
-                          "4_5": 8,
-                          "9_10": 9,
-                          "none": 15
-                          }
-
        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(self.fecmap[fec]) + " inversion: " + str(inversion) + " modulation: " + str(modulation) + " system: " + str(system) + " rolloff" + str(rolloff) + " pilot" + str(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)
                print "orbpos: " + str(orbital_position)
                parm = eDVBFrontendParametersSatellite()
-               if modulation == 1:
-                       parm.modulation = 2 # eDVBFrontendParametersSatellite.Modulation.8PSK
-               else:
-                       parm.modulation = 1 # eDVBFrontendParametersSatellite.Modulation.QPSK
+               parm.modulation = modulation
                parm.system = system
                parm.frequency = frequency * 1000
                parm.symbol_rate = symbol_rate * 1000
                parm.polarisation = polarisation
-               parm.fec = self.fecmap[fec]
+               parm.fec = fec
                parm.inversion = inversion
                parm.orbital_position = orbital_position
                parm.rolloff = rolloff
@@ -632,7 +696,7 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                parm.frequency = frequency * 1000
                parm.symbol_rate = symbol_rate * 1000
                parm.modulation = modulation
-               parm.fec = self.fecmap[fec]
+               parm.fec = fec
                parm.inversion = inversion
                tlist.append(parm)
 
@@ -665,21 +729,21 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                                # 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 == "dvb-s":
+                                       if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S:
                                                fec = self.scan_sat.fec.value
                                        else:
                                                fec = self.scan_sat.fec_s2.value
                                        print "add sat transponder"
                                        self.addSatTransponder(tlist, self.scan_sat.frequency.value,
                                                                self.scan_sat.symbolrate.value,
-                                                               self.scan_sat.polarization.index,
+                                                               self.scan_sat.polarization.value,
                                                                fec,
-                                                               self.scan_sat.inversion.index,
+                                                               self.scan_sat.inversion.value,
                                                                orbpos,
-                                                               self.scan_sat.system.index,
-                                                               self.scan_sat.modulation.index,
-                                                               self.scan_sat.rolloff.index,
-                                                               self.scan_sat.pilot.index)
+                                                               self.scan_sat.system.value,
+                                                               self.scan_sat.modulation.value,
+                                                               self.scan_sat.rolloff.value,
+                                                               self.scan_sat.pilot.value)
                                removeAll = False
                        elif self.scan_type.value == "single_satellite":
                                sat = self.satList[index_to_scan][self.scan_satselection[index_to_scan].index]
@@ -693,12 +757,11 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
 
                elif nim.isCompatible("DVB-C"):
                        if self.scan_typecable.value == "single_transponder":
-                               fec = self.scan_cab.fec.value
                                self.addCabTransponder(tlist, self.scan_cab.frequency.value,
                                                                                          self.scan_cab.symbolrate.value,
-                                                                                         self.scan_cab.modulation.index + 1,
-                                                                                         fec,
-                                                                                         self.scan_cab.inversion.index)
+                                                                                         self.scan_cab.modulation.value,
+                                                                                         self.scan_cab.fec.value,
+                                                                                         self.scan_cab.inversion.value)
                                removeAll = False
                        elif self.scan_typecable.value == "complete":
                                if config.Nims[index_to_scan].cable.scan_type.value == "provider":
@@ -710,14 +773,14 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                        if self.scan_typeterrestrial.value == "single_transponder":
                                self.addTerTransponder(tlist,
                                                self.scan_ter.frequency.value * 1000,
-                                               inversion = self.scan_ter.inversion.index,
-                                               bandwidth = self.scan_ter.bandwidth.index,
-                                               fechigh = self.scan_ter.fechigh.index,
-                                               feclow = self.scan_ter.feclow.index,
-                                               modulation = self.scan_ter.modulation.index,
-                                               transmission = self.scan_ter.transmission.index,
-                                               guard = self.scan_ter.guard.index,
-                                               hierarchy = self.scan_ter.hierarchy.index)
+                                               inversion = self.scan_ter.inversion.value,
+                                               bandwidth = self.scan_ter.bandwidth.value,
+                                               fechigh = self.scan_ter.fechigh.value,
+                                               feclow = self.scan_ter.feclow.value,
+                                               modulation = self.scan_ter.modulation.value,
+                                               transmission = self.scan_ter.transmission.value,
+                                               guard = self.scan_ter.guard.value,
+                                               hierarchy = self.scan_ter.hierarchy.value)
                                removeAll = False
                        elif self.scan_typeterrestrial.value == "complete":
                                getInitialTerrestrialTransponderList(tlist, nimmanager.getTerrestrialDescription(index_to_scan))
index dcd7017..bcf005e 100644 (file)
@@ -122,64 +122,64 @@ void PutSatelliteDataToDict(ePyObject &dict, eDVBFrontendParametersSatellite &fe
        PutToDictAsStr(dict, "orbital position", feparm.orbital_position);
        switch (feparm.inversion)
        {
-               case eDVBFrontendParametersSatellite::Inversion::On: tmp="ON"; break;
-               case eDVBFrontendParametersSatellite::Inversion::Off: tmp="OFF"; break;
+               case eDVBFrontendParametersSatellite::Inversion_On: tmp="ON"; break;
+               case eDVBFrontendParametersSatellite::Inversion_Off: tmp="OFF"; break;
                default:
-               case eDVBFrontendParametersSatellite::Inversion::Unknown: tmp="AUTO"; break;
+               case eDVBFrontendParametersSatellite::Inversion_Unknown: tmp="AUTO"; break;
        }
        PutToDict(dict, "inversion", tmp);
        switch (feparm.fec)
        {
-               case eDVBFrontendParametersSatellite::FEC::fNone: tmp="NONE"; break;
-               case eDVBFrontendParametersSatellite::FEC::f1_2: tmp="1/2"; break;
-               case eDVBFrontendParametersSatellite::FEC::f2_3: tmp="2/3"; break;
-               case eDVBFrontendParametersSatellite::FEC::f3_4: tmp="3/4"; break;
-               case eDVBFrontendParametersSatellite::FEC::f5_6: tmp="5/6"; break;
-               case eDVBFrontendParametersSatellite::FEC::f7_8: tmp="7/8"; break;
-               case eDVBFrontendParametersSatellite::FEC::f3_5: tmp="3/5"; break;
-               case eDVBFrontendParametersSatellite::FEC::f4_5: tmp="4/5"; break;
-               case eDVBFrontendParametersSatellite::FEC::f8_9: tmp="8/9"; break;
-               case eDVBFrontendParametersSatellite::FEC::f9_10: tmp="9/10"; break;
+               case eDVBFrontendParametersSatellite::FEC_None: tmp="NONE"; break;
+               case eDVBFrontendParametersSatellite::FEC_1_2: tmp="1/2"; break;
+               case eDVBFrontendParametersSatellite::FEC_2_3: tmp="2/3"; break;
+               case eDVBFrontendParametersSatellite::FEC_3_4: tmp="3/4"; break;
+               case eDVBFrontendParametersSatellite::FEC_5_6: tmp="5/6"; break;
+               case eDVBFrontendParametersSatellite::FEC_7_8: tmp="7/8"; break;
+               case eDVBFrontendParametersSatellite::FEC_3_5: tmp="3/5"; break;
+               case eDVBFrontendParametersSatellite::FEC_4_5: tmp="4/5"; break;
+               case eDVBFrontendParametersSatellite::FEC_8_9: tmp="8/9"; break;
+               case eDVBFrontendParametersSatellite::FEC_9_10: tmp="9/10"; break;
                default:
-               case eDVBFrontendParametersSatellite::FEC::fAuto: tmp="AUTO"; break;
+               case eDVBFrontendParametersSatellite::FEC_Auto: tmp="AUTO"; break;
        }
        PutToDict(dict, "fec inner", tmp);
        switch (feparm.modulation)
        {
-               case eDVBFrontendParametersSatellite::Modulation::Auto: tmp="AUTO"; break;
-               case eDVBFrontendParametersSatellite::Modulation::QPSK: tmp="QPSK"; break;
-               case eDVBFrontendParametersSatellite::Modulation::M8PSK: tmp="8PSK"; break;
-               case eDVBFrontendParametersSatellite::Modulation::QAM_16: tmp="QAM16"; break;
+               case eDVBFrontendParametersSatellite::Modulation_Auto: tmp="AUTO"; break;
+               case eDVBFrontendParametersSatellite::Modulation_QPSK: tmp="QPSK"; break;
+               case eDVBFrontendParametersSatellite::Modulation_8PSK: tmp="8PSK"; break;
+               case eDVBFrontendParametersSatellite::Modulation_QAM16: tmp="QAM16"; break;
        }
        PutToDict(dict, "modulation", tmp);
        switch(feparm.polarisation)
        {
-               case eDVBFrontendParametersSatellite::Polarisation::Horizontal: tmp="HORIZONTAL"; break;
-               case eDVBFrontendParametersSatellite::Polarisation::Vertical: tmp="VERTICAL"; break;
-               case eDVBFrontendParametersSatellite::Polarisation::CircularLeft: tmp="CIRCULAR LEFT"; break;
+               case eDVBFrontendParametersSatellite::Polarisation_Horizontal: tmp="HORIZONTAL"; break;
+               case eDVBFrontendParametersSatellite::Polarisation_Vertical: tmp="VERTICAL"; break;
+               case eDVBFrontendParametersSatellite::Polarisation_CircularLeft: tmp="CIRCULAR LEFT"; break;
                default:
-               case eDVBFrontendParametersSatellite::Polarisation::CircularRight: tmp="CIRCULAR RIGHT"; break;
+               case eDVBFrontendParametersSatellite::Polarisation_CircularRight: tmp="CIRCULAR RIGHT"; break;
        }
        PutToDict(dict, "polarization", tmp);
        switch(feparm.system)
        {
                default:
-               case eDVBFrontendParametersSatellite::System::DVB_S: tmp="DVB-S"; break;
-               case eDVBFrontendParametersSatellite::System::DVB_S2:
+               case eDVBFrontendParametersSatellite::System_DVB_S: tmp="DVB-S"; break;
+               case eDVBFrontendParametersSatellite::System_DVB_S2:
                        switch(feparm.rolloff)
                        {
                                default:
-                               case eDVBFrontendParametersSatellite::RollOff::alpha_0_35: tmp="0.35"; break;
-                               case eDVBFrontendParametersSatellite::RollOff::alpha_0_25: tmp="0.25"; break;
-                               case eDVBFrontendParametersSatellite::RollOff::alpha_0_20: tmp="0.20"; break;
+                               case eDVBFrontendParametersSatellite::RollOff_alpha_0_35: tmp="0.35"; break;
+                               case eDVBFrontendParametersSatellite::RollOff_alpha_0_25: tmp="0.25"; break;
+                               case eDVBFrontendParametersSatellite::RollOff_alpha_0_20: tmp="0.20"; break;
                        }
                        PutToDict(dict, "roll off", tmp);
                        switch(feparm.pilot)
                        {
-                               case eDVBFrontendParametersSatellite::Pilot::On: tmp="ON"; break;
-                               case eDVBFrontendParametersSatellite::Pilot::Off: tmp="OFF"; break;
+                               case eDVBFrontendParametersSatellite::Pilot_On: tmp="ON"; break;
+                               case eDVBFrontendParametersSatellite::Pilot_Off: tmp="OFF"; break;
                                default:
-                               case eDVBFrontendParametersSatellite::Pilot::Unknown: tmp="AUTO"; break;
+                               case eDVBFrontendParametersSatellite::Pilot_Unknown: tmp="AUTO"; break;
                        }
                        PutToDict(dict, "pilot", tmp);
                        tmp="DVB-S2";
@@ -195,78 +195,78 @@ void PutTerrestrialDataToDict(ePyObject &dict, eDVBFrontendParametersTerrestrial
        const char *tmp=0;
        switch (feparm.bandwidth)
        {
-       case eDVBFrontendParametersTerrestrial::Bandwidth::Bw8MHz: tmp="8 MHz"; break;
-       case eDVBFrontendParametersTerrestrial::Bandwidth::Bw7MHz: tmp="7 MHz"; break;
-       case eDVBFrontendParametersTerrestrial::Bandwidth::Bw6MHz: tmp="6 MHz"; break;
+       case eDVBFrontendParametersTerrestrial::Bandwidth_8MHz: tmp="8 MHz"; break;
+       case eDVBFrontendParametersTerrestrial::Bandwidth_7MHz: tmp="7 MHz"; break;
+       case eDVBFrontendParametersTerrestrial::Bandwidth_6MHz: tmp="6 MHz"; break;
        default:
-       case eDVBFrontendParametersTerrestrial::Bandwidth::BwAuto: tmp="AUTO"; break;
+       case eDVBFrontendParametersTerrestrial::Bandwidth_Auto: tmp="AUTO"; break;
        }
        PutToDict(dict, "bandwidth", tmp);
        switch (feparm.code_rate_LP)
        {
-       case eDVBFrontendParametersTerrestrial::FEC::f1_2: tmp="1/2"; break;
-       case eDVBFrontendParametersTerrestrial::FEC::f2_3: tmp="2/3"; break;
-       case eDVBFrontendParametersTerrestrial::FEC::f3_4: tmp="3/4"; break;
-       case eDVBFrontendParametersTerrestrial::FEC::f5_6: tmp="5/6"; break;
-       case eDVBFrontendParametersTerrestrial::FEC::f7_8: tmp="7/8"; break;
+       case eDVBFrontendParametersTerrestrial::FEC_1_2: tmp="1/2"; break;
+       case eDVBFrontendParametersTerrestrial::FEC_2_3: tmp="2/3"; break;
+       case eDVBFrontendParametersTerrestrial::FEC_3_4: tmp="3/4"; break;
+       case eDVBFrontendParametersTerrestrial::FEC_5_6: tmp="5/6"; break;
+       case eDVBFrontendParametersTerrestrial::FEC_7_8: tmp="7/8"; break;
        default:
-       case eDVBFrontendParametersTerrestrial::FEC::fAuto: tmp="AUTO"; break;
+       case eDVBFrontendParametersTerrestrial::FEC_Auto: tmp="AUTO"; break;
        }
        PutToDict(dict, "code rate lp", tmp);
        switch (feparm.code_rate_HP)
        {
-       case eDVBFrontendParametersTerrestrial::FEC::f1_2: tmp="1/2"; break;
-       case eDVBFrontendParametersTerrestrial::FEC::f2_3: tmp="2/3"; break;
-       case eDVBFrontendParametersTerrestrial::FEC::f3_4: tmp="3/4"; break;
-       case eDVBFrontendParametersTerrestrial::FEC::f5_6: tmp="5/6"; break;
-       case eDVBFrontendParametersTerrestrial::FEC::f7_8: tmp="7/8"; break;
+       case eDVBFrontendParametersTerrestrial::FEC_1_2: tmp="1/2"; break;
+       case eDVBFrontendParametersTerrestrial::FEC_2_3: tmp="2/3"; break;
+       case eDVBFrontendParametersTerrestrial::FEC_3_4: tmp="3/4"; break;
+       case eDVBFrontendParametersTerrestrial::FEC_5_6: tmp="5/6"; break;
+       case eDVBFrontendParametersTerrestrial::FEC_7_8: tmp="7/8"; break;
        default:
-       case eDVBFrontendParametersTerrestrial::FEC::fAuto: tmp="AUTO"; break;
+       case eDVBFrontendParametersTerrestrial::FEC_Auto: tmp="AUTO"; break;
        }
        PutToDict(dict, "code rate hp", tmp);
        switch (feparm.modulation)
        {
-       case eDVBFrontendParametersTerrestrial::Modulation::QPSK: tmp="QPSK"; break;
-       case eDVBFrontendParametersTerrestrial::Modulation::QAM16: tmp="QAM16"; break;
-       case eDVBFrontendParametersTerrestrial::Modulation::QAM64: tmp="QAM64"; break;
+       case eDVBFrontendParametersTerrestrial::Modulation_QPSK: tmp="QPSK"; break;
+       case eDVBFrontendParametersTerrestrial::Modulation_QAM16: tmp="QAM16"; break;
+       case eDVBFrontendParametersTerrestrial::Modulation_QAM64: tmp="QAM64"; break;
        default:
-       case eDVBFrontendParametersTerrestrial::Modulation::Auto: tmp="AUTO"; break;
+       case eDVBFrontendParametersTerrestrial::Modulation_Auto: tmp="AUTO"; break;
        }
        PutToDict(dict, "constellation", tmp);
        switch (feparm.transmission_mode)
        {
-       case eDVBFrontendParametersTerrestrial::TransmissionMode::TM2k: tmp="2k"; break;
-       case eDVBFrontendParametersTerrestrial::TransmissionMode::TM8k: tmp="8k"; break;
+       case eDVBFrontendParametersTerrestrial::TransmissionMode_2k: tmp="2k"; break;
+       case eDVBFrontendParametersTerrestrial::TransmissionMode_8k: tmp="8k"; break;
        default:
-       case eDVBFrontendParametersTerrestrial::TransmissionMode::TMAuto: tmp="AUTO"; break;
+       case eDVBFrontendParametersTerrestrial::TransmissionMode_Auto: tmp="AUTO"; break;
        }
        PutToDict(dict, "transmission mode", tmp);
        switch (feparm.guard_interval)
        {
-               case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_32: tmp="1/32"; break;
-               case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_16: tmp="1/16"; break;
-               case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_8: tmp="1/8"; break;
-               case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_4: tmp="1/4"; break;
+               case eDVBFrontendParametersTerrestrial::GuardInterval_1_32: tmp="1/32"; break;
+               case eDVBFrontendParametersTerrestrial::GuardInterval_1_16: tmp="1/16"; break;
+               case eDVBFrontendParametersTerrestrial::GuardInterval_1_8: tmp="1/8"; break;
+               case eDVBFrontendParametersTerrestrial::GuardInterval_1_4: tmp="1/4"; break;
                default:
-               case eDVBFrontendParametersTerrestrial::GuardInterval::GI_Auto: tmp="AUTO"; break;
+               case eDVBFrontendParametersTerrestrial::GuardInterval_Auto: tmp="AUTO"; break;
        }
        PutToDict(dict, "guard interval", tmp);
        switch (feparm.hierarchy)
        {
-               case eDVBFrontendParametersTerrestrial::Hierarchy::HNone: tmp="NONE"; break;
-               case eDVBFrontendParametersTerrestrial::Hierarchy::H1: tmp="1"; break;
-               case eDVBFrontendParametersTerrestrial::Hierarchy::H2: tmp="2"; break;
-               case eDVBFrontendParametersTerrestrial::Hierarchy::H4: tmp="4"; break;
+               case eDVBFrontendParametersTerrestrial::Hierarchy_None: tmp="NONE"; break;
+               case eDVBFrontendParametersTerrestrial::Hierarchy_1: tmp="1"; break;
+               case eDVBFrontendParametersTerrestrial::Hierarchy_2: tmp="2"; break;
+               case eDVBFrontendParametersTerrestrial::Hierarchy_4: tmp="4"; break;
                default:
-               case eDVBFrontendParametersTerrestrial::Hierarchy::HAuto: tmp="AUTO"; break;
+               case eDVBFrontendParametersTerrestrial::Hierarchy_Auto: tmp="AUTO"; break;
        }
        PutToDict(dict, "hierarchy", tmp);
        switch (feparm.inversion)
        {
-               case eDVBFrontendParametersSatellite::Inversion::On: tmp="ON"; break;
-               case eDVBFrontendParametersSatellite::Inversion::Off: tmp="OFF"; break;
+               case eDVBFrontendParametersSatellite::Inversion_On: tmp="ON"; break;
+               case eDVBFrontendParametersSatellite::Inversion_Off: tmp="OFF"; break;
                default:
-               case eDVBFrontendParametersSatellite::Inversion::Unknown: tmp="AUTO"; break;
+               case eDVBFrontendParametersSatellite::Inversion_Unknown: tmp="AUTO"; break;
        }
        PutToDict(dict, "inversion", tmp);
 }
@@ -279,34 +279,34 @@ void PutCableDataToDict(ePyObject &dict, eDVBFrontendParametersCable &feparm)
        PutToDictAsStr(dict, "symbolrate", feparm.symbol_rate);
        switch (feparm.modulation)
        {
-       case eDVBFrontendParametersCable::Modulation::QAM16: tmp="QAM16"; break;
-       case eDVBFrontendParametersCable::Modulation::QAM32: tmp="QAM32"; break;
-       case eDVBFrontendParametersCable::Modulation::QAM64: tmp="QAM64"; break;
-       case eDVBFrontendParametersCable::Modulation::QAM128: tmp="QAM128"; break;
-       case eDVBFrontendParametersCable::Modulation::QAM256: tmp="QAM256"; break;
+       case eDVBFrontendParametersCable::Modulation_QAM16: tmp="QAM16"; break;
+       case eDVBFrontendParametersCable::Modulation_QAM32: tmp="QAM32"; break;
+       case eDVBFrontendParametersCable::Modulation_QAM64: tmp="QAM64"; break;
+       case eDVBFrontendParametersCable::Modulation_QAM128: tmp="QAM128"; break;
+       case eDVBFrontendParametersCable::Modulation_QAM256: tmp="QAM256"; break;
        default:
-       case eDVBFrontendParametersCable::Modulation::Auto: tmp="AUTO"; break;
+       case eDVBFrontendParametersCable::Modulation_Auto: tmp="AUTO"; break;
        }
        PutToDict(dict, "modulation", tmp);
        switch (feparm.inversion)
        {
-       case eDVBFrontendParametersCable::Inversion::On: tmp="ON"; break;
-       case eDVBFrontendParametersCable::Inversion::Off: tmp="OFF"; break;
+       case eDVBFrontendParametersCable::Inversion_On: tmp="ON"; break;
+       case eDVBFrontendParametersCable::Inversion_Off: tmp="OFF"; break;
        default:
-       case eDVBFrontendParametersCable::Inversion::Unknown: tmp="AUTO"; break;
+       case eDVBFrontendParametersCable::Inversion_Unknown: tmp="AUTO"; break;
        }
        PutToDict(dict, "inversion", tmp);
        switch (feparm.fec_inner)
        {
-       case eDVBFrontendParametersCable::FEC::fNone: tmp="NONE"; break;
-       case eDVBFrontendParametersCable::FEC::f1_2: tmp="1/2"; break;
-       case eDVBFrontendParametersCable::FEC::f2_3: tmp="2/3"; break;
-       case eDVBFrontendParametersCable::FEC::f3_4: tmp="3/4"; break;
-       case eDVBFrontendParametersCable::FEC::f5_6: tmp="5/6"; break;
-       case eDVBFrontendParametersCable::FEC::f7_8: tmp="7/8"; break;
-       case eDVBFrontendParametersCable::FEC::f8_9: tmp="8/9"; break;
+       case eDVBFrontendParametersCable::FEC_None: tmp="NONE"; break;
+       case eDVBFrontendParametersCable::FEC_1_2: tmp="1/2"; break;
+       case eDVBFrontendParametersCable::FEC_2_3: tmp="2/3"; break;
+       case eDVBFrontendParametersCable::FEC_3_4: tmp="3/4"; break;
+       case eDVBFrontendParametersCable::FEC_5_6: tmp="5/6"; break;
+       case eDVBFrontendParametersCable::FEC_7_8: tmp="7/8"; break;
+       case eDVBFrontendParametersCable::FEC_8_9: tmp="8/9"; break;
        default:
-       case eDVBFrontendParametersCable::FEC::fAuto: tmp="AUTO"; break;
+       case eDVBFrontendParametersCable::FEC_Auto: tmp="AUTO"; break;
        }
        PutToDict(dict, "fec inner", tmp);
 }
@@ -2028,16 +2028,7 @@ PyObject *eDVBServiceBase::getTransponderData(bool original)
                                        if (!feparm->getDVBS(osat))
                                        {
                                                PutToDict(ret, "orbital_position", osat.orbital_position);
-                                               const char *tmp = "UNKNOWN";
-                                               switch(osat.polarisation)
-                                               {
-                                                       case eDVBFrontendParametersSatellite::Polarisation::Horizontal: tmp="HORIZONTAL"; break;
-                                                       case eDVBFrontendParametersSatellite::Polarisation::Vertical: tmp="VERTICAL"; break;
-                                                       case eDVBFrontendParametersSatellite::Polarisation::CircularLeft: tmp="CIRCULAR_LEFT"; break;
-                                                       case eDVBFrontendParametersSatellite::Polarisation::CircularRight: tmp="CIRCULAR_RIGHT"; break;
-                                                       default:break;
-                                               }
-                                               PutToDict(ret, "polarization", tmp);
+                                               PutToDict(ret, "polarization", osat.polarisation);
                                        }
                                }
                        }