// createBlock
//
// Create the actual GNU Radio Block to that will perform the work method. The resulting
// block object is assigned to gr_stpr
//
// Add property change callbacks for getter/setter methods
//
void iir_filter_ffd_i::createBlock()
{
//
// gr_sptr = xxx_make_xxx( args );
//
this->gr_sptr = gr::filter::iir_filter_ffd::make( this->fftaps, this->fbtaps );
this->setPropertyChangeListener("fftaps", this, &iir_filter_ffd_i::setTaps);
this->setPropertyChangeListener("fbtaps", this, &iir_filter_ffd_i::setTaps);
//
// Use setThrottle method to enable the throttling of consumption/production of data by the
// service function. The affect of the throttle will try to pause the execution of the
// service function for a specified duration. This duration is calculated using the getTargetDuration() method
// and the actual processing time to perform the work method.
//
// This is turned ON by default for "output" only components
//
// setThrottle( bool onoff );
//
// Use maintainTimeStamp to enable proper data flow of timestamp with input and output data.
// if turned on (true)
// The timestamp from the input source will be used and maintained based on the output rate and
// the number of samples produced
// if turned off
// then the timestamp from the input source is passed through if available or the time of day
//
// maintainTimestamp( bool onoff );
setupIOMappings();
}
void pll_carriertracking_cc_i::createBlock()
{
//
// gr_sptr = xxx_make_xxx( args );
//
gr_sptr = gr_make_pll_carriertracking_cc( this->loop_bw, this->max_freq, this->min_freq );
this->registerGetValue("d_locksig", this, &pll_carriertracking_cc_i::lock_detector);
this->setPropertyChangeListener("d_squelch_enable", this, &pll_carriertracking_cc_i::squelch_enable);
this->setPropertyChangeListener("d_lock_threshold", this, &pll_carriertracking_cc_i::set_lock_threshold);
//
// Use setThrottle method to enable the throttling of consumption/production of data by the
// service function. The affect of the throttle will try to pause the execution of the
// service function for a specified duration. This duration is calculated using the getTargetDuration() method
// and the actual processing time to perform the work method.
//
// This is turned ON by default for "output" only components
//
// setThrottle( bool onoff );
//
// Use maintainTimeStamp to enable proper data flow of timestamp with input and output data.
// if turned on (true)
// The timestamp from the input source will be used and maintained based on the output rate and
// the number of samples produced
// if turned off
// then the timestamp from the input source is passed through if available or the time of day
//
// maintainTimestamp( bool onoff );
setupIOMappings();
}
// createBlock
//
// Create the actual GNU Radio Block to that will perform the work method. The resulting
// block object is assigned to gr_stpr
//
// Add property change callbacks for getter/setter methods
//
void pfb_clock_sync_ccf_4o_i::createBlock()
{
//
//
gr_sptr = digital_make_pfb_clock_sync_ccf(sps, loop_bandwidth, taps, filter_size, init_phase, max_rate_deviation, osps);
this->registerGetterSetter("loop_bandwidth", &digital_pfb_clock_sync_ccf::get_loop_bandwidth, &digital_pfb_clock_sync_ccf::set_loop_bandwidth);
this->registerGetterSetter("damping_factor", &digital_pfb_clock_sync_ccf::get_damping_factor, &digital_pfb_clock_sync_ccf::set_damping_factor);
this->registerGetterSetter("alpha", &digital_pfb_clock_sync_ccf::get_alpha, &digital_pfb_clock_sync_ccf::set_alpha);
this->registerGetterSetter("beta", &digital_pfb_clock_sync_ccf::get_beta, &digital_pfb_clock_sync_ccf::set_beta);
this->registerGetter("clock_rate", &digital_pfb_clock_sync_ccf::get_clock_rate);
//
// Use setThrottle method to enable the throttling of consumption/production of data by the
// service function. The affect of the throttle will try to pause the execution of the
// service function for a specified duration. This duration is calculated using the getTargetDuration() method
// and the actual processing time to perform the work method.
//
// This is turned ON by default for "output" only components
//
// setThrottle( bool onoff );
//
// Use maintainTimeStamp to enable proper data flow of timestamp with input and output data.
// if turned on (true)
// The timestamp from the input source will be used and maintained based on the output rate and
// the number of samples produced
// if turned off
// then the timestamp from the input source is passed through if available or the time of day
//
// maintainTimestamp( bool onoff );
setupIOMappings();
}
void regenerate_bb_i::createBlock()
{
//
// gr_sptr = xxx_make_xxx( args );
//
gr_sptr = gr_make_regenerate_bb( this->period, this->max_regen );
this->registerSetter("period", &gr_regenerate_bb::set_period);
this->registerSetter("max_regen", &gr_regenerate_bb::set_max_regen);
//
// Use setThrottle method to enable the throttling of consumption/production of data by the
// service function. The affect of the throttle will try to pause the execution of the
// service function for a specified duration. This duration is calculated using the getTargetDuration() method
// and the actual processing time to perform the work method.
//
// This is turned ON by default for "output" only components
//
// setThrottle( bool onoff );
//
// Use maintainTimeStamp to enable proper data flow of timestamp with input and output data.
// if turned on (true)
// The timestamp from the input source will be used and maintained based on the output rate and
// the number of samples produced
// if turned off
// then the timestamp from the input source is passed through if available or the time of day
//
// maintainTimestamp( bool onoff );
setupIOMappings();
}
// createBlock
//
// Create the actual GNU Radio Block to that will perform the work method. The resulting
// block object is assigned to gr_stpr
//
// Add property change callbacks for getter/setter methods
//
void dc_blocker_cc_i::createBlock()
{
//
// gr_sptr = xxx_make_xxx( args );
//
gr_sptr = gr::filter::dc_blocker_cc::make( this->delay_length, this->long_form );
this->registerGetValue("group_delay", this, &dc_blocker_cc_i::getGroupDelay);
//
// Use setThrottle method to enable the throttling of consumption/production of data by the
// service function. The affect of the throttle will try to pause the execution of the
// service function for a specified duration. This duration is calculated using the getTargetDuration() method
// and the actual processing time to perform the work method.
//
// This is turned ON by default for "output" only components
//
// setThrottle( bool onoff );
//
// Use maintainTimeStamp to enable proper data flow of timestamp with input and output data.
// if turned on (true)
// The timestamp from the input source will be used and maintained based on the output rate and
// the number of samples produced
// if turned off
// then the timestamp from the input source is passed through if available or the time of day
//
// maintainTimestamp( bool onoff );
setupIOMappings();
}
void streams_to_stream_ii_4i_i::createBlock()
{
//
// gr_sptr = xxx_make_xxx( args );
//
try{
this->gr_sptr = gr_make_streams_to_stream(this->item_size, this->nstreams);
}
catch(...){
return;
}
//
// Use setThrottle method to enable the throttling of consumption/production of data by the
// service function. The affect of the throttle will try to pause the execution of the
// service function for a specified duration. This duration is calculated using the getTargetDuration() method
// and the actual processing time to perform the work method.
//
// This is turned ON by default for "output" only components
//
// setThrottle( bool onoff );
//
// Use maintainTimeStamp to enable proper data flow of timestamp with input and output data.
// if turned on (true)
// The timestamp from the input source will be used and maintained based on the output rate and
// the number of samples produced
// if turned off
// then the timestamp from the input source is passed through if available or the time of day
//
// maintainTimestamp( bool onoff );
setupIOMappings();
}
void mpsk_snr_est_cc_i::createBlock()
{
//
// gr_sptr = xxx_make_xxx( args );
//
snr_est_type_t curr_type = SNR_EST_SIMPLE;
if (this->type == 0){
curr_type = SNR_EST_SIMPLE;
} else if (this->type == 1){
curr_type = SNR_EST_SKEW;
} else if (this->type == 2){
curr_type = SNR_EST_M2M4;
} else if (this->type == 3){
curr_type = SNR_EST_SVR;
}
gr_sptr = digital_make_mpsk_snr_est_cc( curr_type, this->tag_nsamples, this->alpha);
this->registerGetterSetter("tag_nsamples",
&digital_mpsk_snr_est_cc::tag_nsample,
&digital_mpsk_snr_est_cc::set_tag_nsample);
this->registerGetterSetter("alpha",
&digital_mpsk_snr_est_cc::alpha,
&digital_mpsk_snr_est_cc::set_alpha);
this->setPropertyChangeListener("type",
this,
&mpsk_snr_est_cc_i::set_type);
this->registerGetValue("snr",
this,
&mpsk_snr_est_cc_i::get_snr);
//
// Use setThrottle method to enable the throttling of consumption/production of data by the
// service function. The affect of the throttle will try to pause the execution of the
// service function for a specified duration. This duration is calculated using the getTargetDuration() method
// and the actual processing time to perform the work method.
//
// This is turned ON by default for "output" only components
//
// setThrottle( bool onoff );
//
// Use maintainTimeStamp to enable proper data flow of timestamp with input and output data.
// if turned on (true)
// The timestamp from the input source will be used and maintained based on the output rate and
// the number of samples produced
// if turned off
// then the timestamp from the input source is passed through if available or the time of day
//
// maintainTimestamp( bool onoff );
setupIOMappings();
}
void mpsk_receiver_cc_i::createBlock()
{
//
// gr_sptr = xxx_make_xxx( args );
//
gr_sptr = digital_make_mpsk_receiver_cc( this->M, this->theta, this->loop_bw, this->fmin, this->fmax,
this->mu, this->gain_mu, this->omega, this->gain_omega, this->omega_rel);
this->registerSetter("M",
&digital_mpsk_receiver_cc::set_modulation_order);
this->registerGetValue("M",
this,
&mpsk_receiver_cc_i::modulation_order);
this->registerGetterSetter("theta",
&digital_mpsk_receiver_cc::theta,
&digital_mpsk_receiver_cc::set_theta);
this->registerGetterSetter("mu",
&digital_mpsk_receiver_cc::mu,
&digital_mpsk_receiver_cc::set_mu);
this->registerGetterSetter("omega",
&digital_mpsk_receiver_cc::omega,
&digital_mpsk_receiver_cc::set_omega);
this->registerGetterSetter("gain_mu",
&digital_mpsk_receiver_cc::gain_mu,
&digital_mpsk_receiver_cc::set_gain_mu);
this->registerGetterSetter("gain_omega",
&digital_mpsk_receiver_cc::gain_omega,
&digital_mpsk_receiver_cc::set_gain_omega);
this->registerGetterSetter("omega_rel",
&digital_mpsk_receiver_cc::gain_omega_rel,
&digital_mpsk_receiver_cc::set_gain_omega_rel);
//
// Use setThrottle method to enable the throttling of consumption/production of data by the
// service function. The affect of the throttle will try to pause the execution of the
// service function for a specified duration. This duration is calculated using the getTargetDuration() method
// and the actual processing time to perform the work method.
//
// This is turned ON by default for "output" only components
//
// setThrottle( bool onoff );
//
// Use maintainTimeStamp to enable proper data flow of timestamp with input and output data.
// if turned on (true)
// The timestamp from the input source will be used and maintained based on the output rate and
// the number of samples produced
// if turned off
// then the timestamp from the input source is passed through if available or the time of day
//
// maintainTimestamp( bool onoff );
setupIOMappings();
}
void cvsd_encode_sb_i::createBlock()
{
//
// gr_sptr = xxx_make_xxx( args );
//
try {
gr_sptr = vocoder_make_cvsd_encode_sb( min_step, max_step, step_decay, accum_decay, K, J, pos_accum_max, neg_accum_max);
} catch (...) {
return;
}
this->registerGetValue("min_step", this, &cvsd_encode_sb_i::get_min_step);
this->registerGetValue("max_step", this, &cvsd_encode_sb_i::get_max_step);
this->registerGetValue("step_decay", this, &cvsd_encode_sb_i::get_step_decay);
this->registerGetValue("accum_decay", this, &cvsd_encode_sb_i::get_accum_decay);
this->registerGetValue("K", this, &cvsd_encode_sb_i::get_K);
this->registerGetValue("J", this, &cvsd_encode_sb_i::get_J);
this->registerGetValue("pos_accum_max", this, &cvsd_encode_sb_i::get_pos_accum_max);
this->registerGetValue("neg_accum_max", this, &cvsd_encode_sb_i::get_neg_accum_max);
//
// Use setThrottle method to enable the throttling of consumption/production of data by the
// service function. The affect of the throttle will try to pause the execution of the
// service function for a specified duration. This duration is calculated using the getTargetDuration() method
// and the actual processing time to perform the work method.
//
// This is turned ON by default for "output" only components
//
// setThrottle( bool onoff );
//
// Use maintainTimeStamp to enable proper data flow of timestamp with input and output data.
// if turned on (true)
// The timestamp from the input source will be used and maintained based on the output rate and
// the number of samples produced
// if turned off
// then the timestamp from the input source is passed through if available or the time of day
//
// maintainTimestamp( bool onoff );
setupIOMappings();
}
void ofdm_frame_acquisition_i::createBlock()
{
//
// gr_sptr = xxx_make_xxx( args );
//
// Need to have at least 2 known symbols or else GR constructor goes into infinite loop because of unsigned arithmetic in for loop
if (known_symbol.size() <= 2) {
LOG_ERROR(ofdm_frame_acquisition_i, "'known_symbol' must contain at least 2 elements");
return;
}
try {
gr_sptr = digital_make_ofdm_frame_acquisition(occupied_carriers, fft_length, cplen, known_symbol, max_fft_shift_len);
} catch (...) {
return;
}
this->registerGetValue("snr", this, &ofdm_frame_acquisition_i::get_snr);
//
// Use setThrottle method to enable the throttling of consumption/production of data by the
// service function. The affect of the throttle will try to pause the execution of the
// service function for a specified duration. This duration is calculated using the getTargetDuration() method
// and the actual processing time to perform the work method.
//
// This is turned ON by default for "output" only components
//
// setThrottle( bool onoff );
//
// Use maintainTimeStamp to enable proper data flow of timestamp with input and output data.
// if turned on (true)
// The timestamp from the input source will be used and maintained based on the output rate and
// the number of samples produced
// if turned off
// then the timestamp from the input source is passed through if available or the time of day
//
// maintainTimestamp( bool onoff );
setupIOMappings();
}
void probe_avg_mag_sqrd_f_i::createBlock()
{
//
// gr_sptr = xxx_make_xxx( args );
//
try {
gr_sptr = gr_make_probe_avg_mag_sqrd_f( this->threshold_db, this->alpha );
} catch (...) {
return;
}
this->registerGetterSetter("threshold_db", &gr_probe_avg_mag_sqrd_f::threshold, &gr_probe_avg_mag_sqrd_f::set_threshold);
this->registerSetter("alpha", &gr_probe_avg_mag_sqrd_f::set_alpha);
this->registerGetter("level", &gr_probe_avg_mag_sqrd_f::level);
this->registerGetter("unmuted", &gr_probe_avg_mag_sqrd_f::unmuted);
//
// Use setThrottle method to enable the throttling of consumption/production of data by the
// service function. The affect of the throttle will try to pause the execution of the
// service function for a specified duration. This duration is calculated using the getTargetDuration() method
// and the actual processing time to perform the work method.
//
// This is turned ON by default for "output" only components
//
// setThrottle( bool onoff );
//
// Use maintainTimeStamp to enable proper data flow of timestamp with input and output data.
// if turned on (true)
// The timestamp from the input source will be used and maintained based on the output rate and
// the number of samples produced
// if turned off
// then the timestamp from the input source is passed through if available or the time of day
//
// maintainTimestamp( bool onoff );
setupIOMappings();
}
void pfb_synthesizer_ccf_5i_i::createBlock()
{
//
// gr_sptr = xxx_make_xxx( args );
//
try {
gr_sptr = gr::filter::pfb_synthesizer_ccf::make( this->numchans, this->taps, this->twox );
} catch (...) {
return;
}
this->registerGetter("taps", &gr::filter::pfb_synthesizer_ccf::taps);
this->registerSetter("taps", &gr::filter::pfb_synthesizer_ccf::set_taps);
this->registerGetter("channel_map", &gr::filter::pfb_synthesizer_ccf::channel_map);
this->registerSetter("channel_map", &gr::filter::pfb_synthesizer_ccf::set_channel_map);
//
// Use setThrottle method to enable the throttling of consumption/production of data by the
// service function. The affect of the throttle will try to pause the execution of the
// service function for a specified duration. This duration is calculated using the getTargetDuration() method
// and the actual processing time to perform the work method.
//
// This is turned ON by default for "output" only components
//
// setThrottle( bool onoff );
//
// Use maintainTimeStamp to enable proper data flow of timestamp with input and output data.
// if turned on (true)
// The timestamp from the input source will be used and maintained based on the output rate and
// the number of samples produced
// if turned off
// then the timestamp from the input source is passed through if available or the time of day
//
// maintainTimestamp( bool onoff );
setupIOMappings();
}
// createBlock
//
// Create the actual GNU Radio Block to that will perform the work method. The resulting
// block object is assigned to gr_stpr
//
// Add property change callbacks for getter/setter methods
//
void multiply_const_vss_i::createBlock()
{
// need to have at least 1 item in the list... bad things happend if not
if ( k.size() < 1 ) return;
try {
gr_sptr = gr_make_multiply_const_vss(k);
}
catch(...) {
return;
}
//
// Use setThrottle method to enable the throttling of consumption/production of data by the
// service function. The affect of the throttle will try to pause the execution of the
// service function for a specified duration. This duration is calculated using the getTargetDuration() method
// and the actual processing time to perform the work method.
//
// This is turned ON by default for "output" only components
//
// setThrottle( bool onoff );
//
// Use maintainTimeStamp to enable proper data flow of timestamp with input and output data.
// if turned on (true)
// The timestamp from the input source will be used and maintained based on the output rate and
// the number of samples produced
// if turned off
// then the timestamp from the input source is passed through if available or the time of day
//
// maintainTimestamp( bool onoff );
setupIOMappings();
this->registerGetterSetter("k", &gr_multiply_const_vss::k, &gr_multiply_const_vss::set_k);
}
void packed_to_unpacked_ss_i::createBlock()
{
//
// gr_sptr = xxx_make_xxx( args );
//
gr_endianness_t end;
if (this->endianness == 1) {
end = GR_MSB_FIRST;
} else if (this->endianness == 2) {
end = GR_LSB_FIRST;
}
gr_sptr = gr_make_packed_to_unpacked_ss(this->bits_per_chunk, end);
//
// Use setThrottle method to enable the throttling of consumption/production of data by the
// service function. The affect of the throttle will try to pause the execution of the
// service function for a specified duration. This duration is calculated using the getTargetDuration() method
// and the actual processing time to perform the work method.
//
// This is turned ON by default for "output" only components
//
// setThrottle( bool onoff );
//
// Use maintainTimeStamp to enable proper data flow of timestamp with input and output data.
// if turned on (true)
// The timestamp from the input source will be used and maintained based on the output rate and
// the number of samples produced
// if turned off
// then the timestamp from the input source is passed through if available or the time of day
//
// maintainTimestamp( bool onoff );
setupIOMappings();
}
// createBlock
//
// Create the actual GNU Radio Block to that will perform the work method. The resulting
// block object is assigned to gr_stpr
//
// Add property change callbacks for getter/setter methods
//
void sig_source_f_i::createBlock()
{
//
// gr_sptr = xxx_make_xxx( args );
//
this->gr_sptr = gr_make_sig_source_f( this->sampling_freq, (gr_waveform_t)this->waveform, this->frequency, this->amplitude, this->offset );
this->setPropertyChangeListener("sampling_freq", this, &sig_source_f_i::changedSamplingFreq);
this->registerGetter("sampling_freq", &gr_sig_source_f::sampling_freq);
this->registerGetterSetter("waveform", &gr_sig_source_f::waveform, &gr_sig_source_f::set_waveform);
this->registerGetterSetter("frequency", &gr_sig_source_f::frequency, &gr_sig_source_f::set_frequency);
this->registerGetterSetter("amplitude", &gr_sig_source_f::amplitude, &gr_sig_source_f::set_amplitude);
this->registerGetterSetter("offset", &gr_sig_source_f::offset, &gr_sig_source_f::set_offset);
//
// Use setThrottle method to enable the throttling of consumption/production of data by the
// service function. The affect of the throttle will try to pause the execution of the
// service function for a specified duration. This duration is calculated using the getTargetDuration() method
// and the actual processing time to perform the work method.
//
// This is turned ON by default for "output" only components
//
// setThrottle( bool onoff );
//
// Use maintainTimeStamp to enable proper data flow of timestamp with input and output data.
// if turned on (true)
// The timestamp from the input source will be used and maintained based on the output rate and
// the number of samples produced
// if turned off
// then the timestamp from the input source is passed through if available or the time of day
//
// maintainTimestamp( bool onoff );
setupIOMappings();
}
void vector_sink_c_i::createBlock()
{
//
// gr_sptr = xxx_make_xxx( args );
//
try {
gr_sptr = gr_make_vector_sink_c( this->vlen );
} catch (...) {
return;
}
this->registerGetter("data", &gr_vector_sink_c::data);
this->setPropertyChangeListener("reset", this, &vector_sink_c_i::on_reset);
//
// Use setThrottle method to enable the throttling of consumption/production of data by the
// service function. The affect of the throttle will try to pause the execution of the
// service function for a specified duration. This duration is calculated using the getTargetDuration() method
// and the actual processing time to perform the work method.
//
// This is turned ON by default for "output" only components
//
// setThrottle( bool onoff );
//
// Use maintainTimeStamp to enable proper data flow of timestamp with input and output data.
// if turned on (true)
// The timestamp from the input source will be used and maintained based on the output rate and
// the number of samples produced
// if turned off
// then the timestamp from the input source is passed through if available or the time of day
//
// maintainTimestamp( bool onoff );
setupIOMappings();
}
template < typename IN_PORT_TYPE, typename OUT_PORT_TYPE > int copy_octet_base::_transformerServiceFunction( typename std::vector< gr_istream< IN_PORT_TYPE > > &istreams ,
typename std::vector< gr_ostream< OUT_PORT_TYPE > > &ostreams )
{
typedef typename std::vector< gr_istream< IN_PORT_TYPE > > _IStreamList;
typedef typename std::vector< gr_ostream< OUT_PORT_TYPE > > _OStreamList;
boost::mutex::scoped_lock lock(serviceThreadLock);
if ( validGRBlock() == false ) {
// create our processing block, and setup property notifiers
createBlock();
// create input/output port-stream mapping
setupIOMappings();
LOG_DEBUG( copy_octet_base, " FINISHED BUILDING GNU RADIO BLOCK");
}
//process any Stream ID changes this could affect number of io streams
processStreamIdChanges();
if ( !validGRBlock() || istreams.size() == 0 || ostreams.size() == 0 ) {
LOG_WARN(copy_octet_base, "NO STREAMS ATTACHED TO BLOCK..." );
return NOOP;
}
_input_ready.resize( istreams.size() );
_ninput_items_required.resize( istreams.size() );
_ninput_items.resize( istreams.size() );
_input_items.resize( istreams.size() );
_output_items.resize( ostreams.size() );
//
// RESOLVE: need to look at forecast strategy,
// 1) see how many read items are necessary for N number of outputs
// 2) read input data and see how much output we can produce
//
//
// Grab available data from input streams
//
typename _OStreamList::iterator ostream;
typename _IStreamList::iterator istream = istreams.begin();
int nitems=0;
for ( int idx=0 ; istream != istreams.end() && serviceThread->threadRunning() ; idx++, istream++ ) {
// note this a blocking read that can cause deadlocks
nitems = istream->read();
if ( istream->overrun() ) {
LOG_WARN( copy_octet_base, " NOT KEEPING UP WITH STREAM ID:" << istream->streamID );
}
if ( istream->sriChanged() ) {
// RESOLVE - need to look at how SRI changes can affect Gnu Radio BLOCK state
LOG_DEBUG( copy_octet_base, "SRI CHANGED, STREAMD IDX/ID: "
<< idx << "/" << istream->pkt->streamID );
setOutputStreamSRI( idx, istream->pkt->SRI );
}
}
LOG_TRACE( copy_octet_base, "READ NITEMS: " << nitems );
if ( nitems <= 0 && !_istreams[0].eos() ) return NOOP;
bool exitServiceFunction = false;
bool eos = false;
int nout = 0;
while ( nout > -1 && !exitServiceFunction && serviceThread->threadRunning() ) {
eos = false;
nout = _forecastAndProcess( eos, istreams, ostreams );
if ( nout > -1 ) {
// we chunked on data so move read pointer..
istream = istreams.begin();
for ( ; istream != istreams.end(); istream++ ) {
int idx=std::distance( istreams.begin(), istream );
// if we processed data for this stream
if ( _input_ready[idx] ) {
size_t nitems = 0;
try {
nitems = gr_sptr->nitems_read( idx );
}
catch(...){}
istream->consume( nitems );
LOG_TRACE( copy_octet_base, " CONSUME READ DATA ITEMS/REMAIN " << nitems << "/" << istream->nitems());
}
}
gr_sptr->reset_read_index();
}
// check for not enough data return
if ( nout == -1 ) {
// check for end of stream
istream = istreams.begin();
for ( ; istream != istreams.end() ; istream++) if ( istream->eos() ) eos=true;
if ( eos ) {
LOG_TRACE( copy_octet_base, " DATA NOT READY, EOS:" << eos );
_forecastAndProcess( eos, istreams, ostreams);
}
exitServiceFunction = true;
}
}
if ( eos ) {
istream = istreams.begin();
for ( ; istream != istreams.end() ; ) {
int idx=std::distance( istreams.begin(), istream );
if ( istream->eos() || eos == true ) {
LOG_DEBUG( copy_octet_base, " CLOSING INPUT STREAM IDX:" << idx );
istream->close();
//
// if we are variable input list of input streams and fixed output...... humm
//
if ( gr_sptr->get_max_input_streams() == -1 ) {
LOG_DEBUG( copy_octet_base, " REMOVE VARIABLE INPUT STREAM IDX:" << idx );
istream=istreams.erase( istream );
gr_sptr->remove_read_index( idx );
// if output is variable then close the corresponding output stream
if ( gr_sptr->get_max_output_streams() == -1 && outPorts.size() == 1 ) {
ostream = ostreams.begin();
for ( int i=0; ostream != ostreams.end(); i++, ostream++) {
if ( i == idx ) {
LOG_DEBUG( copy_octet_base, " REMOVE VARIABLE OUTPUT STREAM IDX:" << idx );
ostream=ostreams.erase(ostream);
break;
}
}
}
}
else {
istream++;
}
}
}
// close remaining output streams
ostream = ostreams.begin();
for ( ; eos && ostream != ostreams.end(); ostream++ ) ostream->close();
}
//
// set the read pointers of the GNU Radio Block to start at the beginning of the
// supplied buffers
//
gr_sptr->reset_read_index();
LOG_TRACE( copy_octet_base, " END OF TRANSFORM SERVICE FUNCTION....." << noutput_items );
if ( nout == -1 && eos == false )
return NOOP;
else
return NORMAL;
}
