#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
{
eDebug("[eEPGCache] remove channel %p", chan);
messages.send(Message(Message::leaveChannel, chan));
- while(!it->second->can_delete)
+ while(!it->second->canDelete())
usleep(1000);
delete it->second;
m_knownChannels.erase(it);
}
}
+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;
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);
- time_t now = time(0)+eDVBLocalTimeHandler::getInstance()->difference();
+ time_t now = eDVBLocalTimeHandler::getInstance()->nowTime();
if ( TM != 3599 && TM > -1)
channel->haveData |= source;
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
- timeMap::iterator tm_it_tmp =
+ timeMap::iterator tm_it_tmp =
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;
- 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;
}
- else
+ else // event has new event begin time
{
tm_erase_count++;
// delete the found record from timemap
}
}
- // 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() )
{
- // 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
- eventMap::iterator ev_it_tmp =
+ eventMap::iterator ev_it_tmp =
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();
}
}
-
+
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
- delete ev_it->second;
+ delete ev_it->second;
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;
}
else // added new eventData
{
-#if EPG_DEBUG
+#ifdef EPG_DEBUG
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 )
- 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 )
- 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 )
- 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:
-#if EPG_DEBUG
+#ifdef EPG_DEBUG
if ( servicemap.first.size() != servicemap.second.size() )
{
FILE *f = fopen("/hdd/event_map.txt", "w+");
{
eDebug("[EPGC] start cleanloop");
- time_t now = time(0)+eDVBLocalTimeHandler::getInstance()->difference();
+ time_t now = eDVBLocalTimeHandler::getInstance()->nowTime();
for (eventCache::iterator DBIt = eventDB.begin(); DBIt != eventDB.end(); DBIt++)
{
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->startPrivateReader(msg.pid, -1);
+ updateMap::iterator It = channelLastUpdated.find( channel->getChannelID() );
+ int update = ( It != channelLastUpdated.end() ? ( UPDATE_INTERVAL - ( (eDVBLocalTimeHandler::getInstance()->nowTime()-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;
}
}
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( &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;
}
}
}
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)
+ ,startPrivateTimer(ml)
{
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()
{
if (!isRunning) // epg ready
{
- eDebug("[EPGC] stop caching events(%ld)", time(0)+eDVBLocalTimeHandler::getInstance()->difference());
+ eDebug("[EPGC] stop caching events(%ld)", eDVBLocalTimeHandler::getInstance()->nowTime());
zapTimer.start(UPDATE_INTERVAL, 1);
eDebug("[EPGC] next update in %i min", UPDATE_INTERVAL / 60000);
for (int i=0; i < 3; ++i)
calcedSections[i].clear();
}
singleLock l(cache->cache_lock);
- cache->channelLastUpdated[channel->getChannelID()] = time(0)+eDVBLocalTimeHandler::getInstance()->difference();
-#ifdef ENABLE_PRIVATE_EPG
- if (seenPrivateSections.empty())
-#endif
- can_delete=1;
+ cache->channelLastUpdated[channel->getChannelID()] = eDVBLocalTimeHandler::getInstance()->nowTime();
return true;
}
return false;
void eEPGCache::channel_data::startEPG()
{
- eDebug("[EPGC] start caching events(%ld)", eDVBLocalTimeHandler::getInstance()->difference()+time(0));
+ eDebug("[EPGC] start caching events(%ld)", eDVBLocalTimeHandler::getInstance()->nowTime());
state=0;
haveData=0;
- can_delete=0;
for (int i=0; i < 3; ++i)
{
seenSections[i].clear();
{
if (!state)
{
- if ( !(haveData&eEPGCache::NOWNEXT) && (isRunning&eEPGCache::NOWNEXT) )
+ if ( !(haveData&NOWNEXT) && (isRunning&NOWNEXT) )
{
eDebug("[EPGC] abort non avail nownext reading");
- isRunning &= ~eEPGCache::NOWNEXT;
+ isRunning &= ~NOWNEXT;
m_NowNextReader->stop();
m_NowNextConn=0;
}
- if ( !(haveData&eEPGCache::SCHEDULE) && (isRunning&eEPGCache::SCHEDULE) )
+ if ( !(haveData&SCHEDULE) && (isRunning&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) )
+ if ( !(haveData&SCHEDULE_OTHER) && (isRunning&SCHEDULE_OTHER) )
{
eDebug("[EPGC] abort non avail schedule_other reading");
isRunning &= ~SCHEDULE_OTHER;
seenSections[i].clear();
calcedSections[i].clear();
}
-#ifdef ENABLE_PRIVATE_EPG
- if (seenPrivateSections.empty())
-#endif
- can_delete=1;
}
}
++state;
{
updateMap::iterator It = cache->channelLastUpdated.find( channel->getChannelID() );
- int update = ( It != cache->channelLastUpdated.end() ? ( UPDATE_INTERVAL - ( (time(0)+eDVBLocalTimeHandler::getInstance()->difference()-It->second) * 1000 ) ) : ZAP_DELAY );
+ int update = ( It != cache->channelLastUpdated.end() ? ( UPDATE_INTERVAL - ( (eDVBLocalTimeHandler::getInstance()->nowTime()-It->second) * 1000 ) ) : ZAP_DELAY );
if (update < ZAP_DELAY)
update = ZAP_DELAY;
if (isRunning)
{
eDebug("[EPGC] abort caching events !!");
- if (isRunning & eEPGCache::SCHEDULE)
+ if (isRunning & SCHEDULE)
{
- isRunning &= ~eEPGCache::SCHEDULE;
+ isRunning &= ~SCHEDULE;
m_ScheduleReader->stop();
m_ScheduleConn=0;
}
- if (isRunning & eEPGCache::NOWNEXT)
+ if (isRunning & NOWNEXT)
{
- isRunning &= ~eEPGCache::NOWNEXT;
+ isRunning &= ~NOWNEXT;
m_NowNextReader->stop();
m_NowNextConn=0;
}
if (isRunning & SCHEDULE_OTHER)
{
- isRunning &= ~eEPGCache::SCHEDULE_OTHER;
+ isRunning &= ~SCHEDULE_OTHER;
m_ScheduleOtherReader->stop();
m_ScheduleOtherConn=0;
}
if (m_PrivateConn)
m_PrivateConn=0;
#endif
- can_delete=1;
}
void eEPGCache::channel_data::readData( const __u8 *data)
{
case 0x4E ... 0x4F:
reader=m_NowNextReader;
- source=eEPGCache::NOWNEXT;
+ source=NOWNEXT;
map=0;
break;
case 0x50 ... 0x5F:
reader=m_ScheduleReader;
- source=eEPGCache::SCHEDULE;
+ source=SCHEDULE;
map=1;
break;
case 0x60 ... 0x6F:
reader=m_ScheduleOtherReader;
- source=eEPGCache::SCHEDULE_OTHER;
+ source=SCHEDULE_OTHER;
map=2;
break;
default:
eDebugNoNewLine("[EPGC] ");
switch (source)
{
- case eEPGCache::NOWNEXT:
+ case NOWNEXT:
m_NowNextConn=0;
eDebugNoNewLine("nownext");
break;
- case eEPGCache::SCHEDULE:
+ case SCHEDULE:
m_ScheduleConn=0;
eDebugNoNewLine("schedule");
break;
- case eEPGCache::SCHEDULE_OTHER:
+ case SCHEDULE_OTHER:
m_ScheduleOtherConn=0;
eDebugNoNewLine("schedule other");
break;
default: eDebugNoNewLine("unknown");break;
}
- eDebug(" finished(%ld)", time(0)+eDVBLocalTimeHandler::getInstance()->difference());
+ eDebug(" finished(%ld)", eDVBLocalTimeHandler::getInstance()->nowTime());
if ( reader )
reader->stop();
isRunning &= ~source;
if ( It != eventDB.end() && !It->second.first.empty() ) // entrys cached ?
{
if (t==-1)
- t = time(0)+eDVBLocalTimeHandler::getInstance()->difference();
+ t = eDVBLocalTimeHandler::getInstance()->nowTime();
timeMap::iterator i = direction <= 0 ? It->second.second.lower_bound(t) : // find > or equal
It->second.second.upper_bound(t); // just >
if ( i != It->second.second.end() )
}
PyObject *nowTime = strchr(argstring, 'C') ?
- PyLong_FromLong(time(0)+eDVBLocalTimeHandler::getInstance()->difference()) :
+ PyLong_FromLong(eDVBLocalTimeHandler::getInstance()->nowTime()) :
NULL;
bool must_get_service_name = strchr(argstring, 'N') ? true : false;
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 )
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, PRIVATE );
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));
- mask.pid = pid;
+ mask.pid = m_PrivatePid;
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);
+ if (!m_PrivateConn)
+ 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)
{
if ( seenPrivateSections.find( data[6] ) == seenPrivateSections.end() )
{
-#ifdef NEED_DEMUX_WORKAROUND
- int version = data[5];
- version = ((version & 0x3E) >> 1);
- can_delete = 0;
- if ( m_PrevVersion != version )
- {
- cache->privateSectionRead(m_PrivateService, data);
- seenPrivateSections.insert(data[6]);
- }
- else
- eDebug("ignore");
-#else
- can_delete = 0;
cache->privateSectionRead(m_PrivateService, data);
seenPrivateSections.insert(data[6]);
-#endif
}
if ( seenPrivateSections.size() == (unsigned int)(data[7] + 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();
}
}
}
git.cweiske.de / enigma2.git / blobdiff