lib/service/servicedvb.cpp

   1 #include <lib/base/eerror.h>
   2 #include <lib/base/object.h>
   3 #include <string>
   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>
   8
   9 #include <lib/dvb/dvb.h>
  10 #include <lib/dvb/db.h>
  11
  12 DEFINE_REF(eServiceFactoryDVB)
  13
  14 eServiceFactoryDVB::eServiceFactoryDVB()
  15 {
  16         ePtr<eServiceCenter> sc;
  17
  18         eServiceCenter::getInstance(sc);
  19         if (sc)
  20                 sc->addServiceFactory(eServiceFactoryDVB::id, this);
  21 }
  22
  23 eServiceFactoryDVB::~eServiceFactoryDVB()
  24 {
  25         ePtr<eServiceCenter> sc;
  26
  27         eServiceCenter::getInstance(sc);
  28         if (sc)
  29                 sc->removeServiceFactory(eServiceFactoryDVB::id);
  30 }
  31
  32 DEFINE_REF(eDVBServiceList);
  33
  34 eDVBServiceList::eDVBServiceList(const eServiceReference &parent): m_parent(parent)
  35 {
  36 }
  37
  38 eDVBServiceList::~eDVBServiceList()
  39 {
  40 }
  41
  42 RESULT eDVBServiceList::getContent(std::list<eServiceReference> &list)
  43 {
  44         ePtr<iDVBChannelList> db;
  45         ePtr<eDVBResourceManager> res;
  46
  47         int err;
  48         if ((err = eDVBResourceManager::getInstance(res)) != 0)
  49         {
  50                 eDebug("no resource manager");
  51                 return err;
  52         }
  53         if ((err = res->getChannelList(db)) != 0)
  54         {
  55                 eDebug("no channel list");
  56                 return err;
  57         }
  58
  59         ePtr<iDVBChannelListQuery> query;
  60
  61         ePtr<eDVBChannelQuery> q;
  62
  63         if (m_parent.path.size())
  64                 eDVBChannelQuery::compile(q, m_parent.path);
  65
  66         if ((err = db->startQuery(query, q)) != 0)
  67         {
  68                 eDebug("startQuery failed");
  69                 return err;
  70         }
  71
  72         eServiceReferenceDVB ref;
  73
  74         while (!query->getNextResult(ref))
  75                 list.push_back(ref);
  76         return 0;
  77 }
  78
  79 RESULT eServiceFactoryDVB::play(const eServiceReference &ref, ePtr<iPlayableService> &ptr)
  80 {
  81                 // check resources...
  82         ptr = new eDVBServicePlay(ref);
  83         return 0;
  84 }
  85
  86 RESULT eServiceFactoryDVB::record(const eServiceReference &, ePtr<iRecordableService> &ptr)
  87 {
  88         ptr = 0;
  89         return -1;
  90 }
  91
  92 RESULT eServiceFactoryDVB::list(const eServiceReference &ref, ePtr<iListableService> &ptr)
  93 {
  94         ptr = new eDVBServiceList(ref);
  95         return 0;
  96 }
  97
  98 RESULT eServiceFactoryDVB::info(const eServiceReference &ref, ePtr<iStaticServiceInformation> &ptr)
  99 {
 100         ptr = 0;
 101                         // TODO: handle the listing itself
 102         // if (ref.... == -1) .. return "... bouquets ...";
 103         // could be also done in another serviceFactory (with seperate ID) to seperate actual services and lists
 104                         // TODO: cache
 105         ePtr<iDVBChannelList> db;
 106         ePtr<eDVBResourceManager> res;
 107
 108         int err;
 109         if ((err = eDVBResourceManager::getInstance(res)) != 0)
 110         {
 111                 eDebug("no resource manager");
 112                 return err;
 113         }
 114         if ((err = res->getChannelList(db)) != 0)
 115         {
 116                 eDebug("no channel list");
 117                 return err;
 118         }
 119
 120         ePtr<eDVBService> service;
 121
 122                 /* we are sure to have a ..DVB reference as the info() call was forwarded here according to it's ID. */
 123         if ((err = db->getService((eServiceReferenceDVB&)ref, service)) != 0)
 124         {
 125                 eDebug("getService failed!");
 126                 return err;
 127         }
 128
 129                 /* eDVBService has the iStaticServiceInformation interface, so we pass it here. */
 130         ptr = service;
 131         return 0;
 132 }
 133
 134 eDVBServicePlay::eDVBServicePlay(const eServiceReference &ref):
 135         m_reference(ref)
 136 {
 137         CONNECT(m_service_handler.serviceEvent, eDVBServicePlay::serviceEvent);
 138         CONNECT(m_event_handler.m_eit_changed, eDVBServicePlay::gotNewEvent);
 139         eDebug("DVB start (play)");
 140 }
 141
 142 eDVBServicePlay::~eDVBServicePlay()
 143 {
 144         eDebug("DVB stop (play)");
 145 }
 146
 147 void eDVBServicePlay::gotNewEvent()
 148 {
 149 #if 0
 150                 // debug only
 151         ePtr<eServiceEvent> m_event_now, m_event_next;
 152         getEvent(m_event_now, 0);
 153         getEvent(m_event_next, 1);
 154
 155         if (m_event_now)
 156                 eDebug("now running: %s (%d seconds :)", m_event_now->m_event_name.c_str(), m_event_now->m_duration);
 157         if (m_event_next)
 158                 eDebug("next running: %s (%d seconds :)", m_event_next->m_event_name.c_str(), m_event_next->m_duration);
 159 #endif
 160         m_event((iPlayableService*)this, evUpdatedEventInfo);
 161 }
 162
 163 void eDVBServicePlay::serviceEvent(int event)
 164 {
 165         eDebug("service event %d", event);
 166         switch (event)
 167         {
 168         case eDVBServicePMTHandler::eventTuned:
 169         {
 170                 ePtr<iDVBDemux> m_demux;
 171                 if (!m_service_handler.getDemux(m_demux))
 172                 {
 173 //                      eventStartedEventAcquisition
 174                         m_event_handler.start(m_demux, ((eServiceReferenceDVB&)m_reference).getServiceID().get());
 175                 } else
 176                         eDebug("no event data available :( ");
 177 //                      eventNoEvent
 178                 break;
 179         }
 180         case eDVBServicePMTHandler::eventNewProgramInfo:
 181         {
 182                 int vpid = -1, apid = -1, pcrpid = -1;
 183                 eDVBServicePMTHandler::program program;
 184                 if (m_service_handler.getProgramInfo(program))
 185                         eDebug("getting program info failed.");
 186                 else
 187                 {
 188                         eDebugNoNewLine("have %d video stream(s)", program.videoStreams.size());
 189                         if (!program.videoStreams.empty())
 190                         {
 191                                 eDebugNoNewLine(" (");
 192                                 for (std::vector<eDVBServicePMTHandler::videoStream>::const_iterator
 193                                         i(program.videoStreams.begin());
 194                                         i != program.videoStreams.end(); ++i)
 195                                 {
 196                                         if (vpid == -1)
 197                                                 vpid = i->pid;
 198                                         if (i != program.videoStreams.begin())
 199                                                 eDebugNoNewLine(", ");
 200                                         eDebugNoNewLine("%04x", i->pid);
 201                                 }
 202                                 eDebugNoNewLine(")");
 203                         }
 204                         eDebugNoNewLine(", and %d audio stream(s)", program.audioStreams.size());
 205                         if (!program.audioStreams.empty())
 206                         {
 207                                 eDebugNoNewLine(" (");
 208                                 for (std::vector<eDVBServicePMTHandler::audioStream>::const_iterator
 209                                         i(program.audioStreams.begin());
 210                                         i != program.audioStreams.end(); ++i)
 211                                 {
 212                                         if (apid == -1)
 213                                                 apid = i->pid;
 214                                         if (i != program.audioStreams.begin())
 215                                                 eDebugNoNewLine(", ");
 216                                         eDebugNoNewLine("%04x", i->pid);
 217                                 }
 218                                 eDebugNoNewLine(")");
 219                         }
 220                         eDebug(", and the pcr pid is %04x", program.pcrPid);
 221                         if (program.pcrPid != 0x1fff)
 222                                 pcrpid = program.pcrPid;
 223                 }
 224
 225                 if (!m_decoder)
 226                 {
 227                         ePtr<iDVBDemux> demux;
 228                         m_service_handler.getDemux(demux);
 229                         if (demux)
 230                                 demux->getMPEGDecoder(m_decoder);
 231                 }
 232
 233                 if (m_decoder)
 234                 {
 235                         m_decoder->setVideoPID(vpid);
 236                         m_decoder->setAudioPID(apid, 0);
 237                         m_decoder->setSyncPCR(pcrpid);
 238                         m_decoder->start();
 239                 }
 240
 241                 break;
 242         }
 243         }
 244 }
 245
 246 RESULT eDVBServicePlay::start()
 247 {
 248         eDebug("starting DVB service");
 249         return m_service_handler.tune((eServiceReferenceDVB&)m_reference);
 250 }
 251
 252 RESULT eDVBServicePlay::stop()
 253 {
 254         eDebug("stopping..");
 255         return 0;
 256 }
 257
 258 RESULT eDVBServicePlay::connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection)
 259 {
 260         connection = new eConnection((iPlayableService*)this, m_event.connect(event));
 261         return 0;
 262 }
 263
 264 RESULT eDVBServicePlay::pause(ePtr<iPauseableService> &ptr)
 265 {
 266                 // not yet possible, maybe later...
 267         ptr = 0;
 268         return -1;
 269 }
 270
 271 RESULT eDVBServicePlay::info(ePtr<iServiceInformation> &ptr)
 272 {
 273         ptr = this;
 274         return 0;
 275 }
 276
 277 RESULT eDVBServicePlay::getName(const eServiceReference &ref, std::string &name)
 278 {
 279         name = "DVB service";
 280         return 0;
 281 }
 282
 283 RESULT eDVBServicePlay::getEvent(ePtr<eServiceEvent> &evt, int nownext)
 284 {
 285         return m_event_handler.getEvent(evt, nownext);
 286 }
 287
 288 DEFINE_REF(eDVBServicePlay)
 289
 290 eAutoInitPtr<eServiceFactoryDVB> init_eServiceFactoryDVB(eAutoInitNumbers::service+1, "eServiceFactoryDVB");