template < typename IN_PORT_TYPE, typename OUT_PORT_TYPE > int peak_detector_ib_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(); LOG_DEBUG( peak_detector_ib_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( peak_detector_ib_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( peak_detector_ib_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( peak_detector_ib_base, "SRI CHANGED, STREAMD IDX/ID: " << idx << "/" << istream->pkt->streamID ); setOutputStreamSRI( idx, istream->pkt->SRI ); } } LOG_TRACE( peak_detector_ib_base, "READ NITEMS: " << nitems ); if ( nitems <= 0 && !_istreams[0].eos() ) { return NOOP; } bool eos = false; int nout = 0; bool workDone = false; while ( nout > -1 && serviceThread->threadRunning() ) { eos = false; nout = _forecastAndProcess( eos, istreams, ostreams ); if ( nout > -1 ) { workDone = true; // 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(...){} if ( nitems > istream->nitems() ) { LOG_WARN( peak_detector_ib_base, "WORK CONSUMED MORE DATA THAN AVAILABLE, READ/AVAILABLE " << nitems << "/" << istream->nitems() ); nitems = istream->nitems(); } istream->consume( nitems ); LOG_TRACE( peak_detector_ib_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( peak_detector_ib_base, "EOS SEEN, SENDING DOWNSTREAM " ); _forecastAndProcess( eos, istreams, ostreams); } } } if ( eos ) { istream = istreams.begin(); for ( ; istream != istreams.end() ; istream++ ) { int idx=std::distance( istreams.begin(), istream ); LOG_DEBUG( peak_detector_ib_base, " CLOSING INPUT STREAM IDX:" << idx ); istream->close(); } // close remaining output streams ostream = ostreams.begin(); for ( ; eos && ostream != ostreams.end(); ostream++ ) { int idx=std::distance( ostreams.begin(), ostream ); LOG_DEBUG( peak_detector_ib_base, " CLOSING OUTPUT STREAM IDX:" << idx ); 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( peak_detector_ib_base, " END OF TRANSFORM SERVICE FUNCTION....." << noutput_items ); if ( nout == -1 && eos == false && !workDone ) { return NOOP; } else { return NORMAL; } }
template < typename IN_PORT_TYPE > int file_sink_s_base::_forecastAndProcess( bool &eos, typename std::vector< gr_istream< IN_PORT_TYPE > > &istreams ) { typedef typename std::vector< gr_istream< IN_PORT_TYPE > > _IStreamList; typename _IStreamList::iterator istream = istreams.begin(); int nout = 0; bool dataReady = false; if ( !eos ) { uint64_t max_items_avail = 0; for ( int idx=0 ; istream != istreams.end() && serviceThread->threadRunning() ; idx++, istream++ ) { LOG_TRACE( file_sink_s_base, "GET MAX ITEMS: STREAM:" << idx << " NITEMS/SCALARS:" << istream->nitems() << "/" << istream->_data.size() ); max_items_avail = std::max( istream->nitems(), max_items_avail ); } // // calc number of output items to produce // noutput_items = (int) (max_items_avail * gr_sptr->relative_rate ()); noutput_items = round_down (noutput_items, gr_sptr->output_multiple ()); if ( noutput_items <= 0 ) { LOG_TRACE( file_sink_s_base, "DATA CHECK - MAX ITEMS NOUTPUT/MAX_ITEMS:" << noutput_items << "/" << max_items_avail); return -1; } if ( gr_sptr->fixed_rate() ) { istream = istreams.begin(); for ( int i=0; istream != istreams.end(); i++, istream++ ) { int t_noutput_items = gr_sptr->fixed_rate_ninput_to_noutput( istream->nitems() ); if ( gr_sptr->output_multiple_set() ) { t_noutput_items = round_up(t_noutput_items, gr_sptr->output_multiple()); } if ( t_noutput_items > 0 ) { if ( noutput_items == 0 ) { noutput_items = t_noutput_items; } if ( t_noutput_items <= noutput_items ) { noutput_items = t_noutput_items; } } } LOG_TRACE( file_sink_s_base, " FIXED FORECAST NOUTPUT/output_multiple == " << noutput_items << "/" << gr_sptr->output_multiple()); } // // ask the block how much input they need to produce noutput_items... // if enough data is available to process then set the dataReady flag // int32_t outMultiple = gr_sptr->output_multiple(); while ( !dataReady && noutput_items >= outMultiple ) { // // ask the block how much input they need to produce noutput_items... // gr_sptr->forecast(noutput_items, _ninput_items_required); LOG_TRACE( file_sink_s_base, "--> FORECAST IN/OUT " << _ninput_items_required[0] << "/" << noutput_items ); istream = istreams.begin(); uint32_t dr_cnt=0; for ( int idx=0 ; noutput_items > 0 && istream != istreams.end(); idx++, istream++ ) { // check if buffer has enough elements _input_ready[idx] = false; if ( istream->nitems() >= (uint64_t)_ninput_items_required[idx] ) { _input_ready[idx] = true; dr_cnt++; } LOG_TRACE( file_sink_s_base, "ISTREAM DATACHECK NELMS/NITEMS/REQ/READY:" << istream->nelems() << "/" << istream->nitems() << "/" << _ninput_items_required[idx] << "/" << _input_ready[idx]); } if ( dr_cnt < istreams.size() ) { if ( outMultiple > 1 ) { noutput_items -= outMultiple; } else { noutput_items /= 2; } } else { dataReady = true; } LOG_TRACE( file_sink_s_base, " TRIM FORECAST NOUTPUT/READY " << noutput_items << "/" << dataReady ); } // check if data is ready... if ( !dataReady ) { LOG_TRACE( file_sink_s_base, "DATA CHECK - NOT ENOUGH DATA AVAIL/REQ:" << _istreams[0].nitems() << "/" << _ninput_items_required[0] ); return -1; } // reset looping variables int ritems = 0; int nitems = 0; // reset caching vectors _output_items.clear(); _input_items.clear(); _ninput_items.clear(); istream = istreams.begin(); for ( int idx=0 ; istream != istreams.end(); idx++, istream++ ) { // check if the stream is ready if ( !_input_ready[idx] ) continue; // get number of items remaining try { ritems = gr_sptr->nitems_read( idx ); } catch(...){ // something bad has happened, we are missing an input stream LOG_ERROR( file_sink_s_base, "MISSING INPUT STREAM FOR GR BLOCK, STREAM ID:" << istream->streamID ); return -2; } nitems = istream->nitems() - ritems; LOG_TRACE( file_sink_s_base, " ISTREAM: IDX:" << idx << " ITEMS AVAIL/READ/REQ " << nitems << "/" << ritems << "/" << _ninput_items_required[idx] ); if ( nitems >= _ninput_items_required[idx] && nitems > 0 ) { //remove eos checks ...if ( nitems < _ninput_items_required[idx] ) nitems=0; _ninput_items.push_back( nitems ); _input_items.push_back( (const void *) (istream->read_pointer(ritems)) ); } } nout=0; if ( _input_items.size() != 0 && serviceThread->threadRunning() ) { LOG_TRACE( file_sink_s_base, " CALLING WORK.....N_OUT:" << noutput_items << " N_IN:" << nitems << " ISTREAMS:" << _input_items.size() << " OSTREAMS:" << _output_items.size()); nout = gr_sptr->general_work( noutput_items, _ninput_items, _input_items, _output_items); // sink/analyzer patterns do not return items, so consume_each is not called in Gnu Radio BLOCK if ( nout == 0 ) { gr_sptr->consume_each(nitems); } LOG_TRACE( file_sink_s_base, "RETURN WORK ..... N_OUT:" << nout); } // check for stop condition from work method if ( nout < gr_block::WORK_DONE ) { LOG_WARN( file_sink_s_base, "WORK RETURNED STOP CONDITION..." << nout ); nout=0; eos = true; } } return nout; }
template < typename IN_PORT_TYPE, typename OUT_PORT_TYPE > int cpfsk_bc_base::_forecastAndProcess( bool &eos, 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; typename _OStreamList::iterator ostream; typename _IStreamList::iterator istream = istreams.begin(); int nout = 0; bool dataReady = false; if ( !eos ) { uint64_t max_items_avail = 0; for ( int idx=0 ; istream != istreams.end() && serviceThread->threadRunning() ; idx++, istream++ ) { LOG_TRACE( cpfsk_bc_base, "GET MAX ITEMS: STREAM:"<< idx << " NITEMS/SCALARS:" << istream->nitems() << "/" << istream->_data.size() ); max_items_avail = std::max( istream->nitems(), max_items_avail ); } if ( max_items_avail == 0 ) { LOG_TRACE( cpfsk_bc_base, "DATA CHECK - MAX ITEMS NOUTPUT/MAX_ITEMS:" << noutput_items << "/" << max_items_avail); return -1; } // // calc number of output elements based on input items available // noutput_items = 0; if ( !gr_sptr->fixed_rate() ) { noutput_items = round_down((int32_t) (max_items_avail * gr_sptr->relative_rate()), gr_sptr->output_multiple()); LOG_TRACE( cpfsk_bc_base, " VARIABLE FORECAST NOUTPUT == " << noutput_items ); } else { istream = istreams.begin(); for ( int i=0; istream != istreams.end(); i++, istream++ ) { int t_noutput_items = gr_sptr->fixed_rate_ninput_to_noutput( istream->nitems() ); if ( gr_sptr->output_multiple_set() ) { t_noutput_items = round_up(t_noutput_items, gr_sptr->output_multiple()); } if ( t_noutput_items > 0 ) { if ( noutput_items == 0 ) { noutput_items = t_noutput_items; } if ( t_noutput_items <= noutput_items ) { noutput_items = t_noutput_items; } } } LOG_TRACE( cpfsk_bc_base, " FIXED FORECAST NOUTPUT/output_multiple == " << noutput_items << "/" << gr_sptr->output_multiple()); } // // ask the block how much input they need to produce noutput_items... // if enough data is available to process then set the dataReady flag // int32_t outMultiple = gr_sptr->output_multiple(); while ( !dataReady && noutput_items >= outMultiple ) { // // ask the block how much input they need to produce noutput_items... // gr_sptr->forecast(noutput_items, _ninput_items_required); LOG_TRACE( cpfsk_bc_base, "--> FORECAST IN/OUT " << _ninput_items_required[0] << "/" << noutput_items ); istream = istreams.begin(); uint32_t dr_cnt=0; for ( int idx=0 ; noutput_items > 0 && istream != istreams.end(); idx++, istream++ ) { // check if buffer has enough elements _input_ready[idx] = false; if ( istream->nitems() >= (uint64_t)_ninput_items_required[idx] ) { _input_ready[idx] = true; dr_cnt++; } LOG_TRACE( cpfsk_bc_base, "ISTREAM DATACHECK NELMS/NITEMS/REQ/READY:" << istream->nelems() << "/" << istream->nitems() << "/" << _ninput_items_required[idx] << "/" << _input_ready[idx]); } if ( dr_cnt < istreams.size() ) { if ( outMultiple > 1 ) { noutput_items -= outMultiple; } else { noutput_items /= 2; } } else { dataReady = true; } LOG_TRACE( cpfsk_bc_base, " TRIM FORECAST NOUTPUT/READY " << noutput_items << "/" << dataReady ); } // check if data is ready... if ( !dataReady ) { LOG_TRACE( cpfsk_bc_base, "DATA CHECK - NOT ENOUGH DATA AVAIL/REQ:" << _istreams[0].nitems() << "/" << _ninput_items_required[0] ); return -1; } // reset looping variables int ritems = 0; int nitems = 0; // reset caching vectors _output_items.clear(); _input_items.clear(); _ninput_items.clear(); istream = istreams.begin(); for ( int idx=0 ; istream != istreams.end(); idx++, istream++ ) { // check if the stream is ready if ( !_input_ready[idx] ) { continue; } // get number of items remaining try { ritems = gr_sptr->nitems_read( idx ); } catch(...){ // something bad has happened, we are missing an input stream LOG_ERROR( cpfsk_bc_base, "MISSING INPUT STREAM FOR GR BLOCK, STREAM ID:" << istream->streamID ); return -2; } nitems = istream->nitems() - ritems; LOG_TRACE( cpfsk_bc_base, " ISTREAM: IDX:" << idx << " ITEMS AVAIL/READ/REQ " << nitems << "/" << ritems << "/" << _ninput_items_required[idx] ); if ( nitems >= _ninput_items_required[idx] && nitems > 0 ) { //remove eos checks ...if ( nitems < _ninput_items_required[idx] ) nitems=0; _ninput_items.push_back( nitems ); _input_items.push_back( (const void *) (istream->read_pointer(ritems)) ); } } // // setup output buffer vector based on noutput.. // ostream = ostreams.begin(); for( ; ostream != ostreams.end(); ostream++ ) { ostream->resize(noutput_items); _output_items.push_back((void*)(ostream->write_pointer()) ); } nout=0; if ( _input_items.size() != 0 && serviceThread->threadRunning() ) { LOG_TRACE( cpfsk_bc_base, " CALLING WORK.....N_OUT:" << noutput_items << " N_IN:" << nitems << " ISTREAMS:" << _input_items.size() << " OSTREAMS:" << _output_items.size()); nout = gr_sptr->general_work( noutput_items, _ninput_items, _input_items, _output_items); LOG_TRACE( cpfsk_bc_base, "RETURN WORK ..... N_OUT:" << nout); } // check for stop condition from work method if ( nout < gr_block::WORK_DONE ) { LOG_WARN( cpfsk_bc_base, "WORK RETURNED STOP CONDITION..." << nout ); nout=0; eos = true; } } if (nout != 0 or eos ) { noutput_items = nout; LOG_TRACE( cpfsk_bc_base, " WORK RETURNED: NOUT : " << nout << " EOS:" << eos); ostream = ostreams.begin(); typename IN_PORT_TYPE::dataTransfer *pkt=NULL; for ( int idx=0 ; ostream != ostreams.end(); idx++, ostream++ ) { pkt=NULL; int inputIdx = idx; if ( (size_t)(inputIdx) >= istreams.size() ) { for ( inputIdx= istreams.size()-1; inputIdx > -1; inputIdx--) { if ( istreams[inputIdx].pkt != NULL ) { pkt = istreams[inputIdx].pkt; break; } } } else { pkt = istreams[inputIdx].pkt; } LOG_TRACE( cpfsk_bc_base, "PUSHING DATA ITEMS/STREAM_ID " << ostream->nitems() << "/" << ostream->streamID ); if ( _maintainTimeStamp ) { // set time stamp for output samples based on input time stamp if ( ostream->nelems() == 0 ) { #ifdef TEST_TIME_STAMP LOG_DEBUG( cpfsk_bc_base, "SEED - TS SRI: xdelta:" << std::setprecision(12) << ostream->sri.xdelta ); LOG_DEBUG( cpfsk_bc_base, "OSTREAM WRITE: maint:" << _maintainTimeStamp ); LOG_DEBUG( cpfsk_bc_base, " mode:" << ostream->tstamp.tcmode ); LOG_DEBUG( cpfsk_bc_base, " status:" << ostream->tstamp.tcstatus ); LOG_DEBUG( cpfsk_bc_base, " offset:" << ostream->tstamp.toff ); LOG_DEBUG( cpfsk_bc_base, " whole:" << std::setprecision(10) << ostream->tstamp.twsec ); LOG_DEBUG( cpfsk_bc_base, "SEED - TS frac:" << std::setprecision(12) << ostream->tstamp.tfsec ); #endif ostream->setTimeStamp( pkt->T, _maintainTimeStamp ); } // write out samples, and set next time stamp based on xdelta and noutput_items ostream->write ( noutput_items, eos ); } else { // use incoming packet's time stamp to forward if ( pkt ) { #ifdef TEST_TIME_STAMP LOG_DEBUG( cpfsk_bc_base, "OSTREAM SRI: items/xdelta:" << noutput_items << "/" << std::setprecision(12) << ostream->sri.xdelta ); LOG_DEBUG( cpfsk_bc_base, "PKT - TS maint:" << _maintainTimeStamp ); LOG_DEBUG( cpfsk_bc_base, " mode:" << pkt->T.tcmode ); LOG_DEBUG( cpfsk_bc_base, " status:" << pkt->T.tcstatus ); LOG_DEBUG( cpfsk_bc_base, " offset:" << pkt->T.toff ); LOG_DEBUG( cpfsk_bc_base, " whole:" << std::setprecision(10) << pkt->T.twsec ); LOG_DEBUG( cpfsk_bc_base, "PKT - TS frac:" << std::setprecision(12) << pkt->T.tfsec ); #endif ostream->write( noutput_items, eos, pkt->T ); } else { #ifdef TEST_TIME_STAMP LOG_DEBUG( cpfsk_bc_base, "OSTREAM SRI: items/xdelta:" << noutput_items << "/" << std::setprecision(12) << ostream->sri.xdelta ); LOG_DEBUG( cpfsk_bc_base, "OSTREAM TOD maint:" << _maintainTimeStamp ); LOG_DEBUG( cpfsk_bc_base, " mode:" << ostream->tstamp.tcmode ); LOG_DEBUG( cpfsk_bc_base, " status:" << ostream->tstamp.tcstatus ); LOG_DEBUG( cpfsk_bc_base, " offset:" << ostream->tstamp.toff ); LOG_DEBUG( cpfsk_bc_base, " whole:" << std::setprecision(10) << ostream->tstamp.twsec ); LOG_DEBUG( cpfsk_bc_base, "OSTREAM TOD frac:" << std::setprecision(12) << ostream->tstamp.tfsec ); #endif // use time of day as time stamp ostream->write( noutput_items, eos, _maintainTimeStamp ); } } } // for ostreams } return nout; }
template<typename T> void encodeImageToPNG (typename std::vector<T>& image_arg, size_t width_arg, size_t height_arg, int image_format_arg, typename std::vector<uint8_t>& pngData_arg, int png_level_arg) { png_structp png_ptr; png_infop info_ptr; volatile int channels; if (image_arg.size () ==0) return; // Get amount of channels switch (image_format_arg) { case PNG_COLOR_TYPE_GRAY: channels = 1; break; case PNG_COLOR_TYPE_GRAY_ALPHA: channels = 2; break; case PNG_COLOR_TYPE_RGB: channels = 3; break; case PNG_COLOR_TYPE_RGB_ALPHA: channels = 4; break; default: channels = 0; break; } // Ensure valid input array assert (image_arg.size () == width_arg*height_arg*channels); // Initialize write structure png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING, 0, 0, 0); assert (png_ptr && "creating png_create_write_structpng_create_write_struct failed"); // Initialize info structure info_ptr = png_create_info_struct (png_ptr); assert (info_ptr && "Could not allocate info struct"); // Setup Exception handling setjmp(png_jmpbuf(png_ptr)); // reserve memory for output data (300kB) pngData_arg.clear (); pngData_arg.reserve (300 * 1024); // Define I/O methods png_set_write_fn (png_ptr, reinterpret_cast<void*> (&pngData_arg), user_write_data, user_flush_data); // Define zlib compression level if (png_level_arg >= 0) { png_set_compression_level (png_ptr, png_level_arg); } else { png_set_compression_level (png_ptr, Z_DEFAULT_COMPRESSION); } // Write header png_set_IHDR (png_ptr, info_ptr, width_arg, height_arg, sizeof(T) * 8, image_format_arg, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); png_write_info (png_ptr, info_ptr); // Write image data size_t y; for (y = 0; y < height_arg; y++) { png_write_row (png_ptr, reinterpret_cast<png_bytep> (&image_arg[y * width_arg * channels])); } // End write png_write_end (png_ptr, 0); if (info_ptr) png_free_data (png_ptr, info_ptr, PNG_FREE_ALL, -1); if (png_ptr) png_destroy_write_struct (&png_ptr, 0); }
template<typename T> void decodePNGImage (typename std::vector<uint8_t>& pngData_arg, typename std::vector<T>& imageData_arg, size_t& width_arg, size_t& height_arg, unsigned int& channels_arg) { int y; png_structp png_ptr; png_infop info_ptr; png_uint_32 png_width; png_uint_32 png_height; int png_bit_depth, png_color_type, png_interlace_type; png_bytep * row_pointers; if (pngData_arg.size () == 0) return; png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING, 0, 0, 0); assert (png_ptr && "creating png_create_write_structpng_create_write_struct failed"); // Initialize info structure info_ptr = png_create_info_struct (png_ptr); assert(info_ptr && "Could not allocate info struct"); // Setup Exception handling setjmp (png_jmpbuf(png_ptr)); uint8_t* input_pointer = &pngData_arg[0]; png_set_read_fn (png_ptr, reinterpret_cast<void*> (&input_pointer), user_read_data); png_read_info (png_ptr, info_ptr); png_get_IHDR (png_ptr, info_ptr, &png_width, &png_height, &png_bit_depth, &png_color_type, &png_interlace_type, NULL, NULL); // ensure a color bit depth of 8 assert(png_bit_depth==sizeof(T)*8); unsigned int png_channels; switch (png_color_type) { case PNG_COLOR_TYPE_GRAY: png_channels = 1; break; case PNG_COLOR_TYPE_GRAY_ALPHA: png_channels = 2; break; case PNG_COLOR_TYPE_RGB: png_channels = 3; break; case PNG_COLOR_TYPE_RGB_ALPHA: png_channels = 4; break; default: png_channels = 0; break; } width_arg = png_width; height_arg = png_height; channels_arg = png_channels; imageData_arg.clear (); imageData_arg.resize (png_height * png_width * png_channels); row_pointers = reinterpret_cast<png_bytep*> (malloc (sizeof(png_bytep) * png_height)); for (y = 0; y < png_height; y++) row_pointers[y] = reinterpret_cast<png_byte*> (&imageData_arg[y * png_width * png_channels]); png_read_image (png_ptr, row_pointers); if (info_ptr) png_free_data (png_ptr, info_ptr, PNG_FREE_ALL, -1); if (png_ptr) png_destroy_read_struct (&png_ptr, 0, 0); if (row_pointers) free (row_pointers); }
void VisusIndexedData::addText(XMLNode& node, const std::vector<std::vector<T > >* items) const { // Count max number of items int maxitems = 0; for (typename std::vector<std::vector<T> >::const_iterator iiter=items->begin(); iiter!=items->end(); ++iiter) maxitems += iiter->size() + 1; // Construct contiguous buffer const int bufsize = sizeof(T) * maxitems; unsigned char* buffer = new unsigned char[bufsize+1]; node.addAttribute("numItems", (long) items->size()); node.addAttribute("bufsize", bufsize); int position = 0; // Copy non-contiguous data into contiguous buffer for (typename std::vector<std::vector<T> >::const_iterator iiter=items->begin(); iiter!=items->end(); ++iiter) { // Save Num Items T value = items->size(); memcpy(&buffer[position], &value, sizeof(T)); position += sizeof(T); // Load Vector's Vector of items into buffer for (typename std::vector<T>::const_iterator idtIter=iiter->begin(); idtIter!=iiter->end(); ++idtIter) { vassert(position < bufsize); memcpy(&buffer[position], &(*idtIter), sizeof(T)); position += sizeof(T); } } vassert(position == bufsize); // Save Buffer out to XML switch (VisusXMLInterface::sWriteXMLDataStorage) { case BASE64: { // Save data as BASE64 XMLParserBase64Tool base64; XMLSTR encoded = base64.encode(buffer, bufsize); node.addText(encoded); } break; case EXTERNAL_FILE: { vwarning("saving data to external file is not yet supported"); } break; case ASCII: { vwarning("saving data to external file is not yet supported"); } break; } delete [] buffer; }
template < typename IN_PORT_TYPE > int tagged_file_sink_b_base::_analyzerServiceFunction( typename std::vector< gr_istream< IN_PORT_TYPE > > &istreams ) { typedef typename std::vector< gr_istream< IN_PORT_TYPE > > _IStreamList; boost::mutex::scoped_lock lock(serviceThreadLock); if ( validGRBlock() == false ) { // create our processing block createBlock(); LOG_DEBUG( tagged_file_sink_b_base, " FINISHED BUILDING GNU RADIO BLOCK"); } // process any Stream ID changes this could affect number of io streams processStreamIdChanges(); if ( !validGRBlock() || istreams.size() == 0 ) { LOG_WARN( tagged_file_sink_b_base, "NO STREAMS ATTACHED TO BLOCK..." ); return NOOP; } // resize data vectors for passing data to GR_BLOCK object _input_ready.resize( istreams.size() ); _ninput_items_required.resize( istreams.size()); _ninput_items.resize( istreams.size()); _input_items.resize(istreams.size()); _output_items.resize(0); // // 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 _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( tagged_file_sink_b_base, " NOT KEEPING UP WITH STREAM ID:" << istream->streamID ); } // RESOLVE issue when SRI changes that could affect the GNU Radio BLOCK if ( istream->sriChanged() ) { LOG_DEBUG( tagged_file_sink_b_base, "SRI CHANGED, STREAMD IDX/ID: " << idx << "/" << istream->pkt->streamID ); } } LOG_TRACE( tagged_file_sink_b_base, "READ NITEMS: " << nitems ); if ( nitems <= 0 && !_istreams[0].eos() ) return NOOP; bool eos = false; int nout = 0; while ( nout > -1 && serviceThread->threadRunning() ) { eos = false; nout = _forecastAndProcess( eos, istreams ); 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(...){} if ( nitems > istream->nitems() ) { LOG_WARN( tagged_file_sink_b_base, "WORK CONSUMED MORE DATA THAN AVAILABLE, READ/AVAILABLE " << nitems << "/" << istream->nitems() ); nitems = istream->nitems(); } istream->consume( nitems ); LOG_TRACE( tagged_file_sink_b_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( tagged_file_sink_b_base, " DATA NOT READY, EOS:" << eos ); _forecastAndProcess( eos, istreams ); } } } if ( eos ) { istream = istreams.begin(); for ( ; istream != istreams.end() ; istream++) { int idx=std::distance( istreams.begin(), istream ); LOG_TRACE( tagged_file_sink_b_base, " CLOSING INPUT STREAM IDX:" << idx ); istream->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( tagged_file_sink_b_base, " END OF ANALYZER SERVICE FUNCTION....." << noutput_items ); if ( nout == -1 && eos == false ) { return NOOP; } else { return NORMAL; } }
int size() const { return m_int2name.size(); }