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 if ( ref.name.length() )
37 int eStaticServiceDVBInformation::getLength(const eServiceReference &ref)
42 class eStaticServiceDVBBouquetInformation: public iStaticServiceInformation
44 DECLARE_REF(eStaticServiceDVBBouquetInformation);
46 RESULT getName(const eServiceReference &ref, std::string &name);
47 int getLength(const eServiceReference &ref);
50 DEFINE_REF(eStaticServiceDVBBouquetInformation);
52 RESULT eStaticServiceDVBBouquetInformation::getName(const eServiceReference &ref, std::string &name)
54 ePtr<iDVBChannelList> db;
55 ePtr<eDVBResourceManager> res;
58 if ((err = eDVBResourceManager::getInstance(res)) != 0)
60 eDebug("eStaticServiceDVBBouquetInformation::getName failed.. no resource manager!");
63 if ((err = res->getChannelList(db)) != 0)
65 eDebug("eStaticServiceDVBBouquetInformation::getName failed.. no channel list!");
69 const eBouquet *bouquet=0;
70 if ((err = db->getBouquet(ref, bouquet)) != 0)
72 eDebug("eStaticServiceDVBBouquetInformation::getName failed.. getBouquet failed!");
76 if ( bouquet && bouquet->m_bouquet_name.length() )
78 name = "[Bouquet] " + bouquet->m_bouquet_name;
85 int eStaticServiceDVBBouquetInformation::getLength(const eServiceReference &ref)
90 class eStaticServiceDVBPVRInformation: public iStaticServiceInformation
92 DECLARE_REF(eStaticServiceDVBPVRInformation);
93 eServiceReference m_ref;
94 eDVBMetaParser m_parser;
96 eStaticServiceDVBPVRInformation(const eServiceReference &ref);
97 RESULT getName(const eServiceReference &ref, std::string &name);
98 int getLength(const eServiceReference &ref);
101 DEFINE_REF(eStaticServiceDVBPVRInformation);
103 eStaticServiceDVBPVRInformation::eStaticServiceDVBPVRInformation(const eServiceReference &ref)
106 m_parser.parseFile(ref.path);
109 RESULT eStaticServiceDVBPVRInformation::getName(const eServiceReference &ref, std::string &name)
111 ASSERT(ref == m_ref);
112 name = m_parser.m_name.size() ? m_parser.m_name : ref.path;
116 int eStaticServiceDVBPVRInformation::getLength(const eServiceReference &ref)
118 ASSERT(ref == m_ref);
122 if (tstools.openFile(ref.path.c_str()))
126 if (tstools.calcLen(len))
134 class eDVBPVRServiceOfflineOperations: public iServiceOfflineOperations
136 DECLARE_REF(eDVBPVRServiceOfflineOperations);
137 eServiceReferenceDVB m_ref;
139 eDVBPVRServiceOfflineOperations(const eServiceReference &ref);
141 RESULT deleteFromDisk(int simulate);
142 RESULT getListOfFilenames(std::list<std::string> &);
145 DEFINE_REF(eDVBPVRServiceOfflineOperations);
147 eDVBPVRServiceOfflineOperations::eDVBPVRServiceOfflineOperations(const eServiceReference &ref): m_ref((const eServiceReferenceDVB&)ref)
151 RESULT eDVBPVRServiceOfflineOperations::deleteFromDisk(int simulate)
157 std::list<std::string> res;
158 if (getListOfFilenames(res))
161 /* TODO: deferred removing.. */
162 for (std::list<std::string>::iterator i(res.begin()); i != res.end(); ++i)
164 eDebug("Removing %s...", i->c_str());
165 ::unlink(i->c_str());
172 RESULT eDVBPVRServiceOfflineOperations::getListOfFilenames(std::list<std::string> &res)
175 res.push_back(m_ref.path);
176 res.push_back(m_ref.path + ".meta");
180 DEFINE_REF(eServiceFactoryDVB)
182 eServiceFactoryDVB::eServiceFactoryDVB()
184 ePtr<eServiceCenter> sc;
186 eServiceCenter::getPrivInstance(sc);
188 sc->addServiceFactory(eServiceFactoryDVB::id, this);
191 eServiceFactoryDVB::~eServiceFactoryDVB()
193 ePtr<eServiceCenter> sc;
195 eServiceCenter::getPrivInstance(sc);
197 sc->removeServiceFactory(eServiceFactoryDVB::id);
200 DEFINE_REF(eDVBServiceList);
202 eDVBServiceList::eDVBServiceList(const eServiceReference &parent): m_parent(parent)
206 eDVBServiceList::~eDVBServiceList()
210 RESULT eDVBServiceList::startQuery()
212 ePtr<iDVBChannelList> db;
213 ePtr<eDVBResourceManager> res;
216 if ((err = eDVBResourceManager::getInstance(res)) != 0)
218 eDebug("no resource manager");
221 if ((err = res->getChannelList(db)) != 0)
223 eDebug("no channel list");
227 ePtr<eDVBChannelQuery> q;
229 if (!m_parent.path.empty())
231 eDVBChannelQuery::compile(q, m_parent.path);
234 eDebug("compile query failed");
239 if ((err = db->startQuery(m_query, q, m_parent)) != 0)
241 eDebug("startQuery failed");
248 RESULT eDVBServiceList::getContent(std::list<eServiceReference> &list)
250 eServiceReferenceDVB ref;
255 while (!m_query->getNextResult(ref))
260 RESULT eDVBServiceList::getNext(eServiceReference &ref)
265 return m_query->getNextResult((eServiceReferenceDVB&)ref);
268 int eDVBServiceList::compareLessEqual(const eServiceReference &a, const eServiceReference &b)
270 return m_query->compareLessEqual((const eServiceReferenceDVB&)a, (const eServiceReferenceDVB&)b);
273 RESULT eDVBServiceList::startEdit(ePtr<iMutableServiceList> &res)
275 if (m_parent.flags & eServiceReference::flagDirectory) // bouquet
277 ePtr<iDVBChannelList> db;
278 ePtr<eDVBResourceManager> resm;
280 if (eDVBResourceManager::getInstance(resm) || resm->getChannelList(db))
284 if (db->getBouquet(m_parent, (const eBouquet*&)m_bouquet) != 0)
295 RESULT eDVBServiceList::addService(eServiceReference &ref)
298 // return m_bouquet->addService(ref);
302 RESULT eDVBServiceList::removeService(eServiceReference &ref)
305 // return m_bouquet->removeService(ref);
309 RESULT eDVBServiceList::moveService(eServiceReference &ref, int pos)
313 // return m_bouquet->moveService(ref, pos);
317 RESULT eServiceFactoryDVB::play(const eServiceReference &ref, ePtr<iPlayableService> &ptr)
319 ePtr<eDVBService> service;
320 int r = lookupService(service, ref);
323 // check resources...
324 ptr = new eDVBServicePlay(ref, service);
328 RESULT eServiceFactoryDVB::record(const eServiceReference &ref, ePtr<iRecordableService> &ptr)
330 if (ref.path.empty())
332 ptr = new eDVBServiceRecord((eServiceReferenceDVB&)ref);
341 RESULT eServiceFactoryDVB::list(const eServiceReference &ref, ePtr<iListableService> &ptr)
343 ePtr<eDVBServiceList> list = new eDVBServiceList(ref);
344 if (list->startQuery())
354 RESULT eServiceFactoryDVB::info(const eServiceReference &ref, ePtr<iStaticServiceInformation> &ptr)
356 /* do we have a PVR service? */
357 if (ref.flags & eServiceReference::flagDirectory) // bouquet
359 ptr = new eStaticServiceDVBBouquetInformation;
362 else if (!ref.path.empty())
364 ptr = new eStaticServiceDVBPVRInformation(ref);
369 ePtr<eDVBService> service;
370 int r = lookupService(service, ref);
372 ptr = new eStaticServiceDVBInformation;
374 /* eDVBService has the iStaticServiceInformation interface, so we pass it here. */
380 RESULT eServiceFactoryDVB::offlineOperations(const eServiceReference &ref, ePtr<iServiceOfflineOperations> &ptr)
382 if (ref.path.empty())
388 ptr = new eDVBPVRServiceOfflineOperations(ref);
393 RESULT eServiceFactoryDVB::lookupService(ePtr<eDVBService> &service, const eServiceReference &ref)
395 // TODO: handle the listing itself
396 // if (ref.... == -1) .. return "... bouquets ...";
397 // could be also done in another serviceFactory (with seperate ID) to seperate actual services and lists
399 ePtr<iDVBChannelList> db;
400 ePtr<eDVBResourceManager> res;
403 if ((err = eDVBResourceManager::getInstance(res)) != 0)
405 eDebug("no resource manager");
408 if ((err = res->getChannelList(db)) != 0)
410 eDebug("no channel list");
414 /* we are sure to have a ..DVB reference as the info() call was forwarded here according to it's ID. */
415 if ((err = db->getService((eServiceReferenceDVB&)ref, service)) != 0)
417 eDebug("getService failed!");
424 eDVBServicePlay::eDVBServicePlay(const eServiceReference &ref, eDVBService *service):
425 m_reference(ref), m_dvb_service(service), m_service_handler(0), m_is_paused(0)
427 m_is_pvr = !ref.path.empty();
429 CONNECT(m_service_handler.serviceEvent, eDVBServicePlay::serviceEvent);
430 CONNECT(m_event_handler.m_eit_changed, eDVBServicePlay::gotNewEvent);
433 eDVBServicePlay::~eDVBServicePlay()
437 void eDVBServicePlay::gotNewEvent()
441 ePtr<eServiceEvent> m_event_now, m_event_next;
442 getEvent(m_event_now, 0);
443 getEvent(m_event_next, 1);
446 eDebug("now running: %s (%d seconds :)", m_event_now->m_event_name.c_str(), m_event_now->m_duration);
448 eDebug("next running: %s (%d seconds :)", m_event_next->m_event_name.c_str(), m_event_next->m_duration);
450 m_event((iPlayableService*)this, evUpdatedEventInfo);
453 void eDVBServicePlay::serviceEvent(int event)
457 case eDVBServicePMTHandler::eventTuned:
459 ePtr<iDVBDemux> m_demux;
460 if (!m_service_handler.getDemux(m_demux))
462 // eventStartedEventAcquisition
463 m_event_handler.start(m_demux, ((eServiceReferenceDVB&)m_reference).getServiceID().get());
468 case eDVBServicePMTHandler::eventTuneFailed:
470 eDebug("DVB service failed to tune");
471 m_event((iPlayableService*)this, evTuneFailed);
474 case eDVBServicePMTHandler::eventNewProgramInfo:
476 int vpid = -1, apid = -1, pcrpid = -1;
477 eDVBServicePMTHandler::program program;
478 if (m_service_handler.getProgramInfo(program))
479 eDebug("getting program info failed.");
482 eDebugNoNewLine("have %d video stream(s)", program.videoStreams.size());
483 if (!program.videoStreams.empty())
485 eDebugNoNewLine(" (");
486 for (std::vector<eDVBServicePMTHandler::videoStream>::const_iterator
487 i(program.videoStreams.begin());
488 i != program.videoStreams.end(); ++i)
492 if (i != program.videoStreams.begin())
493 eDebugNoNewLine(", ");
494 eDebugNoNewLine("%04x", i->pid);
496 eDebugNoNewLine(")");
498 eDebugNoNewLine(", and %d audio stream(s)", program.audioStreams.size());
499 if (!program.audioStreams.empty())
501 eDebugNoNewLine(" (");
502 for (std::vector<eDVBServicePMTHandler::audioStream>::const_iterator
503 i(program.audioStreams.begin());
504 i != program.audioStreams.end(); ++i)
508 if (i != program.audioStreams.begin())
509 eDebugNoNewLine(", ");
510 eDebugNoNewLine("%04x", i->pid);
512 eDebugNoNewLine(")");
514 eDebug(", and the pcr pid is %04x", program.pcrPid);
515 if (program.pcrPid != 0x1fff)
516 pcrpid = program.pcrPid;
521 ePtr<iDVBDemux> demux;
522 m_service_handler.getDemux(demux);
524 demux->getMPEGDecoder(m_decoder);
529 m_decoder->setVideoPID(vpid);
530 m_decoder->setAudioPID(apid, 0);
532 m_decoder->setSyncPCR(pcrpid);
534 m_decoder->setSyncPCR(-1);
536 // how we can do this better?
537 // update cache pid when the user changed the audio track or video track
538 // TODO handling of difference audio types.. default audio types..
540 /* don't worry about non-existing services, nor pvr services */
541 if (m_dvb_service && !m_is_pvr)
543 m_dvb_service->setCachePID(eDVBService::cVPID, vpid);
544 m_dvb_service->setCachePID(eDVBService::cAPID, apid);
545 m_dvb_service->setCachePID(eDVBService::cPCRPID, pcrpid);
554 RESULT eDVBServicePlay::start()
557 eDebug("starting DVB service");
558 r = m_service_handler.tune((eServiceReferenceDVB&)m_reference);
559 eDebug("tune result: %d", r);
560 m_event(this, evStart);
564 RESULT eDVBServicePlay::stop()
566 eDebug("stopping..");
570 RESULT eDVBServicePlay::connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection)
572 connection = new eConnection((iPlayableService*)this, m_event.connect(event));
576 RESULT eDVBServicePlay::pause(ePtr<iPauseableService> &ptr)
588 RESULT eDVBServicePlay::seek(ePtr<iSeekableService> &ptr)
600 RESULT eDVBServicePlay::getLength(pts_t &len)
602 ePtr<iDVBPVRChannel> pvr_channel;
604 if (m_service_handler.getPVRChannel(pvr_channel))
606 eDebug("getPVRChannel failed!");
610 return pvr_channel->getLength(len);
613 RESULT eDVBServicePlay::pause()
615 if (!m_is_paused && m_decoder)
618 return m_decoder->freeze(0);
623 RESULT eDVBServicePlay::unpause()
625 if (m_is_paused && m_decoder)
628 return m_decoder->unfreeze();
633 RESULT eDVBServicePlay::seekTo(pts_t to)
638 RESULT eDVBServicePlay::seekRelative(int direction, pts_t to)
640 eDebug("eDVBServicePlay::seekRelative: jump %d, %lld", direction, to);
642 ePtr<iDVBPVRChannel> pvr_channel;
644 if (m_service_handler.getPVRChannel(pvr_channel))
647 return pvr_channel->seekToPosition(SEEK_CUR, to);
650 RESULT eDVBServicePlay::getPlayPosition(pts_t &pos)
652 ePtr<iDVBPVRChannel> pvr_channel;
654 if (m_service_handler.getPVRChannel(pvr_channel))
657 return pvr_channel->getCurrentPosition(pos);
660 RESULT eDVBServicePlay::info(ePtr<iServiceInformation> &ptr)
666 RESULT eDVBServicePlay::getName(std::string &name)
670 m_dvb_service->getName(m_reference, name);
674 name = "DVB service";
678 RESULT eDVBServicePlay::getEvent(ePtr<eServiceEvent> &evt, int nownext)
680 return m_event_handler.getEvent(evt, nownext);
683 DEFINE_REF(eDVBServicePlay)
685 eAutoInitPtr<eServiceFactoryDVB> init_eServiceFactoryDVB(eAutoInitNumbers::service+1, "eServiceFactoryDVB");