better readable code

[enigma2.git] / lib / dvb / epgcache.cpp

diff --git a/lib/dvb/epgcache.cpp b/lib/dvb/epgcache.cpp
index ee61268c30520508a10e5454438ecc70ac5c30ee..a744655a2b253511acb411a9c8fe380fcee3771f 100644 (file)
--- a/lib/dvb/epgcache.cpp
+++ b/lib/dvb/epgcache.cpp
@@ -3,6 +3,10 @@
 
 #undef EPG_DEBUG  
 
 
 #undef EPG_DEBUG  
 

+#ifdef EPG_DEBUG
+#include <lib/service/event.h>
+#endif
+

 #include <time.h>
 #include <unistd.h>  // for usleep
 #include <sys/vfs.h> // for statfs
 #include <time.h>
 #include <unistd.h>  // for usleep
 #include <sys/vfs.h> // for statfs


@@ -297,6 +301,69 @@ void eEPGCache::DVBChannelStateChanged(iDVBChannel *chan)
        }
 }
 
        }
 }
 

+void eEPGCache::FixOverlapping(std::pair<eventMap,timeMap> &servicemap, time_t TM, int duration, const timeMap::iterator &tm_it, const uniqueEPGKey &service)
+{
+       timeMap::iterator tmp = tm_it;
+       while ((tmp->first+tmp->second->getDuration()-300) > TM)
+       {
+               if(tmp->first != TM && tmp->second->type != PRIVATE)
+               {
+                       __u16 event_id = tmp->second->getEventID();
+                       servicemap.first.erase(event_id);
+#ifdef EPG_DEBUG
+                       Event evt((uint8_t*)tmp->second->get());
+                       eServiceEvent event;
+                       event.parseFrom(&evt, service.sid<<16|service.onid);
+                       eDebug("(1)erase no more used event %04x %d\n%s %s\n%s",
+                               service.sid, event_id,
+                               event.getBeginTimeString().c_str(),
+                               event.getEventName().c_str(),
+                               event.getExtendedDescription().c_str());
+#endif
+                       delete tmp->second;
+                       if (tmp == servicemap.second.begin())
+                       {
+                               servicemap.second.erase(tmp);
+                               break;
+                       }
+                       else
+                               servicemap.second.erase(tmp--);
+               }
+               else
+               {
+                       if (tmp == servicemap.second.begin())
+                               break;
+                       --tmp;
+               }
+       }
+
+       tmp = tm_it;
+       while(tmp->first < (TM+duration-300))
+       {
+               if (tmp->first != TM && tmp->second->type != PRIVATE)
+               {
+                       __u16 event_id = tmp->second->getEventID();
+                       servicemap.first.erase(event_id);
+#ifdef EPG_DEBUG  
+                       Event evt((uint8_t*)tmp->second->get());
+                       eServiceEvent event;
+                       event.parseFrom(&evt, service.sid<<16|service.onid);
+                       eDebug("(2)erase no more used event %04x %d\n%s %s\n%s",
+                               service.sid, event_id,
+                               event.getBeginTimeString().c_str(),
+                               event.getEventName().c_str(),
+                               event.getExtendedDescription().c_str());
+#endif
+                       delete tmp->second;
+                       servicemap.second.erase(tmp++);
+               }
+               else
+                       ++tmp;
+               if (tmp == servicemap.second.end())
+                       break;
+       }
+}
+

 void eEPGCache::sectionRead(const __u8 *data, int source, channel_data *channel)
 {
        eit_t *eit = (eit_t*) data;
 void eEPGCache::sectionRead(const __u8 *data, int source, channel_data *channel)
 {
        eit_t *eit = (eit_t*) data;


@@ -364,24 +431,24 @@ void eEPGCache::sectionRead(const __u8 *data, int source, channel_data *channel)
                        if ( ev_it != servicemap.first.end() )
                        {
                                if ( source > ev_it->second->type )  // update needed ?
                        if ( ev_it != servicemap.first.end() )
                        {
                                if ( source > ev_it->second->type )  // update needed ?

-                                       goto next; // when not.. the skip this entry
+                                       goto next; // when not.. then skip this entry

 
                                // search this event in timemap
 
                                // search this event in timemap

-                               timeMap::iterator tm_it_tmp = 
+                               timeMap::iterator tm_it_tmp =

                                        servicemap.second.find(ev_it->second->getStartTime());
 
                                if ( tm_it_tmp != servicemap.second.end() )
                                {
                                        servicemap.second.find(ev_it->second->getStartTime());
 
                                if ( tm_it_tmp != servicemap.second.end() )
                                {

-                                       if ( tm_it_tmp->first == TM ) // correct eventData
+                                       if ( tm_it_tmp->first == TM ) // just update eventdata

                                        {
                                                // exempt memory
                                                delete ev_it->second;
                                        {
                                                // exempt memory
                                                delete ev_it->second;

-                                               evt = new eventData(eit_event, eit_event_size, source);
-                                               ev_it->second=evt;
-                                               tm_it_tmp->second=evt;
+                                               ev_it->second = tm_it_tmp->second =
+                                                       new eventData(eit_event, eit_event_size, source);
+                                               FixOverlapping(servicemap, TM, duration, tm_it_tmp, service);

                                                goto next;
                                        }
                                                goto next;
                                        }

-                                       else
+                                       else  // event has new event begin time

                                        {
                                                tm_erase_count++;
                                                // delete the found record from timemap
                                        {
                                                tm_erase_count++;
                                                // delete the found record from timemap


@@ -391,45 +458,44 @@ void 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 
+                       // 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() )
                        {
                        // 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
-#if 0
-                               if ( source > tm_it->second->type && tm_erase_count == 0 ) // update needed ?
-                                       goto next; // when not.. the skip this entry
-#endif
+                               // event with same start time but another event_id...
+                               if ( source > tm_it->second->type &&
+                                       ev_it == servicemap.first.end() )
+                                       goto next; // when not.. then skip this entry

 
                                // search this time in eventmap
 
                                // search this time in eventmap

-                               eventMap::iterator ev_it_tmp = 
+                               eventMap::iterator ev_it_tmp =

                                        servicemap.first.find(tm_it->second->getEventID());
 
                                if ( ev_it_tmp != servicemap.first.end() )
                                {
                                        servicemap.first.find(tm_it->second->getEventID());
 
                                if ( ev_it_tmp != servicemap.first.end() )
                                {

-                                       ev_erase_count++;                               
+                                       ev_erase_count++;

                                        // delete the found record from eventmap
                                        servicemap.first.erase(ev_it_tmp);
                                        prevEventIt=servicemap.first.end();
                                }
                        }
                                        // delete the found record from eventmap
                                        servicemap.first.erase(ev_it_tmp);
                                        prevEventIt=servicemap.first.end();
                                }
                        }

-                       
+

                        evt = new eventData(eit_event, eit_event_size, source);
                        evt = new eventData(eit_event, eit_event_size, source);

-#if EPG_DEBUG
+#ifdef EPG_DEBUG

                        bool consistencyCheck=true;
 #endif
                        if (ev_erase_count > 0 && tm_erase_count > 0) // 2 different pairs have been removed
                        {
                                // exempt memory
                        bool consistencyCheck=true;
 #endif
                        if (ev_erase_count > 0 && tm_erase_count > 0) // 2 different pairs have been removed
                        {
                                // exempt memory

-                               delete ev_it->second; 
+                               delete ev_it->second;

                                delete tm_it->second;
                                ev_it->second=evt;
                                tm_it->second=evt;
                        }
                                delete tm_it->second;
                                ev_it->second=evt;
                                tm_it->second=evt;
                        }

-                       else if (ev_erase_count == 0 && tm_erase_count > 0) 
+                       else if (ev_erase_count == 0 && tm_erase_count > 0)

                        {
                                // exempt memory
                                delete ev_it->second;
                        {
                                // exempt memory
                                delete ev_it->second;


@@ -445,34 +511,37 @@ void eEPGCache::sectionRead(const __u8 *data, int source, channel_data *channel)
                        }
                        else // added new eventData
                        {
                        }
                        else // added new eventData
                        {

-#if EPG_DEBUG
+#ifdef EPG_DEBUG

                                consistencyCheck=false;
 #endif
                                consistencyCheck=false;
 #endif

-                               prevEventIt=servicemap.first.insert( prevEventIt, std::pair<const __u16, eventData*>( event_id, evt) );
-                               prevTimeIt=servicemap.second.insert( prevTimeIt, std::pair<const time_t, eventData*>( TM, evt ) );
+                               ev_it=prevEventIt=servicemap.first.insert( prevEventIt, std::pair<const __u16, eventData*>( event_id, evt) );
+                               tm_it=prevTimeIt=servicemap.second.insert( prevTimeIt, std::pair<const time_t, eventData*>( TM, evt ) );

                        }
                        }

-#if EPG_DEBUG
+
+                       FixOverlapping(servicemap, TM, duration, tm_it, service);
+
+#ifdef EPG_DEBUG

                        if ( consistencyCheck )
                        {
                                if ( tm_it->second != evt || ev_it->second != evt )
                                        eFatal("tm_it->second != ev_it->second");
                                else if ( tm_it->second->getStartTime() != tm_it->first )
                        if ( consistencyCheck )
                        {
                                if ( tm_it->second != evt || ev_it->second != evt )
                                        eFatal("tm_it->second != ev_it->second");
                                else if ( tm_it->second->getStartTime() != tm_it->first )

-                                       eFatal("event start_time(%d) non equal timemap key(%d)", 
+                                       eFatal("event start_time(%d) non equal timemap key(%d)",

                                                tm_it->second->getStartTime(), tm_it->first );
                                else if ( tm_it->first != TM )
                                                tm_it->second->getStartTime(), tm_it->first );
                                else if ( tm_it->first != TM )

-                                       eFatal("timemap key(%d) non equal TM(%d)", 
+                                       eFatal("timemap key(%d) non equal TM(%d)",

                                                tm_it->first, TM);
                                else if ( ev_it->second->getEventID() != ev_it->first )
                                        eFatal("event_id (%d) non equal event_map key(%d)",
                                                ev_it->second->getEventID(), ev_it->first);
                                else if ( ev_it->first != event_id )
                                                tm_it->first, TM);
                                else if ( ev_it->second->getEventID() != ev_it->first )
                                        eFatal("event_id (%d) non equal event_map key(%d)",
                                                ev_it->second->getEventID(), ev_it->first);
                                else if ( ev_it->first != event_id )

-                                       eFatal("eventmap key(%d) non equal event_id(%d)", 
+                                       eFatal("eventmap key(%d) non equal event_id(%d)",

                                                ev_it->first, event_id );
                        }
 #endif
                }
 next:
                                                ev_it->first, event_id );
                        }
 #endif
                }
 next:

-#if EPG_DEBUG
+#ifdef EPG_DEBUG

                if ( servicemap.first.size() != servicemap.second.size() )
                {
                        FILE *f = fopen("/hdd/event_map.txt", "w+");
                if ( servicemap.first.size() != servicemap.second.size() )
                {
                        FILE *f = fopen("/hdd/event_map.txt", "w+");


@@ -671,9 +740,18 @@ void eEPGCache::gotMessage( const Message &msg )
                                        chid.original_network_id.get() == msg.service.onid &&
                                        data->m_PrivatePid == -1 )
                                {
                                        chid.original_network_id.get() == msg.service.onid &&
                                        data->m_PrivatePid == -1 )
                                {

+                                       data->m_PrevVersion = -1;

                                        data->m_PrivatePid = msg.pid;
                                        data->m_PrivateService = msg.service;
                                        data->m_PrivatePid = msg.pid;
                                        data->m_PrivateService = msg.service;

-                                       data->startPrivateReader(msg.pid, -1);
+                                       updateMap::iterator It = channelLastUpdated.find( channel->getChannelID() );
+                                       int update = ( It != channelLastUpdated.end() ? ( UPDATE_INTERVAL - ( (time(0)+eDVBLocalTimeHandler::getInstance()->difference()-It->second) * 1000 ) ) : ZAP_DELAY );
+                                       if (update < ZAP_DELAY)
+                                               update = ZAP_DELAY;
+                                       data->startPrivateTimer.start(update, 1);
+                                       if (update >= 60000)
+                                               eDebug("[EPGC] next private update in %i min", update/60000);
+                                       else if (update >= 1000)
+                                               eDebug("[EPGC] next private update in %i sec", update/1000);

                                        break;
                                }
                        }
                                        break;
                                }
                        }


@@ -778,6 +856,7 @@ void eEPGCache::load()
                                                int size=0;
                                                uniqueEPGKey key;
                                                fread( &key, sizeof(uniqueEPGKey), 1, f);
                                                int size=0;
                                                uniqueEPGKey key;
                                                fread( &key, sizeof(uniqueEPGKey), 1, f);

+                                               eventMap &evMap=eventDB[key].first;

                                                fread( &size, sizeof(int), 1, f);
                                                while(size--)
                                                {
                                                fread( &size, sizeof(int), 1, f);
                                                while(size--)
                                                {


@@ -793,6 +872,10 @@ void eEPGCache::load()
                                                                fread( &time2, sizeof(time_t), 1, f);
                                                                fread( &event_id, sizeof(__u16), 1, f);
                                                                content_time_tables[key][content_id][time1]=std::pair<time_t, __u16>(time2, event_id);
                                                                fread( &time2, sizeof(time_t), 1, f);
                                                                fread( &event_id, sizeof(__u16), 1, f);
                                                                content_time_tables[key][content_id][time1]=std::pair<time_t, __u16>(time2, event_id);

+                                                               eventMap::iterator it =
+                                                                       evMap.find(event_id);
+                                                               if (it != evMap.end())
+                                                                       it->second->type = PRIVATE;

                                                        }
                                                }
                                        }
                                                        }
                                                }
                                        }


@@ -899,11 +982,13 @@ void eEPGCache::save()
 
 eEPGCache::channel_data::channel_data(eEPGCache *ml)
        :cache(ml)
 
 eEPGCache::channel_data::channel_data(eEPGCache *ml)
        :cache(ml)

-       ,abortTimer(ml), zapTimer(ml)
-       ,state(0), isRunning(0), haveData(0), can_delete(1)
+       ,abortTimer(ml), zapTimer(ml),state(0)
+       ,isRunning(0), haveData(0), can_delete(1)
+       ,startPrivateTimer(ml)

 {
        CONNECT(zapTimer.timeout, eEPGCache::channel_data::startEPG);
        CONNECT(abortTimer.timeout, eEPGCache::channel_data::abortNonAvail);
 {
        CONNECT(zapTimer.timeout, eEPGCache::channel_data::startEPG);
        CONNECT(abortTimer.timeout, eEPGCache::channel_data::abortNonAvail);

+       CONNECT(startPrivateTimer.timeout, eEPGCache::channel_data::startPrivateReader);

 }
 
 bool eEPGCache::channel_data::finishEPG()
 }
 
 bool eEPGCache::channel_data::finishEPG()


@@ -2118,7 +2203,7 @@ void eEPGCache::PMTready(eDVBServicePMTHandler *pmthandler)
                                if (tmp==3)
                                {
                                        eServiceReferenceDVB ref;
                                if (tmp==3)
                                {
                                        eServiceReferenceDVB ref;

-                                       if (!pmthandler->getService(ref))
+                                       if (!pmthandler->getServiceReference(ref))

                                        {
                                                int pid = (*es)->getPid();
                                                messages.send(Message(Message::got_private_pid, ref, pid));
                                        {
                                                int pid = (*es)->getPid();
                                                messages.send(Message(Message::got_private_pid, ref, pid));


@@ -2216,6 +2301,14 @@ void eEPGCache::privateSectionRead(const uniqueEPGKey &current_service, const __
                        onid |= data[ptr++];
                        int sid = data[ptr++] << 8;
                        sid |= data[ptr++];
                        onid |= data[ptr++];
                        int sid = data[ptr++] << 8;
                        sid |= data[ptr++];

+
+// WORKAROUND for wrong transmitted epg data
+                       if ( onid == 0x85 && tsid == 0x11 && sid == 0xd3 )  // premiere sends wrong tsid here
+                               tsid = 0x1;
+                       else if ( onid == 0x85 && tsid == 0x3 && sid == 0xf5 ) // premiere sends wrong sid here
+                               sid = 0xdc;
+////////////////////////////////////////////
+                               

                        uniqueEPGKey service( sid, onid, tsid );
                        descr_len -= 6;
                        while( descr_len > 0 )
                        uniqueEPGKey service( sid, onid, tsid );
                        descr_len -= 6;
                        while( descr_len > 0 )


@@ -2291,33 +2384,30 @@ void eEPGCache::privateSectionRead(const uniqueEPGKey &current_service, const __
                event[0] = (event_id & 0xFF00) >> 8;
                event[1] = (event_id & 0xFF);
                time_event_map[it->first.tm]=std::pair<time_t, __u16>(stime, event_id);
                event[0] = (event_id & 0xFF00) >> 8;
                event[1] = (event_id & 0xFF);
                time_event_map[it->first.tm]=std::pair<time_t, __u16>(stime, event_id);

-               eventData *d = new eventData( ev_struct, bptr, eEPGCache::SCHEDULE );
+               eventData *d = new eventData( ev_struct, bptr, eEPGCache::PRIVATE );

                evMap[event_id] = d;
                tmMap[stime] = d;
        }
 }
 
                evMap[event_id] = d;
                tmMap[stime] = d;
        }
 }
 

-void eEPGCache::channel_data::startPrivateReader(int pid, int version)
+void eEPGCache::channel_data::startPrivateReader()

 {
        eDVBSectionFilterMask mask;
        memset(&mask, 0, sizeof(mask));
 {
        eDVBSectionFilterMask mask;
        memset(&mask, 0, sizeof(mask));

-       mask.pid = pid;
+       mask.pid = m_PrivatePid;

        mask.flags = eDVBSectionFilterMask::rfCRC;
        mask.data[0] = 0xA0;
        mask.mask[0] = 0xFF;
        mask.flags = eDVBSectionFilterMask::rfCRC;
        mask.data[0] = 0xA0;
        mask.mask[0] = 0xFF;

-       eDebug("start privatefilter for pid %04x and version %d", pid, version);
-       if (version != -1)
+       eDebug("start privatefilter for pid %04x and version %d", m_PrivatePid, m_PrevVersion);
+       if (m_PrevVersion != -1)

        {
        {

-               mask.data[3] = version << 1;
+               mask.data[3] = m_PrevVersion << 1;

                mask.mask[3] = 0x3E;
                mask.mode[3] = 0x3E;
        }
        seenPrivateSections.clear();
        m_PrivateReader->connectRead(slot(*this, &eEPGCache::channel_data::readPrivateData), m_PrivateConn);
        m_PrivateReader->start(mask);
                mask.mask[3] = 0x3E;
                mask.mode[3] = 0x3E;
        }
        seenPrivateSections.clear();
        m_PrivateReader->connectRead(slot(*this, &eEPGCache::channel_data::readPrivateData), m_PrivateConn);
        m_PrivateReader->start(mask);

-#ifdef NEED_DEMUX_WORKAROUND
-       m_PrevVersion=version;
-#endif

 }
 
 void eEPGCache::channel_data::readPrivateData( const __u8 *data)
 }
 
 void eEPGCache::channel_data::readPrivateData( const __u8 *data)


@@ -2350,9 +2440,8 @@ void eEPGCache::channel_data::readPrivateData( const __u8 *data)
                        eDebug("[EPGC] private finished");
                        if (!isRunning)
                                can_delete = 1;
                        eDebug("[EPGC] private finished");
                        if (!isRunning)
                                can_delete = 1;

-                       int version = data[5];
-                       version = ((version & 0x3E) >> 1);
-                       startPrivateReader(m_PrivatePid, version);
+                       m_PrevVersion = (data[5] & 0x3E) >> 1;
+                       startPrivateReader();

                }
        }
 }
                }
        }
 }