X-Git-Url: https://git.cweiske.de/enigma2.git/blobdiff_plain/c0f5089ea04bd04fe25148e712fa62cd49dc17da..2e2cf81de863a180f7d27dca89e5122e1eb0acaa:/lib/service/servicedvb.cpp

diff --git a/lib/service/servicedvb.cpp b/lib/service/servicedvb.cpp
index 62dbee54..94833f44 100644
--- a/lib/service/servicedvb.cpp
+++ b/lib/service/servicedvb.cpp
@@ -6,13 +6,184 @@
 #include <lib/base/init_num.h>
 #include <lib/base/init.h>
 
+#include <lib/dvb/dvb.h>
+#include <lib/dvb/db.h>
+
+#include <lib/service/servicedvbrecord.h>
+#include <lib/dvb/metaparser.h>
+#include <lib/dvb/tstools.h>
+
+class eStaticServiceDVBInformation: public iStaticServiceInformation
+{
+	DECLARE_REF(eStaticServiceDVBInformation);
+public:
+	RESULT getName(const eServiceReference &ref, std::string &name);
+	int getLength(const eServiceReference &ref);
+};
+
+DEFINE_REF(eStaticServiceDVBInformation);
+
+RESULT eStaticServiceDVBInformation::getName(const eServiceReference &ref, std::string &name)
+{
+	if ( ref.name.length() )
+	{
+		name = ref.name;
+		return 0;
+	}
+	else
+		return -1;
+}
+
+int eStaticServiceDVBInformation::getLength(const eServiceReference &ref)
+{
+	return -1;
+}
+
+class eStaticServiceDVBBouquetInformation: public iStaticServiceInformation
+{
+	DECLARE_REF(eStaticServiceDVBBouquetInformation);
+public:
+	RESULT getName(const eServiceReference &ref, std::string &name);
+	int getLength(const eServiceReference &ref);
+};
+
+DEFINE_REF(eStaticServiceDVBBouquetInformation);
+
+RESULT eStaticServiceDVBBouquetInformation::getName(const eServiceReference &ref, std::string &name)
+{
+	ePtr<iDVBChannelList> db;
+	ePtr<eDVBResourceManager> res;
+
+	int err;
+	if ((err = eDVBResourceManager::getInstance(res)) != 0)
+	{
+		eDebug("eStaticServiceDVBBouquetInformation::getName failed.. no resource manager!");
+		return err;
+	}
+	if ((err = res->getChannelList(db)) != 0)
+	{
+		eDebug("eStaticServiceDVBBouquetInformation::getName failed.. no channel list!");
+		return err;
+	}
+
+	const eBouquet *bouquet=0;
+	if ((err = db->getBouquet(ref, bouquet)) != 0)
+	{
+		eDebug("eStaticServiceDVBBouquetInformation::getName failed.. getBouquet failed!");
+		return -1;
+	}
+
+	if ( bouquet && bouquet->m_bouquet_name.length() )
+	{
+		name = "[Bouquet] " + bouquet->m_bouquet_name;
+		return 0;
+	}
+	else
+		return -1;
+}
+
+int eStaticServiceDVBBouquetInformation::getLength(const eServiceReference &ref)
+{
+	return -1;
+}
+
+class eStaticServiceDVBPVRInformation: public iStaticServiceInformation
+{
+	DECLARE_REF(eStaticServiceDVBPVRInformation);
+	eServiceReference m_ref;
+	eDVBMetaParser m_parser;
+public:
+	eStaticServiceDVBPVRInformation(const eServiceReference &ref);
+	RESULT getName(const eServiceReference &ref, std::string &name);
+	int getLength(const eServiceReference &ref);
+};
+
+DEFINE_REF(eStaticServiceDVBPVRInformation);
+
+eStaticServiceDVBPVRInformation::eStaticServiceDVBPVRInformation(const eServiceReference &ref)
+{
+	m_ref = ref;
+	m_parser.parseFile(ref.path);
+}
+
+RESULT eStaticServiceDVBPVRInformation::getName(const eServiceReference &ref, std::string &name)
+{
+	ASSERT(ref == m_ref);
+	name = m_parser.m_name.size() ? m_parser.m_name : ref.path;
+	return 0;
+}
+
+int eStaticServiceDVBPVRInformation::getLength(const eServiceReference &ref)
+{
+	ASSERT(ref == m_ref);
+	
+	eDVBTSTools tstools;
+	
+	if (tstools.openFile(ref.path.c_str()))
+		return 0;
+
+	pts_t len;
+	if (tstools.calcLen(len))
+		return 0;
+
+	return len / 90000;
+}
+
+
+
+class eDVBPVRServiceOfflineOperations: public iServiceOfflineOperations
+{
+	DECLARE_REF(eDVBPVRServiceOfflineOperations);
+	eServiceReferenceDVB m_ref;
+public:
+	eDVBPVRServiceOfflineOperations(const eServiceReference &ref);
+	
+	RESULT deleteFromDisk(int simulate);
+	RESULT getListOfFilenames(std::list<std::string> &);
+};
+
+DEFINE_REF(eDVBPVRServiceOfflineOperations);
+
+eDVBPVRServiceOfflineOperations::eDVBPVRServiceOfflineOperations(const eServiceReference &ref): m_ref((const eServiceReferenceDVB&)ref)
+{
+}
+
+RESULT eDVBPVRServiceOfflineOperations::deleteFromDisk(int simulate)
+{
+	if (simulate)
+		return 0;
+	else
+	{
+		std::list<std::string> res;
+		if (getListOfFilenames(res))
+			return -1;
+		
+				/* TODO: deferred removing.. */
+		for (std::list<std::string>::iterator i(res.begin()); i != res.end(); ++i)
+		{
+			eDebug("Removing %s...", i->c_str());
+			::unlink(i->c_str());
+		}
+		
+		return 0;
+	}
+}
+
+RESULT eDVBPVRServiceOfflineOperations::getListOfFilenames(std::list<std::string> &res)
+{
+	res.clear();
+	res.push_back(m_ref.path);
+	res.push_back(m_ref.path + ".meta");
+	return 0;
+}
+
 DEFINE_REF(eServiceFactoryDVB)
 
-eServiceFactoryDVB::eServiceFactoryDVB(): ref(0)
+eServiceFactoryDVB::eServiceFactoryDVB()
 {
 	ePtr<eServiceCenter> sc;
 	
-	eServiceCenter::getInstance(sc);
+	eServiceCenter::getPrivInstance(sc);
 	if (sc)
 		sc->addServiceFactory(eServiceFactoryDVB::id, this);
 }
@@ -21,52 +192,290 @@ eServiceFactoryDVB::~eServiceFactoryDVB()
 {
 	ePtr<eServiceCenter> sc;
 	
-	eServiceCenter::getInstance(sc);
+	eServiceCenter::getPrivInstance(sc);
 	if (sc)
 		sc->removeServiceFactory(eServiceFactoryDVB::id);
 }
 
-RESULT eServiceFactoryDVB::play(const eServiceReference &ref, ePtr<iPlayableService> &ptr)
+DEFINE_REF(eDVBServiceList);
+
+eDVBServiceList::eDVBServiceList(const eServiceReference &parent): m_parent(parent)
 {
-		// check resources...
-	ptr = new eDVBServicePlay(ref);
+}
+
+eDVBServiceList::~eDVBServiceList()
+{
+}
+
+RESULT eDVBServiceList::startQuery()
+{
+	ePtr<iDVBChannelList> db;
+	ePtr<eDVBResourceManager> res;
+	
+	int err;
+	if ((err = eDVBResourceManager::getInstance(res)) != 0)
+	{
+		eDebug("no resource manager");
+		return err;
+	}
+	if ((err = res->getChannelList(db)) != 0)
+	{
+		eDebug("no channel list");
+		return err;
+	}
+	
+	ePtr<eDVBChannelQuery> q;
+	
+	if (!m_parent.path.empty())
+	{
+		eDVBChannelQuery::compile(q, m_parent.path);
+		if (!q)
+		{
+			eDebug("compile query failed");
+			return err;
+		}
+	}
+	
+	if ((err = db->startQuery(m_query, q, m_parent)) != 0)
+	{
+		eDebug("startQuery failed");
+		return err;
+	}
+
 	return 0;
 }
 
-RESULT eServiceFactoryDVB::record(const eServiceReference &, ePtr<iRecordableService> &ptr)
+RESULT eDVBServiceList::getContent(std::list<eServiceReference> &list)
 {
-	ptr = 0;
+	eServiceReferenceDVB ref;
+	
+	if (!m_query)
+		return -1;
+	
+	while (!m_query->getNextResult(ref))
+		list.push_back(ref);
+	return 0;
+}
+
+RESULT eDVBServiceList::getNext(eServiceReference &ref)
+{
+	if (!m_query)
+		return -1;
+	
+	return m_query->getNextResult((eServiceReferenceDVB&)ref);
+}
+
+int eDVBServiceList::compareLessEqual(const eServiceReference &a, const eServiceReference &b)
+{
+	return m_query->compareLessEqual((const eServiceReferenceDVB&)a, (const eServiceReferenceDVB&)b);
+}
+
+RESULT eDVBServiceList::startEdit(ePtr<iMutableServiceList> &res)
+{
+	if (m_parent.flags & eServiceReference::flagDirectory) // bouquet
+	{
+		ePtr<iDVBChannelList> db;
+		ePtr<eDVBResourceManager> resm;
+
+		if (eDVBResourceManager::getInstance(resm) || resm->getChannelList(db))
+			return -1;
+
+			// FIXME!
+		if (db->getBouquet(m_parent, (const eBouquet*&)m_bouquet) != 0)
+			return -1;
+		
+		res = this;
+		
+		return 0;
+	}
+	res = 0;
 	return -1;
 }
 
-RESULT eServiceFactoryDVB::list(const eServiceReference &, ePtr<iListableService> &ptr)
+RESULT eDVBServiceList::addService(eServiceReference &ref)
 {
-	ptr = 0;
+	ASSERT(m_bouquet);
+//	return m_bouquet->addService(ref);
+	return -1;
+}
+
+RESULT eDVBServiceList::removeService(eServiceReference &ref)
+{
+	ASSERT(m_bouquet);
+//	return m_bouquet->removeService(ref);
+	return -1;
+}
+
+RESULT eDVBServiceList::moveService(eServiceReference &ref, int pos)
+{
+	ASSERT(m_bouquet);
+	
+//	return m_bouquet->moveService(ref, pos);
 	return -1;
 }
 
-eDVBServicePlay::eDVBServicePlay(const eServiceReference &ref): 
-	ref(0), m_reference(ref)
+RESULT eServiceFactoryDVB::play(const eServiceReference &ref, ePtr<iPlayableService> &ptr)
+{
+	ePtr<eDVBService> service;
+	int r = lookupService(service, ref);
+	if (r)
+		service = 0;
+		// check resources...
+	ptr = new eDVBServicePlay(ref, service);
+	return 0;
+}
+
+RESULT eServiceFactoryDVB::record(const eServiceReference &ref, ePtr<iRecordableService> &ptr)
+{
+	if (ref.path.empty())
+	{
+		ptr = new eDVBServiceRecord((eServiceReferenceDVB&)ref);
+		return 0;
+	} else
+	{
+		ptr = 0;
+		return -1;
+	}
+}
+
+RESULT eServiceFactoryDVB::list(const eServiceReference &ref, ePtr<iListableService> &ptr)
+{
+	ePtr<eDVBServiceList> list = new eDVBServiceList(ref);
+	if (list->startQuery())
+	{
+		ptr = 0;
+		return -1;
+	}
+	
+	ptr = list;
+	return 0;
+}
+
+RESULT eServiceFactoryDVB::info(const eServiceReference &ref, ePtr<iStaticServiceInformation> &ptr)
+{
+		/* do we have a PVR service? */
+	if (ref.flags & eServiceReference::flagDirectory) // bouquet
+	{
+		ptr = new eStaticServiceDVBBouquetInformation;
+		return 0;
+	}
+	else if (!ref.path.empty())
+	{
+		ptr = new eStaticServiceDVBPVRInformation(ref);
+		return 0;
+	}
+	else
+	{
+		ePtr<eDVBService> service;
+		int r = lookupService(service, ref);
+		if (r)
+			ptr = new eStaticServiceDVBInformation;
+		else
+			/* eDVBService has the iStaticServiceInformation interface, so we pass it here. */
+			ptr = service;
+		return 0;
+	}
+}
+
+RESULT eServiceFactoryDVB::offlineOperations(const eServiceReference &ref, ePtr<iServiceOfflineOperations> &ptr)
+{
+	if (ref.path.empty())
+	{
+		ptr = 0;
+		return -1;
+	} else
+	{
+		ptr = new eDVBPVRServiceOfflineOperations(ref);
+		return 0;
+	}
+}
+
+RESULT eServiceFactoryDVB::lookupService(ePtr<eDVBService> &service, const eServiceReference &ref)
+{
+			// TODO: handle the listing itself
+	// if (ref.... == -1) .. return "... bouquets ...";
+	// could be also done in another serviceFactory (with seperate ID) to seperate actual services and lists
+			// TODO: cache
+	ePtr<iDVBChannelList> db;
+	ePtr<eDVBResourceManager> res;
+	
+	int err;
+	if ((err = eDVBResourceManager::getInstance(res)) != 0)
+	{
+		eDebug("no resource manager");
+		return err;
+	}
+	if ((err = res->getChannelList(db)) != 0)
+	{
+		eDebug("no channel list");
+		return err;
+	}
+	
+		/* we are sure to have a ..DVB reference as the info() call was forwarded here according to it's ID. */
+	if ((err = db->getService((eServiceReferenceDVB&)ref, service)) != 0)
+	{
+		eDebug("getService failed!");
+		return err;
+	}
+
+	return 0;
+}
+
+eDVBServicePlay::eDVBServicePlay(const eServiceReference &ref, eDVBService *service): 
+	m_reference(ref), m_dvb_service(service), m_service_handler(0), m_is_paused(0)
 {
-	CONNECT(m_serviceHandler.serviceEvent, eDVBServicePlay::serviceEvent);
-	eDebug("DVB start (play)");
+	m_is_pvr = !ref.path.empty();
+	
+	CONNECT(m_service_handler.serviceEvent, eDVBServicePlay::serviceEvent);
+	CONNECT(m_event_handler.m_eit_changed, eDVBServicePlay::gotNewEvent);
 }
 
 eDVBServicePlay::~eDVBServicePlay()
 {
-	eDebug("DVB stop (play)");
+}
+
+void eDVBServicePlay::gotNewEvent()
+{
+#if 0
+		// 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);
+#endif
+	m_event((iPlayableService*)this, evUpdatedEventInfo);
 }
 
 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());
+		}
+//			eventNoEvent
+		break;
+	}
+	case eDVBServicePMTHandler::eventTuneFailed:
+	{
+		eDebug("DVB service failed to tune");
+		m_event((iPlayableService*)this, evTuneFailed);
+		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
 		{
@@ -110,7 +519,7 @@ void eDVBServicePlay::serviceEvent(int event)
 		if (!m_decoder)
 		{
 			ePtr<iDVBDemux> demux;
-			m_serviceHandler.getDemux(demux);
+			m_service_handler.getDemux(demux);
 			if (demux)
 				demux->getMPEGDecoder(m_decoder);
 		}
@@ -119,10 +528,24 @@ void eDVBServicePlay::serviceEvent(int event)
 		{
 			m_decoder->setVideoPID(vpid);
 			m_decoder->setAudioPID(apid, 0);
-			m_decoder->setSyncPCR(pcrpid);
+			if (!m_is_pvr)
+				m_decoder->setSyncPCR(pcrpid);
+			else
+				m_decoder->setSyncPCR(-1);
 			m_decoder->start();
-		}
+// how we can do this better?
+// update cache pid when the user changed the audio track or video track
+// TODO handling of difference audio types.. default audio types..
 				
+				/* don't worry about non-existing services, nor pvr services */
+			if (m_dvb_service && !m_is_pvr)
+			{
+				m_dvb_service->setCachePID(eDVBService::cVPID, vpid);
+				m_dvb_service->setCachePID(eDVBService::cAPID, apid);
+				m_dvb_service->setCachePID(eDVBService::cPCRPID, pcrpid);
+			}
+		}
+		
 		break;
 	}
 	}
@@ -130,8 +553,12 @@ void eDVBServicePlay::serviceEvent(int event)
 
 RESULT eDVBServicePlay::start()
 {
+	int r;
 	eDebug("starting DVB service");
-	return m_serviceHandler.tune((eServiceReferenceDVB&)m_reference);
+	r = m_service_handler.tune((eServiceReferenceDVB&)m_reference);
+	eDebug("tune result: %d", r);
+	m_event(this, evStart);
+	return 0;
 }
 
 RESULT eDVBServicePlay::stop()
@@ -142,28 +569,117 @@ RESULT eDVBServicePlay::stop()
 
 RESULT eDVBServicePlay::connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection)
 {
+	connection = new eConnection((iPlayableService*)this, m_event.connect(event));
+	return 0;
+}
+
+RESULT eDVBServicePlay::pause(ePtr<iPauseableService> &ptr)
+{
+	if (m_is_pvr)
+	{
+		ptr = this;
+		return 0;
+	}
+
+	ptr = 0;
 	return -1;
 }
 
-RESULT eDVBServicePlay::getIPausableService(ePtr<iPauseableService> &ptr)
+RESULT eDVBServicePlay::seek(ePtr<iSeekableService> &ptr)
 {
-		// not yet possible, maybe later...
+	if (m_is_pvr)
+	{
+		ptr = this;
+		return 0;
+	}
+	
 	ptr = 0;
 	return -1;
 }
 
-RESULT eDVBServicePlay::getIServiceInformation(ePtr<iServiceInformation> &ptr)
+RESULT eDVBServicePlay::getLength(pts_t &len)
+{
+	ePtr<iDVBPVRChannel> pvr_channel;
+	
+	if (m_service_handler.getPVRChannel(pvr_channel))
+	{
+		eDebug("getPVRChannel failed!");
+		return -1;
+	}
+	
+	return pvr_channel->getLength(len);
+}
+
+RESULT eDVBServicePlay::pause()
+{
+	if (!m_is_paused && m_decoder)
+	{
+		m_is_paused = 1;
+		return m_decoder->freeze(0);
+	} else
+		return -1;
+}
+
+RESULT eDVBServicePlay::unpause()
+{
+	if (m_is_paused && m_decoder)
+	{
+		m_is_paused = 0;
+		return m_decoder->unfreeze();
+	} else
+		return -1;
+}
+
+RESULT eDVBServicePlay::seekTo(pts_t to)
+{
+	return -1;
+}
+
+RESULT eDVBServicePlay::seekRelative(int direction, pts_t to)
+{
+	eDebug("eDVBServicePlay::seekRelative: jump %d, %lld", direction, to);
+
+	ePtr<iDVBPVRChannel> pvr_channel;
+	
+	if (m_service_handler.getPVRChannel(pvr_channel))
+		return -1;
+	
+	return pvr_channel->seekToPosition(SEEK_CUR, to);
+}
+
+RESULT eDVBServicePlay::getPlayPosition(pts_t &pos)
+{
+	ePtr<iDVBPVRChannel> pvr_channel;
+	
+	if (m_service_handler.getPVRChannel(pvr_channel))
+		return -1;
+	
+	return pvr_channel->getCurrentPosition(pos);
+}
+
+RESULT eDVBServicePlay::info(ePtr<iServiceInformation> &ptr)
 {
 	ptr = this;
 	return 0;
 }
 
-RESULT eDVBServicePlay::getName(eString &name)
+RESULT eDVBServicePlay::getName(std::string &name)
 {
-	name = "DVB service";
+	if (m_dvb_service)
+	{
+		m_dvb_service->getName(m_reference, name);
+		if (name.empty())
+			name = "(...)";
+	} else
+		name = "DVB service";
 	return 0;
 }
 
+RESULT eDVBServicePlay::getEvent(ePtr<eServiceEvent> &evt, int nownext)
+{
+	return m_event_handler.getEvent(evt, nownext);
+}
+
 DEFINE_REF(eDVBServicePlay)
 
-eAutoInitP0<eServiceFactoryDVB> init_eServiceFactoryDVB(eAutoInitNumbers::service+1, "eServiceFactoryDVB");
+eAutoInitPtr<eServiceFactoryDVB> init_eServiceFactoryDVB(eAutoInitNumbers::service+1, "eServiceFactoryDVB");