X-Git-Url: https://git.cweiske.de/enigma2.git/blobdiff_plain/a2f2b1a1523b784e70cf3bd9a74b4cc5cfdbb3de..3e1cb3008ad22a23a1c9d0edff53346e2fc5d46d:/lib/dvb/frontend.cpp diff --git a/lib/dvb/frontend.cpp b/lib/dvb/frontend.cpp index aae7bbc2..15a46db8 100644 --- a/lib/dvb/frontend.cpp +++ b/lib/dvb/frontend.cpp @@ -1,4 +1,5 @@ #include +#include #include #include // access to python config #include @@ -48,9 +49,7 @@ #define parm_u_ofdm_transmission_mode parm.u.ofdm.transmission_mode #define parm_u_ofdm_guard_interval parm.u.ofdm.guard_interval #define parm_u_ofdm_hierarchy_information parm.u.ofdm.hierarchy_information -#ifdef FEC_9_10 - #warning "FEC_9_10 already exist in dvb api ... it seems it is now ready for DVB-S2" -#else +#if HAVE_DVB_API_VERSION < 5 #define FEC_S2_QPSK_1_2 (fe_code_rate_t)(FEC_AUTO+1) #define FEC_S2_QPSK_2_3 (fe_code_rate_t)(FEC_S2_QPSK_1_2+1) #define FEC_S2_QPSK_3_4 (fe_code_rate_t)(FEC_S2_QPSK_2_3+1) @@ -69,6 +68,16 @@ #define FEC_S2_8PSK_3_5 (fe_code_rate_t)(FEC_S2_8PSK_8_9+1) #define FEC_S2_8PSK_4_5 (fe_code_rate_t)(FEC_S2_8PSK_3_5+1) #define FEC_S2_8PSK_9_10 (fe_code_rate_t)(FEC_S2_8PSK_4_5+1) +#else + #define FEC_S2_QPSK_1_2 (fe_code_rate_t)(FEC_1_2) + #define FEC_S2_QPSK_2_3 (fe_code_rate_t)(FEC_2_3) + #define FEC_S2_QPSK_3_4 (fe_code_rate_t)(FEC_3_4) + #define FEC_S2_QPSK_5_6 (fe_code_rate_t)(FEC_5_6) + #define FEC_S2_QPSK_7_8 (fe_code_rate_t)(FEC_7_8) + #define FEC_S2_QPSK_8_9 (fe_code_rate_t)(FEC_8_9) + #define FEC_S2_QPSK_3_5 (fe_code_rate_t)(FEC_3_5) + #define FEC_S2_QPSK_4_5 (fe_code_rate_t)(FEC_4_5) + #define FEC_S2_QPSK_9_10 (fe_code_rate_t)(FEC_9_10) #endif #endif @@ -148,10 +157,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 +169,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, @@ -191,12 +200,12 @@ void eDVBFrontendParametersCable::set(const CableDeliverySystemDescriptor &descr frequency = descriptor.getFrequency() / 10; symbol_rate = descriptor.getSymbolRate() * 100; fec_inner = descriptor.getFecInner(); - if ( fec_inner == 0xF ) - fec_inner = FEC::fNone; + if ( fec_inner != eDVBFrontendParametersCable::FEC_None && fec_inner > eDVBFrontendParametersCable::FEC_8_9 ) + fec_inner = eDVBFrontendParametersCable::FEC_Auto; 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 +216,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 +325,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 +342,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,35 +359,35 @@ 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); + diff = abs(terrestrial.frequency - oterrestrial.frequency) / 1000; return 0; default: return -1; @@ -402,7 +411,7 @@ RESULT eDVBFrontendParameters::getHash(unsigned long &hash) const return 0; case iDVBFrontend::feTerrestrial: hash = 0xEEEE0000; - hash |= (terrestrial.frequency/1000)&0xFFFF; + hash |= (terrestrial.frequency/1000000)&0xFFFF; return 0; default: return -1; @@ -447,7 +456,7 @@ int eDVBFrontend::PriorityOrder=0; eDVBFrontend::eDVBFrontend(int adap, int fe, int &ok, bool simulate) :m_simulate(simulate), m_enabled(false), m_type(-1), m_dvbid(fe), m_slotid(fe) ,m_fd(-1), m_need_rotor_workaround(false), m_can_handle_dvbs2(false) - , m_timeout(0), m_tuneTimer(0) + ,m_state(stateClosed), m_timeout(0), m_tuneTimer(0) #if HAVE_DVB_API_VERSION < 3 ,m_secfd(-1) #endif @@ -476,7 +485,7 @@ eDVBFrontend::eDVBFrontend(int adap, int fe, int &ok, bool simulate) int eDVBFrontend::openFrontend() { - if (m_sn) + if (m_state != stateClosed) return -1; // already opened m_state=stateIdle; @@ -651,12 +660,6 @@ void eDVBFrontend::feEvent(int w) if (res && (errno == EAGAIN)) break; - if (res) - { - eWarning("FE_GET_EVENT failed! %m"); - return; - } - if (w < 0) continue; @@ -734,7 +737,7 @@ int eDVBFrontend::readFrontendData(int type) float SDS_SNRE = snr << 16; float snr_in_db; - if (parm_u_qpsk_fec_inner <= FEC_AUTO) // DVB-S1 / QPSK + if (oparm.sat.system == eDVBFrontendParametersSatellite::System_DVB_S) // DVB-S1 / QPSK { static float SNR_COEFF[6] = { 100.0 / 4194304.0, @@ -857,6 +860,8 @@ int eDVBFrontend::readFrontendData(int type) if (snr != 0) ret = 10 * (int)(-100 * (log10(snr) - log10(255))); } + else if (strstr(m_description, "BCM4506") || strstr(m_description, "BCM4505")) + ret = (snr * 100) >> 8; if (type == signalQuality) { @@ -960,123 +965,190 @@ void PutToDict(ePyObject &dict, const char*key, const char *value) eDebug("could not create PyObject for %s", key); } -void fillDictWithSatelliteData(ePyObject dict, const FRONTENDPARAMETERS &parm, eDVBFrontend *fe) +void PutSatelliteDataToDict(ePyObject &dict, eDVBFrontendParametersSatellite &feparm) +{ + PutToDict(dict, "tuner_type", "DVB-S"); + PutToDict(dict, "frequency", feparm.frequency); + PutToDict(dict, "symbol_rate", feparm.symbol_rate); + PutToDict(dict, "orbital_position", feparm.orbital_position); + PutToDict(dict, "inversion", feparm.inversion); + PutToDict(dict, "fec_inner", feparm.fec); + PutToDict(dict, "modulation", feparm.modulation); + PutToDict(dict, "polarization", feparm.polarisation); + if (feparm.system == eDVBFrontendParametersSatellite::System_DVB_S2) + { + PutToDict(dict, "rolloff", feparm.rolloff); + PutToDict(dict, "pilot", feparm.pilot); + } + PutToDict(dict, "system", feparm.system); +} + +void PutTerrestrialDataToDict(ePyObject &dict, eDVBFrontendParametersTerrestrial &feparm) +{ + PutToDict(dict, "tuner_type", "DVB-T"); + PutToDict(dict, "frequency", feparm.frequency); + PutToDict(dict, "bandwidth", feparm.bandwidth); + PutToDict(dict, "code_rate_lp", feparm.code_rate_LP); + PutToDict(dict, "code_rate_hp", feparm.code_rate_HP); + PutToDict(dict, "constellation", feparm.modulation); + PutToDict(dict, "transmission_mode", feparm.transmission_mode); + PutToDict(dict, "guard_interval", feparm.guard_interval); + PutToDict(dict, "hierarchy_information", feparm.hierarchy); + PutToDict(dict, "inversion", feparm.inversion); +} + +void PutCableDataToDict(ePyObject &dict, eDVBFrontendParametersCable &feparm) { - long freq_offset=0; - const char *tmp=0; - fe->getData(eDVBFrontend::FREQ_OFFSET, freq_offset); + PutToDict(dict, "tuner_type", "DVB-C"); + PutToDict(dict, "frequency", feparm.frequency); + PutToDict(dict, "symbol_rate", feparm.symbol_rate); + PutToDict(dict, "modulation", feparm.modulation); + PutToDict(dict, "inversion", feparm.inversion); + PutToDict(dict, "fec_inner", feparm.fec_inner); +} + +#if HAVE_DVB_API_VERSION >= 5 +static void fillDictWithSatelliteData(ePyObject dict, const FRONTENDPARAMETERS &parm, struct dtv_property *p, long freq_offset, int orb_pos, int polarization) +{ + long tmp=0; int frequency = parm_frequency + freq_offset; PutToDict(dict, "frequency", frequency); PutToDict(dict, "symbol_rate", parm_u_qpsk_symbol_rate); + PutToDict(dict, "orbital_position", orb_pos); + PutToDict(dict, "polarization", polarization); + 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_3_5: tmp = eDVBFrontendParametersSatellite::FEC_3_5; break; + case FEC_4_5: tmp = eDVBFrontendParametersSatellite::FEC_4_5; break; + case FEC_5_6: tmp = eDVBFrontendParametersSatellite::FEC_5_6; break; + case FEC_7_8: tmp = eDVBFrontendParametersSatellite::FEC_7_8; break; + case FEC_8_9: tmp = eDVBFrontendParametersSatellite::FEC_8_9; break; + case FEC_9_10: tmp = eDVBFrontendParametersSatellite::FEC_9_10; break; + case FEC_NONE: tmp = eDVBFrontendParametersSatellite::FEC_None; break; + case FEC_AUTO: tmp = eDVBFrontendParametersSatellite::FEC_Auto; break; + default: eDebug("got unsupported FEC from frontend! report as FEC_AUTO!\n"); + } + + switch (p[0].u.data) + { + default: eDebug("got unsupported system from frontend! report as DVBS!"); + case SYS_DVBS: tmp = eDVBFrontendParametersSatellite::System_DVB_S; break; + case SYS_DVBS2: + { + switch (p[2].u.data) + { + default: eDebug("got unsupported rolloff from frontend! report as 0_20!"); + case ROLLOFF_20: tmp = eDVBFrontendParametersSatellite::RollOff_alpha_0_20; break; + case ROLLOFF_25: tmp = eDVBFrontendParametersSatellite::RollOff_alpha_0_25; break; + case ROLLOFF_35: tmp = eDVBFrontendParametersSatellite::RollOff_alpha_0_35; break; + } + PutToDict(dict, "rolloff", tmp); + + switch (p[3].u.data) + { + case PILOT_OFF: tmp = eDVBFrontendParametersSatellite::Pilot_Off; break; + case PILOT_ON: tmp = eDVBFrontendParametersSatellite::Pilot_On; break; + case PILOT_AUTO: tmp = eDVBFrontendParametersSatellite::Pilot_Unknown; break; + } + PutToDict(dict, "pilot", tmp); + + tmp = eDVBFrontendParametersSatellite::System_DVB_S2; break; + } + } + PutToDict(dict, "system", tmp); + + switch (p[1].u.data) + { + default: eDebug("got unsupported modulation from frontend! report as QPSK!"); + case QPSK: tmp = eDVBFrontendParametersSatellite::Modulation_QPSK; break; + case PSK_8: tmp = eDVBFrontendParametersSatellite::Modulation_8PSK; break; + } + PutToDict(dict, "modulation", tmp); +} + +#else +static void fillDictWithSatelliteData(ePyObject dict, const FRONTENDPARAMETERS &parm, long freq_offset, int orb_pos, int polarization) +{ + long tmp=0; + int frequency = parm_frequency + freq_offset; + PutToDict(dict, "frequency", frequency); + PutToDict(dict, "symbol_rate", parm_u_qpsk_symbol_rate); + PutToDict(dict, "orbital_position", orb_pos); + PutToDict(dict, "polarization", polarization); + + switch(parm_u_qpsk_fec_inner) + { + 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_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); } +#endif -void fillDictWithCableData(ePyObject dict, const FRONTENDPARAMETERS &parm) +static 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 +1157,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) +static 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); } @@ -1326,53 +1304,78 @@ void eDVBFrontend::getTransponderData(ePyObject dest, bool original) { if (dest && PyDict_Check(dest)) { - switch(m_type) + FRONTENDPARAMETERS front; +#if HAVE_DVB_API_VERSION >= 5 + struct dtv_property p[4]; + struct dtv_properties cmdseq; + cmdseq.props = p; + cmdseq.num = 4; + p[0].cmd = DTV_DELIVERY_SYSTEM; + p[1].cmd = DTV_MODULATION; + p[2].cmd = DTV_ROLLOFF; + p[3].cmd = DTV_PILOT; +#endif + if (m_simulate || m_fd == -1 || original) + original = true; +#if HAVE_DVB_API_VERSION >= 5 + else if (m_type == feSatellite && // yet just use new api for DVB-S(2) only + ioctl(m_fd, FE_GET_PROPERTY, &cmdseq)<0) { - case feSatellite: - case feCable: - case feTerrestrial: + eDebug("FE_GET_PROPERTY failed (%m)"); + original = true; + } +#endif + else if (ioctl(m_fd, FE_GET_FRONTEND, &front)<0) + { + eDebug("FE_GET_FRONTEND failed (%m)"); + original = true; + } + if (original) + { + switch(m_type) { - FRONTENDPARAMETERS front; - if (m_fd == -1 && !original) - original = true; - else if (ioctl(m_fd, FE_GET_FRONTEND, &front)<0) - { - eDebug("FE_GET_FRONTEND failed (%m)"); - original = true; - } - { - const FRONTENDPARAMETERS &parm = original || m_simulate ? this->parm : front; - const char *tmp = "INVERSION_AUTO"; - switch(parm_inversion & 3) - { - case INVERSION_ON: - tmp = "INVERSION_ON"; - break; - case INVERSION_OFF: - tmp = "INVERSION_OFF"; - break; - default: - break; - } - if (tmp) - PutToDict(dest, "inversion", tmp); - - switch(m_type) - { - case feSatellite: - fillDictWithSatelliteData(dest, original?parm:front, this); - break; - case feCable: - fillDictWithCableData(dest, original?parm:front); - break; - case feTerrestrial: - fillDictWithTerrestrialData(dest, original?parm:front); - break; - } - } + case feSatellite: + PutSatelliteDataToDict(dest, oparm.sat); + break; + case feCable: + PutCableDataToDict(dest, oparm.cab); + break; + case feTerrestrial: + PutTerrestrialDataToDict(dest, oparm.ter); + break; + } + } + else + { + FRONTENDPARAMETERS &parm = front; + long tmp = eDVBFrontendParametersSatellite::Inversion_Unknown; + switch(parm_inversion & 3) + { + case INVERSION_ON: + tmp = eDVBFrontendParametersSatellite::Inversion_On; + break; + case INVERSION_OFF: + tmp = eDVBFrontendParametersSatellite::Inversion_Off; + default: + break; + } + PutToDict(dest, "inversion", tmp); + switch(m_type) + { + case feSatellite: +#if HAVE_DVB_API_VERSION >= 5 + fillDictWithSatelliteData(dest, parm, p, m_data[FREQ_OFFSET], oparm.sat.orbital_position, oparm.sat.polarisation); +#else + fillDictWithSatelliteData(dest, parm, m_data[FREQ_OFFSET], oparm.sat.orbital_position, oparm.sat.polarisation); +#endif + break; + case feCable: + fillDictWithCableData(dest, parm); + break; + case feTerrestrial: + fillDictWithTerrestrialData(dest, parm); + break; } - default: - break; } } } @@ -1482,7 +1485,7 @@ void eDVBFrontend::tuneLoop() // called by m_tuneTimer state = sec_fe->m_state; } // sec_fe is closed... we must reopen it here.. - if (state == eDVBFrontend::stateClosed) + if (state == stateClosed) { regFE = prev; prev->inc_use(); @@ -1565,14 +1568,18 @@ void eDVBFrontend::tuneLoop() // called by m_tuneTimer sec_fe->sendToneburst(m_sec_sequence.current()++->toneburst); break; case eSecCommand::SET_FRONTEND: - eDebugNoSimulate("[SEC] setFrontend"); - setFrontend(); - ++m_sec_sequence.current(); + { + int enableEvents = (m_sec_sequence.current()++)->val; + eDebugNoSimulate("[SEC] setFrontend %d", enableEvents); + setFrontend(enableEvents); break; + } case eSecCommand::START_TUNE_TIMEOUT: { + int tuneTimeout = m_sec_sequence.current()->timeout; + eDebugNoSimulate("[SEC] startTuneTimeout %d", tuneTimeout); if (!m_simulate) - m_timeout->start(m_sec_sequence.current()->timeout, 1); + m_timeout->start(tuneTimeout, 1); ++m_sec_sequence.current(); break; } @@ -1630,23 +1637,27 @@ void eDVBFrontend::tuneLoop() // called by m_tuneTimer int signal = 0; int isLocked = readFrontendData(locked); m_idleInputpower[0] = m_idleInputpower[1] = 0; - if (isLocked && ((abs((signal = readFrontendData(signalQualitydB)) - cmd.lastSignal) < 50) || !cmd.lastSignal)) + --m_timeoutCount; + if (!m_timeoutCount && m_retryCount > 0) + --m_retryCount; + if (isLocked && ((abs((signal = readFrontendData(signalQualitydB)) - cmd.lastSignal) < 40) || !cmd.lastSignal)) { if (cmd.lastSignal) eDebugNoSimulate("[SEC] locked step %d ok (%d %d)", cmd.okcount, signal, cmd.lastSignal); else { eDebugNoSimulate("[SEC] locked step %d ok", cmd.okcount); - cmd.lastSignal = signal; + if (!cmd.okcount) + cmd.lastSignal = signal; } ++cmd.okcount; if (cmd.okcount > 4) { - eDebugNoSimulate("ok > 4 .. goto %d\n",cmd.steps); + eDebugNoSimulate("ok > 4 .. goto %d\n", cmd.steps); setSecSequencePos(cmd.steps); m_state = stateLock; m_stateChanged(this); - feEvent(-1); + feEvent(-1); // flush events m_sn->start(); break; } @@ -1657,9 +1668,6 @@ void eDVBFrontend::tuneLoop() // called by m_tuneTimer eDebugNoSimulate("[SEC] rotor locked step %d failed (oldSignal %d, curSignal %d)", cmd.okcount, signal, cmd.lastSignal); else eDebugNoSimulate("[SEC] rotor locked step %d failed (not locked)", cmd.okcount); - --m_timeoutCount; - if (!m_timeoutCount && m_retryCount > 0) - --m_retryCount; cmd.okcount=0; cmd.lastSignal=0; } @@ -1691,6 +1699,9 @@ void eDVBFrontend::tuneLoop() // called by m_tuneTimer } int idleInputpower = m_idleInputpower[ (sec_fe_data[CUR_VOLTAGE]&1) ? 0 : 1]; const char *txt = cmd.direction ? "running" : "stopped"; + --m_timeoutCount; + if (!m_timeoutCount && m_retryCount > 0) + --m_retryCount; eDebugNoSimulate("[SEC] waiting for rotor %s %d, idle %d, delta %d", txt, m_runningInputpower, @@ -1711,9 +1722,6 @@ void eDVBFrontend::tuneLoop() // called by m_tuneTimer else { eDebugNoSimulate("[SEC] rotor not %s... reset counter.. increase timeout", txt); - --m_timeoutCount; - if (!m_timeoutCount && m_retryCount > 0) - --m_retryCount; cmd.okcount=0; } ++m_sec_sequence.current(); @@ -1829,17 +1837,80 @@ void eDVBFrontend::tuneLoop() // called by m_tuneTimer tuneLoop(); } -void eDVBFrontend::setFrontend() +void eDVBFrontend::setFrontend(bool recvEvents) { if (!m_simulate) { eDebug("setting frontend %d", m_dvbid); - m_sn->start(); - feEvent(-1); - if (ioctl(m_fd, FE_SET_FRONTEND, &parm) == -1) + if (recvEvents) + m_sn->start(); + feEvent(-1); // flush events +#if HAVE_DVB_API_VERSION >= 5 + if (m_type == iDVBFrontend::feSatellite) { - perror("FE_SET_FRONTEND failed"); - return; + fe_rolloff_t rolloff = ROLLOFF_35; + fe_pilot_t pilot = PILOT_OFF; + fe_modulation_t modulation = QPSK; + fe_delivery_system_t system = SYS_DVBS; + switch(oparm.sat.system) + { + case eDVBFrontendParametersSatellite::System_DVB_S: system = SYS_DVBS; break; + case eDVBFrontendParametersSatellite::System_DVB_S2: system = SYS_DVBS2; break; + }; + switch(oparm.sat.modulation) + { + case eDVBFrontendParametersSatellite::Modulation_QPSK: modulation = QPSK; break; + case eDVBFrontendParametersSatellite::Modulation_8PSK: modulation = PSK_8; break; + case eDVBFrontendParametersSatellite::Modulation_QAM16: modulation = QAM_16; break; + }; + switch(oparm.sat.pilot) + { + case eDVBFrontendParametersSatellite::Pilot_Off: pilot = PILOT_OFF; break; + case eDVBFrontendParametersSatellite::Pilot_On: pilot = PILOT_ON; break; + case eDVBFrontendParametersSatellite::Pilot_Unknown: pilot = PILOT_AUTO; break; + }; + switch(oparm.sat.rolloff) + { + case eDVBFrontendParametersSatellite::RollOff_alpha_0_20: rolloff = ROLLOFF_20; break; + case eDVBFrontendParametersSatellite::RollOff_alpha_0_25: rolloff = ROLLOFF_25; break; + case eDVBFrontendParametersSatellite::RollOff_alpha_0_35: rolloff = ROLLOFF_35; break; + }; + struct dtv_property p[10]; + struct dtv_properties cmdseq; + cmdseq.props = p; + p[0].cmd = DTV_CLEAR; + p[1].cmd = DTV_DELIVERY_SYSTEM, p[1].u.data = system; + p[2].cmd = DTV_FREQUENCY, p[2].u.data = parm_frequency; + p[3].cmd = DTV_MODULATION, p[3].u.data = modulation; + p[4].cmd = DTV_SYMBOL_RATE, p[4].u.data = parm_u_qpsk_symbol_rate; + p[5].cmd = DTV_INNER_FEC, p[5].u.data = parm_u_qpsk_fec_inner; + p[6].cmd = DTV_INVERSION, p[6].u.data = parm_inversion; + if (system == SYS_DVBS2) + { + p[7].cmd = DTV_ROLLOFF, p[7].u.data = rolloff; + p[8].cmd = DTV_PILOT, p[8].u.data = pilot; + p[9].cmd = DTV_TUNE; + cmdseq.num = 10; + } + else + { + p[7].cmd = DTV_TUNE; + cmdseq.num = 8; + } + if (ioctl(m_fd, FE_SET_PROPERTY, &cmdseq) == -1) + { + perror("FE_SET_PROPERTY failed"); + return; + } + } + else +#endif + { + if (ioctl(m_fd, FE_SET_FRONTEND, &parm) == -1) + { + perror("FE_SET_FRONTEND failed"); + return; + } } } } @@ -1889,86 +1960,91 @@ 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; } + } #if HAVE_DVB_API_VERSION >= 3 else // DVB_S2 { 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: eDebugNoSimulate("no valid fec for DVB-S2 set.. abort !!"); return -EINVAL; } +#if HAVE_DVB_API_VERSION < 5 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 } +#endif } #endif // FIXME !!! get frequency range from tuner @@ -1979,6 +2055,7 @@ RESULT eDVBFrontend::prepare_sat(const eDVBFrontendParametersSatellite &feparm, } eDebugNoSimulate("tuning to %d mhz", parm_frequency/1000); } + oparm.sat = feparm; return res; } @@ -1992,66 +2069,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; } @@ -2061,6 +2138,7 @@ RESULT eDVBFrontend::prepare_cable(const eDVBFrontendParametersCable &feparm) parm_u_qam_fec_inner, parm_u_qam_modulation, parm_inversion); + oparm.cab = feparm; return 0; } @@ -2070,144 +2148,145 @@ 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; } + oparm.ter = feparm; return 0; } @@ -2272,7 +2351,7 @@ RESULT eDVBFrontend::tune(const iDVBFrontendParameters &where) goto tune_error; m_sec_sequence.push_back( eSecCommand(eSecCommand::START_TUNE_TIMEOUT, timeout) ); - m_sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND) ); + m_sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND, 1) ); break; } case feTerrestrial: @@ -2297,7 +2376,7 @@ RESULT eDVBFrontend::tune(const iDVBFrontendParameters &where) m_sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, iDVBFrontend::voltage13) ); else m_sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, iDVBFrontend::voltageOff) ); - m_sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND) ); + m_sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND, 1) ); break; } @@ -2514,10 +2593,10 @@ int eDVBFrontend::isCompatibleWith(ePtr &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; }