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