X-Git-Url: https://git.cweiske.de/enigma2.git/blobdiff_plain/1aeefd997cc362c3b37c1587c5f08891b35c3a75..b6bb02750e7e7e44d6c4e99a9754006a1e1051e5:/lib/dvb/idvb.h diff --git a/lib/dvb/idvb.h b/lib/dvb/idvb.h index a69f170f..d5f399c0 100644 --- a/lib/dvb/idvb.h +++ b/lib/dvb/idvb.h @@ -1,13 +1,97 @@ #ifndef __dvb_idvb_h #define __dvb_idvb_h +#ifndef SWIG + +#if HAVE_DVB_API_VERSION < 3 +#include +#define FRONTENDPARAMETERS FrontendParameters +#else +#include +#include +#define FRONTENDPARAMETERS struct dvb_frontend_parameters +#endif +#include #include #include +#include #include #include #include - // bitte KEINE operator int() definieren, sonst bringt das ganze nix! +#if defined(__GNUC__) && ((__GNUC__ == 3 && __GNUC_MINOR__ >= 1) || __GNUC__ == 4 ) // check if gcc version >= 3.1 +#include +#define CAID_LIST __gnu_cxx::slist +#else +#include +#define CAID_LIST std::slist +#endif + +#ifndef DMX_FILTER_SIZE +#define DMX_FILTER_SIZE 16 +#endif + +struct eDVBSectionFilterMask +{ + int pid; + /* mode is 0 for positive, 1 for negative filtering */ + __u8 data[DMX_FILTER_SIZE], mask[DMX_FILTER_SIZE], mode[DMX_FILTER_SIZE]; + enum { + rfCRC=1, + rfNoAbort=2 + }; + int flags; +}; + +struct eDVBTableSpec +{ + int pid, tid, tidext, tid_mask, tidext_mask; + int version; + int timeout; /* timeout in ms */ + enum + { + tfInOrder=1, + /* + tfAnyVersion filter ANY version + 0 filter all EXCEPT given version (negative filtering) + tfThisVersion filter only THIS version + */ + tfAnyVersion=2, + tfThisVersion=4, + tfHaveTID=8, + tfHaveTIDExt=16, + tfCheckCRC=32, + tfHaveTimeout=64, + tfHaveTIDMask=128, + tfHaveTIDExtMask=256 + }; + int flags; +}; + +struct eBouquet +{ + std::string m_bouquet_name; + std::string m_filename; // without path.. just name + typedef std::list list; + list m_services; +// the following five methods are implemented in db.cpp + RESULT flushChanges(); + RESULT addService(const eServiceReference &, eServiceReference before=eServiceReference()); + RESULT removeService(const eServiceReference &); + RESULT moveService(const eServiceReference &, unsigned int); + RESULT setListName(const std::string &name); +}; + + /* these structures have by intention no operator int() defined. + the reason of these structures is to avoid mixing for example + a onid and a tsid (as there's no general order for them). + + defining an operator int() would implicitely convert values + between them over the constructor with the int argument. + + 'explicit' doesn't here - eTransportStreamID(eOriginalNetworkID(n)) + would still work. */ + struct eTransportStreamID { private: @@ -69,6 +153,14 @@ struct eDVBChannelID eDVBNamespace dvbnamespace; eTransportStreamID transport_stream_id; eOriginalNetworkID original_network_id; + + bool operator==(const eDVBChannelID &c) const + { + return dvbnamespace == c.dvbnamespace && + transport_stream_id == c.transport_stream_id && + original_network_id == c.original_network_id; + } + bool operator<(const eDVBChannelID &c) const { if (dvbnamespace < c.dvbnamespace) @@ -114,6 +206,26 @@ struct eServiceReferenceDVB: public eServiceReference eDVBNamespace getDVBNamespace() const { return eDVBNamespace(data[4]); } void setDVBNamespace(eDVBNamespace dvbnamespace) { data[4]=dvbnamespace.get(); } + eServiceID getParentServiceID() const { return eServiceID(data[5]); } + void setParentServiceID( eServiceID sid ) { data[5]=sid.get(); } + + eTransportStreamID getParentTransportStreamID() const { return eTransportStreamID(data[6]); } + void setParentTransportStreamID( eTransportStreamID tsid ) { data[6]=tsid.get(); } + + eServiceReferenceDVB getParentServiceReference() const + { + eServiceReferenceDVB tmp(*this); + if (data[5] && data[6]) + { + tmp.data[1] = data[5]; + tmp.data[2] = data[6]; + tmp.data[5] = tmp.data[6] = 0; + } + else + tmp.type = idInvalid; + return tmp; + } + eServiceReferenceDVB(eDVBNamespace dvbnamespace, eTransportStreamID transport_stream_id, eOriginalNetworkID original_network_id, eServiceID service_id, int service_type) :eServiceReference(eServiceReference::idDVB, 0) { @@ -131,7 +243,7 @@ struct eServiceReferenceDVB: public eServiceReference setTransportStreamID(chid.transport_stream_id); } - void getChannelID(eDVBChannelID &chid) + void getChannelID(eDVBChannelID &chid) const { chid = eDVBChannelID(getDVBNamespace(), getTransportStreamID(), getOriginalNetworkID()); } @@ -140,192 +252,403 @@ struct eServiceReferenceDVB: public eServiceReference :eServiceReference(eServiceReference::idDVB, 0) { } + + eServiceReferenceDVB(const std::string &string) + :eServiceReference(string) + { + } }; -class iDVBChannel; -class iDVBDemux; -class iDVBFrontendParameters; +////////////////// TODO: we need an interface here, but what exactly? -class iDVBChannelList: public iObject +#include +// btw, still implemented in db.cpp. FIX THIS, TOO. + +class eDVBChannelQuery; + +class eDVBService: public iStaticServiceInformation { + DECLARE_REF(eDVBService); + int *m_cache; + void initCache(); + void copyCache(int *source); public: - virtual RESULT getChannelFrontendData(const eDVBChannelID &id, ePtr &parm)=0; + enum cacheID + { + cVPID, cAPID, cTPID, cPCRPID, cAC3PID, + cVTYPE, cACHANNEL, cAC3DELAY, cPCMDELAY, + cSUBTITLE, cacheMax + }; + + int getCacheEntry(cacheID); + void setCacheEntry(cacheID, int); + + bool cacheEmpty(); + + eDVBService(); + /* m_service_name_sort is uppercase, with special chars removed, to increase sort performance. */ + std::string m_service_name, m_service_name_sort; + std::string m_provider_name; + + void genSortName(); + + int m_flags; + enum + { + dxNoSDT=1, // don't get SDT +//nyi dxDontshow=2, + dxNoDVB=4, // dont use PMT for this service ( use cached pids ) + dxHoldName=8, + dxNewFound=64, + }; + + bool usePMT() const { return !(m_flags & dxNoDVB); } + + CAID_LIST m_ca; + + virtual ~eDVBService(); + + eDVBService &operator=(const eDVBService &); + + // iStaticServiceInformation + RESULT getName(const eServiceReference &ref, std::string &name); + RESULT getEvent(const eServiceReference &ref, ePtr &ptr, time_t start_time); + int isPlayable(const eServiceReference &ref, const eServiceReference &ignore); + PyObject *getInfoObject(const eServiceReference &ref, int); // implemented in lib/service/servicedvb.h + + /* for filtering: */ + int checkFilter(const eServiceReferenceDVB &ref, const eDVBChannelQuery &query); }; -class iDVBResourceManager: public iObject +////////////////// + +class iDVBChannel; +class iDVBDemux; +class iDVBFrontendParameters; + +class iDVBChannelListQuery: public iObject { public: - /* - solange rumloopen bis eine resource gefunden wurde, die eine frequenz - tunen will - - wenn natuerlich sowas schon vorhanden ist, dann einfach ne ref darauf - geben. (zwei services auf dem gleichen transponder teilen sich einen - channel) - */ - virtual RESULT setChannelList(iDVBChannelList *list)=0; - virtual RESULT getChannelList(ePtr &list)=0; - virtual RESULT allocateChannel(const eDVBChannelID &channel, ePtr &channel)=0; - virtual RESULT allocateRawChannel(ePtr &channel)=0; - virtual RESULT allocatePVRChannel(int caps)=0; + virtual RESULT getNextResult(eServiceReferenceDVB &ref)=0; + virtual int compareLessEqual(const eServiceReferenceDVB &a, const eServiceReferenceDVB &b)=0; }; -class SatelliteDeliverySystemDescriptor; -class CableDeliverySystemDescriptor; -class TerrestrialDeliverySystemDescriptor; - -struct eDVBFrontendParametersSatellite +class eDVBChannelQuery: public iObject { - struct Polarisation - { - enum { - Horizontal, Vertical, CircularLeft, CircularRight - }; - }; - struct Inversion - { - enum { - On, Off, Unknown - }; - }; - struct FEC + DECLARE_REF(eDVBChannelQuery); +public: + enum { - enum { - fNone, f1_2, f2_3, f3_4, f5_6, f7_8, fAuto - }; + tName, + tProvider, + tType, + tBouquet, + tSatellitePosition, + tChannelID, + tAND, + tOR, + tAny, + tFlags }; - unsigned int frequency, symbol_rate; - int polarisation, fec, inversion, orbital_position; - void set(const SatelliteDeliverySystemDescriptor &); + int m_type; + int m_inverse; + + std::string m_string; + int m_int; + eDVBChannelID m_channelid; + + /* sort is only valid in root, and must be from the enum above. */ + int m_sort; + std::string m_bouquet_name; + + static RESULT compile(ePtr &res, std::string query); + + ePtr m_p1, m_p2; }; -struct eDVBFrontendParametersCable +class iDVBChannelList: public iObject { - unsigned int frequency, symbol_rate; - int modulation, inversion, fec_inner; - void set(const CableDeliverySystemDescriptor &); -}; +public: + virtual RESULT removeService(const eServiceReference &service)=0; + virtual RESULT removeServices(eDVBChannelID chid=eDVBChannelID(), unsigned int orb_pos=0xFFFFFFFF)=0; + virtual RESULT removeServices(int dvb_namespace=-1, int tsid=-1, int onid=-1, unsigned int orb_pos=0xFFFFFFFF)=0; + virtual RESULT addFlag(const eServiceReference &service, unsigned int flagmask=0xFFFFFFFF)=0; + virtual RESULT removeFlag(const eServiceReference &service, unsigned int flagmask=0xFFFFFFFF)=0; + virtual RESULT removeFlags(unsigned int flagmask, eDVBChannelID chid=eDVBChannelID(), unsigned int orb_pos=0xFFFFFFFF)=0; + virtual RESULT removeFlags(unsigned int flagmask, int dvb_namespace=-1, int tsid=-1, int onid=-1, unsigned int orb_pos=0xFFFFFFFF)=0; + virtual RESULT addChannelToList(const eDVBChannelID &id, iDVBFrontendParameters *feparm)=0; + virtual RESULT removeChannel(const eDVBChannelID &id)=0; + + virtual RESULT getChannelFrontendData(const eDVBChannelID &id, ePtr &parm)=0; + + virtual RESULT addService(const eServiceReferenceDVB &service, eDVBService *service)=0; + virtual RESULT getService(const eServiceReferenceDVB &reference, ePtr &service)=0; + virtual RESULT flush()=0; -struct eDVBFrontendParametersTerrestrial -{ - int unknown; - void set(const TerrestrialDeliverySystemDescriptor &); + virtual RESULT getBouquet(const eServiceReference &ref, eBouquet* &bouquet)=0; + + virtual RESULT startQuery(ePtr &query, eDVBChannelQuery *query, const eServiceReference &source)=0; }; +#endif // SWIG + class iDVBFrontendParameters: public iObject { +#ifdef SWIG + iDVBFrontendParameters(); + ~iDVBFrontendParameters(); +#endif public: - virtual RESULT getSystem(int &type) const = 0; - virtual RESULT getDVBS(eDVBFrontendParametersSatellite &p) const = 0; - virtual RESULT getDVBC(eDVBFrontendParametersCable &p) const = 0; - virtual RESULT getDVBT(eDVBFrontendParametersTerrestrial &p) const = 0; + virtual RESULT getSystem(int &SWIG_OUTPUT) const = 0; + virtual RESULT getDVBS(eDVBFrontendParametersSatellite &SWIG_OUTPUT) const = 0; + virtual RESULT getDVBC(eDVBFrontendParametersCable &SWIG_OUTPUT) const = 0; + virtual RESULT getDVBT(eDVBFrontendParametersTerrestrial &SWIG_OUTPUT) const = 0; - virtual RESULT calculateDifference(const iDVBFrontendParameters *parm, int &diff) const = 0; - virtual RESULT getHash(unsigned long &hash) const = 0; + virtual RESULT calculateDifference(const iDVBFrontendParameters *parm, int &SWIG_OUTPUT, bool exact) const = 0; + virtual RESULT getHash(unsigned long &SWIG_OUTPUT) const = 0; }; #define MAX_DISEQC_LENGTH 16 -struct eDVBDiseqcCommand +class eDVBDiseqcCommand { +#ifndef SWIG +public: +#endif int len; __u8 data[MAX_DISEQC_LENGTH]; +#if HAVE_DVB_API_VERSION < 3 + int tone; + int voltage; +#endif +#ifdef SWIG +public: +#endif + void setCommandString(const char *str); }; class iDVBSatelliteEquipmentControl; +class eSecCommandList; -class iDVBFrontend: public iObject +class iDVBFrontend_ENUMS { +#ifdef SWIG + iDVBFrontend_ENUMS(); + ~iDVBFrontend_ENUMS(); +#endif public: - enum { - feSatellite, feCable, feTerrestrial - }; - virtual RESULT getFrontendType(int &type)=0; + enum { feSatellite, feCable, feTerrestrial }; + enum { stateIdle, stateTuning, stateFailed, stateLock, stateLostLock }; + enum { toneOff, toneOn }; + enum { voltageOff, voltage13, voltage18, voltage13_5, voltage18_5 }; + enum { bitErrorRate, signalPower, signalQuality, locked, synced, frontendNumber }; +}; + +SWIG_IGNORE(iDVBFrontend); +class iDVBFrontend: public iDVBFrontend_ENUMS, public iObject +{ +public: + virtual RESULT getFrontendType(int &SWIG_OUTPUT)=0; virtual RESULT tune(const iDVBFrontendParameters &where)=0; +#ifndef SWIG virtual RESULT connectStateChange(const Slot1 &stateChange, ePtr &connection)=0; - enum { - stateIdle = 0, - stateTuning = 1, - stateFailed = 2, - stateLock = 3 - }; - virtual RESULT getState(int &state)=0; - enum { - toneOn, toneOff - }; +#endif + virtual RESULT getState(int &SWIG_OUTPUT)=0; virtual RESULT setTone(int tone)=0; - enum { - voltageOff, voltage13, voltage18 - }; virtual RESULT setVoltage(int voltage)=0; virtual RESULT sendDiseqc(const eDVBDiseqcCommand &diseqc)=0; + virtual RESULT sendToneburst(int burst)=0; +#ifndef SWIG virtual RESULT setSEC(iDVBSatelliteEquipmentControl *sec)=0; + virtual RESULT setSecSequence(const eSecCommandList &list)=0; +#endif + virtual int readFrontendData(int type)=0; + virtual PyObject *readTransponderData(bool original)=0; +#ifndef SWIG + virtual RESULT getData(int num, int &data)=0; + virtual RESULT setData(int num, int val)=0; + /* 0 means: not compatible. other values are a priority. */ + virtual int isCompatibleWith(ePtr &feparm)=0; +#endif }; +SWIG_TEMPLATE_TYPEDEF(ePtr, iDVBFrontendPtr); +#ifndef SWIG class iDVBSatelliteEquipmentControl: public iObject { public: - virtual RESULT prepare(iDVBFrontend &frontend, struct dvb_frontend_parameters &parm, eDVBFrontendParametersSatellite &sat)=0; + virtual RESULT prepare(iDVBFrontend &frontend, FRONTENDPARAMETERS &parm, const eDVBFrontendParametersSatellite &sat, int frontend_id)=0; + virtual int canTune(const eDVBFrontendParametersSatellite &feparm, iDVBFrontend *fe, int frontend_id)=0; + virtual void setRotorMoving(bool)=0; }; struct eDVBCIRouting { int enabled; }; +#endif // SWIG +SWIG_IGNORE(iDVBChannel); class iDVBChannel: public iObject { public: + /* direct frontend access for raw channels and/or status inquiries. */ + virtual SWIG_VOID(RESULT) getFrontend(ePtr &SWIG_OUTPUT)=0; +#ifndef SWIG enum { state_idle, /* not yet tuned */ state_tuning, /* currently tuning (first time) */ + state_failed, /* tuning failed. */ state_unavailable, /* currently unavailable, will be back without further interaction */ - state_ok /* ok */ + state_ok, /* ok */ + state_last_instance, /* just one reference to this channel is left */ + state_release /* channel is being shut down. */ + }; + virtual RESULT getState(int &SWIG_OUTPUT)=0; + + virtual RESULT getCurrentFrontendParameters(ePtr &)=0; + enum + { + evtEOF, evtSOF, evtFailed }; virtual RESULT connectStateChange(const Slot1 &stateChange, ePtr &connection)=0; - virtual RESULT getState(int &state)=0; + virtual RESULT connectEvent(const Slot2 &eventChange, ePtr &connection)=0; + + /* demux capabilities */ enum { - cap_decode, - cap_ci + capDecode = 1, + /* capCI = 2 */ }; virtual RESULT setCIRouting(const eDVBCIRouting &routing)=0; - virtual RESULT getDemux(ePtr &demux)=0; + virtual RESULT getDemux(ePtr &demux, int cap=0)=0; - /* direct frontend access for raw channels and/or status inquiries. */ - virtual RESULT getFrontend(ePtr &frontend)=0; + /* use count handling */ + virtual void AddUse() = 0; + virtual void ReleaseUse() = 0; +#endif +}; +SWIG_TEMPLATE_TYPEDEF(eUsePtr, iDVBChannelPtr); + +#ifndef SWIG + /* signed, so we can express deltas. */ + +typedef long long pts_t; + +class iFilePushScatterGather; +class iTSMPEGDecoder; + + /* note that a cue sheet describes the logical positions. thus + everything is specified in pts and not file positions */ + + /* implemented in dvb.cpp */ +class eCueSheet: public iObject, public Object +{ + DECLARE_REF(eCueSheet); +public: + eCueSheet(); + + /* frontend */ + void seekTo(int relative, const pts_t &pts); + + void clear(); + void addSourceSpan(const pts_t &begin, const pts_t &end); + void commitSpans(); + + void setSkipmode(const pts_t &ratio); /* 90000 is 1:1 */ + void setDecodingDemux(iDVBDemux *demux, iTSMPEGDecoder *decoder); + + /* frontend and backend */ + eSingleLock m_lock; + + /* backend */ + enum { evtSeek, evtSkipmode, evtSpanChanged }; + RESULT connectEvent(const Slot1 &event, ePtr &connection); + + std::list > m_spans; /* begin, end */ + std::list > m_seek_requests; /* relative, delta */ + pts_t m_skipmode_ratio; + Signal1 m_event; + ePtr m_decoding_demux; + ePtr m_decoder; +}; + +class iDVBPVRChannel: public iDVBChannel +{ +public: + enum + { + state_eof = state_release + 1 /* end-of-file reached. */ + }; + + /* FIXME: there are some very ugly buffer-end and ... related problems */ + /* so this is VERY UGLY. + + ok, it's going to get better. but still...*/ + virtual RESULT playFile(const char *file) = 0; + virtual void stopFile() = 0; + + virtual void setCueSheet(eCueSheet *cuesheet) = 0; + + virtual RESULT getLength(pts_t &pts) = 0; + + /* we explicitely ask for the decoding demux here because a channel + can be shared between multiple decoders. + */ + virtual RESULT getCurrentPosition(iDVBDemux *decoding_demux, pts_t &pos, int mode) = 0; + /* skipping must be done with a cue sheet */ }; class iDVBSectionReader; +class iDVBPESReader; +class iDVBTSRecorder; class iTSMPEGDecoder; class iDVBDemux: public iObject { public: virtual RESULT createSectionReader(eMainloop *context, ePtr &reader)=0; - virtual RESULT getMPEGDecoder(ePtr &reader)=0; + virtual RESULT createPESReader(eMainloop *context, ePtr &reader)=0; + virtual RESULT createTSRecorder(ePtr &recorder)=0; + virtual RESULT getMPEGDecoder(ePtr &reader, int primary=1)=0; + virtual RESULT getSTC(pts_t &pts, int num=0)=0; + virtual RESULT getCADemuxID(uint8_t &id)=0; + virtual RESULT flush()=0; }; class iTSMPEGDecoder: public iObject { public: enum { pidDisabled = -1 }; - /** Set Displayed Video PID */ - virtual RESULT setVideoPID(int vpid)=0; + /** Set Displayed Video PID and type */ + virtual RESULT setVideoPID(int vpid, int type)=0; - enum { af_MPEG, af_AC3, af_DTS }; + enum { af_MPEG, af_AC3, af_DTS, af_AAC }; /** Set Displayed Audio PID and type */ virtual RESULT setAudioPID(int apid, int type)=0; + enum { ac_left, ac_stereo, ac_right }; + /** Set Displayed Audio Channel */ + virtual RESULT setAudioChannel(int channel)=0; + virtual int getAudioChannel()=0; + + virtual RESULT setPCMDelay(int delay)=0; + virtual int getPCMDelay()=0; + virtual RESULT setAC3Delay(int delay)=0; + virtual int getAC3Delay()=0; + + /** Set Displayed Videotext PID */ + virtual RESULT setTextPID(int vpid)=0; + /** Set Sync mode to PCR */ virtual RESULT setSyncPCR(int pcrpid)=0; enum { sm_Audio, sm_Video }; /** Set Sync mode to either audio or video master */ virtual RESULT setSyncMaster(int who)=0; - + /** Apply settings */ virtual RESULT start()=0; @@ -334,6 +657,9 @@ public: /** Continue after freeze. */ virtual RESULT unfreeze()=0; + /** fast forward by skipping frames. 0 is disabled, 2 is twice-the-speed, ... */ + virtual RESULT setFastForward(int skip=0)=0; + // stop on .. Picture enum { spm_I, spm_Ref, spm_Any }; /** Stop on specific decoded picture. For I-Frame display. */ @@ -349,6 +675,25 @@ public: enum { zoom_Normal, zoom_PanScan, zoom_Letterbox, zoom_Fullscreen }; /** Set Zoom. mode *must* be fitting. */ virtual RESULT setZoom(int what)=0; + + virtual RESULT setTrickmode(int what) = 0; + + virtual RESULT getPTS(int what, pts_t &pts) = 0; + + virtual RESULT showSinglePic(const char *filename) = 0; + + virtual RESULT setRadioPic(const std::string &filename) = 0; + + struct videoEvent + { + enum { eventUnknown = 0, eventSizeChanged = VIDEO_EVENT_SIZE_CHANGED } type; + unsigned char aspect; + unsigned short height; + unsigned short width; + }; + + virtual RESULT connectVideoEvent(const Slot1 &event, ePtr &connection) = 0; }; +#endif //SWIG #endif