1 #include <lib/base/eerror.h>
2 #include <lib/base/object.h>
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>
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
22 #include <lib/gui/esubtitle.h>
28 #include <netinet/in.h>
31 #error no byte order defined!
34 class eStaticServiceDVBInformation: public iStaticServiceInformation
36 DECLARE_REF(eStaticServiceDVBInformation);
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);
44 DEFINE_REF(eStaticServiceDVBInformation);
46 RESULT eStaticServiceDVBInformation::getName(const eServiceReference &ref, std::string &name)
48 eServiceReferenceDVB &service = (eServiceReferenceDVB&)ref;
49 if ( !ref.name.empty() )
51 if (service.getParentTransportStreamID().get()) // linkage subservice
53 ePtr<iServiceHandler> service_center;
54 if (!eServiceCenter::getInstance(service_center))
56 eServiceReferenceDVB parent = service;
57 parent.setTransportStreamID( service.getParentTransportStreamID() );
58 parent.setServiceID( service.getParentServiceID() );
59 parent.setParentTransportStreamID(eTransportStreamID(0));
60 parent.setParentServiceID(eServiceID(0));
62 ePtr<iStaticServiceInformation> service_info;
63 if (!service_center->info(parent, service_info))
65 if (!service_info->getName(parent, name))
66 name=buildShortName(name) + " - ";
79 int eStaticServiceDVBInformation::getLength(const eServiceReference &ref)
84 int eStaticServiceDVBInformation::isPlayable(const eServiceReference &ref, const eServiceReference &ignore)
86 ePtr<eDVBResourceManager> res_mgr;
87 if ( eDVBResourceManager::getInstance( res_mgr ) )
88 eDebug("isPlayable... no res manager!!");
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);
99 extern void PutToDict(ePyObject &dict, const char*key, long value); // defined in dvb/frontend.cpp
100 extern void PutSatelliteDataToDict(ePyObject &dict, eDVBFrontendParametersSatellite &feparm); // defined in dvb/frontend.cpp
101 extern void PutTerrestrialDataToDict(ePyObject &dict, eDVBFrontendParametersTerrestrial &feparm); // defined in dvb/frontend.cpp
102 extern void PutCableDataToDict(ePyObject &dict, eDVBFrontendParametersCable &feparm); // defined in dvb/frontend.cpp
104 PyObject *eStaticServiceDVBInformation::getInfoObject(const eServiceReference &r, int what)
106 if (r.type == eServiceReference::idDVB)
108 const eServiceReferenceDVB &ref = (const eServiceReferenceDVB&)r;
111 case iServiceInformation::sTransponderData:
113 ePtr<eDVBResourceManager> res;
114 if (!eDVBResourceManager::getInstance(res))
116 ePtr<iDVBChannelList> db;
117 if (!res->getChannelList(db))
120 ref.getChannelID(chid);
121 ePtr<iDVBFrontendParameters> feparm;
122 if (!db->getChannelFrontendData(chid, feparm))
125 if (!feparm->getSystem(system))
127 ePyObject dict = PyDict_New();
130 case iDVBFrontend::feSatellite:
132 eDVBFrontendParametersSatellite s;
134 PutSatelliteDataToDict(dict, s);
137 case iDVBFrontend::feTerrestrial:
139 eDVBFrontendParametersTerrestrial t;
141 PutTerrestrialDataToDict(dict, t);
144 case iDVBFrontend::feCable:
146 eDVBFrontendParametersCable c;
148 PutCableDataToDict(dict, c);
152 eDebug("unknown frontend type %d", system);
167 DEFINE_REF(eStaticServiceDVBBouquetInformation);
169 RESULT eStaticServiceDVBBouquetInformation::getName(const eServiceReference &ref, std::string &name)
171 ePtr<iDVBChannelList> db;
172 ePtr<eDVBResourceManager> res;
175 if ((err = eDVBResourceManager::getInstance(res)) != 0)
177 eDebug("eStaticServiceDVBBouquetInformation::getName failed.. no resource manager!");
180 if ((err = res->getChannelList(db)) != 0)
182 eDebug("eStaticServiceDVBBouquetInformation::getName failed.. no channel list!");
187 if ((err = db->getBouquet(ref, bouquet)) != 0)
189 eDebug("eStaticServiceDVBBouquetInformation::getName failed.. getBouquet failed!");
193 if ( bouquet && bouquet->m_bouquet_name.length() )
195 name = bouquet->m_bouquet_name;
202 int eStaticServiceDVBBouquetInformation::isPlayable(const eServiceReference &ref, const eServiceReference &ignore, bool simulate)
204 if (ref.flags & eServiceReference::isGroup)
206 ePtr<iDVBChannelList> db;
207 ePtr<eDVBResourceManager> res;
209 if (eDVBResourceManager::getInstance(res))
211 eDebug("eStaticServiceDVBBouquetInformation::isPlayable failed.. no resource manager!");
215 if (res->getChannelList(db))
217 eDebug("eStaticServiceDVBBouquetInformation::isPlayable failed.. no channel list!");
222 if (db->getBouquet(ref, bouquet))
224 eDebug("eStaticServiceDVBBouquetInformation::isPlayable failed.. getBouquet failed!");
228 int prio_order = eDVBFrontend::getTypePriorityOrder();
230 eDVBChannelID chid, chid_ignore;
231 ((const eServiceReferenceDVB&)ignore).getChannelID(chid_ignore);
232 for (std::list<eServiceReference>::iterator it(bouquet->m_services.begin()); it != bouquet->m_services.end(); ++it)
234 static unsigned char prio_map[6][3] = {
235 { 3, 2, 1 }, // -S -C -T
236 { 3, 1, 2 }, // -S -T -C
237 { 2, 3, 1 }, // -C -S -T
238 { 1, 3, 2 }, // -C -T -S
239 { 1, 2, 3 }, // -T -C -S
240 { 2, 1, 3 } // -T -S -C
242 ((const eServiceReferenceDVB&)*it).getChannelID(chid);
243 int tmp=res->canAllocateChannel(chid, chid_ignore, simulate);
248 case 30000: // cached DVB-T channel
249 case 1: // DVB-T frontend
250 tmp = prio_map[prio_order][2];
252 case 40000: // cached DVB-C channel
254 tmp = prio_map[prio_order][1];
257 tmp = prio_map[prio_order][0];
262 m_playable_service = *it;
269 m_playable_service = eServiceReference();
273 int eStaticServiceDVBBouquetInformation::getLength(const eServiceReference &ref)
278 #include <lib/dvb/epgcache.h>
280 RESULT eStaticServiceDVBBouquetInformation::getEvent(const eServiceReference &ref, ePtr<eServiceEvent> &ptr, time_t start_time)
282 return eEPGCache::getInstance()->lookupEventTime(ref, start_time, ptr);
285 class eStaticServiceDVBPVRInformation: public iStaticServiceInformation
287 DECLARE_REF(eStaticServiceDVBPVRInformation);
288 eServiceReference m_ref;
289 eDVBMetaParser m_parser;
291 eStaticServiceDVBPVRInformation(const eServiceReference &ref);
292 RESULT getName(const eServiceReference &ref, std::string &name);
293 int getLength(const eServiceReference &ref);
294 RESULT getEvent(const eServiceReference &ref, ePtr<eServiceEvent> &SWIG_OUTPUT, time_t start_time);
295 int isPlayable(const eServiceReference &ref, const eServiceReference &ignore) { return 1; }
296 int getInfo(const eServiceReference &ref, int w);
297 std::string getInfoString(const eServiceReference &ref,int w);
298 PyObject *getInfoObject(const eServiceReference &r, int what);
301 DEFINE_REF(eStaticServiceDVBPVRInformation);
303 eStaticServiceDVBPVRInformation::eStaticServiceDVBPVRInformation(const eServiceReference &ref)
306 m_parser.parseFile(ref.path);
309 RESULT eStaticServiceDVBPVRInformation::getName(const eServiceReference &ref, std::string &name)
311 ASSERT(ref == m_ref);
312 if (!ref.name.empty())
314 else if (!m_parser.m_name.empty())
315 name = m_parser.m_name;
319 size_t n = name.rfind('/');
320 if (n != std::string::npos)
321 name = name.substr(n + 1);
326 int eStaticServiceDVBPVRInformation::getLength(const eServiceReference &ref)
328 ASSERT(ref == m_ref);
333 stat(ref.path.c_str(), &s);
335 if (tstools.openFile(ref.path.c_str(), 1))
338 /* check if cached data is still valid */
339 if (m_parser.m_data_ok && (s.st_size == m_parser.m_filesize) && (m_parser.m_length))
340 return m_parser.m_length / 90000;
342 /* open again, this time with stream info */
343 if (tstools.openFile(ref.path.c_str()))
346 /* otherwise, re-calc length and update meta file */
348 if (tstools.calcLen(len))
351 m_parser.m_length = len;
352 m_parser.m_filesize = s.st_size;
353 m_parser.updateMeta(ref.path);
354 return m_parser.m_length / 90000;
357 int eStaticServiceDVBPVRInformation::getInfo(const eServiceReference &ref, int w)
361 case iServiceInformation::sDescription:
362 return iServiceInformation::resIsString;
363 case iServiceInformation::sServiceref:
364 return iServiceInformation::resIsString;
365 case iServiceInformation::sFileSize:
366 return m_parser.m_filesize;
367 case iServiceInformation::sTimeCreate:
368 if (m_parser.m_time_create)
369 return m_parser.m_time_create;
371 return iServiceInformation::resNA;
373 return iServiceInformation::resNA;
377 std::string eStaticServiceDVBPVRInformation::getInfoString(const eServiceReference &ref,int w)
381 case iServiceInformation::sDescription:
382 return m_parser.m_description;
383 case iServiceInformation::sServiceref:
384 return m_parser.m_ref.toString();
385 case iServiceInformation::sTags:
386 return m_parser.m_tags;
392 PyObject *eStaticServiceDVBPVRInformation::getInfoObject(const eServiceReference &r, int what)
396 case iServiceInformation::sFileSize:
397 return PyLong_FromLongLong(m_parser.m_filesize);
403 RESULT eStaticServiceDVBPVRInformation::getEvent(const eServiceReference &ref, ePtr<eServiceEvent> &evt, time_t start_time)
405 if (!ref.path.empty())
407 ePtr<eServiceEvent> event = new eServiceEvent;
408 std::string filename = ref.path;
409 filename.erase(filename.length()-2, 2);
411 if (!event->parseFrom(filename, (m_parser.m_ref.getTransportStreamID().get()<<16)|m_parser.m_ref.getOriginalNetworkID().get()))
421 class eDVBPVRServiceOfflineOperations: public iServiceOfflineOperations
423 DECLARE_REF(eDVBPVRServiceOfflineOperations);
424 eServiceReferenceDVB m_ref;
426 eDVBPVRServiceOfflineOperations(const eServiceReference &ref);
428 RESULT deleteFromDisk(int simulate);
429 RESULT getListOfFilenames(std::list<std::string> &);
433 DEFINE_REF(eDVBPVRServiceOfflineOperations);
435 eDVBPVRServiceOfflineOperations::eDVBPVRServiceOfflineOperations(const eServiceReference &ref): m_ref((const eServiceReferenceDVB&)ref)
439 RESULT eDVBPVRServiceOfflineOperations::deleteFromDisk(int simulate)
445 std::list<std::string> res;
446 if (getListOfFilenames(res))
449 eBackgroundFileEraser *eraser = eBackgroundFileEraser::getInstance();
451 eDebug("FATAL !! can't get background file eraser");
453 for (std::list<std::string>::iterator i(res.begin()); i != res.end(); ++i)
455 eDebug("Removing %s...", i->c_str());
457 eraser->erase(i->c_str());
459 ::unlink(i->c_str());
466 RESULT eDVBPVRServiceOfflineOperations::getListOfFilenames(std::list<std::string> &res)
469 res.push_back(m_ref.path);
471 // handling for old splitted recordings (enigma 1)
476 snprintf(buf, 255, "%s.%03d", m_ref.path.c_str(), slice++);
478 if (stat(buf, &s) < 0)
483 res.push_back(m_ref.path + ".meta");
484 res.push_back(m_ref.path + ".ap");
485 res.push_back(m_ref.path + ".sc");
486 res.push_back(m_ref.path + ".cuts");
487 std::string tmp = m_ref.path;
488 tmp.erase(m_ref.path.length()-3);
489 res.push_back(tmp + ".eit");
493 RESULT eDVBPVRServiceOfflineOperations::reindex()
495 const char *filename = m_ref.path.c_str();
496 eDebug("reindexing %s...", filename);
498 eMPEGStreamInformation info;
499 eMPEGStreamParserTS parser(info);
501 info.startSave(filename);
505 int err = f.open(m_ref.path.c_str(), 0);
510 off_t length = f.length();
511 unsigned char buffer[188*256*4];
514 eDebug("at %08llx / %08llx (%d %%)", offset, length, (int)(offset * 100 / length));
515 int r = f.read(offset, buffer, sizeof(buffer));
521 parser.parseData(offset, buffer, r);
530 DEFINE_REF(eServiceFactoryDVB)
532 eServiceFactoryDVB::eServiceFactoryDVB()
534 ePtr<eServiceCenter> sc;
536 eServiceCenter::getPrivInstance(sc);
539 std::list<std::string> extensions;
540 extensions.push_back("ts");
541 extensions.push_back("trp");
542 sc->addServiceFactory(eServiceFactoryDVB::id, this, extensions);
545 m_StaticServiceDVBInfo = new eStaticServiceDVBInformation;
546 m_StaticServiceDVBBouquetInfo = new eStaticServiceDVBBouquetInformation;
549 eServiceFactoryDVB::~eServiceFactoryDVB()
551 ePtr<eServiceCenter> sc;
553 eServiceCenter::getPrivInstance(sc);
555 sc->removeServiceFactory(eServiceFactoryDVB::id);
558 DEFINE_REF(eDVBServiceList);
560 eDVBServiceList::eDVBServiceList(const eServiceReference &parent): m_parent(parent)
564 eDVBServiceList::~eDVBServiceList()
568 RESULT eDVBServiceList::startQuery()
570 ePtr<iDVBChannelList> db;
571 ePtr<eDVBResourceManager> res;
574 if ((err = eDVBResourceManager::getInstance(res)) != 0)
576 eDebug("no resource manager");
579 if ((err = res->getChannelList(db)) != 0)
581 eDebug("no channel list");
585 ePtr<eDVBChannelQuery> q;
587 if (!m_parent.path.empty())
589 eDVBChannelQuery::compile(q, m_parent.path);
592 eDebug("compile query failed");
597 if ((err = db->startQuery(m_query, q, m_parent)) != 0)
599 eDebug("startQuery failed");
606 RESULT eDVBServiceList::getContent(std::list<eServiceReference> &list, bool sorted)
608 eServiceReferenceDVB ref;
613 while (!m_query->getNextResult(ref))
617 list.sort(iListableServiceCompare(this));
622 // The first argument of this function is a format string to specify the order and
623 // the content of the returned list
624 // useable format options are
625 // R = Service Reference (as swig object .. this is very slow)
626 // S = Service Reference (as python string object .. same as ref.toString())
627 // C = Service Reference (as python string object .. same as ref.toCompareString())
628 // N = Service Name (as python string object)
629 // n = Short Service Name (short name brakets used) (as python string object)
630 // when exactly one return value per service is selected in the format string,
631 // then each value is directly a list entry
632 // when more than one value is returned per service, then the list is a list of
634 // unknown format string chars are returned as python None values !
635 PyObject *eDVBServiceList::getContent(const char* format, bool sorted)
638 std::list<eServiceReference> tmplist;
641 if (!format || !(retcount=strlen(format)))
642 format = "R"; // just return service reference swig object ...
644 if (!getContent(tmplist, sorted))
646 int services=tmplist.size();
647 ePtr<iStaticServiceInformation> sptr;
648 eServiceCenterPtr service_center;
650 if (strchr(format, 'N') || strchr(format, 'n'))
651 eServiceCenter::getPrivInstance(service_center);
653 ret = PyList_New(services);
654 std::list<eServiceReference>::iterator it(tmplist.begin());
656 for (int cnt=0; cnt < services; ++cnt)
658 eServiceReference &ref=*it++;
659 ePyObject tuple = retcount > 1 ? PyTuple_New(retcount) : ePyObject();
660 for (int i=0; i < retcount; ++i)
665 case 'R': // service reference (swig)object
666 tmp = NEW_eServiceReference(ref);
668 case 'C': // service reference compare string
669 tmp = PyString_FromString(ref.toCompareString().c_str());
671 case 'S': // service reference string
672 tmp = PyString_FromString(ref.toString().c_str());
674 case 'N': // service name
677 service_center->info(ref, sptr);
681 sptr->getName(ref, name);
683 // filter short name brakets
685 while((pos = name.find("\xc2\x86")) != std::string::npos)
687 while((pos = name.find("\xc2\x87")) != std::string::npos)
691 tmp = PyString_FromString(name.c_str());
695 tmp = PyString_FromString("<n/a>");
697 case 'n': // short service name
700 service_center->info(ref, sptr);
704 sptr->getName(ref, name);
705 name = buildShortName(name);
707 tmp = PyString_FromString(name.c_str());
711 tmp = PyString_FromString("<n/a>");
724 PyTuple_SET_ITEM(tuple, i, tmp);
726 PyList_SET_ITEM(ret, cnt, tmp);
730 PyList_SET_ITEM(ret, cnt, tuple);
733 return ret ? (PyObject*)ret : (PyObject*)PyList_New(0);
736 RESULT eDVBServiceList::getNext(eServiceReference &ref)
741 return m_query->getNextResult((eServiceReferenceDVB&)ref);
744 RESULT eDVBServiceList::startEdit(ePtr<iMutableServiceList> &res)
746 if (m_parent.flags & eServiceReference::canDescent) // bouquet
748 ePtr<iDVBChannelList> db;
749 ePtr<eDVBResourceManager> resm;
751 if (eDVBResourceManager::getInstance(resm) || resm->getChannelList(db))
754 if (db->getBouquet(m_parent, m_bouquet) != 0)
765 RESULT eDVBServiceList::addService(eServiceReference &ref, eServiceReference before)
769 return m_bouquet->addService(ref, before);
772 RESULT eDVBServiceList::removeService(eServiceReference &ref)
776 return m_bouquet->removeService(ref);
779 RESULT eDVBServiceList::moveService(eServiceReference &ref, int pos)
783 return m_bouquet->moveService(ref, pos);
786 RESULT eDVBServiceList::flushChanges()
790 return m_bouquet->flushChanges();
793 RESULT eDVBServiceList::setListName(const std::string &name)
797 return m_bouquet->setListName(name);
800 RESULT eServiceFactoryDVB::play(const eServiceReference &ref, ePtr<iPlayableService> &ptr)
802 ePtr<eDVBService> service;
803 int r = lookupService(service, ref);
806 // check resources...
807 ptr = new eDVBServicePlay(ref, service);
811 RESULT eServiceFactoryDVB::record(const eServiceReference &ref, ePtr<iRecordableService> &ptr)
813 if (ref.path.empty())
815 ptr = new eDVBServiceRecord((eServiceReferenceDVB&)ref);
824 RESULT eServiceFactoryDVB::list(const eServiceReference &ref, ePtr<iListableService> &ptr)
826 ePtr<eDVBServiceList> list = new eDVBServiceList(ref);
827 if (list->startQuery())
837 RESULT eServiceFactoryDVB::info(const eServiceReference &ref, ePtr<iStaticServiceInformation> &ptr)
839 /* is a listable service? */
840 if (ref.flags & eServiceReference::canDescent) // bouquet
842 if ( !ref.name.empty() ) // satellites or providers list
843 ptr = m_StaticServiceDVBInfo;
844 else // a dvb bouquet
845 ptr = m_StaticServiceDVBBouquetInfo;
847 else if (!ref.path.empty()) /* do we have a PVR service? */
848 ptr = new eStaticServiceDVBPVRInformation(ref);
849 else // normal dvb service
851 ePtr<eDVBService> service;
852 if (lookupService(service, ref)) // no eDVBService avail for this reference ( Linkage Services... )
853 ptr = m_StaticServiceDVBInfo;
855 /* eDVBService has the iStaticServiceInformation interface, so we pass it here. */
861 RESULT eServiceFactoryDVB::offlineOperations(const eServiceReference &ref, ePtr<iServiceOfflineOperations> &ptr)
863 if (ref.path.empty())
869 ptr = new eDVBPVRServiceOfflineOperations(ref);
874 RESULT eServiceFactoryDVB::lookupService(ePtr<eDVBService> &service, const eServiceReference &ref)
876 if (!ref.path.empty()) // playback
878 eDVBMetaParser parser;
879 int ret=parser.parseFile(ref.path);
880 service = new eDVBService;
882 eDVBDB::getInstance()->parseServiceData(service, parser.m_service_data);
886 // TODO: handle the listing itself
887 // if (ref.... == -1) .. return "... bouquets ...";
888 // could be also done in another serviceFactory (with seperate ID) to seperate actual services and lists
890 ePtr<iDVBChannelList> db;
891 ePtr<eDVBResourceManager> res;
894 if ((err = eDVBResourceManager::getInstance(res)) != 0)
896 eDebug("no resource manager");
899 if ((err = res->getChannelList(db)) != 0)
901 eDebug("no channel list");
905 /* we are sure to have a ..DVB reference as the info() call was forwarded here according to it's ID. */
906 if ((err = db->getService((eServiceReferenceDVB&)ref, service)) != 0)
908 eDebug("getService failed!");
916 eDVBServicePlay::eDVBServicePlay(const eServiceReference &ref, eDVBService *service):
917 m_reference(ref), m_dvb_service(service), m_have_video_pid(0), m_is_paused(0)
920 m_is_pvr = !m_reference.path.empty();
922 m_timeshift_enabled = m_timeshift_active = 0, m_timeshift_changed = 0;
923 m_skipmode = m_fastforward = m_slowmotion = 0;
925 CONNECT(m_service_handler.serviceEvent, eDVBServicePlay::serviceEvent);
926 CONNECT(m_service_handler_timeshift.serviceEvent, eDVBServicePlay::serviceEventTimeshift);
927 CONNECT(m_event_handler.m_eit_changed, eDVBServicePlay::gotNewEvent);
929 m_cuesheet_changed = 0;
930 m_cutlist_enabled = 1;
932 m_subtitle_widget = 0;
936 m_subtitle_sync_timer = eTimer::create(eApp);
938 CONNECT(m_subtitle_sync_timer->timeout, eDVBServicePlay::checkSubtitleTiming);
941 eDVBServicePlay::~eDVBServicePlay()
946 int ret=meta.parseFile(m_reference.path);
950 meta.m_service_data="";
951 sprintf(tmp, "f:%x", m_dvb_service->m_flags);
952 meta.m_service_data += tmp;
954 for (int x=0; x < eDVBService::cacheMax; ++x)
956 int entry = m_dvb_service->getCacheEntry((eDVBService::cacheID)x);
959 sprintf(tmp, ",c:%02d%04x", x, entry);
960 meta.m_service_data += tmp;
963 meta.updateMeta(m_reference.path);
966 delete m_subtitle_widget;
969 void eDVBServicePlay::gotNewEvent()
973 ePtr<eServiceEvent> m_event_now, m_event_next;
974 getEvent(m_event_now, 0);
975 getEvent(m_event_next, 1);
978 eDebug("now running: %s (%d seconds :)", m_event_now->m_event_name.c_str(), m_event_now->m_duration);
980 eDebug("next running: %s (%d seconds :)", m_event_next->m_event_name.c_str(), m_event_next->m_duration);
982 m_event((iPlayableService*)this, evUpdatedEventInfo);
985 void eDVBServicePlay::serviceEvent(int event)
987 m_tune_state = event;
991 case eDVBServicePMTHandler::eventTuned:
993 ePtr<iDVBDemux> m_demux;
994 if (!m_service_handler.getDataDemux(m_demux))
996 eServiceReferenceDVB &ref = (eServiceReferenceDVB&) m_reference;
997 int sid = ref.getParentServiceID().get();
999 sid = ref.getServiceID().get();
1000 if ( ref.getParentTransportStreamID().get() &&
1001 ref.getParentTransportStreamID() != ref.getTransportStreamID() )
1002 m_event_handler.startOther(m_demux, sid);
1004 m_event_handler.start(m_demux, sid);
1006 m_event((iPlayableService*)this, evTunedIn);
1009 case eDVBServicePMTHandler::eventNoResources:
1010 case eDVBServicePMTHandler::eventNoPAT:
1011 case eDVBServicePMTHandler::eventNoPATEntry:
1012 case eDVBServicePMTHandler::eventNoPMT:
1013 case eDVBServicePMTHandler::eventTuneFailed:
1014 case eDVBServicePMTHandler::eventMisconfiguration:
1016 eDebug("DVB service failed to tune - error %d", event);
1017 m_event((iPlayableService*)this, evTuneFailed);
1020 case eDVBServicePMTHandler::eventNewProgramInfo:
1022 eDebug("eventNewProgramInfo %d %d", m_timeshift_enabled, m_timeshift_active);
1023 if (m_timeshift_enabled)
1024 updateTimeshiftPids();
1025 if (!m_timeshift_active)
1027 if (m_first_program_info & 1 && m_is_pvr)
1029 m_first_program_info &= ~1;
1032 if (!m_timeshift_active)
1033 m_event((iPlayableService*)this, evUpdatedInfo);
1036 case eDVBServicePMTHandler::eventPreStart:
1039 case eDVBServicePMTHandler::eventEOF:
1040 m_event((iPlayableService*)this, evEOF);
1042 case eDVBServicePMTHandler::eventSOF:
1043 m_event((iPlayableService*)this, evSOF);
1048 void eDVBServicePlay::serviceEventTimeshift(int event)
1052 case eDVBServicePMTHandler::eventNewProgramInfo:
1053 eDebug("eventNewProgramInfo TS");
1054 if (m_timeshift_active)
1057 if (m_first_program_info & 2)
1061 eDebug("re-apply slowmotion after timeshift file change");
1062 m_decoder->setSlowMotion(m_slowmotion);
1066 eDebug("re-apply skip %d, ratio %d after timeshift file change", m_skipmode, m_fastforward);
1068 m_cue->setSkipmode(m_skipmode * 90000); /* convert to 90000 per second */
1069 if (m_fastforward != 1)
1070 m_decoder->setFastForward(m_fastforward);
1072 m_decoder->setTrickmode();
1076 m_first_program_info &= ~2;
1078 m_event((iPlayableService*)this, evUpdatedInfo);
1081 case eDVBServicePMTHandler::eventSOF:
1083 if (!m_timeshift_file_next.empty())
1085 eDebug("timeshift SOF, switch to next file");
1088 m_first_program_info |= 2;
1090 eServiceReferenceDVB r = (eServiceReferenceDVB&)m_reference;
1091 r.path = m_timeshift_file_next;
1093 /* free the timeshift service handler, we need the resources */
1094 m_service_handler_timeshift.free();
1098 m_cue->seekTo(0, -1000);
1099 ePtr<iTsSource> source = createTsSource(r);
1100 m_service_handler_timeshift.tuneExt(r, 1, source, r.path.c_str(), m_cue, 0, m_dvb_service); /* use the decoder demux for everything */
1102 m_event((iPlayableService*)this, evUser+1);
1106 m_event((iPlayableService*)this, evSOF);
1108 case eDVBServicePMTHandler::eventEOF:
1109 if ((!m_is_paused) && (m_skipmode >= 0))
1111 if (m_timeshift_file_next.empty())
1113 eDebug("timeshift EOF, so let's go live");
1118 eDebug("timeshift EOF, switch to next file");
1120 m_first_program_info |= 2;
1122 eServiceReferenceDVB r = (eServiceReferenceDVB&)m_reference;
1123 r.path = m_timeshift_file_next;
1125 /* free the timeshift service handler, we need the resources */
1126 m_service_handler_timeshift.free();
1129 ePtr<iTsSource> source = createTsSource(r);
1130 m_service_handler_timeshift.tuneExt(r, 1, source, m_timeshift_file_next.c_str(), m_cue, 0, m_dvb_service); /* use the decoder demux for everything */
1132 m_event((iPlayableService*)this, evUser+1);
1139 RESULT eDVBServicePlay::start()
1141 eServiceReferenceDVB service = (eServiceReferenceDVB&)m_reference;
1143 /* in pvr mode, we only want to use one demux. in tv mode, we're using
1144 two (one for decoding, one for data source), as we must be prepared
1145 to start recording from the data demux. */
1148 eDVBMetaParser meta;
1149 if (!meta.parseFile(m_reference.path))
1151 service = meta.m_ref;
1152 service.path = m_reference.path;
1154 m_cue = new eCueSheet();
1157 m_event(this, evStart);
1159 m_first_program_info = 1;
1160 ePtr<iTsSource> source = createTsSource(service);
1161 m_service_handler.tuneExt(service, m_is_pvr, source, service.path.c_str(), m_cue, false, m_dvb_service);
1165 /* inject EIT if there is a stored one */
1166 std::string filename = service.path;
1167 filename.erase(filename.length()-2, 2);
1169 ePtr<eServiceEvent> event = new eServiceEvent;
1170 if (!event->parseFrom(filename, (service.getTransportStreamID().get()<<16)|service.getOriginalNetworkID().get()))
1172 ePtr<eServiceEvent> empty;
1173 m_event_handler.inject(event, 0);
1174 m_event_handler.inject(empty, 1);
1176 m_event(this, evStart);
1181 RESULT eDVBServicePlay::stop()
1183 /* add bookmark for last play position */
1186 pts_t play_position, length;
1187 if (!getPlayPosition(play_position))
1189 /* remove last position */
1190 for (std::multiset<struct cueEntry>::iterator i(m_cue_entries.begin()); i != m_cue_entries.end();)
1192 if (i->what == 3) /* current play position */
1194 m_cue_entries.erase(i);
1195 i = m_cue_entries.begin();
1201 if (getLength(length))
1206 m_cue_entries.insert(cueEntry(play_position, 3)); /* last play position */
1208 m_cuesheet_changed = 1;
1212 stopTimeshift(); /* in case timeshift was enabled, remove buffer etc. */
1214 m_service_handler_timeshift.free();
1215 m_service_handler.free();
1217 if (m_is_pvr && m_cuesheet_changed)
1220 /* save cuesheet only when main file is accessible. */
1221 if (!::stat(m_reference.path.c_str(), &s))
1224 m_event((iPlayableService*)this, evStopped);
1228 RESULT eDVBServicePlay::setTarget(int target)
1230 m_is_primary = !target;
1234 RESULT eDVBServicePlay::connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection)
1236 connection = new eConnection((iPlayableService*)this, m_event.connect(event));
1240 RESULT eDVBServicePlay::pause(ePtr<iPauseableService> &ptr)
1242 /* note: we check for timeshift to be enabled,
1243 not neccessary active. if you pause when timeshift
1244 is not active, you should activate it when unpausing */
1245 if ((!m_is_pvr) && (!m_timeshift_enabled))
1255 RESULT eDVBServicePlay::setSlowMotion(int ratio)
1257 ASSERT(ratio); /* The API changed: instead of calling setSlowMotion(0), call play! */
1258 eDebug("eDVBServicePlay::setSlowMotion(%d)", ratio);
1259 setFastForward_internal(0);
1262 m_slowmotion = ratio;
1263 return m_decoder->setSlowMotion(ratio);
1269 RESULT eDVBServicePlay::setFastForward(int ratio)
1271 eDebug("eDVBServicePlay::setFastForward(%d)", ratio);
1273 return setFastForward_internal(ratio);
1276 RESULT eDVBServicePlay::setFastForward_internal(int ratio, bool final_seek)
1278 int skipmode, ffratio, ret = 0;
1285 } else if (ratio > 0)
1293 } else // if (ratio < 0)
1299 if (m_skipmode != skipmode)
1301 eDebug("setting cue skipmode to %d", skipmode);
1303 m_cue->setSkipmode(skipmode * 90000); /* convert to 90000 per second */
1306 m_skipmode = skipmode;
1309 eDebug("trickplay stopped .. ret %d, pos %lld", getPlayPosition(pos), pos);
1311 m_fastforward = ffratio;
1317 ; /* return m_decoder->play(); is done in caller*/
1318 else if (ffratio != 1)
1319 ret = m_decoder->setFastForward(ffratio);
1321 ret = m_decoder->setTrickmode();
1324 eDebug("final seek after trickplay ret %d", seekTo(pos));
1329 RESULT eDVBServicePlay::seek(ePtr<iSeekableService> &ptr)
1331 if (m_is_pvr || m_timeshift_enabled)
1341 /* TODO: when timeshift is enabled but not active, this doesn't work. */
1342 RESULT eDVBServicePlay::getLength(pts_t &len)
1344 ePtr<iDVBPVRChannel> pvr_channel;
1346 if ((m_timeshift_enabled ? m_service_handler_timeshift : m_service_handler).getPVRChannel(pvr_channel))
1349 return pvr_channel->getLength(len);
1352 RESULT eDVBServicePlay::pause()
1354 eDebug("eDVBServicePlay::pause");
1355 setFastForward_internal(0, m_slowmotion || m_fastforward > 1);
1360 return m_decoder->pause();
1365 RESULT eDVBServicePlay::unpause()
1367 eDebug("eDVBServicePlay::unpause");
1368 setFastForward_internal(0, m_slowmotion || m_fastforward > 1);
1373 return m_decoder->play();
1378 RESULT eDVBServicePlay::seekTo(pts_t to)
1380 eDebug("eDVBServicePlay::seekTo: jump %lld", to);
1382 if (!m_decode_demux)
1385 ePtr<iDVBPVRChannel> pvr_channel;
1387 if ((m_timeshift_enabled ? m_service_handler_timeshift : m_service_handler).getPVRChannel(pvr_channel))
1393 m_cue->seekTo(0, to);
1394 m_dvb_subtitle_pages.clear();
1395 m_subtitle_pages.clear();
1400 RESULT eDVBServicePlay::seekRelative(int direction, pts_t to)
1402 eDebug("eDVBServicePlay::seekRelative: jump %d, %lld", direction, to);
1404 if (!m_decode_demux)
1407 ePtr<iDVBPVRChannel> pvr_channel;
1409 if ((m_timeshift_enabled ? m_service_handler_timeshift : m_service_handler).getPVRChannel(pvr_channel))
1414 /* HACK until we have skip-AP api */
1415 if ((to > 0) && (to < 100))
1423 m_cue->seekTo(mode, to);
1424 m_dvb_subtitle_pages.clear();
1425 m_subtitle_pages.clear();
1429 RESULT eDVBServicePlay::getPlayPosition(pts_t &pos)
1431 ePtr<iDVBPVRChannel> pvr_channel;
1433 if (!m_decode_demux)
1436 if ((m_timeshift_enabled ? m_service_handler_timeshift : m_service_handler).getPVRChannel(pvr_channel))
1441 /* if there is a decoder, use audio or video PTS */
1444 r = m_decoder->getPTS(0, pos);
1450 return pvr_channel->getCurrentPosition(m_decode_demux, pos, m_decoder ? 1 : 0);
1453 RESULT eDVBServicePlay::setTrickmode(int trick)
1455 /* currently unimplemented */
1459 RESULT eDVBServicePlay::isCurrentlySeekable()
1464 ret = (m_is_pvr || m_timeshift_active) ? 3 : 0; // fast forward/backward possible and seeking possible
1465 if (m_decoder->getVideoProgressive() == -1)
1471 RESULT eDVBServicePlay::frontendInfo(ePtr<iFrontendInformation> &ptr)
1477 RESULT eDVBServicePlay::info(ePtr<iServiceInformation> &ptr)
1483 RESULT eDVBServicePlay::audioChannel(ePtr<iAudioChannelSelection> &ptr)
1489 RESULT eDVBServicePlay::audioTracks(ePtr<iAudioTrackSelection> &ptr)
1495 RESULT eDVBServicePlay::subServices(ePtr<iSubserviceList> &ptr)
1501 RESULT eDVBServicePlay::timeshift(ePtr<iTimeshiftService> &ptr)
1504 if (m_have_video_pid && // HACK !!! FIXMEE !! temporary no timeshift on radio services !!
1505 (m_timeshift_enabled || !m_is_pvr))
1507 if (!m_timeshift_enabled)
1509 /* query config path */
1511 if(ePythonConfigQuery::getConfigValue("config.usage.timeshift_path", tspath) == -1){
1512 eDebug("could not query ts path from config");
1516 /* we need enough diskspace */
1518 if (statfs(tspath.c_str(), &fs) < 0)
1520 eDebug("statfs failed!");
1524 if (((off_t)fs.f_bavail) * ((off_t)fs.f_bsize) < 1024*1024*1024LL)
1526 eDebug("not enough diskspace for timeshift! (less than 1GB)");
1536 RESULT eDVBServicePlay::cueSheet(ePtr<iCueSheet> &ptr)
1547 RESULT eDVBServicePlay::subtitle(ePtr<iSubtitleOutput> &ptr)
1553 RESULT eDVBServicePlay::audioDelay(ePtr<iAudioDelay> &ptr)
1559 RESULT eDVBServicePlay::rdsDecoder(ePtr<iRdsDecoder> &ptr)
1565 RESULT eDVBServicePlay::getName(std::string &name)
1569 ePtr<iStaticServiceInformation> i = new eStaticServiceDVBPVRInformation(m_reference);
1570 return i->getName(m_reference, name);
1572 else if (m_dvb_service)
1574 m_dvb_service->getName(m_reference, name);
1578 else if (!m_reference.name.empty())
1579 eStaticServiceDVBInformation().getName(m_reference, name);
1581 name = "DVB service";
1585 RESULT eDVBServicePlay::getEvent(ePtr<eServiceEvent> &evt, int nownext)
1587 return m_event_handler.getEvent(evt, nownext);
1590 int eDVBServicePlay::getInfo(int w)
1592 eDVBServicePMTHandler::program program;
1594 if (w == sCAIDs || w == sCAIDPIDs)
1595 return resIsPyObject;
1597 eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
1599 int no_program_info = 0;
1601 if (h.getProgramInfo(program))
1602 no_program_info = 1;
1608 return m_decoder->getVideoHeight();
1612 return m_decoder->getVideoWidth();
1616 return m_decoder->getVideoFrameRate();
1620 return m_decoder->getVideoProgressive();
1626 aspect = m_decoder->getVideoAspect();
1627 if (aspect == -1 && no_program_info)
1629 else if (aspect == -1 && !program.videoStreams.empty() && program.videoStreams[0].component_tag != -1)
1631 ePtr<eServiceEvent> evt;
1632 if (!m_event_handler.getEvent(evt, 0))
1634 ePtr<eComponentData> data;
1635 if (!evt->getComponentData(data, program.videoStreams[0].component_tag))
1637 if ( data->getStreamContent() == 1 )
1639 switch(data->getComponentType())
1642 case 1: // 4:3 SD PAL
1644 case 3: // 16:9 SD PAL
1645 case 4: // > 16:9 PAL
1646 case 5: // 4:3 SD NTSC
1648 case 7: // 16:9 SD NTSC
1649 case 8: // > 16:9 NTSC
1652 case 9: // 4:3 HD PAL
1654 case 0xB: // 16:9 HD PAL
1655 case 0xC: // > 16:9 HD PAL
1656 case 0xD: // 4:3 HD NTSC
1658 case 0xF: // 16:9 HD NTSC
1659 case 0x10: // > 16:9 HD PAL
1660 return data->getComponentType();
1670 case sIsCrypted: if (no_program_info) return -1; return program.isCrypted();
1674 int vpid = m_dvb_service->getCacheEntry(eDVBService::cVPID);
1678 if (no_program_info) return -1; if (program.videoStreams.empty()) return -1; return program.videoStreams[0].pid;
1679 case sVideoType: if (no_program_info) return -1; if (program.videoStreams.empty()) return -1; return program.videoStreams[0].type;
1683 int apid = m_dvb_service->getCacheEntry(eDVBService::cAPID);
1686 apid = m_dvb_service->getCacheEntry(eDVBService::cAC3PID);
1690 if (no_program_info) return -1; if (program.audioStreams.empty()) return -1; return program.audioStreams[0].pid;
1694 int pcrpid = m_dvb_service->getCacheEntry(eDVBService::cPCRPID);
1698 if (no_program_info) return -1; return program.pcrPid;
1699 case sPMTPID: if (no_program_info) return -1; return program.pmtPid;
1700 case sTXTPID: if (no_program_info) return -1; return program.textPid;
1701 case sSID: return ((const eServiceReferenceDVB&)m_reference).getServiceID().get();
1702 case sONID: return ((const eServiceReferenceDVB&)m_reference).getOriginalNetworkID().get();
1703 case sTSID: return ((const eServiceReferenceDVB&)m_reference).getTransportStreamID().get();
1704 case sNamespace: return ((const eServiceReferenceDVB&)m_reference).getDVBNamespace().get();
1705 case sProvider: if (!m_dvb_service) return -1; return -2;
1706 case sServiceref: return resIsString;
1707 case sDVBState: return m_tune_state;
1714 std::string eDVBServicePlay::getInfoString(int w)
1719 if (!m_dvb_service) return "";
1720 return m_dvb_service->m_provider_name;
1722 return m_reference.toString();
1726 return iServiceInformation::getInfoString(w);
1729 PyObject *eDVBServicePlay::getInfoObject(int w)
1734 return m_service_handler.getCaIds();
1736 return m_service_handler.getCaIds(true);
1737 case sTransponderData:
1738 return eStaticServiceDVBInformation().getInfoObject(m_reference, w);
1742 return iServiceInformation::getInfoObject(w);
1745 int eDVBServicePlay::getNumberOfTracks()
1747 eDVBServicePMTHandler::program program;
1748 eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
1749 if (h.getProgramInfo(program))
1751 return program.audioStreams.size();
1754 int eDVBServicePlay::getCurrentTrack()
1756 eDVBServicePMTHandler::program program;
1757 eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
1758 if (h.getProgramInfo(program))
1761 int max = program.audioStreams.size();
1764 for (i = 0; i < max; ++i)
1765 if (program.audioStreams[i].pid == m_current_audio_pid)
1771 RESULT eDVBServicePlay::selectTrack(unsigned int i)
1773 int ret = selectAudioStream(i);
1775 if (m_decoder->set())
1781 RESULT eDVBServicePlay::getTrackInfo(struct iAudioTrackInfo &info, unsigned int i)
1783 eDVBServicePMTHandler::program program;
1784 eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
1786 if (h.getProgramInfo(program))
1789 if (i >= program.audioStreams.size())
1792 info.m_pid = program.audioStreams[i].pid;
1794 if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atMPEG)
1795 info.m_description = "MPEG";
1796 else if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atAC3)
1797 info.m_description = "AC3";
1798 else if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atAAC)
1799 info.m_description = "AAC";
1800 else if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atAACHE)
1801 info.m_description = "AAC-HE";
1802 else if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atDTS)
1803 info.m_description = "DTS";
1805 info.m_description = "???";
1807 if (program.audioStreams[i].component_tag != -1)
1809 ePtr<eServiceEvent> evt;
1810 if (!m_event_handler.getEvent(evt, 0))
1812 ePtr<eComponentData> data;
1813 if (!evt->getComponentData(data, program.audioStreams[i].component_tag))
1814 info.m_language = data->getText();
1818 if (info.m_language.empty())
1819 info.m_language = program.audioStreams[i].language_code;
1824 int eDVBServicePlay::selectAudioStream(int i)
1826 eDVBServicePMTHandler::program program;
1827 eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
1828 pts_t position = -1;
1830 if (h.getProgramInfo(program))
1833 if ((i != -1) && ((unsigned int)i >= program.audioStreams.size()))
1841 stream = program.defaultAudioStream;
1843 int apid = -1, apidtype = -1;
1845 if (((unsigned int)stream) < program.audioStreams.size())
1847 apid = program.audioStreams[stream].pid;
1848 apidtype = program.audioStreams[stream].type;
1851 if (i != -1 && apid != m_current_audio_pid && (m_is_pvr || m_timeshift_active))
1852 eDebug("getPlayPosition ret %d, pos %lld in selectAudioStream", getPlayPosition(position), position);
1854 m_current_audio_pid = apid;
1856 if (m_is_primary && m_decoder->setAudioPID(apid, apidtype))
1858 eDebug("set audio pid failed");
1863 eDebug("seekTo ret %d", seekTo(position));
1867 /* 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 */
1868 if (!(m_is_pvr || m_timeshift_active || !m_is_primary))
1870 int different_pid = program.videoStreams.empty() && program.audioStreams.size() == 1 && program.audioStreams[stream].rdsPid != -1;
1872 rdsPid = program.audioStreams[stream].rdsPid;
1873 if (!m_rds_decoder || m_rds_decoder->getPid() != rdsPid)
1876 ePtr<iDVBDemux> data_demux;
1877 if (!h.getDataDemux(data_demux))
1879 m_rds_decoder = new eDVBRdsDecoder(data_demux, different_pid);
1880 m_rds_decoder->connectEvent(slot(*this, &eDVBServicePlay::rdsDecoderEvent), m_rds_decoder_event_connection);
1881 m_rds_decoder->start(rdsPid);
1886 /* store new pid as default only when:
1887 a.) we have an entry in the service db for the current service,
1888 b.) we are not playing back something,
1889 c.) we are not selecting the default entry. (we wouldn't change
1890 anything in the best case, or destroy the default setting in
1891 case the real default is not yet available.)
1893 if (m_dvb_service && ((i != -1)
1894 || ((m_dvb_service->getCacheEntry(eDVBService::cAPID) == -1) && (m_dvb_service->getCacheEntry(eDVBService::cAC3PID)==-1))))
1896 if (apidtype == eDVBAudio::aMPEG)
1898 m_dvb_service->setCacheEntry(eDVBService::cAPID, apid);
1899 m_dvb_service->setCacheEntry(eDVBService::cAC3PID, -1);
1901 else if (apidtype == eDVBAudio::aAC3)
1903 m_dvb_service->setCacheEntry(eDVBService::cAPID, -1);
1904 m_dvb_service->setCacheEntry(eDVBService::cAC3PID, apid);
1908 m_dvb_service->setCacheEntry(eDVBService::cAPID, -1);
1909 m_dvb_service->setCacheEntry(eDVBService::cAC3PID, -1);
1913 h.resetCachedProgram();
1918 int eDVBServicePlay::getCurrentChannel()
1920 return m_decoder ? m_decoder->getAudioChannel() : STEREO;
1923 RESULT eDVBServicePlay::selectChannel(int i)
1925 if (i < LEFT || i > RIGHT || i == STEREO)
1928 m_dvb_service->setCacheEntry(eDVBService::cACHANNEL, i);
1930 m_decoder->setAudioChannel(i);
1934 std::string eDVBServicePlay::getText(int x)
1940 return convertLatin1UTF8(m_rds_decoder->getRadioText());
1942 return convertLatin1UTF8(m_rds_decoder->getRtpText());
1947 void eDVBServicePlay::rdsDecoderEvent(int what)
1951 case eDVBRdsDecoder::RadioTextChanged:
1952 m_event((iPlayableService*)this, evUpdatedRadioText);
1954 case eDVBRdsDecoder::RtpTextChanged:
1955 m_event((iPlayableService*)this, evUpdatedRtpText);
1957 case eDVBRdsDecoder::RassInteractivePicMaskChanged:
1958 m_event((iPlayableService*)this, evUpdatedRassInteractivePicMask);
1960 case eDVBRdsDecoder::RecvRassSlidePic:
1961 m_event((iPlayableService*)this, evUpdatedRassSlidePic);
1966 void eDVBServicePlay::showRassSlidePicture()
1972 std::string rass_slide_pic = m_rds_decoder->getRassSlideshowPicture();
1973 if (rass_slide_pic.length())
1974 m_decoder->showSinglePic(rass_slide_pic.c_str());
1976 eDebug("empty filename for rass slide picture received!!");
1979 eDebug("no MPEG Decoder to show iframes avail");
1982 eDebug("showRassSlidePicture called.. but not decoder");
1985 void eDVBServicePlay::showRassInteractivePic(int page, int subpage)
1991 std::string rass_interactive_pic = m_rds_decoder->getRassPicture(page, subpage);
1992 if (rass_interactive_pic.length())
1993 m_decoder->showSinglePic(rass_interactive_pic.c_str());
1995 eDebug("empty filename for rass interactive picture %d/%d received!!", page, subpage);
1998 eDebug("no MPEG Decoder to show iframes avail");
2001 eDebug("showRassInteractivePic called.. but not decoder");
2004 ePyObject eDVBServicePlay::getRassInteractiveMask()
2007 return m_rds_decoder->getRassPictureMask();
2011 int eDVBServiceBase::getFrontendInfo(int w)
2013 eUsePtr<iDVBChannel> channel;
2014 if(m_service_handler.getChannel(channel))
2016 ePtr<iDVBFrontend> fe;
2017 if(channel->getFrontend(fe))
2019 return fe->readFrontendData(w);
2022 PyObject *eDVBServiceBase::getFrontendData()
2024 ePyObject ret = PyDict_New();
2027 eUsePtr<iDVBChannel> channel;
2028 if(!m_service_handler.getChannel(channel))
2030 ePtr<iDVBFrontend> fe;
2031 if(!channel->getFrontend(fe))
2032 fe->getFrontendData(ret);
2040 PyObject *eDVBServiceBase::getFrontendStatus()
2042 ePyObject ret = PyDict_New();
2045 eUsePtr<iDVBChannel> channel;
2046 if(!m_service_handler.getChannel(channel))
2048 ePtr<iDVBFrontend> fe;
2049 if(!channel->getFrontend(fe))
2050 fe->getFrontendStatus(ret);
2058 PyObject *eDVBServiceBase::getTransponderData(bool original)
2060 ePyObject ret = PyDict_New();
2063 eUsePtr<iDVBChannel> channel;
2064 if(!m_service_handler.getChannel(channel))
2066 ePtr<iDVBFrontend> fe;
2067 if(!channel->getFrontend(fe))
2068 fe->getTransponderData(ret, original);
2076 PyObject *eDVBServiceBase::getAll(bool original)
2078 ePyObject ret = getTransponderData(original);
2081 eUsePtr<iDVBChannel> channel;
2082 if(!m_service_handler.getChannel(channel))
2084 ePtr<iDVBFrontend> fe;
2085 if(!channel->getFrontend(fe))
2087 fe->getFrontendData(ret);
2088 fe->getFrontendStatus(ret);
2095 int eDVBServicePlay::getNumberOfSubservices()
2097 ePtr<eServiceEvent> evt;
2098 if (!m_event_handler.getEvent(evt, 0))
2099 return evt->getNumOfLinkageServices();
2103 RESULT eDVBServicePlay::getSubservice(eServiceReference &sub, unsigned int n)
2105 ePtr<eServiceEvent> evt;
2106 if (!m_event_handler.getEvent(evt, 0))
2108 if (!evt->getLinkageService(sub, m_reference, n))
2111 sub.type=eServiceReference::idInvalid;
2115 RESULT eDVBServicePlay::startTimeshift()
2117 ePtr<iDVBDemux> demux;
2119 eDebug("Start timeshift!");
2121 if (m_timeshift_enabled)
2124 /* start recording with the data demux. */
2125 if (m_service_handler.getDataDemux(demux))
2128 demux->createTSRecorder(m_record);
2133 if(ePythonConfigQuery::getConfigValue("config.usage.timeshift_path", tspath) == -1){
2134 eDebug("could not query ts path");
2137 tspath.append("/timeshift.XXXXXX");
2139 templ = new char[tspath.length() + 1];
2140 strcpy(templ, tspath.c_str());
2142 m_timeshift_fd = mkstemp(templ);
2143 m_timeshift_file = std::string(templ);
2145 eDebug("recording to %s", templ);
2149 if (m_timeshift_fd < 0)
2155 m_record->setTargetFD(m_timeshift_fd);
2157 m_timeshift_enabled = 1;
2159 updateTimeshiftPids();
2165 RESULT eDVBServicePlay::stopTimeshift(bool swToLive)
2167 if (!m_timeshift_enabled)
2173 m_timeshift_enabled = 0;
2178 close(m_timeshift_fd);
2179 eDebug("remove timeshift file");
2180 eBackgroundFileEraser::getInstance()->erase(m_timeshift_file.c_str());
2185 int eDVBServicePlay::isTimeshiftActive()
2187 return m_timeshift_enabled && m_timeshift_active;
2190 RESULT eDVBServicePlay::activateTimeshift()
2192 if (!m_timeshift_enabled)
2195 if (!m_timeshift_active)
2197 switchToTimeshift();
2204 PyObject *eDVBServicePlay::getCutList()
2206 ePyObject list = PyList_New(0);
2208 for (std::multiset<struct cueEntry>::iterator i(m_cue_entries.begin()); i != m_cue_entries.end(); ++i)
2210 ePyObject tuple = PyTuple_New(2);
2211 PyTuple_SET_ITEM(tuple, 0, PyLong_FromLongLong(i->where));
2212 PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(i->what));
2213 PyList_Append(list, tuple);
2220 void eDVBServicePlay::setCutList(ePyObject list)
2222 if (!PyList_Check(list))
2224 int size = PyList_Size(list);
2227 m_cue_entries.clear();
2229 for (i=0; i<size; ++i)
2231 ePyObject tuple = PyList_GET_ITEM(list, i);
2232 if (!PyTuple_Check(tuple))
2234 eDebug("non-tuple in cutlist");
2237 if (PyTuple_Size(tuple) != 2)
2239 eDebug("cutlist entries need to be a 2-tuple");
2242 ePyObject ppts = PyTuple_GET_ITEM(tuple, 0), ptype = PyTuple_GET_ITEM(tuple, 1);
2243 if (!(PyLong_Check(ppts) && PyInt_Check(ptype)))
2245 eDebug("cutlist entries need to be (pts, type)-tuples (%d %d)", PyLong_Check(ppts), PyInt_Check(ptype));
2248 pts_t pts = PyLong_AsLongLong(ppts);
2249 int type = PyInt_AsLong(ptype);
2250 m_cue_entries.insert(cueEntry(pts, type));
2251 eDebug("adding %08llx, %d", pts, type);
2253 m_cuesheet_changed = 1;
2255 cutlistToCuesheet();
2256 m_event((iPlayableService*)this, evCuesheetChanged);
2259 void eDVBServicePlay::setCutListEnable(int enable)
2261 m_cutlist_enabled = enable;
2262 cutlistToCuesheet();
2265 void eDVBServicePlay::updateTimeshiftPids()
2270 eDVBServicePMTHandler::program program;
2271 eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
2273 if (h.getProgramInfo(program))
2277 std::set<int> pids_to_record;
2278 pids_to_record.insert(0); // PAT
2279 if (program.pmtPid != -1)
2280 pids_to_record.insert(program.pmtPid); // PMT
2282 if (program.textPid != -1)
2283 pids_to_record.insert(program.textPid); // Videotext
2285 for (std::vector<eDVBServicePMTHandler::videoStream>::const_iterator
2286 i(program.videoStreams.begin());
2287 i != program.videoStreams.end(); ++i)
2288 pids_to_record.insert(i->pid);
2290 for (std::vector<eDVBServicePMTHandler::audioStream>::const_iterator
2291 i(program.audioStreams.begin());
2292 i != program.audioStreams.end(); ++i)
2293 pids_to_record.insert(i->pid);
2295 for (std::vector<eDVBServicePMTHandler::subtitleStream>::const_iterator
2296 i(program.subtitleStreams.begin());
2297 i != program.subtitleStreams.end(); ++i)
2298 pids_to_record.insert(i->pid);
2300 std::set<int> new_pids, obsolete_pids;
2302 std::set_difference(pids_to_record.begin(), pids_to_record.end(),
2303 m_pids_active.begin(), m_pids_active.end(),
2304 std::inserter(new_pids, new_pids.begin()));
2306 std::set_difference(
2307 m_pids_active.begin(), m_pids_active.end(),
2308 pids_to_record.begin(), pids_to_record.end(),
2309 std::inserter(new_pids, new_pids.begin())
2312 for (std::set<int>::iterator i(new_pids.begin()); i != new_pids.end(); ++i)
2313 m_record->addPID(*i);
2315 for (std::set<int>::iterator i(obsolete_pids.begin()); i != obsolete_pids.end(); ++i)
2316 m_record->removePID(*i);
2320 RESULT eDVBServicePlay::setNextPlaybackFile(const char *f)
2322 m_timeshift_file_next = f;
2326 void eDVBServicePlay::switchToLive()
2328 if (!m_timeshift_active)
2331 eDebug("SwitchToLive");
2335 m_is_paused = m_skipmode = m_fastforward = m_slowmotion = 0; /* not supported in live mode */
2337 /* free the timeshift service handler, we need the resources */
2338 m_service_handler_timeshift.free();
2340 updateDecoder(true);
2343 void eDVBServicePlay::resetTimeshift(int start)
2348 m_teletext_parser = 0;
2350 m_subtitle_parser = 0;
2351 m_new_subtitle_page_connection = 0;
2352 m_new_dvb_subtitle_page_connection = 0;
2353 m_rds_decoder_event_connection = 0;
2354 m_video_event_connection = 0;
2355 m_timeshift_changed = 1;
2356 m_timeshift_file_next.clear();
2360 m_cue = new eCueSheet();
2361 m_timeshift_active = 1;
2364 m_timeshift_active = 0;
2367 ePtr<iTsSource> eDVBServicePlay::createTsSource(eServiceReferenceDVB &ref)
2369 eRawFile *f = new eRawFile();
2370 f->open(ref.path.c_str());
2371 return ePtr<iTsSource>(f);
2374 void eDVBServicePlay::switchToTimeshift()
2376 if (m_timeshift_active)
2381 eServiceReferenceDVB r = (eServiceReferenceDVB&)m_reference;
2382 r.path = m_timeshift_file;
2384 m_cue->seekTo(0, -1000);
2386 ePtr<iTsSource> source = createTsSource(r);
2387 m_service_handler_timeshift.tuneExt(r, 1, source, m_timeshift_file.c_str(), m_cue, 0, m_dvb_service); /* use the decoder demux for everything */
2389 eDebug("eDVBServicePlay::switchToTimeshift, in pause mode now.");
2391 updateDecoder(true); /* mainly to switch off PCR, and to set pause */
2394 void eDVBServicePlay::updateDecoder(bool sendSeekableStateChanged)
2396 int vpid = -1, vpidtype = -1, pcrpid = -1, tpid = -1, achannel = -1, ac3_delay=-1, pcm_delay=-1;
2397 bool mustPlay = false;
2399 eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
2401 eDVBServicePMTHandler::program program;
2402 if (h.getProgramInfo(program))
2403 eDebug("getting program info failed.");
2406 eDebugNoNewLine("have %d video stream(s)", program.videoStreams.size());
2407 if (!program.videoStreams.empty())
2409 eDebugNoNewLine(" (");
2410 for (std::vector<eDVBServicePMTHandler::videoStream>::const_iterator
2411 i(program.videoStreams.begin());
2412 i != program.videoStreams.end(); ++i)
2419 if (i != program.videoStreams.begin())
2420 eDebugNoNewLine(", ");
2421 eDebugNoNewLine("%04x", i->pid);
2423 eDebugNoNewLine(")");
2425 eDebugNoNewLine(", and %d audio stream(s)", program.audioStreams.size());
2426 if (!program.audioStreams.empty())
2428 eDebugNoNewLine(" (");
2429 for (std::vector<eDVBServicePMTHandler::audioStream>::const_iterator
2430 i(program.audioStreams.begin());
2431 i != program.audioStreams.end(); ++i)
2433 if (i != program.audioStreams.begin())
2434 eDebugNoNewLine(", ");
2435 eDebugNoNewLine("%04x", i->pid);
2437 eDebugNoNewLine(")");
2439 eDebugNoNewLine(", and the pcr pid is %04x", program.pcrPid);
2440 pcrpid = program.pcrPid;
2441 eDebug(", and the text pid is %04x", program.textPid);
2442 tpid = program.textPid;
2447 h.getDecodeDemux(m_decode_demux);
2450 m_decode_demux->getMPEGDecoder(m_decoder, m_is_primary);
2452 m_decoder->connectVideoEvent(slot(*this, &eDVBServicePlay::video_event), m_video_event_connection);
2455 m_teletext_parser = new eDVBTeletextParser(m_decode_demux);
2456 m_teletext_parser->connectNewPage(slot(*this, &eDVBServicePlay::newSubtitlePage), m_new_subtitle_page_connection);
2457 m_subtitle_parser = new eDVBSubtitleParser(m_decode_demux);
2458 m_subtitle_parser->connectNewPage(slot(*this, &eDVBServicePlay::newDVBSubtitlePage), m_new_dvb_subtitle_page_connection);
2459 if (m_timeshift_changed)
2461 ePyObject subs = getCachedSubtitle();
2462 if (subs != Py_None)
2464 int type = PyInt_AsLong(PyTuple_GET_ITEM(subs, 0)),
2465 pid = PyInt_AsLong(PyTuple_GET_ITEM(subs, 1)),
2466 comp_page = PyInt_AsLong(PyTuple_GET_ITEM(subs, 2)), // ttx page
2467 anc_page = PyInt_AsLong(PyTuple_GET_ITEM(subs, 3)); // ttx magazine
2468 if (type == 0) // dvb
2469 m_subtitle_parser->start(pid, comp_page, anc_page);
2470 else if (type == 1) // ttx
2471 m_teletext_parser->setPageAndMagazine(comp_page, anc_page);
2478 m_cue->setDecodingDemux(m_decode_demux, m_decoder);
2482 m_timeshift_changed = 0;
2486 bool wasSeekable = m_decoder->getVideoProgressive() != -1;
2489 achannel = m_dvb_service->getCacheEntry(eDVBService::cACHANNEL);
2490 ac3_delay = m_dvb_service->getCacheEntry(eDVBService::cAC3DELAY);
2491 pcm_delay = m_dvb_service->getCacheEntry(eDVBService::cPCMDELAY);
2495 eServiceReferenceDVB ref;
2496 m_service_handler.getServiceReference(ref);
2497 eServiceReferenceDVB parent = ref.getParentServiceReference();
2502 ePtr<eDVBResourceManager> res_mgr;
2503 if (!eDVBResourceManager::getInstance(res_mgr))
2505 ePtr<iDVBChannelList> db;
2506 if (!res_mgr->getChannelList(db))
2508 ePtr<eDVBService> origService;
2509 if (!db->getService(parent, origService))
2511 ac3_delay = origService->getCacheEntry(eDVBService::cAC3DELAY);
2512 pcm_delay = origService->getCacheEntry(eDVBService::cPCMDELAY);
2519 setAC3Delay(ac3_delay == -1 ? 0 : ac3_delay);
2520 setPCMDelay(pcm_delay == -1 ? 0 : pcm_delay);
2522 m_decoder->setVideoPID(vpid, vpidtype);
2523 selectAudioStream();
2525 if (!(m_is_pvr || m_timeshift_active || !m_is_primary))
2526 m_decoder->setSyncPCR(pcrpid);
2528 m_decoder->setSyncPCR(-1);
2532 m_decoder->setTextPID(tpid);
2533 m_teletext_parser->start(program.textPid);
2536 if (vpid > 0 && vpid < 0x2000)
2540 std::string radio_pic;
2541 if (!ePythonConfigQuery::getConfigValue("config.misc.radiopic", radio_pic))
2542 m_decoder->setRadioPic(radio_pic);
2550 m_decoder->setAudioChannel(achannel);
2552 /* don't worry about non-existing services, nor pvr services */
2555 /* (audio pid will be set in selectAudioTrack */
2556 m_dvb_service->setCacheEntry(eDVBService::cVPID, vpid);
2557 m_dvb_service->setCacheEntry(eDVBService::cVTYPE, vpidtype == eDVBVideo::MPEG2 ? -1 : vpidtype);
2558 m_dvb_service->setCacheEntry(eDVBService::cPCRPID, pcrpid);
2559 m_dvb_service->setCacheEntry(eDVBService::cTPID, tpid);
2561 if (!sendSeekableStateChanged && (m_decoder->getVideoProgressive() != -1) != wasSeekable)
2562 sendSeekableStateChanged = true;
2564 m_have_video_pid = (vpid > 0 && vpid < 0x2000);
2566 if (sendSeekableStateChanged)
2567 m_event((iPlayableService*)this, evSeekableStatusChanged);
2570 void eDVBServicePlay::loadCuesheet()
2572 std::string filename = m_reference.path + ".cuts";
2574 m_cue_entries.clear();
2576 FILE *f = fopen(filename.c_str(), "rb");
2580 eDebug("loading cuts..");
2583 unsigned long long where;
2586 if (!fread(&where, sizeof(where), 1, f))
2588 if (!fread(&what, sizeof(what), 1, f))
2591 #if BYTE_ORDER == LITTLE_ENDIAN
2592 where = bswap_64(where);
2599 m_cue_entries.insert(cueEntry(where, what));
2602 eDebug("%d entries", m_cue_entries.size());
2604 eDebug("cutfile not found!");
2606 m_cuesheet_changed = 0;
2607 cutlistToCuesheet();
2608 m_event((iPlayableService*)this, evCuesheetChanged);
2611 void eDVBServicePlay::saveCuesheet()
2613 std::string filename = m_reference.path + ".cuts";
2615 FILE *f = fopen(filename.c_str(), "wb");
2619 unsigned long long where;
2622 for (std::multiset<cueEntry>::iterator i(m_cue_entries.begin()); i != m_cue_entries.end(); ++i)
2624 #if BYTE_ORDER == BIG_ENDIAN
2627 where = bswap_64(i->where);
2629 what = htonl(i->what);
2630 fwrite(&where, sizeof(where), 1, f);
2631 fwrite(&what, sizeof(what), 1, f);
2637 m_cuesheet_changed = 0;
2640 void eDVBServicePlay::cutlistToCuesheet()
2644 eDebug("no cue sheet");
2649 if (!m_cutlist_enabled)
2651 m_cue->commitSpans();
2652 eDebug("cutlists were disabled");
2656 pts_t in = 0, out = 0, length = 0;
2660 std::multiset<cueEntry>::iterator i(m_cue_entries.begin());
2662 int have_any_span = 0;
2666 if (i == m_cue_entries.end())
2668 if (!have_any_span && !in)
2672 if (i->what == 0) /* in */
2676 } else if (i->what == 1) /* out */
2678 else /* mark (2) or last play position (3) */
2697 m_cue->addSourceSpan(in, out);
2703 if (i == m_cue_entries.end())
2706 m_cue->commitSpans();
2709 RESULT eDVBServicePlay::enableSubtitles(eWidget *parent, ePyObject tuple)
2711 if (m_subtitle_widget)
2712 disableSubtitles(parent);
2715 int tuplesize = PyTuple_Size(tuple);
2718 if (!PyTuple_Check(tuple))
2724 entry = PyTuple_GET_ITEM(tuple, 0);
2726 if (!PyInt_Check(entry))
2729 type = PyInt_AsLong(entry);
2731 if (type == 1) // teletext subtitles
2733 int page, magazine, pid;
2737 if (!m_teletext_parser)
2739 eDebug("enable teletext subtitles.. no parser !!!");
2743 entry = PyTuple_GET_ITEM(tuple, 1);
2744 if (!PyInt_Check(entry))
2746 pid = PyInt_AsLong(entry);
2748 entry = PyTuple_GET_ITEM(tuple, 2);
2749 if (!PyInt_Check(entry))
2751 page = PyInt_AsLong(entry);
2753 entry = PyTuple_GET_ITEM(tuple, 3);
2754 if (!PyInt_Check(entry))
2756 magazine = PyInt_AsLong(entry);
2758 m_subtitle_widget = new eSubtitleWidget(parent);
2759 m_subtitle_widget->resize(parent->size()); /* full size */
2760 m_teletext_parser->setPageAndMagazine(page, magazine);
2762 m_dvb_service->setCacheEntry(eDVBService::cSUBTITLE,((pid&0xFFFF)<<16)|((page&0xFF)<<8)|(magazine&0xFF));
2766 int pid = 0, composition_page_id = 0, ancillary_page_id = 0;
2767 if (!m_subtitle_parser)
2769 eDebug("enable dvb subtitles.. no parser !!!");
2775 entry = PyTuple_GET_ITEM(tuple, 1);
2776 if (!PyInt_Check(entry))
2778 pid = PyInt_AsLong(entry);
2780 entry = PyTuple_GET_ITEM(tuple, 2);
2781 if (!PyInt_Check(entry))
2783 composition_page_id = PyInt_AsLong(entry);
2785 entry = PyTuple_GET_ITEM(tuple, 3);
2786 if (!PyInt_Check(entry))
2788 ancillary_page_id = PyInt_AsLong(entry);
2790 m_subtitle_widget = new eSubtitleWidget(parent);
2791 m_subtitle_widget->resize(parent->size()); /* full size */
2792 m_subtitle_parser->start(pid, composition_page_id, ancillary_page_id);
2794 m_dvb_service->setCacheEntry(eDVBService::cSUBTITLE, ((pid&0xFFFF)<<16)|((composition_page_id&0xFF)<<8)|(ancillary_page_id&0xFF));
2800 eDebug("enableSubtitles needs a tuple as 2nd argument!\n"
2801 "for teletext subtitles (0, pid, teletext_page, teletext_magazine)\n"
2802 "for dvb subtitles (1, pid, composition_page_id, ancillary_page_id)");
2806 RESULT eDVBServicePlay::disableSubtitles(eWidget *parent)
2808 delete m_subtitle_widget;
2809 m_subtitle_widget = 0;
2810 if (m_subtitle_parser)
2812 m_subtitle_parser->stop();
2813 m_dvb_subtitle_pages.clear();
2815 if (m_teletext_parser)
2817 m_teletext_parser->setPageAndMagazine(-1, -1);
2818 m_subtitle_pages.clear();
2821 m_dvb_service->setCacheEntry(eDVBService::cSUBTITLE, -1);
2825 PyObject *eDVBServicePlay::getCachedSubtitle()
2829 int tmp = m_dvb_service->getCacheEntry(eDVBService::cSUBTITLE);
2832 unsigned int data = (unsigned int)tmp;
2833 int pid = (data&0xFFFF0000)>>16;
2834 ePyObject tuple = PyTuple_New(4);
2835 eDVBServicePMTHandler::program program;
2836 eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
2837 if (!h.getProgramInfo(program))
2839 if (program.textPid==pid) // teletext
2840 PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(1)); // type teletext
2842 PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(0)); // type dvb
2843 PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(pid)); // pid
2844 PyTuple_SET_ITEM(tuple, 2, PyInt_FromLong((data&0xFF00)>>8)); // composition_page / page
2845 PyTuple_SET_ITEM(tuple, 3, PyInt_FromLong(data&0xFF)); // ancillary_page / magazine
2853 PyObject *eDVBServicePlay::getSubtitleList()
2855 if (!m_teletext_parser)
2858 ePyObject l = PyList_New(0);
2859 std::set<int> added_ttx_pages;
2861 std::set<eDVBServicePMTHandler::subtitleStream> &subs =
2862 m_teletext_parser->m_found_subtitle_pages;
2864 eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
2865 eDVBServicePMTHandler::program program;
2866 if (h.getProgramInfo(program))
2867 eDebug("getting program info failed.");
2870 for (std::vector<eDVBServicePMTHandler::subtitleStream>::iterator it(program.subtitleStreams.begin());
2871 it != program.subtitleStreams.end(); ++it)
2873 switch(it->subtitling_type)
2875 case 0x01: // ebu teletext subtitles
2877 int page_number = it->teletext_page_number & 0xFF;
2878 int magazine_number = it->teletext_magazine_number & 7;
2879 int hash = magazine_number << 8 | page_number;
2880 if (added_ttx_pages.find(hash) == added_ttx_pages.end())
2882 ePyObject tuple = PyTuple_New(5);
2883 PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(1));
2884 PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(it->pid));
2885 PyTuple_SET_ITEM(tuple, 2, PyInt_FromLong(page_number));
2886 PyTuple_SET_ITEM(tuple, 3, PyInt_FromLong(magazine_number));
2887 PyTuple_SET_ITEM(tuple, 4, PyString_FromString(it->language_code.c_str()));
2888 PyList_Append(l, tuple);
2890 added_ttx_pages.insert(hash);
2895 case 0x20 ... 0x23: // dvb subtitles
2897 ePyObject tuple = PyTuple_New(5);
2898 PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(0));
2899 PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(it->pid));
2900 PyTuple_SET_ITEM(tuple, 2, PyInt_FromLong(it->composition_page_id));
2901 PyTuple_SET_ITEM(tuple, 3, PyInt_FromLong(it->ancillary_page_id));
2902 PyTuple_SET_ITEM(tuple, 4, PyString_FromString(it->language_code.c_str()));
2903 PyList_Insert(l, 0, tuple);
2911 for (std::set<eDVBServicePMTHandler::subtitleStream>::iterator it(subs.begin());
2912 it != subs.end(); ++it)
2914 int page_number = it->teletext_page_number & 0xFF;
2915 int magazine_number = it->teletext_magazine_number & 7;
2916 int hash = magazine_number << 8 | page_number;
2917 if (added_ttx_pages.find(hash) == added_ttx_pages.end())
2919 ePyObject tuple = PyTuple_New(5);
2920 PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(1));
2921 PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(it->pid));
2922 PyTuple_SET_ITEM(tuple, 2, PyInt_FromLong(page_number));
2923 PyTuple_SET_ITEM(tuple, 3, PyInt_FromLong(magazine_number));
2924 PyTuple_SET_ITEM(tuple, 4, PyString_FromString("und")); // undetermined
2925 PyList_Append(l, tuple);
2933 void eDVBServicePlay::newSubtitlePage(const eDVBTeletextSubtitlePage &page)
2935 if (m_subtitle_widget)
2939 m_decoder->getPTS(0, pos);
2940 eDebug("got new subtitle page %lld %lld %d", pos, page.m_pts, page.m_have_pts);
2941 m_subtitle_pages.push_back(page);
2942 checkSubtitleTiming();
2946 void eDVBServicePlay::checkSubtitleTiming()
2948 eDebug("checkSubtitleTiming");
2949 if (!m_subtitle_widget)
2953 enum { TELETEXT, DVB } type;
2954 eDVBTeletextSubtitlePage page;
2955 eDVBSubtitlePage dvb_page;
2957 if (!m_subtitle_pages.empty())
2959 page = m_subtitle_pages.front();
2961 show_time = page.m_pts;
2963 else if (!m_dvb_subtitle_pages.empty())
2965 dvb_page = m_dvb_subtitle_pages.front();
2967 show_time = dvb_page.m_show_time;
2975 m_decoder->getPTS(0, pos);
2977 eDebug("%lld %lld", pos, show_time);
2978 int diff = show_time - pos;
2979 if (type == TELETEXT && !page.m_have_pts)
2981 eDebug("ttx subtitle page without pts... immediate show");
2986 eDebug("[late (%d ms)]", -diff / 90);
2989 if (abs(diff) > 1800000)
2991 eDebug("[invalid]... immediate show!");
2996 if (type == TELETEXT)
2998 eDebug("display teletext subtitle page %lld", show_time);
2999 m_subtitle_widget->setPage(page);
3000 m_subtitle_pages.pop_front();
3004 eDebug("display dvb subtitle Page %lld", show_time);
3005 m_subtitle_widget->setPage(dvb_page);
3006 m_dvb_subtitle_pages.pop_front();
3010 eDebug("start subtitle delay %d", diff / 90);
3011 m_subtitle_sync_timer->start(diff / 90, 1);
3017 void eDVBServicePlay::newDVBSubtitlePage(const eDVBSubtitlePage &p)
3019 if (m_subtitle_widget)
3023 m_decoder->getPTS(0, pos);
3024 eDebug("got new subtitle page %lld %lld", pos, p.m_show_time);
3025 m_dvb_subtitle_pages.push_back(p);
3026 checkSubtitleTiming();
3030 int eDVBServicePlay::getAC3Delay()
3033 return m_dvb_service->getCacheEntry(eDVBService::cAC3DELAY);
3035 return m_decoder->getAC3Delay();
3040 int eDVBServicePlay::getPCMDelay()
3043 return m_dvb_service->getCacheEntry(eDVBService::cPCMDELAY);
3045 return m_decoder->getPCMDelay();
3050 void eDVBServicePlay::setAC3Delay(int delay)
3053 m_dvb_service->setCacheEntry(eDVBService::cAC3DELAY, delay ? delay : -1);
3055 std::string config_delay;
3056 int config_delay_int = 0;
3057 if(ePythonConfigQuery::getConfigValue("config.av.generalAC3delay", config_delay) == 0)
3058 config_delay_int = atoi(config_delay.c_str());
3059 m_decoder->setAC3Delay(delay + config_delay_int);
3063 void eDVBServicePlay::setPCMDelay(int delay)
3066 m_dvb_service->setCacheEntry(eDVBService::cPCMDELAY, delay ? delay : -1);
3068 std::string config_delay;
3069 int config_delay_int = 0;
3070 if(ePythonConfigQuery::getConfigValue("config.av.generalPCMdelay", config_delay) == 0)
3071 config_delay_int = atoi(config_delay.c_str());
3073 config_delay_int = 0;
3074 m_decoder->setPCMDelay(delay + config_delay_int);
3078 void eDVBServicePlay::video_event(struct iTSMPEGDecoder::videoEvent event)
3080 switch(event.type) {
3081 case iTSMPEGDecoder::videoEvent::eventSizeChanged:
3082 m_event((iPlayableService*)this, evVideoSizeChanged);
3084 case iTSMPEGDecoder::videoEvent::eventFrameRateChanged:
3085 m_event((iPlayableService*)this, evVideoFramerateChanged);
3087 case iTSMPEGDecoder::videoEvent::eventProgressiveChanged:
3088 m_event((iPlayableService*)this, evVideoProgressiveChanged);
3095 RESULT eDVBServicePlay::stream(ePtr<iStreamableService> &ptr)
3101 PyObject *eDVBServicePlay::getStreamingData()
3103 eDVBServicePMTHandler::program program;
3104 if (m_service_handler.getProgramInfo(program))
3109 ePyObject r = program.createPythonObject();
3110 ePtr<iDVBDemux> demux;
3111 if (!m_service_handler.getDataDemux(demux))
3114 if (!demux->getCADemuxID(demux_id))
3115 PutToDict(r, "demux", demux_id);
3122 DEFINE_REF(eDVBServicePlay)
3124 PyObject *eDVBService::getInfoObject(const eServiceReference &ref, int w)
3128 case iServiceInformation::sTransponderData:
3129 return eStaticServiceDVBInformation().getInfoObject(ref, w);
3133 return iStaticServiceInformation::getInfoObject(ref, w);
3136 eAutoInitPtr<eServiceFactoryDVB> init_eServiceFactoryDVB(eAutoInitNumbers::service+1, "eServiceFactoryDVB");