X-Git-Url: https://git.cweiske.de/enigma2.git/blobdiff_plain/1e830c12e59df00acb76af47a37e13fba4e1ae0b..f27bd5e1b2c49b0db87dbac70298ad33d2e4d537:/lib/dvb/epgcache.h diff --git a/lib/dvb/epgcache.h b/lib/dvb/epgcache.h index 3f1aeaed..dfd19482 100644 --- a/lib/dvb/epgcache.h +++ b/lib/dvb/epgcache.h @@ -1,6 +1,11 @@ #ifndef __epgcache_h_ #define __epgcache_h_ +#define ENABLE_PRIVATE_EPG 1 +//#define ENABLE_MHW_EPG 1 + +#ifndef SWIG + #include #include #include @@ -10,12 +15,17 @@ #include #include +#ifdef ENABLE_MHW_EPG +#include +#endif #include #include #include #include #include #include +#include +#include #define CLEAN_INTERVAL 60000 // 1 min #define UPDATE_INTERVAL 3600000 // 60 min @@ -25,14 +35,15 @@ class eventData; class eServiceReferenceDVB; +class eDVBServicePMTHandler; struct uniqueEPGKey { int sid, onid, tsid; - uniqueEPGKey( const eServiceReferenceDVB &ref ) - :sid( ref.type != eServiceReference::idInvalid ? ref.getServiceID().get() : -1 ) - ,onid( ref.type != eServiceReference::idInvalid ? ref.getOriginalNetworkID().get() : -1 ) - ,tsid( ref.type != eServiceReference::idInvalid ? ref.getTransportStreamID().get() : -1 ) + uniqueEPGKey( const eServiceReference &ref ) + :sid( ref.type != eServiceReference::idInvalid ? ((eServiceReferenceDVB&)ref).getServiceID().get() : -1 ) + ,onid( ref.type != eServiceReference::idInvalid ? ((eServiceReferenceDVB&)ref).getOriginalNetworkID().get() : -1 ) + ,tsid( ref.type != eServiceReference::idInvalid ? ((eServiceReferenceDVB&)ref).getTransportStreamID().get() : -1 ) { } uniqueEPGKey() @@ -83,8 +94,18 @@ struct hash_uniqueEPGKey #define tidMap std::set<__u32> #if defined(__GNUC__) && ((__GNUC__ == 3 && __GNUC_MINOR__ >= 1) || __GNUC__ == 4 ) // check if gcc version >= 3.1 #define eventCache __gnu_cxx::hash_map, hash_uniqueEPGKey, uniqueEPGKey::equal> + #ifdef ENABLE_PRIVATE_EPG + #define contentTimeMap __gnu_cxx::hash_map > + #define contentMap __gnu_cxx::hash_map + #define contentMaps __gnu_cxx::hash_map + #endif #else // for older gcc use following #define eventCache std::hash_map, hash_uniqueEPGKey, uniqueEPGKey::equal > + #ifdef ENABLE_PRIVATE_EPG + #define contentTimeMap std::hash_map > + #define contentMap std::hash_map + #define contentMaps std::hash_map + #endif #endif #define descriptorPair std::pair @@ -92,17 +113,18 @@ struct hash_uniqueEPGKey class eventData { - friend class eEPGCache; + friend class eEPGCache; private: __u8* EITdata; - int ByteSize; + __u8 ByteSize; + __u8 type; static descriptorMap descriptors; -public: - int type; + static __u8 data[4108]; static int CacheSize; static void load(FILE *); static void save(FILE *); - eventData(const eit_event_struct* e, int size, int type); +public: + eventData(const eit_event_struct* e=NULL, int size=0, int type=0); ~eventData(); const eit_event_struct* get() const; operator const eit_event_struct*() const @@ -122,29 +144,75 @@ public: return fromBCD(EITdata[7])*3600+fromBCD(EITdata[8])*60+fromBCD(EITdata[9]); } }; +#endif class eEPGCache: public eMainloop, private eThread, public Object { +#ifndef SWIG DECLARE_REF(eEPGCache) struct channel_data: public Object { + pthread_mutex_t channel_active; channel_data(eEPGCache*); eEPGCache *cache; - eTimer abortTimer, zapTimer; - __u8 state, isRunning, haveData, can_delete; + ePtr abortTimer, zapTimer; + int prevChannelState; + __u8 state, isRunning, haveData; ePtr channel; - ePtr m_stateChangedConn, m_NowNextConn, m_ScheduleConn, m_ScheduleOtherConn; - ePtr m_NowNextReader, m_ScheduleReader, m_ScheduleOtherReader; - tidMap seenSections[3], calcedSections[3]; + ePtr m_stateChangedConn, m_NowNextConn, m_ScheduleConn, m_ScheduleOtherConn, m_ViasatConn; + ePtr m_NowNextReader, m_ScheduleReader, m_ScheduleOtherReader, m_ViasatReader; + tidMap seenSections[4], calcedSections[4]; +#ifdef ENABLE_PRIVATE_EPG + ePtr startPrivateTimer; + int m_PrevVersion; + int m_PrivatePid; + uniqueEPGKey m_PrivateService; + ePtr m_PrivateConn; + ePtr m_PrivateReader; + std::set<__u8> seenPrivateSections; + void readPrivateData(const __u8 *data); + void startPrivateReader(); +#endif +#ifdef ENABLE_MHW_EPG + std::vector m_channels; + std::map<__u8, mhw_theme_name_t> m_themes; + std::map<__u32, mhw_title_t> m_titles; + std::multimap<__u32, __u32> m_program_ids; + ePtr m_MHWConn, m_MHWConn2; + ePtr m_MHWReader, m_MHWReader2; + eDVBSectionFilterMask m_MHWFilterMask, m_MHWFilterMask2; + ePtr m_MHWTimeoutTimer; + bool m_MHWTimeoutet; + void MHWTimeout() { m_MHWTimeoutet=true; } + void readMHWData(const __u8 *data); + void readMHWData2(const __u8 *data); + void startMHWReader(__u16 pid, __u8 tid); + void startMHWReader2(__u16 pid, __u8 tid, int ext=-1); + void startTimeout(int msek); + bool checkTimeout() { return m_MHWTimeoutet; } + void cleanup(); + __u8 *delimitName( __u8 *in, __u8 *out, int len_in ); + void timeMHW2DVB( u_char hours, u_char minutes, u_char *return_time); + void timeMHW2DVB( int minutes, u_char *return_time); + void timeMHW2DVB( u_char day, u_char hours, u_char minutes, u_char *return_time); + void storeTitle(std::map<__u32, mhw_title_t>::iterator itTitle, std::string sumText, const __u8 *data); +#endif void readData(const __u8 *data); + void readDataViasat(const __u8 *data); void startChannel(); void startEPG(); bool finishEPG(); void abortEPG(); void abortNonAvail(); }; + bool FixOverlapping(std::pair &servicemap, time_t TM, int duration, const timeMap::iterator &tm_it, const uniqueEPGKey &service); public: - enum {NOWNEXT=1, SCHEDULE=2, SCHEDULE_OTHER=4}; + enum {PRIVATE=0, NOWNEXT=1, SCHEDULE=2, SCHEDULE_OTHER=4 +#ifdef ENABLE_MHW_EPG + ,MHW=8 +#endif + ,VIASAT=16 + }; struct Message { enum @@ -152,11 +220,8 @@ public: flush, startChannel, leaveChannel, - pause, - restart, - updated, - isavail, quit, + got_private_pid, timeChanged }; int type; @@ -166,6 +231,7 @@ public: int err; time_t time; bool avail; + int pid; }; Message() :type(0), time(0) {} @@ -175,7 +241,7 @@ public: :type(type), avail(b) {} Message(int type, iDVBChannel *channel, int err=0) :type(type), channel(channel), err(err) {} - Message(int type, const eServiceReferenceDVB& service, int err=0) + Message(int type, const eServiceReference& service, int err=0) :type(type), service(service), err(err) {} Message(int type, time_t time) :type(type), time(time) {} @@ -185,7 +251,7 @@ private: friend class channel_data; static eEPGCache *instance; - eTimer cleanTimer; + ePtr cleanTimer; std::map m_knownChannels; ePtr m_chanAddedConn; @@ -193,11 +259,18 @@ private: updateMap channelLastUpdated; static pthread_mutex_t cache_lock, channel_map_lock; +#ifdef ENABLE_PRIVATE_EPG + contentMaps content_time_tables; +#endif + void thread(); // thread function // called from epgcache thread void save(); void load(); +#ifdef ENABLE_PRIVATE_EPG + void privateSectionRead(const uniqueEPGKey &, const __u8 *); +#endif void sectionRead(const __u8 *data, int source, channel_data *channel); void gotMessage(const Message &message); void flushEPG(const uniqueEPGKey & s=uniqueEPGKey()); @@ -208,74 +281,72 @@ private: void DVBChannelAdded(eDVBChannel*); void DVBChannelStateChanged(iDVBChannel*); void DVBChannelRunning(iDVBChannel *); + + timeMap::iterator m_timemap_cursor, m_timemap_end; + int currentQueryTsidOnid; // needed for getNextTimeEntry.. only valid until next startTimeQuery call +#else + eEPGCache(); + ~eEPGCache(); +#endif // SWIG public: - static RESULT getInstance(ePtr &ptr); + static eEPGCache *getInstance() { return instance; } +#ifndef SWIG eEPGCache(); ~eEPGCache(); +#ifdef ENABLE_PRIVATE_EPG + void PMTready(eDVBServicePMTHandler *pmthandler); +#else + void PMTready(eDVBServicePMTHandler *pmthandler) {} +#endif + +#endif // called from main thread inline void Lock(); inline void Unlock(); - // result Event * must be deleted by caller of lookupEvent - inline RESULT lookupEvent(const eServiceReferenceDVB &service, int event_id, Event *& ); - inline RESULT lookupEvent(const eServiceReferenceDVB &service, time_t , Event *& ); - - // methods for faster use.. but not thread save .. - // Lock and Unlock should be used !! - RESULT lookupEvent(const eServiceReferenceDVB &service, int event_id, const eventData *& ); - RESULT lookupEvent(const eServiceReferenceDVB &service, time_t , const eventData *& ); + // at moment just for one service.. + RESULT startTimeQuery(const eServiceReference &service, time_t begin=-1, int minutes=-1); - inline RESULT getEventMap(const eServiceReferenceDVB &service, const eventMap *& ); - inline RESULT getTimeMap(const eServiceReferenceDVB &service, const timeMap *& ); -}; - -TEMPLATE_TYPEDEF(ePtr,eEPGCachePtr); - -inline RESULT eEPGCache::lookupEvent(const eServiceReferenceDVB &service, time_t t, Event *& result ) -{ - const eventData *data=0; - RESULT ret = lookupEvent(service, t, data); - if ( !ret && data ) - result = new Event((uint8_t*)data->get()); - return ret; -} +#ifndef SWIG + // eventData's are plain entrys out of the cache.. it's not safe to use them after cache unlock + // but its faster in use... its not allowed to delete this pointers via delete or free.. + RESULT lookupEventId(const eServiceReference &service, int event_id, const eventData *&); + RESULT lookupEventTime(const eServiceReference &service, time_t, const eventData *&, int direction=0); + RESULT getNextTimeEntry(const eventData *&); -inline RESULT eEPGCache::lookupEvent(const eServiceReferenceDVB &service, int event_id, Event *& result) -{ - const eventData *data=0; - RESULT ret = lookupEvent(service, event_id, data); - if ( !ret && data ) - result = new Event((uint8_t*)data->get()); - return ret; -} + // eit_event_struct's are plain dvb eit_events .. it's not safe to use them after cache unlock + // its not allowed to delete this pointers via delete or free.. + RESULT lookupEventId(const eServiceReference &service, int event_id, const eit_event_struct *&); + RESULT lookupEventTime(const eServiceReference &service, time_t , const eit_event_struct *&, int direction=0); + RESULT getNextTimeEntry(const eit_event_struct *&); -inline RESULT eEPGCache::getEventMap(const eServiceReferenceDVB &service, const eventMap *& result) -{ - eventCache::iterator It = eventDB.find( service ); - if ( It != eventDB.end() && It->second.first.size() ) - { - result=&(It->second.first); - return 0; - } - else - result=0; - return -1; -} + // Event's are parsed epg events.. it's safe to use them after cache unlock + // after use this Events must be deleted (memleaks) + RESULT lookupEventId(const eServiceReference &service, int event_id, Event* &); + RESULT lookupEventTime(const eServiceReference &service, time_t, Event* &, int direction=0); + RESULT getNextTimeEntry(Event *&); +#endif + enum { + SIMILAR_BROADCASTINGS_SEARCH, + EXAKT_TITLE_SEARCH, + PARTIAL_TITLE_SEARCH + }; + enum { + CASE_CHECK, + NO_CASE_CHECK + }; + PyObject *lookupEvent(SWIG_PYOBJECT(ePyObject) list, SWIG_PYOBJECT(ePyObject) convertFunc=(PyObject*)0); + PyObject *search(SWIG_PYOBJECT(ePyObject)); -inline RESULT eEPGCache::getTimeMap(const eServiceReferenceDVB &service, const timeMap *& result) -{ - eventCache::iterator It = eventDB.find( service ); - if ( It != eventDB.end() && It->second.second.size() ) - { - result=&(It->second.second); - return 0; - } - else - result=0; - return -1; -} + // eServiceEvent are parsed epg events.. it's safe to use them after cache unlock + // for use from python ( members: m_start_time, m_duration, m_short_description, m_extended_description ) + SWIG_VOID(RESULT) lookupEventId(const eServiceReference &service, int event_id, ePtr &SWIG_OUTPUT); + SWIG_VOID(RESULT) lookupEventTime(const eServiceReference &service, time_t, ePtr &SWIG_OUTPUT, int direction=0); + SWIG_VOID(RESULT) getNextTimeEntry(ePtr &SWIG_OUTPUT); +}; +#ifndef SWIG inline void eEPGCache::Lock() { pthread_mutex_lock(&cache_lock); @@ -285,5 +356,6 @@ inline void eEPGCache::Unlock() { pthread_mutex_unlock(&cache_lock); } +#endif #endif