noinst_LIBRARIES = libenigma_dvb.a
libenigma_dvb_a_SOURCES = dvb.cpp demux.cpp frontend.cpp esection.cpp db.cpp \
- sec.cpp scan.cpp crc32.cpp pmt.cpp decoder.cpp
+ sec.cpp scan.cpp crc32.cpp pmt.cpp decoder.cpp eit.cpp
\ No newline at end of file
--- /dev/null
+#include <lib/dvb/eit.h>
+#include <lib/dvb/specs.h>
+#include <lib/base/eerror.h>
+#include <lib/service/event.h>
+
+void eDVBServiceEITHandler::EITready(int error)
+{
+ if (!error)
+ {
+ ePtr<eTable<EventInformationTable> > ptr;
+ if (!m_EIT.getCurrent(ptr))
+ {
+ int a = 0;
+ for (EventInformationTableConstIterator i = ptr->getSections().begin();
+ i != ptr->getSections().end(); ++i)
+ {
+ for (EventConstIterator ev = (*i)->getEvents()->begin(); ev != (*i)->getEvents()->end(); ++ev)
+ {
+ ePtr<eServiceEvent> evt = new eServiceEvent();
+ evt->parseFrom(*ev);
+ if (!a)
+ m_event_now = evt;
+ else
+ m_event_next = evt;
+ ++a;
+ }
+ }
+ }
+ }
+
+ m_eit_changed();
+}
+
+eDVBServiceEITHandler::eDVBServiceEITHandler()
+{
+ CONNECT(m_EIT.tableReady, eDVBServiceEITHandler::EITready);
+}
+
+void eDVBServiceEITHandler::start(iDVBDemux *demux, int sid)
+{
+ m_EIT.begin(eApp, eDVBEITSpec(sid), demux);
+}
+
+RESULT eDVBServiceEITHandler::getEvent(ePtr<eServiceEvent> &event, int nownext)
+{
+ event = nownext ? m_event_next : m_event_now;
+ if (!event)
+ return -1;
+ return 0;
+}
--- /dev/null
+#ifndef __lib_dvb_eit_h
+#define __lib_dvb_eit_h
+
+#include <lib/dvb/isection.h>
+#include <lib/dvb/esection.h>
+#include <lib/dvb_si/eit.h>
+#include <lib/service/event.h>
+
+class eDVBServiceEITHandler: public Object
+{
+ ePtr<iDVBDemux> m_demux;
+ eAUTable<eTable<EventInformationTable> > m_EIT;
+ void EITready(int error);
+
+ RESULT parseEvent(ePtr<eServiceEvent> &serviceevent, const Event &dvbevent);
+
+ ePtr<eServiceEvent> m_event_now, m_event_next;
+public:
+ eDVBServiceEITHandler();
+
+ void start(iDVBDemux *demux, int sid);
+
+ RESULT getEvent(ePtr<eServiceEvent> &event, int nownext);
+
+ PSignal0<void> m_eit_changed;
+};
+
+#endif
if (m_channel->getDemux(m_demux))
eDebug("shit it failed.. again.");
+ serviceEvent(eventTuned);
+
if (m_demux)
{
eDebug("ok ... now we start!!");
void PMTready(int error);
void PATready(int error);
-
public:
eDVBServicePMTHandler();
eventNoPAT, // no pat could be received (timeout)
eventNoPATEntry, // no pat entry for the corresponding SID could be found
eventNoPMT, // no pmt could be received (timeout)
- eventNewProgramInfo // we just received a PMT
+ eventNewProgramInfo, // we just received a PMT
+ eventTuned // a channel was sucessfully (re-)tuned in, you may start additional filters now
};
Signal1<void,int> serviceEvent;
#include <lib/dvb_si/nit.h>
#include <lib/dvb_si/bat.h>
#include <lib/dvb_si/pat.h>
+#include <lib/dvb_si/eit.h>
struct eDVBPMTSpec
{
}
};
+class eDVBEITSpec
+{
+ eDVBTableSpec m_spec;
+public:
+ /* this is for now&next on actual transponder. */
+ eDVBEITSpec(int sid)
+ {
+ m_spec.pid = EventInformationTable::PID;
+ m_spec.tid = EventInformationTable::TID;
+ m_spec.tidext = sid;
+ m_spec.timeout = EventInformationTable::TIMEOUT;
+ m_spec.flags = eDVBTableSpec::tfAnyVersion |
+ eDVBTableSpec::tfHaveTID | eDVBTableSpec::tfHaveTIDExt |
+ eDVBTableSpec::tfCheckCRC | eDVBTableSpec::tfHaveTimeout;
+ }
+ operator eDVBTableSpec &()
+ {
+ return m_spec;
+ }
+};
+
#endif
--- /dev/null
+#include <lib/nav/pcore.h>
+#include <lib/service/service.h>
+
+DEFINE_REF(pNavigation);
+
+pNavigation::pNavigation()
+{
+ ePtr<eServiceCenter> service_center;
+ eServiceCenter::getInstance(service_center);
+
+ assert(service_center);
+ m_core = new eNavigation(service_center);
+}
+
+RESULT pNavigation::playService(const eServiceReference &service)
+{
+ return m_core->playService(service);
+}
+
+RESULT pNavigation::enqueueService(const eServiceReference &service)
+{
+ return m_core->enqueueService(service);
+}
+
+RESULT pNavigation::getCurrentService(ePtr<iPlayableService> &service)
+{
+ return m_core->getCurrentService(service);
+}
+
+RESULT pNavigation::getPlaylist(ePtr<ePlaylist> &playlist)
+{
+ return m_core->getPlaylist(playlist);
+}
+
+RESULT pNavigation::pause(int p)
+{
+ return m_core->pause(p);
+}
--- /dev/null
+#ifndef __lib_nav_pcore_h
+#define __lib_nav_pcore_h
+
+#include <lib/nav/core.h>
+#include <lib/python/connections.h>
+
+/* a subset of eNavigation */
+
+class pNavigation: public iObject
+{
+DECLARE_REF;
+private:
+ ePtr<eNavigation> m_core;
+public:
+ PSignal1<void, int> event;
+
+ pNavigation();
+
+ RESULT playService(const eServiceReference &service);
+ RESULT enqueueService(const eServiceReference &service);
+ RESULT getCurrentService(ePtr<iPlayableService> &service);
+ RESULT getPlaylist(ePtr<ePlaylist> &playlist);
+
+ RESULT pause(int p);
+};
+
+#endif
noinst_LIBRARIES = libenigma_service.a
libenigma_service_a_SOURCES = \
- listboxservice.cpp service.cpp servicemp3.cpp servicedvb.cpp servicefs.cpp
+ listboxservice.cpp service.cpp servicemp3.cpp servicedvb.cpp servicefs.cpp \
+ event.cpp
--- /dev/null
+#include <lib/service/event.h>
+#include <lib/dvb_si/eit.h>
+#include <lib/dvb_si/short_event_descriptor.h>
+#include <lib/dvb_si/descriptor_tag.h>
+
+DEFINE_REF(eServiceEvent);
+
+RESULT eServiceEvent::parseFrom(Event *evt)
+{
+ m_begin = 0; // ich bin FAUL
+ m_duration = evt->getDuration();
+
+
+ for (DescriptorConstIterator desc = evt->getDescriptors()->begin(); desc != evt->getDescriptors()->end(); ++desc)
+ {
+ switch ((*desc)->getTag())
+ {
+ case SHORT_EVENT_DESCRIPTOR:
+ {
+ const ShortEventDescriptor *sed = (ShortEventDescriptor*)*desc;
+ m_event_name = sed->getEventName();
+ m_description = sed->getText();
+ break;
+ }
+ }
+ }
+}
--- /dev/null
+#ifndef __service_ievent_h
+#define __service_ievent_h
+
+#include <time.h>
+#include <lib/base/object.h>
+#include <string>
+class Event;
+
+class eServiceEvent: public iObject
+{
+DECLARE_REF;
+public:
+ time_t m_begin;
+ int m_duration;
+ std::string m_event_name, m_description;
+ // .. additional info
+
+ RESULT parseFrom(Event *evt);
+};
+
+#endif
TEMPLATE_TYPEDEF(ePtr<iStaticServiceInformation>, iStaticServiceInformationPtr);
+class eServiceEvent;
+
class iServiceInformation: public iStaticServiceInformation
{
public:
-
+ virtual RESULT getEvent(ePtr<eServiceEvent> &evt, int nownext);
};
TEMPLATE_TYPEDEF(ePtr<iServiceInformation>, iServiceInformationPtr);
enum
{
evStart,
- evEnd
+ evEnd,
+
+ // when iServiceInformation is implemented:
+ evNewEvent
};
virtual RESULT connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection)=0;
virtual RESULT start()=0;
return -1;
}
+#include <lib/service/event.h>
+
+RESULT iServiceInformation::getEvent(ePtr<eServiceEvent> &evt, int m_nownext)
+{
+ evt = 0;
+ return -1;
+}
+
+
eAutoInitPtr<eServiceCenter> init_eServiceCenter(eAutoInitNumbers::service, "eServiceCenter");
eDVBServicePlay::eDVBServicePlay(const eServiceReference &ref):
m_reference(ref)
{
- CONNECT(m_serviceHandler.serviceEvent, eDVBServicePlay::serviceEvent);
+ CONNECT(m_service_handler.serviceEvent, eDVBServicePlay::serviceEvent);
+ CONNECT(m_event_handler.m_eit_changed, eDVBServicePlay::gotNewEvent);
eDebug("DVB start (play)");
}
eDebug("DVB stop (play)");
}
+void eDVBServicePlay::gotNewEvent()
+{
+ // debug only
+ ePtr<eServiceEvent> m_event_now, m_event_next;
+ getEvent(m_event_now, 0);
+ getEvent(m_event_next, 1);
+
+ if (m_event_now)
+ eDebug("now running: %s (%d seconds :)", m_event_now->m_event_name.c_str(), m_event_now->m_duration);
+ if (m_event_next)
+ eDebug("next running: %s (%d seconds :)", m_event_next->m_event_name.c_str(), m_event_next->m_duration);
+}
+
void eDVBServicePlay::serviceEvent(int event)
{
eDebug("service event %d", event);
switch (event)
{
+ case eDVBServicePMTHandler::eventTuned:
+ {
+ ePtr<iDVBDemux> m_demux;
+ if (!m_service_handler.getDemux(m_demux))
+ {
+// eventStartedEventAcquisition
+ m_event_handler.start(m_demux, ((eServiceReferenceDVB&)m_reference).getServiceID().get());
+ } else
+ eDebug("no event data available :( ");
+// eventNoEvent
+ break;
+ }
case eDVBServicePMTHandler::eventNewProgramInfo:
{
int vpid = -1, apid = -1, pcrpid = -1;
eDVBServicePMTHandler::program program;
- if (m_serviceHandler.getProgramInfo(program))
+ if (m_service_handler.getProgramInfo(program))
eDebug("getting program info failed.");
else
{
if (!m_decoder)
{
ePtr<iDVBDemux> demux;
- m_serviceHandler.getDemux(demux);
+ m_service_handler.getDemux(demux);
if (demux)
demux->getMPEGDecoder(m_decoder);
}
m_decoder->setSyncPCR(pcrpid);
m_decoder->start();
}
-
+
break;
}
}
RESULT eDVBServicePlay::start()
{
eDebug("starting DVB service");
- return m_serviceHandler.tune((eServiceReferenceDVB&)m_reference);
+ return m_service_handler.tune((eServiceReferenceDVB&)m_reference);
}
RESULT eDVBServicePlay::stop()
return 0;
}
+RESULT eDVBServicePlay::getEvent(ePtr<eServiceEvent> &evt, int nownext)
+{
+ return m_event_handler.getEvent(evt, nownext);
+}
+
DEFINE_REF(eDVBServicePlay)
eAutoInitPtr<eServiceFactoryDVB> init_eServiceFactoryDVB(eAutoInitNumbers::service+1, "eServiceFactoryDVB");
#include <lib/dvb/idvb.h>
#include <lib/dvb/pmt.h>
+#include <lib/dvb/eit.h>
class eServiceFactoryDVB: public iServiceHandler
{
ePtr<iTSMPEGDecoder> m_decoder;
- eDVBServicePMTHandler m_serviceHandler;
+ eDVBServicePMTHandler m_service_handler;
+ eDVBServiceEITHandler m_event_handler;
eDVBServicePlay(const eServiceReference &ref);
+ void gotNewEvent();
+
void serviceEvent(int event);
public:
virtual ~eDVBServicePlay();
// iServiceInformation
RESULT getName(const eServiceReference &ref, std::string &name);
+ RESULT getEvent(ePtr<eServiceEvent> &evt, int nownext);
};
#endif