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/init_num.h>
7 #include <lib/base/init.h>
9 #include <lib/dvb/dvb.h>
10 #include <lib/dvb/db.h>
12 #include <lib/service/servicedvbrecord.h>
13 #include <lib/dvb/metaparser.h>
14 #include <lib/dvb/tstools.h>
16 class eStaticServiceDVBInformation: public iStaticServiceInformation
18 DECLARE_REF(eStaticServiceDVBInformation);
20 RESULT getName(const eServiceReference &ref, std::string &name);
21 int getLength(const eServiceReference &ref);
24 DEFINE_REF(eStaticServiceDVBInformation);
26 RESULT eStaticServiceDVBInformation::getName(const eServiceReference &ref, std::string &name)
28 eServiceReferenceDVB &service = (eServiceReferenceDVB&)ref;
29 if ( !ref.name.empty() )
31 if (service.getParentTransportStreamID().get()) // linkage subservice
33 ePtr<iServiceHandler> service_center;
34 if (!eServiceCenter::getInstance(service_center))
36 eServiceReferenceDVB parent = service;
37 parent.setTransportStreamID( service.getParentTransportStreamID() );
38 parent.setServiceID( service.getParentServiceID() );
39 parent.setParentTransportStreamID(eTransportStreamID(0));
40 parent.setParentServiceID(eServiceID(0));
42 ePtr<iStaticServiceInformation> service_info;
43 if (!service_center->info(parent, service_info))
45 if (!service_info->getName(parent, name))
47 // just show short name
48 unsigned int pos = name.find("\xc2\x86");
49 if ( pos != std::string::npos )
51 pos = name.find("\xc2\x87");
52 if ( pos != std::string::npos )
68 int eStaticServiceDVBInformation::getLength(const eServiceReference &ref)
73 class eStaticServiceDVBBouquetInformation: public iStaticServiceInformation
75 DECLARE_REF(eStaticServiceDVBBouquetInformation);
77 RESULT getName(const eServiceReference &ref, std::string &name);
78 int getLength(const eServiceReference &ref);
81 DEFINE_REF(eStaticServiceDVBBouquetInformation);
83 RESULT eStaticServiceDVBBouquetInformation::getName(const eServiceReference &ref, std::string &name)
85 ePtr<iDVBChannelList> db;
86 ePtr<eDVBResourceManager> res;
89 if ((err = eDVBResourceManager::getInstance(res)) != 0)
91 eDebug("eStaticServiceDVBBouquetInformation::getName failed.. no resource manager!");
94 if ((err = res->getChannelList(db)) != 0)
96 eDebug("eStaticServiceDVBBouquetInformation::getName failed.. no channel list!");
101 if ((err = db->getBouquet(ref, bouquet)) != 0)
103 eDebug("eStaticServiceDVBBouquetInformation::getName failed.. getBouquet failed!");
107 if ( bouquet && bouquet->m_bouquet_name.length() )
109 name = bouquet->m_bouquet_name;
116 int eStaticServiceDVBBouquetInformation::getLength(const eServiceReference &ref)
121 class eStaticServiceDVBPVRInformation: public iStaticServiceInformation
123 DECLARE_REF(eStaticServiceDVBPVRInformation);
124 eServiceReference m_ref;
125 eDVBMetaParser m_parser;
127 eStaticServiceDVBPVRInformation(const eServiceReference &ref);
128 RESULT getName(const eServiceReference &ref, std::string &name);
129 int getLength(const eServiceReference &ref);
131 int getInfo(const eServiceReference &ref, int w);
132 std::string getInfoString(const eServiceReference &ref,int w);
135 DEFINE_REF(eStaticServiceDVBPVRInformation);
137 eStaticServiceDVBPVRInformation::eStaticServiceDVBPVRInformation(const eServiceReference &ref)
140 m_parser.parseFile(ref.path);
143 RESULT eStaticServiceDVBPVRInformation::getName(const eServiceReference &ref, std::string &name)
145 ASSERT(ref == m_ref);
146 name = m_parser.m_name.size() ? m_parser.m_name : ref.path;
150 int eStaticServiceDVBPVRInformation::getLength(const eServiceReference &ref)
152 ASSERT(ref == m_ref);
156 if (tstools.openFile(ref.path.c_str()))
160 if (tstools.calcLen(len))
166 int eStaticServiceDVBPVRInformation::getInfo(const eServiceReference &ref, int w)
170 case iServiceInformation::sDescription:
171 return iServiceInformation::resIsString;
172 case iServiceInformation::sTimeCreate:
173 if (m_parser.m_time_create)
174 return m_parser.m_time_create;
176 return iServiceInformation::resNA;
178 return iServiceInformation::resNA;
182 std::string eStaticServiceDVBPVRInformation::getInfoString(const eServiceReference &ref,int w)
186 case iServiceInformation::sDescription:
187 return m_parser.m_description;
193 class eDVBPVRServiceOfflineOperations: public iServiceOfflineOperations
195 DECLARE_REF(eDVBPVRServiceOfflineOperations);
196 eServiceReferenceDVB m_ref;
198 eDVBPVRServiceOfflineOperations(const eServiceReference &ref);
200 RESULT deleteFromDisk(int simulate);
201 RESULT getListOfFilenames(std::list<std::string> &);
204 DEFINE_REF(eDVBPVRServiceOfflineOperations);
206 eDVBPVRServiceOfflineOperations::eDVBPVRServiceOfflineOperations(const eServiceReference &ref): m_ref((const eServiceReferenceDVB&)ref)
210 RESULT eDVBPVRServiceOfflineOperations::deleteFromDisk(int simulate)
216 std::list<std::string> res;
217 if (getListOfFilenames(res))
220 /* TODO: deferred removing.. */
221 for (std::list<std::string>::iterator i(res.begin()); i != res.end(); ++i)
223 eDebug("Removing %s...", i->c_str());
224 ::unlink(i->c_str());
231 RESULT eDVBPVRServiceOfflineOperations::getListOfFilenames(std::list<std::string> &res)
234 res.push_back(m_ref.path);
235 res.push_back(m_ref.path + ".meta");
239 DEFINE_REF(eServiceFactoryDVB)
241 eServiceFactoryDVB::eServiceFactoryDVB()
243 ePtr<eServiceCenter> sc;
245 eServiceCenter::getPrivInstance(sc);
247 sc->addServiceFactory(eServiceFactoryDVB::id, this);
250 eServiceFactoryDVB::~eServiceFactoryDVB()
252 ePtr<eServiceCenter> sc;
254 eServiceCenter::getPrivInstance(sc);
256 sc->removeServiceFactory(eServiceFactoryDVB::id);
259 DEFINE_REF(eDVBServiceList);
261 eDVBServiceList::eDVBServiceList(const eServiceReference &parent): m_parent(parent)
265 eDVBServiceList::~eDVBServiceList()
269 RESULT eDVBServiceList::startQuery()
271 ePtr<iDVBChannelList> db;
272 ePtr<eDVBResourceManager> res;
275 if ((err = eDVBResourceManager::getInstance(res)) != 0)
277 eDebug("no resource manager");
280 if ((err = res->getChannelList(db)) != 0)
282 eDebug("no channel list");
286 ePtr<eDVBChannelQuery> q;
288 if (!m_parent.path.empty())
290 eDVBChannelQuery::compile(q, m_parent.path);
293 eDebug("compile query failed");
298 if ((err = db->startQuery(m_query, q, m_parent)) != 0)
300 eDebug("startQuery failed");
307 RESULT eDVBServiceList::getContent(std::list<eServiceReference> &list)
309 eServiceReferenceDVB ref;
314 while (!m_query->getNextResult(ref))
319 RESULT eDVBServiceList::getNext(eServiceReference &ref)
324 return m_query->getNextResult((eServiceReferenceDVB&)ref);
327 int eDVBServiceList::compareLessEqual(const eServiceReference &a, const eServiceReference &b)
329 return m_query->compareLessEqual((const eServiceReferenceDVB&)a, (const eServiceReferenceDVB&)b);
332 RESULT eDVBServiceList::startEdit(ePtr<iMutableServiceList> &res)
334 if (m_parent.flags & eServiceReference::flagDirectory) // bouquet
336 ePtr<iDVBChannelList> db;
337 ePtr<eDVBResourceManager> resm;
339 if (eDVBResourceManager::getInstance(resm) || resm->getChannelList(db))
342 if (db->getBouquet(m_parent, m_bouquet) != 0)
353 RESULT eDVBServiceList::addService(eServiceReference &ref)
357 return m_bouquet->addService(ref);
360 RESULT eDVBServiceList::removeService(eServiceReference &ref)
364 return m_bouquet->removeService(ref);
367 RESULT eDVBServiceList::moveService(eServiceReference &ref, int pos)
371 return m_bouquet->moveService(ref, pos);
374 RESULT eDVBServiceList::flushChanges()
378 return m_bouquet->flushChanges();
381 RESULT eServiceFactoryDVB::play(const eServiceReference &ref, ePtr<iPlayableService> &ptr)
383 ePtr<eDVBService> service;
384 int r = lookupService(service, ref);
387 // check resources...
388 ptr = new eDVBServicePlay(ref, service);
392 RESULT eServiceFactoryDVB::record(const eServiceReference &ref, ePtr<iRecordableService> &ptr)
394 if (ref.path.empty())
396 ptr = new eDVBServiceRecord((eServiceReferenceDVB&)ref);
405 RESULT eServiceFactoryDVB::list(const eServiceReference &ref, ePtr<iListableService> &ptr)
407 ePtr<eDVBServiceList> list = new eDVBServiceList(ref);
408 if (list->startQuery())
418 RESULT eServiceFactoryDVB::info(const eServiceReference &ref, ePtr<iStaticServiceInformation> &ptr)
420 /* is a listable service? */
421 if ((ref.flags & eServiceReference::flagDirectory) == eServiceReference::flagDirectory) // bouquet
423 if ( !ref.name.empty() ) // satellites or providers list
424 ptr = new eStaticServiceDVBInformation;
425 else // a dvb bouquet
426 ptr = new eStaticServiceDVBBouquetInformation;
428 else if (!ref.path.empty()) /* do we have a PVR service? */
429 ptr = new eStaticServiceDVBPVRInformation(ref);
430 else // normal dvb service
432 ePtr<eDVBService> service;
433 if (lookupService(service, ref)) // no eDVBService avail for this reference ( Linkage Services... )
434 ptr = new eStaticServiceDVBInformation;
436 /* eDVBService has the iStaticServiceInformation interface, so we pass it here. */
442 RESULT eServiceFactoryDVB::offlineOperations(const eServiceReference &ref, ePtr<iServiceOfflineOperations> &ptr)
444 if (ref.path.empty())
450 ptr = new eDVBPVRServiceOfflineOperations(ref);
455 RESULT eServiceFactoryDVB::lookupService(ePtr<eDVBService> &service, const eServiceReference &ref)
457 // TODO: handle the listing itself
458 // if (ref.... == -1) .. return "... bouquets ...";
459 // could be also done in another serviceFactory (with seperate ID) to seperate actual services and lists
461 ePtr<iDVBChannelList> db;
462 ePtr<eDVBResourceManager> res;
465 if ((err = eDVBResourceManager::getInstance(res)) != 0)
467 eDebug("no resource manager");
470 if ((err = res->getChannelList(db)) != 0)
472 eDebug("no channel list");
476 /* we are sure to have a ..DVB reference as the info() call was forwarded here according to it's ID. */
477 if ((err = db->getService((eServiceReferenceDVB&)ref, service)) != 0)
479 eDebug("getService failed!");
486 eDVBServicePlay::eDVBServicePlay(const eServiceReference &ref, eDVBService *service):
487 m_reference(ref), m_dvb_service(service), m_service_handler(0), m_is_paused(0)
489 m_is_pvr = !ref.path.empty();
490 m_timeshift_enabled = 0;
492 CONNECT(m_service_handler.serviceEvent, eDVBServicePlay::serviceEvent);
493 CONNECT(m_event_handler.m_eit_changed, eDVBServicePlay::gotNewEvent);
496 eDVBServicePlay::~eDVBServicePlay()
500 void eDVBServicePlay::gotNewEvent()
504 ePtr<eServiceEvent> m_event_now, m_event_next;
505 getEvent(m_event_now, 0);
506 getEvent(m_event_next, 1);
509 eDebug("now running: %s (%d seconds :)", m_event_now->m_event_name.c_str(), m_event_now->m_duration);
511 eDebug("next running: %s (%d seconds :)", m_event_next->m_event_name.c_str(), m_event_next->m_duration);
513 m_event((iPlayableService*)this, evUpdatedEventInfo);
516 void eDVBServicePlay::serviceEvent(int event)
520 case eDVBServicePMTHandler::eventTuned:
522 ePtr<iDVBDemux> m_demux;
523 if (!m_service_handler.getDemux(m_demux))
525 eServiceReferenceDVB &ref = (eServiceReferenceDVB&) m_reference;
526 int sid = ref.getParentServiceID().get();
528 sid = ref.getServiceID().get();
529 if ( ref.getParentTransportStreamID().get() &&
530 ref.getParentTransportStreamID() != ref.getTransportStreamID() )
531 m_event_handler.startOther(m_demux, sid);
533 m_event_handler.start(m_demux, sid);
537 case eDVBServicePMTHandler::eventTuneFailed:
539 eDebug("DVB service failed to tune");
540 m_event((iPlayableService*)this, evTuneFailed);
543 case eDVBServicePMTHandler::eventNewProgramInfo:
545 int vpid = -1, apid = -1, apidtype = -1, pcrpid = -1;
546 eDVBServicePMTHandler::program program;
547 if (m_service_handler.getProgramInfo(program))
548 eDebug("getting program info failed.");
551 eDebugNoNewLine("have %d video stream(s)", program.videoStreams.size());
552 if (!program.videoStreams.empty())
554 eDebugNoNewLine(" (");
555 for (std::vector<eDVBServicePMTHandler::videoStream>::const_iterator
556 i(program.videoStreams.begin());
557 i != program.videoStreams.end(); ++i)
561 if (i != program.videoStreams.begin())
562 eDebugNoNewLine(", ");
563 eDebugNoNewLine("%04x", i->pid);
565 eDebugNoNewLine(")");
567 eDebugNoNewLine(", and %d audio stream(s)", program.audioStreams.size());
568 if (!program.audioStreams.empty())
570 eDebugNoNewLine(" (");
571 for (std::vector<eDVBServicePMTHandler::audioStream>::const_iterator
572 i(program.audioStreams.begin());
573 i != program.audioStreams.end(); ++i)
580 if (i != program.audioStreams.begin())
581 eDebugNoNewLine(", ");
582 eDebugNoNewLine("%04x", i->pid);
584 eDebugNoNewLine(")");
586 eDebug(", and the pcr pid is %04x", program.pcrPid);
587 if (program.pcrPid != 0x1fff)
588 pcrpid = program.pcrPid;
593 ePtr<iDVBDemux> demux;
594 m_service_handler.getDemux(demux);
596 demux->getMPEGDecoder(m_decoder);
601 m_decoder->setVideoPID(vpid);
602 m_current_audio_stream = 0;
603 m_decoder->setAudioPID(apid, apidtype);
605 m_decoder->setSyncPCR(pcrpid);
607 m_decoder->setSyncPCR(-1);
609 // how we can do this better?
610 // update cache pid when the user changed the audio track or video track
611 // TODO handling of difference audio types.. default audio types..
613 /* don't worry about non-existing services, nor pvr services */
614 if (m_dvb_service && !m_is_pvr)
616 m_dvb_service->setCachePID(eDVBService::cVPID, vpid);
617 m_dvb_service->setCachePID(eDVBService::cAPID, apid);
618 m_dvb_service->setCachePID(eDVBService::cPCRPID, pcrpid);
627 RESULT eDVBServicePlay::start()
630 eDebug("starting DVB service");
631 r = m_service_handler.tune((eServiceReferenceDVB&)m_reference);
632 eDebug("tune result: %d", r);
633 m_event(this, evStart);
637 RESULT eDVBServicePlay::stop()
639 eDebug("stopping..");
643 RESULT eDVBServicePlay::connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection)
645 connection = new eConnection((iPlayableService*)this, m_event.connect(event));
649 RESULT eDVBServicePlay::pause(ePtr<iPauseableService> &ptr)
661 RESULT eDVBServicePlay::setSlowMotion(int ratio)
664 return m_decoder->setSlowMotion(ratio);
669 RESULT eDVBServicePlay::setFastForward(int ratio)
672 return m_decoder->setFastForward(ratio);
677 RESULT eDVBServicePlay::seek(ePtr<iSeekableService> &ptr)
689 RESULT eDVBServicePlay::getLength(pts_t &len)
691 ePtr<iDVBPVRChannel> pvr_channel;
693 if (m_service_handler.getPVRChannel(pvr_channel))
695 eDebug("getPVRChannel failed!");
699 return pvr_channel->getLength(len);
702 RESULT eDVBServicePlay::pause()
704 if (!m_is_paused && m_decoder)
707 return m_decoder->freeze(0);
712 RESULT eDVBServicePlay::unpause()
714 if (m_is_paused && m_decoder)
717 return m_decoder->unfreeze();
722 RESULT eDVBServicePlay::seekTo(pts_t to)
727 RESULT eDVBServicePlay::seekRelative(int direction, pts_t to)
729 eDebug("eDVBServicePlay::seekRelative: jump %d, %lld", direction, to);
731 ePtr<iDVBPVRChannel> pvr_channel;
733 if (m_service_handler.getPVRChannel(pvr_channel))
738 ePtr<iDVBDemux> demux;
739 m_service_handler.getDemux(demux);
743 return pvr_channel->seekTo(demux, 1, to);
746 RESULT eDVBServicePlay::getPlayPosition(pts_t &pos)
748 ePtr<iDVBPVRChannel> pvr_channel;
750 if (m_service_handler.getPVRChannel(pvr_channel))
753 ePtr<iDVBDemux> demux;
754 m_service_handler.getDemux(demux);
758 return pvr_channel->getCurrentPosition(demux, pos);
761 RESULT eDVBServicePlay::setTrickmode(int trick=0)
764 m_decoder->setTrickmode(trick);
768 RESULT eDVBServicePlay::frontendStatusInfo(ePtr<iFrontendStatusInformation> &ptr)
774 RESULT eDVBServicePlay::info(ePtr<iServiceInformation> &ptr)
780 RESULT eDVBServicePlay::audioTracks(ePtr<iAudioTrackSelection> &ptr)
786 RESULT eDVBServicePlay::subServices(ePtr<iSubserviceList> &ptr)
792 RESULT eDVBServicePlay::timeshift(ePtr<iTimeshiftService> &ptr)
794 if (m_timeshift_enabled || !m_is_pvr)
803 RESULT eDVBServicePlay::getName(std::string &name)
807 m_dvb_service->getName(m_reference, name);
811 else if (!m_reference.name.empty())
812 eStaticServiceDVBInformation().getName(m_reference, name);
814 name = "DVB service";
818 RESULT eDVBServicePlay::getEvent(ePtr<eServiceEvent> &evt, int nownext)
820 return m_event_handler.getEvent(evt, nownext);
823 int eDVBServicePlay::getInfo(int w)
825 eDVBServicePMTHandler::program program;
827 if (m_service_handler.getProgramInfo(program))
832 case sVideoPID: if (program.videoStreams.empty()) return -1; return program.videoStreams[0].pid;
833 case sAudioPID: if (program.audioStreams.empty()) return -1; return program.audioStreams[m_current_audio_stream].pid;
834 case sPCRPID: return program.pcrPid;
835 case sPMTPID: return program.pmtPid;
836 case sTXTPID: return -1;
838 case sSID: return ((const eServiceReferenceDVB&)m_reference).getServiceID().get();
839 case sONID: return ((const eServiceReferenceDVB&)m_reference).getOriginalNetworkID().get();
840 case sTSID: return ((const eServiceReferenceDVB&)m_reference).getTransportStreamID().get();
841 case sNamespace: return ((const eServiceReferenceDVB&)m_reference).getDVBNamespace().get();
842 case sProvider: if (!m_dvb_service) return -1; return -2;
848 std::string eDVBServicePlay::getInfoString(int w)
853 if (!m_dvb_service) return "";
854 return m_dvb_service->m_provider_name;
860 int eDVBServicePlay::getNumberOfTracks()
862 eDVBServicePMTHandler::program program;
863 if (m_service_handler.getProgramInfo(program))
865 return program.audioStreams.size();
868 RESULT eDVBServicePlay::selectTrack(unsigned int i)
870 int ret = selectAudioStream(i);
872 if (m_decoder->start())
878 RESULT eDVBServicePlay::getTrackInfo(struct iAudioTrackInfo &info, unsigned int i)
880 eDVBServicePMTHandler::program program;
882 if (m_service_handler.getProgramInfo(program))
885 if (i >= program.audioStreams.size())
888 if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atMPEG)
889 info.m_description = "MPEG";
890 else if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atAC3)
891 info.m_description = "AC3";
892 else if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atDTS)
893 info.m_description = "DTS";
895 info.m_description = "???";
897 if (program.audioStreams[i].component_tag != -1)
899 ePtr<eServiceEvent> evt;
900 if (!m_event_handler.getEvent(evt, 0))
902 ePtr<eComponentData> data;
903 if (!evt->getComponentData(data, program.audioStreams[i].component_tag))
904 info.m_language = data->getText();
908 if (info.m_language.empty())
909 info.m_language = program.audioStreams[i].language_code;
914 int eDVBServicePlay::selectAudioStream(int i)
916 eDVBServicePMTHandler::program program;
918 if (m_service_handler.getProgramInfo(program))
921 if ((unsigned int)i >= program.audioStreams.size())
927 if (m_decoder->setAudioPID(program.audioStreams[i].pid, program.audioStreams[i].type))
930 m_current_audio_stream = i;
935 int eDVBServicePlay::getFrontendInfo(int w)
939 eUsePtr<iDVBChannel> channel;
940 if(m_service_handler.getChannel(channel))
942 ePtr<iDVBFrontend> fe;
943 if(channel->getFrontend(fe))
945 return fe->readFrontendData(w);
948 int eDVBServicePlay::getNumberOfSubservices()
950 ePtr<eServiceEvent> evt;
951 if (!m_event_handler.getEvent(evt, 0))
952 return evt->getNumOfLinkageServices();
956 RESULT eDVBServicePlay::getSubservice(eServiceReference &sub, unsigned int n)
958 ePtr<eServiceEvent> evt;
959 if (!m_event_handler.getEvent(evt, 0))
961 if (!evt->getLinkageService(sub, n))
963 eServiceReferenceDVB &subservice = (eServiceReferenceDVB&) sub;
964 eServiceReferenceDVB ¤t = (eServiceReferenceDVB&) m_reference;
965 subservice.setDVBNamespace(current.getDVBNamespace());
966 if ( current.getParentTransportStreamID().get() )
968 subservice.setParentTransportStreamID( current.getParentTransportStreamID() );
969 subservice.setParentServiceID( current.getParentServiceID() );
973 subservice.setParentTransportStreamID( current.getTransportStreamID() );
974 subservice.setParentServiceID( current.getServiceID() );
976 if ( subservice.getParentTransportStreamID() == subservice.getTransportStreamID() &&
977 subservice.getParentServiceID() == subservice.getServiceID() )
979 subservice.setParentTransportStreamID( eTransportStreamID(0) );
980 subservice.setParentServiceID( eServiceID(0) );
985 sub.type=eServiceReference::idInvalid;
989 RESULT eDVBServicePlay::startTimeshift()
991 if (m_timeshift_enabled)
993 eDebug("TIMESHIFT - start!");
997 RESULT eDVBServicePlay::stopTimeshift()
999 if (!m_timeshift_enabled)
1001 m_timeshift_enabled = 0;
1002 eDebug("timeshift disabled");
1006 DEFINE_REF(eDVBServicePlay)
1008 eAutoInitPtr<eServiceFactoryDVB> init_eServiceFactoryDVB(eAutoInitNumbers::service+1, "eServiceFactoryDVB");