lcd: fix inverted mode
[enigma2.git] / lib / service / servicedvb.cpp
index 3b22ab7..d8206b9 100644 (file)
 #include <lib/base/init_num.h>
 #include <lib/base/init.h>
 
 #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;
+       }
+
+       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()
 {
        ePtr<eServiceCenter> sc;
        
 DEFINE_REF(eServiceFactoryDVB)
 
 eServiceFactoryDVB::eServiceFactoryDVB()
 {
        ePtr<eServiceCenter> sc;
        
-       eServiceCenter::getInstance(sc);
+       eServiceCenter::getPrivInstance(sc);
        if (sc)
                sc->addServiceFactory(eServiceFactoryDVB::id, this);
 }
        if (sc)
                sc->addServiceFactory(eServiceFactoryDVB::id, this);
 }
@@ -21,52 +192,295 @@ eServiceFactoryDVB::~eServiceFactoryDVB()
 {
        ePtr<eServiceCenter> sc;
        
 {
        ePtr<eServiceCenter> sc;
        
-       eServiceCenter::getInstance(sc);
+       eServiceCenter::getPrivInstance(sc);
        if (sc)
                sc->removeServiceFactory(eServiceFactoryDVB::id);
 }
 
        if (sc)
                sc->removeServiceFactory(eServiceFactoryDVB::id);
 }
 
+DEFINE_REF(eDVBServiceList);
+
+eDVBServiceList::eDVBServiceList(const eServiceReference &parent): m_parent(parent)
+{
+}
+
+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 eDVBServiceList::getContent(std::list<eServiceReference> &list)
+{
+       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;
+
+               if (db->getBouquet(m_parent, m_bouquet) != 0)
+                       return -1;
+
+               res = this;
+               
+               return 0;
+       }
+       res = 0;
+       return -1;
+}
+
+RESULT eDVBServiceList::addService(eServiceReference &ref)
+{
+       if (!m_bouquet)
+               return -1;
+       return m_bouquet->addService(ref);
+}
+
+RESULT eDVBServiceList::removeService(eServiceReference &ref)
+{
+       if (!m_bouquet)
+               return -1;
+       return m_bouquet->removeService(ref);
+}
+
+RESULT eDVBServiceList::moveService(eServiceReference &ref, int pos)
+{
+       if (!m_bouquet)
+               return -1;
+       return m_bouquet->moveService(ref, pos);
+}
+
+RESULT eDVBServiceList::flushChanges()
+{
+       if (!m_bouquet)
+               return -1;
+       return m_bouquet->flushChanges();
+}
+
 RESULT eServiceFactoryDVB::play(const eServiceReference &ref, ePtr<iPlayableService> &ptr)
 {
 RESULT eServiceFactoryDVB::play(const eServiceReference &ref, ePtr<iPlayableService> &ptr)
 {
+       ePtr<eDVBService> service;
+       int r = lookupService(service, ref);
+       if (r)
+               service = 0;
                // check resources...
                // check resources...
-       ptr = new eDVBServicePlay(ref);
+       ptr = new eDVBServicePlay(ref, service);
        return 0;
 }
 
        return 0;
 }
 
-RESULT eServiceFactoryDVB::record(const eServiceReference &, ePtr<iRecordableService> &ptr)
+RESULT eServiceFactoryDVB::record(const eServiceReference &ref, ePtr<iRecordableService> &ptr)
 {
 {
-       ptr = 0;
-       return -1;
+       if (ref.path.empty())
+       {
+               ptr = new eDVBServiceRecord((eServiceReferenceDVB&)ref);
+               return 0;
+       } else
+       {
+               ptr = 0;
+               return -1;
+       }
 }
 
 }
 
-RESULT eServiceFactoryDVB::list(const eServiceReference &, ePtr<iListableService> &ptr)
+RESULT eServiceFactoryDVB::list(const eServiceReference &ref, ePtr<iListableService> &ptr)
 {
 {
-       ptr = 0;
-       return -1;
+       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;
+       }
 }
 
 }
 
-eDVBServicePlay::eDVBServicePlay(const eServiceReference &ref): 
-       m_reference(ref)
+RESULT eServiceFactoryDVB::offlineOperations(const eServiceReference &ref, ePtr<iServiceOfflineOperations> &ptr)
 {
 {
-       CONNECT(m_serviceHandler.serviceEvent, eDVBServicePlay::serviceEvent);
-       eDebug("DVB start (play)");
+       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)
+{
+       m_is_pvr = !ref.path.empty();
+       
+       CONNECT(m_service_handler.serviceEvent, eDVBServicePlay::serviceEvent);
+       CONNECT(m_event_handler.m_eit_changed, eDVBServicePlay::gotNewEvent);
 }
 
 eDVBServicePlay::~eDVBServicePlay()
 {
 }
 
 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)
 {
 }
 
 void eDVBServicePlay::serviceEvent(int event)
 {
-       eDebug("service event %d", event);
        switch (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:
        {
        case eDVBServicePMTHandler::eventNewProgramInfo:
        {
-               int vpid = -1, apid = -1, pcrpid = -1;
+               int vpid = -1, apid = -1, apidtype = -1, pcrpid = -1;
                eDVBServicePMTHandler::program program;
                eDVBServicePMTHandler::program program;
-               if (m_serviceHandler.getProgramInfo(program))
+               if (m_service_handler.getProgramInfo(program))
                        eDebug("getting program info failed.");
                else
                {
                        eDebug("getting program info failed.");
                else
                {
@@ -95,7 +509,10 @@ void eDVBServicePlay::serviceEvent(int event)
                                        i != program.audioStreams.end(); ++i)
                                {
                                        if (apid == -1)
                                        i != program.audioStreams.end(); ++i)
                                {
                                        if (apid == -1)
+                                       {
                                                apid = i->pid;
                                                apid = i->pid;
+                                               apidtype = i->type;
+                                       }
                                        if (i != program.audioStreams.begin())
                                                eDebugNoNewLine(", ");
                                        eDebugNoNewLine("%04x", i->pid);
                                        if (i != program.audioStreams.begin())
                                                eDebugNoNewLine(", ");
                                        eDebugNoNewLine("%04x", i->pid);
@@ -110,7 +527,7 @@ void eDVBServicePlay::serviceEvent(int event)
                if (!m_decoder)
                {
                        ePtr<iDVBDemux> demux;
                if (!m_decoder)
                {
                        ePtr<iDVBDemux> demux;
-                       m_serviceHandler.getDemux(demux);
+                       m_service_handler.getDemux(demux);
                        if (demux)
                                demux->getMPEGDecoder(m_decoder);
                }
                        if (demux)
                                demux->getMPEGDecoder(m_decoder);
                }
@@ -118,11 +535,25 @@ void eDVBServicePlay::serviceEvent(int event)
                if (m_decoder)
                {
                        m_decoder->setVideoPID(vpid);
                if (m_decoder)
                {
                        m_decoder->setVideoPID(vpid);
-                       m_decoder->setAudioPID(apid, 0);
-                       m_decoder->setSyncPCR(pcrpid);
+                       m_decoder->setAudioPID(apid, apidtype);
+                       if (!m_is_pvr)
+                               m_decoder->setSyncPCR(pcrpid);
+                       else
+                               m_decoder->setSyncPCR(-1);
                        m_decoder->start();
                        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;
        }
        }
                break;
        }
        }
@@ -130,8 +561,12 @@ void eDVBServicePlay::serviceEvent(int event)
 
 RESULT eDVBServicePlay::start()
 {
 
 RESULT eDVBServicePlay::start()
 {
+       int r;
        eDebug("starting DVB service");
        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()
 }
 
 RESULT eDVBServicePlay::stop()
@@ -142,17 +577,113 @@ RESULT eDVBServicePlay::stop()
 
 RESULT eDVBServicePlay::connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection)
 {
 
 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;
 }
 
        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;
 }
 
        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;
+       
+       to *= direction;
+       
+       ePtr<iDVBDemux> demux;
+       m_service_handler.getDemux(demux);
+       if (!demux)
+               return -1;
+       
+       return pvr_channel->seekTo(demux, 1, to);
+}
+
+RESULT eDVBServicePlay::getPlayPosition(pts_t &pos)
+{
+       ePtr<iDVBPVRChannel> pvr_channel;
+       
+       if (m_service_handler.getPVRChannel(pvr_channel))
+               return -1;
+       
+       ePtr<iDVBDemux> demux;
+       m_service_handler.getDemux(demux);
+       if (!demux)
+               return -1;
+       
+       return pvr_channel->getCurrentPosition(demux, pos);
+}
+
+RESULT eDVBServicePlay::info(ePtr<iServiceInformation> &ptr)
+{
+       ptr = this;
+       return 0;
+}
+
+RESULT eDVBServicePlay::audioTracks(ePtr<iAudioTrackSelection> &ptr)
 {
        ptr = this;
        return 0;
 {
        ptr = this;
        return 0;
@@ -160,7 +691,70 @@ RESULT eDVBServicePlay::getIServiceInformation(ePtr<iServiceInformation> &ptr)
 
 RESULT eDVBServicePlay::getName(std::string &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);
+}
+
+int eDVBServicePlay::getNumberOfTracks()
+{
+       eDVBServicePMTHandler::program program;
+       if (m_service_handler.getProgramInfo(program))
+               return 0;
+       return program.audioStreams.size();
+}
+
+RESULT eDVBServicePlay::selectTrack(unsigned int i)
+{
+       eDVBServicePMTHandler::program program;
+
+       if (m_service_handler.getProgramInfo(program))
+               return -1;
+       
+       if (i >= program.audioStreams.size())
+               return -2;
+       
+       if (!m_decoder)
+               return -3;
+       
+       if (m_decoder->setAudioPID(program.audioStreams[i].pid, program.audioStreams[i].type))
+               return -4;
+
+       if (m_decoder->start())
+               return -5;
+       
+       return 0;
+}
+
+RESULT eDVBServicePlay::getTrackInfo(struct iAudioTrackInfo &info, unsigned int i)
+{
+       eDVBServicePMTHandler::program program;
+
+       if (m_service_handler.getProgramInfo(program))
+               return -1;
+       
+       if (i >= program.audioStreams.size())
+               return -2;
+       
+       if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atMPEG)
+               info.m_description = "MPEG";
+       else if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atAC3)
+               info.m_description = "AC3";
+       else  if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atDTS)
+               info.m_description = "DTS";
+       else
+               info.m_description = "???";
+       
        return 0;
 }
 
        return 0;
 }