616c7007e5ceeb9a6707d4520e152917c0ddedf5
[enigma2.git] / lib / service / servicedvb.cpp
1 #include <lib/base/eerror.h>
2 #include <lib/base/object.h>
3 #include <string>
4 #include <lib/service/servicedvb.h>
5 #include <lib/service/service.h>
6 #include <lib/base/init_num.h>
7 #include <lib/base/init.h>
8 #include <lib/base/nconfig.h> // access to python config
9 #include <lib/dvb/dvb.h>
10 #include <lib/dvb/db.h>
11 #include <lib/dvb/decoder.h>
12
13 #include <lib/components/file_eraser.h>
14 #include <lib/service/servicedvbrecord.h>
15 #include <lib/service/event.h>
16 #include <lib/dvb/metaparser.h>
17 #include <lib/dvb/tstools.h>
18 #include <lib/python/python.h>
19
20                 /* for subtitles */
21 #include <lib/gui/esubtitle.h>
22
23 #include <sys/vfs.h>
24
25 #include <byteswap.h>
26 #include <netinet/in.h>
27
28 #define INTERNAL_TELETEXT
29
30 #ifndef BYTE_ORDER
31 #error no byte order defined!
32 #endif
33
34 #define TSPATH "/media/hdd"
35
36 class eStaticServiceDVBInformation: public iStaticServiceInformation
37 {
38         DECLARE_REF(eStaticServiceDVBInformation);
39 public:
40         RESULT getName(const eServiceReference &ref, std::string &name);
41         int getLength(const eServiceReference &ref);
42 };
43
44 DEFINE_REF(eStaticServiceDVBInformation);
45
46 RESULT eStaticServiceDVBInformation::getName(const eServiceReference &ref, std::string &name)
47 {
48         eServiceReferenceDVB &service = (eServiceReferenceDVB&)ref;
49         if ( !ref.name.empty() )
50         {
51                 if (service.getParentTransportStreamID().get()) // linkage subservice
52                 {
53                         ePtr<iServiceHandler> service_center;
54                         if (!eServiceCenter::getInstance(service_center))
55                         {
56                                 eServiceReferenceDVB parent = service;
57                                 parent.setTransportStreamID( service.getParentTransportStreamID() );
58                                 parent.setServiceID( service.getParentServiceID() );
59                                 parent.setParentTransportStreamID(eTransportStreamID(0));
60                                 parent.setParentServiceID(eServiceID(0));
61                                 parent.name="";
62                                 ePtr<iStaticServiceInformation> service_info;
63                                 if (!service_center->info(parent, service_info))
64                                 {
65                                         if (!service_info->getName(parent, name))
66                                         {
67                                                 // just show short name
68                                                 unsigned int pos = name.find("\xc2\x86");
69                                                 if ( pos != std::string::npos )
70                                                         name.erase(0, pos+2);
71                                                 pos = name.find("\xc2\x87");
72                                                 if ( pos != std::string::npos )
73                                                         name.erase(pos);
74                                                 name+=" - ";
75                                         }
76                                 }
77                         }
78                 }
79                 else
80                         name="";
81                 name += ref.name;
82                 return 0;
83         }
84         else
85                 return -1;
86 }
87
88 int eStaticServiceDVBInformation::getLength(const eServiceReference &ref)
89 {
90         return -1;
91 }
92
93 class eStaticServiceDVBBouquetInformation: public iStaticServiceInformation
94 {
95         DECLARE_REF(eStaticServiceDVBBouquetInformation);
96 public:
97         RESULT getName(const eServiceReference &ref, std::string &name);
98         int getLength(const eServiceReference &ref);
99 };
100
101 DEFINE_REF(eStaticServiceDVBBouquetInformation);
102
103 RESULT eStaticServiceDVBBouquetInformation::getName(const eServiceReference &ref, std::string &name)
104 {
105         ePtr<iDVBChannelList> db;
106         ePtr<eDVBResourceManager> res;
107
108         int err;
109         if ((err = eDVBResourceManager::getInstance(res)) != 0)
110         {
111                 eDebug("eStaticServiceDVBBouquetInformation::getName failed.. no resource manager!");
112                 return err;
113         }
114         if ((err = res->getChannelList(db)) != 0)
115         {
116                 eDebug("eStaticServiceDVBBouquetInformation::getName failed.. no channel list!");
117                 return err;
118         }
119
120         eBouquet *bouquet=0;
121         if ((err = db->getBouquet(ref, bouquet)) != 0)
122         {
123                 eDebug("eStaticServiceDVBBouquetInformation::getName failed.. getBouquet failed!");
124                 return -1;
125         }
126
127         if ( bouquet && bouquet->m_bouquet_name.length() )
128         {
129                 name = bouquet->m_bouquet_name;
130                 return 0;
131         }
132         else
133                 return -1;
134 }
135
136 int eStaticServiceDVBBouquetInformation::getLength(const eServiceReference &ref)
137 {
138         return -1;
139 }
140
141 class eStaticServiceDVBPVRInformation: public iStaticServiceInformation
142 {
143         DECLARE_REF(eStaticServiceDVBPVRInformation);
144         eServiceReference m_ref;
145         eDVBMetaParser m_parser;
146 public:
147         eStaticServiceDVBPVRInformation(const eServiceReference &ref);
148         RESULT getName(const eServiceReference &ref, std::string &name);
149         int getLength(const eServiceReference &ref);
150         RESULT getEvent(const eServiceReference &ref, ePtr<eServiceEvent> &SWIG_OUTPUT, time_t start_time);
151
152         int getInfo(const eServiceReference &ref, int w);
153         std::string getInfoString(const eServiceReference &ref,int w);
154 };
155
156 DEFINE_REF(eStaticServiceDVBPVRInformation);
157
158 eStaticServiceDVBPVRInformation::eStaticServiceDVBPVRInformation(const eServiceReference &ref)
159 {
160         m_ref = ref;
161         m_parser.parseFile(ref.path);
162 }
163
164 RESULT eStaticServiceDVBPVRInformation::getName(const eServiceReference &ref, std::string &name)
165 {
166         ASSERT(ref == m_ref);
167         name = m_parser.m_name.size() ? m_parser.m_name : ref.path;
168         return 0;
169 }
170
171 int eStaticServiceDVBPVRInformation::getLength(const eServiceReference &ref)
172 {
173         ASSERT(ref == m_ref);
174         
175         eDVBTSTools tstools;
176         
177         if (tstools.openFile(ref.path.c_str()))
178                 return 0;
179
180         pts_t len;
181         if (tstools.calcLen(len))
182                 return 0;
183
184         return len / 90000;
185 }
186
187 int eStaticServiceDVBPVRInformation::getInfo(const eServiceReference &ref, int w)
188 {
189         switch (w)
190         {
191         case iServiceInformation::sDescription:
192                 return iServiceInformation::resIsString;
193         case iServiceInformation::sServiceref:
194                 return iServiceInformation::resIsString;
195         case iServiceInformation::sTimeCreate:
196                 if (m_parser.m_time_create)
197                         return m_parser.m_time_create;
198                 else
199                         return iServiceInformation::resNA;
200         default:
201                 return iServiceInformation::resNA;
202         }
203 }
204
205 std::string eStaticServiceDVBPVRInformation::getInfoString(const eServiceReference &ref,int w)
206 {
207         switch (w)
208         {
209         case iServiceInformation::sDescription:
210                 return m_parser.m_description;
211         case iServiceInformation::sServiceref:
212                 return m_parser.m_ref.toString();
213         default:
214                 return "";
215         }
216 }
217
218 RESULT eStaticServiceDVBPVRInformation::getEvent(const eServiceReference &ref, ePtr<eServiceEvent> &evt, time_t start_time)
219 {
220         if (!ref.path.empty())
221         {
222                 ePtr<eServiceEvent> event = new eServiceEvent;
223                 std::string filename = ref.path;
224                 filename.erase(filename.length()-2, 2);
225                 filename+="eit";
226                 if (!event->parseFrom(filename, (m_parser.m_ref.getTransportStreamID().get()<<16)|m_parser.m_ref.getOriginalNetworkID().get()))
227                 {
228                         evt = event;
229                         return 0;
230                 }
231         }
232         evt = 0;
233         return -1;
234 }
235
236 class eDVBPVRServiceOfflineOperations: public iServiceOfflineOperations
237 {
238         DECLARE_REF(eDVBPVRServiceOfflineOperations);
239         eServiceReferenceDVB m_ref;
240 public:
241         eDVBPVRServiceOfflineOperations(const eServiceReference &ref);
242         
243         RESULT deleteFromDisk(int simulate);
244         RESULT getListOfFilenames(std::list<std::string> &);
245 };
246
247 DEFINE_REF(eDVBPVRServiceOfflineOperations);
248
249 eDVBPVRServiceOfflineOperations::eDVBPVRServiceOfflineOperations(const eServiceReference &ref): m_ref((const eServiceReferenceDVB&)ref)
250 {
251 }
252
253 RESULT eDVBPVRServiceOfflineOperations::deleteFromDisk(int simulate)
254 {
255         if (simulate)
256                 return 0;
257         else
258         {
259                 std::list<std::string> res;
260                 if (getListOfFilenames(res))
261                         return -1;
262                 
263                 eBackgroundFileEraser *eraser = eBackgroundFileEraser::getInstance();
264                 if (!eraser)
265                         eDebug("FATAL !! can't get background file eraser");
266                 
267                 for (std::list<std::string>::iterator i(res.begin()); i != res.end(); ++i)
268                 {
269                         eDebug("Removing %s...", i->c_str());
270                         if (eraser)
271                                 eraser->erase(i->c_str());
272                         else
273                                 ::unlink(i->c_str());
274                 }
275                 
276                 return 0;
277         }
278 }
279
280 RESULT eDVBPVRServiceOfflineOperations::getListOfFilenames(std::list<std::string> &res)
281 {
282         res.clear();
283         res.push_back(m_ref.path);
284
285 // handling for old splitted recordings (enigma 1)
286         char buf[255];
287         int slice=1;
288         while(true)
289         {
290                 snprintf(buf, 255, "%s.%03d", m_ref.path.c_str(), slice++);
291                 struct stat s;
292                 if (stat(buf, &s) < 0)
293                         break;
294                 res.push_back(buf);
295         }       
296
297         res.push_back(m_ref.path + ".meta");
298         res.push_back(m_ref.path + ".ap");
299         res.push_back(m_ref.path + ".cuts");
300         std::string tmp = m_ref.path;
301         tmp.erase(m_ref.path.length()-3);
302         res.push_back(tmp + ".eit");
303         return 0;
304 }
305
306 DEFINE_REF(eServiceFactoryDVB)
307
308 eServiceFactoryDVB::eServiceFactoryDVB()
309 {
310         ePtr<eServiceCenter> sc;
311         
312         eServiceCenter::getPrivInstance(sc);
313         if (sc)
314                 sc->addServiceFactory(eServiceFactoryDVB::id, this);
315 }
316
317 eServiceFactoryDVB::~eServiceFactoryDVB()
318 {
319         ePtr<eServiceCenter> sc;
320         
321         eServiceCenter::getPrivInstance(sc);
322         if (sc)
323                 sc->removeServiceFactory(eServiceFactoryDVB::id);
324 }
325
326 DEFINE_REF(eDVBServiceList);
327
328 eDVBServiceList::eDVBServiceList(const eServiceReference &parent): m_parent(parent)
329 {
330 }
331
332 eDVBServiceList::~eDVBServiceList()
333 {
334 }
335
336 RESULT eDVBServiceList::startQuery()
337 {
338         ePtr<iDVBChannelList> db;
339         ePtr<eDVBResourceManager> res;
340         
341         int err;
342         if ((err = eDVBResourceManager::getInstance(res)) != 0)
343         {
344                 eDebug("no resource manager");
345                 return err;
346         }
347         if ((err = res->getChannelList(db)) != 0)
348         {
349                 eDebug("no channel list");
350                 return err;
351         }
352         
353         ePtr<eDVBChannelQuery> q;
354         
355         if (!m_parent.path.empty())
356         {
357                 eDVBChannelQuery::compile(q, m_parent.path);
358                 if (!q)
359                 {
360                         eDebug("compile query failed");
361                         return err;
362                 }
363         }
364         
365         if ((err = db->startQuery(m_query, q, m_parent)) != 0)
366         {
367                 eDebug("startQuery failed");
368                 return err;
369         }
370
371         return 0;
372 }
373
374 RESULT eDVBServiceList::getContent(std::list<eServiceReference> &list, bool sorted)
375 {
376         eServiceReferenceDVB ref;
377         
378         if (!m_query)
379                 return -1;
380         
381         while (!m_query->getNextResult(ref))
382                 list.push_back(ref);
383
384         if (sorted)
385                 list.sort(iListableServiceCompare(this));
386
387         return 0;
388 }
389
390 //   The first argument of this function is a format string to specify the order and
391 //   the content of the returned list
392 //   useable format options are
393 //   R = Service Reference (as swig object .. this is very slow)
394 //   S = Service Reference (as python string object .. same as ref.toString())
395 //   N = Service Name (as python string object)
396 //   when exactly one return value per service is selected in the format string,
397 //   then each value is directly a list entry
398 //   when more than one value is returned per service, then the list is a list of
399 //   python tuples
400 //   unknown format string chars are returned as python None values !
401 PyObject *eDVBServiceList::getContent(const char* format, bool sorted)
402 {
403         PyObject *ret=0;
404         std::list<eServiceReference> tmplist;
405         int retcount=1;
406
407         if (!format || !(retcount=strlen(format)))
408                 format = "R"; // just return service reference swig object ...
409
410         if (!getContent(tmplist, sorted))
411         {
412                 int services=tmplist.size();
413                 ePtr<iStaticServiceInformation> sptr;
414                 eServiceCenterPtr service_center;
415
416                 if (strchr(format, 'N'))
417                         eServiceCenter::getPrivInstance(service_center);
418
419                 ret = PyList_New(services);
420                 std::list<eServiceReference>::iterator it(tmplist.begin());
421
422                 for (int cnt=0; cnt < services; ++cnt)
423                 {
424                         eServiceReference &ref=*it++;
425                         PyObject *tuple = retcount > 1 ? PyTuple_New(retcount) : 0;
426                         for (int i=0; i < retcount; ++i)
427                         {
428                                 PyObject *tmp=0;
429                                 switch(format[i])
430                                 {
431                                 case 'R':  // service reference (swig)object
432                                         tmp = New_eServiceReference(ref);
433                                         break;
434                                 case 'S':  // service reference string
435                                         tmp = PyString_FromString(ref.toString().c_str());
436                                         break;
437                                 case 'N':  // service name
438                                         if (service_center)
439                                         {
440                                                 service_center->info(ref, sptr);
441                                                 if (sptr)
442                                                 {
443                                                         std::string name;
444                                                         sptr->getName(ref, name);
445                                                         if (name.length())
446                                                                 tmp = PyString_FromString(name.c_str());
447                                                 }
448                                         }
449                                         if (!tmp)
450                                                 tmp = PyString_FromString("<n/a>");
451                                         break;
452                                 default:
453                                         if (tuple)
454                                         {
455                                                 tmp = Py_None;
456                                                 Py_INCREF(Py_None);
457                                         }
458                                         break;
459                                 }
460                                 if (tmp)
461                                 {
462                                         if (tuple)
463                                                 PyTuple_SET_ITEM(tuple, i, tmp);
464                                         else
465                                                 PyList_SET_ITEM(ret, cnt, tmp);
466                                 }
467                         }
468                         if (tuple)
469                                 PyList_SET_ITEM(ret, cnt, tuple);
470                 }
471         }
472         return ret ? ret : PyList_New(0);
473 }
474
475 RESULT eDVBServiceList::getNext(eServiceReference &ref)
476 {
477         if (!m_query)
478                 return -1;
479         
480         return m_query->getNextResult((eServiceReferenceDVB&)ref);
481 }
482
483 int eDVBServiceList::compareLessEqual(const eServiceReference &a, const eServiceReference &b)
484 {
485         return m_query->compareLessEqual((const eServiceReferenceDVB&)a, (const eServiceReferenceDVB&)b);
486 }
487
488 RESULT eDVBServiceList::startEdit(ePtr<iMutableServiceList> &res)
489 {
490         if (m_parent.flags & eServiceReference::flagDirectory) // bouquet
491         {
492                 ePtr<iDVBChannelList> db;
493                 ePtr<eDVBResourceManager> resm;
494
495                 if (eDVBResourceManager::getInstance(resm) || resm->getChannelList(db))
496                         return -1;
497
498                 if (db->getBouquet(m_parent, m_bouquet) != 0)
499                         return -1;
500
501                 res = this;
502                 
503                 return 0;
504         }
505         res = 0;
506         return -1;
507 }
508
509 RESULT eDVBServiceList::addService(eServiceReference &ref)
510 {
511         if (!m_bouquet)
512                 return -1;
513         return m_bouquet->addService(ref);
514 }
515
516 RESULT eDVBServiceList::removeService(eServiceReference &ref)
517 {
518         if (!m_bouquet)
519                 return -1;
520         return m_bouquet->removeService(ref);
521 }
522
523 RESULT eDVBServiceList::moveService(eServiceReference &ref, int pos)
524 {
525         if (!m_bouquet)
526                 return -1;
527         return m_bouquet->moveService(ref, pos);
528 }
529
530 RESULT eDVBServiceList::flushChanges()
531 {
532         if (!m_bouquet)
533                 return -1;
534         return m_bouquet->flushChanges();
535 }
536
537 RESULT eDVBServiceList::setListName(const std::string &name)
538 {
539         if (!m_bouquet)
540                 return -1;
541         return m_bouquet->setListName(name);
542 }
543
544 RESULT eServiceFactoryDVB::play(const eServiceReference &ref, ePtr<iPlayableService> &ptr)
545 {
546         ePtr<eDVBService> service;
547         int r = lookupService(service, ref);
548         if (r)
549                 service = 0;
550                 // check resources...
551         ptr = new eDVBServicePlay(ref, service);
552         return 0;
553 }
554
555 RESULT eServiceFactoryDVB::record(const eServiceReference &ref, ePtr<iRecordableService> &ptr)
556 {
557         if (ref.path.empty())
558         {
559                 ptr = new eDVBServiceRecord((eServiceReferenceDVB&)ref);
560                 return 0;
561         } else
562         {
563                 ptr = 0;
564                 return -1;
565         }
566 }
567
568 RESULT eServiceFactoryDVB::list(const eServiceReference &ref, ePtr<iListableService> &ptr)
569 {
570         ePtr<eDVBServiceList> list = new eDVBServiceList(ref);
571         if (list->startQuery())
572         {
573                 ptr = 0;
574                 return -1;
575         }
576         
577         ptr = list;
578         return 0;
579 }
580
581 RESULT eServiceFactoryDVB::info(const eServiceReference &ref, ePtr<iStaticServiceInformation> &ptr)
582 {
583         /* is a listable service? */
584         if ((ref.flags & eServiceReference::flagDirectory) == eServiceReference::flagDirectory) // bouquet
585         {
586                 if ( !ref.name.empty() )  // satellites or providers list
587                         ptr = new eStaticServiceDVBInformation;
588                 else // a dvb bouquet
589                         ptr = new eStaticServiceDVBBouquetInformation;
590         }
591         else if (!ref.path.empty()) /* do we have a PVR service? */
592                 ptr = new eStaticServiceDVBPVRInformation(ref);
593         else // normal dvb service
594         {
595                 ePtr<eDVBService> service;
596                 if (lookupService(service, ref)) // no eDVBService avail for this reference ( Linkage Services... )
597                         ptr = new eStaticServiceDVBInformation;
598                 else
599                         /* eDVBService has the iStaticServiceInformation interface, so we pass it here. */
600                         ptr = service;
601         }
602         return 0;
603 }
604
605 RESULT eServiceFactoryDVB::offlineOperations(const eServiceReference &ref, ePtr<iServiceOfflineOperations> &ptr)
606 {
607         if (ref.path.empty())
608         {
609                 ptr = 0;
610                 return -1;
611         } else
612         {
613                 ptr = new eDVBPVRServiceOfflineOperations(ref);
614                 return 0;
615         }
616 }
617
618 RESULT eServiceFactoryDVB::lookupService(ePtr<eDVBService> &service, const eServiceReference &ref)
619 {
620                         // TODO: handle the listing itself
621         // if (ref.... == -1) .. return "... bouquets ...";
622         // could be also done in another serviceFactory (with seperate ID) to seperate actual services and lists
623                         // TODO: cache
624         ePtr<iDVBChannelList> db;
625         ePtr<eDVBResourceManager> res;
626         
627         int err;
628         if ((err = eDVBResourceManager::getInstance(res)) != 0)
629         {
630                 eDebug("no resource manager");
631                 return err;
632         }
633         if ((err = res->getChannelList(db)) != 0)
634         {
635                 eDebug("no channel list");
636                 return err;
637         }
638         
639                 /* we are sure to have a ..DVB reference as the info() call was forwarded here according to it's ID. */
640         if ((err = db->getService((eServiceReferenceDVB&)ref, service)) != 0)
641         {
642                 eDebug("getService failed!");
643                 return err;
644         }
645
646         return 0;
647 }
648
649 eDVBServicePlay::eDVBServicePlay(const eServiceReference &ref, eDVBService *service): 
650         m_reference(ref), m_dvb_service(service), m_have_video_pid(0), m_is_paused(0)
651 {
652         m_is_primary = 1;
653         m_is_pvr = !m_reference.path.empty();
654         
655         m_timeshift_enabled = m_timeshift_active = 0;
656         m_skipmode = 0;
657         
658         CONNECT(m_service_handler.serviceEvent, eDVBServicePlay::serviceEvent);
659         CONNECT(m_service_handler_timeshift.serviceEvent, eDVBServicePlay::serviceEventTimeshift);
660         CONNECT(m_event_handler.m_eit_changed, eDVBServicePlay::gotNewEvent);
661
662         m_cuesheet_changed = 0;
663         m_cutlist_enabled = 1;
664         
665         m_subtitle_widget = 0;
666         
667         CONNECT(m_subtitle_sync_timer.timeout, eDVBServicePlay::checkSubtitleTiming);
668 }
669
670 eDVBServicePlay::~eDVBServicePlay()
671 {
672         delete m_subtitle_widget;
673 }
674
675 void eDVBServicePlay::gotNewEvent()
676 {
677 #if 0
678                 // debug only
679         ePtr<eServiceEvent> m_event_now, m_event_next;
680         getEvent(m_event_now, 0);
681         getEvent(m_event_next, 1);
682
683         if (m_event_now)
684                 eDebug("now running: %s (%d seconds :)", m_event_now->m_event_name.c_str(), m_event_now->m_duration);
685         if (m_event_next)
686                 eDebug("next running: %s (%d seconds :)", m_event_next->m_event_name.c_str(), m_event_next->m_duration);
687 #endif
688         m_event((iPlayableService*)this, evUpdatedEventInfo);
689 }
690
691 void eDVBServicePlay::serviceEvent(int event)
692 {
693         switch (event)
694         {
695         case eDVBServicePMTHandler::eventTuned:
696         {
697                 ePtr<iDVBDemux> m_demux;
698                 if (!m_service_handler.getDataDemux(m_demux))
699                 {
700                         eServiceReferenceDVB &ref = (eServiceReferenceDVB&) m_reference;
701                         int sid = ref.getParentServiceID().get();
702                         if (!sid)
703                                 sid = ref.getServiceID().get();
704                         if ( ref.getParentTransportStreamID().get() &&
705                                 ref.getParentTransportStreamID() != ref.getTransportStreamID() )
706                                 m_event_handler.startOther(m_demux, sid);
707                         else
708                                 m_event_handler.start(m_demux, sid);
709                 }
710                 break;
711         }
712         case eDVBServicePMTHandler::eventTuneFailed:
713         {
714                 eDebug("DVB service failed to tune");
715                 m_event((iPlayableService*)this, evTuneFailed);
716                 break;
717         }
718         case eDVBServicePMTHandler::eventNewProgramInfo:
719         {
720                 eDebug("eventNewProgramInfo %d %d", m_timeshift_enabled, m_timeshift_active);
721                 if (m_timeshift_enabled)
722                         updateTimeshiftPids();
723                 if (!m_timeshift_active)
724                         updateDecoder();
725                 if (m_first_program_info && m_is_pvr)
726                 {
727                         m_first_program_info = 0;
728                         seekTo(0);
729                 }
730                 m_event((iPlayableService*)this, evUpdatedInfo);
731                 break;
732         }
733         case eDVBServicePMTHandler::eventEOF:
734                 m_event((iPlayableService*)this, evEOF);
735                 break;
736         case eDVBServicePMTHandler::eventSOF:
737                 m_event((iPlayableService*)this, evSOF);
738                 break;
739         }
740 }
741
742 void eDVBServicePlay::serviceEventTimeshift(int event)
743 {
744         switch (event)
745         {
746         case eDVBServicePMTHandler::eventNewProgramInfo:
747                 if (m_timeshift_active)
748                         updateDecoder();
749                 break;
750         case eDVBServicePMTHandler::eventSOF:
751                 m_event((iPlayableService*)this, evSOF);
752                 break;
753         case eDVBServicePMTHandler::eventEOF:
754                 switchToLive();
755                 break;
756         }
757 }
758
759 RESULT eDVBServicePlay::start()
760 {
761         int r;
762                 /* in pvr mode, we only want to use one demux. in tv mode, we're using 
763                    two (one for decoding, one for data source), as we must be prepared
764                    to start recording from the data demux. */
765         if (m_is_pvr)
766                 m_cue = new eCueSheet();
767
768         m_first_program_info = 1;
769         eServiceReferenceDVB &service = (eServiceReferenceDVB&)m_reference;
770         r = m_service_handler.tune(service, m_is_pvr, m_cue);
771
772                 /* inject EIT if there is a stored one */
773         if (m_is_pvr)
774         {
775                 std::string filename = service.path;
776                 filename.erase(filename.length()-2, 2);
777                 filename+="eit";
778                 ePtr<eServiceEvent> event = new eServiceEvent;
779                 if (!event->parseFrom(filename, (service.getTransportStreamID().get()<<16)|service.getOriginalNetworkID().get()))
780                 {
781                         ePtr<eServiceEvent> empty;
782                         m_event_handler.inject(event, 0);
783                         m_event_handler.inject(empty, 1);
784                 }
785         }
786
787         if (m_is_pvr)
788                 loadCuesheet();
789
790         m_event(this, evStart);
791         m_event((iPlayableService*)this, evSeekableStatusChanged);
792         return 0;
793 }
794
795 RESULT eDVBServicePlay::stop()
796 {
797         stopTimeshift(); /* in case timeshift was enabled, remove buffer etc. */
798
799         m_service_handler_timeshift.free();
800         m_service_handler.free();
801         
802         if (m_is_pvr && m_cuesheet_changed)
803                 saveCuesheet();
804         
805         return 0;
806 }
807
808 RESULT eDVBServicePlay::setTarget(int target)
809 {
810         m_is_primary = !target;
811         return 0;
812 }
813
814 RESULT eDVBServicePlay::connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection)
815 {
816         connection = new eConnection((iPlayableService*)this, m_event.connect(event));
817         return 0;
818 }
819
820 RESULT eDVBServicePlay::pause(ePtr<iPauseableService> &ptr)
821 {
822                 /* note: we check for timeshift to be enabled,
823                    not neccessary active. if you pause when timeshift
824                    is not active, you should activate it when unpausing */
825         if ((!m_is_pvr) && (!m_timeshift_enabled))
826         {
827                 ptr = 0;
828                 return -1;
829         }
830
831         ptr = this;
832         return 0;
833 }
834
835 RESULT eDVBServicePlay::setSlowMotion(int ratio)
836 {
837         if (m_decoder)
838                 return m_decoder->setSlowMotion(ratio);
839         else
840                 return -1;
841 }
842
843 RESULT eDVBServicePlay::setFastForward(int ratio)
844 {
845         int skipmode, ffratio;
846         
847         if (ratio > 8)
848         {
849                 skipmode = ratio;
850                 ffratio = 1;
851         } else if (ratio > 0)
852         {
853                 skipmode = 0;
854                 ffratio = ratio;
855         } else if (!ratio)
856         {
857                 skipmode = 0;
858                 ffratio = 0;
859         } else // if (ratio < 0)
860         {
861                 skipmode = ratio;
862                 ffratio = 1;
863         }
864
865         if (m_skipmode != skipmode)
866         {
867                 eDebug("setting cue skipmode to %d", skipmode);
868                 if (m_cue)
869                         m_cue->setSkipmode(skipmode * 90000); /* convert to 90000 per second */
870         }
871         
872         m_skipmode = skipmode;
873         
874         if (!m_decoder)
875                 return -1;
876
877         return m_decoder->setFastForward(ffratio);
878 }
879     
880 RESULT eDVBServicePlay::seek(ePtr<iSeekableService> &ptr)
881 {
882         if (m_is_pvr || m_timeshift_enabled)
883         {
884                 ptr = this;
885                 return 0;
886         }
887         
888         ptr = 0;
889         return -1;
890 }
891
892         /* TODO: when timeshift is enabled but not active, this doesn't work. */
893 RESULT eDVBServicePlay::getLength(pts_t &len)
894 {
895         ePtr<iDVBPVRChannel> pvr_channel;
896         
897         if ((m_timeshift_enabled ? m_service_handler_timeshift : m_service_handler).getPVRChannel(pvr_channel))
898                 return -1;
899         
900         return pvr_channel->getLength(len);
901 }
902
903 RESULT eDVBServicePlay::pause()
904 {
905         if (!m_is_paused && m_decoder)
906         {
907                 m_is_paused = 1;
908                 return m_decoder->freeze(0);
909         } else
910                 return -1;
911 }
912
913 RESULT eDVBServicePlay::unpause()
914 {
915         if (m_is_paused && m_decoder)
916         {
917                 m_is_paused = 0;
918                 return m_decoder->unfreeze();
919         } else
920                 return -1;
921 }
922
923 RESULT eDVBServicePlay::seekTo(pts_t to)
924 {
925         eDebug("eDVBServicePlay::seekTo: jump %lld", to);
926         
927         if (!m_decode_demux)
928                 return -1;
929
930         ePtr<iDVBPVRChannel> pvr_channel;
931         
932         if ((m_timeshift_enabled ? m_service_handler_timeshift : m_service_handler).getPVRChannel(pvr_channel))
933                 return -1;
934         
935         if (!m_cue)
936                 return -1;
937         
938         m_cue->seekTo(0, to);
939         return 0;
940 }
941
942 RESULT eDVBServicePlay::seekRelative(int direction, pts_t to)
943 {
944         eDebug("eDVBServicePlay::seekRelative: jump %d, %lld", direction, to);
945         
946         if (!m_decode_demux)
947                 return -1;
948
949         ePtr<iDVBPVRChannel> pvr_channel;
950         
951         if ((m_timeshift_enabled ? m_service_handler_timeshift : m_service_handler).getPVRChannel(pvr_channel))
952                 return -1;
953         
954         int mode = 1;
955         
956                         /* HACK until we have skip-AP api */
957         if ((to > 0) && (to < 100))
958                 mode = 2;
959         
960         to *= direction;
961         
962         if (!m_cue)
963                 return 0;
964         
965         m_cue->seekTo(mode, to);
966         return 0;
967 }
968
969 RESULT eDVBServicePlay::getPlayPosition(pts_t &pos)
970 {
971         ePtr<iDVBPVRChannel> pvr_channel;
972         
973         if (!m_decode_demux)
974                 return -1;
975         
976         if ((m_timeshift_enabled ? m_service_handler_timeshift : m_service_handler).getPVRChannel(pvr_channel))
977                 return -1;
978         
979         int r = 0;
980
981                 /* if there is a decoder, use audio or video PTS */
982         if (m_decoder)
983         {
984                 r = m_decoder->getPTS(0, pos);
985                 if (r)
986                         return r;
987         }
988         
989                 /* fixup */
990         return pvr_channel->getCurrentPosition(m_decode_demux, pos, m_decoder ? 1 : 0);
991 }
992
993 RESULT eDVBServicePlay::setTrickmode(int trick)
994 {
995         if (m_decoder)
996                 m_decoder->setTrickmode(trick);
997         return 0;
998 }
999
1000 RESULT eDVBServicePlay::isCurrentlySeekable()
1001 {
1002         return m_is_pvr || m_timeshift_active;
1003 }
1004
1005 RESULT eDVBServicePlay::frontendInfo(ePtr<iFrontendInformation> &ptr)
1006 {
1007         ptr = this;
1008         return 0;
1009 }
1010
1011 RESULT eDVBServicePlay::info(ePtr<iServiceInformation> &ptr)
1012 {
1013         ptr = this;
1014         return 0;
1015 }
1016
1017 RESULT eDVBServicePlay::audioChannel(ePtr<iAudioChannelSelection> &ptr)
1018 {
1019         ptr = this;
1020         return 0;
1021 }
1022
1023 RESULT eDVBServicePlay::audioTracks(ePtr<iAudioTrackSelection> &ptr)
1024 {
1025         ptr = this;
1026         return 0;
1027 }
1028
1029 RESULT eDVBServicePlay::subServices(ePtr<iSubserviceList> &ptr)
1030 {
1031         ptr = this;
1032         return 0;
1033 }
1034
1035 RESULT eDVBServicePlay::timeshift(ePtr<iTimeshiftService> &ptr)
1036 {
1037         ptr = 0;
1038         if (m_have_video_pid &&  // HACK !!! FIXMEE !! temporary no timeshift on radio services !!
1039                 (m_timeshift_enabled || !m_is_pvr))
1040         {
1041                 if (!m_timeshift_enabled)
1042                 {
1043                                 /* we need enough diskspace */
1044                         struct statfs fs;
1045                         if (statfs(TSPATH "/.", &fs) < 0)
1046                         {
1047                                 eDebug("statfs failed!");
1048                                 return -2;
1049                         }
1050                 
1051                         if (((off_t)fs.f_bavail) * ((off_t)fs.f_bsize) < 1024*1024*1024LL)
1052                         {
1053                                 eDebug("not enough diskspace for timeshift! (less than 1GB)");
1054                                 return -3;
1055                         }
1056                 }
1057                 ptr = this;
1058                 return 0;
1059         }
1060         return -1;
1061 }
1062
1063 RESULT eDVBServicePlay::cueSheet(ePtr<iCueSheet> &ptr)
1064 {
1065         if (m_is_pvr)
1066         {
1067                 ptr = this;
1068                 return 0;
1069         }
1070         ptr = 0;
1071         return -1;
1072 }
1073
1074 RESULT eDVBServicePlay::subtitle(ePtr<iSubtitleOutput> &ptr)
1075 {
1076         ptr = this;
1077         return 0;
1078 }
1079
1080 RESULT eDVBServicePlay::audioDelay(ePtr<iAudioDelay> &ptr)
1081 {
1082         ptr = this;
1083         return 0;
1084 }
1085
1086 RESULT eDVBServicePlay::getName(std::string &name)
1087 {
1088         if (m_is_pvr)
1089         {
1090                 ePtr<iStaticServiceInformation> i = new eStaticServiceDVBPVRInformation(m_reference);
1091                 return i->getName(m_reference, name);
1092         }
1093         if (m_dvb_service)
1094         {
1095                 m_dvb_service->getName(m_reference, name);
1096                 if (name.empty())
1097                         name = "(...)";
1098         }
1099         else if (!m_reference.name.empty())
1100                 eStaticServiceDVBInformation().getName(m_reference, name);
1101         else
1102                 name = "DVB service";
1103         return 0;
1104 }
1105
1106 RESULT eDVBServicePlay::getEvent(ePtr<eServiceEvent> &evt, int nownext)
1107 {
1108         return m_event_handler.getEvent(evt, nownext);
1109 }
1110
1111 int eDVBServicePlay::getInfo(int w)
1112 {
1113         eDVBServicePMTHandler::program program;
1114
1115         if (w == sCAIDs)
1116                 return resIsPyObject;
1117
1118         if (m_service_handler.getProgramInfo(program))
1119                 return -1;
1120         
1121         switch (w)
1122         {
1123         case sAspect:
1124                 if (!program.videoStreams.empty() && program.videoStreams[0].component_tag != -1)
1125                 {
1126                         ePtr<eServiceEvent> evt;
1127                         if (!m_event_handler.getEvent(evt, 0))
1128                         {
1129                                 ePtr<eComponentData> data;
1130                                 if (!evt->getComponentData(data, program.videoStreams[0].component_tag))
1131                                 {
1132                                         if ( data->getStreamContent() == 1 )
1133                                         {
1134                                                 switch(data->getComponentType())
1135                                                 {
1136                                                         // SD
1137                                                         case 1: // 4:3 SD PAL
1138                                                         case 2:
1139                                                         case 3: // 16:9 SD PAL
1140                                                         case 4: // > 16:9 PAL
1141                                                         case 5: // 4:3 SD NTSC
1142                                                         case 6: 
1143                                                         case 7: // 16:9 SD NTSC
1144                                                         case 8: // > 16:9 NTSC
1145
1146                                                         // HD
1147                                                         case 9: // 4:3 HD PAL
1148                                                         case 0xA:
1149                                                         case 0xB: // 16:9 HD PAL
1150                                                         case 0xC: // > 16:9 HD PAL
1151                                                         case 0xD: // 4:3 HD NTSC
1152                                                         case 0xE:
1153                                                         case 0xF: // 16:9 HD NTSC
1154                                                         case 0x10: // > 16:9 HD PAL
1155                                                                 return data->getComponentType();
1156                                                 }
1157                                         }
1158                                 }
1159                         }
1160                 }
1161                 return -1;
1162         case sIsCrypted: return program.isCrypted();
1163         case sVideoPID: if (program.videoStreams.empty()) return -1; return program.videoStreams[0].pid;
1164         case sVideoType: if (program.videoStreams.empty()) return -1; return program.videoStreams[0].type;
1165         case sAudioPID: if (program.audioStreams.empty()) return -1; return program.audioStreams[m_current_audio_stream].pid;
1166         case sPCRPID: return program.pcrPid;
1167         case sPMTPID: return program.pmtPid;
1168         case sTXTPID: return program.textPid;
1169         case sSID: return ((const eServiceReferenceDVB&)m_reference).getServiceID().get();
1170         case sONID: return ((const eServiceReferenceDVB&)m_reference).getOriginalNetworkID().get();
1171         case sTSID: return ((const eServiceReferenceDVB&)m_reference).getTransportStreamID().get();
1172         case sNamespace: return ((const eServiceReferenceDVB&)m_reference).getDVBNamespace().get();
1173         case sProvider: if (!m_dvb_service) return -1; return -2;
1174         default:
1175                 return -1;
1176         }
1177 }
1178
1179 std::string eDVBServicePlay::getInfoString(int w)
1180 {
1181         switch (w)
1182         {
1183         case sProvider:
1184                 if (!m_dvb_service) return "";
1185                 return m_dvb_service->m_provider_name;
1186         default:
1187                 break;
1188         }
1189         return iServiceInformation::getInfoString(w);
1190 }
1191
1192 PyObject *eDVBServicePlay::getInfoObject(int w)
1193 {
1194         switch (w)
1195         {
1196         case sCAIDs:
1197                 return m_service_handler.getCaIds();
1198         default:
1199                 break;
1200         }
1201         return iServiceInformation::getInfoObject(w);
1202 }
1203
1204 int eDVBServicePlay::getNumberOfTracks()
1205 {
1206         eDVBServicePMTHandler::program program;
1207         if (m_service_handler.getProgramInfo(program))
1208                 return 0;
1209         return program.audioStreams.size();
1210 }
1211
1212 RESULT eDVBServicePlay::selectTrack(unsigned int i)
1213 {
1214         int ret = selectAudioStream(i);
1215
1216         if (m_decoder->start())
1217                 return -5;
1218
1219         return ret;
1220 }
1221
1222 RESULT eDVBServicePlay::getTrackInfo(struct iAudioTrackInfo &info, unsigned int i)
1223 {
1224         eDVBServicePMTHandler::program program;
1225
1226         if (m_service_handler.getProgramInfo(program))
1227                 return -1;
1228         
1229         if (i >= program.audioStreams.size())
1230                 return -2;
1231         
1232         if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atMPEG)
1233                 info.m_description = "MPEG";
1234         else if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atAC3)
1235                 info.m_description = "AC3";
1236         else if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atAAC)
1237                 info.m_description = "AAC";
1238         else  if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atDTS)
1239                 info.m_description = "DTS";
1240         else
1241                 info.m_description = "???";
1242
1243         if (program.audioStreams[i].component_tag != -1)
1244         {
1245                 ePtr<eServiceEvent> evt;
1246                 if (!m_event_handler.getEvent(evt, 0))
1247                 {
1248                         ePtr<eComponentData> data;
1249                         if (!evt->getComponentData(data, program.audioStreams[i].component_tag))
1250                                 info.m_language = data->getText();
1251                 }
1252         }
1253
1254         if (info.m_language.empty())
1255                 info.m_language = program.audioStreams[i].language_code;
1256         
1257         return 0;
1258 }
1259
1260 int eDVBServicePlay::selectAudioStream(int i)
1261 {
1262         eDVBServicePMTHandler::program program;
1263
1264         if (m_service_handler.getProgramInfo(program))
1265                 return -1;
1266         
1267         if ((unsigned int)i >= program.audioStreams.size())
1268                 return -2;
1269         
1270         if (!m_decoder)
1271                 return -3;
1272         
1273         if (m_decoder->setAudioPID(program.audioStreams[i].pid, program.audioStreams[i].type))
1274                 return -4;
1275
1276         if (m_dvb_service && !m_is_pvr)
1277         {
1278                 if (program.audioStreams[i].type == eDVBAudio::aMPEG)
1279                 {
1280                         m_dvb_service->setCacheEntry(eDVBService::cAPID, program.audioStreams[i].pid);
1281                         m_dvb_service->setCacheEntry(eDVBService::cAC3PID, -1);
1282                 }       else
1283                 {
1284                         m_dvb_service->setCacheEntry(eDVBService::cAPID, -1);
1285                         m_dvb_service->setCacheEntry(eDVBService::cAC3PID, program.audioStreams[i].pid);
1286                 }
1287         }
1288
1289         m_current_audio_stream = i;
1290
1291         return 0;
1292 }
1293
1294 int eDVBServicePlay::getCurrentChannel()
1295 {
1296         return m_decoder ? m_decoder->getAudioChannel() : STEREO;
1297 }
1298
1299 RESULT eDVBServicePlay::selectChannel(int i)
1300 {
1301         if (i < LEFT || i > RIGHT || i == STEREO)
1302                 i = -1;  // Stereo
1303         if (m_dvb_service)
1304                 m_dvb_service->setCacheEntry(eDVBService::cACHANNEL, i);
1305         if (m_decoder)
1306                 m_decoder->setAudioChannel(i);
1307         return 0;
1308 }
1309
1310 int eDVBServiceBase::getFrontendInfo(int w)
1311 {
1312         eUsePtr<iDVBChannel> channel;
1313         if(m_service_handler.getChannel(channel))
1314                 return 0;
1315         ePtr<iDVBFrontend> fe;
1316         if(channel->getFrontend(fe))
1317                 return 0;
1318         return fe->readFrontendData(w);
1319 }
1320
1321 PyObject *eDVBServiceBase::getFrontendData(bool original)
1322 {
1323         PyObject *ret=0;
1324
1325         eUsePtr<iDVBChannel> channel;
1326         if(!m_service_handler.getChannel(channel))
1327         {
1328                 ePtr<iDVBFrontend> fe;
1329                 if(!channel->getFrontend(fe))
1330                 {
1331                         ret = fe->readTransponderData(original);
1332                         if (ret)
1333                         {
1334                                 ePtr<iDVBFrontendParameters> feparm;
1335                                 channel->getCurrentFrontendParameters(feparm);
1336                                 if (feparm)
1337                                 {
1338                                         eDVBFrontendParametersSatellite osat;
1339                                         if (!feparm->getDVBS(osat))
1340                                         {
1341                                                 void PutToDict(PyObject *, const char*, long);
1342                                                 void PutToDict(PyObject *, const char*, const char*);
1343                                                 PutToDict(ret, "orbital_position", osat.orbital_position);
1344                                                 const char *tmp = "UNKNOWN";
1345                                                 switch(osat.polarisation)
1346                                                 {
1347                                                         case eDVBFrontendParametersSatellite::Polarisation::Horizontal: tmp="HORIZONTAL"; break;
1348                                                         case eDVBFrontendParametersSatellite::Polarisation::Vertical: tmp="VERTICAL"; break;
1349                                                         case eDVBFrontendParametersSatellite::Polarisation::CircularLeft: tmp="CIRCULAR_LEFT"; break;
1350                                                         case eDVBFrontendParametersSatellite::Polarisation::CircularRight: tmp="CIRCULAR_RIGHT"; break;
1351                                                         default:break;
1352                                                 }
1353                                                 PutToDict(ret, "polarization", tmp);
1354                                         }
1355                                 }
1356                         }
1357                 }
1358         }
1359         if (!ret)
1360         {
1361                 ret = Py_None;
1362                 Py_INCREF(ret);
1363         }
1364         return ret;
1365 }
1366
1367 int eDVBServicePlay::getNumberOfSubservices()
1368 {
1369         ePtr<eServiceEvent> evt;
1370         if (!m_event_handler.getEvent(evt, 0))
1371                 return evt->getNumOfLinkageServices();
1372         return 0;
1373 }
1374
1375 RESULT eDVBServicePlay::getSubservice(eServiceReference &sub, unsigned int n)
1376 {
1377         ePtr<eServiceEvent> evt;
1378         if (!m_event_handler.getEvent(evt, 0))
1379         {
1380                 if (!evt->getLinkageService(sub, m_reference, n))
1381                         return 0;
1382         }
1383         sub.type=eServiceReference::idInvalid;
1384         return -1;
1385 }
1386
1387 RESULT eDVBServicePlay::startTimeshift()
1388 {
1389         ePtr<iDVBDemux> demux;
1390         
1391         eDebug("Start timeshift!");
1392         
1393         if (m_timeshift_enabled)
1394                 return -1;
1395         
1396                 /* start recording with the data demux. */
1397         if (m_service_handler.getDataDemux(demux))
1398                 return -2;
1399
1400         demux->createTSRecorder(m_record);
1401         if (!m_record)
1402                 return -3;
1403
1404         char templ[]=TSPATH "/timeshift.XXXXXX";
1405         m_timeshift_fd = mkstemp(templ);
1406         m_timeshift_file = templ;
1407         
1408         eDebug("recording to %s", templ);
1409         
1410         if (m_timeshift_fd < 0)
1411         {
1412                 m_record = 0;
1413                 return -4;
1414         }
1415                 
1416         m_record->setTargetFD(m_timeshift_fd);
1417
1418         m_timeshift_enabled = 1;
1419         
1420         updateTimeshiftPids();
1421         m_record->start();
1422
1423         return 0;
1424 }
1425
1426 RESULT eDVBServicePlay::stopTimeshift()
1427 {
1428         if (!m_timeshift_enabled)
1429                 return -1;
1430         
1431         switchToLive();
1432         
1433         m_timeshift_enabled = 0;
1434         
1435         m_record->stop();
1436         m_record = 0;
1437         
1438         close(m_timeshift_fd);
1439         eDebug("remove timeshift file");
1440         remove(m_timeshift_file.c_str());
1441         
1442         return 0;
1443 }
1444
1445 int eDVBServicePlay::isTimeshiftActive()
1446 {
1447         return m_timeshift_enabled && m_timeshift_active;
1448 }
1449
1450 RESULT eDVBServicePlay::activateTimeshift()
1451 {
1452         if (!m_timeshift_enabled)
1453                 return -1;
1454         
1455         if (!m_timeshift_active)
1456         {
1457                 switchToTimeshift();
1458                 return 0;
1459         }
1460         
1461         return -2;
1462 }
1463
1464 PyObject *eDVBServicePlay::getCutList()
1465 {
1466         PyObject *list = PyList_New(0);
1467         
1468         for (std::multiset<struct cueEntry>::iterator i(m_cue_entries.begin()); i != m_cue_entries.end(); ++i)
1469         {
1470                 PyObject *tuple = PyTuple_New(2);
1471                 PyTuple_SetItem(tuple, 0, PyLong_FromLongLong(i->where));
1472                 PyTuple_SetItem(tuple, 1, PyInt_FromLong(i->what));
1473                 PyList_Append(list, tuple);
1474                 Py_DECREF(tuple);
1475         }
1476         
1477         return list;
1478 }
1479
1480 void eDVBServicePlay::setCutList(PyObject *list)
1481 {
1482         if (!PyList_Check(list))
1483                 return;
1484         int size = PyList_Size(list);
1485         int i;
1486         
1487         m_cue_entries.clear();
1488         
1489         for (i=0; i<size; ++i)
1490         {
1491                 PyObject *tuple = PyList_GetItem(list, i);
1492                 if (!PyTuple_Check(tuple))
1493                 {
1494                         eDebug("non-tuple in cutlist");
1495                         continue;
1496                 }
1497                 if (PyTuple_Size(tuple) != 2)
1498                 {
1499                         eDebug("cutlist entries need to be a 2-tuple");
1500                         continue;
1501                 }
1502                 PyObject *ppts = PyTuple_GetItem(tuple, 0), *ptype = PyTuple_GetItem(tuple, 1);
1503                 if (!(PyLong_Check(ppts) && PyInt_Check(ptype)))
1504                 {
1505                         eDebug("cutlist entries need to be (pts, type)-tuples (%d %d)", PyLong_Check(ppts), PyInt_Check(ptype));
1506                         continue;
1507                 }
1508                 pts_t pts = PyLong_AsLongLong(ppts);
1509                 int type = PyInt_AsLong(ptype);
1510                 m_cue_entries.insert(cueEntry(pts, type));
1511                 eDebug("adding %08llx, %d", pts, type);
1512         }
1513         m_cuesheet_changed = 1;
1514         
1515         cutlistToCuesheet();
1516         m_event((iPlayableService*)this, evCuesheetChanged);
1517 }
1518
1519 void eDVBServicePlay::setCutListEnable(int enable)
1520 {
1521         m_cutlist_enabled = enable;
1522         cutlistToCuesheet();
1523 }
1524
1525 void eDVBServicePlay::updateTimeshiftPids()
1526 {
1527         if (!m_record)
1528                 return;
1529         
1530         eDVBServicePMTHandler::program program;
1531         if (m_service_handler.getProgramInfo(program))
1532                 return;
1533         else
1534         {
1535                 std::set<int> pids_to_record;
1536                 pids_to_record.insert(0); // PAT
1537                 if (program.pmtPid != -1)
1538                         pids_to_record.insert(program.pmtPid); // PMT
1539
1540                 if (program.textPid != -1)
1541                         pids_to_record.insert(program.textPid); // Videotext
1542
1543                 for (std::vector<eDVBServicePMTHandler::videoStream>::const_iterator
1544                         i(program.videoStreams.begin()); 
1545                         i != program.videoStreams.end(); ++i)
1546                         pids_to_record.insert(i->pid);
1547
1548                 for (std::vector<eDVBServicePMTHandler::audioStream>::const_iterator
1549                         i(program.audioStreams.begin()); 
1550                         i != program.audioStreams.end(); ++i)
1551                                 pids_to_record.insert(i->pid);
1552
1553                 std::set<int> new_pids, obsolete_pids;
1554                 
1555                 std::set_difference(pids_to_record.begin(), pids_to_record.end(), 
1556                                 m_pids_active.begin(), m_pids_active.end(),
1557                                 std::inserter(new_pids, new_pids.begin()));
1558                 
1559                 std::set_difference(
1560                                 m_pids_active.begin(), m_pids_active.end(),
1561                                 pids_to_record.begin(), pids_to_record.end(), 
1562                                 std::inserter(new_pids, new_pids.begin())
1563                                 );
1564
1565                 for (std::set<int>::iterator i(new_pids.begin()); i != new_pids.end(); ++i)
1566                         m_record->addPID(*i);
1567
1568                 for (std::set<int>::iterator i(obsolete_pids.begin()); i != obsolete_pids.end(); ++i)
1569                         m_record->removePID(*i);
1570         }
1571 }
1572
1573 void eDVBServicePlay::switchToLive()
1574 {
1575         if (!m_timeshift_active)
1576                 return;
1577         
1578         m_cue = 0;
1579         m_decoder = 0;
1580         m_decode_demux = 0;
1581         m_teletext_parser = 0;
1582         m_new_subtitle_page_connection = 0;
1583         
1584                 /* free the timeshift service handler, we need the resources */
1585         m_service_handler_timeshift.free();
1586         m_timeshift_active = 0;
1587         
1588         m_event((iPlayableService*)this, evSeekableStatusChanged);
1589         
1590         updateDecoder();
1591 }
1592
1593 void eDVBServicePlay::switchToTimeshift()
1594 {
1595         if (m_timeshift_active)
1596                 return;
1597         
1598         m_decode_demux = 0;
1599         m_decoder = 0;
1600         m_teletext_parser = 0;
1601         m_new_subtitle_page_connection = 0;
1602         
1603         m_timeshift_active = 1;
1604
1605         m_event((iPlayableService*)this, evSeekableStatusChanged);
1606         
1607         eServiceReferenceDVB r = (eServiceReferenceDVB&)m_reference;
1608         r.path = m_timeshift_file;
1609         
1610         m_cue = new eCueSheet();
1611         m_service_handler_timeshift.tune(r, 1, m_cue); /* use the decoder demux for everything */
1612         updateDecoder(); /* mainly to switch off PCR */
1613 }
1614
1615 void eDVBServicePlay::updateDecoder()
1616 {
1617         int vpid = -1, vpidtype = -1, apid = -1, apidtype = -1, pcrpid = -1, tpid = -1, achannel = -1, ac3_delay=-1, pcm_delay=-1;
1618
1619         eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
1620
1621         bool defaultac3=false;
1622         std::string default_ac3;
1623
1624         if (!ePythonConfigQuery::getConfigValue("config.av.defaultac3", default_ac3))
1625                 defaultac3 = default_ac3 == "enable";
1626
1627         eDVBServicePMTHandler::program program;
1628         if (h.getProgramInfo(program))
1629                 eDebug("getting program info failed.");
1630         else
1631         {
1632                 eDebugNoNewLine("have %d video stream(s)", program.videoStreams.size());
1633                 if (!program.videoStreams.empty())
1634                 {
1635                         eDebugNoNewLine(" (");
1636                         for (std::vector<eDVBServicePMTHandler::videoStream>::const_iterator
1637                                 i(program.videoStreams.begin()); 
1638                                 i != program.videoStreams.end(); ++i)
1639                         {
1640                                 if (vpid == -1)
1641                                 {
1642                                         vpid = i->pid;
1643                                         vpidtype = i->type;
1644                                 }
1645                                 if (i != program.videoStreams.begin())
1646                                         eDebugNoNewLine(", ");
1647                                 eDebugNoNewLine("%04x", i->pid);
1648                         }
1649                         eDebugNoNewLine(")");
1650                 }
1651                 eDebugNoNewLine(", and %d audio stream(s)", program.audioStreams.size());
1652                 if (!program.audioStreams.empty())
1653                 {
1654                         eDebugNoNewLine(" (");
1655                         for (std::vector<eDVBServicePMTHandler::audioStream>::const_iterator
1656                                 i(program.audioStreams.begin()); 
1657                                 i != program.audioStreams.end(); ++i)
1658                         {
1659                                 if (apid == -1 || (apidtype == eDVBAudio::aMPEG && defaultac3))
1660                                 {
1661                                         if ( apid == -1 || (i->type != eDVBAudio::aMPEG) )
1662                                         {
1663                                                 apid = i->pid;
1664                                                 apidtype = i->type;
1665                                         }
1666                                 }
1667                                 if (i != program.audioStreams.begin())
1668                                         eDebugNoNewLine(", ");
1669                                 eDebugNoNewLine("%04x", i->pid);
1670                         }
1671                         eDebugNoNewLine(")");
1672                 }
1673                 eDebugNoNewLine(", and the pcr pid is %04x", program.pcrPid);
1674                 pcrpid = program.pcrPid;
1675                 eDebug(", and the text pid is %04x", program.textPid);
1676                 tpid = program.textPid;
1677         }
1678
1679         if (!m_decoder)
1680         {
1681                 h.getDecodeDemux(m_decode_demux);
1682                 if (m_decode_demux)
1683                         m_decode_demux->getMPEGDecoder(m_decoder, m_is_primary);
1684                 if (m_cue)
1685                         m_cue->setDecodingDemux(m_decode_demux, m_decoder);
1686 #ifdef INTERNAL_TELETEXT
1687                 m_teletext_parser = new eDVBTeletextParser(m_decode_demux);
1688                 m_teletext_parser->connectNewPage(slot(*this, &eDVBServicePlay::newSubtitlePage), m_new_subtitle_page_connection);
1689 #endif
1690         }
1691
1692         if (m_decoder)
1693         {
1694                 if (m_dvb_service)
1695                 {
1696                         achannel = m_dvb_service->getCacheEntry(eDVBService::cACHANNEL);
1697                         ac3_delay = m_dvb_service->getCacheEntry(eDVBService::cAC3DELAY);
1698                         pcm_delay = m_dvb_service->getCacheEntry(eDVBService::cPCMDELAY);
1699                 }
1700                 else // subservice or recording
1701                 {
1702                         eServiceReferenceDVB ref;
1703                         m_service_handler.getServiceReference(ref);
1704                         eServiceReferenceDVB parent = ref.getParentServiceReference();
1705                         if (!parent)
1706                                 parent = ref;
1707                         if (parent)
1708                         {
1709                                 ePtr<eDVBResourceManager> res_mgr;
1710                                 if (!eDVBResourceManager::getInstance(res_mgr))
1711                                 {
1712                                         ePtr<iDVBChannelList> db;
1713                                         if (!res_mgr->getChannelList(db))
1714                                         {
1715                                                 ePtr<eDVBService> origService;
1716                                                 if (!db->getService(parent, origService))
1717                                                 {
1718                                                         ac3_delay = origService->getCacheEntry(eDVBService::cAC3DELAY);
1719                                                         pcm_delay = origService->getCacheEntry(eDVBService::cPCMDELAY);
1720                                                 }
1721                                         }
1722                                 }
1723                         }
1724                 }
1725                 m_decoder->setAC3Delay(ac3_delay == -1 ? 0 : ac3_delay);
1726                 m_decoder->setPCMDelay(pcm_delay == -1 ? 0 : pcm_delay);
1727
1728                 m_decoder->setVideoPID(vpid, vpidtype);
1729                 m_current_audio_stream = 0;
1730                 m_decoder->setAudioPID(apid, apidtype);
1731                 if (!(m_is_pvr || m_timeshift_active || !m_is_primary))
1732                         m_decoder->setSyncPCR(pcrpid);
1733                 else
1734                         m_decoder->setSyncPCR(-1);
1735
1736                 m_decoder->setTextPID(tpid);
1737
1738                 if (m_teletext_parser)
1739                         m_teletext_parser->start(tpid);
1740
1741                 if (!m_is_primary)
1742                         m_decoder->setTrickmode(1);
1743
1744                 m_decoder->start();
1745
1746                 if (vpid > 0 && vpid < 0x2000)
1747                         ;
1748                 else
1749                 {
1750                         std::string radio_pic;
1751                         if (!ePythonConfigQuery::getConfigValue("config.misc.radiopic", radio_pic))
1752                                 m_decoder->setRadioPic(radio_pic);
1753                 }
1754
1755                 m_decoder->setAudioChannel(achannel);
1756
1757 // how we can do this better?
1758 // update cache pid when the user changed the audio track or video track
1759 // TODO handling of difference audio types.. default audio types..
1760                                 
1761                 /* don't worry about non-existing services, nor pvr services */
1762                 if (m_dvb_service && !m_is_pvr)
1763                 {
1764                         if (apidtype == eDVBAudio::aMPEG)
1765                         {
1766                                 m_dvb_service->setCacheEntry(eDVBService::cAPID, apid);
1767                                 m_dvb_service->setCacheEntry(eDVBService::cAC3PID, -1);
1768                         }
1769                         else
1770                         {
1771                                 m_dvb_service->setCacheEntry(eDVBService::cAPID, -1);
1772                                 m_dvb_service->setCacheEntry(eDVBService::cAC3PID, apid);
1773                         }
1774                         m_dvb_service->setCacheEntry(eDVBService::cVPID, vpid);
1775                         m_dvb_service->setCacheEntry(eDVBService::cVTYPE, vpidtype == eDVBVideo::MPEG2 ? -1 : vpidtype);
1776                         m_dvb_service->setCacheEntry(eDVBService::cPCRPID, pcrpid);
1777                         m_dvb_service->setCacheEntry(eDVBService::cTPID, tpid);
1778                 }
1779         }
1780         m_have_video_pid = (vpid > 0 && vpid < 0x2000);
1781 }
1782
1783 void eDVBServicePlay::loadCuesheet()
1784 {
1785         std::string filename = m_reference.path + ".cuts";
1786         
1787         m_cue_entries.clear();
1788
1789         FILE *f = fopen(filename.c_str(), "rb");
1790
1791         if (f)
1792         {
1793                 eDebug("loading cuts..");
1794                 while (1)
1795                 {
1796                         unsigned long long where;
1797                         unsigned int what;
1798                         
1799                         if (!fread(&where, sizeof(where), 1, f))
1800                                 break;
1801                         if (!fread(&what, sizeof(what), 1, f))
1802                                 break;
1803                         
1804 #if BYTE_ORDER == LITTLE_ENDIAN
1805                         where = bswap_64(where);
1806 #endif
1807                         what = ntohl(what);
1808                         
1809                         if (what > 2)
1810                                 break;
1811                         
1812                         m_cue_entries.insert(cueEntry(where, what));
1813                 }
1814                 fclose(f);
1815                 eDebug("%d entries", m_cue_entries.size());
1816         } else
1817                 eDebug("cutfile not found!");
1818         
1819         m_cuesheet_changed = 0;
1820         cutlistToCuesheet();
1821         m_event((iPlayableService*)this, evCuesheetChanged);
1822 }
1823
1824 void eDVBServicePlay::saveCuesheet()
1825 {
1826         std::string filename = m_reference.path + ".cuts";
1827         
1828         FILE *f = fopen(filename.c_str(), "wb");
1829
1830         if (f)
1831         {
1832                 unsigned long long where;
1833                 int what;
1834
1835                 for (std::multiset<cueEntry>::iterator i(m_cue_entries.begin()); i != m_cue_entries.end(); ++i)
1836                 {
1837 #if BYTE_ORDER == BIG_ENDIAN
1838                         where = i->where;
1839 #else
1840                         where = bswap_64(i->where);
1841 #endif
1842                         what = htonl(i->what);
1843                         fwrite(&where, sizeof(where), 1, f);
1844                         fwrite(&what, sizeof(what), 1, f);
1845                         
1846                 }
1847                 fclose(f);
1848         }
1849         
1850         m_cuesheet_changed = 0;
1851 }
1852
1853 void eDVBServicePlay::cutlistToCuesheet()
1854 {
1855         if (!m_cue)
1856         {
1857                 eDebug("no cue sheet");
1858                 return;
1859         }       
1860         m_cue->clear();
1861         
1862         if (!m_cutlist_enabled)
1863         {
1864                 m_cue->commitSpans();
1865                 eDebug("cutlists where disabled");
1866                 return;
1867         }
1868
1869         pts_t in = 0, out = 0, length = 0;
1870         
1871         getLength(length);
1872                 
1873         std::multiset<cueEntry>::iterator i(m_cue_entries.begin());
1874         
1875         while (1)
1876         {
1877                 if (i == m_cue_entries.end())
1878                         out = length;
1879                 else {
1880                         if (i->what == 0) /* in */
1881                         {
1882                                 in = i++->where;
1883                                 continue;
1884                         } else if (i->what == 1) /* out */
1885                                 out = i++->where;
1886                         else /* mark */
1887                         {
1888                                 i++;
1889                                 continue;
1890                         }
1891                 }
1892                 
1893                 if (in != out)
1894                         m_cue->addSourceSpan(in, out);
1895                 
1896                 in = length;
1897                 
1898                 if (i == m_cue_entries.end())
1899                         break;
1900         }
1901         m_cue->commitSpans();
1902 }
1903
1904 RESULT eDVBServicePlay::enableSubtitles(eWidget *parent, PyObject *entry)
1905 {
1906         if (m_subtitle_widget)
1907                 disableSubtitles(parent);
1908         
1909         if (!m_teletext_parser)
1910                 return -1;
1911         
1912         if (!PyInt_Check(entry))
1913                 return -1;
1914         
1915         m_subtitle_widget = new eSubtitleWidget(parent);
1916         m_subtitle_widget->resize(parent->size()); /* full size */
1917         
1918         int page = PyInt_AsLong(entry);
1919         
1920         m_teletext_parser->setPage(page);
1921
1922         return 0;
1923 }
1924
1925 RESULT eDVBServicePlay::disableSubtitles(eWidget *parent)
1926 {
1927         delete m_subtitle_widget;
1928         m_subtitle_widget = 0;
1929         return 0;
1930 }
1931
1932 PyObject *eDVBServicePlay::getSubtitleList()
1933 {
1934         if (!m_teletext_parser)
1935         {
1936                 Py_INCREF(Py_None);
1937                 return Py_None;
1938         }
1939         
1940         PyObject *l = PyList_New(0);
1941         
1942         for (std::set<int>::iterator i(m_teletext_parser->m_found_subtitle_pages.begin()); i != m_teletext_parser->m_found_subtitle_pages.end(); ++i)
1943         {
1944                 PyObject *tuple = PyTuple_New(2);
1945                 char desc[20];
1946                 sprintf(desc, "Page %x", *i);
1947                 PyTuple_SetItem(tuple, 0, PyString_FromString(desc));
1948                 PyTuple_SetItem(tuple, 1, PyInt_FromLong(*i));
1949                 PyList_Append(l, tuple);
1950         }
1951         
1952         return l;
1953 }
1954
1955 void eDVBServicePlay::newSubtitlePage(const eDVBTeletextSubtitlePage &page)
1956 {
1957         if (m_subtitle_widget)
1958         {
1959                 m_subtitle_pages.push_back(page);
1960                 
1961                 checkSubtitleTiming();
1962         }
1963 }
1964
1965 void eDVBServicePlay::checkSubtitleTiming()
1966 {
1967         while (1)
1968         {
1969                 if (m_subtitle_pages.empty())
1970                         return;
1971         
1972                 eDVBTeletextSubtitlePage p = m_subtitle_pages.front();
1973         
1974                 pts_t pos = 0;
1975         
1976                 if (m_decoder)
1977                         m_decoder->getPTS(0, pos);
1978         
1979                 int diff = p.m_pts - pos;
1980                 if (diff < 0)
1981                 {
1982                         eDebug("[late (%d ms)]", -diff / 90);
1983                         diff = 0;
1984                 }
1985                 if (diff > 900000)
1986                 {
1987                         eDebug("[invalid]");
1988                         diff = 0;
1989                 }
1990         
1991                 if (!diff)
1992                 {
1993                         m_subtitle_widget->setPage(p);
1994                         m_subtitle_pages.pop_front();
1995                 } else
1996                 {
1997                         m_subtitle_sync_timer.start(diff / 90, 1);
1998                         break;
1999                 }
2000         }
2001 }
2002
2003 int eDVBServicePlay::getAC3Delay()
2004 {
2005         if (m_dvb_service)
2006                 return m_dvb_service->getCacheEntry(eDVBService::cAC3DELAY);
2007         else if (m_decoder)
2008                 return m_decoder->getAC3Delay();
2009         else
2010                 return 0;
2011 }
2012
2013 int eDVBServicePlay::getPCMDelay()
2014 {
2015         if (m_dvb_service)
2016                 return m_dvb_service->getCacheEntry(eDVBService::cPCMDELAY);
2017         else if (m_decoder)
2018                 return m_decoder->getPCMDelay();
2019         else
2020                 return 0;
2021 }
2022
2023 void eDVBServicePlay::setAC3Delay(int delay)
2024 {
2025         if (m_dvb_service)
2026                 m_dvb_service->setCacheEntry(eDVBService::cAC3DELAY, delay ? delay : -1);
2027         if (m_decoder)
2028                 m_decoder->setAC3Delay(delay);
2029 }
2030
2031 void eDVBServicePlay::setPCMDelay(int delay)
2032 {
2033         if (m_dvb_service)
2034                 m_dvb_service->setCacheEntry(eDVBService::cPCMDELAY, delay ? delay : -1);
2035         if (m_decoder)
2036                 m_decoder->setPCMDelay(delay);
2037 }
2038
2039 DEFINE_REF(eDVBServicePlay)
2040
2041 eAutoInitPtr<eServiceFactoryDVB> init_eServiceFactoryDVB(eAutoInitNumbers::service+1, "eServiceFactoryDVB");