num_adapter++;
}
- eDebug("found %d adapter, %d frontends(%d sim) and %d demux",
- m_adapter.size(), m_frontend.size(), m_simulate_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 if (!strncmp(tmp, "dm800se\n", rd))
+ m_boxtype = DM800SE;
+ else if (!strncmp(tmp, "dm7020hd\n", rd))
+ m_boxtype = DM7020HD;
+ 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 %zd adapter, %zd frontends(%zd sim) and %zd demux, boxtype %d",
+ m_adapter.size(), m_frontend.size(), m_simulate_frontend.size(), m_demux.size(), m_boxtype);
eDVBCAService::registerChannelCallback(this);
#endif
if (stat(filename, &s))
break;
- ePtr<eDVBFrontend> fe;
+ eDVBFrontend *fe;
{
int ok = 0;
- fe = new eDVBFrontend(m_nr, num_fe, ok);
+ fe = new eDVBFrontend(m_nr, num_fe, ok, true);
if (ok)
- m_frontend.push_back(fe);
+ m_simulate_frontend.push_back(ePtr<eDVBFrontend>(fe));
}
+
{
int ok = 0;
- fe = new eDVBFrontend(m_nr, num_fe, ok, true);
+ fe = new eDVBFrontend(m_nr, num_fe, ok, false, fe);
if (ok)
- m_simulate_frontend.push_back(fe);
+ m_frontend.push_back(ePtr<eDVBFrontend>(fe));
}
++num_fe;
}
PyErr_SetString(PyExc_StandardError, "eDVBResourceManager::setFrontendSlotInformations argument should be a python list");
return NULL;
}
- if ((unsigned int)PyList_Size(list) != m_frontend.size())
+ unsigned int assigned=0;
+ for (eSmartPtrList<eDVBRegisteredFrontend>::iterator i(m_frontend.begin()); i != m_frontend.end(); ++i)
{
+ int pos=0;
+ while (pos < PyList_Size(list)) {
+ ePyObject obj = PyList_GET_ITEM(list, pos++);
+ if (!i->m_frontend->setSlotInfo(obj))
+ continue;
+ ++assigned;
+ break;
+ }
+ }
+ if (assigned != 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));
+ sprintf(blasel, "eDVBResourceManager::setFrontendSlotInformations .. assigned %zd socket informations, but %d registered frontends!",
+ m_frontend.size(), assigned);
PyErr_SetString(PyExc_StandardError, blasel);
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++);
- 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;
+ int pos=0;
+ while (pos < PyList_Size(list)) {
+ ePyObject obj = PyList_GET_ITEM(list, pos++);
+ if (!i->m_frontend->setSlotInfo(obj))
+ continue;
+ break;
+ }
}
Py_RETURN_NONE;
}
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. */
ePtr<eDVBRegisteredDemux> unused;
- if (m_demux.size() < 5)
+ if (m_boxtype == DM800) // dm800
+ {
+ 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
{
/* FIXME: hardware demux policy */
if (!(cap & iDVBChannel::capDecode))
}
}
}
- else // we asume dm8000
+ else if (m_boxtype == DM8000 || m_boxtype == DM500HD || m_boxtype == DM800SE || m_boxtype == DM7020HD)
{
- for (; i != m_demux.end(); ++i, ++n)
+ iDVBAdapter *adapter = fe ? fe->m_adapter : m_adapter.begin(); /* look for a demux on the same adapter as the frontend, or the first adapter for dvr playback */
+ int source = fe ? fe->m_frontend->getDVBID() : -1;
+ cap |= capHoldDecodeReference; // this is checked in eDVBChannel::getDemux
+ if (!fe)
{
- if (fe)
+ /*
+ * For pvr playback, start with the last demux.
+ * On some hardware, we have less ca devices than demuxes,
+ * so we should try to leave the first demuxes for live tv,
+ * and start with the last for pvr playback
+ */
+ i = m_demux.end();
+ --i;
+ }
+ while (i != m_demux.end())
+ {
+ if (i->m_adapter == adapter)
{
if (!i->m_inuse)
{
- if (!unused)
- unused = i;
+ /* mark the first unused demux, we'll use that when we do not find a better match */
+ if (!unused) unused = i;
}
- else if (i->m_adapter == fe->m_adapter &&
- i->m_demux->getSource() == fe->m_frontend->getDVBID())
+ else
{
- demux = new eDVBAllocatedDemux(i);
- return 0;
+ /* demux is in use, see if we can share it */
+ if (source >= 0 && i->m_demux->getSource() == source)
+ {
+ demux = new eDVBAllocatedDemux(i);
+ return 0;
+ }
}
}
- else if (n == 4) // always use demux4 for PVR (demux 4 can not descramble...)
+ if (fe)
{
- if (i->m_inuse) {
- demux = new eDVBAllocatedDemux(i);
- return 0;
- }
- unused = i;
+ ++i;
+ }
+ else
+ {
+ --i;
}
}
}
return 0;
}
-
-RESULT eDVBResourceManager::allocatePVRChannel(eUsePtr<iDVBPVRChannel> &channel)
+RESULT eDVBResourceManager::allocatePVRChannel(const eDVBChannelID &channelid, eUsePtr<iDVBPVRChannel> &channel)
{
ePtr<eDVBAllocatedDemux> demux;
m_releaseCachedChannelTimer->stop();
}
- channel = new eDVBChannel(this, 0);
+ ePtr<eDVBChannel> ch = new eDVBChannel(this, 0);
+ if (channelid)
+ {
+ /*
+ * user provided a channelid, with the clear intention for
+ * this channel to be registered at the resource manager.
+ * (allowing e.g. epgcache to be started)
+ */
+ ePtr<iDVBFrontendParameters> feparm;
+ ch->setChannel(channelid, feparm);
+ }
+ channel = ch;
return 0;
}
return bestval;
}
-int tuner_type_channel_default(ePtr<iDVBChannelList> &channellist, const eDVBChannelID &chid)
+int tuner_type_channel_default(ePtr<iDVBChannelList> &channellist, const eDVBChannelID &chid, int &system)
{
+ system = iDVBFrontend::feSatellite;
if (channellist)
{
ePtr<iDVBFrontendParameters> feparm;
if (!channellist->getChannelFrontendData(chid, feparm))
{
- int system;
if (!feparm->getSystem(system))
{
- switch(system)
+ switch (system)
{
case iDVBFrontend::feSatellite:
return 50000;
return 0;
}
-int eDVBResourceManager::canAllocateChannel(const eDVBChannelID &channelid, const eDVBChannelID& ignore, bool simulate)
+int eDVBResourceManager::canAllocateChannel(const eDVBChannelID &channelid, const eDVBChannelID& ignore, int &system, bool simulate)
{
std::list<active_channel> &active_channels = simulate ? m_active_simulate_channels : m_active_channels;
- int ret=0;
+ int ret = 0;
+ system = iDVBFrontend::feSatellite;
if (!simulate && m_cached_channel)
{
eDVBChannel *cache_chan = (eDVBChannel*)&(*m_cached_channel);
if(channelid==cache_chan->getChannelID())
- return tuner_type_channel_default(m_list, channelid);
+ return tuner_type_channel_default(m_list, channelid, system);
}
/* first, check if a channel is already existing. */
if (i->m_channel_id == channelid)
{
// eDebug("found shared channel..");
- return tuner_type_channel_default(m_list, channelid);
+ return tuner_type_channel_default(m_list, channelid, system);
}
}
eDebug("channel not found!");
goto error;
}
+ feparm->getSystem(system);
ret = canAllocateFrontend(feparm, simulate);
}
#endif
-#if 1 /* not yet */
+#if 0
if (!m_iframe_search)
return len;
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);
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_pvr_fd_dst = -1;
- m_skipmode_n = m_skipmode_m = 0;
+ m_skipmode_n = m_skipmode_m = m_skipmode_frames = 0;
if (m_frontend)
m_frontend->get().connectStateChange(slot(*this, &eDVBChannel::frontendStateChanged), m_conn_frontendStateChanged);
}
} else if (state == iDVBFrontend::stateFailed)
{
+#ifdef BUILD_VUPLUS
+ if (m_current_frontend_parameters)
+ {
+ eDebug("OURSTATE: lost lock, trying to retune");
+ ourstate = state_tuning;
+ m_frontend->get().tune(*m_current_frontend_parameters);
+ }
+ else
+ {
+ eDebug("OURSTATE: failed");
+ ourstate = state_failed;
+ }
+#else
eDebug("OURSTATE: failed");
ourstate = state_failed;
+#endif
} else
eFatal("state unknown");
/* 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;
}
}
m_pvr_thread->setIFrameSearch(m_skipmode_n != 0);
{
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;
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;
+
+ int r = x % align;
+ x -= r;
+ len += r;
+
+ if (sign)
+ x = -x;
+
+ return x;
+}
+
/* remember, this gets called from another thread. */
void eDVBChannel::getNextSourceSpan(off_t current_offset, size_t bytes_read, off_t &start, size_t &size)
{
return;
}
- 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;
- }
-
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);
+ eDebug("getNextSourceSpan, current offset is %08lld, 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 %lld, 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(current_offset < 0)
+ current_offset = 0;
+ else
+ {
+ if (m_skipmode_m)
+ {
+ eDebug("we are at %lld, and we try to find the iframe here:", current_offset);
+ size_t iframe_len;
+ off_t start_offset = current_offset;
+ off_t new_offset = start_offset;
+ int direction = (m_skipmode_m < 0) ? -1 : +1;
+ if (m_tstools.findFrame(start_offset, new_offset, iframe_len, direction))
+ eDebug("failed");
+ else
+ {
+ current_offset = align_with_len(new_offset, blocksize, iframe_len);
+ max = align(iframe_len, blocksize);
+ }
+ }
+ }
+ }
+
+ m_cue->m_lock.RdLock();
while (!m_cue->m_seek_requests.empty())
{
eDebug("decoder getPTS failed, can't seek relative");
continue;
}
+ if (!m_cue->m_decoding_demux)
+ {
+ eDebug("getNextSourceSpan, no decoding demux. couldn't seek to %llx... ignore request!", pts);
+ start = current_offset;
+ size = max;
+ continue;
+ }
if (getCurrentPosition(m_cue->m_decoding_demux, now, 1))
{
eDebug("seekTo: getCurrentPosition failed!");
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;
}
-
+
eDebug("ok, resolved skip (rel: %d, diff %lld), now at %08llx", relative, pts, offset);
current_offset = align(offset, blocksize); /* in case tstools return non-aligned offset */
}
size = max;
else
size = aligned_end - current_offset;
- eDebug("HIT, %lld < %lld < %lld, size: %d", i->first, current_offset, i->second, size);
+ eDebug("HIT, %lld < %lld < %lld, size: %zd", i->first, current_offset, i->second, size);
return;
}
if (current_offset < aligned_start)
len = aligned_end - aligned_start;
start = aligned_end - len;
- eDebug("skipping to %llx, %d", start, len);
+ eDebug("skipping to %llx, %zd", start, len);
}
- eDebug("result: %llx, %x (%llx %llx)", start, size, aligned_start, aligned_end);
+ eDebug("result: %llx, %zx (%llx %llx)", start, size, aligned_start, aligned_end);
return;
}
}
+ if(current_offset <0)
+ current_offset =0;
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;
-
- eDebug("END OF CUESHEET. (%08llx, %d)", start, size);
+ if (m_source_span.empty())
+ {
+ start = current_offset;
+ size = max;
+ eDebug("NO CUESHEET. (%08lld, %zd)", start, size);
+ } else
+ {
+ start = current_offset;
+ size = 0;
+ }
return;
}
if (!channelid)
return 0;
+ m_channel_id = channelid;
+ m_mgr->addChannel(channelid, this);
+
if (!m_frontend)
{
- eDebug("no frontend to tune!");
- return -ENODEV;
+ /* no frontend, no need to tune (must be a streamed service) */
+ return 0;
}
- m_channel_id = channelid;
- m_mgr->addChannel(channelid, this);
m_state = state_tuning;
/* if tuning fails, shutdown the channel immediately. */
int res;
m_SDT = 0;
}
+int eDVBChannel::reserveDemux()
+{
+ ePtr<iDVBDemux> dmx;
+ if (!getDemux(dmx, 0))
+ {
+ uint8_t id;
+ if (!dmx->getCADemuxID(id))
+ return id;
+ }
+ return -1;
+}
+
RESULT eDVBChannel::requestTsidOnid(ePyObject callback)
{
if (PyCallable_Check(callback))
{
ePtr<eDVBAllocatedDemux> &our_demux = (cap & capDecode) ? m_decoder_demux : m_demux;
+ if (m_frontend == NULL)
+ {
+ /* in dvr mode, we have to stick to a single demux (the one connected to our dvr device) */
+ our_demux = m_decoder_demux ? 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.
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;
}
RESULT eDVBChannel::playFile(const char *file)
{
+ eRawFile *f = new eRawFile();
+ ePtr<iTsSource> source = f;
+
+ if (f->open(file) < 0)
+ {
+ eDebug("can't open PVR file %s (%m)", file);
+ return -ENOENT;
+ }
+
+ return playSource(source, file);
+}
+
+RESULT eDVBChannel::playSource(ePtr<iTsSource> &source, const char *streaminfo_file)
+{
ASSERT(!m_frontend);
if (m_pvr_thread)
{
m_pvr_thread = 0;
}
- m_tstools.openFile(file);
+ if (!source->valid() && !source->isStream())
+ {
+ eDebug("PVR source is not valid!");
+ return -ENOENT;
+ }
+
+ m_tstools.setSource(source, streaminfo_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);
+ if (m_pvr_fd_dst < 0)
+ {
+ eDebug("can't open /dev/pvr - you need to buy the new(!) $$$ box! (%m)"); // or wait for the driver to be improved.
+ return -ENODEV;
+ }
#else
- m_pvr_fd_dst = open("/dev/misc/pvr", O_WRONLY);
+ ePtr<eDVBAllocatedDemux> &demux = m_demux ? m_demux : m_decoder_demux;
+ if (demux)
+ {
+ m_pvr_fd_dst = demux->get().openDVR(O_WRONLY);
+ if (m_pvr_fd_dst < 0)
+ {
+ eDebug("can't open /dev/dvb/adapterX/dvrX - you need to buy the new(!) $$$ box! (%m)"); // or wait for the driver to be improved.
+ return -ENODEV;
+ }
+ }
+ else
+ {
+ eDebug("no demux allocated yet.. so its not possible to open the dvr device!!");
+ return -ENODEV;
+ }
#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;
}
m_pvr_thread = new eDVBChannelFilePush();
m_pvr_thread->enablePVRCommit(1);
- m_pvr_thread->setStreamMode(1);
+ /* If the source specifies a length, it's a file. If not, it's a stream */
+ m_pvr_thread->setStreamMode(source->isStream());
m_pvr_thread->setScatterGather(this);
- if (m_pvr_thread->start(file, m_pvr_fd_dst))
- {
- delete m_pvr_thread;
- m_pvr_thread = 0;
- eDebug("can't open PVR file %s (%m)", file);
- return -ENOENT;
- }
+ m_event(this, evtPreStart);
+
+ m_pvr_thread->start(source, m_pvr_fd_dst);
CONNECT(m_pvr_thread->m_event, eDVBChannel::pvrEvent);
m_state = state_ok;
return 0;
}
-void eDVBChannel::stopFile()
+void eDVBChannel::stopSource()
{
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);
+ ePtr<iTsSource> d;
+ m_tstools.setSource(d);
+}
+
+void eDVBChannel::stopFile()
+{
+ stopSource();
}
void eDVBChannel::setCueSheet(eCueSheet *cuesheet)
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();
projects / vuplus_dvbapp / blobdiff