#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;
+__u8 eventData::data[4108];
+extern const uint32_t crc32_table[256];
+
+eventData::eventData(const eit_event_struct* e, int size, int type)
+ :ByteSize(size&0xFF), type(type&0xFF)
+{
+ if (!e)
+ return;
+
+ __u32 descr[65];
+ __u32 *pdescr=descr;
+
+ __u8 *data = (__u8*)e;
+ int ptr=10;
+ int descriptors_length = (data[ptr++]&0x0F) << 8;
+ descriptors_length |= data[ptr++];
+ while ( descriptors_length > 0 )
+ {
+ __u8 *descr = data+ptr;
+ int descr_len = descr[1]+2;
+
+ __u32 crc = 0;
+ int cnt=0;
+ while(cnt++ < descr_len)
+ crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ data[ptr++]) & 0xFF];
+
+ descriptorMap::iterator it =
+ descriptors.find(crc);
+ if ( it == descriptors.end() )
+ {
+ CacheSize+=descr_len;
+ __u8 *d = new __u8[descr_len];
+ memcpy(d, descr, descr_len);
+ descriptors[crc] = descriptorPair(1, d);
+ }
+ else
+ ++it->second.first;
+
+ *pdescr++=crc;
+ descriptors_length -= descr_len;
+ }
+ ByteSize = 12+((pdescr-descr)*4);
+ EITdata = new __u8[ByteSize];
+ CacheSize+=ByteSize;
+ memcpy(EITdata, (__u8*) e, 12);
+ memcpy(EITdata+12, descr, ByteSize-12);
+}
+
+const eit_event_struct* eventData::get() const
+{
+ int pos = 12;
+ int tmp = ByteSize-12;
+
+ memcpy(data, EITdata, 12);
+ __u32 *p = (__u32*)(EITdata+12);
+ while(tmp>0)
+ {
+ descriptorMap::iterator it =
+ descriptors.find(*p++);
+ if ( it != descriptors.end() )
+ {
+ int b = it->second.second[1]+2;
+ memcpy(data+pos, it->second.second, b );
+ pos += b;
+ }
+ tmp-=4;
+ }
+
+ return (const 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 -= it->second.second[1];
+ delete [] it->second.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=
PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
+pthread_mutex_t eEPGCache::channel_map_lock=
+ PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
DEFINE_REF(eEPGCache)
eEPGCache::eEPGCache()
- :messages(this,1), back_messages(this,1) ,paused(0)
- ,CleanTimer(this), zapTimer(this), abortTimer(this)
+ :messages(this,1), cleanTimer(this)//, paused(0)
{
eDebug("[EPGC] Initialized EPGCache");
- isRunning=0;
CONNECT(messages.recv_msg, eEPGCache::gotMessage);
- CONNECT(back_messages.recv_msg, eEPGCache::gotBackMessage);
-// CONNECT(eDVB::getInstance()->switchedService, eEPGCache::enterService);
-// CONNECT(eDVB::getInstance()->leaveService, eEPGCache::leaveService);
CONNECT(eDVBLocalTimeHandler::getInstance()->m_timeUpdated, eEPGCache::timeUpdated);
- CONNECT(zapTimer.timeout, eEPGCache::startEPG);
- CONNECT(CleanTimer.timeout, eEPGCache::cleanLoop);
- CONNECT(abortTimer.timeout, eEPGCache::abortNonAvail);
+ CONNECT(cleanTimer.timeout, eEPGCache::cleanLoop);
+
+ ePtr<eDVBResourceManager> res_mgr;
+ eDVBResourceManager::getInstance(res_mgr);
+ if (!res_mgr)
+ eDebug("[eEPGCache] no resource manager !!!!!!!");
+ else
+ res_mgr->connectChannelAdded(slot(*this,&eEPGCache::DVBChannelAdded), m_chanAddedConn);
instance=this;
}
messages.send(Message(Message::timeChanged));
}
-int eEPGCache::sectionRead(const __u8 *data, int source)
+void eEPGCache::DVBChannelAdded(eDVBChannel *chan)
+{
+ if ( chan )
+ {
+// eDebug("[eEPGCache] add channel %p", chan);
+ channel_data *data = new channel_data(this);
+ data->channel = chan;
+ singleLock s(channel_map_lock);
+ m_knownChannels.insert( std::pair<iDVBChannel*, channel_data* >(chan, data) );
+ chan->connectStateChange(slot(*this, &eEPGCache::DVBChannelStateChanged), data->m_stateChangedConn);
+ }
+}
+
+void eEPGCache::DVBChannelRunning(iDVBChannel *chan)
+{
+ singleLock s(channel_map_lock);
+ channelMapIterator it =
+ m_knownChannels.find(chan);
+ if ( it == m_knownChannels.end() )
+ eDebug("[eEPGCache] will start non existing channel %p !!!", chan);
+ else
+ {
+ channel_data &data = *it->second;
+ ePtr<eDVBResourceManager> res_mgr;
+ if ( eDVBResourceManager::getInstance( res_mgr ) )
+ eDebug("[eEPGCache] no res manager!!");
+ else
+ {
+ ePtr<iDVBDemux> demux;
+ if ( data.channel->getDemux(demux, 0) )
+ {
+ eDebug("[eEPGCache] no demux!!");
+ return;
+ }
+ else
+ {
+ RESULT res = demux->createSectionReader( this, data.m_NowNextReader );
+ if ( res )
+ {
+ eDebug("[eEPGCache] couldnt initialize nownext reader!!");
+ return;
+ }
+
+ res = demux->createSectionReader( this, data.m_ScheduleReader );
+ if ( res )
+ {
+ eDebug("[eEPGCache] couldnt initialize schedule reader!!");
+ return;
+ }
+
+ res = demux->createSectionReader( this, data.m_ScheduleOtherReader );
+ if ( res )
+ {
+ eDebug("[eEPGCache] couldnt initialize schedule other reader!!");
+ return;
+ }
+
+ messages.send(Message(Message::startChannel, chan));
+ // -> gotMessage -> changedService
+ }
+ }
+ }
+}
+
+void eEPGCache::DVBChannelStateChanged(iDVBChannel *chan)
+{
+ channelMapIterator it =
+ m_knownChannels.find(chan);
+ if ( it != m_knownChannels.end() )
+ {
+ int state=0;
+ chan->getState(state);
+ switch (state)
+ {
+ case iDVBChannel::state_ok:
+ {
+ eDebug("[eEPGCache] channel %p running", chan);
+ DVBChannelRunning(chan);
+ break;
+ }
+ case iDVBChannel::state_release:
+ {
+ eDebug("[eEPGCache] remove channel %p", chan);
+ messages.send(Message(Message::leaveChannel, chan));
+ while(!it->second->can_delete)
+ usleep(1000);
+ delete it->second;
+ m_knownChannels.erase(it);
+ // -> gotMessage -> abortEPG
+ break;
+ }
+ }
+ }
+}
+
+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 )
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)
- {
- switch(source)
- {
- case NOWNEXT:
- haveData |= 2;
- break;
- case SCHEDULE:
- haveData |= 1;
- break;
- case SCHEDULE_OTHER:
- haveData |= 4;
- break;
- }
- }
+ channel->haveData |= source;
- Lock();
+ singleLock s(cache_lock);
// hier wird immer eine eventMap zurück gegeben.. entweder eine vorhandene..
// oder eine durch [] erzeugte
std::pair<eventMap,timeMap> &servicemap = eventDB[service];
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);
{
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());
}
}
-// 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());
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",
ptr += eit_event_size;
eit_event=(eit_event_struct*)(((__u8*)eit_event)+eit_event_size);
}
-
- tmpMap::iterator it = temp.find( service );
- if ( it != temp.end() )
- {
- if ( source > it->second.second )
- {
- it->second.first=now;
- it->second.second=source;
- }
- }
- else
- temp[service] = std::pair< time_t, int> (now, source);
-
- Unlock();
-
- return 0;
-}
-
-bool eEPGCache::finishEPG()
-{
- if (!isRunning) // epg ready
- {
- eDebug("[EPGC] stop caching events");
- zapTimer.start(UPDATE_INTERVAL, 1);
- eDebug("[EPGC] next update in %i min", UPDATE_INTERVAL / 60000);
-
- singleLock l(cache_lock);
- tmpMap::iterator It = temp.begin();
- abortTimer.stop();
-
- while (It != temp.end())
- {
-// eDebug("sid = %02x, onid = %02x, type %d", It->first.sid, It->first.onid, It->second.second );
- if ( It->second.second == SCHEDULE
- || ( It->second.second == NOWNEXT && !(haveData&1) )
- )
- {
-// eDebug("ADD to last updated Map");
- serviceLastUpdated[It->first]=It->second.first;
- }
- if ( eventDB.find( It->first ) == eventDB.end() )
- {
-// eDebug("REMOVE from update Map");
- temp.erase(It++);
- }
- else
- It++;
- }
- if (!eventDB[current_service].first.empty())
- /*emit*/ EPGAvail(1);
-
- /*emit*/ EPGUpdated();
-
- return true;
- }
- return false;
}
void eEPGCache::flushEPG(const uniqueEPGKey & s)
{
eDebug("[EPGC] flushEPG %d", (int)(bool)s);
- Lock();
+ singleLock l(cache_lock);
if (s) // clear only this service
{
eventCache::iterator it = eventDB.find(s);
delete i->second;
evMap.clear();
eventDB.erase(it);
- updateMap::iterator u = serviceLastUpdated.find(s);
- if ( u != serviceLastUpdated.end() )
- serviceLastUpdated.erase(u);
- startEPG();
+
+ // TODO .. search corresponding channel for removed service and remove this channel from lastupdated map
}
}
else // clear complete EPG Cache
evMap.clear();
tmMap.clear();
}
- serviceLastUpdated.clear();
eventDB.clear();
- startEPG();
+ channelLastUpdated.clear();
+ singleLock m(channel_map_lock);
+ for (channelMapIterator it(m_knownChannels.begin()); it != m_knownChannels.end(); ++it)
+ it->second->startEPG();
}
eDebug("[EPGC] %i bytes for cache used", eventData::CacheSize);
- Unlock();
}
void eEPGCache::cleanLoop()
{
singleLock s(cache_lock);
- if ( isRunning )
- {
- CleanTimer.start(5000,true);
- eDebug("[EPGC] schedule cleanloop");
- return;
- }
- if (!eventDB.empty() && !paused )
+ 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()));
delete It->second;
DBIt->second.second.erase(It++);
// eDebug("[EPGC] delete old event (timeMap)");
-
- // add this (changed) service to temp map...
- if ( temp.find(DBIt->first) == temp.end() )
- temp[DBIt->first]=std::pair<time_t, int>(now, NOWNEXT);
}
else
++It;
}
- if ( DBIt->second.second.size() < 2 )
- // less than two events for this service in cache..
- {
- updateMap::iterator u = serviceLastUpdated.find(DBIt->first);
- if ( u != serviceLastUpdated.end() )
- {
- // remove from lastupdated map..
- serviceLastUpdated.erase(u);
- // current service?
- if ( DBIt->first == current_service )
- {
- // immediate .. after leave cleanloop
- // update epgdata for this service
- zapTimer.start(0,true);
- }
- }
- }
}
-
- if (temp.size())
- /*emit*/ EPGUpdated();
-
eDebug("[EPGC] stop cleanloop");
eDebug("[EPGC] %i bytes for cache used", eventData::CacheSize);
}
- CleanTimer.start(CLEAN_INTERVAL,true);
+ cleanTimer.start(CLEAN_INTERVAL,true);
}
eEPGCache::~eEPGCache()
{
messages.send(Message::quit);
kill(); // waiting for thread shutdown
- Lock();
+ singleLock s(cache_lock);
for (eventCache::iterator evIt = eventDB.begin(); evIt != eventDB.end(); evIt++)
for (eventMap::iterator It = evIt->second.first.begin(); It != evIt->second.first.end(); It++)
delete It->second;
- Unlock();
}
-Event *eEPGCache::lookupEvent(const eServiceReferenceDVB &service, int event_id, bool plain)
+void eEPGCache::gotMessage( const Message &msg )
{
- singleLock s(cache_lock);
- uniqueEPGKey key( service );
-
- eventCache::iterator It = eventDB.find( key );
- if ( It != eventDB.end() && !It->second.first.empty() ) // entrys cached?
+ switch (msg.type)
{
- eventMap::iterator i( It->second.first.find( event_id ));
- if ( i != It->second.first.end() )
+ case Message::flush:
+ flushEPG(msg.service);
+ break;
+ case Message::startChannel:
{
- 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*/ );
+ singleLock s(channel_map_lock);
+ channelMapIterator channel =
+ m_knownChannels.find(msg.channel);
+ if ( channel != m_knownChannels.end() )
+ channel->second->startChannel();
+ break;
}
- else
- eDebug("event %04x not found in epgcache", event_id);
+ case Message::leaveChannel:
+ {
+ singleLock s(channel_map_lock);
+ channelMapIterator channel =
+ m_knownChannels.find(msg.channel);
+ if ( channel != m_knownChannels.end() )
+ channel->second->abortEPG();
+ break;
+ }
+ case Message::quit:
+ quit(0);
+ break;
+ case Message::timeChanged:
+ cleanLoop();
+ break;
+ default:
+ eDebug("unhandled EPGCache Message!!");
+ break;
}
- return 0;
}
-Event *eEPGCache::lookupEvent(const eServiceReferenceDVB &service, time_t t, bool plain )
-// if t == 0 we search the current event...
+void eEPGCache::thread()
{
- singleLock s(cache_lock);
- uniqueEPGKey key(service);
+ nice(4);
+ load();
+ cleanLoop();
+ exec();
+ save();
+}
- // check if EPG for this service is ready...
- eventCache::iterator It = eventDB.find( key );
- if ( It != eventDB.end() && !It->second.first.empty() ) // entrys cached ?
+void eEPGCache::load()
+{
+#if 0
+ FILE *f = fopen("/hdd/epg.dat", "r");
+ if (f)
{
- if (!t)
- t = time(0)+eDVBLocalTimeHandler::getInstance()->difference();
-
- timeMap::iterator i = It->second.second.lower_bound(t);
- if ( i != It->second.second.end() )
+ unsigned char md5_saved[16];
+ unsigned char md5[16];
+ int size=0;
+ int cnt=0;
+ bool md5ok=false;
+ if (!md5_file("/hdd/epg.dat", 1, md5))
{
- i--;
- if ( i != It->second.second.end() )
+ FILE *f = fopen("/hdd/epg.dat.md5", "r");
+ if (f)
{
- 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 ( 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 */ );
- }
+ fread( md5_saved, 16, 1, f);
+ fclose(f);
+ if ( !memcmp(md5_saved, md5, 16) )
+ md5ok=true;
}
}
-
- for ( eventMap::iterator i( It->second.first.begin() ); i != It->second.first.end(); i++)
+ if ( md5ok )
{
- 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);
- if ( t >= begTime && t <= begTime+duration) // then we have found
+ char text1[13];
+ fread( text1, 13, 1, f);
+ if ( !strncmp( text1, "ENIGMA_EPG_V4", 13) )
{
- 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*/ );
+ fread( &size, sizeof(int), 1, f);
+ while(size--)
+ {
+ uniqueEPGKey key;
+ eventMap evMap;
+ timeMap tmMap;
+ int size=0;
+ fread( &key, sizeof(uniqueEPGKey), 1, f);
+ fread( &size, sizeof(int), 1, f);
+ while(size--)
+ {
+ __u8 len=0;
+ __u8 type=0;
+ eventData *event=0;
+ fread( &type, sizeof(__u8), 1, f);
+ fread( &len, sizeof(__u8), 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);
+ }
+ eventData::load(f);
+ eDebug("%d events read from /hdd/epg.dat", cnt);
}
+ else
+ eDebug("[EPGC] don't read old epg database");
+ fclose(f);
}
}
- return 0;
-}
-
-void eEPGCache::pauseEPG()
-{
- if (!paused)
- {
- abortEPG();
- eDebug("[EPGC] paused]");
- paused=1;
- }
+#endif
}
-void eEPGCache::restartEPG()
+void eEPGCache::save()
{
- if (paused)
+#if 0
+ struct statfs s;
+ off64_t tmp;
+ if (statfs("/hdd", &s)<0)
+ tmp=0;
+ else
{
- isRunning=0;
- eDebug("[EPGC] restarted");
- paused--;
- if (paused)
- {
- paused = 0;
- startEPG(); // updateEPG
- }
- cleanLoop();
+ tmp=s.f_blocks;
+ tmp*=s.f_bsize;
}
-}
-void eEPGCache::startEPG()
-{
- if (paused) // called from the updateTimer during pause...
- {
- paused++;
+ // prevent writes to builtin flash
+ if ( tmp < 1024*1024*50 ) // storage size < 50MB
return;
- }
- if (eDVBLocalTimeHandler::getInstance()->ready())
- {
- Lock();
- temp.clear();
- Unlock();
- eDebug("[EPGC] start caching events");
- state=0;
- haveData=0;
-
- eDVBSectionFilterMask mask;
- memset(&mask, 0, sizeof(mask));
- mask.pid = 0x12;
- mask.flags = eDVBSectionFilterMask::rfCRC;
- mask.data[0] = 0x4E;
- mask.mask[0] = 0xFE;
- m_NowNextReader->start(mask);
- isRunning |= 1;
-
- mask.data[0] = 0x50;
- mask.mask[0] = 0xF0;
- m_ScheduleReader->start(mask);
- isRunning |= 2;
-
- mask.data[0] = 0x60;
- mask.mask[0] = 0xF0;
- m_ScheduleOtherReader->start(mask);
- isRunning |= 4;
+ // check for enough free space on storage
+ tmp=s.f_bfree;
+ tmp*=s.f_bsize;
+ if ( tmp < (eventData::CacheSize*12)/10 ) // 20% overhead
+ return;
- abortTimer.start(5000,true);
- }
- else
+ FILE *f = fopen("/hdd/epg.dat", "w");
+ int cnt=0;
+ if ( f )
+ {
+ const char *text = "ENIGMA_EPG_V4";
+ 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)
+ {
+ timeMap &timemap = service_it->second.second;
+ fwrite( &service_it->first, sizeof(uniqueEPGKey), 1, f);
+ size = timemap.size();
+ fwrite( &size, sizeof(int), 1, f);
+ for (timeMap::iterator time_it(timemap.begin()); time_it != timemap.end(); ++time_it)
+ {
+ __u8 len = time_it->second->ByteSize;
+ fwrite( &time_it->second->type, sizeof(__u8), 1, f );
+ fwrite( &len, sizeof(__u8), 1, f);
+ fwrite( time_it->second->EITdata, len, 1, f);
+ ++cnt;
+ }
+ }
+ 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))
+ {
+ FILE *f = fopen("/hdd/epg.dat.md5", "w");
+ if (f)
+ {
+ fwrite( md5, 16, 1, f);
+ fclose(f);
+ }
+ }
+ }
+#endif
+}
+
+eEPGCache::channel_data::channel_data(eEPGCache *ml)
+ :cache(ml)
+ ,abortTimer(ml), zapTimer(ml)
+ ,state(0), isRunning(0), haveData(0), can_delete(1)
+{
+ CONNECT(zapTimer.timeout, eEPGCache::channel_data::startEPG);
+ CONNECT(abortTimer.timeout, eEPGCache::channel_data::abortNonAvail);
+}
+
+bool eEPGCache::channel_data::finishEPG()
+{
+ if (!isRunning) // epg ready
+ {
+ 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;
+ return true;
+ }
+ return false;
+}
+
+void eEPGCache::channel_data::startEPG()
+{
+ 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)
{
- eDebug("[EPGC] wait for clock update");
- zapTimer.start(1000, 1); // restart Timer
+ seenSections[i].clear();
+ calcedSections[i].clear();
}
+
+ eDVBSectionFilterMask mask;
+ memset(&mask, 0, sizeof(mask));
+ mask.pid = 0x12;
+ mask.flags = eDVBSectionFilterMask::rfCRC;
+
+ 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(7000,true);
}
-void eEPGCache::abortNonAvail()
+void eEPGCache::channel_data::abortNonAvail()
{
if (!state)
{
- if ( !(haveData&2) && (isRunning&2) )
+ if ( !(haveData&eEPGCache::NOWNEXT) && (isRunning&eEPGCache::NOWNEXT) )
{
eDebug("[EPGC] abort non avail nownext reading");
- isRunning &= ~2;
- if ( m_NowNextReader )
- m_NowNextReader->stop();
+ isRunning &= ~eEPGCache::NOWNEXT;
+ m_NowNextReader->stop();
+ m_NowNextConn=0;
}
- if ( !(haveData&1) && (isRunning&1) )
+ if ( !(haveData&eEPGCache::SCHEDULE) && (isRunning&eEPGCache::SCHEDULE) )
{
eDebug("[EPGC] abort non avail schedule reading");
- isRunning &= ~1;
+ isRunning &= ~SCHEDULE;
m_ScheduleReader->stop();
+ m_ScheduleConn=0;
}
- if ( !(haveData&4) && (isRunning&4) )
+ if ( !(haveData&eEPGCache::SCHEDULE_OTHER) && (isRunning&eEPGCache::SCHEDULE_OTHER) )
{
eDebug("[EPGC] abort non avail schedule_other reading");
- isRunning &= ~4;
+ isRunning &= ~SCHEDULE_OTHER;
m_ScheduleOtherReader->stop();
+ m_ScheduleOtherConn=0;
+ }
+ if ( isRunning )
+ abortTimer.start(90000, true);
+ else
+ {
+ ++state;
+ for (int i=0; i < 3; ++i)
+ {
+ seenSections[i].clear();
+ calcedSections[i].clear();
+ }
+ can_delete=1;
}
- abortTimer.start(20000, true);
}
++state;
}
-void eEPGCache::startCache(const eServiceReferenceDVB& ref)
+void eEPGCache::channel_data::startChannel()
+{
+ 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 );
+
+ if (update < ZAP_DELAY)
+ update = ZAP_DELAY;
+
+ zapTimer.start(update, 1);
+ if (update >= 60000)
+ eDebug("[EPGC] next update in %i min", update/60000);
+ else if (update >= 1000)
+ eDebug("[EPGC] next update in %i sec", update/1000);
+}
+
+void eEPGCache::channel_data::abortEPG()
{
- if ( m_currentChannel )
+ for (int i=0; i < 3; ++i)
{
- next_service = ref;
- leaveChannel(m_currentChannel);
- return;
+ seenSections[i].clear();
+ calcedSections[i].clear();
}
- eDVBChannelID chid;
- ref.getChannelID( chid );
- ePtr<eDVBResourceManager> res_mgr;
- if ( eDVBResourceManager::getInstance( res_mgr ) )
- eDebug("[eEPGCache] no res manager!!");
- else
+ abortTimer.stop();
+ zapTimer.stop();
+ if (isRunning)
{
- ePtr<iDVBDemux> demux;
-// res_mgr->allocateChannel(chid, m_currentChannel);
- if ( m_currentChannel->getDemux(demux) )
+ eDebug("[EPGC] abort caching events !!");
+ if (isRunning & eEPGCache::SCHEDULE)
{
- eDebug("[eEPGCache] no demux!!");
- goto error4;
+ isRunning &= ~eEPGCache::SCHEDULE;
+ m_ScheduleReader->stop();
+ m_ScheduleConn=0;
}
- else
+ if (isRunning & eEPGCache::NOWNEXT)
{
- RESULT res;
- m_NowNextReader = new eDVBSectionReader( demux, this, res );
- if ( res )
- {
- eDebug("[eEPGCache] couldnt initialize nownext reader!!");
- goto error3;
- }
- m_NowNextReader->connectRead(slot(*this, &eEPGCache::readNowNextData), m_NowNextConn);
- m_ScheduleReader = new eDVBSectionReader( demux, this, res );
- if ( res )
- {
- eDebug("[eEPGCache] couldnt initialize schedule reader!!");
- goto error2;
- }
- m_ScheduleReader->connectRead(slot(*this, &eEPGCache::readScheduleData), m_ScheduleConn);
- m_ScheduleOtherReader = new eDVBSectionReader( demux, this, res );
- if ( res )
- {
- eDebug("[eEPGCache] couldnt initialize schedule other reader!!");
- goto error1;
- }
- m_ScheduleOtherReader->connectRead(slot(*this, &eEPGCache::readScheduleOtherData), m_ScheduleOtherConn);
- messages.send(Message(Message::startService, ref));
- // -> gotMessage -> changedService
+ isRunning &= ~eEPGCache::NOWNEXT;
+ m_NowNextReader->stop();
+ m_NowNextConn=0;
}
+ if (isRunning & SCHEDULE_OTHER)
+ {
+ isRunning &= ~eEPGCache::SCHEDULE_OTHER;
+ m_ScheduleOtherReader->stop();
+ m_ScheduleOtherConn=0;
+ }
+ can_delete=1;
}
- return;
-error1:
- m_ScheduleOtherReader=0;
- m_ScheduleOtherConn=0;
-error2:
- m_ScheduleReader=0;
- m_ScheduleConn=0;
-error3:
- m_NowNextReader=0;
- m_NowNextConn=0;
-error4:
- m_currentChannel=0;
}
-void eEPGCache::leaveChannel(iDVBChannel * chan)
+void eEPGCache::channel_data::readData( const __u8 *data)
{
- if ( chan && chan == m_currentChannel )
+ if (!data)
+ eDebug("get Null pointer from section reader !!");
+ else
{
- messages.send(Message(Message::leaveChannel, chan));
- // -> gotMessage -> abortEPG
+ int source;
+ int map;
+ iDVBSectionReader *reader=NULL;
+ switch(data[0])
+ {
+ 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::NOWNEXT:
+ m_NowNextConn=0;
+ eDebugNoNewLine("nownext");
+ break;
+ case eEPGCache::SCHEDULE:
+ m_ScheduleConn=0;
+ eDebugNoNewLine("schedule");
+ break;
+ case eEPGCache::SCHEDULE_OTHER:
+ m_ScheduleOtherConn=0;
+ eDebugNoNewLine("schedule other");
+ break;
+ default: eDebugNoNewLine("unknown");break;
+ }
+ eDebug(" finished(%d)", time(0)+eDVBLocalTimeHandler::getInstance()->difference());
+ if ( reader )
+ reader->stop();
+ isRunning &= ~source;
+ if (!isRunning)
+ finishEPG();
+ }
+ else
+ {
+ 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);
+ }
+ }
}
}
-void eEPGCache::changedService(const uniqueEPGKey &service)
+RESULT eEPGCache::lookupEvent(const eServiceReference &service, time_t t, const eventData *&result )
+// if t == 0 we search the current event...
{
- current_service = service;
- updateMap::iterator It = serviceLastUpdated.find( current_service );
-
- int update;
-
-// check if this is a subservice and this is only a dbox2
-// then we dont start epgcache on subservice change..
-// ever and ever..
+ singleLock s(cache_lock);
+ uniqueEPGKey key(service);
-// if ( !err || err == -ENOCASYS )
+ // check if EPG for this service is ready...
+ eventCache::iterator It = eventDB.find( key );
+ if ( It != eventDB.end() && !It->second.first.empty() ) // entrys cached ?
{
- update = ( It != serviceLastUpdated.end() ? ( UPDATE_INTERVAL - ( (time(0)+eDVBLocalTimeHandler::getInstance()->difference()-It->second) * 1000 ) ) : ZAP_DELAY );
+ if (!t)
+ t = time(0)+eDVBLocalTimeHandler::getInstance()->difference();
- if (update < ZAP_DELAY)
- update = ZAP_DELAY;
+// TODO: optimize this.. why we here search first in timemap.. and then in eventmap??
+ timeMap::iterator i = It->second.second.lower_bound(t);
+ if ( i != It->second.second.end() )
+ {
+ if ( i != It->second.second.end() )
+ {
+ if ( t <= i->first+i->second->getDuration() )
+ {
+ result = i->second;
+ return 0;
+ }
+ }
+ }
- zapTimer.start(update, 1);
- if (update >= 60000)
- eDebug("[EPGC] next update in %i min", update/60000);
- else if (update >= 1000)
- eDebug("[EPGC] next update in %i sec", update/1000);
+ for ( eventMap::iterator i( It->second.first.begin() ); i != It->second.first.end(); i++)
+ {
+ int duration = i->second->getDuration();
+ time_t begTime = i->second->getStartTime();
+ if ( t >= begTime && t <= begTime+duration) // then we have found
+ {
+ result = i->second;
+ return 0;
+ }
+ }
}
+ return -1;
+}
+
+RESULT eEPGCache::lookupEvent(const eServiceReference &service, time_t t, const eit_event_struct *&result )
+{
+ singleLock s(cache_lock);
+ const eventData *data=0;
+ RESULT ret = lookupEvent(service, t, data);
+ if ( !ret && data )
+ result = data->get();
+ return ret;
+}
- Lock();
- bool empty=eventDB[current_service].first.empty();
- Unlock();
+RESULT eEPGCache::lookupEvent(const eServiceReference &service, time_t t, Event *& result )
+{
+ singleLock s(cache_lock);
+ const eventData *data=0;
+ RESULT ret = lookupEvent(service, t, data);
+ if ( !ret && data )
+ result = new Event((uint8_t*)data->get());
+ return ret;
+}
- if (!empty)
- {
- eDebug("[EPGC] yet cached");
- /*emit*/ EPGAvail(1);
- }
- else
+RESULT eEPGCache::lookupEvent(const eServiceReference &service, time_t t, ePtr<eServiceEvent> &result )
+{
+ singleLock s(cache_lock);
+ const eventData *data=0;
+ RESULT ret = lookupEvent(service, t, data);
+ if ( !ret && data )
{
- eDebug("[EPGC] not cached yet");
- /*emit*/ EPGAvail(0);
+ Event ev((uint8_t*)data->get());
+ result = new eServiceEvent();
+ ret = result->parseFrom(&ev);
}
+ return ret;
}
-void eEPGCache::abortEPG()
+RESULT eEPGCache::lookupEvent(const eServiceReference &service, int event_id, const eventData *&result )
{
- abortTimer.stop();
- zapTimer.stop();
- if (isRunning)
+ singleLock s(cache_lock);
+ uniqueEPGKey key( service );
+
+ eventCache::iterator It = eventDB.find( key );
+ if ( It != eventDB.end() && !It->second.first.empty() ) // entrys cached?
{
- if (isRunning & 1)
- {
- isRunning &= ~1;
- if ( m_ScheduleReader )
- m_ScheduleReader->stop();
- }
- if (isRunning & 2)
+ eventMap::iterator i( It->second.first.find( event_id ));
+ if ( i != It->second.first.end() )
{
- isRunning &= ~2;
- if ( m_NowNextReader )
- m_NowNextReader->stop();
+ result = i->second;
+ return 0;
}
- if (isRunning & 4)
+ else
{
- isRunning &= ~4;
- if ( m_ScheduleOtherReader )
- m_ScheduleOtherReader->stop();
+ result = 0;
+ eDebug("event %04x not found in epgcache", event_id);
}
- eDebug("[EPGC] abort caching events !!");
- Lock();
- temp.clear();
- Unlock();
}
+ return -1;
}
-void eEPGCache::gotMessage( const Message &msg )
+RESULT eEPGCache::lookupEvent(const eServiceReference &service, int event_id, const eit_event_struct *&result)
{
- switch (msg.type)
- {
- case Message::flush:
- flushEPG(msg.service);
- break;
- case Message::startService:
- changedService(msg.service);
- break;
- case Message::leaveChannel:
- abortEPG();
- back_messages.send(Message(Message::leaveChannelFinished));
- break;
- case Message::pause:
- pauseEPG();
- break;
- case Message::restart:
- restartEPG();
- break;
- case Message::quit:
- quit(0);
- break;
- case Message::timeChanged:
- cleanLoop();
- break;
- default:
- eDebug("unhandled EPGCache Message!!");
- break;
- }
+ singleLock s(cache_lock);
+ const eventData *data=0;
+ RESULT ret = lookupEvent(service, event_id, data);
+ if ( !ret && data )
+ result = data->get();
+ return ret;
}
-void eEPGCache::gotBackMessage( const Message &msg )
+RESULT eEPGCache::lookupEvent(const eServiceReference &service, int event_id, Event *& result)
{
- switch (msg.type)
- {
- case Message::leaveChannelFinished:
- m_ScheduleOtherReader=0;
- m_ScheduleOtherConn=0;
- m_ScheduleReader=0;
- m_ScheduleConn=0;
- m_NowNextReader=0;
- m_NowNextConn=0;
- m_currentChannel=0;
- eDebug("[eEPGC] channel leaved");
- if (next_service)
- {
- startCache(next_service);
- next_service = eServiceReferenceDVB();
- }
- break;
- default:
- eDebug("unhandled EPGCache BackMessage!!");
- break;
- }
+ singleLock s(cache_lock);
+ const eventData *data=0;
+ RESULT ret = lookupEvent(service, event_id, data);
+ if ( !ret && data )
+ result = new Event((uint8_t*)data->get());
+ return ret;
}
-void eEPGCache::thread()
+RESULT eEPGCache::lookupEvent(const eServiceReference &service, int event_id, ePtr<eServiceEvent> &result)
{
- nice(4);
- load();
- cleanLoop();
- exec();
- save();
+ singleLock s(cache_lock);
+ const eventData *data=0;
+ RESULT ret = lookupEvent(service, event_id, data);
+ if ( !ret && data )
+ {
+ Event ev((uint8_t*)data->get());
+ result = new eServiceEvent();
+ ret = result->parseFrom(&ev);
+ }
+ return ret;
}
-void eEPGCache::load()
+RESULT eEPGCache::startTimeQuery(const eServiceReference &service, time_t begin, int minutes)
{
- FILE *f = fopen("/hdd/epg.dat", "r");
- if (f)
+ eventCache::iterator It = eventDB.find( service );
+ if ( It != eventDB.end() && It->second.second.size() )
{
- unsigned char md5_saved[16];
- unsigned char md5[16];
- int size=0;
- int cnt=0;
- bool md5ok=false;
- if (!md5_file("/hdd/epg.dat", 1, md5))
+ m_timemap_end = minutes != -1 ? It->second.second.upper_bound(begin+minutes*60) : It->second.second.end();
+ if ( begin != -1 )
{
- FILE *f = fopen("/hdd/epg.dat.md5", "r");
- if (f)
+ m_timemap_cursor = It->second.second.lower_bound(begin);
+ if ( m_timemap_cursor != It->second.second.end() && m_timemap_cursor != It->second.second.begin() )
{
- fread( md5_saved, 16, 1, f);
- fclose(f);
- if ( !memcmp(md5_saved, md5, 16) )
- md5ok=true;
- }
- }
- if ( md5ok )
- {
- fread( &size, sizeof(int), 1, f);
- while(size--)
- {
- 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;
- }
- eventDB[key]=std::pair<eventMap,timeMap>(evMap,tmMap);
+ timeMap::iterator it = m_timemap_cursor;
+ --it;
+ if ( (it->second->getStartTime() + it->second->getDuration()) > begin )
+ m_timemap_cursor = it;
}
- eDebug("%d events read from /hdd/epg.dat.md5", cnt);
}
- fclose(f);
+ else
+ m_timemap_cursor = It->second.second.begin();
+ return 0;
}
+ return -1;
}
-void eEPGCache::save()
+RESULT eEPGCache::getNextTimeEntry(const eventData *& result)
{
- struct statfs s;
- off64_t tmp;
- if (statfs("/hdd", &s)<0)
- tmp=0;
- else
+ if ( m_timemap_cursor != m_timemap_end )
{
- tmp=s.f_blocks;
- tmp*=s.f_bsize;
+ result = m_timemap_cursor++->second;
+ return 0;
}
+ return -1;
+}
- // prevent writes to builtin flash
- if ( tmp < 1024*1024*50 ) // storage size < 50MB
- return;
-
- // check for enough free space on storage
- tmp=s.f_bfree;
- tmp*=s.f_bsize;
- if ( tmp < (eventData::CacheSize*12)/10 ) // 20% overhead
- return;
-
- FILE *f = fopen("/hdd/epg.dat", "w");
- int cnt=0;
- if ( f )
+RESULT eEPGCache::getNextTimeEntry(const eit_event_struct *&result)
+{
+ if ( m_timemap_cursor != m_timemap_end )
{
- int size = eventDB.size();
- fwrite( &size, sizeof(int), 1, f );
- for (eventCache::iterator service_it(eventDB.begin()); service_it != eventDB.end(); ++service_it)
- {
- timeMap &timemap = service_it->second.second;
- fwrite( &service_it->first, sizeof(uniqueEPGKey), 1, f);
- size = timemap.size();
- fwrite( &size, sizeof(int), 1, f);
- for (timeMap::iterator time_it(timemap.begin()); time_it != timemap.end(); ++time_it)
- {
- int len = time_it->second->ByteSize;
- fwrite( &time_it->second->type, sizeof(int), 1, f );
- fwrite( &len, sizeof(int), 1, f);
- fwrite( time_it->second->EITdata, len, 1, f);
- ++cnt;
- }
- }
- eDebug("%d events written to /hdd/epg.dat", cnt);
- fclose(f);
- unsigned char md5[16];
- if (!md5_file("/hdd/epg.dat", 1, md5))
- {
- FILE *f = fopen("/hdd/epg.dat.md5", "w");
- if (f)
- {
- fwrite( md5, 16, 1, f);
- fclose(f);
- }
- }
+ result = m_timemap_cursor++->second->get();
+ return 0;
}
+ return -1;
}
-RESULT eEPGCache::getInstance(ePtr<eEPGCache> &ptr)
+RESULT eEPGCache::getNextTimeEntry(Event *&result)
{
- ptr = instance;
- if (!ptr)
- return -1;
- return 0;
+ if ( m_timemap_cursor != m_timemap_end )
+ {
+ result = new Event((uint8_t*)m_timemap_cursor++->second->get());
+ return 0;
+ }
+ return -1;
}
+RESULT eEPGCache::getNextTimeEntry(ePtr<eServiceEvent> &result)
+{
+ if ( m_timemap_cursor != m_timemap_end )
+ {
+ Event ev((uint8_t*)m_timemap_cursor++->second->get());
+ result = new eServiceEvent();
+ return result->parseFrom(&ev);
+ }
+ return -1;
+}
git.cweiske.de / enigma2.git / blobdiff