Pointer<Streamable> IBInstrumentationSpec::Factory::unpackStream(AbstractStream& stream,
const IntVector<NDIM>& /*offset*/)
{
Pointer<IBInstrumentationSpec> ret_val = new IBInstrumentationSpec();
stream.unpack(&ret_val->d_master_idx, 1);
stream.unpack(&ret_val->d_meter_idx, 1);
stream.unpack(&ret_val->d_node_idx, 1);
return ret_val;
} // unpackStream
AbstractStream * DASHStreamFactory::create(demux_t *realdemux, const StreamFormat &format,
SegmentTracker *tracker, HTTPConnectionManager *manager) const
{
AbstractStream *stream = new (std::nothrow) DASHStream(realdemux);
if(stream && !stream->init(format, tracker, manager))
{
delete stream;
return NULL;
}
return stream;
}
bool PlaylistManager::setupPeriod()
{
if(!currentPeriod)
return false;
if(!logic && !(logic = createLogic(logicType, conManager)))
return false;
std::vector<BaseAdaptationSet*> sets = currentPeriod->getAdaptationSets();
std::vector<BaseAdaptationSet*>::iterator it;
for(it=sets.begin();it!=sets.end();++it)
{
BaseAdaptationSet *set = *it;
if(set && streamFactory)
{
SegmentTracker *tracker = new (std::nothrow) SegmentTracker(logic, set);
if(!tracker)
continue;
AbstractStream *st = streamFactory->create(p_demux, set->getStreamFormat(),
tracker, conManager);
if(!st)
{
delete tracker;
continue;
}
streams.push_back(st);
/* Generate stream description */
std::list<std::string> languages;
if(!set->getLang().empty())
{
languages = set->getLang();
}
else if(!set->getRepresentations().empty())
{
languages = set->getRepresentations().front()->getLang();
}
if(!languages.empty())
st->setLanguage(languages.front());
if(!set->description.Get().empty())
st->setDescription(set->description.Get());
}
}
return true;
}
Pointer<Streamable>
IBTargetPointForceSpec::Factory::unpackStream(
AbstractStream& stream,
const IntVector<NDIM>& /*offset*/)
{
Pointer<IBTargetPointForceSpec> ret_val = new IBTargetPointForceSpec();
stream.unpack(&ret_val->d_master_idx,1);
stream.unpack(&ret_val->d_kappa_target,1);
stream.unpack(&ret_val->d_eta_target,1);
stream.unpack(ret_val->d_X_target.data(),NDIM);
#if ENABLE_SUBDOMAIN_INDICES
stream.unpack(&ret_val->d_subdomain_idx,1);
#endif
return ret_val;
}// unpackStream
Pointer<Streamable> MaterialPointSpec::Factory::unpackStream(AbstractStream& stream,
const IntVector<NDIM>& /*offset*/)
{
Pointer<MaterialPointSpec> ret_val = new MaterialPointSpec();
stream.unpack(&ret_val->d_point_idx, 1);
stream.unpack(&ret_val->d_weight, 1);
int subdomain_id;
stream.unpack(&subdomain_id, 1);
ret_val->d_subdomain_id = subdomain_id;
int n_internal_vars;
stream.unpack(&n_internal_vars, 1);
ret_val->d_internal_vars.resize(n_internal_vars);
if (n_internal_vars) stream.unpack(&ret_val->d_internal_vars[0], n_internal_vars);
return ret_val;
} // unpackStream
AbstractStream::status PlaylistManager::demux(mtime_t nzdeadline, bool send)
{
AbstractStream::status i_return = AbstractStream::status_eof;
std::vector<AbstractStream *>::iterator it;
for(it=streams.begin(); it!=streams.end(); ++it)
{
AbstractStream *st = *it;
if (st->isDisabled())
{
if(st->isSelected() && !st->isEOF())
reactivateStream(st);
else
continue;
}
AbstractStream::status i_ret = st->demux(nzdeadline, send);
if(i_ret == AbstractStream::status_buffering_ahead ||
i_return == AbstractStream::status_buffering_ahead)
{
i_return = AbstractStream::status_buffering_ahead;
}
else if(i_ret == AbstractStream::status_buffering)
{
i_return = AbstractStream::status_buffering;
}
else if(i_ret == AbstractStream::status_demuxed &&
i_return != AbstractStream::status_buffering)
{
i_return = AbstractStream::status_demuxed;
}
else if(i_ret == AbstractStream::status_dis)
{
i_return = AbstractStream::status_dis;
}
}
/* might be end of current period */
if(i_return == AbstractStream::status_eof && currentPeriod)
{
unsetPeriod();
currentPeriod = playlist->getNextPeriod(currentPeriod);
i_return = (setupPeriod()) ? AbstractStream::status_eop : AbstractStream::status_eof;
}
return i_return;
}
bool PlaylistManager::setPosition(mtime_t time)
{
bool ret = true;
for(int real = 0; real < 2; real++)
{
/* Always probe if we can seek first */
std::vector<AbstractStream *>::iterator it;
for(it=streams.begin(); it!=streams.end(); ++it)
{
AbstractStream *st = *it;
if(!st->isDisabled())
ret &= st->setPosition(time, !real);
}
if(!ret)
break;
}
return ret;
}
AbstractStream::buffering_status PlaylistManager::bufferize(mtime_t i_nzdeadline,
unsigned i_min_buffering, unsigned i_extra_buffering)
{
AbstractStream::buffering_status i_return = AbstractStream::buffering_end;
/* First reorder by status >> buffering level */
std::vector<AbstractStream *> prioritized_streams(streams);
std::sort(prioritized_streams.begin(), prioritized_streams.end(), streamCompare);
std::vector<AbstractStream *>::iterator it;
for(it=prioritized_streams.begin(); it!=prioritized_streams.end(); ++it)
{
AbstractStream *st = *it;
if (st->isDisabled() &&
(!st->isSelected() || !st->canActivate() || !reactivateStream(st)))
continue;
AbstractStream::buffering_status i_ret = st->bufferize(i_nzdeadline, i_min_buffering, i_extra_buffering);
if(i_return != AbstractStream::buffering_ongoing) /* Buffering streams need to keep going */
{
if(i_ret > i_return)
i_return = i_ret;
}
/* Bail out, will start again (high prio could be same starving stream) */
if( i_return == AbstractStream::buffering_lessthanmin )
break;
}
vlc_mutex_lock(&demux.lock);
if(demux.i_nzpcr == VLC_TS_INVALID &&
i_return != AbstractStream::buffering_lessthanmin /* prevents starting before buffering is reached */ )
{
demux.i_nzpcr = getFirstDTS();
}
vlc_mutex_unlock(&demux.lock);
return i_return;
}
AbstractStream::status PlaylistManager::dequeue(mtime_t i_floor, mtime_t *pi_nzbarrier)
{
AbstractStream::status i_return = AbstractStream::status_eof;
const mtime_t i_nzdeadline = *pi_nzbarrier;
std::vector<AbstractStream *>::iterator it;
for(it=streams.begin(); it!=streams.end(); ++it)
{
AbstractStream *st = *it;
mtime_t i_pcr;
AbstractStream::status i_ret = st->dequeue(i_nzdeadline, &i_pcr);
if( i_ret > i_return )
i_return = i_ret;
if( i_pcr > i_floor )
*pi_nzbarrier = std::min( *pi_nzbarrier, i_pcr - VLC_TS_0 );
}
return i_return;
}
void PlaylistManager::drain()
{
for(;;)
{
bool b_drained = true;
std::vector<AbstractStream *>::iterator it;
for(it=streams.begin(); it!=streams.end(); ++it)
{
AbstractStream *st = *it;
if (st->isDisabled())
continue;
b_drained &= st->drain();
}
if(b_drained)
break;
msleep(20*1000); /* ugly, but we have no way to get feedback */
}
es_out_Control(p_demux->out, ES_OUT_RESET_PCR);
}
void
LTransaction<T>::packStream(
AbstractStream& stream)
{
stream << static_cast<int>(d_src_item_set.size());
for (typename std::vector<LTransactionComponent>::iterator it = d_src_item_set.begin(); it != d_src_item_set.end(); ++it)
{
typename LSet<T>::value_type& item = it->item;
item->packStream(stream);
const blitz::TinyVector<double,NDIM>& posn = it->posn;
stream.pack(posn.data(),NDIM);
}
return;
}// packStream
AbstractStream::buffering_status PlaylistManager::bufferize(mtime_t i_nzdeadline,
unsigned i_min_buffering, unsigned i_extra_buffering)
{
AbstractStream::buffering_status i_return = AbstractStream::buffering_end;
std::vector<AbstractStream *>::iterator it;
for(it=streams.begin(); it!=streams.end(); ++it)
{
AbstractStream *st = *it;
if (st->isDisabled())
{
if(st->isSelected() && !st->isDead())
reactivateStream(st);
else
continue;
}
AbstractStream::buffering_status i_ret = st->bufferize(i_nzdeadline, i_min_buffering, i_extra_buffering);
if(i_return != AbstractStream::buffering_ongoing) /* Buffering streams need to keep going */
{
if(i_ret > i_return)
i_return = i_ret;
}
}
vlc_mutex_lock(&demux.lock);
if(demux.i_nzpcr == VLC_TS_INVALID &&
i_return != AbstractStream::buffering_lessthanmin /* prevents starting before buffering is reached */ )
{
demux.i_nzpcr = getFirstDTS();
}
vlc_mutex_unlock(&demux.lock);
return i_return;
}
void
LTransaction<T>::unpackStream(
AbstractStream& stream)
{
static const IntVector<NDIM> periodic_offset = 0;
int num_items;
stream >> num_items;
d_dst_item_set.resize(num_items);
for (typename std::vector<LTransactionComponent>::iterator it = d_dst_item_set.begin(); it != d_dst_item_set.end(); ++it)
{
it->item->unpackStream(stream, periodic_offset);
blitz::TinyVector<double,NDIM>& posn = it->posn;
stream.unpack(posn.data(),NDIM);
}
return;
}// unpackStream
