X-Git-Url: https://git.cweiske.de/enigma2.git/blobdiff_plain/20f69c200ec5703e958a6b95abfcfd5a108e5939..1e88da3ea994175689ab4d8edbc1fd809f1d6ad8:/lib/dvb/epgcache.h?ds=sidebyside diff --git a/lib/dvb/epgcache.h b/lib/dvb/epgcache.h index bc25692e..3f1aeaed 100644 --- a/lib/dvb/epgcache.h +++ b/lib/dvb/epgcache.h @@ -1,17 +1,11 @@ #ifndef __epgcache_h_ #define __epgcache_h_ -#ifndef SWIG - #include #include #include +#include -// check if gcc version >= 3.4 -#if defined(__GNUC__) && ((__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || __GNUC__ == 4 ) -#else -#include -#endif #include #include @@ -75,28 +69,26 @@ struct uniqueEPGKey //timeMap is sorted by beginTime #define timeMap std::map -#define tmpMap std::map > +#define channelMapIterator std::map::iterator +#define updateMap std::map -#if defined(__GNUC__) && ((__GNUC__ == 3 && __GNUC_MINOR__ >= 1) || __GNUC__ == 4 ) // check if gcc version >= 3.1 - #define eventCache __gnu_cxx::hash_map, __gnu_cxx::hash, uniqueEPGKey::equal> - #define updateMap __gnu_cxx::hash_map, uniqueEPGKey::equal > - namespace __gnu_cxx -#else // for older gcc use following - #define eventCache std::hash_map, std::hash, uniqueEPGKey::equal > - #define updateMap std::hash_map, uniqueEPGKey::equal > - namespace std -#endif -{ -template<> struct hash +struct hash_uniqueEPGKey { inline size_t operator()( const uniqueEPGKey &x) const { - int v=(x.onid^x.sid); - v^=v>>8; - return v&0xFF; + return (x.onid << 16) | x.tsid; } }; -} + +#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> +#else // for older gcc use following + #define eventCache std::hash_map, hash_uniqueEPGKey, uniqueEPGKey::equal > +#endif + +#define descriptorPair std::pair +#define descriptorMap std::map<__u32, descriptorPair > class eventData { @@ -104,67 +96,71 @@ class eventData private: __u8* EITdata; int ByteSize; + static descriptorMap descriptors; public: int type; static int CacheSize; - eventData(const eit_event_struct* e, int size, int type) - :ByteSize(size), type(type) - { - CacheSize+=size; - EITdata = new __u8[size]; - if (e) - memcpy(EITdata, (__u8*) e, size); - } - ~eventData() - { - CacheSize-=ByteSize; - delete [] EITdata; - } + static void load(FILE *); + static void save(FILE *); + eventData(const eit_event_struct* e, int size, int type); + ~eventData(); + const eit_event_struct* get() const; operator const eit_event_struct*() const { - return (const eit_event_struct*) EITdata; - } - const eit_event_struct* get() const - { - return (const eit_event_struct*) EITdata; + return get(); } int getEventID() { - return HILO( ((const eit_event_struct*) EITdata)->event_id ); + return (EITdata[0] << 8) | EITdata[1]; } time_t getStartTime() { - return parseDVBtime( - EITdata[2], EITdata[3], - EITdata[4], EITdata[5], EITdata[6]); + return parseDVBtime(EITdata[2], EITdata[3], EITdata[4], EITdata[5], EITdata[6]); + } + int getDuration() + { + return fromBCD(EITdata[7])*3600+fromBCD(EITdata[8])*60+fromBCD(EITdata[9]); } }; -#else - #include -#endif class eEPGCache: public eMainloop, private eThread, public Object { DECLARE_REF(eEPGCache) + struct channel_data: public Object + { + channel_data(eEPGCache*); + eEPGCache *cache; + eTimer abortTimer, zapTimer; + __u8 state, isRunning, haveData, can_delete; + ePtr channel; + ePtr m_stateChangedConn, m_NowNextConn, m_ScheduleConn, m_ScheduleOtherConn; + ePtr m_NowNextReader, m_ScheduleReader, m_ScheduleOtherReader; + tidMap seenSections[3], calcedSections[3]; + void readData(const __u8 *data); + void startChannel(); + void startEPG(); + bool finishEPG(); + void abortEPG(); + void abortNonAvail(); + }; public: -#ifndef SWIG - enum {NOWNEXT, SCHEDULE, SCHEDULE_OTHER}; + enum {NOWNEXT=1, SCHEDULE=2, SCHEDULE_OTHER=4}; struct Message { enum { flush, - startService, + startChannel, leaveChannel, pause, restart, updated, isavail, quit, - timeChanged, - leaveChannelFinished + timeChanged }; int type; + iDVBChannel *channel; uniqueEPGKey service; union { int err; @@ -177,122 +173,107 @@ public: :type(type) {} Message(int type, bool b) :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) :type(type), service(service), err(err) {} Message(int type, time_t time) :type(type), time(time) {} }; eFixedMessagePump messages; - eFixedMessagePump back_messages; private: - static pthread_mutex_t cache_lock; - eServiceReferenceDVB next_service; - uniqueEPGKey current_service; - int paused; - - int state; - __u8 isRunning, haveData; - - ePtr m_currentChannel; - ePtr m_NowNextConn, m_ScheduleConn, m_ScheduleOtherConn; - ePtr m_NowNextReader, m_ScheduleReader, m_ScheduleOtherReader; - - int sectionRead(const __u8 *data, int source); - void readNowNextData(const __u8 *data); - void readScheduleData(const __u8 *data); - void readScheduleOtherData(const __u8 *data); - + friend class channel_data; static eEPGCache *instance; + eTimer cleanTimer; + std::map m_knownChannels; + ePtr m_chanAddedConn; + eventCache eventDB; - updateMap serviceLastUpdated; - tmpMap temp; - eTimer CleanTimer; - eTimer zapTimer; - eTimer abortTimer; - bool finishEPG(); - void abortNonAvail(); - void flushEPG(const uniqueEPGKey & s=uniqueEPGKey()); - void startEPG(); + updateMap channelLastUpdated; + static pthread_mutex_t cache_lock, channel_map_lock; - void changedService(const uniqueEPGKey &); - void abortEPG(); + void thread(); // thread function - void cleanLoop(); - void pauseEPG(); - void restartEPG(); - void thread(); - void gotMessage(const Message &message); - void gotBackMessage(const Message &message); - void timeUpdated(); +// called from epgcache thread void save(); void load(); - void leaveChannel(iDVBChannel *); -#endif + void sectionRead(const __u8 *data, int source, channel_data *channel); + void gotMessage(const Message &message); + void flushEPG(const uniqueEPGKey & s=uniqueEPGKey()); + void cleanLoop(); + +// called from main thread + void timeUpdated(); + void DVBChannelAdded(eDVBChannel*); + void DVBChannelStateChanged(iDVBChannel*); + void DVBChannelRunning(iDVBChannel *); public: static RESULT getInstance(ePtr &ptr); - // called from other thread context !! - void startCache(const eServiceReferenceDVB &); - Event *lookupEvent(const eServiceReferenceDVB &service, int event_id, bool plain=false ); - Event *lookupEvent(const eServiceReferenceDVB &service, time_t=0, bool plain=false ); -#ifndef SWIG eEPGCache(); ~eEPGCache(); + // called from main thread inline void Lock(); inline void Unlock(); - const eventMap* getEventMap(const eServiceReferenceDVB &service); - const timeMap* getTimeMap(const eServiceReferenceDVB &service); - tmpMap* getUpdatedMap() { return &temp; } + // 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 *& ); - Signal1 EPGAvail; - Signal0 EPGUpdated; -#endif + // 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 *& ); + + inline RESULT getEventMap(const eServiceReferenceDVB &service, const eventMap *& ); + inline RESULT getTimeMap(const eServiceReferenceDVB &service, const timeMap *& ); }; TEMPLATE_TYPEDEF(ePtr,eEPGCachePtr); -inline const eventMap* eEPGCache::getEventMap(const eServiceReferenceDVB &service) +inline RESULT eEPGCache::lookupEvent(const eServiceReferenceDVB &service, time_t t, Event *& result ) { - eventCache::iterator It = eventDB.find( service ); - if ( It != eventDB.end() && It->second.first.size() ) - return &(It->second.first); - else - return 0; + const eventData *data=0; + RESULT ret = lookupEvent(service, t, data); + if ( !ret && data ) + result = new Event((uint8_t*)data->get()); + return ret; } -inline const timeMap* eEPGCache::getTimeMap(const eServiceReferenceDVB &service) +inline RESULT eEPGCache::lookupEvent(const eServiceReferenceDVB &service, int event_id, Event *& result) { - eventCache::iterator It = eventDB.find( service ); - if ( It != eventDB.end() && It->second.second.size() ) - return &(It->second.second); - else - return 0; -} - -inline void eEPGCache::readNowNextData( const __u8 *data) -{ - if ( !data || state == 2 ) - m_NowNextReader->stop(); - else - sectionRead(data, eEPGCache::NOWNEXT); + const eventData *data=0; + RESULT ret = lookupEvent(service, event_id, data); + if ( !ret && data ) + result = new Event((uint8_t*)data->get()); + return ret; } -inline void eEPGCache::readScheduleData(const __u8 *data) +inline RESULT eEPGCache::getEventMap(const eServiceReferenceDVB &service, const eventMap *& result) { - if ( !data || state == 2 ) - m_ScheduleReader->stop(); + eventCache::iterator It = eventDB.find( service ); + if ( It != eventDB.end() && It->second.first.size() ) + { + result=&(It->second.first); + return 0; + } else - sectionRead(data, eEPGCache::SCHEDULE); + result=0; + return -1; } -inline void eEPGCache::readScheduleOtherData(const __u8 *data) +inline RESULT eEPGCache::getTimeMap(const eServiceReferenceDVB &service, const timeMap *& result) { - if ( !data || state == 2 ) - m_ScheduleOtherReader->stop(); + eventCache::iterator It = eventDB.find( service ); + if ( It != eventDB.end() && It->second.second.size() ) + { + result=&(It->second.second); + return 0; + } else - sectionRead(data, eEPGCache::SCHEDULE_OTHER); + result=0; + return -1; } inline void eEPGCache::Lock()