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