#include <lib/dvb/dvb.h>
#include <lib/dvb/pmt.h>
#include <lib/dvb/sec.h>
+#include <lib/dvb/specs.h>
#include <errno.h>
#include <sys/types.h>
}
eDVBResourceManager::eDVBResourceManager()
- :m_releaseCachedChannelTimer(eApp)
+ :m_releaseCachedChannelTimer(eTimer::create(eApp))
{
avail = 1;
busy = 0;
- m_sec = new eDVBSatelliteEquipmentControl(m_frontend);
+ m_sec = new eDVBSatelliteEquipmentControl(m_frontend, m_simulate_frontend);
+
if (!instance)
instance = this;
-
+
/* search available adapters... */
// add linux devices
-
+
int num_adapter = 0;
while (eDVBAdapterLinux::exist(num_adapter))
{
addAdapter(new eDVBAdapterLinux(num_adapter));
num_adapter++;
}
-
- eDebug("found %d adapter, %d frontends and %d demux",
- m_adapter.size(), m_frontend.size(), m_demux.size());
+
+ int fd = open("/proc/stb/info/model", O_RDONLY);
+ char tmp[255];
+ int rd = fd >= 0 ? read(fd, tmp, 255) : 0;
+ if (fd >= 0)
+ close(fd);
+
+ if (!strncmp(tmp, "dm7025\n", rd))
+ m_boxtype = DM7025;
+ else if (!strncmp(tmp, "dm8000\n", rd))
+ m_boxtype = DM8000;
+ else if (!strncmp(tmp, "dm800\n", rd))
+ m_boxtype = DM800;
+ else if (!strncmp(tmp, "dm500hd\n", rd))
+ m_boxtype = DM500HD;
+ else {
+ eDebug("boxtype detection via /proc/stb/info not possible... use fallback via demux count!\n");
+ if (m_demux.size() == 3)
+ m_boxtype = DM800;
+ else if (m_demux.size() < 5)
+ m_boxtype = DM7025;
+ else
+ m_boxtype = DM8000;
+ }
+
+ eDebug("found %d adapter, %d frontends(%d sim) and %d demux, boxtype %d",
+ m_adapter.size(), m_frontend.size(), m_simulate_frontend.size(), m_demux.size(), m_boxtype);
eDVBCAService::registerChannelCallback(this);
- CONNECT(m_releaseCachedChannelTimer.timeout, eDVBResourceManager::releaseCachedChannel);
+ CONNECT(m_releaseCachedChannelTimer->timeout, eDVBResourceManager::releaseCachedChannel);
}
void eDVBResourceManager::feStateChanged()
{
// scan frontends
int num_fe = 0;
-
+
eDebug("scanning for frontends..");
while (1)
{
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;
}
-
+
// scan demux
int num_demux = 0;
while (1)
if (stat(filename, &s))
break;
ePtr<eDVBDemux> demux;
-
+
demux = new eDVBDemux(m_nr, num_demux);
m_demux.push_back(demux);
-
+
++num_demux;
}
}
--nr;
++i;
}
-
+
if (i != m_demux.end())
demux = *i;
else
return -1;
-
+
return 0;
}
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;
++i;
}
-
+
if (i != m_frontend.end())
fe = *i;
else
return -1;
-
+
return 0;
}
{
int num_fe = adapter->getNumFrontends();
int num_demux = adapter->getNumDemux();
-
+
m_adapter.push_back(adapter);
-
+
int i;
for (i=0; i<num_demux; ++i)
{
}
}
}
+
+ 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;
+ }
+ }
+ }
+
}
PyObject *eDVBResourceManager::setFrontendSlotInformations(ePyObject list)
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;
}
-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;
int foundone = 0;
- for (eSmartPtrList<eDVBRegisteredFrontend>::iterator i(m_frontend.begin()); i != m_frontend.end(); ++i)
+ for (eSmartPtrList<eDVBRegisteredFrontend>::iterator i(frontends.begin()); i != frontends.end(); ++i)
{
int c = i->m_frontend->isCompatibleWith(feparm);
if (!i->m_inuse)
{
+// eDebug("Slot %d, score %d", i->m_frontend->getSlotID(), c);
if (c > bestval)
{
bestval = c;
best = i;
}
}
+// else
+// eDebug("Slot %d, score %d... but BUSY!!!!!!!!!!!", i->m_frontend->getSlotID(), c);
}
if (best)
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 ( (long)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!");
}
else // check linked tuners
{
- eDVBRegisteredFrontend *next =
- (eDVBRegisteredFrontend *) i->m_frontend->m_data[eDVBFrontend::LINKED_NEXT_PTR];
- while ( (long)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!");
err = errAllSourcesBusy;
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 ( (long)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!");
err = errAllSourcesBusy;
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);
return err;
}
-RESULT eDVBResourceManager::allocateDemux(eDVBRegisteredFrontend *fe, ePtr<eDVBAllocatedDemux> &demux, int cap)
+#define capHoldDecodeReference 64
+
+RESULT eDVBResourceManager::allocateDemux(eDVBRegisteredFrontend *fe, ePtr<eDVBAllocatedDemux> &demux, int &cap)
{
/* find first unused demux which is on same adapter as frontend (or any, if PVR)
never use the first one unless we need a decoding demux. */
eDebug("allocate demux");
eSmartPtrList<eDVBRegisteredDemux>::iterator i(m_demux.begin());
-
+
+ int n=0;
+
if (i == m_demux.end())
return -1;
-
- int n=0;
- /* FIXME: hardware demux policy */
- if (!(cap & iDVBChannel::capDecode))
+
+ ePtr<eDVBRegisteredDemux> unused;
+
+ if (m_boxtype == DM800 || m_boxtype == DM500HD) // dm800 / 500hd
+ {
+ cap |= capHoldDecodeReference; // this is checked in eDVBChannel::getDemux
+ for (; i != m_demux.end(); ++i, ++n)
+ {
+ if (!i->m_inuse)
+ {
+ if (!unused)
+ unused = i;
+ }
+ else
+ {
+ if (fe)
+ {
+ if (i->m_adapter == fe->m_adapter &&
+ i->m_demux->getSource() == fe->m_frontend->getDVBID())
+ {
+ demux = new eDVBAllocatedDemux(i);
+ return 0;
+ }
+ }
+ else if (i->m_demux->getSource() == -1) // PVR
+ {
+ demux = new eDVBAllocatedDemux(i);
+ return 0;
+ }
+ }
+ }
+ }
+ else if (m_boxtype == DM7025) // ATI
{
- 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;
+
+ int in_use = is_decode ? (i->m_demux->getRefCount() != 2) : i->m_inuse;
+
+ if ((!in_use) && ((!fe) || (i->m_adapter == fe->m_adapter)))
+ {
+ if ((cap & iDVBChannel::capDecode) && !is_decode)
+ continue;
+ unused = i;
+ break;
+ }
}
}
-
- for (; i != m_demux.end(); ++i, ++n)
+ else if (m_boxtype == DM8000)
{
- int is_decode = n < 2;
-
- int in_use = is_decode ? (i->m_demux->getRefCount() != 2) : i->m_inuse;
-
- if ((!in_use) && ((!fe) || (i->m_adapter == fe->m_adapter)))
+ cap |= capHoldDecodeReference; // this is checked in eDVBChannel::getDemux
+ for (; i != m_demux.end(); ++i, ++n)
{
- if ((cap & iDVBChannel::capDecode) && !is_decode)
- continue;
-
- demux = new eDVBAllocatedDemux(i);
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;
}
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. */
+ 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())
}
m_cached_channel_state_changed_conn.disconnect();
m_cached_channel=0;
- 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)
{
-// eDebug("found shared channel..");
+ eDebugNoSimulate("found shared channel..");
channel = i->m_channel;
return 0;
}
}
-
+
/* no currently available channel is tuned to this channelid. create a new one, if possible. */
if (!m_list)
{
- eDebug("no channel list set!");
+ eDebugNoSimulate("no channel list set!");
return errNoChannelList;
}
ePtr<iDVBFrontendParameters> feparm;
if (m_list->getChannelFrontendData(channelid, feparm))
{
- eDebug("channel not found!");
+ eDebugNoSimulate("channel not found!");
return errChannelNotInList;
}
/* allocate a frontend. */
-
+
ePtr<eDVBAllocatedFrontend> fe;
- int err = allocateFrontend(fe, feparm);
+ int err = allocateFrontend(fe, feparm, simulate);
if (err)
return err;
RESULT res;
- ePtr<eDVBChannel> ch;
- ch = new eDVBChannel(this, fe);
+ ePtr<eDVBChannel> ch = new eDVBChannel(this, fe);
res = ch->setChannel(channelid, feparm);
if (res)
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;
}
case iDVBChannel::state_ok:
{
eDebug("stop release channel timer");
- m_releaseCachedChannelTimer.stop();
+ m_releaseCachedChannelTimer->stop();
break;
}
case iDVBChannel::state_last_instance:
{
eDebug("start release channel timer");
- m_releaseCachedChannelTimer.start(3000, true);
+ m_releaseCachedChannelTimer->start(3000, true);
break;
}
default: // ignore all other events
{
m_cached_channel_state_changed_conn.disconnect();
m_cached_channel=0;
- m_releaseCachedChannelTimer.stop();
+ m_releaseCachedChannelTimer->stop();
}
int err = allocateFrontendByIndex(fe, slot_index);
if (err)
return err;
- eDVBChannel *ch;
- ch = new eDVBChannel(this, fe);
-
- channel = ch;
+ channel = new eDVBChannel(this, fe);
return 0;
}
{
ePtr<eDVBAllocatedDemux> demux;
- if (m_cached_channel && m_releaseCachedChannelTimer.isActive())
+ if (m_cached_channel && m_releaseCachedChannelTimer->isActive())
{
m_cached_channel_state_changed_conn.disconnect();
m_cached_channel=0;
- m_releaseCachedChannelTimer.stop();
+ m_releaseCachedChannelTimer->stop();
}
- eDVBChannel *ch;
- ch = new eDVBChannel(this, 0);
-
- channel = ch;
+ channel = new eDVBChannel(this, 0);
return 0;
}
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)
{
- 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 0;
}
-int eDVBResourceManager::canAllocateFrontend(ePtr<iDVBFrontendParameters> &feparm)
+int eDVBResourceManager::canAllocateFrontend(ePtr<iDVBFrontendParameters> &feparm, bool simulate)
{
+ eSmartPtrList<eDVBRegisteredFrontend> &frontends = simulate ? m_simulate_frontend : m_frontend;
ePtr<eDVBRegisteredFrontend> best;
int bestval = 0;
- for (eSmartPtrList<eDVBRegisteredFrontend>::iterator i(m_frontend.begin()); i != m_frontend.end(); ++i)
+ for (eSmartPtrList<eDVBRegisteredFrontend>::iterator i(frontends.begin()); i != frontends.end(); ++i)
if (!i->m_inuse)
{
int c = i->m_frontend->isCompatibleWith(feparm);
return 0;
}
-int eDVBResourceManager::canAllocateChannel(const eDVBChannelID &channelid, const eDVBChannelID& ignore)
+int eDVBResourceManager::canAllocateChannel(const eDVBChannelID &channelid, const eDVBChannelID& ignore, bool simulate)
{
+ std::list<active_channel> &active_channels = simulate ? m_active_simulate_channels : m_active_channels;
int ret=0;
- if (m_cached_channel)
+ if (!simulate && m_cached_channel)
{
eDVBChannel *cache_chan = (eDVBChannel*)&(*m_cached_channel);
if(channelid==cache_chan->getChannelID())
/* first, check if a channel is already existing. */
// 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)
+ 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());
if (i->m_channel_id == channelid)
int *decremented_cached_channel_fe_usecount=NULL,
*decremented_fe_usecount=NULL;
- for (std::list<active_channel>::iterator i(m_active_channels.begin()); i != m_active_channels.end(); ++i)
+ for (std::list<active_channel>::iterator i(active_channels.begin()); i != active_channels.end(); ++i)
{
+ eSmartPtrList<eDVBRegisteredFrontend> &frontends = simulate ? m_simulate_frontend : m_frontend;
// eDebug("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 == ignore)
{
ePtr<iDVBFrontend> fe;
if (!i->m_channel->getFrontend(fe))
{
- for (eSmartPtrList<eDVBRegisteredFrontend>::iterator ii(m_frontend.begin()); ii != m_frontend.end(); ++ii)
+ for (eSmartPtrList<eDVBRegisteredFrontend>::iterator ii(frontends.begin()); ii != frontends.end(); ++ii)
{
if ( &(*fe) == &(*ii->m_frontend) )
{
ePtr<iDVBFrontend> fe;
if (!channel->getFrontend(fe))
{
- for (eSmartPtrList<eDVBRegisteredFrontend>::iterator ii(m_frontend.begin()); ii != m_frontend.end(); ++ii)
+ eSmartPtrList<eDVBRegisteredFrontend> &frontends = simulate ? m_simulate_frontend : m_frontend;
+ for (eSmartPtrList<eDVBRegisteredFrontend>::iterator ii(frontends.begin()); ii != frontends.end(); ++ii)
{
if ( &(*fe) == &(*ii->m_frontend) )
{
goto error;
}
- ret = canAllocateFrontend(feparm);
+ ret = canAllocateFrontend(feparm, simulate);
error:
if (decremented_fe_usecount)
}
#endif
-#if 1 /* not yet */
+#if 0
if (!m_iframe_search)
return len;
// 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)))
+ while ((d + 3 < data + len) && (d = (unsigned char*)memmem(d, data + len - d, "\x00\x00\x01", 3)))
{
int offset = d - data;
int ts_offset = offset - offset % 188; /* offset to the start of TS packet */
unsigned char *ts = data + ts_offset;
int pid = ((ts[1] << 8) | ts[2]) & 0x1FFF;
- if ((d[3] == 0) && (m_pid == pid)) /* picture start */
+ if ((d[3] == 0 || d[3] == 0x09 && d[-1] == 0 && (ts[1] & 0x40)) && (m_pid == pid)) /* picture start */
{
- int picture_type = (d[5] >> 3) & 7;
+ int picture_type = (d[3]==0 ? (d[5] >> 3) & 7 : (d[4] >> 5) + 1);
d += 4;
// eDebug("%d-frame at %d, offset in TS packet: %d, pid=%04x", picture_type, offset, offset % 188, pid);
if (m_iframe_state == 1)
{
- /* we are allowing data, and stop allowing data on the next frame.
+ /* we are allowing data, and stop allowing data on the next frame.
we now found a frame. so stop here. */
memset(data + offset, 0, 188 - (offset%188)); /* zero out rest of TS packet */
current_span_remaining = 0;
fts += 188;
}
- /* force payload only */
- ts[3] &= ~0x30;
- ts[3] |= 0x10;
-
-// memset(ts + 4, 0xFF, (offset % 188) - 4);
m_iframe_state = 1;
}
} else if ((d[3] & 0xF0) == 0xE0) /* video stream */
{
- if (m_pid != pid)
+ /* verify that this is actually a PES header, not just some ES data */
+ if (ts[1] & 0x40) /* PUSI set */
{
- eDebug("now locked to pid %04x", pid);
- m_pid = pid;
+ int payload_start = 4;
+ if (ts[3] & 0x20) /* adaptation field present */
+ payload_start += ts[4] + 1; /* skip AF */
+ if (payload_start == (offset%188)) /* the 00 00 01 should be directly at the payload start, otherwise it's not a PES header */
+ {
+ if (m_pid != pid)
+ {
+ eDebug("now locked to pid %04x (%02x %02x %02x %02x)", pid, ts[0], ts[1], ts[2], ts[3]);
+ m_pid = pid;
+ }
+ }
}
// m_pid = 0x6e;
d += 4;
} else
d += 4; /* ignore */
-
}
if (m_iframe_state == 1)
m_frontend = frontend;
m_pvr_thread = 0;
-
- m_skipmode_n = m_skipmode_m = 0;
-
+ m_pvr_fd_dst = -1;
+
+ m_skipmode_n = m_skipmode_m = m_skipmode_frames = 0;
+
if (m_frontend)
m_frontend->get().connectStateChange(slot(*this, &eDVBChannel::frontendStateChanged), m_conn_frontendStateChanged);
}
void eDVBChannel::frontendStateChanged(iDVBFrontend*fe)
{
int state, ourstate = 0;
-
+
/* if we are already in shutdown, don't change state. */
if (m_state == state_release)
return;
-
+
if (fe->getState(state))
return;
-
+
if (state == iDVBFrontend::stateLock)
{
eDebug("OURSTATE: ok");
ourstate = state_failed;
} else
eFatal("state unknown");
-
+
if (ourstate != m_state)
{
m_state = ourstate;
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:
/* 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;
+ m_skipmode_frames = m_cue->m_skipmode_ratio / 90000;
+ m_skipmode_frames_remainder = 0;
if (m_cue->m_skipmode_ratio < 0)
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;
+ m_skipmode_frames = m_skipmode_n = m_skipmode_m = 0;
}
} else
{
eDebug("skipmode ratio is 0, normal play");
- m_skipmode_n = m_skipmode_m = 0;
+ m_skipmode_frames = m_skipmode_n = m_skipmode_m = 0;
}
}
- ASSERT(m_pvr_thread);
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 */
{
off_t offset_in, offset_out;
pts_t pts_in = i->first, pts_out = i->second;
- if (m_tstools.getOffset(offset_in, pts_in) || m_tstools.getOffset(offset_out, pts_out))
+ if (m_tstools.getOffset(offset_in, pts_in, -1) || m_tstools.getOffset(offset_out, pts_out, 1))
{
eDebug("span translation failed.\n");
continue;
x -= x % align;
+ if (sign)
+ x = -x;
+
+ return x;
+}
+
+ /* align toward zero */
+static inline long long align_with_len(long long x, int align, size_t &len)
+{
+ int sign = x < 0;
+
+ if (sign)
+ x = -x;
+
+ x -= x % align;
+ len += x % align;
+
if (sign)
x = -x;
const int blocksize = 188;
unsigned int max = align(10*1024*1024, blocksize);
current_offset = align(current_offset, blocksize);
-
+
if (!m_cue)
{
eDebug("no cue sheet. forcing normal play");
if (m_skipmode_n)
{
- eDebug("skipmode %d:%d", m_skipmode_m, m_skipmode_n);
+ eDebug("skipmode %d:%d (x%d)", m_skipmode_m, m_skipmode_n, m_skipmode_frames);
max = align(m_skipmode_n, blocksize);
}
eDebug("getNextSourceSpan, current offset is %08llx, m_skipmode_m = %d!", current_offset, m_skipmode_m);
+
+ int frame_skip_success = 0;
- current_offset += align(m_skipmode_m, blocksize);
+ if (m_skipmode_m)
+ {
+ int frames_to_skip = m_skipmode_frames + m_skipmode_frames_remainder;
+ eDebug("we are at %llx, and we try to skip %d+%d frames from here", current_offset, m_skipmode_frames, m_skipmode_frames_remainder);
+ size_t iframe_len;
+ off_t iframe_start = current_offset;
+ int frames_skipped = frames_to_skip;
+ if (!m_tstools.findNextPicture(iframe_start, iframe_len, frames_skipped))
+ {
+ m_skipmode_frames_remainder = frames_to_skip - frames_skipped;
+ eDebug("successfully skipped %d (out of %d, rem now %d) frames.", frames_skipped, frames_to_skip, m_skipmode_frames_remainder);
+ current_offset = align_with_len(iframe_start, blocksize, iframe_len);
+ max = align(iframe_len + 187, blocksize);
+ frame_skip_success = 1;
+ } else
+ {
+ m_skipmode_frames_remainder = 0;
+ eDebug("frame skipping failed, reverting to byte-skipping");
+ }
+ }
+
+ if (!frame_skip_success)
+ {
+ current_offset += align(m_skipmode_m, blocksize);
+
+ if (m_skipmode_m)
+ {
+ eDebug("we are at %llx, and we try to find the iframe here:", current_offset);
+ size_t iframe_len;
+ off_t iframe_start = current_offset;
+
+ int direction = (m_skipmode_m < 0) ? -1 : +1;
+ if (m_tstools.findFrame(iframe_start, iframe_len, direction))
+ eDebug("failed");
+ else
+ {
+ current_offset = align_with_len(iframe_start, blocksize, iframe_len);
+ max = align(iframe_len, blocksize);
+ }
+ }
+ }
while (!m_cue->m_seek_requests.empty())
{
continue;
}
}
-
+
if (relative == 1) /* pts relative */
{
pts += now;
if (relative != 2)
if (pts < 0)
pts = 0;
-
+
if (relative == 2) /* AP relative */
{
eDebug("AP relative seeking: %lld, at %lld", pts, now);
eDebug("AP relative seeking failed!");
} else
{
- eDebug("next ap is %llx\n", pts);
pts = nextap;
+ eDebug("next ap is %llx\n", pts);
}
}
-
+
off_t offset = 0;
- if (m_tstools.getOffset(offset, pts))
+ if (m_tstools.getOffset(offset, pts, -1))
{
eDebug("get offset for pts=%lld failed!", pts);
continue;
}
+
+ size_t iframe_len;
+ /* try to align to iframe */
+ int direction = pts < 0 ? -1 : 1;
+ m_tstools.findFrame(offset, iframe_len, direction);
- eDebug("ok, resolved skip (rel: %d, diff %lld), now at %08llx", relative, pts, offset);
+ eDebug("ok, resolved skip (rel: %d, diff %lld), now at %08llx (skipped additional %d frames due to iframe re-align)", relative, pts, offset, direction);
current_offset = align(offset, blocksize); /* in case tstools return non-aligned offset */
}
{
long long aligned_start = align(i->first, blocksize);
long long aligned_end = align(i->second, blocksize);
-
+
if ((current_offset >= aligned_start) && (current_offset < aligned_end))
{
start = current_offset;
m_pvr_thread->sendEvent(eFilePushThread::evtUser);
}
- start = current_offset;
- size = max;
-
- eDebug("END OF CUESHEET. (%08llx, %d)", start, size);
+ if (m_source_span.empty())
+ {
+ start = current_offset;
+ size = max;
+ eDebug("NO CUESHEET. (%08llx, %d)", start, size);
+ } else
+ {
+ start = current_offset;
+ size = 0;
+ }
return;
}
{
if (m_channel_id)
m_mgr->removeChannel(this);
-
+
if (!channelid)
return 0;
eDebug("no frontend to tune!");
return -ENODEV;
}
-
+
m_channel_id = channelid;
m_mgr->addChannel(channelid, this);
m_state = state_tuning;
int res;
res = m_frontend->get().tune(*feparm);
m_current_frontend_parameters = feparm;
-
+
if (res)
{
m_state = state_release;
m_stateChanged(this);
return res;
}
-
+
return 0;
}
return -1;
}
+void eDVBChannel::SDTready(int result)
+{
+ ePyObject args = PyTuple_New(2), ret;
+ bool ok=false;
+ if (!result)
+ {
+ for (std::vector<ServiceDescriptionSection*>::const_iterator i = m_SDT->getSections().begin(); i != m_SDT->getSections().end(); ++i)
+ {
+ ok = true;
+ PyTuple_SET_ITEM(args, 0, PyInt_FromLong((*i)->getTransportStreamId()));
+ PyTuple_SET_ITEM(args, 1, PyInt_FromLong((*i)->getOriginalNetworkId()));
+ break;
+ }
+ }
+ if (!ok)
+ {
+ PyTuple_SET_ITEM(args, 0, Py_None);
+ PyTuple_SET_ITEM(args, 1, Py_None);
+ Py_INCREF(Py_None);
+ Py_INCREF(Py_None);
+ }
+ ret = PyObject_CallObject(m_tsid_onid_callback, args);
+ if (ret)
+ Py_DECREF(ret);
+ Py_DECREF(args);
+ Py_DECREF(m_tsid_onid_callback);
+ m_tsid_onid_callback = ePyObject();
+ m_tsid_onid_demux = 0;
+ m_SDT = 0;
+}
+
+RESULT eDVBChannel::requestTsidOnid(ePyObject callback)
+{
+ if (PyCallable_Check(callback))
+ {
+ if (!getDemux(m_tsid_onid_demux, 0))
+ {
+ m_SDT = new eTable<ServiceDescriptionSection>;
+ CONNECT(m_SDT->tableReady, eDVBChannel::SDTready);
+ if (m_SDT->start(m_tsid_onid_demux, eDVBSDTSpec()))
+ {
+ m_tsid_onid_demux = 0;
+ m_SDT = 0;
+ }
+ else
+ {
+ Py_INCREF(callback);
+ m_tsid_onid_callback = callback;
+ return 0;
+ }
+ }
+ }
+ return -1;
+}
+
RESULT eDVBChannel::getDemux(ePtr<iDVBDemux> &demux, int cap)
{
ePtr<eDVBAllocatedDemux> &our_demux = (cap & capDecode) ? m_decoder_demux : m_demux;
-
+
if (!our_demux)
{
demux = 0;
-
+
if (m_mgr->allocateDemux(m_frontend ? (eDVBRegisteredFrontend*)*m_frontend : (eDVBRegisteredFrontend*)0, our_demux, cap))
return -1;
- }
-
- demux = *our_demux;
+
+ demux = *our_demux;
+
/* don't hold a reference to the decoding demux, we don't need it. */
-
+
/* FIXME: by dropping the 'allocated demux' in favour of the 'iDVBDemux',
- the refcount is lost. thus, decoding demuxes are never allocated.
-
+ the refcount is lost. thus, decoding demuxes are never allocated.
+
this poses a big problem for PiP. */
- if (cap & capDecode)
- our_demux = 0;
+
+ if (cap & capHoldDecodeReference) // this is set in eDVBResourceManager::allocateDemux for Dm500HD/DM800 and DM8000
+ ;
+ else if (cap & capDecode)
+ our_demux = 0;
+ }
+ else
+ demux = *our_demux;
+
return 0;
}
delete m_pvr_thread;
m_pvr_thread = 0;
}
-
+
m_tstools.openFile(file);
-
+
/* DON'T EVEN THINK ABOUT FIXING THIS. FIX THE ATI SOURCES FIRST,
THEN DO A REAL FIX HERE! */
-
+
+ if (m_pvr_fd_dst < 0)
+ {
/* (this codepath needs to be improved anyway.) */
#if HAVE_DVB_API_VERSION < 3
- m_pvr_fd_dst = open("/dev/pvr", O_WRONLY);
+ m_pvr_fd_dst = open("/dev/pvr", O_WRONLY);
#else
- m_pvr_fd_dst = open("/dev/misc/pvr", O_WRONLY);
+ m_pvr_fd_dst = open("/dev/misc/pvr", O_WRONLY);
#endif
- if (m_pvr_fd_dst < 0)
- {
- eDebug("can't open /dev/misc/pvr - you need to buy the new(!) $$$ box! (%m)"); // or wait for the driver to be improved.
- return -ENODEV;
+ if (m_pvr_fd_dst < 0)
+ {
+ eDebug("can't open /dev/misc/pvr - you need to buy the new(!) $$$ box! (%m)"); // or wait for the driver to be improved.
+ return -ENODEV;
+ }
}
m_pvr_thread = new eDVBChannelFilePush();
{
delete m_pvr_thread;
m_pvr_thread = 0;
+ ::close(m_pvr_fd_dst);
+ m_pvr_fd_dst = -1;
eDebug("can't open PVR file %s (%m)", file);
return -ENOENT;
}
if (m_pvr_thread)
{
m_pvr_thread->stop();
- ::close(m_pvr_fd_dst);
delete m_pvr_thread;
m_pvr_thread = 0;
}
+ if (m_pvr_fd_dst >= 0)
+ ::close(m_pvr_fd_dst);
}
void eDVBChannel::setCueSheet(eCueSheet *cuesheet)
{
if (!decoding_demux)
return -1;
-
+
pts_t now;
-
+
int r;
-
+
if (mode == 0) /* demux */
{
r = decoding_demux->getSTC(now, 0);
}
} else
now = pos; /* fixup supplied */
-
+
off_t off = 0; /* TODO: fixme */
r = m_tstools.fixupPTS(off, now);
if (r)
eDebug("fixup PTS failed");
return -1;
}
-
+
pos = now;
-
+
return 0;
}
a.) the filepush's internal buffer
b.) the PVR buffer (before demux)
c.) the ratebuffer (after demux)
-
+
it's important to clear them in the correct order, otherwise
the ratebuffer (for example) would immediately refill from
the not-yet-flushed PVR buffer.
m_pvr_thread->flush();
/* HACK: flush PVR buffer */
::ioctl(m_pvr_fd_dst, 0);
-
+
/* flush ratebuffers (video, audio) */
if (decoding_demux)
decoding_demux->flush();
m_lock.Unlock();
m_event(evtSeek);
}
-
+
void eCueSheet::clear()
{
m_lock.WrLock();
void eCueSheet::addSourceSpan(const pts_t &begin, const pts_t &end)
{
- assert(begin < end);
+ ASSERT(begin < end);
m_lock.WrLock();
m_spans.push_back(std::pair<pts_t, pts_t>(begin, end));
m_lock.Unlock();
git.cweiske.de / enigma2.git / blobdiff