From 3cddda083f4ace59e279f9f4f6ae12bad079d33b Mon Sep 17 00:00:00 2001 From: Felix Domke Date: Thu, 28 Apr 2005 12:23:04 +0000 Subject: [PATCH] - add dvb resource management - scan hardcoded to dvb-s again - added untested recording support (data io thread still missing) --- lib/components/scan.cpp | 6 +- lib/dvb/dvb.cpp | 304 +++++++++++++++++++++++++++---- lib/dvb/dvb.h | 148 +++++++++++++-- lib/dvb/idvb.h | 18 -- lib/dvb/pmt.h | 3 +- lib/dvb/scan.cpp | 4 +- lib/service/Makefile.am | 2 +- lib/service/servicedvb.cpp | 6 +- lib/service/servicedvbrecord.cpp | 84 +++++++++ lib/service/servicedvbrecord.h | 27 +++ 10 files changed, 527 insertions(+), 75 deletions(-) create mode 100644 lib/service/servicedvbrecord.cpp create mode 100644 lib/service/servicedvbrecord.h diff --git a/lib/components/scan.cpp b/lib/components/scan.cpp index ad2e4d1a..c46bb4a8 100644 --- a/lib/components/scan.cpp +++ b/lib/components/scan.cpp @@ -61,7 +61,7 @@ int eComponentScan::start() eDVBResourceManager::getInstance(mgr); eDVBFrontendParameters *fe = new eDVBFrontendParameters(); -#if 0 +#if 1 eDVBFrontendParametersSatellite fesat; fesat.frequency = 11817000; // 12070000; @@ -73,8 +73,8 @@ int eComponentScan::start() fe->setDVBS(fesat); -#endif +#else eDVBFrontendParametersTerrestrial fet; fet.frequency = 626000000; fet.inversion = eDVBFrontendParametersTerrestrial::Inversion::Unknown; @@ -85,7 +85,7 @@ int eComponentScan::start() fet.guard_interval = eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_32; fet.hierarchy = eDVBFrontendParametersTerrestrial::Hierarchy::HNone; fe->setDVBT(fet); - +#endif ePtr channel; if (mgr->allocateRawChannel(channel)) diff --git a/lib/dvb/dvb.cpp b/lib/dvb/dvb.cpp index 8acd0c5d..9a355615 100644 --- a/lib/dvb/dvb.cpp +++ b/lib/dvb/dvb.cpp @@ -4,6 +4,37 @@ #include #include +#include +#include +#include + +DEFINE_REF(eDVBRegisteredFrontend); +DEFINE_REF(eDVBRegisteredDemux); + +DEFINE_REF(eDVBAllocatedFrontend); + +eDVBAllocatedFrontend::eDVBAllocatedFrontend(eDVBRegisteredFrontend *fe): m_fe(fe) +{ + m_fe->m_inuse++; +} + +eDVBAllocatedFrontend::~eDVBAllocatedFrontend() +{ + --m_fe->m_inuse; +} + +DEFINE_REF(eDVBAllocatedDemux); + +eDVBAllocatedDemux::eDVBAllocatedDemux(eDVBRegisteredDemux *demux): m_demux(demux) +{ + m_demux->m_inuse++; +} + +eDVBAllocatedDemux::~eDVBAllocatedDemux() +{ + --m_demux->m_inuse; +} + DEFINE_REF(eDVBResourceManager); eDVBResourceManager *eDVBResourceManager::instance; @@ -15,12 +46,170 @@ eDVBResourceManager::eDVBResourceManager() m_sec = new eDVBSatelliteEquipmentControl; if (!instance) instance = this; + + /* search available adapters... */ + + // add linux devices + + int num_adapter = 0; + while (eDVBAdapterLinux::exist(num_adapter)) + { + addAdapter(new eDVBAdapterLinux(num_adapter)); + num_adapter++; + } + + eDebug("found %d adapter, %d frontends and %d demux", + m_adapter.size(), m_frontend.size(), m_demux.size()); +} + + +DEFINE_REF(eDVBAdapterLinux); +eDVBAdapterLinux::eDVBAdapterLinux(int nr): m_nr(nr) +{ + // scan frontends + int num_fe = 0; + + eDebug("scanning for frontends.."); + while (1) + { + struct stat s; + char filename[128]; + sprintf(filename, "/dev/dvb/adapter%d/frontend%d", m_nr, num_fe); + if (stat(filename, &s)) + break; + ePtr fe; + + int ok = 0; + fe = new eDVBFrontend(m_nr, num_fe, ok); + if (ok) + m_frontend.push_back(fe); + ++num_fe; + } + + // scan demux + int num_demux = 0; + while (1) + { + struct stat s; + char filename[128]; + sprintf(filename, "/dev/dvb/adapter%d/demux%d", m_nr, num_demux); + if (stat(filename, &s)) + break; + ePtr demux; + + demux = new eDVBDemux(m_nr, num_demux); + m_demux.push_back(demux); + + ++num_demux; + } +} + +int eDVBAdapterLinux::getNumDemux() +{ + return m_demux.size(); +} + +RESULT eDVBAdapterLinux::getDemux(ePtr &demux, int nr) +{ + eSmartPtrList::iterator i(m_demux.begin()); + while (nr && (i != m_demux.end())) + { + --nr; + ++i; + } + + if (i != m_demux.end()) + demux = *i; + else + return -1; + + return 0; +} + +int eDVBAdapterLinux::getNumFrontends() +{ + return m_frontend.size(); +} + +RESULT eDVBAdapterLinux::getFrontend(ePtr &fe, int nr) +{ + eSmartPtrList::iterator i(m_frontend.begin()); + while (nr && (i != m_frontend.end())) + { + --nr; + ++i; + } + + if (i != m_frontend.end()) + fe = *i; + else + return -1; + + return 0; +} + +int eDVBAdapterLinux::exist(int nr) +{ + struct stat s; + char filename[128]; + sprintf(filename, "/dev/dvb/adapter%d", nr); + if (!stat(filename, &s)) + return 1; + return 0; } eDVBResourceManager::~eDVBResourceManager() { if (instance == this) instance = 0; + +} + +void eDVBResourceManager::addAdapter(iDVBAdapter *adapter) +{ + int num_fe = adapter->getNumFrontends(); + int num_demux = adapter->getNumDemux(); + + m_adapter.push_back(adapter); + + int i; + for (i=0; i demux; + if (!adapter->getDemux(demux, i)) + m_demux.push_back(new eDVBRegisteredDemux(demux, adapter)); + } + + for (i=0; i frontend; + if (!adapter->getFrontend(frontend, i)) + m_frontend.push_back(new eDVBRegisteredFrontend(frontend, adapter)); + } +} + +RESULT eDVBResourceManager::allocateFrontend(const eDVBChannelID &chid, ePtr &fe) +{ + /* find first unused frontend. we ignore compatibility for now. */ + for (eSmartPtrList::iterator i(m_frontend.begin()); i != m_frontend.end(); ++i) + if (!i->m_inuse) + { + fe = new eDVBAllocatedFrontend(i); + return 0; + } + return -1; +} + +RESULT eDVBResourceManager::allocateDemux(eDVBRegisteredFrontend *fe, ePtr &demux) +{ + /* find first unused demux which is on same adapter as frontend */ + for (eSmartPtrList::iterator i(m_demux.begin()); i != m_demux.end(); ++i) + if ((!i->m_inuse) && (i->m_adapter == fe->m_adapter)) + { + demux = new eDVBAllocatedDemux(i); + return 0; + } + return -1; } RESULT eDVBResourceManager::setChannelList(iDVBChannelList *list) @@ -41,30 +230,70 @@ RESULT eDVBResourceManager::getChannelList(ePtr &list) RESULT eDVBResourceManager::allocateChannel(const eDVBChannelID &channelid, ePtr &channel) { + /* first, check if a channel is already existing. */ + + for (std::list::iterator i(m_active_channels.begin()); i != m_active_channels.end();) + { + if (i->m_channel_id == channelid) + { + channel = i->m_channel; + return 0; + } + } + + /* no currently available channel is tuned to this channelid. create a new one, if possible. */ + + /* allocate a frontend. */ + + ePtr fe; + + if (allocateFrontend(channelid, fe)) + return errNoFrontend; + + ePtr demux; + + if (allocateDemux(*fe, demux)) + return errNoDemux; + RESULT res; eDVBChannel *ch; - channel = ch = new eDVBChannel(this, 0, 0, 0); + ch = new eDVBChannel(this, fe, demux); - ePtr fe; - if (!channel->getFrontend(fe)) - fe->setSEC(m_sec); + ePtr myfe; + if (!ch->getFrontend(myfe)) + myfe->setSEC(m_sec); res = ch->setChannel(channelid); if (res) { channel = 0; - return res; + return errChidNotFound; } + + channel = ch; return 0; } RESULT eDVBResourceManager::allocateRawChannel(ePtr &channel) { - channel = new eDVBChannel(this, 0, 0, 0); - ePtr fe; - if (!channel->getFrontend(fe)) - fe->setSEC(m_sec); + ePtr fe; + + if (allocateFrontend(eDVBChannelID(), fe)) + return errNoFrontend; + + ePtr demux; + + if (allocateDemux(*fe, demux)) + return errNoDemux; + eDVBChannel *ch; + ch = new eDVBChannel(this, fe, demux); + + ePtr myfe; + if (!ch->getFrontend(myfe)) + myfe->setSEC(m_sec); + + channel = ch; return 0; } @@ -76,15 +305,23 @@ RESULT eDVBResourceManager::allocatePVRChannel(int caps) RESULT eDVBResourceManager::addChannel(const eDVBChannelID &chid, eDVBChannel *ch) { eDebug("add channel %p", ch); - m_active_channels.insert(std::pair(chid, ch)); + m_active_channels.push_back(active_channel(chid, ch)); return 0; } -RESULT eDVBResourceManager::removeChannel(const eDVBChannelID &chid, eDVBChannel *) +RESULT eDVBResourceManager::removeChannel(eDVBChannel *ch) { - int cnt = m_active_channels.erase(chid); - eDebug("remove channel: removed %d channels", cnt); - ASSERT(cnt <= 1); + int cnt = 0; + for (std::list::iterator i(m_active_channels.begin()); i != m_active_channels.end();) + { + if (i->m_channel == ch) + { + i = m_active_channels.erase(i); + ++cnt; + } else + ++i; + } + ASSERT(cnt == 1); if (cnt == 1) return 0; return -ENOENT; @@ -92,26 +329,19 @@ RESULT eDVBResourceManager::removeChannel(const eDVBChannelID &chid, eDVBChannel DEFINE_REF(eDVBChannel); -eDVBChannel::eDVBChannel(eDVBResourceManager *mgr, int adapter, int frontend, int demux): eDVBDemux(adapter, demux), m_state(state_idle), m_mgr(mgr) +eDVBChannel::eDVBChannel(eDVBResourceManager *mgr, eDVBAllocatedFrontend *frontend, eDVBAllocatedDemux *demux): m_state(state_idle), m_mgr(mgr) { - if (frontend >= 0) - { - int ok; - m_frontend = new eDVBFrontend(adapter, frontend, ok); - if (!ok) - { - eDebug("warning, frontend failed"); - m_frontend = 0; - return; - } - m_frontend->connectStateChange(slot(*this, &eDVBChannel::frontendStateChanged), m_conn_frontendStateChanged); - } + m_frontend = frontend; + m_demux = demux; + + if (m_frontend) + m_frontend->get().connectStateChange(slot(*this, &eDVBChannel::frontendStateChanged), m_conn_frontendStateChanged); } eDVBChannel::~eDVBChannel() { if (m_channel_id) - m_mgr->removeChannel(m_channel_id, this); + m_mgr->removeChannel(this); } void eDVBChannel::frontendStateChanged(iDVBFrontend*fe) @@ -145,6 +375,12 @@ void eDVBChannel::frontendStateChanged(iDVBFrontend*fe) RESULT eDVBChannel::setChannel(const eDVBChannelID &channelid) { + if (m_channel_id) + m_mgr->removeChannel(this); + + if (!channelid) + return 0; + ePtr list; if (m_mgr->getChannelList(list)) @@ -155,7 +391,6 @@ RESULT eDVBChannel::setChannel(const eDVBChannelID &channelid) eDebug("tuning to chid: ns: %08x tsid %04x onid %04x", channelid.dvbnamespace.get(), channelid.transport_stream_id.get(), channelid.original_network_id.get()); - ePtr feparm; if (list->getChannelFrontendData(channelid, feparm)) @@ -171,13 +406,10 @@ RESULT eDVBChannel::setChannel(const eDVBChannelID &channelid) return -ENODEV; } - if (m_channel_id) - m_mgr->removeChannel(m_channel_id, this); m_channel_id = channelid; - m_mgr->addChannel(m_channel_id, this); + m_mgr->addChannel(channelid, this); m_state = state_tuning; - eDebug("%p", &*feparm); - return m_frontend->tune(*feparm); + return m_frontend->get().tune(*feparm); } RESULT eDVBChannel::connectStateChange(const Slot1 &stateChange, ePtr &connection) @@ -199,13 +431,13 @@ RESULT eDVBChannel::setCIRouting(const eDVBCIRouting &routing) RESULT eDVBChannel::getDemux(ePtr &demux) { - demux = this; + demux = &m_demux->get(); return 0; } RESULT eDVBChannel::getFrontend(ePtr &frontend) { - frontend = m_frontend; + frontend = &m_frontend->get(); if (frontend) return 0; else diff --git a/lib/dvb/dvb.h b/lib/dvb/dvb.h index 8a13b403..a4652e81 100644 --- a/lib/dvb/dvb.h +++ b/lib/dvb/dvb.h @@ -7,20 +7,135 @@ #include class eDVBChannel; +class eDVBChannel; + + /* we do NOT handle resource conflicts here. instead, the allocateChannel + fails, and the application has to see why the channel is allocated + (and how to deallocate it). */ +class iDVBAdapter; + +class eDVBRegisteredFrontend: public iObject +{ +DECLARE_REF(eDVBRegisteredFrontend); +public: + iDVBAdapter *m_adapter; + ePtr m_frontend; + int m_inuse; + eDVBRegisteredFrontend(eDVBFrontend *fe, iDVBAdapter *adap): m_adapter(adap), m_frontend(fe), m_inuse(0) { } +}; + +struct eDVBRegisteredDemux +{ +DECLARE_REF(eDVBRegisteredDemux); +public: + iDVBAdapter *m_adapter; + ePtr m_demux; + int m_inuse; + eDVBRegisteredDemux(eDVBDemux *demux, iDVBAdapter *adap): m_adapter(adap), m_demux(demux), m_inuse(0) { } +}; + +class eDVBAllocatedFrontend +{ +DECLARE_REF(eDVBAllocatedFrontend); +public: + + eDVBAllocatedFrontend(eDVBRegisteredFrontend *fe); + ~eDVBAllocatedFrontend(); + eDVBFrontend &get() { return *m_fe->m_frontend; } + operator eDVBRegisteredFrontend*() { return m_fe; } + operator eDVBFrontend*() { return m_fe->m_frontend; } + +private: + eDVBRegisteredFrontend *m_fe; +}; + +class eDVBAllocatedDemux +{ +DECLARE_REF(eDVBAllocatedDemux); +public: + + eDVBAllocatedDemux(eDVBRegisteredDemux *demux); + ~eDVBAllocatedDemux(); + eDVBDemux &get() { return *m_demux->m_demux; } + operator eDVBRegisteredDemux*() { return m_demux; } + operator eDVBDemux*() { return m_demux->m_demux; } + +private: + eDVBRegisteredDemux *m_demux; +}; + +class iDVBAdapter: public iObject +{ +public: + virtual int getNumDemux() = 0; + virtual RESULT getDemux(ePtr &demux, int nr) = 0; + + virtual int getNumFrontends() = 0; + virtual RESULT getFrontend(ePtr &fe, int nr) = 0; +}; + +class eDVBAdapterLinux: public iDVBAdapter +{ +DECLARE_REF(eDVBAdapterLinux); +public: + eDVBAdapterLinux(int nr); + + int getNumDemux(); + RESULT getDemux(ePtr &demux, int nr); + + int getNumFrontends(); + RESULT getFrontend(ePtr &fe, int nr); + + static int exist(int nr); +private: + int m_nr; + eSmartPtrList m_frontend; + eSmartPtrList m_demux; +}; -class eDVBResourceManager: public iDVBResourceManager +class eDVBResourceManager: public iObject { DECLARE_REF(eDVBResourceManager); int avail, busy; - struct adapter + + eSmartPtrList m_adapter; + + eSmartPtrList m_demux; + eSmartPtrList m_frontend; + + void addAdapter(iDVBAdapter *adapter); + + /* allocates a frontend able to tune to channelID "chid". + the frontend must be tuned lateron. there is no guarante + that tuning will suceed - it just means that if this frontend + can't tune, no other frontend could do it. + + there might be a priority given to certain frontend/chid + combinations. this will be evaluated here. */ + + RESULT allocateFrontend(const eDVBChannelID &chid, ePtr &fe); + + /* allocate a demux able to filter on the selected frontend. */ + RESULT allocateDemux(eDVBRegisteredFrontend *fe, ePtr &demux); + + struct active_channel { - eSmartPtrList fe; - eSmartPtrList demux; + eDVBChannelID m_channel_id; + /* we don't hold a reference here. */ + eDVBChannel *m_channel; + + active_channel(const eDVBChannelID &chid, eDVBChannel *ch) : m_channel_id(chid), m_channel(ch) { } }; - std::multimap m_active_channels; + + std::list m_active_channels; + ePtr m_list; ePtr m_sec; static eDVBResourceManager *instance; + + friend class eDVBChannel; + RESULT addChannel(const eDVBChannelID &chid, eDVBChannel *ch); + RESULT removeChannel(eDVBChannel *ch); public: eDVBResourceManager(); virtual ~eDVBResourceManager(); @@ -30,32 +145,41 @@ public: RESULT setChannelList(iDVBChannelList *list); RESULT getChannelList(ePtr &list); + enum { + errNoFrontend = -1, + errNoDemux = -2, + errChidNotFound = -3 + }; + + /* allocate channel... */ RESULT allocateChannel(const eDVBChannelID &channelid, ePtr &channel); RESULT allocateRawChannel(ePtr &channel); RESULT allocatePVRChannel(int caps); - - RESULT addChannel(const eDVBChannelID &chid, eDVBChannel *ch); - RESULT removeChannel(const eDVBChannelID &chid, eDVBChannel *ch); + }; -class eDVBChannel: public iDVBChannel, public eDVBDemux, public Object +class eDVBChannel: public iDVBChannel, public Object { DECLARE_REF(eDVBChannel); private: - ePtr m_frontend; + ePtr m_frontend; + ePtr m_demux; + ePtr m_current_frontend_parameters; eDVBChannelID m_channel_id; Signal1 m_stateChanged; int m_state; + + /* for channel list */ ePtr m_mgr; void frontendStateChanged(iDVBFrontend*fe); ePtr m_conn_frontendStateChanged; public: - eDVBChannel(eDVBResourceManager *mgr, int adapter, int frontend, int demux); + eDVBChannel(eDVBResourceManager *mgr, eDVBAllocatedFrontend *frontend, eDVBAllocatedDemux *demux); virtual ~eDVBChannel(); - /* only for managed channels */ + /* only for managed channels - effectively tunes to the channelid. should not be used... */ RESULT setChannel(const eDVBChannelID &id); RESULT connectStateChange(const Slot1 &stateChange, ePtr &connection); diff --git a/lib/dvb/idvb.h b/lib/dvb/idvb.h index a6533a9c..1ee92837 100644 --- a/lib/dvb/idvb.h +++ b/lib/dvb/idvb.h @@ -234,24 +234,6 @@ public: virtual RESULT startQuery(ePtr &query, eDVBChannelQuery *query)=0; }; -class iDVBResourceManager: public iObject -{ -public: - /* - solange rumloopen bis eine resource gefunden wurde, die eine frequenz - tunen will - - wenn natuerlich sowas schon vorhanden ist, dann einfach ne ref darauf - geben. (zwei services auf dem gleichen transponder teilen sich einen - channel) - */ - virtual RESULT setChannelList(iDVBChannelList *list)=0; - virtual RESULT getChannelList(ePtr &list)=0; - virtual RESULT allocateChannel(const eDVBChannelID &channel, ePtr &channel)=0; - virtual RESULT allocateRawChannel(ePtr &channel)=0; - virtual RESULT allocatePVRChannel(int caps)=0; -}; - class SatelliteDeliverySystemDescriptor; class CableDeliverySystemDescriptor; class TerrestrialDeliverySystemDescriptor; diff --git a/lib/dvb/pmt.h b/lib/dvb/pmt.h index b3a0a538..03df198b 100644 --- a/lib/dvb/pmt.h +++ b/lib/dvb/pmt.h @@ -2,6 +2,7 @@ #define __lib_dvb_dvbmid_h #include +#include #include #include #include @@ -18,7 +19,7 @@ class eDVBServicePMTHandler: public Object eAUTable > m_PAT; ePtr m_channel; - ePtr m_resourceManager; + ePtr m_resourceManager; ePtr m_demux; void channelStateChanged(iDVBChannel *); diff --git a/lib/dvb/scan.cpp b/lib/dvb/scan.cpp index b6d0575b..0fc3e0a8 100644 --- a/lib/dvb/scan.cpp +++ b/lib/dvb/scan.cpp @@ -13,8 +13,8 @@ #include #include -#define SCAN_eDebug(x...) -#define SCAN_eDebugNoNewLine(x...) +#define SCAN_eDebug(x...) eDebug(x) +#define SCAN_eDebugNoNewLine(x...) eDebugNoNewLine(x) DEFINE_REF(eDVBScan); diff --git a/lib/service/Makefile.am b/lib/service/Makefile.am index f8cf6d52..ed09d73d 100644 --- a/lib/service/Makefile.am +++ b/lib/service/Makefile.am @@ -5,5 +5,5 @@ noinst_LIBRARIES = libenigma_service.a libenigma_service_a_SOURCES = \ listboxservice.cpp service.cpp servicemp3.cpp servicedvb.cpp servicefs.cpp \ - event.cpp + event.cpp servicedvbrecord.cpp diff --git a/lib/service/servicedvb.cpp b/lib/service/servicedvb.cpp index 48d00d65..40e26365 100644 --- a/lib/service/servicedvb.cpp +++ b/lib/service/servicedvb.cpp @@ -9,6 +9,8 @@ #include #include +#include + DEFINE_REF(eServiceFactoryDVB) eServiceFactoryDVB::eServiceFactoryDVB() @@ -83,9 +85,9 @@ RESULT eServiceFactoryDVB::play(const eServiceReference &ref, ePtr &ptr) +RESULT eServiceFactoryDVB::record(const eServiceReference &ref, ePtr &ptr) { - ptr = 0; + ptr = new eDVBServiceRecord((eServiceReferenceDVB&)ref); return -1; } diff --git a/lib/service/servicedvbrecord.cpp b/lib/service/servicedvbrecord.cpp new file mode 100644 index 00000000..368adb70 --- /dev/null +++ b/lib/service/servicedvbrecord.cpp @@ -0,0 +1,84 @@ +#include +#include + + +DEFINE_REF(eDVBServiceRecord); + +eDVBServiceRecord::eDVBServiceRecord(const eServiceReferenceDVB &ref): m_ref(ref) +{ + CONNECT(m_service_handler.serviceEvent, eDVBServiceRecord::serviceEvent); +} + +void eDVBServiceRecord::serviceEvent(int event) +{ + eDebug("service event %d", event); + switch (event) + { + case eDVBServicePMTHandler::eventTuned: + { + eDebug("tuned.."); + break; + } + case eDVBServicePMTHandler::eventNewProgramInfo: + { + int vpid = -1, apid = -1, pcrpid = -1; + eDVBServicePMTHandler::program program; + if (m_service_handler.getProgramInfo(program)) + eDebug("getting program info failed."); + else + { + eDebugNoNewLine("RECORD: have %d video stream(s)", program.videoStreams.size()); + if (!program.videoStreams.empty()) + { + eDebugNoNewLine(" ("); + for (std::vector::const_iterator + i(program.videoStreams.begin()); + i != program.videoStreams.end(); ++i) + { + if (vpid == -1) + vpid = i->pid; + if (i != program.videoStreams.begin()) + eDebugNoNewLine(", "); + eDebugNoNewLine("%04x", i->pid); + } + eDebugNoNewLine(")"); + } + eDebugNoNewLine(", and %d audio stream(s)", program.audioStreams.size()); + if (!program.audioStreams.empty()) + { + eDebugNoNewLine(" ("); + for (std::vector::const_iterator + i(program.audioStreams.begin()); + i != program.audioStreams.end(); ++i) + { + if (apid == -1) + apid = i->pid; + if (i != program.audioStreams.begin()) + eDebugNoNewLine(", "); + eDebugNoNewLine("%04x", i->pid); + } + eDebugNoNewLine(")"); + } + eDebug(", and the pcr pid is %04x", program.pcrPid); + if (program.pcrPid != 0x1fff) + pcrpid = program.pcrPid; + } + + // notify record thread... + break; + } + } +} + +RESULT eDVBServiceRecord::start() +{ + eDebug("starting recording.."); + return m_service_handler.tune(m_ref); +} + +RESULT eDVBServiceRecord::stop() +{ + eDebug("stop recording!!"); + return 0; +} + diff --git a/lib/service/servicedvbrecord.h b/lib/service/servicedvbrecord.h new file mode 100644 index 00000000..93118bed --- /dev/null +++ b/lib/service/servicedvbrecord.h @@ -0,0 +1,27 @@ +#ifndef __servicedvbrecord_h +#define __servicedvbrecord_h + +#include +#include + +#include +#include + +#include + +class eDVBServiceRecord: public iRecordableService, public Object +{ +DECLARE_REF(eDVBServiceRecord); +public: + RESULT start(); + RESULT stop(); +private: + friend class eServiceFactoryDVB; + eDVBServiceRecord(const eServiceReferenceDVB &ref); + + eDVBServicePMTHandler m_service_handler; + eServiceReferenceDVB m_ref; + void serviceEvent(int event); +}; + +#endif -- 2.30.2