hide subtitles after actual duration timeout, unescape entities and simulate bold...

[enigma2.git] / lib / dvb / dvb.cpp

diff --git a/lib/dvb/dvb.cpp b/lib/dvb/dvb.cpp
index b7d278ccfa4accf21a5b841d1b0b4df59cceb133..f163230e3b8bf12b479276f4cfd75259a12d2cf7 100644 (file)
--- a/lib/dvb/dvb.cpp
+++ b/lib/dvb/dvb.cpp
@@ -65,7 +65,8 @@ eDVBResourceManager::eDVBResourceManager()
 {
        avail = 1;
        busy = 0;
 {
        avail = 1;
        busy = 0;

-       m_sec = new eDVBSatelliteEquipmentControl(m_frontend);
+       m_sec = new eDVBSatelliteEquipmentControl(m_frontend, m_simulate_frontend);
+

        if (!instance)
                instance = this;
                
        if (!instance)
                instance = this;
                


@@ -80,8 +81,8 @@ eDVBResourceManager::eDVBResourceManager()
                num_adapter++;
        }
        
                num_adapter++;
        }
        

-       eDebug("found %d adapter, %d frontends and %d demux", 
-               m_adapter.size(), m_frontend.size(), m_demux.size());
+       eDebug("found %d adapter, %d frontends(%d sim) and %d demux", 
+               m_adapter.size(), m_frontend.size(), m_simulate_frontend.size(), m_demux.size());

 
        eDVBCAService::registerChannelCallback(this);
 
 
        eDVBCAService::registerChannelCallback(this);
 


@@ -117,10 +118,18 @@ eDVBAdapterLinux::eDVBAdapterLinux(int nr): m_nr(nr)
                        break;
                ePtr<eDVBFrontend> fe;
 
                        break;
                ePtr<eDVBFrontend> fe;
 

-               int ok = 0;
-               fe = new eDVBFrontend(m_nr, num_fe, ok);
-               if (ok)
-                       m_frontend.push_back(fe);
+               {
+                       int ok = 0;
+                       fe = new eDVBFrontend(m_nr, num_fe, ok);
+                       if (ok)
+                               m_frontend.push_back(fe);
+               }
+               {
+                       int ok = 0;
+                       fe = new eDVBFrontend(m_nr, num_fe, ok, true);
+                       if (ok)
+                               m_simulate_frontend.push_back(fe);
+               }

                ++num_fe;
        }
        
                ++num_fe;
        }
        


@@ -173,9 +182,9 @@ int eDVBAdapterLinux::getNumFrontends()
        return m_frontend.size();
 }
 
        return m_frontend.size();
 }
 

-RESULT eDVBAdapterLinux::getFrontend(ePtr<eDVBFrontend> &fe, int nr)
+RESULT eDVBAdapterLinux::getFrontend(ePtr<eDVBFrontend> &fe, int nr, bool simulate)

 {
 {

-       eSmartPtrList<eDVBFrontend>::iterator i(m_frontend.begin());
+       eSmartPtrList<eDVBFrontend>::iterator i(simulate ? m_simulate_frontend.begin() : m_frontend.begin());

        while (nr && (i != m_frontend.end()))
        {
                --nr;
        while (nr && (i != m_frontend.end()))
        {
                --nr;


@@ -242,13 +251,39 @@ void eDVBResourceManager::addAdapter(iDVBAdapter *adapter)
                        {
                                if (prev_dvbt_frontend)
                                {
                        {
                                if (prev_dvbt_frontend)
                                {

-                                       prev_dvbt_frontend->m_frontend->setData(eDVBFrontend::LINKED_NEXT_PTR, (int)new_fe);
-                                       frontend->setData(eDVBFrontend::LINKED_PREV_PTR, (int)&(*prev_dvbt_frontend));
+                                       prev_dvbt_frontend->m_frontend->setData(eDVBFrontend::LINKED_NEXT_PTR, (long)new_fe);
+                                       frontend->setData(eDVBFrontend::LINKED_PREV_PTR, (long)&(*prev_dvbt_frontend));
+                               }
+                               prev_dvbt_frontend = new_fe;
+                       }
+               }
+       }
+
+       prev_dvbt_frontend = 0;
+       for (i=0; i<num_fe; ++i)
+       {
+               ePtr<eDVBFrontend> frontend;
+               if (!adapter->getFrontend(frontend, i, true))
+               {
+                       int frontendType=0;
+                       frontend->getFrontendType(frontendType);
+                       eDVBRegisteredFrontend *new_fe = new eDVBRegisteredFrontend(frontend, adapter);
+//                     CONNECT(new_fe->stateChanged, eDVBResourceManager::feStateChanged);
+                       m_simulate_frontend.push_back(new_fe);
+                       frontend->setSEC(m_sec);
+                       // we must link all dvb-t frontends ( for active antenna voltage )
+                       if (frontendType == iDVBFrontend::feTerrestrial)
+                       {
+                               if (prev_dvbt_frontend)
+                               {
+                                       prev_dvbt_frontend->m_frontend->setData(eDVBFrontend::LINKED_NEXT_PTR, (long)new_fe);
+                                       frontend->setData(eDVBFrontend::LINKED_PREV_PTR, (long)&(*prev_dvbt_frontend));

                                }
                                prev_dvbt_frontend = new_fe;
                        }
                }
        }
                                }
                                prev_dvbt_frontend = new_fe;
                        }
                }
        }

+

 }
 
 PyObject *eDVBResourceManager::setFrontendSlotInformations(ePyObject list)
 }
 
 PyObject *eDVBResourceManager::setFrontendSlotInformations(ePyObject list)


@@ -273,75 +308,101 @@ PyObject *eDVBResourceManager::setFrontendSlotInformations(ePyObject list)
                if (!i->m_frontend->setSlotInfo(obj))
                        return NULL;
        }
                if (!i->m_frontend->setSlotInfo(obj))
                        return NULL;
        }

+       pos=0;
+       for (eSmartPtrList<eDVBRegisteredFrontend>::iterator i(m_simulate_frontend.begin()); i != m_simulate_frontend.end(); ++i)
+       {
+               ePyObject obj = PyList_GET_ITEM(list, pos++);
+               if (!i->m_frontend->setSlotInfo(obj))
+                       return NULL;
+       }

        Py_RETURN_NONE;
 }
 
        Py_RETURN_NONE;
 }
 

-RESULT eDVBResourceManager::allocateFrontend(ePtr<eDVBAllocatedFrontend> &fe, ePtr<iDVBFrontendParameters> &feparm)
+RESULT eDVBResourceManager::allocateFrontend(ePtr<eDVBAllocatedFrontend> &fe, ePtr<iDVBFrontendParameters> &feparm, bool simulate)

 {
 {

+       eSmartPtrList<eDVBRegisteredFrontend> &frontends = simulate ? m_simulate_frontend : m_frontend;

        ePtr<eDVBRegisteredFrontend> best;
        int bestval = 0;
        ePtr<eDVBRegisteredFrontend> best;
        int bestval = 0;

+       int foundone = 0;
+
+       for (eSmartPtrList<eDVBRegisteredFrontend>::iterator i(frontends.begin()); i != frontends.end(); ++i)
+       {
+               int c = i->m_frontend->isCompatibleWith(feparm);
+
+               if (c)  /* if we have at least one frontend which is compatible with the source, flag this. */
+                       foundone = 1;

 
 

-       for (eSmartPtrList<eDVBRegisteredFrontend>::iterator i(m_frontend.begin()); i != m_frontend.end(); ++i)

                if (!i->m_inuse)
                {
                if (!i->m_inuse)
                {

-                       int c = i->m_frontend->isCompatibleWith(feparm);
+//                     eDebug("Slot %d, score %d", i->m_frontend->getSlotID(), c);

                        if (c > bestval)
                        {
                                bestval = c;
                                best = i;
                        }
                }
                        if (c > bestval)
                        {
                                bestval = c;
                                best = i;
                        }
                }

+//             else
+//                     eDebug("Slot %d, score %d... but BUSY!!!!!!!!!!!", i->m_frontend->getSlotID(), c);
+       }

 
        if (best)
        {
                fe = new eDVBAllocatedFrontend(best);
                return 0;
        }
 
        if (best)
        {
                fe = new eDVBAllocatedFrontend(best);
                return 0;
        }

-       
+

        fe = 0;
        fe = 0;

-       
-       return -1;
+
+       if (foundone)
+               return errAllSourcesBusy;
+       else
+               return errNoSourceFound;

 }
 
 RESULT eDVBResourceManager::allocateFrontendByIndex(ePtr<eDVBAllocatedFrontend> &fe, int slot_index)
 {
 }
 
 RESULT eDVBResourceManager::allocateFrontendByIndex(ePtr<eDVBAllocatedFrontend> &fe, int slot_index)
 {

+       int err = errNoSourceFound;

        for (eSmartPtrList<eDVBRegisteredFrontend>::iterator i(m_frontend.begin()); i != m_frontend.end(); ++i)
                if (!i->m_inuse && i->m_frontend->getSlotID() == slot_index)
                {
                        // check if another slot linked to this is in use
        for (eSmartPtrList<eDVBRegisteredFrontend>::iterator i(m_frontend.begin()); i != m_frontend.end(); ++i)
                if (!i->m_inuse && i->m_frontend->getSlotID() == slot_index)
                {
                        // check if another slot linked to this is in use

-                       eDVBRegisteredFrontend *satpos_depends_to_fe =
-                               (eDVBRegisteredFrontend*) i->m_frontend->m_data[eDVBFrontend::SATPOS_DEPENDS_PTR];
-                       if ( (int)satpos_depends_to_fe != -1 )
+                       long tmp;
+                       i->m_frontend->getData(eDVBFrontend::SATPOS_DEPENDS_PTR, tmp);
+                       if ( tmp != -1 )

                        {
                        {

+                               eDVBRegisteredFrontend *satpos_depends_to_fe = (eDVBRegisteredFrontend *)tmp;

                                if (satpos_depends_to_fe->m_inuse)
                                {
                                        eDebug("another satpos depending frontend is in use.. so allocateFrontendByIndex not possible!");
                                if (satpos_depends_to_fe->m_inuse)
                                {
                                        eDebug("another satpos depending frontend is in use.. so allocateFrontendByIndex not possible!");

+                                       err = errAllSourcesBusy;

                                        goto alloc_fe_by_id_not_possible;
                                }
                        }
                        else // check linked tuners
                        {
                                        goto alloc_fe_by_id_not_possible;
                                }
                        }
                        else // check linked tuners
                        {

-                               eDVBRegisteredFrontend *next =
-                                       (eDVBRegisteredFrontend *) i->m_frontend->m_data[eDVBFrontend::LINKED_NEXT_PTR];
-                               while ( (int)next != -1 )
+                               i->m_frontend->getData(eDVBFrontend::LINKED_NEXT_PTR, tmp);
+                               while ( tmp != -1 )

                                {
                                {

+                                       eDVBRegisteredFrontend *next = (eDVBRegisteredFrontend *) tmp;

                                        if (next->m_inuse)
                                        {
                                                eDebug("another linked frontend is in use.. so allocateFrontendByIndex not possible!");
                                        if (next->m_inuse)
                                        {
                                                eDebug("another linked frontend is in use.. so allocateFrontendByIndex not possible!");

+                                               err = errAllSourcesBusy;

                                                goto alloc_fe_by_id_not_possible;
                                        }
                                                goto alloc_fe_by_id_not_possible;
                                        }

-                                       next = (eDVBRegisteredFrontend *)next->m_frontend->m_data[eDVBFrontend::LINKED_NEXT_PTR];
+                                       next->m_frontend->getData(eDVBFrontend::LINKED_NEXT_PTR, tmp);

                                }
                                }

-                               eDVBRegisteredFrontend *prev = (eDVBRegisteredFrontend *)
-                                       i->m_frontend->m_data[eDVBFrontend::LINKED_PREV_PTR];
-                               while ( (int)prev != -1 )
+                               i->m_frontend->getData(eDVBFrontend::LINKED_PREV_PTR, tmp);
+                               while ( tmp != -1 )

                                {
                                {

+                                       eDVBRegisteredFrontend *prev = (eDVBRegisteredFrontend *) tmp;

                                        if (prev->m_inuse)
                                        {
                                                eDebug("another linked frontend is in use.. so allocateFrontendByIndex not possible!");
                                        if (prev->m_inuse)
                                        {
                                                eDebug("another linked frontend is in use.. so allocateFrontendByIndex not possible!");

+                                               err = errAllSourcesBusy;

                                                goto alloc_fe_by_id_not_possible;
                                        }
                                                goto alloc_fe_by_id_not_possible;
                                        }

-                                       prev = (eDVBRegisteredFrontend *)prev->m_frontend->m_data[eDVBFrontend::LINKED_PREV_PTR];
+                                       prev->m_frontend->getData(eDVBFrontend::LINKED_PREV_PTR, tmp);

                                }
                        }
                        fe = new eDVBAllocatedFrontend(i);
                                }
                        }
                        fe = new eDVBAllocatedFrontend(i);


@@ -349,7 +410,7 @@ RESULT eDVBResourceManager::allocateFrontendByIndex(ePtr<eDVBAllocatedFrontend>
                }
 alloc_fe_by_id_not_possible:
        fe = 0;
                }
 alloc_fe_by_id_not_possible:
        fe = 0;

-       return -1;
+       return err;

 }
 
 RESULT eDVBResourceManager::allocateDemux(eDVBRegisteredFrontend *fe, ePtr<eDVBAllocatedDemux> &demux, int cap)
 }
 
 RESULT eDVBResourceManager::allocateDemux(eDVBRegisteredFrontend *fe, ePtr<eDVBAllocatedDemux> &demux, int cap)


@@ -359,40 +420,80 @@ RESULT eDVBResourceManager::allocateDemux(eDVBRegisteredFrontend *fe, ePtr<eDVBA
 
        eDebug("allocate demux");
        eSmartPtrList<eDVBRegisteredDemux>::iterator i(m_demux.begin());
 
        eDebug("allocate demux");
        eSmartPtrList<eDVBRegisteredDemux>::iterator i(m_demux.begin());

-       
+
+       int n=0;
+

        if (i == m_demux.end())
                return -1;
        if (i == m_demux.end())
                return -1;

-               
-       int n=0;
-               /* FIXME: hardware demux policy */
-       if (!(cap & iDVBChannel::capDecode))
+       
+       ePtr<eDVBRegisteredDemux> unused;
+       
+       if (m_demux.size() < 5)

        {
        {

-               if (m_demux.size() > 2)  /* assumed to be true, otherwise we have lost anyway */
+               /* FIXME: hardware demux policy */
+               if (!(cap & iDVBChannel::capDecode))

                {
                {

-                       ++i, ++n;
-                       ++i, ++n;
+                       if (m_demux.size() > 2)  /* assumed to be true, otherwise we have lost anyway */
+                       {
+                               ++i, ++n;
+                               ++i, ++n;
+                       }

                }
                }

-       }
-       
-       for (; i != m_demux.end(); ++i, ++n)
-       {
-               int is_decode = n < 2;
+
+               for (; i != m_demux.end(); ++i, ++n)
+               {
+                       int is_decode = n < 2;

                
                

-               int in_use = is_decode ? (i->m_demux->getRefCount() != 2) : i->m_inuse;
+                       int in_use = is_decode ? (i->m_demux->getRefCount() != 2) : i->m_inuse;

                
                

-               if ((!in_use) && ((!fe) || (i->m_adapter == fe->m_adapter)))
+                       if ((!in_use) && ((!fe) || (i->m_adapter == fe->m_adapter)))
+                       {
+                               if ((cap & iDVBChannel::capDecode) && !is_decode)
+                                       continue;
+                               unused = i;     
+                               break;
+                       }
+               }
+       }
+       else // we asume dm8000
+       {
+               for (; i != m_demux.end(); ++i, ++n)

                {
                {

-                       if ((cap & iDVBChannel::capDecode) && !is_decode)
-                               continue;
-                       
-                       demux = new eDVBAllocatedDemux(i);

                        if (fe)
                        if (fe)

-                               demux->get().setSourceFrontend(fe->m_frontend->getDVBID());
-                       else
-                               demux->get().setSourcePVR(0);
-                       return 0;
+                       {
+                               if (!i->m_inuse)
+                               {
+                                       if (!unused)
+                                               unused = i;
+                               }
+                               else if (i->m_adapter == fe->m_adapter && 
+                                   i->m_demux->getSource() == fe->m_frontend->getDVBID())
+                               {
+                                       demux = new eDVBAllocatedDemux(i);
+                                       return 0;
+                               }
+                       }
+                       else if (n == 4) // always use demux4 for PVR (demux 4 can not descramble...)
+                       {
+                               if (i->m_inuse) {
+                                       demux = new eDVBAllocatedDemux(i);
+                                       return 0;
+                               }
+                               unused = i;
+                       }

                }
        }
                }
        }

+
+       if (unused)
+       {
+               demux = new eDVBAllocatedDemux(unused);
+               if (fe)
+                       demux->get().setSourceFrontend(fe->m_frontend->getDVBID());
+               else
+                       demux->get().setSourcePVR(0);
+               return 0;
+       }
+

        eDebug("demux not found");
        return -1;
 }
        eDebug("demux not found");
        return -1;
 }


@@ -412,11 +513,24 @@ RESULT eDVBResourceManager::getChannelList(ePtr<iDVBChannelList> &list)
                return -ENOENT;
 }
 
                return -ENOENT;
 }
 

-RESULT eDVBResourceManager::allocateChannel(const eDVBChannelID &channelid, eUsePtr<iDVBChannel> &channel)
+#define eDebugNoSimulate(x...) \
+       do { \
+               if (!simulate) \
+                       eDebug(x); \
+       } while(0)
+//             else \
+//             { \
+//                     eDebugNoNewLine("SIMULATE:"); \
+//                     eDebug(x); \
+//             } \
+
+
+RESULT eDVBResourceManager::allocateChannel(const eDVBChannelID &channelid, eUsePtr<iDVBChannel> &channel, bool simulate)

 {
                /* first, check if a channel is already existing. */
 {
                /* first, check if a channel is already existing. */

+       std::list<active_channel> &active_channels = simulate ? m_active_simulate_channels : m_active_channels;

 
 

-       if (m_cached_channel)
+       if (!simulate && m_cached_channel)

        {
                eDVBChannel *cache_chan = (eDVBChannel*)&(*m_cached_channel);
                if(channelid==cache_chan->getChannelID())
        {
                eDVBChannel *cache_chan = (eDVBChannel*)&(*m_cached_channel);
                if(channelid==cache_chan->getChannelID())


@@ -430,39 +544,40 @@ RESULT eDVBResourceManager::allocateChannel(const eDVBChannelID &channelid, eUse
                m_releaseCachedChannelTimer.stop();
        }
 
                m_releaseCachedChannelTimer.stop();
        }
 

-//     eDebug("allocate channel.. %04x:%04x", channelid.transport_stream_id.get(), channelid.original_network_id.get());
-       for (std::list<active_channel>::iterator i(m_active_channels.begin()); i != m_active_channels.end(); ++i)
+       eDebugNoSimulate("allocate channel.. %04x:%04x", channelid.transport_stream_id.get(), channelid.original_network_id.get());
+       for (std::list<active_channel>::iterator i(active_channels.begin()); i != active_channels.end(); ++i)

        {
        {

-//             eDebug("available channel.. %04x:%04x", i->m_channel_id.transport_stream_id.get(), i->m_channel_id.original_network_id.get());
+               eDebugNoSimulate("available channel.. %04x:%04x", i->m_channel_id.transport_stream_id.get(), i->m_channel_id.original_network_id.get());

                if (i->m_channel_id == channelid)
                {
                if (i->m_channel_id == channelid)
                {

-//                     eDebug("found shared channel..");
+                       eDebugNoSimulate("found shared channel..");

                        channel = i->m_channel;
                        return 0;
                }
        }
                        channel = i->m_channel;
                        return 0;
                }
        }

-       
+

        /* no currently available channel is tuned to this channelid. create a new one, if possible. */
 
        if (!m_list)
        {
        /* no currently available channel is tuned to this channelid. create a new one, if possible. */
 
        if (!m_list)
        {

-               eDebug("no channel list set!");
-               return -ENOENT;
+               eDebugNoSimulate("no channel list set!");
+               return errNoChannelList;

        }
 
        ePtr<iDVBFrontendParameters> feparm;
        if (m_list->getChannelFrontendData(channelid, feparm))
        {
        }
 
        ePtr<iDVBFrontendParameters> feparm;
        if (m_list->getChannelFrontendData(channelid, feparm))
        {

-               eDebug("channel not found!");
-               return -ENOENT;
+               eDebugNoSimulate("channel not found!");
+               return errChannelNotInList;

        }
 
        /* allocate a frontend. */
        
        ePtr<eDVBAllocatedFrontend> fe;
        }
 
        /* allocate a frontend. */
        
        ePtr<eDVBAllocatedFrontend> fe;

-       
-       if (allocateFrontend(fe, feparm))
-               return errNoFrontend;
+
+       int err = allocateFrontend(fe, feparm, simulate);
+       if (err)
+               return err;

 
        RESULT res;
        ePtr<eDVBChannel> ch;
 
        RESULT res;
        ePtr<eDVBChannel> ch;


@@ -474,9 +589,15 @@ RESULT eDVBResourceManager::allocateChannel(const eDVBChannelID &channelid, eUse
                channel = 0;
                return errChidNotFound;
        }
                channel = 0;
                return errChidNotFound;
        }

-       m_cached_channel = channel = ch;
-       m_cached_channel_state_changed_conn =
-               CONNECT(ch->m_stateChanged,eDVBResourceManager::DVBChannelStateChanged);
+
+       if (simulate)
+               channel = ch;
+       else
+       {
+               m_cached_channel = channel = ch;
+               m_cached_channel_state_changed_conn =
+                       CONNECT(ch->m_stateChanged,eDVBResourceManager::DVBChannelStateChanged);
+       }

 
        return 0;
 }
 
        return 0;
 }


@@ -522,9 +643,10 @@ RESULT eDVBResourceManager::allocateRawChannel(eUsePtr<iDVBChannel> &channel, in
                m_releaseCachedChannelTimer.stop();
        }
 
                m_releaseCachedChannelTimer.stop();
        }
 

-       if (allocateFrontendByIndex(fe, slot_index))
-               return errNoFrontend;
-       
+       int err = allocateFrontendByIndex(fe, slot_index);
+       if (err)
+               return err;
+

        eDVBChannel *ch;
        ch = new eDVBChannel(this, fe);
 
        eDVBChannel *ch;
        ch = new eDVBChannel(this, fe);
 


@@ -553,26 +675,42 @@ RESULT eDVBResourceManager::allocatePVRChannel(eUsePtr<iDVBPVRChannel> &channel)
 
 RESULT eDVBResourceManager::addChannel(const eDVBChannelID &chid, eDVBChannel *ch)
 {
 
 RESULT eDVBResourceManager::addChannel(const eDVBChannelID &chid, eDVBChannel *ch)
 {

-       m_active_channels.push_back(active_channel(chid, ch));
-       /* emit */ m_channelAdded(ch);
+       ePtr<iDVBFrontend> fe;
+       if (!ch->getFrontend(fe))
+       {
+               eDVBFrontend *frontend = (eDVBFrontend*)&(*fe);
+               if (frontend->is_simulate())
+                       m_active_simulate_channels.push_back(active_channel(chid, ch));
+               else
+               {
+                       m_active_channels.push_back(active_channel(chid, ch));
+                       /* emit */ m_channelAdded(ch);
+               }
+       }

        return 0;
 }
 
 RESULT eDVBResourceManager::removeChannel(eDVBChannel *ch)
 {
        return 0;
 }
 
 RESULT eDVBResourceManager::removeChannel(eDVBChannel *ch)
 {

-       int cnt = 0;
-       for (std::list<active_channel>::iterator i(m_active_channels.begin()); i != m_active_channels.end();)
+       ePtr<iDVBFrontend> fe;
+       if (!ch->getFrontend(fe))

        {
        {

-               if (i->m_channel == ch)
+               eDVBFrontend *frontend = (eDVBFrontend*)&(*fe);
+               std::list<active_channel> &active_channels = frontend->is_simulate() ? m_active_simulate_channels : m_active_channels;
+               int cnt = 0;
+               for (std::list<active_channel>::iterator i(active_channels.begin()); i != active_channels.end();)

                {
                {

-                       i = m_active_channels.erase(i);
-                       ++cnt;
-               } else
-                       ++i;
+                       if (i->m_channel == ch)
+                       {
+                               i = active_channels.erase(i);
+                               ++cnt;
+                       } else
+                               ++i;
+               }
+               ASSERT(cnt == 1);
+               if (cnt == 1)
+                       return 0;

        }
        }

-       ASSERT(cnt == 1);
-       if (cnt == 1)
-               return 0;

        return -ENOENT;
 }
 
        return -ENOENT;
 }
 


@@ -732,24 +870,119 @@ error:
        return ret;
 }
 
        return ret;
 }
 

+bool eDVBResourceManager::canMeasureFrontendInputPower()
+{
+       for (eSmartPtrList<eDVBRegisteredFrontend>::iterator i(m_frontend.begin()); i != m_frontend.end(); ++i)
+       {
+               return i->m_frontend->readInputpower() >= 0;
+       }
+       return false;
+}
+

 class eDVBChannelFilePush: public eFilePushThread
 {
 public:
 class eDVBChannelFilePush: public eFilePushThread
 {
 public:

+       eDVBChannelFilePush() { setIFrameSearch(0); setTimebaseChange(0); }

        void setIFrameSearch(int enabled) { m_iframe_search = enabled; m_iframe_state = 0; }
        void setIFrameSearch(int enabled) { m_iframe_search = enabled; m_iframe_state = 0; }

+
+                       /* "timebase change" is for doing trickmode playback at an exact speed, even when pictures are skipped. */
+                       /* you need to set it to 1/16 if you want 16x playback, for example. you need video master sync. */
+       void setTimebaseChange(int ratio) { m_timebase_change = ratio; } /* 16bit fixpoint, 0 for disable */

 protected:
        int m_iframe_search, m_iframe_state, m_pid;
 protected:
        int m_iframe_search, m_iframe_state, m_pid;

+       int m_timebase_change;

        int filterRecordData(const unsigned char *data, int len, size_t &current_span_remaining);
 };
 
 int eDVBChannelFilePush::filterRecordData(const unsigned char *_data, int len, size_t &current_span_remaining)
 {
        int filterRecordData(const unsigned char *data, int len, size_t &current_span_remaining);
 };
 
 int eDVBChannelFilePush::filterRecordData(const unsigned char *_data, int len, size_t &current_span_remaining)
 {

-#if 0 /* not yet */
+#if 0
+       if (m_timebase_change)
+       {
+               eDebug("timebase change: %d", m_timebase_change);
+               int offset;
+               for (offset = 0; offset < len; offset += 188)
+               {
+                       unsigned char *pkt = (unsigned char*)_data + offset;
+                       if (pkt[1] & 0x40) /* pusi */
+                       {
+                               if (pkt[3] & 0x20) // adaption field present?
+                                       pkt += pkt[4] + 4 + 1;  /* skip adaption field and header */
+                               else
+                                       pkt += 4; /* skip header */
+                               if (pkt[0] || pkt[1] || (pkt[2] != 1))
+                               {
+                                       eWarning("broken startcode");
+                                       continue;
+                               }
+
+                               pts_t pts = 0;
+
+                               if (pkt[7] & 0x80) // PTS present?
+                               {
+                                       pts  = ((unsigned long long)(pkt[ 9]&0xE))  << 29;
+                                       pts |= ((unsigned long long)(pkt[10]&0xFF)) << 22;
+                                       pts |= ((unsigned long long)(pkt[11]&0xFE)) << 14;
+                                       pts |= ((unsigned long long)(pkt[12]&0xFF)) << 7;
+                                       pts |= ((unsigned long long)(pkt[13]&0xFE)) >> 1;
+
+#if 0
+                                       off_t off = 0;
+                                       RESULT r = m_tstools.fixupPTS(off, pts);
+                                       if (r)
+                                               eWarning("fixup PTS while trickmode playback failed.\n");
+#endif
+
+                                       int sec = pts / 90000;
+                                       int frm = pts % 90000;
+                                       int min = sec / 60;
+                                       sec %= 60;
+                                       int hr = min / 60;
+                                       min %= 60;
+                                       int d = hr / 24;
+                                       hr %= 24;
+
+//                                     eDebug("original, fixed pts: %016llx %d:%02d:%02d:%02d:%05d", pts, d, hr, min, sec, frm);
+
+                                       pts += 0x80000000LL;
+                                       pts *= m_timebase_change;
+                                       pts >>= 16;
+
+                                       sec = pts / 90000;
+                                       frm = pts % 90000;
+                                       min = sec / 60;
+                                       sec %= 60;
+                                       hr = min / 60;
+                                       min %= 60;
+                                       d = hr / 24;
+                                       hr %= 24;
+
+//                                     eDebug("new pts (after timebase change): %016llx %d:%02d:%02d:%02d:%05d", pts, d, hr, min, sec, frm);
+
+                                       pkt[9] &= ~0xE;
+                                       pkt[10] = 0;
+                                       pkt[11] &= ~1;
+                                       pkt[12] = 0;
+                                       pkt[13] &= ~1;
+
+                                       pkt[9]  |= (pts >> 29) & 0xE;
+                                       pkt[10] |= (pts >> 22) & 0xFF;
+                                       pkt[11] |= (pts >> 14) & 0xFE;
+                                       pkt[12] |= (pts >> 7) & 0xFF;
+                                       pkt[13] |= (pts << 1) & 0xFE;
+                               }
+                       }
+               }
+       }
+#endif
+
+#if 1 /* not yet */

        if (!m_iframe_search)
                return len;
 
        unsigned char *data = (unsigned char*)_data; /* remove that const. we know what we are doing. */
 
        if (!m_iframe_search)
                return len;
 
        unsigned char *data = (unsigned char*)_data; /* remove that const. we know what we are doing. */
 

-       eDebug("filterRecordData, size=%d (mod 188=%d), first byte is %02x", len, len %188, data[0]);
+//     eDebug("filterRecordData, size=%d (mod 188=%d), first byte is %02x", len, len %188, data[0]);

 
        unsigned char *d = data;
        while ((d = (unsigned char*)memmem(d, data + len - d, "\x00\x00\x01", 3)))
 
        unsigned char *d = data;
        while ((d = (unsigned char*)memmem(d, data + len - d, "\x00\x00\x01", 3)))


@@ -763,8 +996,8 @@ int eDVBChannelFilePush::filterRecordData(const unsigned char *_data, int len, s
                {
                        int picture_type = (d[5] >> 3) & 7;
                        d += 4;
                {
                        int picture_type = (d[5] >> 3) & 7;
                        d += 4;

-                       
-                       eDebug("%d-frame at %d, offset in TS packet: %d, pid=%04x", picture_type, offset, offset % 188, pid);
+
+//                     eDebug("%d-frame at %d, offset in TS packet: %d, pid=%04x", picture_type, offset, offset % 188, pid);

 
                        if (m_iframe_state == 1)
                        {
 
                        if (m_iframe_state == 1)
                        {


@@ -786,19 +1019,19 @@ int eDVBChannelFilePush::filterRecordData(const unsigned char *_data, int len, s
                        {
                                if (picture_type != 1) /* we are only interested in I frames */
                                        continue;
                        {
                                if (picture_type != 1) /* we are only interested in I frames */
                                        continue;

-                       
+

                                unsigned char *fts = data;
                                while (fts < ts)
                                {
                                        fts[1] |= 0x1f;
                                        fts[2] |= 0xff; /* drop packet */
                                unsigned char *fts = data;
                                while (fts < ts)
                                {
                                        fts[1] |= 0x1f;
                                        fts[2] |= 0xff; /* drop packet */

-                               
+

                                        fts += 188;
                                }
                                                /* force payload only */
                                ts[3] &= ~0x30;
                                ts[3] |=  0x10;
                                        fts += 188;
                                }
                                                /* force payload only */
                                ts[3] &= ~0x30;
                                ts[3] |=  0x10;

-                               
+

 //                             memset(ts + 4, 0xFF, (offset % 188) - 4);
 
                                m_iframe_state = 1;
 //                             memset(ts + 4, 0xFF, (offset % 188) - 4);
 
                                m_iframe_state = 1;


@@ -912,6 +1145,9 @@ void eDVBChannel::pvrEvent(int event)
 
 void eDVBChannel::cueSheetEvent(int event)
 {
 
 void eDVBChannel::cueSheetEvent(int event)
 {

+               /* we might end up here if playing failed or stopped, but the client hasn't (yet) noted. */
+       if (!m_pvr_thread)
+               return;

        switch (event)
        {
        case eCueSheet::evtSeek:
        switch (event)
        {
        case eCueSheet::evtSeek:


@@ -932,26 +1168,28 @@ void eDVBChannel::cueSheetEvent(int event)
                                                /* i agree that this might look a bit like black magic. */
                                m_skipmode_n = 512*1024; /* must be 1 iframe at least. */
                                m_skipmode_m = bitrate / 8 / 90000 * m_cue->m_skipmode_ratio / 8;
                                                /* i agree that this might look a bit like black magic. */
                                m_skipmode_n = 512*1024; /* must be 1 iframe at least. */
                                m_skipmode_m = bitrate / 8 / 90000 * m_cue->m_skipmode_ratio / 8;

-                               
+

                                if (m_cue->m_skipmode_ratio < 0)
                                        m_skipmode_m -= m_skipmode_n;
                                if (m_cue->m_skipmode_ratio < 0)
                                        m_skipmode_m -= m_skipmode_n;

-       
+

                                eDebug("resolved to: %d %d", m_skipmode_m, m_skipmode_n);
                                eDebug("resolved to: %d %d", m_skipmode_m, m_skipmode_n);

-                               
+

                                if (abs(m_skipmode_m) < abs(m_skipmode_n))
                                {
                                        eWarning("something is wrong with this calculation");
                                        m_skipmode_n = m_skipmode_m = 0;
                                }
                                if (abs(m_skipmode_m) < abs(m_skipmode_n))
                                {
                                        eWarning("something is wrong with this calculation");
                                        m_skipmode_n = m_skipmode_m = 0;
                                }

-                               

                        } else
                        {
                                eDebug("skipmode ratio is 0, normal play");
                                m_skipmode_n = m_skipmode_m = 0;
                        }
                }
                        } else
                        {
                                eDebug("skipmode ratio is 0, normal play");
                                m_skipmode_n = m_skipmode_m = 0;
                        }
                }

-               ASSERT(m_pvr_thread);

                m_pvr_thread->setIFrameSearch(m_skipmode_n != 0);
                m_pvr_thread->setIFrameSearch(m_skipmode_n != 0);

+               if (m_cue->m_skipmode_ratio != 0)
+                       m_pvr_thread->setTimebaseChange(0x10000 * 9000 / (m_cue->m_skipmode_ratio / 10)); /* negative values are also ok */
+               else
+                       m_pvr_thread->setTimebaseChange(0); /* normal playback */

                eDebug("flush pvr");
                flushPVR(m_cue->m_decoding_demux);
                eDebug("done");
                eDebug("flush pvr");
                flushPVR(m_cue->m_decoding_demux);
                eDebug("done");


@@ -1461,6 +1699,7 @@ void eCueSheet::clear()
 
 void eCueSheet::addSourceSpan(const pts_t &begin, const pts_t &end)
 {
 
 void eCueSheet::addSourceSpan(const pts_t &begin, const pts_t &end)
 {

+       assert(begin < end);

        m_lock.WrLock();
        m_spans.push_back(std::pair<pts_t, pts_t>(begin, end));
        m_lock.Unlock();
        m_lock.WrLock();
        m_spans.push_back(std::pair<pts_t, pts_t>(begin, end));
        m_lock.Unlock();