#include <lib/base/filepush.h>
#include <lib/dvb/idvb.h>
#include <lib/dvb/dvb.h>
+#include <lib/dvb/pmt.h>
#include <lib/dvb/sec.h>
#include <errno.h>
eDebug("found %d adapter, %d frontends and %d demux",
m_adapter.size(), m_frontend.size(), m_demux.size());
+ eDVBCAService::registerChannelCallback(this);
+
CONNECT(m_releaseCachedChannelTimer.timeout, eDVBResourceManager::releaseCachedChannel);
}
}
}
-void eDVBResourceManager::setFrontendSlotInformations(ePyObject list)
+PyObject *eDVBResourceManager::setFrontendSlotInformations(ePyObject list)
{
if (!PyList_Check(list))
{
PyErr_SetString(PyExc_StandardError, "eDVBResourceManager::setFrontendSlotInformations argument should be a python list");
- return;
+ return NULL;
}
- if (PyList_Size(list) != m_frontend.size())
+ if ((unsigned int)PyList_Size(list) != m_frontend.size())
{
char blasel[256];
sprintf(blasel, "eDVBResourceManager::setFrontendSlotInformations list size incorrect %d frontends avail, but %d entries in slotlist",
m_frontend.size(), PyList_Size(list));
PyErr_SetString(PyExc_StandardError, blasel);
- return;
+ return NULL;
}
int pos=0;
for (eSmartPtrList<eDVBRegisteredFrontend>::iterator i(m_frontend.begin()); i != m_frontend.end(); ++i)
{
ePyObject obj = PyList_GET_ITEM(list, pos++);
- i->m_frontend->setSlotInfo(obj);
+ if (!i->m_frontend->setSlotInfo(obj))
+ return NULL;
}
+ Py_RETURN_NONE;
}
RESULT eDVBResourceManager::allocateFrontend(ePtr<eDVBAllocatedFrontend> &fe, ePtr<iDVBFrontendParameters> &feparm)
{
ePtr<eDVBRegisteredFrontend> best;
int bestval = 0;
+ int foundone = 0;
for (eSmartPtrList<eDVBRegisteredFrontend>::iterator i(m_frontend.begin()); i != m_frontend.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;
+
if (!i->m_inuse)
{
- int c = i->m_frontend->isCompatibleWith(feparm);
if (c > bestval)
{
bestval = c;
best = i;
}
}
+ }
if (best)
{
fe = new eDVBAllocatedFrontend(best);
return 0;
}
-
+
fe = 0;
-
- return -1;
+
+ if (foundone)
+ return errAllSourcesBusy;
+ else
+ return errNoSourceFound;
}
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
+ eDVBRegisteredFrontend *satpos_depends_to_fe =
+ (eDVBRegisteredFrontend*) i->m_frontend->m_data[eDVBFrontend::SATPOS_DEPENDS_PTR];
+ if ( (int)satpos_depends_to_fe != -1 )
+ {
+ 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
+ {
+ eDVBRegisteredFrontend *next =
+ (eDVBRegisteredFrontend *) i->m_frontend->m_data[eDVBFrontend::LINKED_NEXT_PTR];
+ while ( (int)next != -1 )
+ {
+ 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];
+ }
+ eDVBRegisteredFrontend *prev = (eDVBRegisteredFrontend *)
+ i->m_frontend->m_data[eDVBFrontend::LINKED_PREV_PTR];
+ while ( (int)prev != -1 )
+ {
+ 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];
+ }
+ }
fe = new eDVBAllocatedFrontend(i);
return 0;
}
-
+alloc_fe_by_id_not_possible:
fe = 0;
- return -1;
+ return err;
}
RESULT eDVBResourceManager::allocateDemux(eDVBRegisteredFrontend *fe, ePtr<eDVBAllocatedDemux> &demux, int cap)
if (!m_list)
{
eDebug("no channel list set!");
- return -ENOENT;
+ return errNoChannelList;
}
ePtr<iDVBFrontendParameters> feparm;
if (m_list->getChannelFrontendData(channelid, feparm))
{
eDebug("channel not found!");
- return -ENOENT;
+ return errChannelNotInList;
}
/* allocate a frontend. */
ePtr<eDVBAllocatedFrontend> fe;
-
- if (allocateFrontend(fe, feparm))
- return errNoFrontend;
+
+ int err = allocateFrontend(fe, feparm);
+ if (err)
+ return err;
RESULT res;
ePtr<eDVBChannel> ch;
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);
if (c > bestval)
bestval = c;
}
-
return bestval;
}
+int tuner_type_channel_default(ePtr<iDVBChannelList> &channellist, const eDVBChannelID &chid)
+{
+ if (channellist)
+ {
+ ePtr<iDVBFrontendParameters> feparm;
+ if (!channellist->getChannelFrontendData(chid, feparm))
+ {
+ int system;
+ if (!feparm->getSystem(system))
+ {
+ switch(system)
+ {
+ case iDVBFrontend::feSatellite:
+ return 50000;
+ case iDVBFrontend::feCable:
+ return 40000;
+ case iDVBFrontend::feTerrestrial:
+ return 30000;
+ default:
+ break;
+ }
+ }
+ }
+ }
+ return 0;
+}
+
int eDVBResourceManager::canAllocateChannel(const eDVBChannelID &channelid, const eDVBChannelID& ignore)
{
- int ret=30000;
+ int ret=0;
if (m_cached_channel)
{
eDVBChannel *cache_chan = (eDVBChannel*)&(*m_cached_channel);
if(channelid==cache_chan->getChannelID())
- return ret;
+ return tuner_type_channel_default(m_list, channelid);
}
/* first, check if a channel is already existing. */
if (i->m_channel_id == channelid)
{
// eDebug("found shared channel..");
- return ret;
+ return tuner_type_channel_default(m_list, channelid);
}
}
if (!m_list)
{
eDebug("no channel list set!");
- ret = 0;
goto error;
}
if (m_list->getChannelFrontendData(channelid, feparm))
{
eDebug("channel not found!");
- ret = 0;
goto error;
}
case eCueSheet::evtSkipmode:
{
{
- eSingleLocker l(m_cue->m_lock);
+ m_cue->m_lock.WrLock();
m_cue->m_seek_requests.push_back(std::pair<int, pts_t>(1, 0)); /* resync */
+ m_cue->m_lock.Unlock();
+ eRdLocker l(m_cue->m_lock);
if (m_cue->m_skipmode_ratio)
{
int bitrate = m_tstools.calcBitrate(); /* in bits/s */
m_skipmode_n = m_skipmode_m = 0;
}
}
+ ASSERT(m_pvr_thread);
m_pvr_thread->setIFrameSearch(m_skipmode_n != 0);
eDebug("flush pvr");
flushPVR(m_cue->m_decoding_demux);
return;
}
- eSingleLocker l(m_cue->m_lock);
-
+ m_cue->m_lock.RdLock();
if (!m_cue->m_decoding_demux)
{
start = current_offset;
size = max;
eDebug("getNextSourceSpan, no decoding demux. forcing normal play");
+ m_cue->m_lock.Unlock();
return;
}
while (!m_cue->m_seek_requests.empty())
{
std::pair<int, pts_t> seek = m_cue->m_seek_requests.front();
+ m_cue->m_lock.Unlock();
+ m_cue->m_lock.WrLock();
m_cue->m_seek_requests.pop_front();
+ m_cue->m_lock.Unlock();
+ m_cue->m_lock.RdLock();
int relative = seek.first;
pts_t pts = seek.second;
pts_t nextap;
if (m_tstools.getNextAccessPoint(nextap, now, pts))
{
- pts = now;
+ pts = now - 90000; /* approx. 1s */
eDebug("AP relative seeking failed!");
} else
{
current_offset = align(offset, blocksize); /* in case tstools return non-aligned offset */
}
+ m_cue->m_lock.Unlock();
+
for (std::list<std::pair<off_t, off_t> >::const_iterator i(m_source_span.begin()); i != m_source_span.end(); ++i)
{
long long aligned_start = align(i->first, blocksize);
{
/* in normal playback, just start at the next zone. */
start = i->first;
-
+
/* size is not 64bit! */
if ((i->second - i->first) > max)
size = max;
--i;
eDebug("skip to previous block, which is %llx..%llx", i->first, i->second);
size_t len;
-
- if ((i->second - i->first) > max)
+
+ aligned_start = align(i->first, blocksize);
+ aligned_end = align(i->second, blocksize);
+
+ if ((aligned_end - aligned_start) > max)
len = max;
else
len = aligned_end - aligned_start;
start = aligned_end - len;
eDebug("skipping to %llx, %d", start, len);
}
-
+
eDebug("result: %llx, %x (%llx %llx)", start, size, aligned_start, aligned_end);
return;
}
}
-
+
if ((current_offset < -m_skipmode_m) && (m_skipmode_m < 0))
{
eDebug("reached SOF");
m_skipmode_m = 0;
m_pvr_thread->sendEvent(eFilePushThread::evtUser);
}
-
+
start = current_offset;
size = max;
void eCueSheet::seekTo(int relative, const pts_t &pts)
{
- {
- eSingleLocker l(m_lock);
- m_seek_requests.push_back(std::pair<int, pts_t>(relative, pts));
- }
+ m_lock.WrLock();
+ m_seek_requests.push_back(std::pair<int, pts_t>(relative, pts));
+ m_lock.Unlock();
m_event(evtSeek);
}
void eCueSheet::clear()
{
- eSingleLocker l(m_lock);
+ m_lock.WrLock();
m_spans.clear();
+ m_lock.Unlock();
}
void eCueSheet::addSourceSpan(const pts_t &begin, const pts_t &end)
{
- {
- eSingleLocker l(m_lock);
- m_spans.push_back(std::pair<pts_t, pts_t>(begin, end));
- }
+ m_lock.WrLock();
+ m_spans.push_back(std::pair<pts_t, pts_t>(begin, end));
+ m_lock.Unlock();
}
void eCueSheet::commitSpans()
void eCueSheet::setSkipmode(const pts_t &ratio)
{
- {
- eSingleLocker l(m_lock);
- m_skipmode_ratio = ratio;
- }
+ m_lock.WrLock();
+ m_skipmode_ratio = ratio;
+ m_lock.Unlock();
m_event(evtSkipmode);
}