}
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;
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);
- CONNECT(m_releaseCachedChannelTimer.timeout, eDVBResourceManager::releaseCachedChannel);
+ CONNECT(m_releaseCachedChannelTimer->timeout, eDVBResourceManager::releaseCachedChannel);
}
void eDVBResourceManager::feStateChanged()
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;
}
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;
{
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;
}
}
}
+
}
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 ( (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!");
}
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!");
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 ( (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!");
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);
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_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)
- 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;
}
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 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:
+ eDVBChannelFilePush() { setIFrameSearch(0); setTimebaseChange(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;
+ int m_timebase_change;
int filterRecordData(const unsigned char *data, int len, size_t ¤t_span_remaining);
};
int eDVBChannelFilePush::filterRecordData(const unsigned char *_data, int len, size_t ¤t_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. */
- 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)))
{
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 (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 */
-
+
fts += 188;
}
/* force payload only */
ts[3] &= ~0x30;
ts[3] |= 0x10;
-
+
// memset(ts + 4, 0xFF, (offset % 188) - 4);
m_iframe_state = 1;
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;
-
+
if (m_cue->m_skipmode_ratio < 0)
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;
}
-
} 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);
+ 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");
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();
git.cweiske.de / enigma2.git / blobdiff