Merge branch 'bug_203_fix_wrong_networkstate'

[enigma2.git] / lib / service / servicedvb.cpp

diff --git a/lib/service/servicedvb.cpp b/lib/service/servicedvb.cpp
index 9bc275e0b328c6100a15cb01051a13baa6eb1eb7..a6b6cc6f6bd876db738e6842a377591ce5b49921 100644 (file)
--- a/lib/service/servicedvb.cpp
+++ b/lib/service/servicedvb.cpp
@@ -31,8 +31,6 @@
 #error no byte order defined!
 #endif
 
 #error no byte order defined!
 #endif
 

-#define TSPATH "/media/hdd"
-

 class eStaticServiceDVBInformation: public iStaticServiceInformation
 {
        DECLARE_REF(eStaticServiceDVBInformation);
 class eStaticServiceDVBInformation: public iStaticServiceInformation
 {
        DECLARE_REF(eStaticServiceDVBInformation);


@@ -98,211 +96,10 @@ int eStaticServiceDVBInformation::isPlayable(const eServiceReference &ref, const
        return false;
 }
 
        return false;
 }
 

-static void PutToDict(ePyObject &dict, const char*key, long value)
-{
-       ePyObject item = PyString_FromFormat("%d", value);
-       if (item)
-       {
-               if (PyDict_SetItemString(dict, key, item))
-                       eDebug("put %s to dict failed", key);
-               Py_DECREF(item);
-       }
-       else
-               eDebug("could not create PyObject for %s", key);
-}
-
-extern void PutToDict(ePyObject &dict, const char*key, const char *value);
-
-void PutSatelliteDataToDict(ePyObject &dict, eDVBFrontendParametersSatellite &feparm)
-{
-       const char *tmp=0;
-       PutToDict(dict, "type", "Satellite");
-       PutToDict(dict, "frequency", feparm.frequency);
-       PutToDict(dict, "symbolrate", feparm.symbol_rate);
-       PutToDict(dict, "orbital position", feparm.orbital_position);
-       switch (feparm.inversion)
-       {
-               case eDVBFrontendParametersSatellite::Inversion::On: tmp="ON"; break;
-               case eDVBFrontendParametersSatellite::Inversion::Off: tmp="OFF"; break;
-               default:
-               case eDVBFrontendParametersSatellite::Inversion::Unknown: tmp="AUTO"; break;
-       }
-       PutToDict(dict, "inversion", tmp);
-       switch (feparm.fec)
-       {
-               case eDVBFrontendParametersSatellite::FEC::fNone: tmp="NONE"; break;
-               case eDVBFrontendParametersSatellite::FEC::f1_2: tmp="1/2"; break;
-               case eDVBFrontendParametersSatellite::FEC::f2_3: tmp="2/3"; break;
-               case eDVBFrontendParametersSatellite::FEC::f3_4: tmp="3/4"; break;
-               case eDVBFrontendParametersSatellite::FEC::f5_6: tmp="5/6"; break;
-               case eDVBFrontendParametersSatellite::FEC::f7_8: tmp="7/8"; break;
-               case eDVBFrontendParametersSatellite::FEC::f3_5: tmp="3/5"; break;
-               case eDVBFrontendParametersSatellite::FEC::f4_5: tmp="4/5"; break;
-               case eDVBFrontendParametersSatellite::FEC::f8_9: tmp="8/9"; break;
-               case eDVBFrontendParametersSatellite::FEC::f9_10: tmp="9/10"; break;
-               default:
-               case eDVBFrontendParametersSatellite::FEC::fAuto: tmp="AUTO"; break;
-       }
-       PutToDict(dict, "fec inner", tmp);
-       switch (feparm.modulation)
-       {
-               case eDVBFrontendParametersSatellite::Modulation::Auto: tmp="AUTO"; break;
-               case eDVBFrontendParametersSatellite::Modulation::QPSK: tmp="QPSK"; break;
-               case eDVBFrontendParametersSatellite::Modulation::M8PSK: tmp="8PSK"; break;
-               case eDVBFrontendParametersSatellite::Modulation::QAM_16: tmp="QAM16"; break;
-       }
-       PutToDict(dict, "modulation", tmp);
-       switch(feparm.polarisation)
-       {
-               case eDVBFrontendParametersSatellite::Polarisation::Horizontal: tmp="HORIZONTAL"; break;
-               case eDVBFrontendParametersSatellite::Polarisation::Vertical: tmp="VERTICAL"; break;
-               case eDVBFrontendParametersSatellite::Polarisation::CircularLeft: tmp="CIRCULAR LEFT"; break;
-               default:
-               case eDVBFrontendParametersSatellite::Polarisation::CircularRight: tmp="CIRCULAR RIGHT"; break;
-       }
-       PutToDict(dict, "polarization", tmp);
-       switch(feparm.system)
-       {
-               default:
-               case eDVBFrontendParametersSatellite::System::DVB_S: tmp="DVB-S"; break;
-               case eDVBFrontendParametersSatellite::System::DVB_S2:
-                       switch(feparm.roll_off)
-                       {
-                               case eDVBFrontendParametersSatellite::RollOff::alpha_0_35: tmp="0.35"; break;
-                               case eDVBFrontendParametersSatellite::RollOff::alpha_0_25: tmp="0.25"; break;
-                               case eDVBFrontendParametersSatellite::RollOff::alpha_0_20: tmp="0.20"; break;
-                               default:
-                               case eDVBFrontendParametersSatellite::RollOff::alpha_auto: tmp="AUTO"; break;
-                       }
-                       PutToDict(dict, "roll off", tmp);
-                       tmp="DVB-S2";
-                       break;
-       }
-       PutToDict(dict, "system", tmp);
-}
-
-void PutTerrestrialDataToDict(ePyObject &dict, eDVBFrontendParametersTerrestrial &feparm)
-{
-       PutToDict(dict, "type", "Terrestrial");
-       PutToDict(dict, "frequency", feparm.frequency);
-       const char *tmp=0;
-       switch (feparm.bandwidth)
-       {
-       case eDVBFrontendParametersTerrestrial::Bandwidth::Bw8MHz: tmp="8 MHz"; break;
-       case eDVBFrontendParametersTerrestrial::Bandwidth::Bw7MHz: tmp="7 MHz"; break;
-       case eDVBFrontendParametersTerrestrial::Bandwidth::Bw6MHz: tmp="6 MHz"; break;
-       default:
-       case eDVBFrontendParametersTerrestrial::Bandwidth::BwAuto: tmp="AUTO"; break;
-       }
-       PutToDict(dict, "bandwidth", tmp);
-       switch (feparm.code_rate_LP)
-       {
-       case eDVBFrontendParametersTerrestrial::FEC::f1_2: tmp="1/2"; break;
-       case eDVBFrontendParametersTerrestrial::FEC::f2_3: tmp="2/3"; break;
-       case eDVBFrontendParametersTerrestrial::FEC::f3_4: tmp="3/4"; break;
-       case eDVBFrontendParametersTerrestrial::FEC::f5_6: tmp="5/6"; break;
-       case eDVBFrontendParametersTerrestrial::FEC::f7_8: tmp="7/8"; break;
-       default:
-       case eDVBFrontendParametersTerrestrial::FEC::fAuto: tmp="AUTO"; break;
-       }
-       PutToDict(dict, "code rate lp", tmp);
-       switch (feparm.code_rate_HP)
-       {
-       case eDVBFrontendParametersTerrestrial::FEC::f1_2: tmp="1/2"; break;
-       case eDVBFrontendParametersTerrestrial::FEC::f2_3: tmp="2/3"; break;
-       case eDVBFrontendParametersTerrestrial::FEC::f3_4: tmp="3/4"; break;
-       case eDVBFrontendParametersTerrestrial::FEC::f5_6: tmp="5/6"; break;
-       case eDVBFrontendParametersTerrestrial::FEC::f7_8: tmp="7/8"; break;
-       default:
-       case eDVBFrontendParametersTerrestrial::FEC::fAuto: tmp="AUTO"; break;
-       }
-       PutToDict(dict, "code rate hp", tmp);
-       switch (feparm.modulation)
-       {
-       case eDVBFrontendParametersTerrestrial::Modulation::QPSK: tmp="QPSK"; break;
-       case eDVBFrontendParametersTerrestrial::Modulation::QAM16: tmp="QAM16"; break;
-       case eDVBFrontendParametersTerrestrial::Modulation::QAM64: tmp="QAM64"; break;
-       default:
-       case eDVBFrontendParametersTerrestrial::Modulation::Auto: tmp="AUTO"; break;
-       }
-       PutToDict(dict, "constellation", tmp);
-       switch (feparm.transmission_mode)
-       {
-       case eDVBFrontendParametersTerrestrial::TransmissionMode::TM2k: tmp="2k"; break;
-       case eDVBFrontendParametersTerrestrial::TransmissionMode::TM8k: tmp="8k"; break;
-       default:
-       case eDVBFrontendParametersTerrestrial::TransmissionMode::TMAuto: tmp="AUTO"; break;
-       }
-       PutToDict(dict, "transmission mode", tmp);
-       switch (feparm.guard_interval)
-       {
-               case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_32: tmp="1/32"; break;
-               case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_16: tmp="1/16"; break;
-               case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_8: tmp="1/8"; break;
-               case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_4: tmp="1/4"; break;
-               default:
-               case eDVBFrontendParametersTerrestrial::GuardInterval::GI_Auto: tmp="AUTO"; break;
-       }
-       PutToDict(dict, "guard interval", tmp);
-       switch (feparm.hierarchy)
-       {
-               case eDVBFrontendParametersTerrestrial::Hierarchy::HNone: tmp="NONE"; break;
-               case eDVBFrontendParametersTerrestrial::Hierarchy::H1: tmp="1"; break;
-               case eDVBFrontendParametersTerrestrial::Hierarchy::H2: tmp="2"; break;
-               case eDVBFrontendParametersTerrestrial::Hierarchy::H4: tmp="4"; break;
-               default:
-               case eDVBFrontendParametersTerrestrial::Hierarchy::HAuto: tmp="AUTO"; break;
-       }
-       PutToDict(dict, "hierarchy", tmp);
-       switch (feparm.inversion)
-       {
-               case eDVBFrontendParametersSatellite::Inversion::On: tmp="ON"; break;
-               case eDVBFrontendParametersSatellite::Inversion::Off: tmp="OFF"; break;
-               default:
-               case eDVBFrontendParametersSatellite::Inversion::Unknown: tmp="AUTO"; break;
-       }
-       PutToDict(dict, "inversion", tmp);
-}
-
-void PutCableDataToDict(ePyObject &dict, eDVBFrontendParametersCable &feparm)
-{
-       const char *tmp=0;
-       PutToDict(dict, "type", "Cable");
-       PutToDict(dict, "frequency", feparm.frequency);
-       PutToDict(dict, "symbolrate", feparm.symbol_rate);
-       switch (feparm.modulation)
-       {
-       case eDVBFrontendParametersCable::Modulation::QAM16: tmp="QAM16"; break;
-       case eDVBFrontendParametersCable::Modulation::QAM32: tmp="QAM32"; break;
-       case eDVBFrontendParametersCable::Modulation::QAM64: tmp="QAM64"; break;
-       case eDVBFrontendParametersCable::Modulation::QAM128: tmp="QAM128"; break;
-       case eDVBFrontendParametersCable::Modulation::QAM256: tmp="QAM256"; break;
-       default:
-       case eDVBFrontendParametersCable::Modulation::Auto: tmp="AUTO"; break;
-       }
-       PutToDict(dict, "modulation", tmp);
-       switch (feparm.inversion)
-       {
-       case eDVBFrontendParametersCable::Inversion::On: tmp="ON"; break;
-       case eDVBFrontendParametersCable::Inversion::Off: tmp="OFF"; break;
-       default:
-       case eDVBFrontendParametersCable::Inversion::Unknown: tmp="AUTO"; break;
-       }
-       PutToDict(dict, "inversion", tmp);
-       switch (feparm.fec_inner)
-       {
-       case eDVBFrontendParametersCable::FEC::fNone: tmp="NONE"; break;
-       case eDVBFrontendParametersCable::FEC::f1_2: tmp="1/2"; break;
-       case eDVBFrontendParametersCable::FEC::f2_3: tmp="2/3"; break;
-       case eDVBFrontendParametersCable::FEC::f3_4: tmp="3/4"; break;
-       case eDVBFrontendParametersCable::FEC::f5_6: tmp="5/6"; break;
-       case eDVBFrontendParametersCable::FEC::f7_8: tmp="7/8"; break;
-       case eDVBFrontendParametersCable::FEC::f8_9: tmp="8/9"; break;
-       default:
-       case eDVBFrontendParametersCable::FEC::fAuto: tmp="AUTO"; break;
-       }
-       PutToDict(dict, "fec inner", tmp);
-}
+extern void PutToDict(ePyObject &dict, const char*key, long value);  // defined in dvb/frontend.cpp
+extern void PutSatelliteDataToDict(ePyObject &dict, eDVBFrontendParametersSatellite &feparm); // defined in dvb/frontend.cpp
+extern void PutTerrestrialDataToDict(ePyObject &dict, eDVBFrontendParametersTerrestrial &feparm); // defined in dvb/frontend.cpp
+extern void PutCableDataToDict(ePyObject &dict, eDVBFrontendParametersCable &feparm); // defined in dvb/frontend.cpp

 
 PyObject *eStaticServiceDVBInformation::getInfoObject(const eServiceReference &r, int what)
 {
 
 PyObject *eStaticServiceDVBInformation::getInfoObject(const eServiceReference &r, int what)
 {


@@ -402,7 +199,7 @@ RESULT eStaticServiceDVBBouquetInformation::getName(const eServiceReference &ref
                return -1;
 }
 
                return -1;
 }
 

-int eStaticServiceDVBBouquetInformation::isPlayable(const eServiceReference &ref, const eServiceReference &ignore)
+int eStaticServiceDVBBouquetInformation::isPlayable(const eServiceReference &ref, const eServiceReference &ignore, bool simulate)

 {
        if (ref.flags & eServiceReference::isGroup)
        {
 {
        if (ref.flags & eServiceReference::isGroup)
        {


@@ -428,13 +225,38 @@ int eStaticServiceDVBBouquetInformation::isPlayable(const eServiceReference &ref
                        return 0;
                }
 
                        return 0;
                }
 

+               int prio_order = eDVBFrontend::getTypePriorityOrder();

                int cur=0;
                eDVBChannelID chid, chid_ignore;
                ((const eServiceReferenceDVB&)ignore).getChannelID(chid_ignore);
                for (std::list<eServiceReference>::iterator it(bouquet->m_services.begin()); it != bouquet->m_services.end(); ++it)
                {
                int cur=0;
                eDVBChannelID chid, chid_ignore;
                ((const eServiceReferenceDVB&)ignore).getChannelID(chid_ignore);
                for (std::list<eServiceReference>::iterator it(bouquet->m_services.begin()); it != bouquet->m_services.end(); ++it)
                {

+                       static unsigned char prio_map[6][3] = {
+                               { 3, 2, 1 }, // -S -C -T
+                               { 3, 1, 2 }, // -S -T -C
+                               { 2, 3, 1 }, // -C -S -T
+                               { 1, 3, 2 }, // -C -T -S
+                               { 1, 2, 3 }, // -T -C -S
+                               { 2, 1, 3 }  // -T -S -C
+                       };

                        ((const eServiceReferenceDVB&)*it).getChannelID(chid);
                        ((const eServiceReferenceDVB&)*it).getChannelID(chid);

-                       int tmp=res->canAllocateChannel(chid, chid_ignore);
+                       int tmp=res->canAllocateChannel(chid, chid_ignore, simulate);
+                       switch(tmp)
+                       {
+                               case 0:
+                                       break;
+                               case 30000: // cached DVB-T channel
+                               case 1: // DVB-T frontend
+                                       tmp = prio_map[prio_order][2];
+                                       break;
+                               case 40000: // cached DVB-C channel
+                               case 2:
+                                       tmp = prio_map[prio_order][1];
+                                       break;
+                               default: // DVB-S
+                                       tmp = prio_map[prio_order][0];
+                                       break;
+                       }

                        if (tmp > cur)
                        {
                                m_playable_service = *it;
                        if (tmp > cur)
                        {
                                m_playable_service = *it;


@@ -473,6 +295,7 @@ public:
        int isPlayable(const eServiceReference &ref, const eServiceReference &ignore) { return 1; }
        int getInfo(const eServiceReference &ref, int w);
        std::string getInfoString(const eServiceReference &ref,int w);
        int isPlayable(const eServiceReference &ref, const eServiceReference &ignore) { return 1; }
        int getInfo(const eServiceReference &ref, int w);
        std::string getInfoString(const eServiceReference &ref,int w);

+       PyObject *getInfoObject(const eServiceReference &r, int what);

 };
 
 DEFINE_REF(eStaticServiceDVBPVRInformation);
 };
 
 DEFINE_REF(eStaticServiceDVBPVRInformation);


@@ -504,14 +327,29 @@ int eStaticServiceDVBPVRInformation::getLength(const eServiceReference &ref)
        
        eDVBTSTools tstools;
        
        
        eDVBTSTools tstools;
        

+       struct stat s;
+       stat(ref.path.c_str(), &s);
+
+       if (tstools.openFile(ref.path.c_str(), 1))
+               return 0;
+
+                       /* check if cached data is still valid */
+       if (m_parser.m_data_ok && (s.st_size == m_parser.m_filesize) && (m_parser.m_length))
+               return m_parser.m_length / 90000;
+
+                       /* open again, this time with stream info */

        if (tstools.openFile(ref.path.c_str()))
                return 0;
 
        if (tstools.openFile(ref.path.c_str()))
                return 0;
 

+                       /* otherwise, re-calc length and update meta file */

        pts_t len;
        if (tstools.calcLen(len))
                return 0;
 
        pts_t len;
        if (tstools.calcLen(len))
                return 0;
 

-       return len / 90000;
+       m_parser.m_length = len;
+       m_parser.m_filesize = s.st_size;
+       m_parser.updateMeta(ref.path);
+       return m_parser.m_length / 90000;

 }
 
 int eStaticServiceDVBPVRInformation::getInfo(const eServiceReference &ref, int w)
 }
 
 int eStaticServiceDVBPVRInformation::getInfo(const eServiceReference &ref, int w)


@@ -522,6 +360,8 @@ int eStaticServiceDVBPVRInformation::getInfo(const eServiceReference &ref, int w
                return iServiceInformation::resIsString;
        case iServiceInformation::sServiceref:
                return iServiceInformation::resIsString;
                return iServiceInformation::resIsString;
        case iServiceInformation::sServiceref:
                return iServiceInformation::resIsString;

+       case iServiceInformation::sFileSize:
+               return m_parser.m_filesize;

        case iServiceInformation::sTimeCreate:
                if (m_parser.m_time_create)
                        return m_parser.m_time_create;
        case iServiceInformation::sTimeCreate:
                if (m_parser.m_time_create)
                        return m_parser.m_time_create;


@@ -547,6 +387,17 @@ std::string eStaticServiceDVBPVRInformation::getInfoString(const eServiceReferen
        }
 }
 
        }
 }
 

+PyObject *eStaticServiceDVBPVRInformation::getInfoObject(const eServiceReference &r, int what)
+{
+       switch (what)
+       {
+       case iServiceInformation::sFileSize:
+               return PyLong_FromLongLong(m_parser.m_filesize);
+       default:
+               Py_RETURN_NONE;
+       }
+}
+

 RESULT eStaticServiceDVBPVRInformation::getEvent(const eServiceReference &ref, ePtr<eServiceEvent> &evt, time_t start_time)
 {
        if (!ref.path.empty())
 RESULT eStaticServiceDVBPVRInformation::getEvent(const eServiceReference &ref, ePtr<eServiceEvent> &evt, time_t start_time)
 {
        if (!ref.path.empty())


@@ -574,6 +425,7 @@ public:
        
        RESULT deleteFromDisk(int simulate);
        RESULT getListOfFilenames(std::list<std::string> &);
        
        RESULT deleteFromDisk(int simulate);
        RESULT getListOfFilenames(std::list<std::string> &);

+       RESULT reindex();

 };
 
 DEFINE_REF(eDVBPVRServiceOfflineOperations);
 };
 
 DEFINE_REF(eDVBPVRServiceOfflineOperations);


@@ -628,6 +480,7 @@ RESULT eDVBPVRServiceOfflineOperations::getListOfFilenames(std::list<std::string
 
        res.push_back(m_ref.path + ".meta");
        res.push_back(m_ref.path + ".ap");
 
        res.push_back(m_ref.path + ".meta");
        res.push_back(m_ref.path + ".ap");

+       res.push_back(m_ref.path + ".sc");

        res.push_back(m_ref.path + ".cuts");
        std::string tmp = m_ref.path;
        tmp.erase(m_ref.path.length()-3);
        res.push_back(m_ref.path + ".cuts");
        std::string tmp = m_ref.path;
        tmp.erase(m_ref.path.length()-3);


@@ -635,6 +488,42 @@ RESULT eDVBPVRServiceOfflineOperations::getListOfFilenames(std::list<std::string
        return 0;
 }
 
        return 0;
 }
 

+RESULT eDVBPVRServiceOfflineOperations::reindex()
+{
+       const char *filename = m_ref.path.c_str();
+       eDebug("reindexing %s...", filename);
+
+       eMPEGStreamInformation info;
+       eMPEGStreamParserTS parser(info);
+       
+       info.startSave(filename);
+       
+       eRawFile f;
+       
+       int err = f.open(m_ref.path.c_str(), 0);
+       if (err < 0)
+               return -1;
+       
+       off_t length = f.length();
+       unsigned char buffer[188*256*4];
+       while (1)
+       {
+               off_t offset = f.lseek(0, SEEK_CUR);
+               eDebug("at %08llx / %08llx (%d %%)", offset, length, (int)(offset * 100 / length));
+               int r = f.read(buffer, sizeof(buffer));
+               if (!r)
+                       break;
+               if (r < 0)
+                       return r;
+               parser.parseData(offset, buffer, r);
+       }
+       
+       info.stopSave();
+       f.close();
+       
+       return 0;
+}
+

 DEFINE_REF(eServiceFactoryDVB)
 
 eServiceFactoryDVB::eServiceFactoryDVB()
 DEFINE_REF(eServiceFactoryDVB)
 
 eServiceFactoryDVB::eServiceFactoryDVB()


@@ -643,7 +532,12 @@ eServiceFactoryDVB::eServiceFactoryDVB()
        
        eServiceCenter::getPrivInstance(sc);
        if (sc)
        
        eServiceCenter::getPrivInstance(sc);
        if (sc)

-               sc->addServiceFactory(eServiceFactoryDVB::id, this);
+       {
+               std::list<std::string> extensions;
+               extensions.push_back("ts");
+               extensions.push_back("trp");
+               sc->addServiceFactory(eServiceFactoryDVB::id, this, extensions);
+       }

 
        m_StaticServiceDVBInfo = new eStaticServiceDVBInformation;
        m_StaticServiceDVBBouquetInfo = new eStaticServiceDVBBouquetInformation;
 
        m_StaticServiceDVBInfo = new eStaticServiceDVBInformation;
        m_StaticServiceDVBBouquetInfo = new eStaticServiceDVBBouquetInformation;


@@ -784,7 +678,7 @@ PyObject *eDVBServiceList::getContent(const char* format, bool sorted)
                                                        sptr->getName(ref, name);
 
                                                        // filter short name brakets
                                                        sptr->getName(ref, name);
 
                                                        // filter short name brakets

-                                                       unsigned int pos;
+                                                       size_t pos;

                                                        while((pos = name.find("\xc2\x86")) != std::string::npos)
                                                                name.erase(pos,2);
                                                        while((pos = name.find("\xc2\x87")) != std::string::npos)
                                                        while((pos = name.find("\xc2\x86")) != std::string::npos)
                                                                name.erase(pos,2);
                                                        while((pos = name.find("\xc2\x87")) != std::string::npos)


@@ -976,30 +870,41 @@ RESULT eServiceFactoryDVB::offlineOperations(const eServiceReference &ref, ePtr<
 
 RESULT eServiceFactoryDVB::lookupService(ePtr<eDVBService> &service, const eServiceReference &ref)
 {
 
 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)
+       if (!ref.path.empty()) // playback

        {
        {

-               eDebug("no resource manager");
-               return err;
+               eDVBMetaParser parser;
+               int ret=parser.parseFile(ref.path);
+               service = new eDVBService;
+               if (!ret)
+                       eDVBDB::getInstance()->parseServiceData(service, parser.m_service_data);

        }
        }

-       if ((err = res->getChannelList(db)) != 0)
+       else

        {
        {

-               eDebug("no channel list");
-               return err;
-       }
+                       // 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. */
        
                /* 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;
+               if ((err = db->getService((eServiceReferenceDVB&)ref, service)) != 0)
+               {
+                       eDebug("getService failed!");
+                       return err;
+               }

        }
 
        return 0;
        }
 
        return 0;


@@ -1008,12 +913,11 @@ RESULT eServiceFactoryDVB::lookupService(ePtr<eDVBService> &service, const eServ
 eDVBServicePlay::eDVBServicePlay(const eServiceReference &ref, eDVBService *service): 
        m_reference(ref), m_dvb_service(service), m_have_video_pid(0), m_is_paused(0)
 {
 eDVBServicePlay::eDVBServicePlay(const eServiceReference &ref, eDVBService *service): 
        m_reference(ref), m_dvb_service(service), m_have_video_pid(0), m_is_paused(0)
 {

-       memset(&m_videoEventData, 0, sizeof(struct iTSMPEGDecoder::videoEvent));

        m_is_primary = 1;
        m_is_pvr = !m_reference.path.empty();
        
        m_is_primary = 1;
        m_is_pvr = !m_reference.path.empty();
        

-       m_timeshift_enabled = m_timeshift_active = 0;
-       m_skipmode = 0;
+       m_timeshift_enabled = m_timeshift_active = 0, m_timeshift_changed = 0;
+       m_skipmode = m_fastforward = m_slowmotion = 0;

        
        CONNECT(m_service_handler.serviceEvent, eDVBServicePlay::serviceEvent);
        CONNECT(m_service_handler_timeshift.serviceEvent, eDVBServicePlay::serviceEventTimeshift);
        
        CONNECT(m_service_handler.serviceEvent, eDVBServicePlay::serviceEvent);
        CONNECT(m_service_handler_timeshift.serviceEvent, eDVBServicePlay::serviceEventTimeshift);


@@ -1025,12 +929,37 @@ eDVBServicePlay::eDVBServicePlay(const eServiceReference &ref, eDVBService *serv
        m_subtitle_widget = 0;
        
        m_tune_state = -1;
        m_subtitle_widget = 0;
        
        m_tune_state = -1;

-       
-       CONNECT(m_subtitle_sync_timer.timeout, eDVBServicePlay::checkSubtitleTiming);
+
+       m_subtitle_sync_timer = eTimer::create(eApp);
+
+       CONNECT(m_subtitle_sync_timer->timeout, eDVBServicePlay::checkSubtitleTiming);

 }
 
 eDVBServicePlay::~eDVBServicePlay()
 {
 }
 
 eDVBServicePlay::~eDVBServicePlay()
 {

+       if (m_is_pvr)
+       {
+               eDVBMetaParser meta;
+               int ret=meta.parseFile(m_reference.path);
+               if (!ret)
+               {
+                       char tmp[255];
+                       meta.m_service_data="";
+                       sprintf(tmp, "f:%x", m_dvb_service->m_flags);
+                       meta.m_service_data += tmp;
+                       // cached pids
+                       for (int x=0; x < eDVBService::cacheMax; ++x)
+                       {
+                               int entry = m_dvb_service->getCacheEntry((eDVBService::cacheID)x);
+                               if (entry != -1)
+                               {
+                                       sprintf(tmp, ",c:%02d%04x", x, entry);
+                                       meta.m_service_data += tmp;
+                               }
+                       }
+                       meta.updateMeta(m_reference.path);
+               }
+       }

        delete m_subtitle_widget;
 }
 
        delete m_subtitle_widget;
 }
 


@@ -1071,6 +1000,7 @@ void eDVBServicePlay::serviceEvent(int event)
                        else
                                m_event_handler.start(m_demux, sid);
                }
                        else
                                m_event_handler.start(m_demux, sid);
                }

+               m_event((iPlayableService*)this, evTunedIn);

                break;
        }
        case eDVBServicePMTHandler::eventNoResources:
                break;
        }
        case eDVBServicePMTHandler::eventNoResources:


@@ -1078,6 +1008,7 @@ void eDVBServicePlay::serviceEvent(int event)
        case eDVBServicePMTHandler::eventNoPATEntry:
        case eDVBServicePMTHandler::eventNoPMT:
        case eDVBServicePMTHandler::eventTuneFailed:
        case eDVBServicePMTHandler::eventNoPATEntry:
        case eDVBServicePMTHandler::eventNoPMT:
        case eDVBServicePMTHandler::eventTuneFailed:

+       case eDVBServicePMTHandler::eventMisconfiguration:

        {
                eDebug("DVB service failed to tune - error %d", event);
                m_event((iPlayableService*)this, evTuneFailed);
        {
                eDebug("DVB service failed to tune - error %d", event);
                m_event((iPlayableService*)this, evTuneFailed);


@@ -1120,29 +1051,40 @@ void eDVBServicePlay::serviceEventTimeshift(int event)
                break;
        case eDVBServicePMTHandler::eventEOF:
                if ((!m_is_paused) && (m_skipmode >= 0))
                break;
        case eDVBServicePMTHandler::eventEOF:
                if ((!m_is_paused) && (m_skipmode >= 0))

+               {
+                       eDebug("timeshift EOF, so let's go live");

                        switchToLive();
                        switchToLive();

+               }

                break;
        }
 }
 
 RESULT eDVBServicePlay::start()
 {
                break;
        }
 }
 
 RESULT eDVBServicePlay::start()
 {

-       int r;
+       eServiceReferenceDVB service = (eServiceReferenceDVB&)m_reference;
+

                /* in pvr mode, we only want to use one demux. in tv mode, we're using 
                   two (one for decoding, one for data source), as we must be prepared
                   to start recording from the data demux. */
        if (m_is_pvr)
                /* in pvr mode, we only want to use one demux. in tv mode, we're using 
                   two (one for decoding, one for data source), as we must be prepared
                   to start recording from the data demux. */
        if (m_is_pvr)

+       {
+               eDVBMetaParser meta;
+               if (!meta.parseFile(m_reference.path))
+               {
+                       service = meta.m_ref;
+                       service.path = m_reference.path;
+               }

                m_cue = new eCueSheet();
                m_cue = new eCueSheet();

+       }

        else
                m_event(this, evStart);
 
        m_first_program_info = 1;
        else
                m_event(this, evStart);
 
        m_first_program_info = 1;

-       eServiceReferenceDVB &service = (eServiceReferenceDVB&)m_reference;
-       r = m_service_handler.tune(service, m_is_pvr, m_cue);
+       m_service_handler.tune(service, m_is_pvr, m_cue, false, m_dvb_service);

 
 

-               /* inject EIT if there is a stored one */

        if (m_is_pvr)
        {
        if (m_is_pvr)
        {

+               /* inject EIT if there is a stored one */

                std::string filename = service.path;
                filename.erase(filename.length()-2, 2);
                filename+="eit";
                std::string filename = service.path;
                filename.erase(filename.length()-2, 2);
                filename+="eit";


@@ -1153,10 +1095,6 @@ RESULT eDVBServicePlay::start()
                        m_event_handler.inject(event, 0);
                        m_event_handler.inject(empty, 1);
                }
                        m_event_handler.inject(event, 0);
                        m_event_handler.inject(empty, 1);
                }

-       }
-
-       if (m_is_pvr)
-       {

                loadCuesheet();
                m_event(this, evStart);
        }
                loadCuesheet();
                m_event(this, evStart);
        }


@@ -1190,8 +1128,8 @@ RESULT eDVBServicePlay::stop()
                        {
                                int perc = play_position * 100LL / length;
                        
                        {
                                int perc = play_position * 100LL / length;
                        

-                                       /* only store last play position when between 5% and 95% */
-                               if ((5 < perc) && (perc < 95))
+                                       /* only store last play position when between 1% and 99% */
+                               if ((1 < perc) && (perc < 99))

                                        m_cue_entries.insert(cueEntry(play_position, 3)); /* last play position */
                        }
                        m_cuesheet_changed = 1;
                                        m_cue_entries.insert(cueEntry(play_position, 3)); /* last play position */
                        }
                        m_cuesheet_changed = 1;


@@ -1243,16 +1181,30 @@ RESULT eDVBServicePlay::pause(ePtr<iPauseableService> &ptr)
 
 RESULT eDVBServicePlay::setSlowMotion(int ratio)
 {
 
 RESULT eDVBServicePlay::setSlowMotion(int ratio)
 {

+       ASSERT(ratio); /* The API changed: instead of calling setSlowMotion(0), call play! */
+       eDebug("eDVBServicePlay::setSlowMotion(%d)", ratio);
+       setFastForward_internal(0);

        if (m_decoder)
        if (m_decoder)

+       {
+               m_slowmotion = ratio;

                return m_decoder->setSlowMotion(ratio);
                return m_decoder->setSlowMotion(ratio);

+       }

        else
                return -1;
 }
 
 RESULT eDVBServicePlay::setFastForward(int ratio)
 {
        else
                return -1;
 }
 
 RESULT eDVBServicePlay::setFastForward(int ratio)
 {

-       int skipmode, ffratio;
-       
+       eDebug("eDVBServicePlay::setFastForward(%d)", ratio);
+       ASSERT(ratio);
+       return setFastForward_internal(ratio);
+}
+
+RESULT eDVBServicePlay::setFastForward_internal(int ratio, bool final_seek)
+{
+       int skipmode, ffratio, ret = 0;
+       pts_t pos=0;
+

        if (ratio > 8)
        {
                skipmode = ratio;
        if (ratio > 8)
        {
                skipmode = ratio;


@@ -1277,13 +1229,28 @@ RESULT eDVBServicePlay::setFastForward(int ratio)
                if (m_cue)
                        m_cue->setSkipmode(skipmode * 90000); /* convert to 90000 per second */
        }
                if (m_cue)
                        m_cue->setSkipmode(skipmode * 90000); /* convert to 90000 per second */
        }

-       
+

        m_skipmode = skipmode;
        m_skipmode = skipmode;

-       
+
+       if (final_seek)
+               eDebug("trickplay stopped .. ret %d, pos %lld", getPlayPosition(pos), pos);
+
+       m_fastforward = ffratio;
+

        if (!m_decoder)
                return -1;
 
        if (!m_decoder)
                return -1;
 

-       return m_decoder->setFastForward(ffratio);
+       if (ffratio == 0)
+               ; /* return m_decoder->play(); is done in caller*/
+       else if (ffratio != 1)
+               ret = m_decoder->setFastForward(ffratio);
+       else
+               ret = m_decoder->setTrickmode();
+
+       if (pos)
+               eDebug("final seek after trickplay ret %d", seekTo(pos));
+
+       return ret;

 }
 
 RESULT eDVBServicePlay::seek(ePtr<iSeekableService> &ptr)
 }
 
 RESULT eDVBServicePlay::seek(ePtr<iSeekableService> &ptr)


@@ -1311,20 +1278,26 @@ RESULT eDVBServicePlay::getLength(pts_t &len)
 
 RESULT eDVBServicePlay::pause()
 {
 
 RESULT eDVBServicePlay::pause()
 {

-       if (!m_is_paused && m_decoder)
+       eDebug("eDVBServicePlay::pause");
+       setFastForward_internal(0, m_slowmotion || m_fastforward > 1);
+       if (m_decoder)

        {
        {

+               m_slowmotion = 0;

                m_is_paused = 1;
                m_is_paused = 1;

-               return m_decoder->freeze(0);
+               return m_decoder->pause();

        } else
                return -1;
 }
 
 RESULT eDVBServicePlay::unpause()
 {
        } else
                return -1;
 }
 
 RESULT eDVBServicePlay::unpause()
 {

-       if (m_is_paused && m_decoder)
+       eDebug("eDVBServicePlay::unpause");
+       setFastForward_internal(0, m_slowmotion || m_fastforward > 1);
+       if (m_decoder)

        {
        {

+               m_slowmotion = 0;

                m_is_paused = 0;
                m_is_paused = 0;

-               return m_decoder->unfreeze();
+               return m_decoder->play();

        } else
                return -1;
 }
        } else
                return -1;
 }


@@ -1345,6 +1318,9 @@ RESULT eDVBServicePlay::seekTo(pts_t to)
                return -1;
        
        m_cue->seekTo(0, to);
                return -1;
        
        m_cue->seekTo(0, to);

+       m_dvb_subtitle_pages.clear();
+       m_subtitle_pages.clear();
+

        return 0;
 }
 
        return 0;
 }
 


@@ -1372,6 +1348,8 @@ RESULT eDVBServicePlay::seekRelative(int direction, pts_t to)
                return 0;
        
        m_cue->seekTo(mode, to);
                return 0;
        
        m_cue->seekTo(mode, to);

+       m_dvb_subtitle_pages.clear();
+       m_subtitle_pages.clear();

        return 0;
 }
 
        return 0;
 }
 


@@ -1401,9 +1379,8 @@ RESULT eDVBServicePlay::getPlayPosition(pts_t &pos)
 
 RESULT eDVBServicePlay::setTrickmode(int trick)
 {
 
 RESULT eDVBServicePlay::setTrickmode(int trick)
 {

-       if (m_decoder)
-               m_decoder->setTrickmode(trick);
-       return 0;
+               /* currently unimplemented */
+       return -1;

 }
 
 RESULT eDVBServicePlay::isCurrentlySeekable()
 }
 
 RESULT eDVBServicePlay::isCurrentlySeekable()


@@ -1449,9 +1426,16 @@ RESULT eDVBServicePlay::timeshift(ePtr<iTimeshiftService> &ptr)
        {
                if (!m_timeshift_enabled)
                {
        {
                if (!m_timeshift_enabled)
                {

-                               /* we need enough diskspace */
+                       /* query config path */
+                       std::string tspath;
+                       if(ePythonConfigQuery::getConfigValue("config.usage.timeshift_path", tspath) == -1){
+                               eDebug("could not query ts path from config");
+                               return -4;
+                       }
+                       tspath.append("/");
+                       /* we need enough diskspace */

                        struct statfs fs;
                        struct statfs fs;

-                       if (statfs(TSPATH "/.", &fs) < 0)
+                       if (statfs(tspath.c_str(), &fs) < 0)

                        {
                                eDebug("statfs failed!");
                                return -2;
                        {
                                eDebug("statfs failed!");
                                return -2;


@@ -1505,7 +1489,7 @@ RESULT eDVBServicePlay::getName(std::string &name)
                ePtr<iStaticServiceInformation> i = new eStaticServiceDVBPVRInformation(m_reference);
                return i->getName(m_reference, name);
        }
                ePtr<iStaticServiceInformation> i = new eStaticServiceDVBPVRInformation(m_reference);
                return i->getName(m_reference, name);
        }

-       if (m_dvb_service)
+       else if (m_dvb_service)

        {
                m_dvb_service->getName(m_reference, name);
                if (name.empty())
        {
                m_dvb_service->getName(m_reference, name);
                if (name.empty())


@@ -1526,42 +1510,43 @@ RESULT eDVBServicePlay::getEvent(ePtr<eServiceEvent> &evt, int nownext)
 int eDVBServicePlay::getInfo(int w)
 {
        eDVBServicePMTHandler::program program;
 int eDVBServicePlay::getInfo(int w)
 {
        eDVBServicePMTHandler::program program;

-       
+

        if (w == sCAIDs)
                return resIsPyObject;
 
        eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
        if (w == sCAIDs)
                return resIsPyObject;
 
        eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;

-       
+

        int no_program_info = 0;
        int no_program_info = 0;

-       
+

        if (h.getProgramInfo(program))
                no_program_info = 1;
        if (h.getProgramInfo(program))
                no_program_info = 1;

-       
+

        switch (w)
        {
        switch (w)
        {

-#if HAVE_DVB_API_VERSION >= 3

        case sVideoHeight:
        case sVideoHeight:

-               if (m_videoEventData.type != iTSMPEGDecoder::videoEvent::eventUnknown)
-                       return m_videoEventData.height;
-               return -1;
+               if (m_decoder)
+                       return m_decoder->getVideoHeight();
+               break;

        case sVideoWidth:
        case sVideoWidth:

-               if (m_videoEventData.type != iTSMPEGDecoder::videoEvent::eventUnknown)
-                       return m_videoEventData.width;
-               return -1;
-#else
-#warning "FIXMEE implement sVideoHeight, sVideoWidth for old DVB API"
-#endif
+               if (m_decoder)
+                       return m_decoder->getVideoWidth();
+               break;
+       case sFrameRate:
+               if (m_decoder)
+                       return m_decoder->getVideoFrameRate();
+               break;
+       case sProgressive:
+               if (m_decoder)
+                       return m_decoder->getVideoProgressive();
+               break;

        case sAspect:
        case sAspect:

-#if HAVE_DVB_API_VERSION >= 3
-               if (m_videoEventData.type != iTSMPEGDecoder::videoEvent::eventUnknown)
-                       return m_videoEventData.aspect == VIDEO_FORMAT_4_3 ? 1 : 3;
-               else
-#else
-#warning "FIXMEE implement sAspect for old DVB API"
-#endif
-               if (no_program_info)
-                       return -1; 
-               else if (!program.videoStreams.empty() && program.videoStreams[0].component_tag != -1)
+       {
+               int aspect = -1;
+               if (m_decoder)
+                       aspect = m_decoder->getVideoAspect();
+               if (aspect == -1 && no_program_info)
+                       break;
+               else if (aspect == -1 && !program.videoStreams.empty() && program.videoStreams[0].component_tag != -1)

                {
                        ePtr<eServiceEvent> evt;
                        if (!m_event_handler.getEvent(evt, 0))
                {
                        ePtr<eServiceEvent> evt;
                        if (!m_event_handler.getEvent(evt, 0))


@@ -1598,12 +1583,39 @@ int eDVBServicePlay::getInfo(int w)
                                }
                        }
                }
                                }
                        }
                }

-               return -1;
+               else
+                       return aspect;
+               break;
+       }

        case sIsCrypted: if (no_program_info) return -1; return program.isCrypted();
        case sIsCrypted: if (no_program_info) return -1; return program.isCrypted();

-       case sVideoPID: if (no_program_info) return -1; if (program.videoStreams.empty()) return -1; return program.videoStreams[0].pid;
+       case sVideoPID:
+               if (m_dvb_service)
+               {
+                       int vpid = m_dvb_service->getCacheEntry(eDVBService::cVPID);
+                       if (vpid != -1)
+                               return vpid;
+               }
+               if (no_program_info) return -1; if (program.videoStreams.empty()) return -1; return program.videoStreams[0].pid;

        case sVideoType: if (no_program_info) return -1; if (program.videoStreams.empty()) return -1; return program.videoStreams[0].type;
        case sVideoType: if (no_program_info) return -1; if (program.videoStreams.empty()) return -1; return program.videoStreams[0].type;

-       case sAudioPID: if (no_program_info) return -1; if (program.audioStreams.empty()) return -1; return program.audioStreams[0].pid;
-       case sPCRPID: if (no_program_info) return -1; return program.pcrPid;
+       case sAudioPID:
+               if (m_dvb_service)
+               {
+                       int apid = m_dvb_service->getCacheEntry(eDVBService::cAPID);
+                       if (apid != -1)
+                               return apid;
+                       apid = m_dvb_service->getCacheEntry(eDVBService::cAC3PID);
+                       if (apid != -1)
+                               return apid;
+               }
+               if (no_program_info) return -1; if (program.audioStreams.empty()) return -1; return program.audioStreams[0].pid;
+       case sPCRPID:
+               if (m_dvb_service)
+               {
+                       int pcrpid = m_dvb_service->getCacheEntry(eDVBService::cPCRPID);
+                       if (pcrpid != -1)
+                               return pcrpid;
+               }
+               if (no_program_info) return -1; return program.pcrPid;

        case sPMTPID: if (no_program_info) return -1; return program.pmtPid;
        case sTXTPID: if (no_program_info) return -1; return program.textPid;
        case sSID: return ((const eServiceReferenceDVB&)m_reference).getServiceID().get();
        case sPMTPID: if (no_program_info) return -1; return program.pmtPid;
        case sTXTPID: if (no_program_info) return -1; return program.textPid;
        case sSID: return ((const eServiceReferenceDVB&)m_reference).getServiceID().get();


@@ -1614,8 +1626,9 @@ int eDVBServicePlay::getInfo(int w)
        case sServiceref: return resIsString;
        case sDVBState: return m_tune_state;
        default:
        case sServiceref: return resIsString;
        case sDVBState: return m_tune_state;
        default:

-               return -1;
+               break;

        }
        }

+       return -1;

 }
 
 std::string eDVBServicePlay::getInfoString(int w)
 }
 
 std::string eDVBServicePlay::getInfoString(int w)


@@ -1677,7 +1690,7 @@ RESULT eDVBServicePlay::selectTrack(unsigned int i)
 {
        int ret = selectAudioStream(i);
 
 {
        int ret = selectAudioStream(i);
 

-       if (m_decoder->start())
+       if (m_decoder->set())

                return -5;
 
        return ret;
                return -5;
 
        return ret;


@@ -1702,6 +1715,8 @@ RESULT eDVBServicePlay::getTrackInfo(struct iAudioTrackInfo &info, unsigned int
                info.m_description = "AC3";
        else if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atAAC)
                info.m_description = "AAC";
                info.m_description = "AC3";
        else if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atAAC)
                info.m_description = "AAC";

+       else if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atAACHE)
+               info.m_description = "AAC-HE";

        else  if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atDTS)
                info.m_description = "DTS";
        else
        else  if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atDTS)
                info.m_description = "DTS";
        else


@@ -1728,6 +1743,7 @@ int eDVBServicePlay::selectAudioStream(int i)
 {
        eDVBServicePMTHandler::program program;
        eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
 {
        eDVBServicePMTHandler::program program;
        eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;

+       pts_t position = -1;

 
        if (h.getProgramInfo(program))
                return -1;
 
        if (h.getProgramInfo(program))
                return -1;


@@ -1750,29 +1766,40 @@ int eDVBServicePlay::selectAudioStream(int i)
                apidtype = program.audioStreams[stream].type;
        }
 
                apidtype = program.audioStreams[stream].type;
        }
 

+       if (i != -1 && apid != m_current_audio_pid && (m_is_pvr || m_timeshift_active))
+               eDebug("getPlayPosition ret %d, pos %lld in selectAudioStream", getPlayPosition(position), position);
+

        m_current_audio_pid = apid;
 
        m_current_audio_pid = apid;
 

-       if (m_decoder->setAudioPID(apid, apidtype))
+       if (m_is_primary && m_decoder->setAudioPID(apid, apidtype))

        {
                eDebug("set audio pid failed");
                return -4;
        }
 
        {
                eDebug("set audio pid failed");
                return -4;
        }
 

+       if (position != -1)
+               eDebug("seekTo ret %d", seekTo(position));
+
+       int rdsPid = apid;
+

                /* if we are not in PVR mode, timeshift is not active and we are not in pip mode, check if we need to enable the rds reader */
        if (!(m_is_pvr || m_timeshift_active || !m_is_primary))
                /* if we are not in PVR mode, timeshift is not active and we are not in pip mode, check if we need to enable the rds reader */
        if (!(m_is_pvr || m_timeshift_active || !m_is_primary))

-               if (!m_rds_decoder)
+       {
+               int different_pid = program.videoStreams.empty() && program.audioStreams.size() == 1 && program.audioStreams[stream].rdsPid != -1;
+               if (different_pid)
+                       rdsPid = program.audioStreams[stream].rdsPid;
+               if (!m_rds_decoder || m_rds_decoder->getPid() != rdsPid)

                {
                {

+                       m_rds_decoder = 0;

                        ePtr<iDVBDemux> data_demux;
                        if (!h.getDataDemux(data_demux))
                        {
                        ePtr<iDVBDemux> data_demux;
                        if (!h.getDataDemux(data_demux))
                        {

-                               m_rds_decoder = new eDVBRdsDecoder(data_demux);
+                               m_rds_decoder = new eDVBRdsDecoder(data_demux, different_pid);

                                m_rds_decoder->connectEvent(slot(*this, &eDVBServicePlay::rdsDecoderEvent), m_rds_decoder_event_connection);
                                m_rds_decoder->connectEvent(slot(*this, &eDVBServicePlay::rdsDecoderEvent), m_rds_decoder_event_connection);

+                               m_rds_decoder->start(rdsPid);

                        }
                }
                        }
                }

-
-               /* if we decided that we need one, update the pid */
-       if (m_rds_decoder)
-               m_rds_decoder->start(apid);
+       }

 
                        /* store new pid as default only when:
                                a.) we have an entry in the service db for the current service,
 
                        /* store new pid as default only when:
                                a.) we have an entry in the service db for the current service,


@@ -1781,18 +1808,24 @@ int eDVBServicePlay::selectAudioStream(int i)
                                    anything in the best case, or destroy the default setting in
                                    case the real default is not yet available.)
                        */
                                    anything in the best case, or destroy the default setting in
                                    case the real default is not yet available.)
                        */

-       if (m_dvb_service && !m_is_pvr && (i != -1))
+       if (m_dvb_service && ((i != -1)
+               || ((m_dvb_service->getCacheEntry(eDVBService::cAPID) == -1) && (m_dvb_service->getCacheEntry(eDVBService::cAC3PID)==-1))))

        {
                if (apidtype == eDVBAudio::aMPEG)
                {
                        m_dvb_service->setCacheEntry(eDVBService::cAPID, apid);
                        m_dvb_service->setCacheEntry(eDVBService::cAC3PID, -1);
                }
        {
                if (apidtype == eDVBAudio::aMPEG)
                {
                        m_dvb_service->setCacheEntry(eDVBService::cAPID, apid);
                        m_dvb_service->setCacheEntry(eDVBService::cAC3PID, -1);
                }

-               else
+               else if (apidtype == eDVBAudio::aAC3)

                {
                        m_dvb_service->setCacheEntry(eDVBService::cAPID, -1);
                        m_dvb_service->setCacheEntry(eDVBService::cAC3PID, apid);
                }
                {
                        m_dvb_service->setCacheEntry(eDVBService::cAPID, -1);
                        m_dvb_service->setCacheEntry(eDVBService::cAC3PID, apid);
                }

+               else
+               {
+                       m_dvb_service->setCacheEntry(eDVBService::cAPID, -1);
+                       m_dvb_service->setCacheEntry(eDVBService::cAC3PID, -1);
+               }

        }
 
        h.resetCachedProgram();
        }
 
        h.resetCachedProgram();


@@ -1950,31 +1983,7 @@ PyObject *eDVBServiceBase::getTransponderData(bool original)
                {
                        ePtr<iDVBFrontend> fe;
                        if(!channel->getFrontend(fe))
                {
                        ePtr<iDVBFrontend> fe;
                        if(!channel->getFrontend(fe))

-                       {

                                fe->getTransponderData(ret, original);
                                fe->getTransponderData(ret, original);

-                               ePtr<iDVBFrontendParameters> feparm;
-                               channel->getCurrentFrontendParameters(feparm);
-                               if (feparm)
-                               {
-                                       eDVBFrontendParametersSatellite osat;
-                                       if (!feparm->getDVBS(osat))
-                                       {
-                                               void PutToDict(ePyObject &, const char*, long);
-                                               void PutToDict(ePyObject &, const char*, const char*);
-                                               PutToDict(ret, "orbital_position", osat.orbital_position);
-                                               const char *tmp = "UNKNOWN";
-                                               switch(osat.polarisation)
-                                               {
-                                                       case eDVBFrontendParametersSatellite::Polarisation::Horizontal: tmp="HORIZONTAL"; break;
-                                                       case eDVBFrontendParametersSatellite::Polarisation::Vertical: tmp="VERTICAL"; break;
-                                                       case eDVBFrontendParametersSatellite::Polarisation::CircularLeft: tmp="CIRCULAR_LEFT"; break;
-                                                       case eDVBFrontendParametersSatellite::Polarisation::CircularRight: tmp="CIRCULAR_RIGHT"; break;
-                                                       default:break;
-                                               }
-                                               PutToDict(ret, "polarization", tmp);
-                                       }
-                               }
-                       }

                }
        }
        else
                }
        }
        else


@@ -2038,12 +2047,23 @@ RESULT eDVBServicePlay::startTimeshift()
        if (!m_record)
                return -3;
 
        if (!m_record)
                return -3;
 

-       char templ[]=TSPATH "/timeshift.XXXXXX";
+       std::string tspath;
+       if(ePythonConfigQuery::getConfigValue("config.usage.timeshift_path", tspath) == -1){ 
+               eDebug("could not query ts path");
+               return -5;
+       }
+       tspath.append("/timeshift.XXXXXX");
+       char* templ;
+       templ = new char[tspath.length() + 1];
+       strcpy(templ, tspath.c_str());
+

        m_timeshift_fd = mkstemp(templ);
        m_timeshift_fd = mkstemp(templ);

-       m_timeshift_file = templ;
-       
+       m_timeshift_file = std::string(templ);
+

        eDebug("recording to %s", templ);
        eDebug("recording to %s", templ);

-       
+
+       delete [] templ;
+

        if (m_timeshift_fd < 0)
        {
                m_record = 0;
        if (m_timeshift_fd < 0)
        {
                m_record = 0;


@@ -2105,8 +2125,8 @@ PyObject *eDVBServicePlay::getCutList()
        for (std::multiset<struct cueEntry>::iterator i(m_cue_entries.begin()); i != m_cue_entries.end(); ++i)
        {
                ePyObject tuple = PyTuple_New(2);
        for (std::multiset<struct cueEntry>::iterator i(m_cue_entries.begin()); i != m_cue_entries.end(); ++i)
        {
                ePyObject tuple = PyTuple_New(2);

-               PyTuple_SetItem(tuple, 0, PyLong_FromLongLong(i->where));
-               PyTuple_SetItem(tuple, 1, PyInt_FromLong(i->what));
+               PyTuple_SET_ITEM(tuple, 0, PyLong_FromLongLong(i->where));
+               PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(i->what));

                PyList_Append(list, tuple);
                Py_DECREF(tuple);
        }
                PyList_Append(list, tuple);
                Py_DECREF(tuple);
        }


@@ -2219,6 +2239,8 @@ void eDVBServicePlay::switchToLive()
        if (!m_timeshift_active)
                return;
        
        if (!m_timeshift_active)
                return;
        

+       eDebug("SwitchToLive");
+       

        m_cue = 0;
        m_decoder = 0;
        m_decode_demux = 0;
        m_cue = 0;
        m_decoder = 0;
        m_decode_demux = 0;


@@ -2229,10 +2251,12 @@ void eDVBServicePlay::switchToLive()
        m_new_subtitle_page_connection = 0;
        m_rds_decoder_event_connection = 0;
        m_video_event_connection = 0;
        m_new_subtitle_page_connection = 0;
        m_rds_decoder_event_connection = 0;
        m_video_event_connection = 0;

+       m_is_paused = m_skipmode = m_fastforward = m_slowmotion = 0; /* not supported in live mode */

 
                /* free the timeshift service handler, we need the resources */
        m_service_handler_timeshift.free();
        m_timeshift_active = 0;
 
                /* free the timeshift service handler, we need the resources */
        m_service_handler_timeshift.free();
        m_timeshift_active = 0;

+       m_timeshift_changed = 1;

 
        m_event((iPlayableService*)this, evSeekableStatusChanged);
 
 
        m_event((iPlayableService*)this, evSeekableStatusChanged);
 


@@ -2255,17 +2279,19 @@ void eDVBServicePlay::switchToTimeshift()
        m_video_event_connection = 0;
 
        m_timeshift_active = 1;
        m_video_event_connection = 0;
 
        m_timeshift_active = 1;

+       m_timeshift_changed = 1;

 
        eServiceReferenceDVB r = (eServiceReferenceDVB&)m_reference;
        r.path = m_timeshift_file;
 
        m_cue = new eCueSheet();
 
        eServiceReferenceDVB r = (eServiceReferenceDVB&)m_reference;
        r.path = m_timeshift_file;
 
        m_cue = new eCueSheet();

-       m_service_handler_timeshift.tune(r, 1, m_cue); /* use the decoder demux for everything */
+       m_cue->seekTo(0, -1000);
+       m_service_handler_timeshift.tune(r, 1, m_cue, 0, m_dvb_service); /* use the decoder demux for everything */

 
        eDebug("eDVBServicePlay::switchToTimeshift, in pause mode now.");
        pause();
        updateDecoder(); /* mainly to switch off PCR, and to set pause */
 
        eDebug("eDVBServicePlay::switchToTimeshift, in pause mode now.");
        pause();
        updateDecoder(); /* mainly to switch off PCR, and to set pause */

-       
+

        m_event((iPlayableService*)this, evSeekableStatusChanged);
 }
 
        m_event((iPlayableService*)this, evSeekableStatusChanged);
 }
 


@@ -2322,25 +2348,45 @@ void eDVBServicePlay::updateDecoder()
        if (!m_decoder)
        {
                h.getDecodeDemux(m_decode_demux);
        if (!m_decoder)
        {
                h.getDecodeDemux(m_decode_demux);

+               if (m_timeshift_changed)
+                       m_decoder = 0;

                if (m_decode_demux)
                {
                        m_decode_demux->getMPEGDecoder(m_decoder, m_is_primary);
                        if (m_decoder)
                                m_decoder->connectVideoEvent(slot(*this, &eDVBServicePlay::video_event), m_video_event_connection);
                if (m_decode_demux)
                {
                        m_decode_demux->getMPEGDecoder(m_decoder, m_is_primary);
                        if (m_decoder)
                                m_decoder->connectVideoEvent(slot(*this, &eDVBServicePlay::video_event), m_video_event_connection);

-                       m_teletext_parser = new eDVBTeletextParser(m_decode_demux);
-                       m_teletext_parser->connectNewPage(slot(*this, &eDVBServicePlay::newSubtitlePage), m_new_subtitle_page_connection);
-                       m_subtitle_parser = new eDVBSubtitleParser(m_decode_demux);
-                       m_subtitle_parser->connectNewPage(slot(*this, &eDVBServicePlay::newDVBSubtitlePage), m_new_dvb_subtitle_page_connection);
-               } else
-               {
-                       m_teletext_parser = 0;
-                       m_subtitle_parser = 0;
+                       if (m_is_primary)
+                       {
+                               m_teletext_parser = new eDVBTeletextParser(m_decode_demux);
+                               m_teletext_parser->connectNewPage(slot(*this, &eDVBServicePlay::newSubtitlePage), m_new_subtitle_page_connection);
+                               m_subtitle_parser = new eDVBSubtitleParser(m_decode_demux);
+                               m_subtitle_parser->connectNewPage(slot(*this, &eDVBServicePlay::newDVBSubtitlePage), m_new_dvb_subtitle_page_connection);
+                               if (m_timeshift_changed)
+                               {
+                                       ePyObject subs = getCachedSubtitle();
+                                       if (subs != Py_None)
+                                       {
+                                               int type = PyInt_AsLong(PyTuple_GET_ITEM(subs, 0)),
+                                                   pid = PyInt_AsLong(PyTuple_GET_ITEM(subs, 1)),
+                                                   comp_page = PyInt_AsLong(PyTuple_GET_ITEM(subs, 2)), // ttx page
+                                                   anc_page = PyInt_AsLong(PyTuple_GET_ITEM(subs, 3)); // ttx magazine
+                                               if (type == 0) // dvb
+                                                       m_subtitle_parser->start(pid, comp_page, anc_page);
+                                               else if (type == 1) // ttx
+                                                       m_teletext_parser->setPageAndMagazine(comp_page, anc_page);
+                                       }
+                                       Py_DECREF(subs);
+                               }
+                       }
+                       m_decoder->play(); /* pids will be set later */

                }
                }

-

                if (m_cue)
                        m_cue->setDecodingDemux(m_decode_demux, m_decoder);
                if (m_cue)
                        m_cue->setDecodingDemux(m_decode_demux, m_decoder);

+               m_decoder->play(); /* pids will be set later. */

        }
 
        }
 

+       m_timeshift_changed = 0;
+

        if (m_decoder)
        {
                if (m_dvb_service)
        if (m_decoder)
        {
                if (m_dvb_service)


@@ -2349,7 +2395,7 @@ void eDVBServicePlay::updateDecoder()
                        ac3_delay = m_dvb_service->getCacheEntry(eDVBService::cAC3DELAY);
                        pcm_delay = m_dvb_service->getCacheEntry(eDVBService::cPCMDELAY);
                }
                        ac3_delay = m_dvb_service->getCacheEntry(eDVBService::cAC3DELAY);
                        pcm_delay = m_dvb_service->getCacheEntry(eDVBService::cPCMDELAY);
                }

-               else // subservice or recording
+               else // subservice

                {
                        eServiceReferenceDVB ref;
                        m_service_handler.getServiceReference(ref);
                {
                        eServiceReferenceDVB ref;
                        m_service_handler.getServiceReference(ref);


@@ -2374,8 +2420,9 @@ void eDVBServicePlay::updateDecoder()
                                }
                        }
                }
                                }
                        }
                }

-               m_decoder->setAC3Delay(ac3_delay == -1 ? 0 : ac3_delay);
-               m_decoder->setPCMDelay(pcm_delay == -1 ? 0 : pcm_delay);
+
+               setAC3Delay(ac3_delay == -1 ? 0 : ac3_delay);
+               setPCMDelay(pcm_delay == -1 ? 0 : pcm_delay);

 
                m_decoder->setVideoPID(vpid, vpidtype);
                selectAudioStream();
 
                m_decoder->setVideoPID(vpid, vpidtype);
                selectAudioStream();


@@ -2385,17 +2432,11 @@ void eDVBServicePlay::updateDecoder()
                else
                        m_decoder->setSyncPCR(-1);
 
                else
                        m_decoder->setSyncPCR(-1);
 

-               m_decoder->setTextPID(tpid);
-
-               m_teletext_parser->start(program.textPid);
-
-               if (!m_is_primary)
-                       m_decoder->setTrickmode(1);
-
-               if (m_is_paused)
-                       m_decoder->preroll();
-               else
-                       m_decoder->start();
+               if (m_is_primary)
+               {
+                       m_decoder->setTextPID(tpid);
+                       m_teletext_parser->start(program.textPid);
+               }

 
                if (vpid > 0 && vpid < 0x2000)
                        ;
 
                if (vpid > 0 && vpid < 0x2000)
                        ;


@@ -2406,10 +2447,11 @@ void eDVBServicePlay::updateDecoder()
                                m_decoder->setRadioPic(radio_pic);
                }
 
                                m_decoder->setRadioPic(radio_pic);
                }
 

+               m_decoder->set();

                m_decoder->setAudioChannel(achannel);
 
                /* don't worry about non-existing services, nor pvr services */
                m_decoder->setAudioChannel(achannel);
 
                /* don't worry about non-existing services, nor pvr services */

-               if (m_dvb_service && !m_is_pvr)
+               if (m_dvb_service)

                {
                                /* (audio pid will be set in selectAudioTrack */
                        m_dvb_service->setCacheEntry(eDVBService::cVPID, vpid);
                {
                                /* (audio pid will be set in selectAudioTrack */
                        m_dvb_service->setCacheEntry(eDVBService::cVPID, vpid);


@@ -2417,7 +2459,7 @@ void eDVBServicePlay::updateDecoder()
                        m_dvb_service->setCacheEntry(eDVBService::cPCRPID, pcrpid);
                        m_dvb_service->setCacheEntry(eDVBService::cTPID, tpid);
                }
                        m_dvb_service->setCacheEntry(eDVBService::cPCRPID, pcrpid);
                        m_dvb_service->setCacheEntry(eDVBService::cTPID, tpid);
                }

-       }       
+       }

        m_have_video_pid = (vpid > 0 && vpid < 0x2000);
 }
 
        m_have_video_pid = (vpid > 0 && vpid < 0x2000);
 }
 


@@ -2513,11 +2555,16 @@ void eDVBServicePlay::cutlistToCuesheet()
                
        std::multiset<cueEntry>::iterator i(m_cue_entries.begin());
        
                
        std::multiset<cueEntry>::iterator i(m_cue_entries.begin());
        

+       int have_any_span = 0;
+       

        while (1)
        {
                if (i == m_cue_entries.end())
        while (1)
        {
                if (i == m_cue_entries.end())

+               {
+                       if (!have_any_span)
+                               break;

                        out = length;
                        out = length;

-               else {
+               } else {

                        if (i->what == 0) /* in */
                        {
                                in = i++->where;
                        if (i->what == 0) /* in */
                        {
                                in = i++->where;


@@ -2531,8 +2578,20 @@ void eDVBServicePlay::cutlistToCuesheet()
                        }
                }
                
                        }
                }
                

-               if (in != out)
+               if (in < 0)
+                       in = 0;
+               if (out < 0)
+                       out = 0;
+               if (in > length)
+                       in = length;
+               if (out > length)
+                       out = length;
+               
+               if (in < out)
+               {
+                       have_any_span = 1;

                        m_cue->addSourceSpan(in, out);
                        m_cue->addSourceSpan(in, out);

+               }

                
                in = length;
                
                
                in = length;
                


@@ -2676,7 +2735,7 @@ PyObject *eDVBServicePlay::getCachedSubtitle()
                                        PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(1)); // type teletext
                                else
                                        PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(0)); // type dvb
                                        PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(1)); // type teletext
                                else
                                        PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(0)); // type dvb

-                               PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong((data&0xFFFF0000)>>16)); // pid
+                               PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(pid)); // pid

                                PyTuple_SET_ITEM(tuple, 2, PyInt_FromLong((data&0xFF00)>>8)); // composition_page / page
                                PyTuple_SET_ITEM(tuple, 3, PyInt_FromLong(data&0xFF)); // ancillary_page / magazine
                                return tuple;
                                PyTuple_SET_ITEM(tuple, 2, PyInt_FromLong((data&0xFF00)>>8)); // composition_page / page
                                PyTuple_SET_ITEM(tuple, 3, PyInt_FromLong(data&0xFF)); // ancillary_page / magazine
                                return tuple;


@@ -2770,6 +2829,10 @@ void eDVBServicePlay::newSubtitlePage(const eDVBTeletextSubtitlePage &page)
 {
        if (m_subtitle_widget)
        {
 {
        if (m_subtitle_widget)
        {

+               pts_t pos = 0;
+               if (m_decoder)
+                       m_decoder->getPTS(0, pos);
+               eDebug("got new subtitle page %lld %lld %d", pos, page.m_pts, page.m_have_pts);

                m_subtitle_pages.push_back(page);
                checkSubtitleTiming();
        }
                m_subtitle_pages.push_back(page);
                checkSubtitleTiming();
        }


@@ -2777,7 +2840,7 @@ void eDVBServicePlay::newSubtitlePage(const eDVBTeletextSubtitlePage &page)
 
 void eDVBServicePlay::checkSubtitleTiming()
 {
 
 void eDVBServicePlay::checkSubtitleTiming()
 {

-//     eDebug("checkSubtitleTiming");
+       eDebug("checkSubtitleTiming");

        if (!m_subtitle_widget)
                return;
        while (1)
        if (!m_subtitle_widget)
                return;
        while (1)


@@ -2806,37 +2869,41 @@ void eDVBServicePlay::checkSubtitleTiming()
                if (m_decoder)
                        m_decoder->getPTS(0, pos);
 
                if (m_decoder)
                        m_decoder->getPTS(0, pos);
 

-//             eDebug("%lld %lld", pos, show_time);
-               int diff =  show_time - pos;
+               eDebug("%lld %lld", pos, show_time);
+               int diff = show_time - pos;
+               if (type == TELETEXT && !page.m_have_pts)
+               {
+                       eDebug("ttx subtitle page without pts... immediate show");
+                       diff = 0;
+               }

                if (diff < 0)
                {
                        eDebug("[late (%d ms)]", -diff / 90);
                        diff = 0;
                }
                if (diff < 0)
                {
                        eDebug("[late (%d ms)]", -diff / 90);
                        diff = 0;
                }

-               if (diff > 900000)
+               if (abs(diff) > 1800000)

                {
                {

-                       eDebug("[invalid]");
+                       eDebug("[invalid]... immediate show!");

                        diff = 0;
                }
                        diff = 0;
                }

-       
-               if (!diff)
+               if ((diff/90)<20)

                {
                        if (type == TELETEXT)
                        {
                {
                        if (type == TELETEXT)
                        {

-                               eDebug("display teletext subtitle page");
+                               eDebug("display teletext subtitle page %lld", show_time);

                                m_subtitle_widget->setPage(page);
                                m_subtitle_pages.pop_front();
                        }
                        else
                        {
                                m_subtitle_widget->setPage(page);
                                m_subtitle_pages.pop_front();
                        }
                        else
                        {

-                               eDebug("display dvb subtitle Page");
+                               eDebug("display dvb subtitle Page %lld", show_time);

                                m_subtitle_widget->setPage(dvb_page);
                                m_dvb_subtitle_pages.pop_front();
                        }
                } else
                {
                                m_subtitle_widget->setPage(dvb_page);
                                m_dvb_subtitle_pages.pop_front();
                        }
                } else
                {

-//                     eDebug("start subtitle delay %d", diff / 90);
-                       m_subtitle_sync_timer.start(diff / 90, 1);
+                       eDebug("start subtitle delay %d", diff / 90);
+                       m_subtitle_sync_timer->start(diff / 90, 1);

                        break;
                }
        }
                        break;
                }
        }


@@ -2846,6 +2913,10 @@ void eDVBServicePlay::newDVBSubtitlePage(const eDVBSubtitlePage &p)
 {
        if (m_subtitle_widget)
        {
 {
        if (m_subtitle_widget)
        {

+               pts_t pos = 0;
+               if (m_decoder)
+                       m_decoder->getPTS(0, pos);
+               eDebug("got new subtitle page %lld %lld", pos, p.m_show_time);

                m_dvb_subtitle_pages.push_back(p);
                checkSubtitleTiming();
        }
                m_dvb_subtitle_pages.push_back(p);
                checkSubtitleTiming();
        }


@@ -2875,22 +2946,45 @@ void eDVBServicePlay::setAC3Delay(int delay)
 {
        if (m_dvb_service)
                m_dvb_service->setCacheEntry(eDVBService::cAC3DELAY, delay ? delay : -1);
 {
        if (m_dvb_service)
                m_dvb_service->setCacheEntry(eDVBService::cAC3DELAY, delay ? delay : -1);

-       if (m_decoder)
-               m_decoder->setAC3Delay(delay);
+       if (m_decoder) {
+               std::string config_delay;
+               int config_delay_int = 0;
+               if(ePythonConfigQuery::getConfigValue("config.av.generalAC3delay", config_delay) == 0)
+                       config_delay_int = atoi(config_delay.c_str());
+               m_decoder->setAC3Delay(delay + config_delay_int);
+       }

 }
 
 void eDVBServicePlay::setPCMDelay(int delay)
 {
        if (m_dvb_service)
                m_dvb_service->setCacheEntry(eDVBService::cPCMDELAY, delay ? delay : -1);
 }
 
 void eDVBServicePlay::setPCMDelay(int delay)
 {
        if (m_dvb_service)
                m_dvb_service->setCacheEntry(eDVBService::cPCMDELAY, delay ? delay : -1);

-       if (m_decoder)
-               m_decoder->setPCMDelay(delay);
+       if (m_decoder) {
+               std::string config_delay;
+               int config_delay_int = 0;
+               if(ePythonConfigQuery::getConfigValue("config.av.generalPCMdelay", config_delay) == 0)
+                       config_delay_int = atoi(config_delay.c_str());
+               else
+                       config_delay_int = 0;
+               m_decoder->setPCMDelay(delay + config_delay_int);
+       }

 }
 
 void eDVBServicePlay::video_event(struct iTSMPEGDecoder::videoEvent event)
 {
 }
 
 void eDVBServicePlay::video_event(struct iTSMPEGDecoder::videoEvent event)
 {

-       memcpy(&m_videoEventData, &event, sizeof(iTSMPEGDecoder::videoEvent));
-       m_event((iPlayableService*)this, evVideoSizeChanged);
+       switch(event.type) {
+               case iTSMPEGDecoder::videoEvent::eventSizeChanged:
+                       m_event((iPlayableService*)this, evVideoSizeChanged);
+                       break;
+               case iTSMPEGDecoder::videoEvent::eventFrameRateChanged:
+                       m_event((iPlayableService*)this, evVideoFramerateChanged);
+                       break;
+               case iTSMPEGDecoder::videoEvent::eventProgressiveChanged:
+                       m_event((iPlayableService*)this, evVideoProgressiveChanged);
+                       break;
+               default:
+                       break;
+       }

 }
 
 RESULT eDVBServicePlay::stream(ePtr<iStreamableService> &ptr)
 }
 
 RESULT eDVBServicePlay::stream(ePtr<iStreamableService> &ptr)


@@ -2904,18 +2998,16 @@ PyObject *eDVBServicePlay::getStreamingData()
        eDVBServicePMTHandler::program program;
        if (m_service_handler.getProgramInfo(program))
        {
        eDVBServicePMTHandler::program program;
        if (m_service_handler.getProgramInfo(program))
        {

-               Py_INCREF(Py_None);
-               return Py_None;
+               Py_RETURN_NONE;

        }
 
        }
 

-       PyObject *r = program.createPythonObject();
+       ePyObject r = program.createPythonObject();

        ePtr<iDVBDemux> demux;
        if (!m_service_handler.getDataDemux(demux))
        {
                uint8_t demux_id;
        ePtr<iDVBDemux> demux;
        if (!m_service_handler.getDataDemux(demux))
        {
                uint8_t demux_id;

-               demux->getCADemuxID(demux_id);
-               
-               PyDict_SetItemString(r, "demux", PyInt_FromLong(demux_id));
+               if (!demux->getCADemuxID(demux_id))
+                       PutToDict(r, "demux", demux_id);

        }
 
        return r;
        }
 
        return r;