1ec88a3955af9177e6add8051893004fad67fc9a
[enigma2.git] / lib / dvb / epgcache.cpp
1 #include <lib/dvb/epgcache.h>
2 #include <lib/dvb/dvb.h>
3
4 #undef EPG_DEBUG  
5
6 #include <time.h>
7 #include <unistd.h>  // for usleep
8 #include <sys/vfs.h> // for statfs
9 // #include <libmd5sum.h>
10 #include <lib/base/eerror.h>
11
12 int eventData::CacheSize=0;
13 descriptorMap eventData::descriptors;
14
15 extern const uint32_t crc32_table[256];
16
17 eventData::eventData(const eit_event_struct* e, int size, int type)
18         :ByteSize(size), type(type)
19 {
20         if (!e)
21                 return;
22         std::list<__u32> d;
23         __u8 *data = (__u8*)e;
24         int ptr=10;
25         int descriptors_length = (data[ptr++]&0x0F) << 8;
26         descriptors_length |= data[ptr++];
27         while ( descriptors_length > 0 )
28         {
29                 int descr_len = data[ptr+1] + 2;
30                 __u8 *descr = new __u8[descr_len];
31                 unsigned int crc=0;
32                 int cnt=0;
33                 while(cnt < descr_len && descriptors_length > 0)
34                 {
35                         crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ data[ptr]) & 0xff];
36                         descr[cnt++] = data[ptr++];
37                         --descriptors_length;
38                 }
39                 descriptorMap::iterator it =
40                         descriptors.find(crc);
41                 if ( it == descriptors.end() )
42                 {
43                         CacheSize+=descr_len;
44                         descriptors[crc] = descriptorPair(1, descr);
45                 }
46                 else
47                 {
48                         ++it->second.first;
49                         delete [] descr;
50                 }
51                 d.push_back(crc);
52         }
53         ByteSize = 12+d.size()*4;
54         EITdata = new __u8[ByteSize];
55         CacheSize+=ByteSize;
56         memcpy(EITdata, (__u8*) e, 12);
57         __u32 *p = (__u32*)(EITdata+12);
58         for (std::list<__u32>::iterator it(d.begin()); it != d.end(); ++it)
59                 *p++ = *it;
60 }
61
62 const eit_event_struct* eventData::get() const
63 {
64         static __u8 *data=NULL;
65         if ( data )
66                 delete [] data;
67
68         int bytes = 12;
69         std::list<__u8*> d;
70
71 // cnt needed bytes
72         int tmp = ByteSize-12;
73         __u32 *p = (__u32*)(EITdata+12);
74         while(tmp>0)
75         {
76                 descriptorMap::iterator it =
77                         descriptors.find(*p++);
78                 if ( it != descriptors.end() )
79                 {
80                         d.push_back(it->second.second);
81                         bytes += it->second.second[1];
82                 }
83                 bytes += 2; // descr_type, descr_len
84                 tmp-=4;
85         }
86
87 // copy eit_event header to buffer
88         data = new __u8[bytes];
89         memcpy(data, EITdata, 12);
90
91         tmp=12;
92 // copy all descriptors to buffer
93         for(std::list<__u8*>::iterator it(d.begin()); it != d.end(); ++it)
94         {
95                 int b=(*it)[1]+2;
96                 memcpy(data+tmp, *it, b);
97                 tmp+=b;
98         }
99
100         return (eit_event_struct*)data;
101 }
102
103 eventData::~eventData()
104 {
105         if ( ByteSize )
106         {
107                 CacheSize-=ByteSize;
108                 ByteSize-=12;
109                 __u32 *d = (__u32*)(EITdata+12);
110                 while(ByteSize)
111                 {
112                         descriptorMap::iterator it =
113                                 descriptors.find(*d++);
114                         if ( it != descriptors.end() )
115                         {
116                                 descriptorPair &p = it->second;
117                                 if (!--p.first) // no more used descriptor
118                                 {
119                                         CacheSize -= p.second[1]+2;
120                                         delete [] p.second;     // free descriptor memory
121                                         descriptors.erase(it);  // remove entry from descriptor map
122                                 }
123                         }
124                         ByteSize-=4;
125                 }
126                 delete [] EITdata;
127         }
128 }
129
130 void eventData::load(FILE *f)
131 {
132         int size=0;
133         int id=0;
134         __u8 header[2];
135         descriptorPair p;
136         fread(&size, sizeof(int), 1, f);
137         while(size)
138         {
139                 fread(&id, sizeof(__u32), 1, f);
140                 fread(&p.first, sizeof(int), 1, f);
141                 fread(header, 2, 1, f);
142                 int bytes = header[1]+2;
143                 p.second = new __u8[bytes];
144                 p.second[0] = header[0];
145                 p.second[1] = header[1];
146                 fread(p.second+2, bytes-2, 1, f);
147                 descriptors[id]=p;
148                 --size;
149                 CacheSize+=bytes;
150         }
151 }
152
153 void eventData::save(FILE *f)
154 {
155         int size=descriptors.size();
156         descriptorMap::iterator it(descriptors.begin());
157         fwrite(&size, sizeof(int), 1, f);
158         while(size)
159         {
160                 fwrite(&it->first, sizeof(__u32), 1, f);
161                 fwrite(&it->second.first, sizeof(int), 1, f);
162                 fwrite(it->second.second, it->second.second[1]+2, 1, f);
163                 ++it;
164                 --size;
165         }
166 }
167
168 eEPGCache* eEPGCache::instance;
169 pthread_mutex_t eEPGCache::cache_lock=
170         PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
171 pthread_mutex_t eEPGCache::channel_map_lock=
172         PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
173
174 DEFINE_REF(eEPGCache)
175
176 eEPGCache::eEPGCache()
177         :messages(this,1), cleanTimer(this)//, paused(0)
178 {
179         eDebug("[EPGC] Initialized EPGCache");
180
181         CONNECT(messages.recv_msg, eEPGCache::gotMessage);
182         CONNECT(eDVBLocalTimeHandler::getInstance()->m_timeUpdated, eEPGCache::timeUpdated);
183         CONNECT(cleanTimer.timeout, eEPGCache::cleanLoop);
184
185         ePtr<eDVBResourceManager> res_mgr;
186         eDVBResourceManager::getInstance(res_mgr);
187         if (!res_mgr)
188                 eDebug("[eEPGCache] no resource manager !!!!!!!");
189         else
190                 res_mgr->connectChannelAdded(slot(*this,&eEPGCache::DVBChannelAdded), m_chanAddedConn);
191         instance=this;
192 }
193
194 void eEPGCache::timeUpdated()
195 {
196         if ( !thread_running() )
197         {
198                 eDebug("[EPGC] time updated.. start EPG Mainloop");
199                 run();
200         }
201         else
202                 messages.send(Message(Message::timeChanged));
203 }
204
205 void eEPGCache::DVBChannelAdded(eDVBChannel *chan)
206 {
207         if ( chan )
208         {
209                 eDebug("[eEPGCache] add channel %p", chan);
210                 channel_data *data = new channel_data(this);
211                 data->channel = chan;
212                 singleLock s(channel_map_lock);
213                 m_knownChannels.insert( std::pair<iDVBChannel*, channel_data* >(chan, data) );
214                 chan->connectStateChange(slot(*this, &eEPGCache::DVBChannelStateChanged), data->m_stateChangedConn);
215         }
216 }
217
218 void eEPGCache::DVBChannelRunning(iDVBChannel *chan)
219 {
220         singleLock s(channel_map_lock);
221         channelMapIterator it =
222                 m_knownChannels.find(chan);
223         if ( it == m_knownChannels.end() )
224                 eDebug("[eEPGCache] will start non existing channel %p !!!", chan);
225         else
226         {
227                 channel_data &data = *it->second;
228                 ePtr<eDVBResourceManager> res_mgr;
229                 if ( eDVBResourceManager::getInstance( res_mgr ) )
230                         eDebug("[eEPGCache] no res manager!!");
231                 else
232                 {
233                         ePtr<iDVBDemux> demux;
234                         if ( data.channel->getDemux(demux, 0) )
235                         {
236                                 eDebug("[eEPGCache] no demux!!");
237                                 return;
238                         }
239                         else
240                         {
241                                 RESULT res = demux->createSectionReader( this, data.m_NowNextReader );
242                                 if ( res )
243                                 {
244                                         eDebug("[eEPGCache] couldnt initialize nownext reader!!");
245                                         return;
246                                 }
247
248                                 res = demux->createSectionReader( this, data.m_ScheduleReader );
249                                 if ( res )
250                                 {
251                                         eDebug("[eEPGCache] couldnt initialize schedule reader!!");
252                                         return;
253                                 }
254
255                                 res = demux->createSectionReader( this, data.m_ScheduleOtherReader );
256                                 if ( res )
257                                 {
258                                         eDebug("[eEPGCache] couldnt initialize schedule other reader!!");
259                                         return;
260                                 }
261
262                                 messages.send(Message(Message::startChannel, chan));
263                                 // -> gotMessage -> changedService
264                         }
265                 }
266         }
267 }
268
269 void eEPGCache::DVBChannelStateChanged(iDVBChannel *chan)
270 {
271         channelMapIterator it =
272                 m_knownChannels.find(chan);
273         if ( it != m_knownChannels.end() )
274         {
275                 int state=0;
276                 chan->getState(state);
277                 switch (state)
278                 {
279                         case iDVBChannel::state_idle:
280                                 break;
281                         case iDVBChannel::state_tuning:
282                                 break;
283                         case iDVBChannel::state_unavailable:
284                                 break;
285                         case iDVBChannel::state_ok:
286                         {
287                                 eDebug("[eEPGCache] channel %p running", chan);
288                                 DVBChannelRunning(chan);
289                                 break;
290                         }
291                         case iDVBChannel::state_release:
292                         {
293                                 eDebug("[eEPGCache] remove channel %p", chan);
294                                 messages.send(Message(Message::leaveChannel, chan));
295                                 while(!it->second->can_delete)
296                                         usleep(1000);
297                                 delete it->second;
298                                 m_knownChannels.erase(it);
299                                 // -> gotMessage -> abortEPG
300                                 break;
301                         }
302                 }
303         }
304 }
305
306 void eEPGCache::sectionRead(const __u8 *data, int source, channel_data *channel)
307 {
308         eit_t *eit = (eit_t*) data;
309
310         int len=HILO(eit->section_length)-1;//+3-4;
311         int ptr=EIT_SIZE;
312         if ( ptr >= len )
313                 return;
314
315         // This fixed the EPG on the Multichoice irdeto systems
316         // the EIT packet is non-compliant.. their EIT packet stinks
317         if ( data[ptr-1] < 0x40 )
318                 --ptr;
319
320         uniqueEPGKey service( HILO(eit->service_id), HILO(eit->original_network_id), HILO(eit->transport_stream_id) );
321         eit_event_struct* eit_event = (eit_event_struct*) (data+ptr);
322         int eit_event_size;
323         int duration;
324
325         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);
326         time_t now = time(0)+eDVBLocalTimeHandler::getInstance()->difference();
327
328         if ( TM != 3599 && TM > -1)
329                 channel->haveData |= source;
330
331         singleLock s(cache_lock);
332         // hier wird immer eine eventMap zurück gegeben.. entweder eine vorhandene..
333         // oder eine durch [] erzeugte
334         std::pair<eventMap,timeMap> &servicemap = eventDB[service];
335         eventMap::iterator prevEventIt = servicemap.first.end();
336         timeMap::iterator prevTimeIt = servicemap.second.end();
337
338         while (ptr<len)
339         {
340                 eit_event_size = HILO(eit_event->descriptors_loop_length)+EIT_LOOP_SIZE;
341
342                 duration = fromBCD(eit_event->duration_1)*3600+fromBCD(eit_event->duration_2)*60+fromBCD(eit_event->duration_3);
343                 TM = parseDVBtime(
344                         eit_event->start_time_1,
345                         eit_event->start_time_2,
346                         eit_event->start_time_3,
347                         eit_event->start_time_4,
348                         eit_event->start_time_5);
349
350                 if ( TM == 3599 )
351                         goto next;
352
353                 if ( TM != 3599 && (TM+duration < now || TM > now+14*24*60*60) )
354                         goto next;
355
356                 if ( now <= (TM+duration) || TM == 3599 /*NVOD Service*/ )  // old events should not be cached
357                 {
358                         __u16 event_id = HILO(eit_event->event_id);
359 //                      eDebug("event_id is %d sid is %04x", event_id, service.sid);
360
361                         eventData *evt = 0;
362                         int ev_erase_count = 0;
363                         int tm_erase_count = 0;
364
365                         // search in eventmap
366                         eventMap::iterator ev_it =
367                                 servicemap.first.find(event_id);
368
369                         // entry with this event_id is already exist ?
370                         if ( ev_it != servicemap.first.end() )
371                         {
372                                 if ( source > ev_it->second->type )  // update needed ?
373                                         goto next; // when not.. the skip this entry
374
375                                 // search this event in timemap
376                                 timeMap::iterator tm_it_tmp = 
377                                         servicemap.second.find(ev_it->second->getStartTime());
378
379                                 if ( tm_it_tmp != servicemap.second.end() )
380                                 {
381                                         if ( tm_it_tmp->first == TM ) // correct eventData
382                                         {
383                                                 // exempt memory
384                                                 delete ev_it->second;
385                                                 evt = new eventData(eit_event, eit_event_size, source);
386                                                 ev_it->second=evt;
387                                                 tm_it_tmp->second=evt;
388                                                 goto next;
389                                         }
390                                         else
391                                         {
392                                                 tm_erase_count++;
393                                                 // delete the found record from timemap
394                                                 servicemap.second.erase(tm_it_tmp);
395                                                 prevTimeIt=servicemap.second.end();
396                                         }
397                                 }
398                         }
399
400                         // search in timemap, for check of a case if new time has coincided with time of other event 
401                         // or event was is not found in eventmap
402                         timeMap::iterator tm_it =
403                                 servicemap.second.find(TM);
404
405                         if ( tm_it != servicemap.second.end() )
406                         {
407                                 // i think, if event is not found on eventmap, but found on timemap updating nevertheless demands
408 #if 0
409                                 if ( source > tm_it->second->type && tm_erase_count == 0 ) // update needed ?
410                                         goto next; // when not.. the skip this entry
411 #endif
412
413                                 // search this time in eventmap
414                                 eventMap::iterator ev_it_tmp = 
415                                         servicemap.first.find(tm_it->second->getEventID());
416
417                                 if ( ev_it_tmp != servicemap.first.end() )
418                                 {
419                                         ev_erase_count++;                               
420                                         // delete the found record from eventmap
421                                         servicemap.first.erase(ev_it_tmp);
422                                         prevEventIt=servicemap.first.end();
423                                 }
424                         }
425                         
426                         evt = new eventData(eit_event, eit_event_size, source);
427 #if EPG_DEBUG
428                         bool consistencyCheck=true;
429 #endif
430                         if (ev_erase_count > 0 && tm_erase_count > 0) // 2 different pairs have been removed
431                         {
432                                 // exempt memory
433                                 delete ev_it->second; 
434                                 delete tm_it->second;
435                                 ev_it->second=evt;
436                                 tm_it->second=evt;
437                         }
438                         else if (ev_erase_count == 0 && tm_erase_count > 0) 
439                         {
440                                 // exempt memory
441                                 delete ev_it->second;
442                                 tm_it=prevTimeIt=servicemap.second.insert( prevTimeIt, std::pair<const time_t, eventData*>( TM, evt ) );
443                                 ev_it->second=evt;
444                         }
445                         else if (ev_erase_count > 0 && tm_erase_count == 0)
446                         {
447                                 // exempt memory
448                                 delete tm_it->second;
449                                 ev_it=prevEventIt=servicemap.first.insert( prevEventIt, std::pair<const __u16, eventData*>( event_id, evt) );
450                                 tm_it->second=evt;
451                         }
452                         else // added new eventData
453                         {
454 #if EPG_DEBUG
455                                 consistencyCheck=false;
456 #endif
457                                 prevEventIt=servicemap.first.insert( prevEventIt, std::pair<const __u16, eventData*>( event_id, evt) );
458                                 prevTimeIt=servicemap.second.insert( prevTimeIt, std::pair<const time_t, eventData*>( TM, evt ) );
459                         }
460 #if EPG_DEBUG
461                         if ( consistencyCheck )
462                         {
463                                 if ( tm_it->second != evt || ev_it->second != evt )
464                                         eFatal("tm_it->second != ev_it->second");
465                                 else if ( tm_it->second->getStartTime() != tm_it->first )
466                                         eFatal("event start_time(%d) non equal timemap key(%d)", 
467                                                 tm_it->second->getStartTime(), tm_it->first );
468                                 else if ( tm_it->first != TM )
469                                         eFatal("timemap key(%d) non equal TM(%d)", 
470                                                 tm_it->first, TM);
471                                 else if ( ev_it->second->getEventID() != ev_it->first )
472                                         eFatal("event_id (%d) non equal event_map key(%d)",
473                                                 ev_it->second->getEventID(), ev_it->first);
474                                 else if ( ev_it->first != event_id )
475                                         eFatal("eventmap key(%d) non equal event_id(%d)", 
476                                                 ev_it->first, event_id );
477                         }
478 #endif
479                 }
480 next:
481 #if EPG_DEBUG
482                 if ( servicemap.first.size() != servicemap.second.size() )
483                 {
484                         FILE *f = fopen("/hdd/event_map.txt", "w+");
485                         int i=0;
486                         for (eventMap::iterator it(servicemap.first.begin())
487                                 ; it != servicemap.first.end(); ++it )
488                                 fprintf(f, "%d(key %d) -> time %d, event_id %d, data %p\n", 
489                                         i++, (int)it->first, (int)it->second->getStartTime(), (int)it->second->getEventID(), it->second );
490                         fclose(f);
491                         f = fopen("/hdd/time_map.txt", "w+");
492                         i=0;
493                         for (timeMap::iterator it(servicemap.second.begin())
494                                 ; it != servicemap.second.end(); ++it )
495                                         fprintf(f, "%d(key %d) -> time %d, event_id %d, data %p\n", 
496                                                 i++, (int)it->first, (int)it->second->getStartTime(), (int)it->second->getEventID(), it->second );
497                         fclose(f);
498
499                         eFatal("(1)map sizes not equal :( sid %04x tsid %04x onid %04x size %d size2 %d", 
500                                 service.sid, service.tsid, service.onid, 
501                                 servicemap.first.size(), servicemap.second.size() );
502                 }
503 #endif
504                 ptr += eit_event_size;
505                 eit_event=(eit_event_struct*)(((__u8*)eit_event)+eit_event_size);
506         }
507 }
508
509 void eEPGCache::flushEPG(const uniqueEPGKey & s)
510 {
511         eDebug("[EPGC] flushEPG %d", (int)(bool)s);
512         singleLock l(cache_lock);
513         if (s)  // clear only this service
514         {
515                 eventCache::iterator it = eventDB.find(s);
516                 if ( it != eventDB.end() )
517                 {
518                         eventMap &evMap = it->second.first;
519                         timeMap &tmMap = it->second.second;
520                         tmMap.clear();
521                         for (eventMap::iterator i = evMap.begin(); i != evMap.end(); ++i)
522                                 delete i->second;
523                         evMap.clear();
524                         eventDB.erase(it);
525
526                         // TODO .. search corresponding channel for removed service and remove this channel from lastupdated map
527                 }
528         }
529         else // clear complete EPG Cache
530         {
531                 for (eventCache::iterator it(eventDB.begin());
532                         it != eventDB.end(); ++it)
533                 {
534                         eventMap &evMap = it->second.first;
535                         timeMap &tmMap = it->second.second;
536                         for (eventMap::iterator i = evMap.begin(); i != evMap.end(); ++i)
537                                 delete i->second;
538                         evMap.clear();
539                         tmMap.clear();
540                 }
541                 eventDB.clear();
542                 channelLastUpdated.clear();
543                 singleLock m(channel_map_lock);
544                 for (channelMapIterator it(m_knownChannels.begin()); it != m_knownChannels.end(); ++it)
545                         it->second->startEPG();
546         }
547         eDebug("[EPGC] %i bytes for cache used", eventData::CacheSize);
548 }
549
550 void eEPGCache::cleanLoop()
551 {
552         singleLock s(cache_lock);
553         if (!eventDB.empty())
554         {
555                 eDebug("[EPGC] start cleanloop");
556
557                 time_t now = time(0)+eDVBLocalTimeHandler::getInstance()->difference();
558
559                 for (eventCache::iterator DBIt = eventDB.begin(); DBIt != eventDB.end(); DBIt++)
560                 {
561                         for (timeMap::iterator It = DBIt->second.second.begin(); It != DBIt->second.second.end() && It->first < now;)
562                         {
563                                 if ( now > (It->first+It->second->getDuration()) )  // outdated normal entry (nvod references to)
564                                 {
565                                         // remove entry from eventMap
566                                         eventMap::iterator b(DBIt->second.first.find(It->second->getEventID()));
567                                         if ( b != DBIt->second.first.end() )
568                                         {
569                                                 // release Heap Memory for this entry   (new ....)
570 //                                              eDebug("[EPGC] delete old event (evmap)");
571                                                 DBIt->second.first.erase(b);
572                                         }
573
574                                         // remove entry from timeMap
575 //                                      eDebug("[EPGC] release heap mem");
576                                         delete It->second;
577                                         DBIt->second.second.erase(It++);
578 //                                      eDebug("[EPGC] delete old event (timeMap)");
579                                 }
580                                 else
581                                         ++It;
582                         }
583                 }
584                 eDebug("[EPGC] stop cleanloop");
585                 eDebug("[EPGC] %i bytes for cache used", eventData::CacheSize);
586         }
587         cleanTimer.start(CLEAN_INTERVAL,true);
588 }
589
590 eEPGCache::~eEPGCache()
591 {
592         messages.send(Message::quit);
593         kill(); // waiting for thread shutdown
594         singleLock s(cache_lock);
595         for (eventCache::iterator evIt = eventDB.begin(); evIt != eventDB.end(); evIt++)
596                 for (eventMap::iterator It = evIt->second.first.begin(); It != evIt->second.first.end(); It++)
597                         delete It->second;
598 }
599
600 RESULT eEPGCache::lookupEvent(const eServiceReferenceDVB &service, int event_id, const eventData *&result )
601 {
602         singleLock s(cache_lock);
603         uniqueEPGKey key( service );
604
605         eventCache::iterator It = eventDB.find( key );
606         if ( It != eventDB.end() && !It->second.first.empty() ) // entrys cached?
607         {
608                 eventMap::iterator i( It->second.first.find( event_id ));
609                 if ( i != It->second.first.end() )
610                 {
611                         result = i->second;
612                         return 0;
613                 }
614                 else
615                 {
616                         result = 0;
617                         eDebug("event %04x not found in epgcache", event_id);
618                 }
619         }
620         return -1;
621 }
622
623 RESULT eEPGCache::lookupEvent(const eServiceReferenceDVB &service, time_t t, const eventData *&result )
624 // if t == 0 we search the current event...
625 {
626         singleLock s(cache_lock);
627         uniqueEPGKey key(service);
628
629         // check if EPG for this service is ready...
630         eventCache::iterator It = eventDB.find( key );
631         if ( It != eventDB.end() && !It->second.first.empty() ) // entrys cached ?
632         {
633                 if (!t)
634                         t = time(0)+eDVBLocalTimeHandler::getInstance()->difference();
635
636                 timeMap::iterator i = It->second.second.lower_bound(t);
637                 if ( i != It->second.second.end() )
638                 {
639                         i--;
640                         if ( i != It->second.second.end() )
641                         {
642                                 if ( t <= i->first+i->second->getDuration() )
643                                 {
644                                         result = i->second;
645                                         return 0;
646                                 }
647                         }
648                 }
649
650                 for ( eventMap::iterator i( It->second.first.begin() ); i != It->second.first.end(); i++)
651                 {
652                         int duration = i->second->getDuration();
653                         time_t begTime = i->second->getStartTime();
654                         if ( t >= begTime && t <= begTime+duration) // then we have found
655                         {
656                                 result = i->second;
657                                 return 0;
658                         }
659                 }
660         }
661         return -1;
662 }
663
664 void eEPGCache::gotMessage( const Message &msg )
665 {
666         switch (msg.type)
667         {
668                 case Message::flush:
669                         flushEPG(msg.service);
670                         break;
671                 case Message::startChannel:
672                 {
673                         singleLock s(channel_map_lock);
674                         channelMapIterator channel =
675                                 m_knownChannels.find(msg.channel);
676                         if ( channel != m_knownChannels.end() )
677                                 channel->second->startChannel();
678                         break;
679                 }
680                 case Message::leaveChannel:
681                 {
682                         singleLock s(channel_map_lock);
683                         channelMapIterator channel =
684                                 m_knownChannels.find(msg.channel);
685                         if ( channel != m_knownChannels.end() )
686                                 channel->second->abortEPG();
687                         break;
688                 }
689                 case Message::quit:
690                         quit(0);
691                         break;
692                 case Message::timeChanged:
693                         cleanLoop();
694                         break;
695                 default:
696                         eDebug("unhandled EPGCache Message!!");
697                         break;
698         }
699 }
700
701 void eEPGCache::thread()
702 {
703         nice(4);
704         load();
705         cleanLoop();
706         exec();
707         save();
708 }
709
710 void eEPGCache::load()
711 {
712 #if 0
713         FILE *f = fopen("/hdd/epg.dat", "r");
714         if (f)
715         {
716                 unsigned char md5_saved[16];
717                 unsigned char md5[16];
718                 int size=0;
719                 int cnt=0;
720                 bool md5ok=false;
721                 if (!md5_file("/hdd/epg.dat", 1, md5))
722                 {
723                         FILE *f = fopen("/hdd/epg.dat.md5", "r");
724                         if (f)
725                         {
726                                 fread( md5_saved, 16, 1, f);
727                                 fclose(f);
728                                 if ( !memcmp(md5_saved, md5, 16) )
729                                         md5ok=true;
730                         }
731                 }
732                 if ( md5ok )
733                 {
734                         char text1[13];
735                         fread( text1, 13, 1, f);
736                         if ( !strncmp( text1, "ENIGMA_EPG_V2", 13) )
737                         {
738                                 fread( &size, sizeof(int), 1, f);
739                                 while(size--)
740                                 {
741                                         uniqueEPGKey key;
742                                         eventMap evMap;
743                                         timeMap tmMap;
744                                         int size=0;
745                                         fread( &key, sizeof(uniqueEPGKey), 1, f);
746                                         fread( &size, sizeof(int), 1, f);
747                                         while(size--)
748                                         {
749                                                 int len=0;
750                                                 int type=0;
751                                                 eventData *event=0;
752                                                 fread( &type, sizeof(int), 1, f);
753                                                 fread( &len, sizeof(int), 1, f);
754                                                 event = new eventData(0, len, type);
755                                                 event->EITdata = new __u8[len];
756                                                 eventData::CacheSize+=len;
757                                                 fread( event->EITdata, len, 1, f);
758                                                 evMap[ event->getEventID() ]=event;
759                                                 tmMap[ event->getStartTime() ]=event;
760                                                 ++cnt;
761                                         }
762                                         eventDB[key]=std::pair<eventMap,timeMap>(evMap,tmMap);
763                                 }
764                                 eventData::load(f);
765                                 eDebug("%d events read from /hdd/epg.dat", cnt);
766                         }
767                         else
768                                 eDebug("[EPGC] don't read old epg database");
769                         fclose(f);
770                 }
771         }
772 #endif
773 }
774
775 void eEPGCache::save()
776 {
777 #if 0
778         struct statfs s;
779         off64_t tmp;
780         if (statfs("/hdd", &s)<0)
781                 tmp=0;
782         else
783         {
784                 tmp=s.f_blocks;
785                 tmp*=s.f_bsize;
786         }
787
788         // prevent writes to builtin flash
789         if ( tmp < 1024*1024*50 ) // storage size < 50MB
790                 return;
791
792         // check for enough free space on storage
793         tmp=s.f_bfree;
794         tmp*=s.f_bsize;
795         if ( tmp < (eventData::CacheSize*12)/10 ) // 20% overhead
796                 return;
797
798         FILE *f = fopen("/hdd/epg.dat", "w");
799         int cnt=0;
800         if ( f )
801         {
802                 const char *text = "ENIGMA_EPG_V2";
803                 fwrite( text, 13, 1, f );
804                 int size = eventDB.size();
805                 fwrite( &size, sizeof(int), 1, f );
806                 for (eventCache::iterator service_it(eventDB.begin()); service_it != eventDB.end(); ++service_it)
807                 {
808                         timeMap &timemap = service_it->second.second;
809                         fwrite( &service_it->first, sizeof(uniqueEPGKey), 1, f);
810                         size = timemap.size();
811                         fwrite( &size, sizeof(int), 1, f);
812                         for (timeMap::iterator time_it(timemap.begin()); time_it != timemap.end(); ++time_it)
813                         {
814                                 int len = time_it->second->ByteSize;
815                                 fwrite( &time_it->second->type, sizeof(int), 1, f );
816                                 fwrite( &len, sizeof(int), 1, f);
817                                 fwrite( time_it->second->EITdata, len, 1, f);
818                                 ++cnt;
819                         }
820                 }
821                 eDebug("%d events written to /hdd/epg.dat", cnt);
822                 eventData::save(f);
823                 fclose(f);
824                 unsigned char md5[16];
825                 if (!md5_file("/hdd/epg.dat", 1, md5))
826                 {
827                         FILE *f = fopen("/hdd/epg.dat.md5", "w");
828                         if (f)
829                         {
830                                 fwrite( md5, 16, 1, f);
831                                 fclose(f);
832                         }
833                 }
834         }
835 #endif
836 }
837
838 RESULT eEPGCache::getInstance(ePtr<eEPGCache> &ptr)
839 {
840         ptr = instance;
841         if (!ptr)
842                 return -1;
843         return 0;
844 }
845
846 eEPGCache::channel_data::channel_data(eEPGCache *ml)
847         :cache(ml)
848         ,abortTimer(ml), zapTimer(ml)
849         ,state(0), isRunning(0), haveData(0), can_delete(1)
850 {
851         CONNECT(zapTimer.timeout, eEPGCache::channel_data::startEPG);
852         CONNECT(abortTimer.timeout, eEPGCache::channel_data::abortNonAvail);
853 }
854
855 bool eEPGCache::channel_data::finishEPG()
856 {
857         if (!isRunning)  // epg ready
858         {
859                 eDebug("[EPGC] stop caching events(%d)", time(0)+eDVBLocalTimeHandler::getInstance()->difference());
860                 zapTimer.start(UPDATE_INTERVAL, 1);
861                 eDebug("[EPGC] next update in %i min", UPDATE_INTERVAL / 60000);
862                 for (int i=0; i < 3; ++i)
863                 {
864                         seenSections[i].clear();
865                         calcedSections[i].clear();
866                 }
867                 singleLock l(cache->cache_lock);
868                 cache->channelLastUpdated[channel->getChannelID()] = time(0)+eDVBLocalTimeHandler::getInstance()->difference();
869                 can_delete=1;
870                 return true;
871         }
872         return false;
873 }
874
875 void eEPGCache::channel_data::startEPG()
876 {
877         eDebug("[EPGC] start caching events(%d)", eDVBLocalTimeHandler::getInstance()->difference()+time(0));
878         state=0;
879         haveData=0;
880         can_delete=0;
881         for (int i=0; i < 3; ++i)
882         {
883                 seenSections[i].clear();
884                 calcedSections[i].clear();
885         }
886
887         eDVBSectionFilterMask mask;
888         memset(&mask, 0, sizeof(mask));
889         mask.pid = 0x12;
890         mask.flags = eDVBSectionFilterMask::rfCRC;
891
892         mask.data[0] = 0x4E;
893         mask.mask[0] = 0xFE;
894         m_NowNextReader->connectRead(slot(*this, &eEPGCache::channel_data::readData), m_NowNextConn);
895         m_NowNextReader->start(mask);
896         isRunning |= NOWNEXT;
897
898         mask.data[0] = 0x50;
899         mask.mask[0] = 0xF0;
900         m_ScheduleReader->connectRead(slot(*this, &eEPGCache::channel_data::readData), m_ScheduleConn);
901         m_ScheduleReader->start(mask);
902         isRunning |= SCHEDULE;
903
904         mask.data[0] = 0x60;
905         mask.mask[0] = 0xF0;
906         m_ScheduleOtherReader->connectRead(slot(*this, &eEPGCache::channel_data::readData), m_ScheduleOtherConn);
907         m_ScheduleOtherReader->start(mask);
908         isRunning |= SCHEDULE_OTHER;
909
910         abortTimer.start(7000,true);
911 }
912
913 void eEPGCache::channel_data::abortNonAvail()
914 {
915         if (!state)
916         {
917                 if ( !(haveData&eEPGCache::NOWNEXT) && (isRunning&eEPGCache::NOWNEXT) )
918                 {
919                         eDebug("[EPGC] abort non avail nownext reading");
920                         isRunning &= ~eEPGCache::NOWNEXT;
921                         m_NowNextReader->stop();
922                         m_NowNextConn=0;
923                 }
924                 if ( !(haveData&eEPGCache::SCHEDULE) && (isRunning&eEPGCache::SCHEDULE) )
925                 {
926                         eDebug("[EPGC] abort non avail schedule reading");
927                         isRunning &= ~SCHEDULE;
928                         m_ScheduleReader->stop();
929                         m_ScheduleConn=0;
930                 }
931                 if ( !(haveData&eEPGCache::SCHEDULE_OTHER) && (isRunning&eEPGCache::SCHEDULE_OTHER) )
932                 {
933                         eDebug("[EPGC] abort non avail schedule_other reading");
934                         isRunning &= ~SCHEDULE_OTHER;
935                         m_ScheduleOtherReader->stop();
936                         m_ScheduleOtherConn=0;
937                 }
938                 if ( isRunning )
939                         abortTimer.start(90000, true);
940                 else
941                 {
942                         ++state;
943                         for (int i=0; i < 3; ++i)
944                         {
945                                 seenSections[i].clear();
946                                 calcedSections[i].clear();
947                         }
948                         can_delete=1;
949                 }
950         }
951         ++state;
952 }
953
954 void eEPGCache::channel_data::startChannel()
955 {
956         updateMap::iterator It = cache->channelLastUpdated.find( channel->getChannelID() );
957
958         int update = ( It != cache->channelLastUpdated.end() ? ( UPDATE_INTERVAL - ( (time(0)+eDVBLocalTimeHandler::getInstance()->difference()-It->second) * 1000 ) ) : ZAP_DELAY );
959
960         if (update < ZAP_DELAY)
961                 update = ZAP_DELAY;
962
963         zapTimer.start(update, 1);
964         if (update >= 60000)
965                 eDebug("[EPGC] next update in %i min", update/60000);
966         else if (update >= 1000)
967                 eDebug("[EPGC] next update in %i sec", update/1000);
968 }
969
970 void eEPGCache::channel_data::abortEPG()
971 {
972         for (int i=0; i < 3; ++i)
973         {
974                 seenSections[i].clear();
975                 calcedSections[i].clear();
976         }
977         abortTimer.stop();
978         zapTimer.stop();
979         if (isRunning)
980         {
981                 eDebug("[EPGC] abort caching events !!");
982                 if (isRunning & eEPGCache::SCHEDULE)
983                 {
984                         isRunning &= ~eEPGCache::SCHEDULE;
985                         m_ScheduleReader->stop();
986                         m_ScheduleConn=0;
987                 }
988                 if (isRunning & eEPGCache::NOWNEXT)
989                 {
990                         isRunning &= ~eEPGCache::NOWNEXT;
991                         m_NowNextReader->stop();
992                         m_NowNextConn=0;
993                 }
994                 if (isRunning & SCHEDULE_OTHER)
995                 {
996                         isRunning &= ~eEPGCache::SCHEDULE_OTHER;
997                         m_ScheduleOtherReader->stop();
998                         m_ScheduleOtherConn=0;
999                 }
1000                 can_delete=1;
1001         }
1002 }
1003
1004 void eEPGCache::channel_data::readData( const __u8 *data)
1005 {
1006         if (!data)
1007                 eDebug("get Null pointer from section reader !!");
1008         else
1009         {
1010                 int source;
1011                 int map;
1012                 iDVBSectionReader *reader=NULL;
1013                 switch(data[0])
1014                 {
1015                         case 0x4E ... 0x4F:
1016                                 reader=m_NowNextReader;
1017                                 source=eEPGCache::NOWNEXT;
1018                                 map=0;
1019                                 break;
1020                         case 0x50 ... 0x5F:
1021                                 reader=m_ScheduleReader;
1022                                 source=eEPGCache::SCHEDULE;
1023                                 map=1;
1024                                 break;
1025                         case 0x60 ... 0x6F:
1026                                 reader=m_ScheduleOtherReader;
1027                                 source=eEPGCache::SCHEDULE_OTHER;
1028                                 map=2;
1029                                 break;
1030                         default:
1031                                 eDebug("[EPGC] unknown table_id !!!");
1032                                 return;
1033                 }
1034                 tidMap &seenSections = this->seenSections[map];
1035                 tidMap &calcedSections = this->calcedSections[map];
1036                 if ( state == 1 && calcedSections == seenSections || state > 1 )
1037                 {
1038                         eDebugNoNewLine("[EPGC] ");
1039                         switch (source)
1040                         {
1041                                 case eEPGCache::NOWNEXT:
1042                                         m_NowNextConn=0;
1043                                         eDebugNoNewLine("nownext");
1044                                         break;
1045                                 case eEPGCache::SCHEDULE:
1046                                         m_ScheduleConn=0;
1047                                         eDebugNoNewLine("schedule");
1048                                         break;
1049                                 case eEPGCache::SCHEDULE_OTHER:
1050                                         m_ScheduleOtherConn=0;
1051                                         eDebugNoNewLine("schedule other");
1052                                         break;
1053                                 default: eDebugNoNewLine("unknown");break;
1054                         }
1055                         eDebug(" finished(%d)", time(0)+eDVBLocalTimeHandler::getInstance()->difference());
1056                         if ( reader )
1057                                 reader->stop();
1058                         isRunning &= ~source;
1059                         if (!isRunning)
1060                                 finishEPG();
1061                 }
1062                 else
1063                 {
1064                         eit_t *eit = (eit_t*) data;
1065                         __u32 sectionNo = data[0] << 24;
1066                         sectionNo |= data[3] << 16;
1067                         sectionNo |= data[4] << 8;
1068                         sectionNo |= eit->section_number;
1069
1070                         tidMap::iterator it =
1071                                 seenSections.find(sectionNo);
1072
1073                         if ( it == seenSections.end() )
1074                         {
1075                                 seenSections.insert(sectionNo);
1076                                 calcedSections.insert(sectionNo);
1077                                 __u32 tmpval = sectionNo & 0xFFFFFF00;
1078                                 __u8 incr = source == NOWNEXT ? 1 : 8;
1079                                 for ( int i = 0; i <= eit->last_section_number; i+=incr )
1080                                 {
1081                                         if ( i == eit->section_number )
1082                                         {
1083                                                 for (int x=i; x <= eit->segment_last_section_number; ++x)
1084                                                         calcedSections.insert(tmpval|(x&0xFF));
1085                                         }
1086                                         else
1087                                                 calcedSections.insert(tmpval|(i&0xFF));
1088                                 }
1089                                 cache->sectionRead(data, source, this);
1090                         }
1091                 }
1092         }
1093 }