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 eStaticServiceDVBPVRInformation: public iStaticServiceInformation
18 DECLARE_REF(eStaticServiceDVBPVRInformation);
19 eServiceReference m_ref;
20 eDVBMetaParser m_parser;
22 eStaticServiceDVBPVRInformation(const eServiceReference &ref);
23 RESULT getName(const eServiceReference &ref, std::string &name);
24 int getLength(const eServiceReference &ref);
27 DEFINE_REF(eStaticServiceDVBPVRInformation);
29 eStaticServiceDVBPVRInformation::eStaticServiceDVBPVRInformation(const eServiceReference &ref)
32 m_parser.parseFile(ref.path);
35 RESULT eStaticServiceDVBPVRInformation::getName(const eServiceReference &ref, std::string &name)
38 name = m_parser.m_name.size() ? m_parser.m_name : ref.path;
42 int eStaticServiceDVBPVRInformation::getLength(const eServiceReference &ref)
48 if (tstools.openFile(ref.path.c_str()))
52 if (tstools.calcLen(len))
60 class eDVBPVRServiceOfflineOperations: public iServiceOfflineOperations
62 DECLARE_REF(eDVBPVRServiceOfflineOperations);
63 eServiceReferenceDVB m_ref;
65 eDVBPVRServiceOfflineOperations(const eServiceReference &ref);
67 RESULT deleteFromDisk(int simulate);
68 RESULT getListOfFilenames(std::list<std::string> &);
71 DEFINE_REF(eDVBPVRServiceOfflineOperations);
73 eDVBPVRServiceOfflineOperations::eDVBPVRServiceOfflineOperations(const eServiceReference &ref): m_ref((const eServiceReferenceDVB&)ref)
77 RESULT eDVBPVRServiceOfflineOperations::deleteFromDisk(int simulate)
83 std::list<std::string> res;
84 if (getListOfFilenames(res))
87 /* TODO: deferred removing.. */
88 for (std::list<std::string>::iterator i(res.begin()); i != res.end(); ++i)
90 eDebug("Removing %s...", i->c_str());
98 RESULT eDVBPVRServiceOfflineOperations::getListOfFilenames(std::list<std::string> &res)
101 res.push_back(m_ref.path);
107 DEFINE_REF(eServiceFactoryDVB)
109 eServiceFactoryDVB::eServiceFactoryDVB()
111 ePtr<eServiceCenter> sc;
113 eServiceCenter::getPrivInstance(sc);
115 sc->addServiceFactory(eServiceFactoryDVB::id, this);
118 eServiceFactoryDVB::~eServiceFactoryDVB()
120 ePtr<eServiceCenter> sc;
122 eServiceCenter::getPrivInstance(sc);
124 sc->removeServiceFactory(eServiceFactoryDVB::id);
127 DEFINE_REF(eDVBServiceList);
129 eDVBServiceList::eDVBServiceList(const eServiceReference &parent): m_parent(parent)
133 eDVBServiceList::~eDVBServiceList()
137 RESULT eDVBServiceList::startQuery()
139 ePtr<iDVBChannelList> db;
140 ePtr<eDVBResourceManager> res;
143 if ((err = eDVBResourceManager::getInstance(res)) != 0)
145 eDebug("no resource manager");
148 if ((err = res->getChannelList(db)) != 0)
150 eDebug("no channel list");
154 ePtr<eDVBChannelQuery> q;
156 if (m_parent.path.size())
158 eDVBChannelQuery::compile(q, m_parent.path);
161 eDebug("compile query failed");
166 if ((err = db->startQuery(m_query, q)) != 0)
168 eDebug("startQuery failed");
175 RESULT eDVBServiceList::getContent(std::list<eServiceReference> &list)
177 eServiceReferenceDVB ref;
182 while (!m_query->getNextResult(ref))
187 RESULT eDVBServiceList::getNext(eServiceReference &ref)
192 return m_query->getNextResult((eServiceReferenceDVB&)ref);
195 int eDVBServiceList::compareLessEqual(const eServiceReference &a, const eServiceReference &b)
197 return m_query->compareLessEqual((const eServiceReferenceDVB&)a, (const eServiceReferenceDVB&)b);
200 RESULT eServiceFactoryDVB::play(const eServiceReference &ref, ePtr<iPlayableService> &ptr)
202 ePtr<eDVBService> service;
203 int r = lookupService(service, ref);
206 // check resources...
207 ptr = new eDVBServicePlay(ref, service);
211 RESULT eServiceFactoryDVB::record(const eServiceReference &ref, ePtr<iRecordableService> &ptr)
213 ptr = new eDVBServiceRecord((eServiceReferenceDVB&)ref);
217 RESULT eServiceFactoryDVB::list(const eServiceReference &ref, ePtr<iListableService> &ptr)
219 ePtr<eDVBServiceList> list = new eDVBServiceList(ref);
220 if (list->startQuery())
230 RESULT eServiceFactoryDVB::info(const eServiceReference &ref, ePtr<iStaticServiceInformation> &ptr)
232 /* do we have a PVR service? */
235 ptr = new eStaticServiceDVBPVRInformation(ref);
239 ePtr<eDVBService> service;
240 int r = lookupService(service, ref);
243 /* eDVBService has the iStaticServiceInformation interface, so we pass it here. */
249 RESULT eServiceFactoryDVB::offlineOperations(const eServiceReference &, ePtr<iServiceOfflineOperations> &ptr)
255 RESULT eServiceFactoryDVB::lookupService(ePtr<eDVBService> &service, const eServiceReference &ref)
257 // TODO: handle the listing itself
258 // if (ref.... == -1) .. return "... bouquets ...";
259 // could be also done in another serviceFactory (with seperate ID) to seperate actual services and lists
261 ePtr<iDVBChannelList> db;
262 ePtr<eDVBResourceManager> res;
265 if ((err = eDVBResourceManager::getInstance(res)) != 0)
267 eDebug("no resource manager");
270 if ((err = res->getChannelList(db)) != 0)
272 eDebug("no channel list");
276 /* we are sure to have a ..DVB reference as the info() call was forwarded here according to it's ID. */
277 if ((err = db->getService((eServiceReferenceDVB&)ref, service)) != 0)
279 eDebug("getService failed!");
286 eDVBServicePlay::eDVBServicePlay(const eServiceReference &ref, eDVBService *service):
287 m_reference(ref), m_dvb_service(service), m_service_handler(0)
289 m_is_pvr = !ref.path.empty();
291 CONNECT(m_service_handler.serviceEvent, eDVBServicePlay::serviceEvent);
292 CONNECT(m_event_handler.m_eit_changed, eDVBServicePlay::gotNewEvent);
293 eDebug("DVB start (play)");
296 eDVBServicePlay::~eDVBServicePlay()
298 eDebug("DVB stop (play)");
301 void eDVBServicePlay::gotNewEvent()
305 ePtr<eServiceEvent> m_event_now, m_event_next;
306 getEvent(m_event_now, 0);
307 getEvent(m_event_next, 1);
310 eDebug("now running: %s (%d seconds :)", m_event_now->m_event_name.c_str(), m_event_now->m_duration);
312 eDebug("next running: %s (%d seconds :)", m_event_next->m_event_name.c_str(), m_event_next->m_duration);
314 m_event((iPlayableService*)this, evUpdatedEventInfo);
317 void eDVBServicePlay::serviceEvent(int event)
319 eDebug("service event %d", event);
322 case eDVBServicePMTHandler::eventTuned:
324 ePtr<iDVBDemux> m_demux;
325 if (!m_service_handler.getDemux(m_demux))
327 // eventStartedEventAcquisition
328 m_event_handler.start(m_demux, ((eServiceReferenceDVB&)m_reference).getServiceID().get());
330 eDebug("no event data available :( ");
334 case eDVBServicePMTHandler::eventNewProgramInfo:
336 int vpid = -1, apid = -1, pcrpid = -1;
337 eDVBServicePMTHandler::program program;
338 if (m_service_handler.getProgramInfo(program))
339 eDebug("getting program info failed.");
342 eDebugNoNewLine("have %d video stream(s)", program.videoStreams.size());
343 if (!program.videoStreams.empty())
345 eDebugNoNewLine(" (");
346 for (std::vector<eDVBServicePMTHandler::videoStream>::const_iterator
347 i(program.videoStreams.begin());
348 i != program.videoStreams.end(); ++i)
352 if (i != program.videoStreams.begin())
353 eDebugNoNewLine(", ");
354 eDebugNoNewLine("%04x", i->pid);
356 eDebugNoNewLine(")");
358 eDebugNoNewLine(", and %d audio stream(s)", program.audioStreams.size());
359 if (!program.audioStreams.empty())
361 eDebugNoNewLine(" (");
362 for (std::vector<eDVBServicePMTHandler::audioStream>::const_iterator
363 i(program.audioStreams.begin());
364 i != program.audioStreams.end(); ++i)
368 if (i != program.audioStreams.begin())
369 eDebugNoNewLine(", ");
370 eDebugNoNewLine("%04x", i->pid);
372 eDebugNoNewLine(")");
374 eDebug(", and the pcr pid is %04x", program.pcrPid);
375 if (program.pcrPid != 0x1fff)
376 pcrpid = program.pcrPid;
381 ePtr<iDVBDemux> demux;
382 m_service_handler.getDemux(demux);
384 demux->getMPEGDecoder(m_decoder);
389 m_decoder->setVideoPID(vpid);
390 m_decoder->setAudioPID(apid, 0);
392 m_decoder->setSyncPCR(pcrpid);
394 m_decoder->setSyncPCR(-1);
396 // how we can do this better?
397 // update cache pid when the user changed the audio track or video track
398 // TODO handling of difference audio types.. default audio types..
400 /* don't worry about non-existing services, nor pvr services */
401 if (m_dvb_service && !m_is_pvr)
403 m_dvb_service->setCachePID(eDVBService::cVPID, vpid);
404 m_dvb_service->setCachePID(eDVBService::cAPID, apid);
405 m_dvb_service->setCachePID(eDVBService::cPCRPID, pcrpid);
414 RESULT eDVBServicePlay::start()
417 eDebug("starting DVB service");
418 r = m_service_handler.tune((eServiceReferenceDVB&)m_reference);
419 m_event(this, evStart);
423 RESULT eDVBServicePlay::stop()
425 eDebug("stopping..");
429 RESULT eDVBServicePlay::connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection)
431 connection = new eConnection((iPlayableService*)this, m_event.connect(event));
435 RESULT eDVBServicePlay::pause(ePtr<iPauseableService> &ptr)
437 // not yet possible, maybe later...
442 RESULT eDVBServicePlay::seek(ePtr<iSeekableService> &ptr)
454 RESULT eDVBServicePlay::getLength(pts_t &len)
456 ePtr<iDVBPVRChannel> pvr_channel;
458 if (m_service_handler.getPVRChannel(pvr_channel))
460 eDebug("getPVRChannel failed!");
464 return pvr_channel->getLength(len);
467 RESULT eDVBServicePlay::seekTo(pts_t to)
472 RESULT eDVBServicePlay::getPlayPosition(pts_t &pos)
474 ePtr<iDVBPVRChannel> pvr_channel;
476 if (m_service_handler.getPVRChannel(pvr_channel))
479 return pvr_channel->getCurrentPosition(pos);
482 RESULT eDVBServicePlay::info(ePtr<iServiceInformation> &ptr)
488 RESULT eDVBServicePlay::getName(std::string &name)
492 m_dvb_service->getName(m_reference, name);
496 name = "DVB service";
500 RESULT eDVBServicePlay::getEvent(ePtr<eServiceEvent> &evt, int nownext)
502 return m_event_handler.getEvent(evt, nownext);
505 DEFINE_REF(eDVBServicePlay)
507 eAutoInitPtr<eServiceFactoryDVB> init_eServiceFactoryDVB(eAutoInitNumbers::service+1, "eServiceFactoryDVB");