- While recording, collect startcodes and save them into ".sc"-files
[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/estring.h>
7 #include <lib/base/init_num.h>
8 #include <lib/base/init.h>
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 #include <lib/base/nconfig.h> // access to python config
20
21                 /* for subtitles */
22 #include <lib/gui/esubtitle.h>
23
24 #include <sys/vfs.h>
25 #include <sys/stat.h>
26
27 #include <byteswap.h>
28 #include <netinet/in.h>
29
30 #ifndef BYTE_ORDER
31 #error no byte order defined!
32 #endif
33
34 class eStaticServiceDVBInformation: public iStaticServiceInformation
35 {
36         DECLARE_REF(eStaticServiceDVBInformation);
37 public:
38         RESULT getName(const eServiceReference &ref, std::string &name);
39         int getLength(const eServiceReference &ref);
40         int isPlayable(const eServiceReference &ref, const eServiceReference &ignore);
41         PyObject *getInfoObject(const eServiceReference &ref, int);
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                                                 name=buildShortName(name) + " - ";
67                                 }
68                         }
69                 }
70                 else
71                         name="";
72                 name += ref.name;
73                 return 0;
74         }
75         else
76                 return -1;
77 }
78
79 int eStaticServiceDVBInformation::getLength(const eServiceReference &ref)
80 {
81         return -1;
82 }
83
84 int eStaticServiceDVBInformation::isPlayable(const eServiceReference &ref, const eServiceReference &ignore)
85 {
86         ePtr<eDVBResourceManager> res_mgr;
87         if ( eDVBResourceManager::getInstance( res_mgr ) )
88                 eDebug("isPlayable... no res manager!!");
89         else
90         {
91                 eDVBChannelID chid, chid_ignore;
92                 ((const eServiceReferenceDVB&)ref).getChannelID(chid);
93                 ((const eServiceReferenceDVB&)ignore).getChannelID(chid_ignore);
94                 return res_mgr->canAllocateChannel(chid, chid_ignore);
95         }
96         return false;
97 }
98
99 extern void PutToDict(ePyObject &dict, const char*key, long value);  // defined in dvb/frontend.cpp
100 extern void PutToDict(ePyObject &dict, const char*key, ePyObject item); // defined in dvb/frontend.cpp
101 extern void PutToDict(ePyObject &dict, const char*key, const char *value); // defined in dvb/frontend.cpp
102
103 void PutSatelliteDataToDict(ePyObject &dict, eDVBFrontendParametersSatellite &feparm)
104 {
105         PutToDict(dict, "tuner_type", "DVB-S");
106         PutToDict(dict, "frequency", feparm.frequency);
107         PutToDict(dict, "symbol_rate", feparm.symbol_rate);
108         PutToDict(dict, "orbital_position", feparm.orbital_position);
109         PutToDict(dict, "inversion", feparm.inversion);
110         PutToDict(dict, "fec_inner", feparm.fec);
111         PutToDict(dict, "modulation", feparm.modulation);
112         PutToDict(dict, "polarization", feparm.polarisation);
113         if (feparm.system == eDVBFrontendParametersSatellite::System_DVB_S2)
114         {
115                 PutToDict(dict, "rolloff", feparm.rolloff);
116                 PutToDict(dict, "pilot", feparm.pilot);
117         }
118         PutToDict(dict, "system", feparm.system);
119 }
120
121 void PutTerrestrialDataToDict(ePyObject &dict, eDVBFrontendParametersTerrestrial &feparm)
122 {
123         PutToDict(dict, "tuner_type", "DVB-T");
124         PutToDict(dict, "frequency", feparm.frequency);
125         PutToDict(dict, "bandwidth", feparm.bandwidth);
126         PutToDict(dict, "code_rate_lp", feparm.code_rate_LP);
127         PutToDict(dict, "code_rate_hp", feparm.code_rate_HP);
128         PutToDict(dict, "constellation", feparm.modulation);
129         PutToDict(dict, "transmission_mode", feparm.transmission_mode);
130         PutToDict(dict, "guard_interval", feparm.guard_interval);
131         PutToDict(dict, "hierarchy_information", feparm.hierarchy);
132         PutToDict(dict, "inversion", feparm.inversion);
133 }
134
135 void PutCableDataToDict(ePyObject &dict, eDVBFrontendParametersCable &feparm)
136 {
137         PutToDict(dict, "tuner_type", "DVB-C");
138         PutToDict(dict, "frequency", feparm.frequency);
139         PutToDict(dict, "symbol_rate", feparm.symbol_rate);
140         PutToDict(dict, "modulation", feparm.modulation);
141         PutToDict(dict, "inversion", feparm.inversion);
142         PutToDict(dict, "fec_inner", feparm.fec_inner);
143 }
144
145 PyObject *eStaticServiceDVBInformation::getInfoObject(const eServiceReference &r, int what)
146 {
147         if (r.type == eServiceReference::idDVB)
148         {
149                 const eServiceReferenceDVB &ref = (const eServiceReferenceDVB&)r;
150                 switch(what)
151                 {
152                         case iServiceInformation::sTransponderData:
153                         {
154                                 ePtr<eDVBResourceManager> res;
155                                 if (!eDVBResourceManager::getInstance(res))
156                                 {
157                                         ePtr<iDVBChannelList> db;
158                                         if (!res->getChannelList(db))
159                                         {
160                                                 eDVBChannelID chid;
161                                                 ref.getChannelID(chid);
162                                                 ePtr<iDVBFrontendParameters> feparm;
163                                                 if (!db->getChannelFrontendData(chid, feparm))
164                                                 {
165                                                         int system;
166                                                         if (!feparm->getSystem(system))
167                                                         {
168                                                                 ePyObject dict = PyDict_New();
169                                                                 switch(system)
170                                                                 {
171                                                                         case iDVBFrontend::feSatellite:
172                                                                         {
173                                                                                 eDVBFrontendParametersSatellite s;
174                                                                                 feparm->getDVBS(s);
175                                                                                 PutSatelliteDataToDict(dict, s);
176                                                                                 break;
177                                                                         }
178                                                                         case iDVBFrontend::feTerrestrial:
179                                                                         {
180                                                                                 eDVBFrontendParametersTerrestrial t;
181                                                                                 feparm->getDVBT(t);
182                                                                                 PutTerrestrialDataToDict(dict, t);
183                                                                                 break;
184                                                                         }
185                                                                         case iDVBFrontend::feCable:
186                                                                         {
187                                                                                 eDVBFrontendParametersCable c;
188                                                                                 feparm->getDVBC(c);
189                                                                                 PutCableDataToDict(dict, c);
190                                                                                 break;
191                                                                         }
192                                                                         default:
193                                                                                 eDebug("unknown frontend type %d", system);
194                                                                                 Py_DECREF(dict);
195                                                                                 break;
196                                                                 }
197                                                                 return dict;
198                                                         }
199                                                 }
200                                         }
201                                 }
202                         }
203                 }
204         }
205         Py_RETURN_NONE;
206 }
207
208 DEFINE_REF(eStaticServiceDVBBouquetInformation);
209
210 RESULT eStaticServiceDVBBouquetInformation::getName(const eServiceReference &ref, std::string &name)
211 {
212         ePtr<iDVBChannelList> db;
213         ePtr<eDVBResourceManager> res;
214
215         int err;
216         if ((err = eDVBResourceManager::getInstance(res)) != 0)
217         {
218                 eDebug("eStaticServiceDVBBouquetInformation::getName failed.. no resource manager!");
219                 return err;
220         }
221         if ((err = res->getChannelList(db)) != 0)
222         {
223                 eDebug("eStaticServiceDVBBouquetInformation::getName failed.. no channel list!");
224                 return err;
225         }
226
227         eBouquet *bouquet=0;
228         if ((err = db->getBouquet(ref, bouquet)) != 0)
229         {
230                 eDebug("eStaticServiceDVBBouquetInformation::getName failed.. getBouquet failed!");
231                 return -1;
232         }
233
234         if ( bouquet && bouquet->m_bouquet_name.length() )
235         {
236                 name = bouquet->m_bouquet_name;
237                 return 0;
238         }
239         else
240                 return -1;
241 }
242
243 int eStaticServiceDVBBouquetInformation::isPlayable(const eServiceReference &ref, const eServiceReference &ignore, bool simulate)
244 {
245         if (ref.flags & eServiceReference::isGroup)
246         {
247                 ePtr<iDVBChannelList> db;
248                 ePtr<eDVBResourceManager> res;
249
250                 if (eDVBResourceManager::getInstance(res))
251                 {
252                         eDebug("eStaticServiceDVBBouquetInformation::isPlayable failed.. no resource manager!");
253                         return 0;
254                 }
255
256                 if (res->getChannelList(db))
257                 {
258                         eDebug("eStaticServiceDVBBouquetInformation::isPlayable failed.. no channel list!");
259                         return 0;
260                 }
261
262                 eBouquet *bouquet=0;
263                 if (db->getBouquet(ref, bouquet))
264                 {
265                         eDebug("eStaticServiceDVBBouquetInformation::isPlayable failed.. getBouquet failed!");
266                         return 0;
267                 }
268
269                 int prio_order = eDVBFrontend::getTypePriorityOrder();
270                 int cur=0;
271                 eDVBChannelID chid, chid_ignore;
272                 ((const eServiceReferenceDVB&)ignore).getChannelID(chid_ignore);
273                 for (std::list<eServiceReference>::iterator it(bouquet->m_services.begin()); it != bouquet->m_services.end(); ++it)
274                 {
275                         static unsigned char prio_map[6][3] = {
276                                 { 3, 2, 1 }, // -S -C -T
277                                 { 3, 1, 2 }, // -S -T -C
278                                 { 2, 3, 1 }, // -C -S -T
279                                 { 1, 3, 2 }, // -C -T -S
280                                 { 1, 2, 3 }, // -T -C -S
281                                 { 2, 1, 3 }  // -T -S -C
282                         };
283                         ((const eServiceReferenceDVB&)*it).getChannelID(chid);
284                         int tmp=res->canAllocateChannel(chid, chid_ignore, simulate);
285                         switch(tmp)
286                         {
287                                 case 0:
288                                         break;
289                                 case 30000: // cached DVB-T channel
290                                 case 1: // DVB-T frontend
291                                         tmp = prio_map[prio_order][2];
292                                         break;
293                                 case 40000: // cached DVB-C channel
294                                 case 2:
295                                         tmp = prio_map[prio_order][1];
296                                         break;
297                                 default: // DVB-S
298                                         tmp = prio_map[prio_order][0];
299                                         break;
300                         }
301                         if (tmp > cur)
302                         {
303                                 m_playable_service = *it;
304                                 cur = tmp;
305                         }
306                 }
307                 if (cur)
308                         return cur;
309         }
310         m_playable_service = eServiceReference();
311         return 0;
312 }
313
314 int eStaticServiceDVBBouquetInformation::getLength(const eServiceReference &ref)
315 {
316         return -1;
317 }
318
319 #include <lib/dvb/epgcache.h>
320
321 RESULT eStaticServiceDVBBouquetInformation::getEvent(const eServiceReference &ref, ePtr<eServiceEvent> &ptr, time_t start_time)
322 {
323         return eEPGCache::getInstance()->lookupEventTime(ref, start_time, ptr);
324 }
325
326 class eStaticServiceDVBPVRInformation: public iStaticServiceInformation
327 {
328         DECLARE_REF(eStaticServiceDVBPVRInformation);
329         eServiceReference m_ref;
330         eDVBMetaParser m_parser;
331 public:
332         eStaticServiceDVBPVRInformation(const eServiceReference &ref);
333         RESULT getName(const eServiceReference &ref, std::string &name);
334         int getLength(const eServiceReference &ref);
335         RESULT getEvent(const eServiceReference &ref, ePtr<eServiceEvent> &SWIG_OUTPUT, time_t start_time);
336         int isPlayable(const eServiceReference &ref, const eServiceReference &ignore) { return 1; }
337         int getInfo(const eServiceReference &ref, int w);
338         std::string getInfoString(const eServiceReference &ref,int w);
339 };
340
341 DEFINE_REF(eStaticServiceDVBPVRInformation);
342
343 eStaticServiceDVBPVRInformation::eStaticServiceDVBPVRInformation(const eServiceReference &ref)
344 {
345         m_ref = ref;
346         m_parser.parseFile(ref.path);
347 }
348
349 RESULT eStaticServiceDVBPVRInformation::getName(const eServiceReference &ref, std::string &name)
350 {
351         ASSERT(ref == m_ref);
352         if (m_parser.m_name.size())
353                 name = m_parser.m_name;
354         else
355         {
356                 name = ref.path;
357                 size_t n = name.rfind('/');
358                 if (n != std::string::npos)
359                         name = name.substr(n + 1);
360         }
361         return 0;
362 }
363
364 int eStaticServiceDVBPVRInformation::getLength(const eServiceReference &ref)
365 {
366         ASSERT(ref == m_ref);
367         
368         eDVBTSTools tstools;
369         
370         struct stat s;
371         stat(ref.path.c_str(), &s);
372
373         if (tstools.openFile(ref.path.c_str(), 1))
374                 return 0;
375
376                         /* check if cached data is still valid */
377         if (m_parser.m_data_ok && (s.st_size == m_parser.m_filesize) && (m_parser.m_length))
378                 return m_parser.m_length / 90000;
379
380                         /* open again, this time with stream info */
381         if (tstools.openFile(ref.path.c_str()))
382                 return 0;
383
384                         /* otherwise, re-calc length and update meta file */
385         pts_t len;
386         if (tstools.calcLen(len))
387                 return 0;
388
389         m_parser.m_length = len;
390         m_parser.m_filesize = s.st_size;
391         m_parser.updateMeta(ref.path);
392         return m_parser.m_length / 90000;
393 }
394
395 int eStaticServiceDVBPVRInformation::getInfo(const eServiceReference &ref, int w)
396 {
397         switch (w)
398         {
399         case iServiceInformation::sDescription:
400                 return iServiceInformation::resIsString;
401         case iServiceInformation::sServiceref:
402                 return iServiceInformation::resIsString;
403         case iServiceInformation::sTimeCreate:
404                 if (m_parser.m_time_create)
405                         return m_parser.m_time_create;
406                 else
407                         return iServiceInformation::resNA;
408         default:
409                 return iServiceInformation::resNA;
410         }
411 }
412
413 std::string eStaticServiceDVBPVRInformation::getInfoString(const eServiceReference &ref,int w)
414 {
415         switch (w)
416         {
417         case iServiceInformation::sDescription:
418                 return m_parser.m_description;
419         case iServiceInformation::sServiceref:
420                 return m_parser.m_ref.toString();
421         case iServiceInformation::sTags:
422                 return m_parser.m_tags;
423         default:
424                 return "";
425         }
426 }
427
428 RESULT eStaticServiceDVBPVRInformation::getEvent(const eServiceReference &ref, ePtr<eServiceEvent> &evt, time_t start_time)
429 {
430         if (!ref.path.empty())
431         {
432                 ePtr<eServiceEvent> event = new eServiceEvent;
433                 std::string filename = ref.path;
434                 filename.erase(filename.length()-2, 2);
435                 filename+="eit";
436                 if (!event->parseFrom(filename, (m_parser.m_ref.getTransportStreamID().get()<<16)|m_parser.m_ref.getOriginalNetworkID().get()))
437                 {
438                         evt = event;
439                         return 0;
440                 }
441         }
442         evt = 0;
443         return -1;
444 }
445
446 class eDVBPVRServiceOfflineOperations: public iServiceOfflineOperations
447 {
448         DECLARE_REF(eDVBPVRServiceOfflineOperations);
449         eServiceReferenceDVB m_ref;
450 public:
451         eDVBPVRServiceOfflineOperations(const eServiceReference &ref);
452         
453         RESULT deleteFromDisk(int simulate);
454         RESULT getListOfFilenames(std::list<std::string> &);
455 };
456
457 DEFINE_REF(eDVBPVRServiceOfflineOperations);
458
459 eDVBPVRServiceOfflineOperations::eDVBPVRServiceOfflineOperations(const eServiceReference &ref): m_ref((const eServiceReferenceDVB&)ref)
460 {
461 }
462
463 RESULT eDVBPVRServiceOfflineOperations::deleteFromDisk(int simulate)
464 {
465         if (simulate)
466                 return 0;
467         else
468         {
469                 std::list<std::string> res;
470                 if (getListOfFilenames(res))
471                         return -1;
472                 
473                 eBackgroundFileEraser *eraser = eBackgroundFileEraser::getInstance();
474                 if (!eraser)
475                         eDebug("FATAL !! can't get background file eraser");
476                 
477                 for (std::list<std::string>::iterator i(res.begin()); i != res.end(); ++i)
478                 {
479                         eDebug("Removing %s...", i->c_str());
480                         if (eraser)
481                                 eraser->erase(i->c_str());
482                         else
483                                 ::unlink(i->c_str());
484                 }
485                 
486                 return 0;
487         }
488 }
489
490 RESULT eDVBPVRServiceOfflineOperations::getListOfFilenames(std::list<std::string> &res)
491 {
492         res.clear();
493         res.push_back(m_ref.path);
494
495 // handling for old splitted recordings (enigma 1)
496         char buf[255];
497         int slice=1;
498         while(true)
499         {
500                 snprintf(buf, 255, "%s.%03d", m_ref.path.c_str(), slice++);
501                 struct stat s;
502                 if (stat(buf, &s) < 0)
503                         break;
504                 res.push_back(buf);
505         }       
506
507         res.push_back(m_ref.path + ".meta");
508         res.push_back(m_ref.path + ".ap");
509         res.push_back(m_ref.path + ".sc");
510         res.push_back(m_ref.path + ".cuts");
511         std::string tmp = m_ref.path;
512         tmp.erase(m_ref.path.length()-3);
513         res.push_back(tmp + ".eit");
514         return 0;
515 }
516
517 DEFINE_REF(eServiceFactoryDVB)
518
519 eServiceFactoryDVB::eServiceFactoryDVB()
520 {
521         ePtr<eServiceCenter> sc;
522         
523         eServiceCenter::getPrivInstance(sc);
524         if (sc)
525         {
526                 std::list<std::string> extensions;
527                 extensions.push_back("ts");
528                 sc->addServiceFactory(eServiceFactoryDVB::id, this, extensions);
529         }
530
531         m_StaticServiceDVBInfo = new eStaticServiceDVBInformation;
532         m_StaticServiceDVBBouquetInfo = new eStaticServiceDVBBouquetInformation;
533 }
534
535 eServiceFactoryDVB::~eServiceFactoryDVB()
536 {
537         ePtr<eServiceCenter> sc;
538         
539         eServiceCenter::getPrivInstance(sc);
540         if (sc)
541                 sc->removeServiceFactory(eServiceFactoryDVB::id);
542 }
543
544 DEFINE_REF(eDVBServiceList);
545
546 eDVBServiceList::eDVBServiceList(const eServiceReference &parent): m_parent(parent)
547 {
548 }
549
550 eDVBServiceList::~eDVBServiceList()
551 {
552 }
553
554 RESULT eDVBServiceList::startQuery()
555 {
556         ePtr<iDVBChannelList> db;
557         ePtr<eDVBResourceManager> res;
558         
559         int err;
560         if ((err = eDVBResourceManager::getInstance(res)) != 0)
561         {
562                 eDebug("no resource manager");
563                 return err;
564         }
565         if ((err = res->getChannelList(db)) != 0)
566         {
567                 eDebug("no channel list");
568                 return err;
569         }
570         
571         ePtr<eDVBChannelQuery> q;
572         
573         if (!m_parent.path.empty())
574         {
575                 eDVBChannelQuery::compile(q, m_parent.path);
576                 if (!q)
577                 {
578                         eDebug("compile query failed");
579                         return err;
580                 }
581         }
582         
583         if ((err = db->startQuery(m_query, q, m_parent)) != 0)
584         {
585                 eDebug("startQuery failed");
586                 return err;
587         }
588
589         return 0;
590 }
591
592 RESULT eDVBServiceList::getContent(std::list<eServiceReference> &list, bool sorted)
593 {
594         eServiceReferenceDVB ref;
595         
596         if (!m_query)
597                 return -1;
598
599         while (!m_query->getNextResult(ref))
600                 list.push_back(ref);
601
602         if (sorted)
603                 list.sort(iListableServiceCompare(this));
604
605         return 0;
606 }
607
608 //   The first argument of this function is a format string to specify the order and
609 //   the content of the returned list
610 //   useable format options are
611 //   R = Service Reference (as swig object .. this is very slow)
612 //   S = Service Reference (as python string object .. same as ref.toString())
613 //   C = Service Reference (as python string object .. same as ref.toCompareString())
614 //   N = Service Name (as python string object)
615 //   n = Short Service Name (short name brakets used) (as python string object)
616 //   when exactly one return value per service is selected in the format string,
617 //   then each value is directly a list entry
618 //   when more than one value is returned per service, then the list is a list of
619 //   python tuples
620 //   unknown format string chars are returned as python None values !
621 PyObject *eDVBServiceList::getContent(const char* format, bool sorted)
622 {
623         ePyObject ret;
624         std::list<eServiceReference> tmplist;
625         int retcount=1;
626
627         if (!format || !(retcount=strlen(format)))
628                 format = "R"; // just return service reference swig object ...
629
630         if (!getContent(tmplist, sorted))
631         {
632                 int services=tmplist.size();
633                 ePtr<iStaticServiceInformation> sptr;
634                 eServiceCenterPtr service_center;
635
636                 if (strchr(format, 'N') || strchr(format, 'n'))
637                         eServiceCenter::getPrivInstance(service_center);
638
639                 ret = PyList_New(services);
640                 std::list<eServiceReference>::iterator it(tmplist.begin());
641
642                 for (int cnt=0; cnt < services; ++cnt)
643                 {
644                         eServiceReference &ref=*it++;
645                         ePyObject tuple = retcount > 1 ? PyTuple_New(retcount) : ePyObject();
646                         for (int i=0; i < retcount; ++i)
647                         {
648                                 ePyObject tmp;
649                                 switch(format[i])
650                                 {
651                                 case 'R':  // service reference (swig)object
652                                         tmp = NEW_eServiceReference(ref);
653                                         break;
654                                 case 'C':  // service reference compare string
655                                         tmp = PyString_FromString(ref.toCompareString().c_str());
656                                         break;
657                                 case 'S':  // service reference string
658                                         tmp = PyString_FromString(ref.toString().c_str());
659                                         break;
660                                 case 'N':  // service name
661                                         if (service_center)
662                                         {
663                                                 service_center->info(ref, sptr);
664                                                 if (sptr)
665                                                 {
666                                                         std::string name;
667                                                         sptr->getName(ref, name);
668
669                                                         // filter short name brakets
670                                                         size_t pos;
671                                                         while((pos = name.find("\xc2\x86")) != std::string::npos)
672                                                                 name.erase(pos,2);
673                                                         while((pos = name.find("\xc2\x87")) != std::string::npos)
674                                                                 name.erase(pos,2);
675
676                                                         if (name.length())
677                                                                 tmp = PyString_FromString(name.c_str());
678                                                 }
679                                         }
680                                         if (!tmp)
681                                                 tmp = PyString_FromString("<n/a>");
682                                         break;
683                                 case 'n':  // short service name
684                                         if (service_center)
685                                         {
686                                                 service_center->info(ref, sptr);
687                                                 if (sptr)
688                                                 {
689                                                         std::string name;
690                                                         sptr->getName(ref, name);
691                                                         name = buildShortName(name);
692                                                         if (name.length())
693                                                                 tmp = PyString_FromString(name.c_str());
694                                                 }
695                                         }
696                                         if (!tmp)
697                                                 tmp = PyString_FromString("<n/a>");
698                                         break;
699                                 default:
700                                         if (tuple)
701                                         {
702                                                 tmp = Py_None;
703                                                 Py_INCREF(Py_None);
704                                         }
705                                         break;
706                                 }
707                                 if (tmp)
708                                 {
709                                         if (tuple)
710                                                 PyTuple_SET_ITEM(tuple, i, tmp);
711                                         else
712                                                 PyList_SET_ITEM(ret, cnt, tmp);
713                                 }
714                         }
715                         if (tuple)
716                                 PyList_SET_ITEM(ret, cnt, tuple);
717                 }
718         }
719         return ret ? (PyObject*)ret : (PyObject*)PyList_New(0);
720 }
721
722 RESULT eDVBServiceList::getNext(eServiceReference &ref)
723 {
724         if (!m_query)
725                 return -1;
726         
727         return m_query->getNextResult((eServiceReferenceDVB&)ref);
728 }
729
730 RESULT eDVBServiceList::startEdit(ePtr<iMutableServiceList> &res)
731 {
732         if (m_parent.flags & eServiceReference::canDescent) // bouquet
733         {
734                 ePtr<iDVBChannelList> db;
735                 ePtr<eDVBResourceManager> resm;
736
737                 if (eDVBResourceManager::getInstance(resm) || resm->getChannelList(db))
738                         return -1;
739
740                 if (db->getBouquet(m_parent, m_bouquet) != 0)
741                         return -1;
742
743                 res = this;
744                 
745                 return 0;
746         }
747         res = 0;
748         return -1;
749 }
750
751 RESULT eDVBServiceList::addService(eServiceReference &ref, eServiceReference before)
752 {
753         if (!m_bouquet)
754                 return -1;
755         return m_bouquet->addService(ref, before);
756 }
757
758 RESULT eDVBServiceList::removeService(eServiceReference &ref)
759 {
760         if (!m_bouquet)
761                 return -1;
762         return m_bouquet->removeService(ref);
763 }
764
765 RESULT eDVBServiceList::moveService(eServiceReference &ref, int pos)
766 {
767         if (!m_bouquet)
768                 return -1;
769         return m_bouquet->moveService(ref, pos);
770 }
771
772 RESULT eDVBServiceList::flushChanges()
773 {
774         if (!m_bouquet)
775                 return -1;
776         return m_bouquet->flushChanges();
777 }
778
779 RESULT eDVBServiceList::setListName(const std::string &name)
780 {
781         if (!m_bouquet)
782                 return -1;
783         return m_bouquet->setListName(name);
784 }
785
786 RESULT eServiceFactoryDVB::play(const eServiceReference &ref, ePtr<iPlayableService> &ptr)
787 {
788         ePtr<eDVBService> service;
789         int r = lookupService(service, ref);
790         if (r)
791                 service = 0;
792                 // check resources...
793         ptr = new eDVBServicePlay(ref, service);
794         return 0;
795 }
796
797 RESULT eServiceFactoryDVB::record(const eServiceReference &ref, ePtr<iRecordableService> &ptr)
798 {
799         if (ref.path.empty())
800         {
801                 ptr = new eDVBServiceRecord((eServiceReferenceDVB&)ref);
802                 return 0;
803         } else
804         {
805                 ptr = 0;
806                 return -1;
807         }
808 }
809
810 RESULT eServiceFactoryDVB::list(const eServiceReference &ref, ePtr<iListableService> &ptr)
811 {
812         ePtr<eDVBServiceList> list = new eDVBServiceList(ref);
813         if (list->startQuery())
814         {
815                 ptr = 0;
816                 return -1;
817         }
818         
819         ptr = list;
820         return 0;
821 }
822
823 RESULT eServiceFactoryDVB::info(const eServiceReference &ref, ePtr<iStaticServiceInformation> &ptr)
824 {
825         /* is a listable service? */
826         if (ref.flags & eServiceReference::canDescent) // bouquet
827         {
828                 if ( !ref.name.empty() )  // satellites or providers list
829                         ptr = m_StaticServiceDVBInfo;
830                 else // a dvb bouquet
831                         ptr = m_StaticServiceDVBBouquetInfo;
832         }
833         else if (!ref.path.empty()) /* do we have a PVR service? */
834                 ptr = new eStaticServiceDVBPVRInformation(ref);
835         else // normal dvb service
836         {
837                 ePtr<eDVBService> service;
838                 if (lookupService(service, ref)) // no eDVBService avail for this reference ( Linkage Services... )
839                         ptr = m_StaticServiceDVBInfo;
840                 else
841                         /* eDVBService has the iStaticServiceInformation interface, so we pass it here. */
842                         ptr = service;
843         }
844         return 0;
845 }
846
847 RESULT eServiceFactoryDVB::offlineOperations(const eServiceReference &ref, ePtr<iServiceOfflineOperations> &ptr)
848 {
849         if (ref.path.empty())
850         {
851                 ptr = 0;
852                 return -1;
853         } else
854         {
855                 ptr = new eDVBPVRServiceOfflineOperations(ref);
856                 return 0;
857         }
858 }
859
860 RESULT eServiceFactoryDVB::lookupService(ePtr<eDVBService> &service, const eServiceReference &ref)
861 {
862                         // TODO: handle the listing itself
863         // if (ref.... == -1) .. return "... bouquets ...";
864         // could be also done in another serviceFactory (with seperate ID) to seperate actual services and lists
865                         // TODO: cache
866         ePtr<iDVBChannelList> db;
867         ePtr<eDVBResourceManager> res;
868         
869         int err;
870         if ((err = eDVBResourceManager::getInstance(res)) != 0)
871         {
872                 eDebug("no resource manager");
873                 return err;
874         }
875         if ((err = res->getChannelList(db)) != 0)
876         {
877                 eDebug("no channel list");
878                 return err;
879         }
880         
881                 /* we are sure to have a ..DVB reference as the info() call was forwarded here according to it's ID. */
882         if ((err = db->getService((eServiceReferenceDVB&)ref, service)) != 0)
883         {
884                 eDebug("getService failed!");
885                 return err;
886         }
887
888         return 0;
889 }
890
891 eDVBServicePlay::eDVBServicePlay(const eServiceReference &ref, eDVBService *service): 
892         m_reference(ref), m_dvb_service(service), m_have_video_pid(0), m_is_paused(0)
893 {
894         m_is_primary = 1;
895         m_is_pvr = !m_reference.path.empty();
896         
897         m_timeshift_enabled = m_timeshift_active = 0;
898         m_skipmode = 0;
899         
900         CONNECT(m_service_handler.serviceEvent, eDVBServicePlay::serviceEvent);
901         CONNECT(m_service_handler_timeshift.serviceEvent, eDVBServicePlay::serviceEventTimeshift);
902         CONNECT(m_event_handler.m_eit_changed, eDVBServicePlay::gotNewEvent);
903
904         m_cuesheet_changed = 0;
905         m_cutlist_enabled = 1;
906         
907         m_subtitle_widget = 0;
908         
909         m_tune_state = -1;
910
911         m_subtitle_sync_timer = eTimer::create(eApp);
912
913         CONNECT(m_subtitle_sync_timer->timeout, eDVBServicePlay::checkSubtitleTiming);
914 }
915
916 eDVBServicePlay::~eDVBServicePlay()
917 {
918         delete m_subtitle_widget;
919 }
920
921 void eDVBServicePlay::gotNewEvent()
922 {
923 #if 0
924                 // debug only
925         ePtr<eServiceEvent> m_event_now, m_event_next;
926         getEvent(m_event_now, 0);
927         getEvent(m_event_next, 1);
928
929         if (m_event_now)
930                 eDebug("now running: %s (%d seconds :)", m_event_now->m_event_name.c_str(), m_event_now->m_duration);
931         if (m_event_next)
932                 eDebug("next running: %s (%d seconds :)", m_event_next->m_event_name.c_str(), m_event_next->m_duration);
933 #endif
934         m_event((iPlayableService*)this, evUpdatedEventInfo);
935 }
936
937 void eDVBServicePlay::serviceEvent(int event)
938 {
939         m_tune_state = event;
940
941         switch (event)
942         {
943         case eDVBServicePMTHandler::eventTuned:
944         {
945                 ePtr<iDVBDemux> m_demux;
946                 if (!m_service_handler.getDataDemux(m_demux))
947                 {
948                         eServiceReferenceDVB &ref = (eServiceReferenceDVB&) m_reference;
949                         int sid = ref.getParentServiceID().get();
950                         if (!sid)
951                                 sid = ref.getServiceID().get();
952                         if ( ref.getParentTransportStreamID().get() &&
953                                 ref.getParentTransportStreamID() != ref.getTransportStreamID() )
954                                 m_event_handler.startOther(m_demux, sid);
955                         else
956                                 m_event_handler.start(m_demux, sid);
957                 }
958                 m_event((iPlayableService*)this, evTunedIn);
959                 break;
960         }
961         case eDVBServicePMTHandler::eventNoResources:
962         case eDVBServicePMTHandler::eventNoPAT:
963         case eDVBServicePMTHandler::eventNoPATEntry:
964         case eDVBServicePMTHandler::eventNoPMT:
965         case eDVBServicePMTHandler::eventTuneFailed:
966         case eDVBServicePMTHandler::eventMisconfiguration:
967         {
968                 eDebug("DVB service failed to tune - error %d", event);
969                 m_event((iPlayableService*)this, evTuneFailed);
970                 break;
971         }
972         case eDVBServicePMTHandler::eventNewProgramInfo:
973         {
974                 eDebug("eventNewProgramInfo %d %d", m_timeshift_enabled, m_timeshift_active);
975                 if (m_timeshift_enabled)
976                         updateTimeshiftPids();
977                 if (!m_timeshift_active)
978                         updateDecoder();
979                 if (m_first_program_info && m_is_pvr)
980                 {
981                         m_first_program_info = 0;
982                         seekTo(0);
983                 }
984                 m_event((iPlayableService*)this, evUpdatedInfo);
985                 break;
986         }
987         case eDVBServicePMTHandler::eventEOF:
988                 m_event((iPlayableService*)this, evEOF);
989                 break;
990         case eDVBServicePMTHandler::eventSOF:
991                 m_event((iPlayableService*)this, evSOF);
992                 break;
993         }
994 }
995
996 void eDVBServicePlay::serviceEventTimeshift(int event)
997 {
998         switch (event)
999         {
1000         case eDVBServicePMTHandler::eventNewProgramInfo:
1001                 if (m_timeshift_active)
1002                         updateDecoder();
1003                 break;
1004         case eDVBServicePMTHandler::eventSOF:
1005                 m_event((iPlayableService*)this, evSOF);
1006                 break;
1007         case eDVBServicePMTHandler::eventEOF:
1008                 if ((!m_is_paused) && (m_skipmode >= 0))
1009                 {
1010                         eDebug("timeshift EOF, so let's go live");
1011                         switchToLive();
1012                 }
1013                 break;
1014         }
1015 }
1016
1017 RESULT eDVBServicePlay::start()
1018 {
1019         int r;
1020                 /* in pvr mode, we only want to use one demux. in tv mode, we're using 
1021                    two (one for decoding, one for data source), as we must be prepared
1022                    to start recording from the data demux. */
1023         if (m_is_pvr)
1024                 m_cue = new eCueSheet();
1025         else
1026                 m_event(this, evStart);
1027
1028         m_first_program_info = 1;
1029         eServiceReferenceDVB &service = (eServiceReferenceDVB&)m_reference;
1030         r = m_service_handler.tune(service, m_is_pvr, m_cue);
1031
1032                 /* inject EIT if there is a stored one */
1033         if (m_is_pvr)
1034         {
1035                 std::string filename = service.path;
1036                 filename.erase(filename.length()-2, 2);
1037                 filename+="eit";
1038                 ePtr<eServiceEvent> event = new eServiceEvent;
1039                 if (!event->parseFrom(filename, (service.getTransportStreamID().get()<<16)|service.getOriginalNetworkID().get()))
1040                 {
1041                         ePtr<eServiceEvent> empty;
1042                         m_event_handler.inject(event, 0);
1043                         m_event_handler.inject(empty, 1);
1044                 }
1045         }
1046
1047         if (m_is_pvr)
1048         {
1049                 loadCuesheet();
1050                 m_event(this, evStart);
1051         }
1052         return 0;
1053 }
1054
1055 RESULT eDVBServicePlay::stop()
1056 {
1057                 /* add bookmark for last play position */
1058         if (m_is_pvr)
1059         {
1060                 pts_t play_position, length;
1061                 if (!getPlayPosition(play_position))
1062                 {
1063                                 /* remove last position */
1064                         for (std::multiset<struct cueEntry>::iterator i(m_cue_entries.begin()); i != m_cue_entries.end();)
1065                         {
1066                                 if (i->what == 3) /* current play position */
1067                                 {
1068                                         m_cue_entries.erase(i);
1069                                         i = m_cue_entries.begin();
1070                                         continue;
1071                                 } else
1072                                         ++i;
1073                         }
1074                         
1075                         if (getLength(length))
1076                                 length = 0;
1077                         
1078                         if (length)
1079                         {
1080                                 int perc = play_position * 100LL / length;
1081                         
1082                                         /* only store last play position when between 1% and 99% */
1083                                 if ((1 < perc) && (perc < 99))
1084                                         m_cue_entries.insert(cueEntry(play_position, 3)); /* last play position */
1085                         }
1086                         m_cuesheet_changed = 1;
1087                 }
1088         }
1089
1090         stopTimeshift(); /* in case timeshift was enabled, remove buffer etc. */
1091
1092         m_service_handler_timeshift.free();
1093         m_service_handler.free();
1094         
1095         if (m_is_pvr && m_cuesheet_changed)
1096         {
1097                 struct stat s;
1098                                 /* save cuesheet only when main file is accessible. */
1099                 if (!::stat(m_reference.path.c_str(), &s))
1100                         saveCuesheet();
1101         }
1102         m_event((iPlayableService*)this, evStopped);
1103         return 0;
1104 }
1105
1106 RESULT eDVBServicePlay::setTarget(int target)
1107 {
1108         m_is_primary = !target;
1109         return 0;
1110 }
1111
1112 RESULT eDVBServicePlay::connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection)
1113 {
1114         connection = new eConnection((iPlayableService*)this, m_event.connect(event));
1115         return 0;
1116 }
1117
1118 RESULT eDVBServicePlay::pause(ePtr<iPauseableService> &ptr)
1119 {
1120                 /* note: we check for timeshift to be enabled,
1121                    not neccessary active. if you pause when timeshift
1122                    is not active, you should activate it when unpausing */
1123         if ((!m_is_pvr) && (!m_timeshift_enabled))
1124         {
1125                 ptr = 0;
1126                 return -1;
1127         }
1128
1129         ptr = this;
1130         return 0;
1131 }
1132
1133 RESULT eDVBServicePlay::setSlowMotion(int ratio)
1134 {
1135         assert(ratio); /* The API changed: instead of calling setSlowMotion(0), call play! */
1136         eDebug("eDVBServicePlay::setSlowMotion(%d)", ratio);
1137         setFastForward_internal(0);
1138         if (m_decoder)
1139                 return m_decoder->setSlowMotion(ratio);
1140         else
1141                 return -1;
1142 }
1143
1144 RESULT eDVBServicePlay::setFastForward(int ratio)
1145 {
1146         eDebug("eDVBServicePlay::setFastForward(%d)", ratio);
1147         assert(ratio);
1148         return setFastForward_internal(ratio);
1149 }
1150
1151 RESULT eDVBServicePlay::setFastForward_internal(int ratio)
1152 {
1153         int skipmode, ffratio;
1154         
1155         if (ratio > 8)
1156         {
1157                 skipmode = ratio;
1158                 ffratio = 1;
1159         } else if (ratio > 0)
1160         {
1161                 skipmode = 0;
1162                 ffratio = ratio;
1163         } else if (!ratio)
1164         {
1165                 skipmode = 0;
1166                 ffratio = 0;
1167         } else // if (ratio < 0)
1168         {
1169                 skipmode = ratio;
1170                 ffratio = 1;
1171         }
1172
1173         if (m_skipmode != skipmode)
1174         {
1175                 eDebug("setting cue skipmode to %d", skipmode);
1176                 if (m_cue)
1177                         m_cue->setSkipmode(skipmode * 90000); /* convert to 90000 per second */
1178         }
1179         
1180         m_skipmode = skipmode;
1181         
1182         if (!m_decoder)
1183                 return -1;
1184                 
1185         if (ffratio == 0)
1186                 return m_decoder->play();
1187         else if (ffratio != 1)
1188                 return m_decoder->setFastForward(ffratio);
1189         else
1190                 return m_decoder->setTrickmode();
1191 }
1192
1193 RESULT eDVBServicePlay::seek(ePtr<iSeekableService> &ptr)
1194 {
1195         if (m_is_pvr || m_timeshift_enabled)
1196         {
1197                 ptr = this;
1198                 return 0;
1199         }
1200         
1201         ptr = 0;
1202         return -1;
1203 }
1204
1205         /* TODO: when timeshift is enabled but not active, this doesn't work. */
1206 RESULT eDVBServicePlay::getLength(pts_t &len)
1207 {
1208         ePtr<iDVBPVRChannel> pvr_channel;
1209         
1210         if ((m_timeshift_enabled ? m_service_handler_timeshift : m_service_handler).getPVRChannel(pvr_channel))
1211                 return -1;
1212         
1213         return pvr_channel->getLength(len);
1214 }
1215
1216 RESULT eDVBServicePlay::pause()
1217 {
1218         eDebug("eDVBServicePlay::pause");
1219         setFastForward_internal(0);
1220         if (m_decoder)
1221         {
1222                 m_is_paused = 1;
1223                 return m_decoder->pause();
1224         } else
1225                 return -1;
1226 }
1227
1228 RESULT eDVBServicePlay::unpause()
1229 {
1230         eDebug("eDVBServicePlay::unpause");
1231         setFastForward_internal(0);
1232         if (m_decoder)
1233         {
1234                 m_is_paused = 0;
1235                 return m_decoder->play();
1236         } else
1237                 return -1;
1238 }
1239
1240 RESULT eDVBServicePlay::seekTo(pts_t to)
1241 {
1242         eDebug("eDVBServicePlay::seekTo: jump %lld", to);
1243         
1244         if (!m_decode_demux)
1245                 return -1;
1246
1247         ePtr<iDVBPVRChannel> pvr_channel;
1248         
1249         if ((m_timeshift_enabled ? m_service_handler_timeshift : m_service_handler).getPVRChannel(pvr_channel))
1250                 return -1;
1251         
1252         if (!m_cue)
1253                 return -1;
1254         
1255         m_cue->seekTo(0, to);
1256         m_dvb_subtitle_pages.clear();
1257         m_subtitle_pages.clear();
1258
1259         return 0;
1260 }
1261
1262 RESULT eDVBServicePlay::seekRelative(int direction, pts_t to)
1263 {
1264         eDebug("eDVBServicePlay::seekRelative: jump %d, %lld", direction, to);
1265         
1266         if (!m_decode_demux)
1267                 return -1;
1268
1269         ePtr<iDVBPVRChannel> pvr_channel;
1270         
1271         if ((m_timeshift_enabled ? m_service_handler_timeshift : m_service_handler).getPVRChannel(pvr_channel))
1272                 return -1;
1273         
1274         int mode = 1;
1275         
1276                         /* HACK until we have skip-AP api */
1277         if ((to > 0) && (to < 100))
1278                 mode = 2;
1279         
1280         to *= direction;
1281         
1282         if (!m_cue)
1283                 return 0;
1284         
1285         m_cue->seekTo(mode, to);
1286         m_dvb_subtitle_pages.clear();
1287         m_subtitle_pages.clear();
1288         return 0;
1289 }
1290
1291 RESULT eDVBServicePlay::getPlayPosition(pts_t &pos)
1292 {
1293         ePtr<iDVBPVRChannel> pvr_channel;
1294         
1295         if (!m_decode_demux)
1296                 return -1;
1297         
1298         if ((m_timeshift_enabled ? m_service_handler_timeshift : m_service_handler).getPVRChannel(pvr_channel))
1299                 return -1;
1300         
1301         int r = 0;
1302
1303                 /* if there is a decoder, use audio or video PTS */
1304         if (m_decoder)
1305         {
1306                 r = m_decoder->getPTS(0, pos);
1307                 if (r)
1308                         return r;
1309         }
1310         
1311                 /* fixup */
1312         return pvr_channel->getCurrentPosition(m_decode_demux, pos, m_decoder ? 1 : 0);
1313 }
1314
1315 RESULT eDVBServicePlay::setTrickmode(int trick)
1316 {
1317                 /* currently unimplemented */
1318         return -1;
1319 }
1320
1321 RESULT eDVBServicePlay::isCurrentlySeekable()
1322 {
1323         return m_is_pvr || m_timeshift_active;
1324 }
1325
1326 RESULT eDVBServicePlay::frontendInfo(ePtr<iFrontendInformation> &ptr)
1327 {
1328         ptr = this;
1329         return 0;
1330 }
1331
1332 RESULT eDVBServicePlay::info(ePtr<iServiceInformation> &ptr)
1333 {
1334         ptr = this;
1335         return 0;
1336 }
1337
1338 RESULT eDVBServicePlay::audioChannel(ePtr<iAudioChannelSelection> &ptr)
1339 {
1340         ptr = this;
1341         return 0;
1342 }
1343
1344 RESULT eDVBServicePlay::audioTracks(ePtr<iAudioTrackSelection> &ptr)
1345 {
1346         ptr = this;
1347         return 0;
1348 }
1349
1350 RESULT eDVBServicePlay::subServices(ePtr<iSubserviceList> &ptr)
1351 {
1352         ptr = this;
1353         return 0;
1354 }
1355
1356 RESULT eDVBServicePlay::timeshift(ePtr<iTimeshiftService> &ptr)
1357 {
1358         ptr = 0;
1359         if (m_have_video_pid &&  // HACK !!! FIXMEE !! temporary no timeshift on radio services !!
1360                 (m_timeshift_enabled || !m_is_pvr))
1361         {
1362                 if (!m_timeshift_enabled)
1363                 {
1364                         /* query config path */
1365                         std::string tspath;
1366                         if(ePythonConfigQuery::getConfigValue("config.usage.timeshift_path", tspath) == -1){
1367                                 eDebug("could not query ts path from config");
1368                                 return -4;
1369                         }
1370                         tspath.append("/");
1371                         /* we need enough diskspace */
1372                         struct statfs fs;
1373                         if (statfs(tspath.c_str(), &fs) < 0)
1374                         {
1375                                 eDebug("statfs failed!");
1376                                 return -2;
1377                         }
1378                 
1379                         if (((off_t)fs.f_bavail) * ((off_t)fs.f_bsize) < 1024*1024*1024LL)
1380                         {
1381                                 eDebug("not enough diskspace for timeshift! (less than 1GB)");
1382                                 return -3;
1383                         }
1384                 }
1385                 ptr = this;
1386                 return 0;
1387         }
1388         return -1;
1389 }
1390
1391 RESULT eDVBServicePlay::cueSheet(ePtr<iCueSheet> &ptr)
1392 {
1393         if (m_is_pvr)
1394         {
1395                 ptr = this;
1396                 return 0;
1397         }
1398         ptr = 0;
1399         return -1;
1400 }
1401
1402 RESULT eDVBServicePlay::subtitle(ePtr<iSubtitleOutput> &ptr)
1403 {
1404         ptr = this;
1405         return 0;
1406 }
1407
1408 RESULT eDVBServicePlay::audioDelay(ePtr<iAudioDelay> &ptr)
1409 {
1410         ptr = this;
1411         return 0;
1412 }
1413
1414 RESULT eDVBServicePlay::rdsDecoder(ePtr<iRdsDecoder> &ptr)
1415 {
1416         ptr = this;
1417         return 0;
1418 }
1419
1420 RESULT eDVBServicePlay::getName(std::string &name)
1421 {
1422         if (m_is_pvr)
1423         {
1424                 ePtr<iStaticServiceInformation> i = new eStaticServiceDVBPVRInformation(m_reference);
1425                 return i->getName(m_reference, name);
1426         }
1427         if (m_dvb_service)
1428         {
1429                 m_dvb_service->getName(m_reference, name);
1430                 if (name.empty())
1431                         name = "(...)";
1432         }
1433         else if (!m_reference.name.empty())
1434                 eStaticServiceDVBInformation().getName(m_reference, name);
1435         else
1436                 name = "DVB service";
1437         return 0;
1438 }
1439
1440 RESULT eDVBServicePlay::getEvent(ePtr<eServiceEvent> &evt, int nownext)
1441 {
1442         return m_event_handler.getEvent(evt, nownext);
1443 }
1444
1445 int eDVBServicePlay::getInfo(int w)
1446 {
1447         eDVBServicePMTHandler::program program;
1448
1449         if (w == sCAIDs)
1450                 return resIsPyObject;
1451
1452         eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
1453
1454         int no_program_info = 0;
1455
1456         if (h.getProgramInfo(program))
1457                 no_program_info = 1;
1458
1459         switch (w)
1460         {
1461         case sVideoHeight:
1462                 if (m_decoder)
1463                         return m_decoder->getVideoHeight();
1464                 break;
1465         case sVideoWidth:
1466                 if (m_decoder)
1467                         return m_decoder->getVideoWidth();
1468                 break;
1469         case sFrameRate:
1470                 if (m_decoder)
1471                         return m_decoder->getVideoFrameRate();
1472                 break;
1473         case sProgressive:
1474                 if (m_decoder)
1475                         return m_decoder->getVideoProgressive();
1476                 break;
1477         case sAspect:
1478         {
1479                 int aspect = -1;
1480                 if (m_decoder)
1481                         aspect = m_decoder->getVideoAspect();
1482                 if (no_program_info)
1483                         break;
1484                 else if (aspect == -1 && !program.videoStreams.empty() && program.videoStreams[0].component_tag != -1)
1485                 {
1486                         ePtr<eServiceEvent> evt;
1487                         if (!m_event_handler.getEvent(evt, 0))
1488                         {
1489                                 ePtr<eComponentData> data;
1490                                 if (!evt->getComponentData(data, program.videoStreams[0].component_tag))
1491                                 {
1492                                         if ( data->getStreamContent() == 1 )
1493                                         {
1494                                                 switch(data->getComponentType())
1495                                                 {
1496                                                         // SD
1497                                                         case 1: // 4:3 SD PAL
1498                                                         case 2:
1499                                                         case 3: // 16:9 SD PAL
1500                                                         case 4: // > 16:9 PAL
1501                                                         case 5: // 4:3 SD NTSC
1502                                                         case 6: 
1503                                                         case 7: // 16:9 SD NTSC
1504                                                         case 8: // > 16:9 NTSC
1505
1506                                                         // HD
1507                                                         case 9: // 4:3 HD PAL
1508                                                         case 0xA:
1509                                                         case 0xB: // 16:9 HD PAL
1510                                                         case 0xC: // > 16:9 HD PAL
1511                                                         case 0xD: // 4:3 HD NTSC
1512                                                         case 0xE:
1513                                                         case 0xF: // 16:9 HD NTSC
1514                                                         case 0x10: // > 16:9 HD PAL
1515                                                                 return data->getComponentType();
1516                                                 }
1517                                         }
1518                                 }
1519                         }
1520                 }
1521                 else
1522                         return aspect;
1523                 break;
1524         }
1525         case sIsCrypted: if (no_program_info) return -1; return program.isCrypted();
1526         case sVideoPID: if (no_program_info) return -1; if (program.videoStreams.empty()) return -1; return program.videoStreams[0].pid;
1527         case sVideoType: if (no_program_info) return -1; if (program.videoStreams.empty()) return -1; return program.videoStreams[0].type;
1528         case sAudioPID: if (no_program_info) return -1; if (program.audioStreams.empty()) return -1; return program.audioStreams[0].pid;
1529         case sPCRPID: if (no_program_info) return -1; return program.pcrPid;
1530         case sPMTPID: if (no_program_info) return -1; return program.pmtPid;
1531         case sTXTPID: if (no_program_info) return -1; return program.textPid;
1532         case sSID: return ((const eServiceReferenceDVB&)m_reference).getServiceID().get();
1533         case sONID: return ((const eServiceReferenceDVB&)m_reference).getOriginalNetworkID().get();
1534         case sTSID: return ((const eServiceReferenceDVB&)m_reference).getTransportStreamID().get();
1535         case sNamespace: return ((const eServiceReferenceDVB&)m_reference).getDVBNamespace().get();
1536         case sProvider: if (!m_dvb_service) return -1; return -2;
1537         case sServiceref: return resIsString;
1538         case sDVBState: return m_tune_state;
1539         default:
1540                 break;
1541         }
1542         return -1;
1543 }
1544
1545 std::string eDVBServicePlay::getInfoString(int w)
1546 {
1547         switch (w)
1548         {
1549         case sProvider:
1550                 if (!m_dvb_service) return "";
1551                 return m_dvb_service->m_provider_name;
1552         case sServiceref:
1553                 return m_reference.toString();
1554         default:
1555                 break;
1556         }
1557         return iServiceInformation::getInfoString(w);
1558 }
1559
1560 PyObject *eDVBServicePlay::getInfoObject(int w)
1561 {
1562         switch (w)
1563         {
1564         case sCAIDs:
1565                 return m_service_handler.getCaIds();
1566         case sTransponderData:
1567                 return eStaticServiceDVBInformation().getInfoObject(m_reference, w);
1568         default:
1569                 break;
1570         }
1571         return iServiceInformation::getInfoObject(w);
1572 }
1573
1574 int eDVBServicePlay::getNumberOfTracks()
1575 {
1576         eDVBServicePMTHandler::program program;
1577         eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
1578         if (h.getProgramInfo(program))
1579                 return 0;
1580         return program.audioStreams.size();
1581 }
1582
1583 int eDVBServicePlay::getCurrentTrack()
1584 {
1585         eDVBServicePMTHandler::program program;
1586         eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
1587         if (h.getProgramInfo(program))
1588                 return 0;
1589
1590         int max = program.audioStreams.size();
1591         int i;
1592
1593         for (i = 0; i < max; ++i)
1594                 if (program.audioStreams[i].pid == m_current_audio_pid)
1595                         return i;
1596
1597         return 0;
1598 }
1599
1600 RESULT eDVBServicePlay::selectTrack(unsigned int i)
1601 {
1602         int ret = selectAudioStream(i);
1603
1604         if (m_decoder->play())
1605                 return -5;
1606
1607         return ret;
1608 }
1609
1610 RESULT eDVBServicePlay::getTrackInfo(struct iAudioTrackInfo &info, unsigned int i)
1611 {
1612         eDVBServicePMTHandler::program program;
1613         eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
1614
1615         if (h.getProgramInfo(program))
1616                 return -1;
1617         
1618         if (i >= program.audioStreams.size())
1619                 return -2;
1620         
1621         info.m_pid = program.audioStreams[i].pid;
1622
1623         if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atMPEG)
1624                 info.m_description = "MPEG";
1625         else if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atAC3)
1626                 info.m_description = "AC3";
1627         else if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atAAC)
1628                 info.m_description = "AAC";
1629         else if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atAACHE)
1630                 info.m_description = "AAC-HE";
1631         else  if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atDTS)
1632                 info.m_description = "DTS";
1633         else
1634                 info.m_description = "???";
1635
1636         if (program.audioStreams[i].component_tag != -1)
1637         {
1638                 ePtr<eServiceEvent> evt;
1639                 if (!m_event_handler.getEvent(evt, 0))
1640                 {
1641                         ePtr<eComponentData> data;
1642                         if (!evt->getComponentData(data, program.audioStreams[i].component_tag))
1643                                 info.m_language = data->getText();
1644                 }
1645         }
1646
1647         if (info.m_language.empty())
1648                 info.m_language = program.audioStreams[i].language_code;
1649         
1650         return 0;
1651 }
1652
1653 int eDVBServicePlay::selectAudioStream(int i)
1654 {
1655         eDVBServicePMTHandler::program program;
1656         eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
1657
1658         if (h.getProgramInfo(program))
1659                 return -1;
1660
1661         if ((i != -1) && ((unsigned int)i >= program.audioStreams.size()))
1662                 return -2;
1663
1664         if (!m_decoder)
1665                 return -3;
1666
1667         int stream = i;
1668         if (stream == -1)
1669                 stream = program.defaultAudioStream;
1670
1671         int apid = -1, apidtype = -1;
1672
1673         if (((unsigned int)stream) < program.audioStreams.size())
1674         {
1675                 apid = program.audioStreams[stream].pid;
1676                 apidtype = program.audioStreams[stream].type;
1677         }
1678
1679         m_current_audio_pid = apid;
1680
1681         if (m_decoder->setAudioPID(apid, apidtype))
1682         {
1683                 eDebug("set audio pid failed");
1684                 return -4;
1685         }
1686
1687                 /* if we are not in PVR mode, timeshift is not active and we are not in pip mode, check if we need to enable the rds reader */
1688         if (!(m_is_pvr || m_timeshift_active || !m_is_primary))
1689                 if (!m_rds_decoder)
1690                 {
1691                         ePtr<iDVBDemux> data_demux;
1692                         if (!h.getDataDemux(data_demux))
1693                         {
1694                                 m_rds_decoder = new eDVBRdsDecoder(data_demux);
1695                                 m_rds_decoder->connectEvent(slot(*this, &eDVBServicePlay::rdsDecoderEvent), m_rds_decoder_event_connection);
1696                         }
1697                 }
1698
1699                 /* if we decided that we need one, update the pid */
1700         if (m_rds_decoder)
1701                 m_rds_decoder->start(apid);
1702
1703                         /* store new pid as default only when:
1704                                 a.) we have an entry in the service db for the current service,
1705                                 b.) we are not playing back something,
1706                                 c.) we are not selecting the default entry. (we wouldn't change 
1707                                     anything in the best case, or destroy the default setting in
1708                                     case the real default is not yet available.)
1709                         */
1710         if (m_dvb_service && !m_is_pvr && ((i != -1)
1711                 || ((m_dvb_service->getCacheEntry(eDVBService::cAPID) == -1) && (m_dvb_service->getCacheEntry(eDVBService::cAC3PID)==-1))))
1712         {
1713                 if (apidtype == eDVBAudio::aMPEG)
1714                 {
1715                         m_dvb_service->setCacheEntry(eDVBService::cAPID, apid);
1716                         m_dvb_service->setCacheEntry(eDVBService::cAC3PID, -1);
1717                 }
1718                 else
1719                 {
1720                         m_dvb_service->setCacheEntry(eDVBService::cAPID, -1);
1721                         m_dvb_service->setCacheEntry(eDVBService::cAC3PID, apid);
1722                 }
1723         }
1724
1725         h.resetCachedProgram();
1726
1727         return 0;
1728 }
1729
1730 int eDVBServicePlay::getCurrentChannel()
1731 {
1732         return m_decoder ? m_decoder->getAudioChannel() : STEREO;
1733 }
1734
1735 RESULT eDVBServicePlay::selectChannel(int i)
1736 {
1737         if (i < LEFT || i > RIGHT || i == STEREO)
1738                 i = -1;  // Stereo
1739         if (m_dvb_service)
1740                 m_dvb_service->setCacheEntry(eDVBService::cACHANNEL, i);
1741         if (m_decoder)
1742                 m_decoder->setAudioChannel(i);
1743         return 0;
1744 }
1745
1746 std::string eDVBServicePlay::getText(int x)
1747 {
1748         if (m_rds_decoder)
1749                 switch(x)
1750                 {
1751                         case RadioText:
1752                                 return convertLatin1UTF8(m_rds_decoder->getRadioText());
1753                         case RtpText:
1754                                 return convertLatin1UTF8(m_rds_decoder->getRtpText());
1755                 }
1756         return "";
1757 }
1758
1759 void eDVBServicePlay::rdsDecoderEvent(int what)
1760 {
1761         switch(what)
1762         {
1763                 case eDVBRdsDecoder::RadioTextChanged:
1764                         m_event((iPlayableService*)this, evUpdatedRadioText);
1765                         break;
1766                 case eDVBRdsDecoder::RtpTextChanged:
1767                         m_event((iPlayableService*)this, evUpdatedRtpText);
1768                         break;
1769                 case eDVBRdsDecoder::RassInteractivePicMaskChanged:
1770                         m_event((iPlayableService*)this, evUpdatedRassInteractivePicMask);
1771                         break;
1772                 case eDVBRdsDecoder::RecvRassSlidePic:
1773                         m_event((iPlayableService*)this, evUpdatedRassSlidePic);
1774                         break;
1775         }
1776 }
1777
1778 void eDVBServicePlay::showRassSlidePicture()
1779 {
1780         if (m_rds_decoder)
1781         {
1782                 if (m_decoder)
1783                 {
1784                         std::string rass_slide_pic = m_rds_decoder->getRassSlideshowPicture();
1785                         if (rass_slide_pic.length())
1786                                 m_decoder->showSinglePic(rass_slide_pic.c_str());
1787                         else
1788                                 eDebug("empty filename for rass slide picture received!!");
1789                 }
1790                 else
1791                         eDebug("no MPEG Decoder to show iframes avail");
1792         }
1793         else
1794                 eDebug("showRassSlidePicture called.. but not decoder");
1795 }
1796
1797 void eDVBServicePlay::showRassInteractivePic(int page, int subpage)
1798 {
1799         if (m_rds_decoder)
1800         {
1801                 if (m_decoder)
1802                 {
1803                         std::string rass_interactive_pic = m_rds_decoder->getRassPicture(page, subpage);
1804                         if (rass_interactive_pic.length())
1805                                 m_decoder->showSinglePic(rass_interactive_pic.c_str());
1806                         else
1807                                 eDebug("empty filename for rass interactive picture %d/%d received!!", page, subpage);
1808                 }
1809                 else
1810                         eDebug("no MPEG Decoder to show iframes avail");
1811         }
1812         else
1813                 eDebug("showRassInteractivePic called.. but not decoder");
1814 }
1815
1816 ePyObject eDVBServicePlay::getRassInteractiveMask()
1817 {
1818         if (m_rds_decoder)
1819                 return m_rds_decoder->getRassPictureMask();
1820         Py_RETURN_NONE;
1821 }
1822
1823 int eDVBServiceBase::getFrontendInfo(int w)
1824 {
1825         eUsePtr<iDVBChannel> channel;
1826         if(m_service_handler.getChannel(channel))
1827                 return 0;
1828         ePtr<iDVBFrontend> fe;
1829         if(channel->getFrontend(fe))
1830                 return 0;
1831         return fe->readFrontendData(w);
1832 }
1833
1834 PyObject *eDVBServiceBase::getFrontendData()
1835 {
1836         ePyObject ret = PyDict_New();
1837         if (ret)
1838         {
1839                 eUsePtr<iDVBChannel> channel;
1840                 if(!m_service_handler.getChannel(channel))
1841                 {
1842                         ePtr<iDVBFrontend> fe;
1843                         if(!channel->getFrontend(fe))
1844                                 fe->getFrontendData(ret);
1845                 }
1846         }
1847         else
1848                 Py_RETURN_NONE;
1849         return ret;
1850 }
1851
1852 PyObject *eDVBServiceBase::getFrontendStatus()
1853 {
1854         ePyObject ret = PyDict_New();
1855         if (ret)
1856         {
1857                 eUsePtr<iDVBChannel> channel;
1858                 if(!m_service_handler.getChannel(channel))
1859                 {
1860                         ePtr<iDVBFrontend> fe;
1861                         if(!channel->getFrontend(fe))
1862                                 fe->getFrontendStatus(ret);
1863                 }
1864         }
1865         else
1866                 Py_RETURN_NONE;
1867         return ret;
1868 }
1869
1870 PyObject *eDVBServiceBase::getTransponderData(bool original)
1871 {
1872         ePyObject ret = PyDict_New();
1873         if (ret)
1874         {
1875                 eUsePtr<iDVBChannel> channel;
1876                 if(!m_service_handler.getChannel(channel))
1877                 {
1878                         ePtr<iDVBFrontend> fe;
1879                         if(!channel->getFrontend(fe))
1880                         {
1881                                 fe->getTransponderData(ret, original);
1882                                 ePtr<iDVBFrontendParameters> feparm;
1883                                 channel->getCurrentFrontendParameters(feparm);
1884                                 if (feparm)
1885                                 {
1886                                         eDVBFrontendParametersSatellite osat;
1887                                         if (!feparm->getDVBS(osat))
1888                                         {
1889                                                 PutToDict(ret, "orbital_position", osat.orbital_position);
1890                                                 PutToDict(ret, "polarization", osat.polarisation);
1891                                         }
1892                                 }
1893                         }
1894                 }
1895         }
1896         else
1897                 Py_RETURN_NONE;
1898         return ret;
1899 }
1900
1901 PyObject *eDVBServiceBase::getAll(bool original)
1902 {
1903         ePyObject ret = getTransponderData(original);
1904         if (ret != Py_None)
1905         {
1906                 eUsePtr<iDVBChannel> channel;
1907                 if(!m_service_handler.getChannel(channel))
1908                 {
1909                         ePtr<iDVBFrontend> fe;
1910                         if(!channel->getFrontend(fe))
1911                         {
1912                                 fe->getFrontendData(ret);
1913                                 fe->getFrontendStatus(ret);
1914                         }
1915                 }
1916         }
1917         return ret;
1918 }
1919
1920 int eDVBServicePlay::getNumberOfSubservices()
1921 {
1922         ePtr<eServiceEvent> evt;
1923         if (!m_event_handler.getEvent(evt, 0))
1924                 return evt->getNumOfLinkageServices();
1925         return 0;
1926 }
1927
1928 RESULT eDVBServicePlay::getSubservice(eServiceReference &sub, unsigned int n)
1929 {
1930         ePtr<eServiceEvent> evt;
1931         if (!m_event_handler.getEvent(evt, 0))
1932         {
1933                 if (!evt->getLinkageService(sub, m_reference, n))
1934                         return 0;
1935         }
1936         sub.type=eServiceReference::idInvalid;
1937         return -1;
1938 }
1939
1940 RESULT eDVBServicePlay::startTimeshift()
1941 {
1942         ePtr<iDVBDemux> demux;
1943         
1944         eDebug("Start timeshift!");
1945         
1946         if (m_timeshift_enabled)
1947                 return -1;
1948         
1949                 /* start recording with the data demux. */
1950         if (m_service_handler.getDataDemux(demux))
1951                 return -2;
1952
1953         demux->createTSRecorder(m_record);
1954         if (!m_record)
1955                 return -3;
1956
1957         std::string tspath;
1958         if(ePythonConfigQuery::getConfigValue("config.usage.timeshift_path", tspath) == -1){ 
1959                 eDebug("could not query ts path");
1960                 return -5;
1961         }
1962         tspath.append("/timeshift.XXXXXX");
1963         char* templ;
1964         templ = new char[tspath.length() + 1];
1965         strcpy(templ, tspath.c_str());
1966
1967         m_timeshift_fd = mkstemp(templ);
1968         m_timeshift_file = std::string(templ);
1969
1970         eDebug("recording to %s", templ);
1971
1972         delete [] templ;
1973
1974         if (m_timeshift_fd < 0)
1975         {
1976                 m_record = 0;
1977                 return -4;
1978         }
1979                 
1980         m_record->setTargetFD(m_timeshift_fd);
1981
1982         m_timeshift_enabled = 1;
1983         
1984         updateTimeshiftPids();
1985         m_record->start();
1986
1987         return 0;
1988 }
1989
1990 RESULT eDVBServicePlay::stopTimeshift()
1991 {
1992         if (!m_timeshift_enabled)
1993                 return -1;
1994         
1995         switchToLive();
1996         
1997         m_timeshift_enabled = 0;
1998         
1999         m_record->stop();
2000         m_record = 0;
2001         
2002         close(m_timeshift_fd);
2003         eDebug("remove timeshift file");
2004         eBackgroundFileEraser::getInstance()->erase(m_timeshift_file.c_str());
2005         
2006         return 0;
2007 }
2008
2009 int eDVBServicePlay::isTimeshiftActive()
2010 {
2011         return m_timeshift_enabled && m_timeshift_active;
2012 }
2013
2014 RESULT eDVBServicePlay::activateTimeshift()
2015 {
2016         if (!m_timeshift_enabled)
2017                 return -1;
2018         
2019         if (!m_timeshift_active)
2020         {
2021                 switchToTimeshift();
2022                 return 0;
2023         }
2024         
2025         return -2;
2026 }
2027
2028 PyObject *eDVBServicePlay::getCutList()
2029 {
2030         ePyObject list = PyList_New(0);
2031         
2032         for (std::multiset<struct cueEntry>::iterator i(m_cue_entries.begin()); i != m_cue_entries.end(); ++i)
2033         {
2034                 ePyObject tuple = PyTuple_New(2);
2035                 PyTuple_SET_ITEM(tuple, 0, PyLong_FromLongLong(i->where));
2036                 PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(i->what));
2037                 PyList_Append(list, tuple);
2038                 Py_DECREF(tuple);
2039         }
2040         
2041         return list;
2042 }
2043
2044 void eDVBServicePlay::setCutList(ePyObject list)
2045 {
2046         if (!PyList_Check(list))
2047                 return;
2048         int size = PyList_Size(list);
2049         int i;
2050         
2051         m_cue_entries.clear();
2052         
2053         for (i=0; i<size; ++i)
2054         {
2055                 ePyObject tuple = PyList_GET_ITEM(list, i);
2056                 if (!PyTuple_Check(tuple))
2057                 {
2058                         eDebug("non-tuple in cutlist");
2059                         continue;
2060                 }
2061                 if (PyTuple_Size(tuple) != 2)
2062                 {
2063                         eDebug("cutlist entries need to be a 2-tuple");
2064                         continue;
2065                 }
2066                 ePyObject ppts = PyTuple_GET_ITEM(tuple, 0), ptype = PyTuple_GET_ITEM(tuple, 1);
2067                 if (!(PyLong_Check(ppts) && PyInt_Check(ptype)))
2068                 {
2069                         eDebug("cutlist entries need to be (pts, type)-tuples (%d %d)", PyLong_Check(ppts), PyInt_Check(ptype));
2070                         continue;
2071                 }
2072                 pts_t pts = PyLong_AsLongLong(ppts);
2073                 int type = PyInt_AsLong(ptype);
2074                 m_cue_entries.insert(cueEntry(pts, type));
2075                 eDebug("adding %08llx, %d", pts, type);
2076         }
2077         m_cuesheet_changed = 1;
2078         
2079         cutlistToCuesheet();
2080         m_event((iPlayableService*)this, evCuesheetChanged);
2081 }
2082
2083 void eDVBServicePlay::setCutListEnable(int enable)
2084 {
2085         m_cutlist_enabled = enable;
2086         cutlistToCuesheet();
2087 }
2088
2089 void eDVBServicePlay::updateTimeshiftPids()
2090 {
2091         if (!m_record)
2092                 return;
2093         
2094         eDVBServicePMTHandler::program program;
2095         eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
2096
2097         if (h.getProgramInfo(program))
2098                 return;
2099         else
2100         {
2101                 std::set<int> pids_to_record;
2102                 pids_to_record.insert(0); // PAT
2103                 if (program.pmtPid != -1)
2104                         pids_to_record.insert(program.pmtPid); // PMT
2105
2106                 if (program.textPid != -1)
2107                         pids_to_record.insert(program.textPid); // Videotext
2108
2109                 for (std::vector<eDVBServicePMTHandler::videoStream>::const_iterator
2110                         i(program.videoStreams.begin()); 
2111                         i != program.videoStreams.end(); ++i)
2112                         pids_to_record.insert(i->pid);
2113
2114                 for (std::vector<eDVBServicePMTHandler::audioStream>::const_iterator
2115                         i(program.audioStreams.begin()); 
2116                         i != program.audioStreams.end(); ++i)
2117                                 pids_to_record.insert(i->pid);
2118
2119                 for (std::vector<eDVBServicePMTHandler::subtitleStream>::const_iterator
2120                         i(program.subtitleStreams.begin());
2121                         i != program.subtitleStreams.end(); ++i)
2122                                 pids_to_record.insert(i->pid);
2123
2124                 std::set<int> new_pids, obsolete_pids;
2125                 
2126                 std::set_difference(pids_to_record.begin(), pids_to_record.end(), 
2127                                 m_pids_active.begin(), m_pids_active.end(),
2128                                 std::inserter(new_pids, new_pids.begin()));
2129                 
2130                 std::set_difference(
2131                                 m_pids_active.begin(), m_pids_active.end(),
2132                                 pids_to_record.begin(), pids_to_record.end(), 
2133                                 std::inserter(new_pids, new_pids.begin())
2134                                 );
2135
2136                 for (std::set<int>::iterator i(new_pids.begin()); i != new_pids.end(); ++i)
2137                         m_record->addPID(*i);
2138
2139                 for (std::set<int>::iterator i(obsolete_pids.begin()); i != obsolete_pids.end(); ++i)
2140                         m_record->removePID(*i);
2141         }
2142 }
2143
2144 void eDVBServicePlay::switchToLive()
2145 {
2146         if (!m_timeshift_active)
2147                 return;
2148         
2149         eDebug("SwitchToLive");
2150         
2151         m_cue = 0;
2152         m_decoder = 0;
2153         m_decode_demux = 0;
2154         m_teletext_parser = 0;
2155         m_rds_decoder = 0;
2156         m_subtitle_parser = 0;
2157         m_new_dvb_subtitle_page_connection = 0;
2158         m_new_subtitle_page_connection = 0;
2159         m_rds_decoder_event_connection = 0;
2160         m_video_event_connection = 0;
2161
2162                 /* free the timeshift service handler, we need the resources */
2163         m_service_handler_timeshift.free();
2164         m_timeshift_active = 0;
2165
2166         m_event((iPlayableService*)this, evSeekableStatusChanged);
2167
2168         updateDecoder();
2169 }
2170
2171 void eDVBServicePlay::switchToTimeshift()
2172 {
2173         if (m_timeshift_active)
2174                 return;
2175
2176         m_decode_demux = 0;
2177         m_decoder = 0;
2178         m_teletext_parser = 0;
2179         m_rds_decoder = 0;
2180         m_subtitle_parser = 0;
2181         m_new_subtitle_page_connection = 0;
2182         m_new_dvb_subtitle_page_connection = 0;
2183         m_rds_decoder_event_connection = 0;
2184         m_video_event_connection = 0;
2185
2186         m_timeshift_active = 1;
2187
2188         eServiceReferenceDVB r = (eServiceReferenceDVB&)m_reference;
2189         r.path = m_timeshift_file;
2190
2191         m_cue = new eCueSheet();
2192         m_service_handler_timeshift.tune(r, 1, m_cue); /* use the decoder demux for everything */
2193
2194         eDebug("eDVBServicePlay::switchToTimeshift, in pause mode now.");
2195         pause();
2196         updateDecoder(); /* mainly to switch off PCR, and to set pause */
2197         
2198         m_event((iPlayableService*)this, evSeekableStatusChanged);
2199 }
2200
2201 void eDVBServicePlay::updateDecoder()
2202 {
2203         int vpid = -1, vpidtype = -1, pcrpid = -1, tpid = -1, achannel = -1, ac3_delay=-1, pcm_delay=-1;
2204
2205         eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
2206
2207         eDVBServicePMTHandler::program program;
2208         if (h.getProgramInfo(program))
2209                 eDebug("getting program info failed.");
2210         else
2211         {
2212                 eDebugNoNewLine("have %d video stream(s)", program.videoStreams.size());
2213                 if (!program.videoStreams.empty())
2214                 {
2215                         eDebugNoNewLine(" (");
2216                         for (std::vector<eDVBServicePMTHandler::videoStream>::const_iterator
2217                                 i(program.videoStreams.begin());
2218                                 i != program.videoStreams.end(); ++i)
2219                         {
2220                                 if (vpid == -1)
2221                                 {
2222                                         vpid = i->pid;
2223                                         vpidtype = i->type;
2224                                 }
2225                                 if (i != program.videoStreams.begin())
2226                                         eDebugNoNewLine(", ");
2227                                 eDebugNoNewLine("%04x", i->pid);
2228                         }
2229                         eDebugNoNewLine(")");
2230                 }
2231                 eDebugNoNewLine(", and %d audio stream(s)", program.audioStreams.size());
2232                 if (!program.audioStreams.empty())
2233                 {
2234                         eDebugNoNewLine(" (");
2235                         for (std::vector<eDVBServicePMTHandler::audioStream>::const_iterator
2236                                 i(program.audioStreams.begin());
2237                                 i != program.audioStreams.end(); ++i)
2238                         {
2239                                 if (i != program.audioStreams.begin())
2240                                         eDebugNoNewLine(", ");
2241                                 eDebugNoNewLine("%04x", i->pid);
2242                         }
2243                         eDebugNoNewLine(")");
2244                 }
2245                 eDebugNoNewLine(", and the pcr pid is %04x", program.pcrPid);
2246                 pcrpid = program.pcrPid;
2247                 eDebug(", and the text pid is %04x", program.textPid);
2248                 tpid = program.textPid;
2249         }
2250
2251         if (!m_decoder)
2252         {
2253                 h.getDecodeDemux(m_decode_demux);
2254                 if (m_decode_demux)
2255                 {
2256                         m_decode_demux->getMPEGDecoder(m_decoder, m_is_primary);
2257                         if (m_decoder)
2258                                 m_decoder->connectVideoEvent(slot(*this, &eDVBServicePlay::video_event), m_video_event_connection);
2259                         m_teletext_parser = new eDVBTeletextParser(m_decode_demux);
2260                         m_teletext_parser->connectNewPage(slot(*this, &eDVBServicePlay::newSubtitlePage), m_new_subtitle_page_connection);
2261                         m_subtitle_parser = new eDVBSubtitleParser(m_decode_demux);
2262                         m_subtitle_parser->connectNewPage(slot(*this, &eDVBServicePlay::newDVBSubtitlePage), m_new_dvb_subtitle_page_connection);
2263                 } else
2264                 {
2265                         m_teletext_parser = 0;
2266                         m_subtitle_parser = 0;
2267                 }
2268
2269                 if (m_cue)
2270                         m_cue->setDecodingDemux(m_decode_demux, m_decoder);
2271         }
2272
2273         if (m_decoder)
2274         {
2275                 if (m_dvb_service)
2276                 {
2277                         achannel = m_dvb_service->getCacheEntry(eDVBService::cACHANNEL);
2278                         ac3_delay = m_dvb_service->getCacheEntry(eDVBService::cAC3DELAY);
2279                         pcm_delay = m_dvb_service->getCacheEntry(eDVBService::cPCMDELAY);
2280                 }
2281                 else // subservice or recording
2282                 {
2283                         eServiceReferenceDVB ref;
2284                         m_service_handler.getServiceReference(ref);
2285                         eServiceReferenceDVB parent = ref.getParentServiceReference();
2286                         if (!parent)
2287                                 parent = ref;
2288                         if (parent)
2289                         {
2290                                 ePtr<eDVBResourceManager> res_mgr;
2291                                 if (!eDVBResourceManager::getInstance(res_mgr))
2292                                 {
2293                                         ePtr<iDVBChannelList> db;
2294                                         if (!res_mgr->getChannelList(db))
2295                                         {
2296                                                 ePtr<eDVBService> origService;
2297                                                 if (!db->getService(parent, origService))
2298                                                 {
2299                                                         ac3_delay = origService->getCacheEntry(eDVBService::cAC3DELAY);
2300                                                         pcm_delay = origService->getCacheEntry(eDVBService::cPCMDELAY);
2301                                                 }
2302                                         }
2303                                 }
2304                         }
2305                 }
2306                 m_decoder->setAC3Delay(ac3_delay == -1 ? 0 : ac3_delay);
2307                 m_decoder->setPCMDelay(pcm_delay == -1 ? 0 : pcm_delay);
2308
2309                 m_decoder->setVideoPID(vpid, vpidtype);
2310                 selectAudioStream();
2311
2312                 if (!(m_is_pvr || m_timeshift_active || !m_is_primary))
2313                         m_decoder->setSyncPCR(pcrpid);
2314                 else
2315                         m_decoder->setSyncPCR(-1);
2316
2317                 m_decoder->setTextPID(tpid);
2318
2319                 m_teletext_parser->start(program.textPid);
2320
2321                 if (!m_is_primary)
2322                         m_decoder->setTrickmode();
2323
2324                 if (m_is_paused)
2325                         m_decoder->pause();
2326                 else
2327                         m_decoder->play();
2328
2329                 if (vpid > 0 && vpid < 0x2000)
2330                         ;
2331                 else
2332                 {
2333                         std::string radio_pic;
2334                         if (!ePythonConfigQuery::getConfigValue("config.misc.radiopic", radio_pic))
2335                                 m_decoder->setRadioPic(radio_pic);
2336                 }
2337
2338                 m_decoder->setAudioChannel(achannel);
2339
2340                 /* don't worry about non-existing services, nor pvr services */
2341                 if (m_dvb_service && !m_is_pvr)
2342                 {
2343                                 /* (audio pid will be set in selectAudioTrack */
2344                         m_dvb_service->setCacheEntry(eDVBService::cVPID, vpid);
2345                         m_dvb_service->setCacheEntry(eDVBService::cVTYPE, vpidtype == eDVBVideo::MPEG2 ? -1 : vpidtype);
2346                         m_dvb_service->setCacheEntry(eDVBService::cPCRPID, pcrpid);
2347                         m_dvb_service->setCacheEntry(eDVBService::cTPID, tpid);
2348                 }
2349         }       
2350         m_have_video_pid = (vpid > 0 && vpid < 0x2000);
2351 }
2352
2353 void eDVBServicePlay::loadCuesheet()
2354 {
2355         std::string filename = m_reference.path + ".cuts";
2356         
2357         m_cue_entries.clear();
2358
2359         FILE *f = fopen(filename.c_str(), "rb");
2360
2361         if (f)
2362         {
2363                 eDebug("loading cuts..");
2364                 while (1)
2365                 {
2366                         unsigned long long where;
2367                         unsigned int what;
2368                         
2369                         if (!fread(&where, sizeof(where), 1, f))
2370                                 break;
2371                         if (!fread(&what, sizeof(what), 1, f))
2372                                 break;
2373                         
2374 #if BYTE_ORDER == LITTLE_ENDIAN
2375                         where = bswap_64(where);
2376 #endif
2377                         what = ntohl(what);
2378                         
2379                         if (what > 3)
2380                                 break;
2381                         
2382                         m_cue_entries.insert(cueEntry(where, what));
2383                 }
2384                 fclose(f);
2385                 eDebug("%d entries", m_cue_entries.size());
2386         } else
2387                 eDebug("cutfile not found!");
2388         
2389         m_cuesheet_changed = 0;
2390         cutlistToCuesheet();
2391         m_event((iPlayableService*)this, evCuesheetChanged);
2392 }
2393
2394 void eDVBServicePlay::saveCuesheet()
2395 {
2396         std::string filename = m_reference.path + ".cuts";
2397         
2398         FILE *f = fopen(filename.c_str(), "wb");
2399
2400         if (f)
2401         {
2402                 unsigned long long where;
2403                 int what;
2404
2405                 for (std::multiset<cueEntry>::iterator i(m_cue_entries.begin()); i != m_cue_entries.end(); ++i)
2406                 {
2407 #if BYTE_ORDER == BIG_ENDIAN
2408                         where = i->where;
2409 #else
2410                         where = bswap_64(i->where);
2411 #endif
2412                         what = htonl(i->what);
2413                         fwrite(&where, sizeof(where), 1, f);
2414                         fwrite(&what, sizeof(what), 1, f);
2415                         
2416                 }
2417                 fclose(f);
2418         }
2419         
2420         m_cuesheet_changed = 0;
2421 }
2422
2423 void eDVBServicePlay::cutlistToCuesheet()
2424 {
2425         if (!m_cue)
2426         {
2427                 eDebug("no cue sheet");
2428                 return;
2429         }       
2430         m_cue->clear();
2431         
2432         if (!m_cutlist_enabled)
2433         {
2434                 m_cue->commitSpans();
2435                 eDebug("cutlists were disabled");
2436                 return;
2437         }
2438
2439         pts_t in = 0, out = 0, length = 0;
2440         
2441         getLength(length);
2442                 
2443         std::multiset<cueEntry>::iterator i(m_cue_entries.begin());
2444         
2445         while (1)
2446         {
2447                 if (i == m_cue_entries.end())
2448                         out = length;
2449                 else {
2450                         if (i->what == 0) /* in */
2451                         {
2452                                 in = i++->where;
2453                                 continue;
2454                         } else if (i->what == 1) /* out */
2455                                 out = i++->where;
2456                         else /* mark (2) or last play position (3) */
2457                         {
2458                                 i++;
2459                                 continue;
2460                         }
2461                 }
2462                 
2463                 if (in < 0)
2464                         in = 0;
2465                 if (out < 0)
2466                         out = 0;
2467                 if (in > length)
2468                         in = length;
2469                 if (out > length)
2470                         out = length;
2471                 
2472                 if (in < out)
2473                         m_cue->addSourceSpan(in, out);
2474                 
2475                 in = length;
2476                 
2477                 if (i == m_cue_entries.end())
2478                         break;
2479         }
2480         m_cue->commitSpans();
2481 }
2482
2483 RESULT eDVBServicePlay::enableSubtitles(eWidget *parent, ePyObject tuple)
2484 {
2485         if (m_subtitle_widget)
2486                 disableSubtitles(parent);
2487
2488         ePyObject entry;
2489         int tuplesize = PyTuple_Size(tuple);
2490         int type = 0;
2491
2492         if (!PyTuple_Check(tuple))
2493                 goto error_out;
2494
2495         if (tuplesize < 1)
2496                 goto error_out;
2497
2498         entry = PyTuple_GET_ITEM(tuple, 0);
2499
2500         if (!PyInt_Check(entry))
2501                 goto error_out;
2502
2503         type = PyInt_AsLong(entry);
2504
2505         if (type == 1)  // teletext subtitles
2506         {
2507                 int page, magazine, pid;
2508                 if (tuplesize < 4)
2509                         goto error_out;
2510
2511                 if (!m_teletext_parser)
2512                 {
2513                         eDebug("enable teletext subtitles.. no parser !!!");
2514                         return -1;
2515                 }
2516
2517                 entry = PyTuple_GET_ITEM(tuple, 1);
2518                 if (!PyInt_Check(entry))
2519                         goto error_out;
2520                 pid = PyInt_AsLong(entry);
2521
2522                 entry = PyTuple_GET_ITEM(tuple, 2);
2523                 if (!PyInt_Check(entry))
2524                         goto error_out;
2525                 page = PyInt_AsLong(entry);
2526
2527                 entry = PyTuple_GET_ITEM(tuple, 3);
2528                 if (!PyInt_Check(entry))
2529                         goto error_out;
2530                 magazine = PyInt_AsLong(entry);
2531
2532                 m_subtitle_widget = new eSubtitleWidget(parent);
2533                 m_subtitle_widget->resize(parent->size()); /* full size */
2534                 m_teletext_parser->setPageAndMagazine(page, magazine);
2535                 if (m_dvb_service)
2536                         m_dvb_service->setCacheEntry(eDVBService::cSUBTITLE,((pid&0xFFFF)<<16)|((page&0xFF)<<8)|(magazine&0xFF));
2537         }
2538         else if (type == 0)
2539         {
2540                 int pid = 0, composition_page_id = 0, ancillary_page_id = 0;
2541                 if (!m_subtitle_parser)
2542                 {
2543                         eDebug("enable dvb subtitles.. no parser !!!");
2544                         return -1;
2545                 }
2546                 if (tuplesize < 4)
2547                         goto error_out;
2548
2549                 entry = PyTuple_GET_ITEM(tuple, 1);
2550                 if (!PyInt_Check(entry))
2551                         goto error_out;
2552                 pid = PyInt_AsLong(entry);
2553
2554                 entry = PyTuple_GET_ITEM(tuple, 2);
2555                 if (!PyInt_Check(entry))
2556                         goto error_out;
2557                 composition_page_id = PyInt_AsLong(entry);
2558
2559                 entry = PyTuple_GET_ITEM(tuple, 3);
2560                 if (!PyInt_Check(entry))
2561                         goto error_out;
2562                 ancillary_page_id = PyInt_AsLong(entry);
2563
2564                 m_subtitle_widget = new eSubtitleWidget(parent);
2565                 m_subtitle_widget->resize(parent->size()); /* full size */
2566                 m_subtitle_parser->start(pid, composition_page_id, ancillary_page_id);
2567                 if (m_dvb_service)
2568                         m_dvb_service->setCacheEntry(eDVBService::cSUBTITLE, ((pid&0xFFFF)<<16)|((composition_page_id&0xFF)<<8)|(ancillary_page_id&0xFF));
2569         }
2570         else
2571                 goto error_out;
2572         return 0;
2573 error_out:
2574         eDebug("enableSubtitles needs a tuple as 2nd argument!\n"
2575                 "for teletext subtitles (0, pid, teletext_page, teletext_magazine)\n"
2576                 "for dvb subtitles (1, pid, composition_page_id, ancillary_page_id)");
2577         return -1;
2578 }
2579
2580 RESULT eDVBServicePlay::disableSubtitles(eWidget *parent)
2581 {
2582         delete m_subtitle_widget;
2583         m_subtitle_widget = 0;
2584         if (m_subtitle_parser)
2585         {
2586                 m_subtitle_parser->stop();
2587                 m_dvb_subtitle_pages.clear();
2588         }
2589         if (m_teletext_parser)
2590         {
2591                 m_teletext_parser->setPageAndMagazine(-1, -1);
2592                 m_subtitle_pages.clear();
2593         }
2594         if (m_dvb_service)
2595                 m_dvb_service->setCacheEntry(eDVBService::cSUBTITLE, -1);
2596         return 0;
2597 }
2598
2599 PyObject *eDVBServicePlay::getCachedSubtitle()
2600 {
2601         if (m_dvb_service)
2602         {
2603                 int tmp = m_dvb_service->getCacheEntry(eDVBService::cSUBTITLE);
2604                 if (tmp != -1)
2605                 {
2606                         unsigned int data = (unsigned int)tmp;
2607                         int pid = (data&0xFFFF0000)>>16;
2608                         ePyObject tuple = PyTuple_New(4);
2609                         eDVBServicePMTHandler::program program;
2610                         eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
2611                         if (!h.getProgramInfo(program))
2612                         {
2613                                 if (program.textPid==pid) // teletext
2614                                         PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(1)); // type teletext
2615                                 else
2616                                         PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(0)); // type dvb
2617                                 PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong((data&0xFFFF0000)>>16)); // pid
2618                                 PyTuple_SET_ITEM(tuple, 2, PyInt_FromLong((data&0xFF00)>>8)); // composition_page / page
2619                                 PyTuple_SET_ITEM(tuple, 3, PyInt_FromLong(data&0xFF)); // ancillary_page / magazine
2620                                 return tuple;
2621                         }
2622                 }
2623         }
2624         Py_RETURN_NONE;
2625 }
2626
2627 PyObject *eDVBServicePlay::getSubtitleList()
2628 {
2629         if (!m_teletext_parser)
2630                 Py_RETURN_NONE;
2631         
2632         ePyObject l = PyList_New(0);
2633         std::set<int> added_ttx_pages;
2634
2635         std::set<eDVBServicePMTHandler::subtitleStream> &subs =
2636                 m_teletext_parser->m_found_subtitle_pages;
2637
2638         eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
2639         eDVBServicePMTHandler::program program;
2640         if (h.getProgramInfo(program))
2641                 eDebug("getting program info failed.");
2642         else
2643         {
2644                 for (std::vector<eDVBServicePMTHandler::subtitleStream>::iterator it(program.subtitleStreams.begin());
2645                         it != program.subtitleStreams.end(); ++it)
2646                 {
2647                         switch(it->subtitling_type)
2648                         {
2649                                 case 0x01: // ebu teletext subtitles
2650                                 {
2651                                         int page_number = it->teletext_page_number & 0xFF;
2652                                         int magazine_number = it->teletext_magazine_number & 7;
2653                                         int hash = magazine_number << 8 | page_number;
2654                                         if (added_ttx_pages.find(hash) == added_ttx_pages.end())
2655                                         {
2656                                                 ePyObject tuple = PyTuple_New(5);
2657                                                 PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(1));
2658                                                 PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(it->pid));
2659                                                 PyTuple_SET_ITEM(tuple, 2, PyInt_FromLong(page_number));
2660                                                 PyTuple_SET_ITEM(tuple, 3, PyInt_FromLong(magazine_number));
2661                                                 PyTuple_SET_ITEM(tuple, 4, PyString_FromString(it->language_code.c_str()));
2662                                                 PyList_Append(l, tuple);
2663                                                 Py_DECREF(tuple);
2664                                                 added_ttx_pages.insert(hash);
2665                                         }
2666                                         break;
2667                                 }
2668                                 case 0x10 ... 0x13:
2669                                 case 0x20 ... 0x23: // dvb subtitles
2670                                 {
2671                                         ePyObject tuple = PyTuple_New(5);
2672                                         PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(0));
2673                                         PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(it->pid));
2674                                         PyTuple_SET_ITEM(tuple, 2, PyInt_FromLong(it->composition_page_id));
2675                                         PyTuple_SET_ITEM(tuple, 3, PyInt_FromLong(it->ancillary_page_id));
2676                                         PyTuple_SET_ITEM(tuple, 4, PyString_FromString(it->language_code.c_str()));
2677                                         PyList_Insert(l, 0, tuple);
2678                                         Py_DECREF(tuple);
2679                                         break;
2680                                 }
2681                         }
2682                 }
2683         }
2684
2685         for (std::set<eDVBServicePMTHandler::subtitleStream>::iterator it(subs.begin());
2686                 it != subs.end(); ++it)
2687         {
2688                 int page_number = it->teletext_page_number & 0xFF;
2689                 int magazine_number = it->teletext_magazine_number & 7;
2690                 int hash = magazine_number << 8 | page_number;
2691                 if (added_ttx_pages.find(hash) == added_ttx_pages.end())
2692                 {
2693                         ePyObject tuple = PyTuple_New(5);
2694                         PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(1));
2695                         PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(it->pid));
2696                         PyTuple_SET_ITEM(tuple, 2, PyInt_FromLong(page_number));
2697                         PyTuple_SET_ITEM(tuple, 3, PyInt_FromLong(magazine_number));
2698                         PyTuple_SET_ITEM(tuple, 4, PyString_FromString("und"));  // undetermined
2699                         PyList_Append(l, tuple);
2700                         Py_DECREF(tuple);
2701                 }
2702         }
2703
2704         return l;
2705 }
2706
2707 void eDVBServicePlay::newSubtitlePage(const eDVBTeletextSubtitlePage &page)
2708 {
2709         if (m_subtitle_widget)
2710         {
2711                 pts_t pos = 0;
2712                 if (m_decoder)
2713                         m_decoder->getPTS(0, pos);
2714                 eDebug("got new subtitle page %lld %lld %d", pos, page.m_pts, page.m_have_pts);
2715                 m_subtitle_pages.push_back(page);
2716                 checkSubtitleTiming();
2717         }
2718 }
2719
2720 void eDVBServicePlay::checkSubtitleTiming()
2721 {
2722         eDebug("checkSubtitleTiming");
2723         if (!m_subtitle_widget)
2724                 return;
2725         while (1)
2726         {
2727                 enum { TELETEXT, DVB } type;
2728                 eDVBTeletextSubtitlePage page;
2729                 eDVBSubtitlePage dvb_page;
2730                 pts_t show_time;
2731                 if (!m_subtitle_pages.empty())
2732                 {
2733                         page = m_subtitle_pages.front();
2734                         type = TELETEXT;
2735                         show_time = page.m_pts;
2736                 }
2737                 else if (!m_dvb_subtitle_pages.empty())
2738                 {
2739                         dvb_page = m_dvb_subtitle_pages.front();
2740                         type = DVB;
2741                         show_time = dvb_page.m_show_time;
2742                 }
2743                 else
2744                         return;
2745         
2746                 pts_t pos = 0;
2747         
2748                 if (m_decoder)
2749                         m_decoder->getPTS(0, pos);
2750
2751                 eDebug("%lld %lld", pos, show_time);
2752                 int diff =  show_time - pos;
2753                 if (diff < 0)
2754                 {
2755                         eDebug("[late (%d ms)]", -diff / 90);
2756                         diff = 0;
2757                 }
2758 //              if (diff > 900000)
2759 //              {
2760 //                      eDebug("[invalid]");
2761 //                      diff = 0;
2762 //              }
2763         
2764                 if ((diff/90)<20)
2765                 {
2766                         if (type == TELETEXT)
2767                         {
2768                                 eDebug("display teletext subtitle page %lld", show_time);
2769                                 m_subtitle_widget->setPage(page);
2770                                 m_subtitle_pages.pop_front();
2771                         }
2772                         else
2773                         {
2774                                 eDebug("display dvb subtitle Page %lld", show_time);
2775                                 m_subtitle_widget->setPage(dvb_page);
2776                                 m_dvb_subtitle_pages.pop_front();
2777                         }
2778                 } else
2779                 {
2780                         eDebug("start subtitle delay %d", diff / 90);
2781                         m_subtitle_sync_timer->start(diff / 90, 1);
2782                         break;
2783                 }
2784         }
2785 }
2786
2787 void eDVBServicePlay::newDVBSubtitlePage(const eDVBSubtitlePage &p)
2788 {
2789         if (m_subtitle_widget)
2790         {
2791                 pts_t pos = 0;
2792                 if (m_decoder)
2793                         m_decoder->getPTS(0, pos);
2794                 eDebug("got new subtitle page %lld %lld", pos, p.m_show_time);
2795                 m_dvb_subtitle_pages.push_back(p);
2796                 checkSubtitleTiming();
2797         }
2798 }
2799
2800 int eDVBServicePlay::getAC3Delay()
2801 {
2802         if (m_dvb_service)
2803                 return m_dvb_service->getCacheEntry(eDVBService::cAC3DELAY);
2804         else if (m_decoder)
2805                 return m_decoder->getAC3Delay();
2806         else
2807                 return 0;
2808 }
2809
2810 int eDVBServicePlay::getPCMDelay()
2811 {
2812         if (m_dvb_service)
2813                 return m_dvb_service->getCacheEntry(eDVBService::cPCMDELAY);
2814         else if (m_decoder)
2815                 return m_decoder->getPCMDelay();
2816         else
2817                 return 0;
2818 }
2819
2820 void eDVBServicePlay::setAC3Delay(int delay)
2821 {
2822         if (m_dvb_service)
2823                 m_dvb_service->setCacheEntry(eDVBService::cAC3DELAY, delay ? delay : -1);
2824         if (m_decoder)
2825                 m_decoder->setAC3Delay(delay);
2826 }
2827
2828 void eDVBServicePlay::setPCMDelay(int delay)
2829 {
2830         if (m_dvb_service)
2831                 m_dvb_service->setCacheEntry(eDVBService::cPCMDELAY, delay ? delay : -1);
2832         if (m_decoder)
2833                 m_decoder->setPCMDelay(delay);
2834 }
2835
2836 void eDVBServicePlay::video_event(struct iTSMPEGDecoder::videoEvent event)
2837 {
2838         switch(event.type) {
2839                 case iTSMPEGDecoder::videoEvent::eventSizeChanged:
2840                         m_event((iPlayableService*)this, evVideoSizeChanged);
2841                         break;
2842                 case iTSMPEGDecoder::videoEvent::eventFrameRateChanged:
2843                         m_event((iPlayableService*)this, evVideoFramerateChanged);
2844                         break;
2845                 case iTSMPEGDecoder::videoEvent::eventProgressiveChanged:
2846                         m_event((iPlayableService*)this, evVideoProgressiveChanged);
2847                         break;
2848                 default:
2849                         break;
2850         }
2851 }
2852
2853 RESULT eDVBServicePlay::stream(ePtr<iStreamableService> &ptr)
2854 {
2855         ptr = this;
2856         return 0;
2857 }
2858
2859 PyObject *eDVBServicePlay::getStreamingData()
2860 {
2861         eDVBServicePMTHandler::program program;
2862         if (m_service_handler.getProgramInfo(program))
2863         {
2864                 Py_RETURN_NONE;
2865         }
2866
2867         ePyObject r = program.createPythonObject();
2868         ePtr<iDVBDemux> demux;
2869         if (!m_service_handler.getDataDemux(demux))
2870         {
2871                 uint8_t demux_id;
2872                 if (!demux->getCADemuxID(demux_id))
2873                         PutToDict(r, "demux", demux_id);
2874         }
2875
2876         return r;
2877 }
2878
2879
2880 DEFINE_REF(eDVBServicePlay)
2881
2882 PyObject *eDVBService::getInfoObject(const eServiceReference &ref, int w)
2883 {
2884         switch (w)
2885         {
2886         case iServiceInformation::sTransponderData:
2887                 return eStaticServiceDVBInformation().getInfoObject(ref, w);
2888         default:
2889                 break;
2890         }
2891         return iStaticServiceInformation::getInfoObject(ref, w);
2892 }
2893
2894 eAutoInitPtr<eServiceFactoryDVB> init_eServiceFactoryDVB(eAutoInitNumbers::service+1, "eServiceFactoryDVB");