} else if (state == iDVBFrontend::stateLostLock)
{
/* on managed channels, we try to retune in order to re-acquire lock. */
- if (m_feparm)
+ if (m_current_frontend_parameters)
{
eDebug("OURSTATE: lost lock, trying to retune");
ourstate = state_tuning;
- m_frontend->get().tune(*m_feparm);
+ m_frontend->get().tune(*m_current_frontend_parameters);
} else
/* on unmanaged channels, we don't do this. the client will do this. */
{
/* if tuning fails, shutdown the channel immediately. */
int res;
res = m_frontend->get().tune(*feparm);
- m_feparm = feparm;
+ m_current_frontend_parameters = feparm;
if (res)
{
frontend = &m_frontend->get();
if (frontend)
return 0;
- else
- return -ENODEV;
+ return -ENODEV;
+}
+
+RESULT eDVBChannel::getCurrentFrontendParameters(ePtr<iDVBFrontendParameters> ¶m)
+{
+ param = m_current_frontend_parameters;
+ return 0;
}
RESULT eDVBChannel::playFile(const char *file)
RESULT setCIRouting(const eDVBCIRouting &routing);
RESULT getDemux(ePtr<iDVBDemux> &demux, int cap);
RESULT getFrontend(ePtr<iDVBFrontend> &frontend);
-
+ RESULT getCurrentFrontendParameters(ePtr<iDVBFrontendParameters> ¶m);
+
/* iDVBPVRChannel */
RESULT playFile(const char *file);
void stopFile();
int getUseCount() { return m_use_count; }
private:
- ePtr<iDVBFrontendParameters> m_feparm; // for retune on lostlock
ePtr<eDVBAllocatedFrontend> m_frontend;
ePtr<eDVBAllocatedDemux> m_demux, m_decoder_demux;
#define GUARD_INTERVAL_AUTO (GuardInterval)4
#define HIERARCHY_AUTO (Hierarchy)4
#define parm.frequency parm.Frequency
+#define parm.inversion parm.Inversion
+#define parm.u.qpsk.symbol_rate parm.u.qpsk.SymbolRate
+#define parm.u.qpsk.fec_inner parm.u.qpsk.FEC_inner
#define parm.u.qam.symbol_rate parm.u.qam.SymbolRate
#define parm.u.qam.fec_inner parm.u.qam.FEC_inner
#define parm.u.qam.modulation parm.u.qam.QAM
#define parm.u.ofdm.transmission_mode parm.u.ofdm.TransmissionMode
#define parm.u.ofdm.guard_interval parm.u.ofdm.guardInterval
#define parm.u.ofdm.hierarchy_information parm.u.ofdm.HierarchyInformation
-#define parm.inversion parm.Inversion
#else
#include <linux/dvb/frontend.h>
#endif
return 0;
}
-PyObject *eDVBFrontend::readTransponderData()
+void PutToDict(PyObject *dict, const char*key, long value)
{
- Py_INCREF(Py_None);
- return Py_None;
+ PyObject *item = PyInt_FromLong(value);
+ if (item)
+ {
+ if (PyDict_SetItemString(dict, key, item))
+ eDebug("put %s to dict failed", key);
+ Py_DECREF(item);
+ }
+ else
+ eDebug("could not create PyObject for %s", key);
+}
+
+void PutToDict(PyObject *dict, const char*key, const char *value)
+{
+ PyObject *item = PyString_FromString(value);
+ if (item)
+ {
+ if (PyDict_SetItemString(dict, key, item))
+ eDebug("put %s to dict failed", key);
+ Py_DECREF(item);
+ }
+ else
+ eDebug("could not create PyObject for %s", key);
+}
+
+void fillDictWithSatelliteData(PyObject *dict, const FRONTENDPARAMETERS &parm, eDVBFrontend *fe)
+{
+ int freq_offset=0;
+ int csw=0;
+ fe->getData(0, csw);
+ fe->getData(9, freq_offset);
+ int frequency = parm.frequency + freq_offset;
+ PutToDict(dict, "frequency", frequency);
+ PutToDict(dict, "inversion", parm.inversion);
+ PutToDict(dict, "symbol_rate", parm.u.qpsk.symbol_rate);
+ const char *fec=0;
+ switch(parm.u.qpsk.fec_inner)
+ {
+ case FEC_1_2:
+ fec = "FEC_1_2";
+ break;
+ case FEC_2_3:
+ fec = "FEC_2_3";
+ break;
+ case FEC_3_4:
+ fec = "FEC_3_4";
+ break;
+ case FEC_5_6:
+ fec = "FEC_5_6";
+ break;
+ case FEC_7_8:
+ fec = "FEC_7_8";
+ break;
+ default:
+ case FEC_AUTO:
+ fec = "FEC_AUTO";
+ break;
+ }
+ PutToDict(dict, "fec_inner", fec);
+}
+
+void fillDictWithCableData(PyObject *dict, const FRONTENDPARAMETERS &parm)
+{
+/*
+#define parm.frequency parm.Frequency
+#define parm.inversion parm.Inversion
+#define parm.u.qam.symbol_rate parm.u.qam.SymbolRate
+#define parm.u.qam.fec_inner parm.u.qam.FEC_inner
+#define parm.u.qam.modulation parm.u.qam.QAM
+*/
+}
+
+void fillDictWithTerrestrialData(PyObject *dict, const FRONTENDPARAMETERS &parm)
+{
+/*
+#define parm.frequency parm.Frequency
+#define parm.inversion parm.Inversion
+#define parm.u.ofdm.bandwidth parm.u.ofdm.bandWidth
+#define parm.u.ofdm.code_rate_LP parm.u.ofdm.LP_CodeRate
+#define parm.u.ofdm.code_rate_HP parm.u.ofdm.HP_CodeRate
+#define parm.u.ofdm.constellation parm.u.ofdm.Constellation
+#define parm.u.ofdm.transmission_mode parm.u.ofdm.TransmissionMode
+#define parm.u.ofdm.guard_interval parm.u.ofdm.guardInterval
+#define parm.u.ofdm.hierarchy_information parm.u.ofdm.HierarchyInformation
+*/
+}
+
+PyObject *eDVBFrontend::readTransponderData(bool original)
+{
+ PyObject *ret=PyDict_New();
+
+ if (ret)
+ {
+ bool read=m_fd != -1;
+ const char *tmp = "unknown";
+
+ PutToDict(ret, "tuner number", m_fe);
+
+ switch(m_type)
+ {
+ case feSatellite:
+ tmp = "DVB-S";
+ break;
+ case feCable:
+ tmp="DVB-C";
+ break;
+ case feTerrestrial:
+ tmp="DVB-T";
+ break;
+ default:
+ read=false;
+ break;
+ }
+ PutToDict(ret, "tuner type", tmp);
+
+ if (read)
+ {
+ FRONTENDPARAMETERS front;
+
+ tmp = "unknown";
+ switch(m_state)
+ {
+ case stateIdle:
+ tmp="idle";
+ break;
+ case stateTuning:
+ tmp="tuning";
+ break;
+ case stateFailed:
+ tmp="failed";
+ break;
+ case stateLock:
+ tmp="lock";
+ break;
+ case stateLostLock:
+ tmp="lostlock";
+ break;
+ default:
+ break;
+ }
+ PutToDict(ret, "tuner state", tmp);
+
+ PutToDict(ret, "tuner locked", readFrontendData(Locked));
+ PutToDict(ret, "tuner synced", readFrontendData(Synced));
+ PutToDict(ret, "tuner bit_error_rate", readFrontendData(bitErrorRate));
+ PutToDict(ret, "tuner signal_power", readFrontendData(signalPower));
+ PutToDict(ret, "tuner signal_quality", readFrontendData(signalQuality));
+
+ if (!original && ioctl(m_fd, FE_GET_FRONTEND, &front)<0)
+ eDebug("FE_GET_FRONTEND (%m)");
+ else
+ {
+ switch(m_type)
+ {
+ case feSatellite:
+ fillDictWithSatelliteData(ret, original?parm:front, this);
+ break;
+ case feCable:
+ fillDictWithCableData(ret, original?parm:front);
+ break;
+ case feTerrestrial:
+ fillDictWithTerrestrialData(ret, original?parm:front);
+ break;
+ }
+ }
+ }
+ }
+ else
+ {
+ Py_INCREF(Py_None);
+ ret = Py_None;
+ }
+ return ret;
}
#ifndef FP_IOCTL_GET_ID
}
res = m_sec->prepare(*this, parm, feparm, 1 << m_fe);
if (!res)
+ {
+ parm.u.qpsk.symbol_rate = feparm.symbol_rate;
+ switch (feparm.inversion)
+ {
+ case eDVBFrontendParametersSatellite::Inversion::On:
+ parm.inversion = INVERSION_ON;
+ break;
+ case eDVBFrontendParametersSatellite::Inversion::Off:
+ parm.inversion = INVERSION_OFF;
+ break;
+ default:
+ case eDVBFrontendParametersSatellite::Inversion::Unknown:
+ parm.inversion = INVERSION_AUTO;
+ break;
+ }
+ switch (feparm.fec)
+ {
+ default:
+ case eDVBFrontendParametersSatellite::FEC::fNone:
+ eDebug("no fec set.. assume auto");
+ case eDVBFrontendParametersSatellite::FEC::fAuto:
+ parm.u.qpsk.fec_inner = FEC_AUTO;
+ break;
+ case eDVBFrontendParametersSatellite::FEC::f1_2:
+ parm.u.qpsk.fec_inner = FEC_1_2;
+ break;
+ case eDVBFrontendParametersSatellite::FEC::f2_3:
+ parm.u.qpsk.fec_inner = FEC_2_3;
+ break;
+ case eDVBFrontendParametersSatellite::FEC::f3_4:
+ parm.u.qpsk.fec_inner = FEC_3_4;
+ break;
+ case eDVBFrontendParametersSatellite::FEC::f5_6:
+ parm.u.qpsk.fec_inner = FEC_5_6;
+ break;
+ case eDVBFrontendParametersSatellite::FEC::f7_8:
+ parm.u.qpsk.fec_inner = FEC_7_8;
+ break;
+ }
eDebug("tuning to %d mhz", parm.frequency/1000);
+ }
return res;
}
eSecCommandList m_sec_sequence;
- int m_data[9]; /* when satellite frontend then
+ int m_data[10]; /* when satellite frontend then
data[0] = lastcsw -> state of the committed switch
data[1] = lastucsw -> state of the uncommitted switch
data[2] = lastToneburst -> current state of toneburst switch
data[5] = curRotorCmd
data[6] = curRotorPos
data[7] = linkedToTunerNo
- data[8] = dependsToTunerNo (just satpos.. for rotor with twin lnb) */
+ data[8] = dependsToTunerNo (just satpos.. for rotor with twin lnb)
+ data[9] = previousFrequencyOffset */
int m_idleInputpower[2]; // 13V .. 18V
int m_runningInputpower;
RESULT setData(int num, int val);
int readFrontendData(int type); // bitErrorRate, signalPower, signalQuality, Locked, Synced
- PyObject *readTransponderData();
+ PyObject *readTransponderData(bool original);
int isCompatibleWith(ePtr<iDVBFrontendParameters> &feparm);
int getID() { return m_fe; }
bitErrorRate, signalPower, signalQuality, Locked, Synced
};
virtual int readFrontendData(int type)=0;
- virtual PyObject *readTransponderData()=0;
+ virtual PyObject *readTransponderData(bool original)=0;
virtual RESULT getData(int num, int &data)=0;
virtual RESULT setData(int num, int val)=0;
/* direct frontend access for raw channels and/or status inquiries. */
virtual RESULT getFrontend(ePtr<iDVBFrontend> &frontend)=0;
+ virtual RESULT getCurrentFrontendParameters(ePtr<iDVBFrontendParameters> &)=0;
/* use count handling */
virtual void AddUse() = 0;
#include <lib/dvb/rotor_calc.h>
#if HAVE_DVB_API_VERSION < 3
-#define INVERSION Inversion
#define FREQUENCY Frequency
-#define FEC_INNER FEC_inner
-#define SYMBOLRATE SymbolRate
#else
-#define INVERSION inversion
#define FREQUENCY frequency
-#define FEC_INNER fec_inner
-#define SYMBOLRATE symbol_rate
#endif
#include <lib/base/eerror.h>
if ( sat.frequency > lnb_param.m_lof_threshold )
band |= 1;
- if (sat.polarisation == eDVBFrontendParametersSatellite::Polarisation::Horizontal)
+ if (!(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical))
band |= 2;
bool rotor=false;
parm.FREQUENCY = abs(parm.FREQUENCY);
- if (sat.polarisation == eDVBFrontendParametersSatellite::Polarisation::Horizontal)
- band |= 2;
-
- switch (sat.inversion)
- {
- case eDVBFrontendParametersCable::Inversion::On:
- parm.INVERSION = INVERSION_ON;
- break;
- case eDVBFrontendParametersCable::Inversion::Off:
- parm.INVERSION = INVERSION_OFF;
- break;
- default:
- case eDVBFrontendParametersCable::Inversion::Unknown:
- parm.INVERSION = INVERSION_AUTO;
- break;
- }
+ frontend.setData(9, sat.frequency - parm.FREQUENCY);
- switch (sat.fec)
- {
- default:
- case eDVBFrontendParametersSatellite::FEC::fNone:
- eDebug("no fec set.. assume auto");
- case eDVBFrontendParametersSatellite::FEC::fAuto:
- parm.u.qpsk.FEC_INNER = FEC_AUTO;
- break;
- case eDVBFrontendParametersSatellite::FEC::f1_2:
- parm.u.qpsk.FEC_INNER = FEC_1_2;
- break;
- case eDVBFrontendParametersSatellite::FEC::f2_3:
- parm.u.qpsk.FEC_INNER = FEC_2_3;
- break;
- case eDVBFrontendParametersSatellite::FEC::f3_4:
- parm.u.qpsk.FEC_INNER = FEC_3_4;
- break;
- case eDVBFrontendParametersSatellite::FEC::f5_6:
- parm.u.qpsk.FEC_INNER = FEC_5_6;
- break;
- case eDVBFrontendParametersSatellite::FEC::f7_8:
- parm.u.qpsk.FEC_INNER = FEC_7_8;
- break;
- }
-
- parm.u.qpsk.SYMBOLRATE = sat.symbol_rate;
+ if (!(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical))
+ band |= 2;
if ( sw_param.m_voltage_mode == eDVBSatelliteSwitchParameters::_14V
- || ( sat.polarisation == eDVBFrontendParametersSatellite::Polarisation::Vertical
+ || ( sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical
&& sw_param.m_voltage_mode == eDVBSatelliteSwitchParameters::HV ) )
voltage = VOLTAGE(13);
else if ( sw_param.m_voltage_mode == eDVBSatelliteSwitchParameters::_18V
- || ( sat.polarisation == eDVBFrontendParametersSatellite::Polarisation::Horizontal
+ || ( !(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical)
&& sw_param.m_voltage_mode == eDVBSatelliteSwitchParameters::HV ) )
voltage = VOLTAGE(18);
if ( (sw_param.m_22khz_signal == eDVBSatelliteSwitchParameters::ON)
SyncState
};
virtual int getFrontendInfo(int w)=0;
- virtual PyObject *getFrontendTransponderData()=0;
+ virtual PyObject *getFrontendData(bool original=false)=0;
};
TEMPLATE_TYPEDEF(ePtr<iFrontendStatusInformation>, iFrontendStatusInformationPtr);
return fe->readFrontendData(w);
}
-PyObject *eDVBServicePlay::getFrontendTransponderData()
+PyObject *eDVBServicePlay::getFrontendData(bool original)
{
PyObject *ret=0;
{
ePtr<iDVBFrontend> fe;
if(!channel->getFrontend(fe))
- ret = fe->readTransponderData();
+ {
+ ret = fe->readTransponderData(original);
+ if (ret)
+ {
+ ePtr<iDVBFrontendParameters> feparm;
+ channel->getCurrentFrontendParameters(feparm);
+ if (feparm)
+ {
+ eDVBFrontendParametersSatellite osat;
+ if (!feparm->getDVBS(osat))
+ {
+ void PutToDict(PyObject *dict, const char*key, long value);
+ 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", osat.polarisation);
+ }
+ }
+ }
+ }
}
-
if (!ret)
{
ret = Py_None;
// iFrontendStatusInformation
int getFrontendInfo(int w);
- PyObject *getFrontendTransponderData();
+ PyObject *getFrontendData(bool);
// iSubserviceList
int getNumberOfSubservices();
projects / vuplus_dvbapp / commitdiff