fix segfault
[enigma2.git] / lib / dvb / epgcache.cpp
index 34bd9f2..7a1c3df 100644 (file)
 #include <time.h>
 #include <unistd.h>  // for usleep
 #include <sys/vfs.h> // for statfs
-#include <libmd5sum.h>
+// #include <libmd5sum.h>
 #include <lib/base/eerror.h>
 
 int eventData::CacheSize=0;
+descriptorMap eventData::descriptors;
+
+extern const uint32_t crc32_table[256];
+
+eventData::eventData(const eit_event_struct* e, int size, int type)
+       :ByteSize(size), type(type)
+{
+       if (!e)
+               return;
+       std::list<__u32> d;
+       __u8 *data = (__u8*)e;
+       int ptr=10;
+       int descriptors_length = (data[ptr++]&0x0F) << 8;
+       descriptors_length |= data[ptr++];
+       while ( descriptors_length > 0 )
+       {
+               int descr_len = data[ptr+1] + 2;
+               __u8 *descr = new __u8[descr_len];
+               unsigned int crc=0;
+               int cnt=0;
+               while(cnt < descr_len && descriptors_length > 0)
+               {
+                       crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ data[ptr]) & 0xff];
+                       descr[cnt++] = data[ptr++];
+                       --descriptors_length;
+               }
+               descriptorMap::iterator it =
+                       descriptors.find(crc);
+               if ( it == descriptors.end() )
+               {
+                       CacheSize+=descr_len;
+                       descriptors[crc] = descriptorPair(1, descr);
+               }
+               else
+               {
+                       ++it->second.first;
+                       delete [] descr;
+               }
+               d.push_back(crc);
+       }
+       ByteSize = 12+d.size()*4;
+       EITdata = new __u8[ByteSize];
+       CacheSize+=ByteSize;
+       memcpy(EITdata, (__u8*) e, 12);
+       __u32 *p = (__u32*)(EITdata+12);
+       for (std::list<__u32>::iterator it(d.begin()); it != d.end(); ++it)
+               *p++ = *it;
+}
+
+const eit_event_struct* eventData::get() const
+{
+       static __u8 *data=NULL;
+       if ( data )
+               delete [] data;
+
+       int bytes = 12;
+       std::list<__u8*> d;
+
+// cnt needed bytes
+       int tmp = ByteSize-12;
+       __u32 *p = (__u32*)(EITdata+12);
+       while(tmp>0)
+       {
+               descriptorMap::iterator it =
+                       descriptors.find(*p++);
+               if ( it != descriptors.end() )
+               {
+                       d.push_back(it->second.second);
+                       bytes += it->second.second[1];
+               }
+               bytes += 2; // descr_type, descr_len
+               tmp-=4;
+       }
+
+// copy eit_event header to buffer
+       data = new __u8[bytes];
+       memcpy(data, EITdata, 12);
+
+       tmp=12;
+// copy all descriptors to buffer
+       for(std::list<__u8*>::iterator it(d.begin()); it != d.end(); ++it)
+       {
+               int b=(*it)[1]+2;
+               memcpy(data+tmp, *it, b);
+               tmp+=b;
+       }
+
+       return (eit_event_struct*)data;
+}
+
+eventData::~eventData()
+{
+       if ( ByteSize )
+       {
+               CacheSize-=ByteSize;
+               ByteSize-=12;
+               __u32 *d = (__u32*)(EITdata+12);
+               while(ByteSize)
+               {
+                       descriptorMap::iterator it =
+                               descriptors.find(*d++);
+                       if ( it != descriptors.end() )
+                       {
+                               descriptorPair &p = it->second;
+                               if (!--p.first) // no more used descriptor
+                               {
+                                       CacheSize -= p.second[1]+2;
+                                       delete [] p.second;     // free descriptor memory
+                                       descriptors.erase(it);  // remove entry from descriptor map
+                               }
+                       }
+                       ByteSize-=4;
+               }
+               delete [] EITdata;
+       }
+}
+
+void eventData::load(FILE *f)
+{
+       int size=0;
+       int id=0;
+       __u8 header[2];
+       descriptorPair p;
+       fread(&size, sizeof(int), 1, f);
+       while(size)
+       {
+               fread(&id, sizeof(__u32), 1, f);
+               fread(&p.first, sizeof(int), 1, f);
+               fread(header, 2, 1, f);
+               int bytes = header[1]+2;
+               p.second = new __u8[bytes];
+               p.second[0] = header[0];
+               p.second[1] = header[1];
+               fread(p.second+2, bytes-2, 1, f);
+               descriptors[id]=p;
+               --size;
+               CacheSize+=bytes;
+       }
+}
+
+void eventData::save(FILE *f)
+{
+       int size=descriptors.size();
+       descriptorMap::iterator it(descriptors.begin());
+       fwrite(&size, sizeof(int), 1, f);
+       while(size)
+       {
+               fwrite(&it->first, sizeof(__u32), 1, f);
+               fwrite(&it->second.first, sizeof(int), 1, f);
+               fwrite(it->second.second, it->second.second[1]+2, 1, f);
+               ++it;
+               --size;
+       }
+}
 
 eEPGCache* eEPGCache::instance;
 pthread_mutex_t eEPGCache::cache_lock=
@@ -84,28 +238,27 @@ void eEPGCache::DVBChannelRunning(iDVBChannel *chan)
                        }
                        else
                        {
-                               RESULT res;
-                               data.m_NowNextReader = new eDVBSectionReader( demux, this, res );
+                               RESULT res = demux->createSectionReader( this, data.m_NowNextReader );
                                if ( res )
                                {
                                        eDebug("[eEPGCache] couldnt initialize nownext reader!!");
                                        return;
                                }
-                               data.m_NowNextReader->connectRead(slot(data, &eEPGCache::channel_data::readData), data.m_NowNextConn);
-                               data.m_ScheduleReader = new eDVBSectionReader( demux, this, res );
+
+                               res = demux->createSectionReader( this, data.m_ScheduleReader );
                                if ( res )
                                {
                                        eDebug("[eEPGCache] couldnt initialize schedule reader!!");
                                        return;
                                }
-                               data.m_ScheduleReader->connectRead(slot(data, &eEPGCache::channel_data::readData), data.m_ScheduleConn);
-                               data.m_ScheduleOtherReader = new eDVBSectionReader( demux, this, res );
+
+                               res = demux->createSectionReader( this, data.m_ScheduleOtherReader );
                                if ( res )
                                {
                                        eDebug("[eEPGCache] couldnt initialize schedule other reader!!");
                                        return;
                                }
-                               data.m_ScheduleOtherReader->connectRead(slot(data, &eEPGCache::channel_data::readData), data.m_ScheduleOtherConn);
+
                                messages.send(Message(Message::startChannel, chan));
                                // -> gotMessage -> changedService
                        }
@@ -150,16 +303,15 @@ void eEPGCache::DVBChannelStateChanged(iDVBChannel *chan)
        }
 }
 
-int eEPGCache::sectionRead(const __u8 *data, int source, channel_data *channel)
+void eEPGCache::sectionRead(const __u8 *data, int source, channel_data *channel)
 {
        eit_t *eit = (eit_t*) data;
 
        int len=HILO(eit->section_length)-1;//+3-4;
        int ptr=EIT_SIZE;
        if ( ptr >= len )
-               return 0;
+               return;
 
-       //
        // This fixed the EPG on the Multichoice irdeto systems
        // the EIT packet is non-compliant.. their EIT packet stinks
        if ( data[ptr-1] < 0x40 )
@@ -171,7 +323,6 @@ int eEPGCache::sectionRead(const __u8 *data, int source, channel_data *channel)
        int duration;
 
        time_t TM = parseDVBtime( eit_event->start_time_1, eit_event->start_time_2,     eit_event->start_time_3, eit_event->start_time_4, eit_event->start_time_5);
-// FIXME !!! TIME CORRECTION !
        time_t now = time(0)+eDVBLocalTimeHandler::getInstance()->difference();
 
        if ( TM != 3599 && TM > -1)
@@ -211,7 +362,7 @@ int eEPGCache::sectionRead(const __u8 *data, int source, channel_data *channel)
                        int ev_erase_count = 0;
                        int tm_erase_count = 0;
 
-// search in eventmap
+                       // search in eventmap
                        eventMap::iterator ev_it =
                                servicemap.first.find(event_id);
 
@@ -221,7 +372,7 @@ int eEPGCache::sectionRead(const __u8 *data, int source, channel_data *channel)
                                if ( source > ev_it->second->type )  // update needed ?
                                        goto next; // when not.. the skip this entry
 
-// search this event in timemap
+                               // search this event in timemap
                                timeMap::iterator tm_it_tmp = 
                                        servicemap.second.find(ev_it->second->getStartTime());
 
@@ -246,20 +397,20 @@ int eEPGCache::sectionRead(const __u8 *data, int source, channel_data *channel)
                                }
                        }
 
-// search in timemap, for check of a case if new time has coincided with time of other event 
-// or event was is not found in eventmap
+                       // search in timemap, for check of a case if new time has coincided with time of other event 
+                       // or event was is not found in eventmap
                        timeMap::iterator tm_it =
                                servicemap.second.find(TM);
 
                        if ( tm_it != servicemap.second.end() )
                        {
-// i think, if event is not found on eventmap, but found on timemap updating nevertheless demands
+                               // i think, if event is not found on eventmap, but found on timemap updating nevertheless demands
 #if 0
                                if ( source > tm_it->second->type && tm_erase_count == 0 ) // update needed ?
                                        goto next; // when not.. the skip this entry
 #endif
 
-// search this time in eventmap
+                               // search this time in eventmap
                                eventMap::iterator ev_it_tmp = 
                                        servicemap.first.find(tm_it->second->getEventID());
 
@@ -341,8 +492,8 @@ next:
                        i=0;
                        for (timeMap::iterator it(servicemap.second.begin())
                                ; it != servicemap.second.end(); ++it )
-                       fprintf(f, "%d(key %d) -> time %d, event_id %d, data %p\n", 
-                               i++, (int)it->first, (int)it->second->getStartTime(), (int)it->second->getEventID(), it->second );
+                                       fprintf(f, "%d(key %d) -> time %d, event_id %d, data %p\n", 
+                                               i++, (int)it->first, (int)it->second->getStartTime(), (int)it->second->getEventID(), it->second );
                        fclose(f);
 
                        eFatal("(1)map sizes not equal :( sid %04x tsid %04x onid %04x size %d size2 %d", 
@@ -353,8 +504,6 @@ next:
                ptr += eit_event_size;
                eit_event=(eit_event_struct*)(((__u8*)eit_event)+eit_event_size);
        }
-
-       return 0;
 }
 
 void eEPGCache::flushEPG(const uniqueEPGKey & s)
@@ -404,20 +553,14 @@ void eEPGCache::cleanLoop()
        if (!eventDB.empty())
        {
                eDebug("[EPGC] start cleanloop");
-               const eit_event_struct* cur_event;
-               int duration;
 
-// FIXME !!! TIME_CORRECTION
                time_t now = time(0)+eDVBLocalTimeHandler::getInstance()->difference();
 
                for (eventCache::iterator DBIt = eventDB.begin(); DBIt != eventDB.end(); DBIt++)
                {
                        for (timeMap::iterator It = DBIt->second.second.begin(); It != DBIt->second.second.end() && It->first < now;)
                        {
-                               cur_event = (*It->second).get();
-                               duration = fromBCD( cur_event->duration_1)*3600 + fromBCD(cur_event->duration_2)*60 + fromBCD(cur_event->duration_3);
-
-                               if ( now > (It->first+duration) )  // outdated normal entry (nvod references to)
+                               if ( now > (It->first+It->second->getDuration()) )  // outdated normal entry (nvod references to)
                                {
                                        // remove entry from eventMap
                                        eventMap::iterator b(DBIt->second.first.find(It->second->getEventID()));
@@ -454,7 +597,7 @@ eEPGCache::~eEPGCache()
                        delete It->second;
 }
 
-Event *eEPGCache::lookupEvent(const eServiceReferenceDVB &service, int event_id, bool plain)
+RESULT eEPGCache::lookupEvent(const eServiceReferenceDVB &service, int event_id, const eventData *&result )
 {
        singleLock s(cache_lock);
        uniqueEPGKey key( service );
@@ -465,22 +608,19 @@ Event *eEPGCache::lookupEvent(const eServiceReferenceDVB &service, int event_id,
                eventMap::iterator i( It->second.first.find( event_id ));
                if ( i != It->second.first.end() )
                {
-                       if ( service.getServiceType() == 4 ) // nvod ref
-                               return lookupEvent( service, i->second->getStartTime(), plain );
-                       else if ( plain )
-               // get plain data... not in Event Format !!!
-               // before use .. cast it to eit_event_struct*
-                               return (Event*) i->second->get();
-                       else
-                               return new Event( (uint8_t*)i->second->get() /*, (It->first.tsid<<16)|It->first.onid*/ );
+                       result = i->second;
+                       return 0;
                }
                else
+               {
+                       result = 0;
                        eDebug("event %04x not found in epgcache", event_id);
+               }
        }
-       return 0;
+       return -1;
 }
 
-Event *eEPGCache::lookupEvent(const eServiceReferenceDVB &service, time_t t, bool plain )
+RESULT eEPGCache::lookupEvent(const eServiceReferenceDVB &service, time_t t, const eventData *&result )
 // if t == 0 we search the current event...
 {
        singleLock s(cache_lock);
@@ -499,35 +639,26 @@ Event *eEPGCache::lookupEvent(const eServiceReferenceDVB &service, time_t t, boo
                        i--;
                        if ( i != It->second.second.end() )
                        {
-                               const eit_event_struct* eit_event = i->second->get();
-                               int duration = fromBCD(eit_event->duration_1)*3600+fromBCD(eit_event->duration_2)*60+fromBCD(eit_event->duration_3);
-                               if ( t <= i->first+duration )
+                               if ( t <= i->first+i->second->getDuration() )
                                {
-                                       if ( plain )
-                                               // get plain data... not in Event Format !!!
-                                               // before use .. cast it to eit_event_struct*
-                                               return (Event*) i->second->get();
-                                       return new Event( (uint8_t*)i->second->get() /*, (It->first.tsid<<16)|It->first.onid */ );
+                                       result = i->second;
+                                       return 0;
                                }
                        }
                }
 
                for ( eventMap::iterator i( It->second.first.begin() ); i != It->second.first.end(); i++)
                {
-                       const eit_event_struct* eit_event = i->second->get();
-                       int duration = fromBCD(eit_event->duration_1)*3600+fromBCD(eit_event->duration_2)*60+fromBCD(eit_event->duration_3);
-                       time_t begTime = parseDVBtime( eit_event->start_time_1, eit_event->start_time_2,        eit_event->start_time_3, eit_event->start_time_4,       eit_event->start_time_5);
+                       int duration = i->second->getDuration();
+                       time_t begTime = i->second->getStartTime();
                        if ( t >= begTime && t <= begTime+duration) // then we have found
                        {
-                               if ( plain )
-                                       // get plain data... not in Event Format !!!
-                                       // before use .. cast it to eit_event_struct*
-                                       return (Event*) i->second->get();
-                               return new Event( (uint8_t*)i->second->get()/*, (It->first.tsid<<16)|It->first.onid*/ );
+                               result = i->second;
+                               return 0;
                        }
                }
        }
-       return 0;
+       return -1;
 }
 
 void eEPGCache::gotMessage( const Message &msg )
@@ -578,6 +709,7 @@ void eEPGCache::thread()
 
 void eEPGCache::load()
 {
+#if 0
        FILE *f = fopen("/hdd/epg.dat", "r");
        if (f)
        {
@@ -599,38 +731,50 @@ void eEPGCache::load()
                }
                if ( md5ok )
                {
-                       fread( &size, sizeof(int), 1, f);
-                       while(size--)
+                       char text1[13];
+                       fread( text1, 13, 1, f);
+                       if ( !strncmp( text1, "ENIGMA_EPG_V2", 13) )
                        {
-                               uniqueEPGKey key;
-                               eventMap evMap;
-                               timeMap tmMap;
-                               int size=0;
-                               fread( &key, sizeof(uniqueEPGKey), 1, f);
                                fread( &size, sizeof(int), 1, f);
                                while(size--)
                                {
-                                       int len=0;
-                                       int type=0;
-                                       eventData *event=0;
-                                       fread( &type, sizeof(int), 1, f);
-                                       fread( &len, sizeof(int), 1, f);
-                                       event = new eventData(0, len, type);
-                                       fread( event->EITdata, len, 1, f);
-                                       evMap[ event->getEventID() ]=event;
-                                       tmMap[ event->getStartTime() ]=event;
-                                       ++cnt;
+                                       uniqueEPGKey key;
+                                       eventMap evMap;
+                                       timeMap tmMap;
+                                       int size=0;
+                                       fread( &key, sizeof(uniqueEPGKey), 1, f);
+                                       fread( &size, sizeof(int), 1, f);
+                                       while(size--)
+                                       {
+                                               int len=0;
+                                               int type=0;
+                                               eventData *event=0;
+                                               fread( &type, sizeof(int), 1, f);
+                                               fread( &len, sizeof(int), 1, f);
+                                               event = new eventData(0, len, type);
+                                               event->EITdata = new __u8[len];
+                                               eventData::CacheSize+=len;
+                                               fread( event->EITdata, len, 1, f);
+                                               evMap[ event->getEventID() ]=event;
+                                               tmMap[ event->getStartTime() ]=event;
+                                               ++cnt;
+                                       }
+                                       eventDB[key]=std::pair<eventMap,timeMap>(evMap,tmMap);
                                }
-                               eventDB[key]=std::pair<eventMap,timeMap>(evMap,tmMap);
+                               eventData::load(f);
+                               eDebug("%d events read from /hdd/epg.dat", cnt);
                        }
-                       eDebug("%d events read from /hdd/epg.dat.md5", cnt);
+                       else
+                               eDebug("[EPGC] don't read old epg database");
+                       fclose(f);
                }
-               fclose(f);
        }
+#endif
 }
 
 void eEPGCache::save()
 {
+#if 0
        struct statfs s;
        off64_t tmp;
        if (statfs("/hdd", &s)<0)
@@ -655,6 +799,8 @@ void eEPGCache::save()
        int cnt=0;
        if ( f )
        {
+               const char *text = "ENIGMA_EPG_V2";
+               fwrite( text, 13, 1, f );
                int size = eventDB.size();
                fwrite( &size, sizeof(int), 1, f );
                for (eventCache::iterator service_it(eventDB.begin()); service_it != eventDB.end(); ++service_it)
@@ -673,6 +819,7 @@ void eEPGCache::save()
                        }
                }
                eDebug("%d events written to /hdd/epg.dat", cnt);
+               eventData::save(f);
                fclose(f);
                unsigned char md5[16];
                if (!md5_file("/hdd/epg.dat", 1, md5))
@@ -685,6 +832,7 @@ void eEPGCache::save()
                        }
                }
        }
+#endif
 }
 
 RESULT eEPGCache::getInstance(ePtr<eEPGCache> &ptr)
@@ -708,10 +856,14 @@ bool eEPGCache::channel_data::finishEPG()
 {
        if (!isRunning)  // epg ready
        {
-               eDebug("[EPGC] stop caching events");
+               eDebug("[EPGC] stop caching events(%d)", time(0)+eDVBLocalTimeHandler::getInstance()->difference());
                zapTimer.start(UPDATE_INTERVAL, 1);
                eDebug("[EPGC] next update in %i min", UPDATE_INTERVAL / 60000);
-
+               for (int i=0; i < 3; ++i)
+               {
+                       seenSections[i].clear();
+                       calcedSections[i].clear();
+               }
                singleLock l(cache->cache_lock);
                cache->channelLastUpdated[channel->getChannelID()] = time(0)+eDVBLocalTimeHandler::getInstance()->difference();
                can_delete=1;
@@ -722,10 +874,15 @@ bool eEPGCache::channel_data::finishEPG()
 
 void eEPGCache::channel_data::startEPG()
 {
-       eDebug("[EPGC] start caching events");
+       eDebug("[EPGC] start caching events(%d)", eDVBLocalTimeHandler::getInstance()->difference()+time(0));
        state=0;
        haveData=0;
        can_delete=0;
+       for (int i=0; i < 3; ++i)
+       {
+               seenSections[i].clear();
+               calcedSections[i].clear();
+       }
 
        eDVBSectionFilterMask mask;
        memset(&mask, 0, sizeof(mask));
@@ -734,20 +891,23 @@ void eEPGCache::channel_data::startEPG()
 
        mask.data[0] = 0x4E;
        mask.mask[0] = 0xFE;
+       m_NowNextReader->connectRead(slot(*this, &eEPGCache::channel_data::readData), m_NowNextConn);
        m_NowNextReader->start(mask);
        isRunning |= NOWNEXT;
 
        mask.data[0] = 0x50;
        mask.mask[0] = 0xF0;
+       m_ScheduleReader->connectRead(slot(*this, &eEPGCache::channel_data::readData), m_ScheduleConn);
        m_ScheduleReader->start(mask);
        isRunning |= SCHEDULE;
 
        mask.data[0] = 0x60;
        mask.mask[0] = 0xF0;
+       m_ScheduleOtherReader->connectRead(slot(*this, &eEPGCache::channel_data::readData), m_ScheduleOtherConn);
        m_ScheduleOtherReader->start(mask);
        isRunning |= SCHEDULE_OTHER;
 
-       abortTimer.start(5000,true);
+       abortTimer.start(7000,true);
 }
 
 void eEPGCache::channel_data::abortNonAvail()
@@ -758,25 +918,35 @@ void eEPGCache::channel_data::abortNonAvail()
                {
                        eDebug("[EPGC] abort non avail nownext reading");
                        isRunning &= ~eEPGCache::NOWNEXT;
-                       if ( m_NowNextReader )
-                               m_NowNextReader->stop();
+                       m_NowNextReader->stop();
+                       m_NowNextConn=0;
                }
                if ( !(haveData&eEPGCache::SCHEDULE) && (isRunning&eEPGCache::SCHEDULE) )
                {
                        eDebug("[EPGC] abort non avail schedule reading");
                        isRunning &= ~SCHEDULE;
                        m_ScheduleReader->stop();
+                       m_ScheduleConn=0;
                }
                if ( !(haveData&eEPGCache::SCHEDULE_OTHER) && (isRunning&eEPGCache::SCHEDULE_OTHER) )
                {
                        eDebug("[EPGC] abort non avail schedule_other reading");
                        isRunning &= ~SCHEDULE_OTHER;
                        m_ScheduleOtherReader->stop();
+                       m_ScheduleOtherConn=0;
                }
                if ( isRunning )
-                       abortTimer.start(20000, true);
+                       abortTimer.start(90000, true);
                else
-                       finishEPG();
+               {
+                       ++state;
+                       for (int i=0; i < 3; ++i)
+                       {
+                               seenSections[i].clear();
+                               calcedSections[i].clear();
+                       }
+                       can_delete=1;
+               }
        }
        ++state;
 }
@@ -799,6 +969,11 @@ void eEPGCache::channel_data::startChannel()
 
 void eEPGCache::channel_data::abortEPG()
 {
+       for (int i=0; i < 3; ++i)
+       {
+               seenSections[i].clear();
+               calcedSections[i].clear();
+       }
        abortTimer.stop();
        zapTimer.stop();
        if (isRunning)
@@ -807,20 +982,20 @@ void eEPGCache::channel_data::abortEPG()
                if (isRunning & eEPGCache::SCHEDULE)
                {
                        isRunning &= eEPGCache::SCHEDULE;
-                       if ( m_ScheduleReader )
-                               m_ScheduleReader->stop();
+                       m_ScheduleReader->stop();
+                       m_ScheduleConn=0;
                }
                if (isRunning & eEPGCache::NOWNEXT)
                {
                        isRunning &= ~eEPGCache::NOWNEXT;
-                       if ( m_NowNextReader )
-                               m_NowNextReader->stop();
+                       m_NowNextReader->stop();
+                       m_NowNextConn=0;
                }
                if (isRunning & SCHEDULE_OTHER)
                {
                        isRunning &= ~eEPGCache::SCHEDULE_OTHER;
-                       if ( m_ScheduleOtherReader )
-                               m_ScheduleOtherReader->stop();
+                       m_ScheduleOtherReader->stop();
+                       m_ScheduleOtherConn=0;
                }
                can_delete=1;
        }
@@ -832,28 +1007,87 @@ void eEPGCache::channel_data::readData( const __u8 *data)
                eDebug("get Null pointer from section reader !!");
        else
        {
-               int source = data[0] > 0x5F ? eEPGCache::SCHEDULE_OTHER : data[0] > 0x4F ? eEPGCache::SCHEDULE : eEPGCache::NOWNEXT;
-               if ( state == 2 )
+               int source;
+               int map;
+               iDVBSectionReader *reader=NULL;
+               switch(data[0])
                {
-                       iDVBSectionReader *reader=NULL;
+                       case 0x4E ... 0x4F:
+                               reader=m_NowNextReader;
+                               source=eEPGCache::NOWNEXT;
+                               map=0;
+                               break;
+                       case 0x50 ... 0x5F:
+                               reader=m_ScheduleReader;
+                               source=eEPGCache::SCHEDULE;
+                               map=1;
+                               break;
+                       case 0x60 ... 0x6F:
+                               reader=m_ScheduleOtherReader;
+                               source=eEPGCache::SCHEDULE_OTHER;
+                               map=2;
+                               break;
+                       default:
+                               eDebug("[EPGC] unknown table_id !!!");
+                               return;
+               }
+               tidMap &seenSections = this->seenSections[map];
+               tidMap &calcedSections = this->calcedSections[map];
+               if ( state == 1 && calcedSections == seenSections || state > 1 )
+               {
+                       eDebugNoNewLine("[EPGC] ");
                        switch (source)
                        {
-                               case eEPGCache::SCHEDULE_OTHER:
-                                       reader=m_ScheduleOtherReader;
+                               case eEPGCache::NOWNEXT:
+                                       m_NowNextConn=0;
+                                       eDebugNoNewLine("nownext");
                                        break;
                                case eEPGCache::SCHEDULE:
-                                       reader=m_ScheduleReader;
+                                       m_ScheduleConn=0;
+                                       eDebugNoNewLine("schedule");
                                        break;
-                               case eEPGCache::NOWNEXT:
-                                       reader=m_NowNextReader;
+                               case eEPGCache::SCHEDULE_OTHER:
+                                       m_ScheduleOtherConn=0;
+                                       eDebugNoNewLine("schedule other");
                                        break;
+                               default: eDebugNoNewLine("unknown");break;
                        }
-                       reader->stop();
+                       eDebug(" finished(%d)", time(0)+eDVBLocalTimeHandler::getInstance()->difference());
+                       if ( reader )
+                               reader->stop();
                        isRunning &= ~source;
                        if (!isRunning)
                                finishEPG();
                }
                else
-                       cache->sectionRead(data, source, this);
+               {
+                       eit_t *eit = (eit_t*) data;
+                       __u32 sectionNo = data[0] << 24;
+                       sectionNo |= data[3] << 16;
+                       sectionNo |= data[4] << 8;
+                       sectionNo |= eit->section_number;
+
+                       tidMap::iterator it =
+                               seenSections.find(sectionNo);
+
+                       if ( it == seenSections.end() )
+                       {
+                               seenSections.insert(sectionNo);
+                               calcedSections.insert(sectionNo);
+                               __u32 tmpval = sectionNo & 0xFFFFFF00;
+                               __u8 incr = source == NOWNEXT ? 1 : 8;
+                               for ( int i = 0; i <= eit->last_section_number; i+=incr )
+                               {
+                                       if ( i == eit->section_number )
+                                       {
+                                               for (int x=i; x <= eit->segment_last_section_number; ++x)
+                                                       calcedSections.insert(tmpval|(x&0xFF));
+                                       }
+                                       else
+                                               calcedSections.insert(tmpval|(i&0xFF));
+                               }
+                               cache->sectionRead(data, source, this);
+                       }
+               }
        }
 }