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 eServiceFactoryDVB::play(const eServiceReference &ref, ePtr<iPlayableService> &ptr)
275 ePtr<eDVBService> service;
276 int r = lookupService(service, ref);
279 // check resources...
280 ptr = new eDVBServicePlay(ref, service);
284 RESULT eServiceFactoryDVB::record(const eServiceReference &ref, ePtr<iRecordableService> &ptr)
286 if (ref.path.empty())
288 ptr = new eDVBServiceRecord((eServiceReferenceDVB&)ref);
297 RESULT eServiceFactoryDVB::list(const eServiceReference &ref, ePtr<iListableService> &ptr)
299 ePtr<eDVBServiceList> list = new eDVBServiceList(ref);
300 if (list->startQuery())
310 RESULT eServiceFactoryDVB::info(const eServiceReference &ref, ePtr<iStaticServiceInformation> &ptr)
312 /* do we have a PVR service? */
313 if (ref.flags & eServiceReference::flagDirectory) // bouquet
315 ptr = new eStaticServiceDVBBouquetInformation;
318 else if (!ref.path.empty())
320 ptr = new eStaticServiceDVBPVRInformation(ref);
325 ePtr<eDVBService> service;
326 int r = lookupService(service, ref);
328 ptr = new eStaticServiceDVBInformation;
330 /* eDVBService has the iStaticServiceInformation interface, so we pass it here. */
336 RESULT eServiceFactoryDVB::offlineOperations(const eServiceReference &ref, ePtr<iServiceOfflineOperations> &ptr)
338 if (ref.path.empty())
344 ptr = new eDVBPVRServiceOfflineOperations(ref);
349 RESULT eServiceFactoryDVB::lookupService(ePtr<eDVBService> &service, const eServiceReference &ref)
351 // TODO: handle the listing itself
352 // if (ref.... == -1) .. return "... bouquets ...";
353 // could be also done in another serviceFactory (with seperate ID) to seperate actual services and lists
355 ePtr<iDVBChannelList> db;
356 ePtr<eDVBResourceManager> res;
359 if ((err = eDVBResourceManager::getInstance(res)) != 0)
361 eDebug("no resource manager");
364 if ((err = res->getChannelList(db)) != 0)
366 eDebug("no channel list");
370 /* we are sure to have a ..DVB reference as the info() call was forwarded here according to it's ID. */
371 if ((err = db->getService((eServiceReferenceDVB&)ref, service)) != 0)
373 eDebug("getService failed!");
380 eDVBServicePlay::eDVBServicePlay(const eServiceReference &ref, eDVBService *service):
381 m_reference(ref), m_dvb_service(service), m_service_handler(0), m_is_paused(0)
383 m_is_pvr = !ref.path.empty();
385 CONNECT(m_service_handler.serviceEvent, eDVBServicePlay::serviceEvent);
386 CONNECT(m_event_handler.m_eit_changed, eDVBServicePlay::gotNewEvent);
389 eDVBServicePlay::~eDVBServicePlay()
393 void eDVBServicePlay::gotNewEvent()
397 ePtr<eServiceEvent> m_event_now, m_event_next;
398 getEvent(m_event_now, 0);
399 getEvent(m_event_next, 1);
402 eDebug("now running: %s (%d seconds :)", m_event_now->m_event_name.c_str(), m_event_now->m_duration);
404 eDebug("next running: %s (%d seconds :)", m_event_next->m_event_name.c_str(), m_event_next->m_duration);
406 m_event((iPlayableService*)this, evUpdatedEventInfo);
409 void eDVBServicePlay::serviceEvent(int event)
413 case eDVBServicePMTHandler::eventTuned:
415 ePtr<iDVBDemux> m_demux;
416 if (!m_service_handler.getDemux(m_demux))
418 // eventStartedEventAcquisition
419 m_event_handler.start(m_demux, ((eServiceReferenceDVB&)m_reference).getServiceID().get());
424 case eDVBServicePMTHandler::eventTuneFailed:
426 eDebug("DVB service failed to tune");
427 m_event((iPlayableService*)this, evTuneFailed);
430 case eDVBServicePMTHandler::eventNewProgramInfo:
432 int vpid = -1, apid = -1, pcrpid = -1;
433 eDVBServicePMTHandler::program program;
434 if (m_service_handler.getProgramInfo(program))
435 eDebug("getting program info failed.");
438 eDebugNoNewLine("have %d video stream(s)", program.videoStreams.size());
439 if (!program.videoStreams.empty())
441 eDebugNoNewLine(" (");
442 for (std::vector<eDVBServicePMTHandler::videoStream>::const_iterator
443 i(program.videoStreams.begin());
444 i != program.videoStreams.end(); ++i)
448 if (i != program.videoStreams.begin())
449 eDebugNoNewLine(", ");
450 eDebugNoNewLine("%04x", i->pid);
452 eDebugNoNewLine(")");
454 eDebugNoNewLine(", and %d audio stream(s)", program.audioStreams.size());
455 if (!program.audioStreams.empty())
457 eDebugNoNewLine(" (");
458 for (std::vector<eDVBServicePMTHandler::audioStream>::const_iterator
459 i(program.audioStreams.begin());
460 i != program.audioStreams.end(); ++i)
464 if (i != program.audioStreams.begin())
465 eDebugNoNewLine(", ");
466 eDebugNoNewLine("%04x", i->pid);
468 eDebugNoNewLine(")");
470 eDebug(", and the pcr pid is %04x", program.pcrPid);
471 if (program.pcrPid != 0x1fff)
472 pcrpid = program.pcrPid;
477 ePtr<iDVBDemux> demux;
478 m_service_handler.getDemux(demux);
480 demux->getMPEGDecoder(m_decoder);
485 m_decoder->setVideoPID(vpid);
486 m_decoder->setAudioPID(apid, 0);
488 m_decoder->setSyncPCR(pcrpid);
490 m_decoder->setSyncPCR(-1);
492 // how we can do this better?
493 // update cache pid when the user changed the audio track or video track
494 // TODO handling of difference audio types.. default audio types..
496 /* don't worry about non-existing services, nor pvr services */
497 if (m_dvb_service && !m_is_pvr)
499 m_dvb_service->setCachePID(eDVBService::cVPID, vpid);
500 m_dvb_service->setCachePID(eDVBService::cAPID, apid);
501 m_dvb_service->setCachePID(eDVBService::cPCRPID, pcrpid);
510 RESULT eDVBServicePlay::start()
513 eDebug("starting DVB service");
514 r = m_service_handler.tune((eServiceReferenceDVB&)m_reference);
515 eDebug("tune result: %d", r);
516 m_event(this, evStart);
520 RESULT eDVBServicePlay::stop()
522 eDebug("stopping..");
526 RESULT eDVBServicePlay::connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection)
528 connection = new eConnection((iPlayableService*)this, m_event.connect(event));
532 RESULT eDVBServicePlay::pause(ePtr<iPauseableService> &ptr)
544 RESULT eDVBServicePlay::seek(ePtr<iSeekableService> &ptr)
556 RESULT eDVBServicePlay::getLength(pts_t &len)
558 ePtr<iDVBPVRChannel> pvr_channel;
560 if (m_service_handler.getPVRChannel(pvr_channel))
562 eDebug("getPVRChannel failed!");
566 return pvr_channel->getLength(len);
569 RESULT eDVBServicePlay::pause()
571 if (!m_is_paused && m_decoder)
574 return m_decoder->freeze(0);
579 RESULT eDVBServicePlay::unpause()
581 if (m_is_paused && m_decoder)
584 return m_decoder->unfreeze();
589 RESULT eDVBServicePlay::seekTo(pts_t to)
594 RESULT eDVBServicePlay::seekRelative(int direction, pts_t to)
596 eDebug("eDVBServicePlay::seekRelative: jump %d, %lld", direction, to);
598 ePtr<iDVBPVRChannel> pvr_channel;
600 if (m_service_handler.getPVRChannel(pvr_channel))
603 return pvr_channel->seekToPosition(SEEK_CUR, to);
606 RESULT eDVBServicePlay::getPlayPosition(pts_t &pos)
608 ePtr<iDVBPVRChannel> pvr_channel;
610 if (m_service_handler.getPVRChannel(pvr_channel))
613 return pvr_channel->getCurrentPosition(pos);
616 RESULT eDVBServicePlay::info(ePtr<iServiceInformation> &ptr)
622 RESULT eDVBServicePlay::getName(std::string &name)
626 m_dvb_service->getName(m_reference, name);
630 name = "DVB service";
634 RESULT eDVBServicePlay::getEvent(ePtr<eServiceEvent> &evt, int nownext)
636 return m_event_handler.getEvent(evt, nownext);
639 DEFINE_REF(eDVBServicePlay)
641 eAutoInitPtr<eServiceFactoryDVB> init_eServiceFactoryDVB(eAutoInitNumbers::service+1, "eServiceFactoryDVB");