aboutsummaryrefslogtreecommitdiffstats
path: root/host
diff options
context:
space:
mode:
Diffstat (limited to 'host')
-rw-r--r--host/include/uhd/device.hpp4
-rw-r--r--host/include/uhd/device_deprecated.ipp36
-rw-r--r--host/include/uhd/streamer.hpp16
-rw-r--r--host/lib/convert/convert_impl.cpp10
-rw-r--r--host/lib/transport/super_recv_packet_handler.hpp99
-rw-r--r--host/lib/transport/super_send_packet_handler.hpp121
-rw-r--r--host/tests/CMakeLists.txt4
-rw-r--r--host/tests/sph_recv_test.cpp166
-rw-r--r--host/tests/sph_send_test.cpp44
9 files changed, 212 insertions, 288 deletions
diff --git a/host/include/uhd/device.hpp b/host/include/uhd/device.hpp
index 47afe7dc6..f76739907 100644
--- a/host/include/uhd/device.hpp
+++ b/host/include/uhd/device.hpp
@@ -77,10 +77,10 @@ public:
static sptr make(const device_addr_t &hint, size_t which = 0);
//! Make a new receive streamer given the list of channels
- virtual recv_streamer::sptr get_recv_streamer(const std::vector<size_t> &channels) = 0;
+ virtual rx_streamer::sptr get_rx_streamer(const std::vector<size_t> &channels) = 0;
//! Make a new transmit streamer given the list of channels
- virtual send_streamer::sptr get_send_streamer(const std::vector<size_t> &channels) = 0;
+ virtual tx_streamer::sptr get_tx_streamer(const std::vector<size_t> &channels) = 0;
/*!
* Receive and asynchronous message from the device.
diff --git a/host/include/uhd/device_deprecated.ipp b/host/include/uhd/device_deprecated.ipp
index 4b8ec0037..ba0edb1bc 100644
--- a/host/include/uhd/device_deprecated.ipp
+++ b/host/include/uhd/device_deprecated.ipp
@@ -77,21 +77,21 @@ size_t send(
send_mode_t send_mode,
double timeout = 0.1
){
- if (_send_streamer.get() == NULL or _send_streamer->get_num_channels() != buffs.size()){
+ if (_tx_streamer.get() == NULL or _tx_streamer->get_num_channels() != buffs.size()){
std::vector<size_t> chans(buffs.size());
for (size_t ch = 0; ch < chans.size(); ch++) chans[ch] = ch;
- _send_streamer.reset(); //cleanup possible old one
- _send_streamer = get_send_streamer(chans);
+ _tx_streamer.reset(); //cleanup possible old one
+ _tx_streamer = get_tx_streamer(chans);
_send_tid = io_type_t::CUSTOM_TYPE;
}
if (io_type.tid != _send_tid){
_send_tid = io_type.tid;
- _send_streamer->set_format((_send_tid == io_type_t::COMPLEX_FLOAT32)? "fc32" : "sc16", "sc16");
+ _tx_streamer->set_format((_send_tid == io_type_t::COMPLEX_FLOAT32)? "fc32" : "sc16", "sc16");
}
const size_t nsamps = (send_mode == SEND_MODE_ONE_PACKET)?
std::min(nsamps_per_buff, get_max_send_samps_per_packet()) :
nsamps_per_buff;
- return _send_streamer->send(buffs, nsamps, metadata, timeout);
+ return _tx_streamer->send(buffs, nsamps, metadata, timeout);
}
/*!
@@ -133,21 +133,21 @@ size_t recv(
recv_mode_t recv_mode,
double timeout = 0.1
){
- if (_recv_streamer.get() == NULL or _recv_streamer->get_num_channels() != buffs.size()){
+ if (_rx_streamer.get() == NULL or _rx_streamer->get_num_channels() != buffs.size()){
std::vector<size_t> chans(buffs.size());
for (size_t ch = 0; ch < chans.size(); ch++) chans[ch] = ch;
- _recv_streamer.reset(); //cleanup possible old one
- _recv_streamer = get_recv_streamer(chans);
+ _rx_streamer.reset(); //cleanup possible old one
+ _rx_streamer = get_rx_streamer(chans);
_recv_tid = io_type_t::CUSTOM_TYPE;
}
if (io_type.tid != _recv_tid){
_recv_tid = io_type.tid;
- _recv_streamer->set_format((_recv_tid == io_type_t::COMPLEX_FLOAT32)? "fc32" : "sc16", "sc16");
+ _rx_streamer->set_format((_recv_tid == io_type_t::COMPLEX_FLOAT32)? "fc32" : "sc16", "sc16");
}
const size_t nsamps = (recv_mode == RECV_MODE_ONE_PACKET)?
std::min(nsamps_per_buff, get_max_recv_samps_per_packet()) :
nsamps_per_buff;
- return _recv_streamer->recv(buffs, nsamps, metadata, timeout);
+ return _rx_streamer->recv(buffs, nsamps, metadata, timeout);
}
/*!
@@ -155,11 +155,11 @@ size_t recv(
* \return the number of samples
*/
size_t get_max_send_samps_per_packet(void){
- if (_send_streamer.get() == NULL){
+ if (_tx_streamer.get() == NULL){
std::vector<size_t> chans(1, 0);
- _send_streamer = get_send_streamer(chans);
+ _tx_streamer = get_tx_streamer(chans);
}
- return _send_streamer->get_items_per_packet();
+ return _tx_streamer->get_items_per_packet();
}
/*!
@@ -167,15 +167,15 @@ size_t get_max_send_samps_per_packet(void){
* \return the number of samples
*/
size_t get_max_recv_samps_per_packet(void){
- if (_recv_streamer.get() == NULL){
+ if (_rx_streamer.get() == NULL){
std::vector<size_t> chans(1, 0);
- _recv_streamer = get_recv_streamer(chans);
+ _rx_streamer = get_rx_streamer(chans);
}
- return _recv_streamer->get_items_per_packet();
+ return _rx_streamer->get_items_per_packet();
}
private:
- recv_streamer::sptr _recv_streamer;
+ rx_streamer::sptr _rx_streamer;
io_type_t::tid_t _recv_tid;
- send_streamer::sptr _send_streamer;
+ tx_streamer::sptr _tx_streamer;
io_type_t::tid_t _send_tid;
diff --git a/host/include/uhd/streamer.hpp b/host/include/uhd/streamer.hpp
index dfbe15ec3..d96eeb2b7 100644
--- a/host/include/uhd/streamer.hpp
+++ b/host/include/uhd/streamer.hpp
@@ -90,12 +90,12 @@ public:
};
//! A receive streamer to receive host samples
-class UHD_API recv_streamer : public streamer{
+class UHD_API rx_streamer : public streamer{
public:
- typedef boost::shared_ptr<recv_streamer> sptr;
+ typedef boost::shared_ptr<rx_streamer> sptr;
//! Typedef for a pointer to a single, or a collection of recv buffers
- typedef ref_vector<void *> recv_buffs_type;
+ typedef ref_vector<void *> buffs_type;
/*!
* Receive buffers containing samples described by the metadata.
@@ -123,7 +123,7 @@ public:
* \return the number of samples received or 0 on error
*/
virtual size_t recv(
- const recv_buffs_type &buffs,
+ const buffs_type &buffs,
size_t nsamps_per_buff,
rx_metadata_t &metadata,
double timeout = 0.1
@@ -131,12 +131,12 @@ public:
};
//! A transmit streamer to send host samples
-class UHD_API send_streamer : public streamer{
+class UHD_API tx_streamer : public streamer{
public:
- typedef boost::shared_ptr<send_streamer> sptr;
+ typedef boost::shared_ptr<tx_streamer> sptr;
//! Typedef for a pointer to a single, or a collection of send buffers
- typedef ref_vector<const void *> send_buffs_type;
+ typedef ref_vector<const void *> buffs_type;
/*!
* Send buffers containing samples described by the metadata.
@@ -160,7 +160,7 @@ public:
* \return the number of samples sent
*/
virtual size_t send(
- const send_buffs_type &buffs,
+ const buffs_type &buffs,
size_t nsamps_per_buff,
const tx_metadata_t &metadata,
double timeout = 0.1
diff --git a/host/lib/convert/convert_impl.cpp b/host/lib/convert/convert_impl.cpp
index 2ead2f5b4..5c9e77e93 100644
--- a/host/lib/convert/convert_impl.cpp
+++ b/host/lib/convert/convert_impl.cpp
@@ -114,6 +114,16 @@ void register_bytes_per_item(
size_t convert::get_bytes_per_item(const std::string &markup){
if (get_item_size_table().has_key(markup)) return get_item_size_table()[markup];
+
+ //OK. I am sorry about this.
+ //We didnt find a match, so lets find a match for the first term.
+ //This is partially a hack because of the way I append strings.
+ //But as long as life is kind, we can keep this.
+ const size_t pos = markup.find("_");
+ if (pos != std::string::npos){
+ return get_bytes_per_item(markup.substr(0, pos));
+ }
+
throw uhd::key_error("Cannot find an item size " + markup);
}
diff --git a/host/lib/transport/super_recv_packet_handler.hpp b/host/lib/transport/super_recv_packet_handler.hpp
index 541c588e6..4ae51e146 100644
--- a/host/lib/transport/super_recv_packet_handler.hpp
+++ b/host/lib/transport/super_recv_packet_handler.hpp
@@ -21,11 +21,9 @@
#include <uhd/config.hpp>
#include <uhd/exception.hpp>
#include <uhd/convert.hpp>
-#include <uhd/device.hpp>
+#include <uhd/streamer.hpp>
#include <uhd/utils/msg.hpp>
#include <uhd/utils/byteswap.hpp>
-#include <uhd/types/io_type.hpp>
-#include <uhd/types/otw_type.hpp>
#include <uhd/types/metadata.hpp>
#include <uhd/transport/vrt_if_packet.hpp>
#include <uhd/transport/zero_copy.hpp>
@@ -124,24 +122,12 @@ public:
_props.at(xport_chan).get_buff = get_buff;
}
- /*!
- * Setup the conversion functions (homogeneous across transports).
- * Here, we load a table of converters for all possible io types.
- * This makes the converter look-up an O(1) operation.
- * \param otw_type the channel data type
- * \param width the streams per channel (usually 1)
- */
- void set_converter(const uhd::otw_type_t &otw_type, const size_t width = 1){
- _io_buffs.resize(width);
- _converters.resize(128);
- for (size_t io_type = 0; io_type < _converters.size(); io_type++){
- try{
- _converters[io_type] = uhd::convert::get_converter_otw_to_cpu(
- io_type_t::tid_t(io_type), otw_type, 1, width
- );
- }catch(const uhd::value_error &){} //we expect this, not all io_types valid...
- }
- _bytes_per_item = otw_type.get_sample_size();
+ //! Set the conversion routine for all channels
+ void set_converter(const uhd::convert::id_type &id){
+ _io_buffs.resize(id.num_inputs);
+ _converter = uhd::convert::get_converter(id);
+ _bytes_per_otw_item = uhd::convert::get_bytes_per_item(id.input_markup);
+ _bytes_per_cpu_item = uhd::convert::get_bytes_per_item(id.output_markup);
}
//! Set the transport channel's overflow handler
@@ -165,11 +151,9 @@ public:
* Dispatch into combinations of single packet receive calls.
******************************************************************/
UHD_INLINE size_t recv(
- const uhd::device::recv_buffs_type &buffs,
+ const uhd::rx_streamer::buffs_type &buffs,
const size_t nsamps_per_buff,
uhd::rx_metadata_t &metadata,
- const uhd::io_type_t &io_type,
- uhd::device::recv_mode_t recv_mode,
double timeout
){
boost::mutex::scoped_lock lock(_mutex);
@@ -183,43 +167,32 @@ public:
if (_queue_metadata.error_code != rx_metadata_t::ERROR_CODE_TIMEOUT) return 0;
}
- switch(recv_mode){
-
- ////////////////////////////////////////////////////////////////
- case uhd::device::RECV_MODE_ONE_PACKET:{
- ////////////////////////////////////////////////////////////////
- return recv_one_packet(buffs, nsamps_per_buff, metadata, io_type, timeout);
- }
+ size_t accum_num_samps = recv_one_packet(
+ buffs, nsamps_per_buff, metadata, timeout
+ );
- ////////////////////////////////////////////////////////////////
- case uhd::device::RECV_MODE_FULL_BUFF:{
- ////////////////////////////////////////////////////////////////
- size_t accum_num_samps = recv_one_packet(
- buffs, nsamps_per_buff, metadata, io_type, timeout
- );
+ #ifdef SRPH_TEST_MODE_ONE_PACKET
+ return accum_num_samps;
+ #endif
- //first recv had an error code set, return immediately
- if (metadata.error_code != rx_metadata_t::ERROR_CODE_NONE) return accum_num_samps;
+ //first recv had an error code set, return immediately
+ if (metadata.error_code != rx_metadata_t::ERROR_CODE_NONE) return accum_num_samps;
- //loop until buffer is filled or error code
- while(accum_num_samps < nsamps_per_buff){
- size_t num_samps = recv_one_packet(
- buffs, nsamps_per_buff - accum_num_samps, _queue_metadata,
- io_type, timeout, accum_num_samps*io_type.size
- );
+ //loop until buffer is filled or error code
+ while(accum_num_samps < nsamps_per_buff){
+ size_t num_samps = recv_one_packet(
+ buffs, nsamps_per_buff - accum_num_samps, _queue_metadata,
+ timeout, accum_num_samps*_bytes_per_cpu_item
+ );
- //metadata had an error code set, store for next call and return
- if (_queue_metadata.error_code != rx_metadata_t::ERROR_CODE_NONE){
- _queue_error_for_next_call = true;
- break;
- }
- accum_num_samps += num_samps;
+ //metadata had an error code set, store for next call and return
+ if (_queue_metadata.error_code != rx_metadata_t::ERROR_CODE_NONE){
+ _queue_error_for_next_call = true;
+ break;
}
- return accum_num_samps;
+ accum_num_samps += num_samps;
}
-
- default: throw uhd::value_error("unknown recv mode");
- }//switch(recv_mode)
+ return accum_num_samps;
}
private:
@@ -242,8 +215,9 @@ private:
};
std::vector<xport_chan_props_type> _props;
std::vector<void *> _io_buffs; //used in conversion
- size_t _bytes_per_item; //used in conversion
- std::vector<uhd::convert::function_type> _converters; //used in conversion
+ size_t _bytes_per_otw_item; //used in conversion
+ size_t _bytes_per_cpu_item; //used in conversion
+ uhd::convert::function_type _converter; //used in conversion
double _scale_factor;
//! information stored for a received buffer
@@ -471,7 +445,7 @@ private:
std::swap(curr_info, next_info); //save progress from curr -> next
curr_info.metadata.has_time_spec = prev_info.metadata.has_time_spec;
curr_info.metadata.time_spec = prev_info.metadata.time_spec + time_spec_t(0,
- prev_info[index].ifpi.num_payload_words32*sizeof(boost::uint32_t)/_bytes_per_item, _samp_rate);
+ prev_info[index].ifpi.num_payload_words32*sizeof(boost::uint32_t)/_bytes_per_otw_item, _samp_rate);
curr_info.metadata.more_fragments = false;
curr_info.metadata.fragment_offset = 0;
curr_info.metadata.start_of_burst = false;
@@ -525,10 +499,9 @@ private:
* Then copy-convert available data into the user's IO buffers.
******************************************************************/
UHD_INLINE size_t recv_one_packet(
- const uhd::device::recv_buffs_type &buffs,
+ const uhd::rx_streamer::buffs_type &buffs,
const size_t nsamps_per_buff,
uhd::rx_metadata_t &metadata,
- const uhd::io_type_t &io_type,
double timeout,
const size_t buffer_offset_bytes = 0
){
@@ -551,9 +524,9 @@ private:
metadata.time_spec += time_spec_t(0, info.fragment_offset_in_samps, _samp_rate);
//extract the number of samples available to copy
- const size_t nsamps_available = info.data_bytes_to_copy/_bytes_per_item;
+ const size_t nsamps_available = info.data_bytes_to_copy/_bytes_per_otw_item;
const size_t nsamps_to_copy = std::min(nsamps_per_buff*_io_buffs.size(), nsamps_available);
- const size_t bytes_to_copy = nsamps_to_copy*_bytes_per_item;
+ const size_t bytes_to_copy = nsamps_to_copy*_bytes_per_otw_item;
const size_t nsamps_to_copy_per_io_buff = nsamps_to_copy/_io_buffs.size();
size_t buff_index = 0;
@@ -565,7 +538,7 @@ private:
}
//copy-convert the samples from the recv buffer
- _converters[io_type.tid](buff_info.copy_buff, _io_buffs, nsamps_to_copy_per_io_buff, _scale_factor);
+ _converter(buff_info.copy_buff, _io_buffs, nsamps_to_copy_per_io_buff, _scale_factor);
//update the rx copy buffer to reflect the bytes copied
buff_info.copy_buff += bytes_to_copy;
diff --git a/host/lib/transport/super_send_packet_handler.hpp b/host/lib/transport/super_send_packet_handler.hpp
index a99adcb5f..6950abb73 100644
--- a/host/lib/transport/super_send_packet_handler.hpp
+++ b/host/lib/transport/super_send_packet_handler.hpp
@@ -21,11 +21,9 @@
#include <uhd/config.hpp>
#include <uhd/exception.hpp>
#include <uhd/convert.hpp>
-#include <uhd/device.hpp>
+#include <uhd/streamer.hpp>
#include <uhd/utils/msg.hpp>
#include <uhd/utils/byteswap.hpp>
-#include <uhd/types/io_type.hpp>
-#include <uhd/types/otw_type.hpp>
#include <uhd/types/metadata.hpp>
#include <uhd/transport/vrt_if_packet.hpp>
#include <uhd/transport/zero_copy.hpp>
@@ -100,24 +98,12 @@ public:
_props.at(xport_chan).get_buff = get_buff;
}
- /*!
- * Setup the conversion functions (homogeneous across transports).
- * Here, we load a table of converters for all possible io types.
- * This makes the converter look-up an O(1) operation.
- * \param otw_type the channel data type
- * \param width the streams per channel (usually 1)
- */
- void set_converter(const uhd::otw_type_t &otw_type, const size_t width = 1){
- _io_buffs.resize(width);
- _converters.resize(128);
- for (size_t io_type = 0; io_type < _converters.size(); io_type++){
- try{
- _converters[io_type] = uhd::convert::get_converter_cpu_to_otw(
- io_type_t::tid_t(io_type), otw_type, 1, width
- );
- }catch(const uhd::value_error &){} //we expect this, not all io_types valid...
- }
- _bytes_per_item = otw_type.get_sample_size();
+ //! Set the conversion routine for all channels
+ void set_converter(const uhd::convert::id_type &id){
+ _io_buffs.resize(id.num_outputs);
+ _converter = uhd::convert::get_converter(id);
+ _bytes_per_otw_item = uhd::convert::get_bytes_per_item(id.output_markup);
+ _bytes_per_cpu_item = uhd::convert::get_bytes_per_item(id.input_markup);
}
/*!
@@ -145,11 +131,9 @@ public:
* Dispatch into combinations of single packet send calls.
******************************************************************/
UHD_INLINE size_t send(
- const uhd::device::send_buffs_type &buffs,
+ const uhd::tx_streamer::buffs_type &buffs,
const size_t nsamps_per_buff,
const uhd::tx_metadata_t &metadata,
- const uhd::io_type_t &io_type,
- uhd::device::send_mode_t send_mode,
double timeout
){
boost::mutex::scoped_lock lock(_mutex);
@@ -166,69 +150,52 @@ public:
if_packet_info.sob = metadata.start_of_burst;
if_packet_info.eob = metadata.end_of_burst;
- if (nsamps_per_buff <= _max_samples_per_packet) send_mode = uhd::device::SEND_MODE_ONE_PACKET;
- switch(send_mode){
-
- ////////////////////////////////////////////////////////////////
- case uhd::device::SEND_MODE_ONE_PACKET:{
- ////////////////////////////////////////////////////////////////
+ if (nsamps_per_buff <= _max_samples_per_packet){
//TODO remove this code when sample counts of zero are supported by hardware
#ifndef SSPH_DONT_PAD_TO_ONE
if (nsamps_per_buff == 0) return send_one_packet(
- _zero_buffs, 1, if_packet_info, io_type, timeout
+ _zero_buffs, 1, if_packet_info, timeout
) & 0x0;
#endif
- return send_one_packet(
- buffs,
- std::min(nsamps_per_buff, _max_samples_per_packet),
- if_packet_info, io_type, timeout
- );
+ return send_one_packet(buffs, nsamps_per_buff, if_packet_info, timeout);
}
+ size_t total_num_samps_sent = 0;
- ////////////////////////////////////////////////////////////////
- case uhd::device::SEND_MODE_FULL_BUFF:{
- ////////////////////////////////////////////////////////////////
- size_t total_num_samps_sent = 0;
+ //false until final fragment
+ if_packet_info.eob = false;
- //false until final fragment
- if_packet_info.eob = false;
+ const size_t num_fragments = (nsamps_per_buff-1)/_max_samples_per_packet;
+ const size_t final_length = ((nsamps_per_buff-1)%_max_samples_per_packet)+1;
- const size_t num_fragments = (nsamps_per_buff-1)/_max_samples_per_packet;
- const size_t final_length = ((nsamps_per_buff-1)%_max_samples_per_packet)+1;
+ //loop through the following fragment indexes
+ for (size_t i = 0; i < num_fragments; i++){
- //loop through the following fragment indexes
- for (size_t i = 0; i < num_fragments; i++){
-
- //send a fragment with the helper function
- const size_t num_samps_sent = send_one_packet(
- buffs, _max_samples_per_packet,
- if_packet_info, io_type, timeout,
- total_num_samps_sent*io_type.size
- );
- total_num_samps_sent += num_samps_sent;
- if (num_samps_sent == 0) return total_num_samps_sent;
+ //send a fragment with the helper function
+ const size_t num_samps_sent = send_one_packet(
+ buffs, _max_samples_per_packet,
+ if_packet_info, timeout,
+ total_num_samps_sent*_bytes_per_cpu_item
+ );
+ total_num_samps_sent += num_samps_sent;
+ if (num_samps_sent == 0) return total_num_samps_sent;
- //setup metadata for the next fragment
- const time_spec_t time_spec = metadata.time_spec + time_spec_t(0, total_num_samps_sent, _samp_rate);
- if_packet_info.tsi = boost::uint32_t(time_spec.get_full_secs());
- if_packet_info.tsf = boost::uint64_t(time_spec.get_tick_count(_tick_rate));
- if_packet_info.sob = false;
+ //setup metadata for the next fragment
+ const time_spec_t time_spec = metadata.time_spec + time_spec_t(0, total_num_samps_sent, _samp_rate);
+ if_packet_info.tsi = boost::uint32_t(time_spec.get_full_secs());
+ if_packet_info.tsf = boost::uint64_t(time_spec.get_tick_count(_tick_rate));
+ if_packet_info.sob = false;
- }
-
- //send the final fragment with the helper function
- if_packet_info.eob = metadata.end_of_burst;
- return total_num_samps_sent + send_one_packet(
- buffs, final_length,
- if_packet_info, io_type, timeout,
- total_num_samps_sent*io_type.size
- );
}
- default: throw uhd::value_error("unknown send mode");
- }//switch(send_mode)
+ //send the final fragment with the helper function
+ if_packet_info.eob = metadata.end_of_burst;
+ return total_num_samps_sent + send_one_packet(
+ buffs, final_length,
+ if_packet_info, timeout,
+ total_num_samps_sent*_bytes_per_cpu_item
+ );
}
private:
@@ -242,8 +209,9 @@ private:
};
std::vector<xport_chan_props_type> _props;
std::vector<const void *> _io_buffs; //used in conversion
- size_t _bytes_per_item; //used in conversion
- std::vector<uhd::convert::function_type> _converters; //used in conversion
+ size_t _bytes_per_otw_item; //used in conversion
+ size_t _bytes_per_cpu_item; //used in conversion
+ uhd::convert::function_type _converter; //used in conversion
size_t _max_samples_per_packet;
std::vector<const void *> _zero_buffs;
size_t _next_packet_seq;
@@ -253,15 +221,14 @@ private:
* Send a single packet:
******************************************************************/
UHD_INLINE size_t send_one_packet(
- const uhd::device::send_buffs_type &buffs,
+ const uhd::tx_streamer::buffs_type &buffs,
const size_t nsamps_per_buff,
vrt::if_packet_info_t &if_packet_info,
- const uhd::io_type_t &io_type,
double timeout,
const size_t buffer_offset_bytes = 0
){
//load the rest of the if_packet_info in here
- if_packet_info.num_payload_words32 = (nsamps_per_buff*_io_buffs.size()*_bytes_per_item)/sizeof(boost::uint32_t);
+ if_packet_info.num_payload_words32 = (nsamps_per_buff*_io_buffs.size()*_bytes_per_otw_item)/sizeof(boost::uint32_t);
if_packet_info.packet_count = _next_packet_seq;
size_t buff_index = 0;
@@ -280,7 +247,7 @@ private:
otw_mem += if_packet_info.num_header_words32;
//copy-convert the samples into the send buffer
- _converters[io_type.tid](_io_buffs, otw_mem, nsamps_per_buff, _scale_factor);
+ _converter(_io_buffs, otw_mem, nsamps_per_buff, _scale_factor);
//commit the samples to the zero-copy interface
size_t num_bytes_total = (_header_offset_words32+if_packet_info.num_packet_words32)*sizeof(boost::uint32_t);
diff --git a/host/tests/CMakeLists.txt b/host/tests/CMakeLists.txt
index 25679a33e..28cc1c5da 100644
--- a/host/tests/CMakeLists.txt
+++ b/host/tests/CMakeLists.txt
@@ -29,8 +29,8 @@ SET(test_sources
msg_test.cpp
property_test.cpp
ranges_test.cpp
- #TODO restore sph_recv_test.cpp
- #TODO restore sph_send_test.cpp
+ sph_recv_test.cpp
+ sph_send_test.cpp
subdev_spec_test.cpp
time_spec_test.cpp
vrt_test.cpp
diff --git a/host/tests/sph_recv_test.cpp b/host/tests/sph_recv_test.cpp
index 1387e3b66..3ca123ef2 100644
--- a/host/tests/sph_recv_test.cpp
+++ b/host/tests/sph_recv_test.cpp
@@ -16,6 +16,7 @@
//
#include <boost/test/unit_test.hpp>
+#define SRPH_TEST_MODE_ONE_PACKET
#include "../lib/transport/super_recv_packet_handler.hpp"
#include <boost/shared_array.hpp>
#include <boost/bind.hpp>
@@ -67,8 +68,8 @@ private:
**********************************************************************/
class dummy_recv_xport_class{
public:
- dummy_recv_xport_class(const uhd::otw_type_t &otw_type){
- _otw_type = otw_type;
+ dummy_recv_xport_class(const std::string &end){
+ _end = end;
}
void push_back_packet(
@@ -77,10 +78,10 @@ public:
){
const size_t max_pkt_len = (ifpi.num_payload_words32 + uhd::transport::vrt::max_if_hdr_words32 + 1/*tlr*/)*sizeof(boost::uint32_t);
_mems.push_back(boost::shared_array<char>(new char[max_pkt_len]));
- if (_otw_type.byteorder == uhd::otw_type_t::BO_BIG_ENDIAN){
+ if (_end == "big"){
uhd::transport::vrt::if_hdr_pack_be(reinterpret_cast<boost::uint32_t *>(_mems.back().get()), ifpi);
}
- if (_otw_type.byteorder == uhd::otw_type_t::BO_LITTLE_ENDIAN){
+ if (_end == "little"){
uhd::transport::vrt::if_hdr_pack_le(reinterpret_cast<boost::uint32_t *>(_mems.back().get()), ifpi);
}
(reinterpret_cast<boost::uint32_t *>(_mems.back().get()) + ifpi.num_header_words32)[0] = optional_msg_word | uhd::byteswap(optional_msg_word);
@@ -100,18 +101,19 @@ private:
std::list<boost::shared_array<char> > _mems;
std::list<size_t> _lens;
std::list<dummy_mrb> _mrbs; //list means no-realloc
- uhd::otw_type_t _otw_type;
+ std::string _end;
};
////////////////////////////////////////////////////////////////////////
BOOST_AUTO_TEST_CASE(test_sph_recv_one_channel_normal){
////////////////////////////////////////////////////////////////////////
- uhd::otw_type_t otw_type;
- otw_type.width = 16;
- otw_type.shift = 0;
- otw_type.byteorder = uhd::otw_type_t::BO_BIG_ENDIAN;
+ uhd::convert::id_type id;
+ id.input_markup = "sc16_item32_be";
+ id.num_inputs = 1;
+ id.output_markup = "fc32";
+ id.num_outputs = 1;
- dummy_recv_xport_class dummy_recv_xport(otw_type);
+ dummy_recv_xport_class dummy_recv_xport("big");
uhd::transport::vrt::if_packet_info_t ifpi;
ifpi.packet_type = uhd::transport::vrt::if_packet_info_t::PACKET_TYPE_DATA;
ifpi.num_payload_words32 = 0;
@@ -144,7 +146,7 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_one_channel_normal){
handler.set_tick_rate(TICK_RATE);
handler.set_samp_rate(SAMP_RATE);
handler.set_xport_chan_get_buff(0, boost::bind(&dummy_recv_xport_class::get_recv_buff, &dummy_recv_xport, _1));
- handler.set_converter(otw_type);
+ handler.set_converter(id);
//check the received packets
size_t num_accum_samps = 0;
@@ -153,9 +155,7 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_one_channel_normal){
for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++){
std::cout << "data check " << i << std::endl;
size_t num_samps_ret = handler.recv(
- &buff.front(), buff.size(), metadata,
- uhd::io_type_t::COMPLEX_FLOAT32,
- uhd::device::RECV_MODE_ONE_PACKET, 1.0
+ &buff.front(), buff.size(), metadata, 1.0
);
BOOST_CHECK_EQUAL(metadata.error_code, uhd::rx_metadata_t::ERROR_CODE_NONE);
BOOST_CHECK(not metadata.more_fragments);
@@ -169,9 +169,7 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_one_channel_normal){
for (size_t i = 0; i < 3; i++){
std::cout << "timeout check " << i << std::endl;
handler.recv(
- &buff.front(), buff.size(), metadata,
- uhd::io_type_t::COMPLEX_FLOAT32,
- uhd::device::RECV_MODE_ONE_PACKET, 1.0
+ &buff.front(), buff.size(), metadata, 1.0
);
BOOST_CHECK_EQUAL(metadata.error_code, uhd::rx_metadata_t::ERROR_CODE_TIMEOUT);
}
@@ -180,12 +178,13 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_one_channel_normal){
////////////////////////////////////////////////////////////////////////
BOOST_AUTO_TEST_CASE(test_sph_recv_one_channel_sequence_error){
////////////////////////////////////////////////////////////////////////
- uhd::otw_type_t otw_type;
- otw_type.width = 16;
- otw_type.shift = 0;
- otw_type.byteorder = uhd::otw_type_t::BO_BIG_ENDIAN;
+ uhd::convert::id_type id;
+ id.input_markup = "sc16_item32_be";
+ id.num_inputs = 1;
+ id.output_markup = "fc32";
+ id.num_outputs = 1;
- dummy_recv_xport_class dummy_recv_xport(otw_type);
+ dummy_recv_xport_class dummy_recv_xport("big");
uhd::transport::vrt::if_packet_info_t ifpi;
ifpi.packet_type = uhd::transport::vrt::if_packet_info_t::PACKET_TYPE_DATA;
ifpi.num_payload_words32 = 0;
@@ -220,7 +219,7 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_one_channel_sequence_error){
handler.set_tick_rate(TICK_RATE);
handler.set_samp_rate(SAMP_RATE);
handler.set_xport_chan_get_buff(0, boost::bind(&dummy_recv_xport_class::get_recv_buff, &dummy_recv_xport, _1));
- handler.set_converter(otw_type);
+ handler.set_converter(id);
//check the received packets
size_t num_accum_samps = 0;
@@ -229,9 +228,7 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_one_channel_sequence_error){
for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++){
std::cout << "data check " << i << std::endl;
size_t num_samps_ret = handler.recv(
- &buff.front(), buff.size(), metadata,
- uhd::io_type_t::COMPLEX_FLOAT32,
- uhd::device::RECV_MODE_ONE_PACKET, 1.0
+ &buff.front(), buff.size(), metadata, 1.0
);
if (i == NUM_PKTS_TO_TEST/2){
//must get the soft overflow here
@@ -253,9 +250,7 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_one_channel_sequence_error){
for (size_t i = 0; i < 3; i++){
std::cout << "timeout check " << i << std::endl;
handler.recv(
- &buff.front(), buff.size(), metadata,
- uhd::io_type_t::COMPLEX_FLOAT32,
- uhd::device::RECV_MODE_ONE_PACKET, 1.0
+ &buff.front(), buff.size(), metadata, 1.0
);
BOOST_CHECK_EQUAL(metadata.error_code, uhd::rx_metadata_t::ERROR_CODE_TIMEOUT);
}
@@ -264,12 +259,13 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_one_channel_sequence_error){
////////////////////////////////////////////////////////////////////////
BOOST_AUTO_TEST_CASE(test_sph_recv_one_channel_inline_message){
////////////////////////////////////////////////////////////////////////
- uhd::otw_type_t otw_type;
- otw_type.width = 16;
- otw_type.shift = 0;
- otw_type.byteorder = uhd::otw_type_t::BO_BIG_ENDIAN;
+ uhd::convert::id_type id;
+ id.input_markup = "sc16_item32_be";
+ id.num_inputs = 1;
+ id.output_markup = "fc32";
+ id.num_outputs = 1;
- dummy_recv_xport_class dummy_recv_xport(otw_type);
+ dummy_recv_xport_class dummy_recv_xport("big");
uhd::transport::vrt::if_packet_info_t ifpi;
ifpi.packet_type = uhd::transport::vrt::if_packet_info_t::PACKET_TYPE_DATA;
ifpi.num_payload_words32 = 0;
@@ -310,7 +306,7 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_one_channel_inline_message){
handler.set_tick_rate(TICK_RATE);
handler.set_samp_rate(SAMP_RATE);
handler.set_xport_chan_get_buff(0, boost::bind(&dummy_recv_xport_class::get_recv_buff, &dummy_recv_xport, _1));
- handler.set_converter(otw_type);
+ handler.set_converter(id);
//create an overflow handler
overflow_handler_type overflow_handler;
@@ -323,9 +319,7 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_one_channel_inline_message){
for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++){
std::cout << "data check " << i << std::endl;
size_t num_samps_ret = handler.recv(
- &buff.front(), buff.size(), metadata,
- uhd::io_type_t::COMPLEX_FLOAT32,
- uhd::device::RECV_MODE_ONE_PACKET, 1.0
+ &buff.front(), buff.size(), metadata, 1.0
);
BOOST_CHECK_EQUAL(metadata.error_code, uhd::rx_metadata_t::ERROR_CODE_NONE);
BOOST_CHECK(not metadata.more_fragments);
@@ -335,9 +329,7 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_one_channel_inline_message){
num_accum_samps += num_samps_ret;
if (i == NUM_PKTS_TO_TEST/2){
handler.recv(
- &buff.front(), buff.size(), metadata,
- uhd::io_type_t::COMPLEX_FLOAT32,
- uhd::device::RECV_MODE_ONE_PACKET, 1.0
+ &buff.front(), buff.size(), metadata, 1.0
);
std::cout << "metadata.error_code " << metadata.error_code << std::endl;
BOOST_REQUIRE(metadata.error_code == uhd::rx_metadata_t::ERROR_CODE_OVERFLOW);
@@ -350,9 +342,7 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_one_channel_inline_message){
for (size_t i = 0; i < 3; i++){
std::cout << "timeout check " << i << std::endl;
handler.recv(
- &buff.front(), buff.size(), metadata,
- uhd::io_type_t::COMPLEX_FLOAT32,
- uhd::device::RECV_MODE_ONE_PACKET, 1.0
+ &buff.front(), buff.size(), metadata, 1.0
);
BOOST_CHECK_EQUAL(metadata.error_code, uhd::rx_metadata_t::ERROR_CODE_TIMEOUT);
}
@@ -361,10 +351,11 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_one_channel_inline_message){
////////////////////////////////////////////////////////////////////////
BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_normal){
////////////////////////////////////////////////////////////////////////
- uhd::otw_type_t otw_type;
- otw_type.width = 16;
- otw_type.shift = 0;
- otw_type.byteorder = uhd::otw_type_t::BO_BIG_ENDIAN;
+ uhd::convert::id_type id;
+ id.input_markup = "sc16_item32_be";
+ id.num_inputs = 1;
+ id.output_markup = "fc32";
+ id.num_outputs = 1;
uhd::transport::vrt::if_packet_info_t ifpi;
ifpi.packet_type = uhd::transport::vrt::if_packet_info_t::PACKET_TYPE_DATA;
@@ -386,7 +377,7 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_normal){
static const size_t NUM_SAMPS_PER_BUFF = 20;
static const size_t NCHANNELS = 4;
- std::vector<dummy_recv_xport_class> dummy_recv_xports(NCHANNELS, dummy_recv_xport_class(otw_type));
+ std::vector<dummy_recv_xport_class> dummy_recv_xports(NCHANNELS, dummy_recv_xport_class("big"));
//generate a bunch of packets
for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++){
@@ -406,7 +397,7 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_normal){
for (size_t ch = 0; ch < NCHANNELS; ch++){
handler.set_xport_chan_get_buff(ch, boost::bind(&dummy_recv_xport_class::get_recv_buff, &dummy_recv_xports[ch], _1));
}
- handler.set_converter(otw_type);
+ handler.set_converter(id);
//check the received packets
size_t num_accum_samps = 0;
@@ -419,9 +410,7 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_normal){
for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++){
std::cout << "data check " << i << std::endl;
size_t num_samps_ret = handler.recv(
- buffs, NUM_SAMPS_PER_BUFF, metadata,
- uhd::io_type_t::COMPLEX_FLOAT32,
- uhd::device::RECV_MODE_ONE_PACKET, 1.0
+ buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0
);
BOOST_CHECK_EQUAL(metadata.error_code, uhd::rx_metadata_t::ERROR_CODE_NONE);
BOOST_CHECK(not metadata.more_fragments);
@@ -435,9 +424,7 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_normal){
for (size_t i = 0; i < 3; i++){
std::cout << "timeout check " << i << std::endl;
handler.recv(
- buffs, NUM_SAMPS_PER_BUFF, metadata,
- uhd::io_type_t::COMPLEX_FLOAT32,
- uhd::device::RECV_MODE_ONE_PACKET, 1.0
+ buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0
);
BOOST_CHECK_EQUAL(metadata.error_code, uhd::rx_metadata_t::ERROR_CODE_TIMEOUT);
}
@@ -447,10 +434,11 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_normal){
////////////////////////////////////////////////////////////////////////
BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_sequence_error){
////////////////////////////////////////////////////////////////////////
- uhd::otw_type_t otw_type;
- otw_type.width = 16;
- otw_type.shift = 0;
- otw_type.byteorder = uhd::otw_type_t::BO_BIG_ENDIAN;
+ uhd::convert::id_type id;
+ id.input_markup = "sc16_item32_be";
+ id.num_inputs = 1;
+ id.output_markup = "fc32";
+ id.num_outputs = 1;
uhd::transport::vrt::if_packet_info_t ifpi;
ifpi.packet_type = uhd::transport::vrt::if_packet_info_t::PACKET_TYPE_DATA;
@@ -472,7 +460,7 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_sequence_error){
static const size_t NUM_SAMPS_PER_BUFF = 20;
static const size_t NCHANNELS = 4;
- std::vector<dummy_recv_xport_class> dummy_recv_xports(NCHANNELS, dummy_recv_xport_class(otw_type));
+ std::vector<dummy_recv_xport_class> dummy_recv_xports(NCHANNELS, dummy_recv_xport_class("big"));
//generate a bunch of packets
for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++){
@@ -495,7 +483,7 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_sequence_error){
for (size_t ch = 0; ch < NCHANNELS; ch++){
handler.set_xport_chan_get_buff(ch, boost::bind(&dummy_recv_xport_class::get_recv_buff, &dummy_recv_xports[ch], _1));
}
- handler.set_converter(otw_type);
+ handler.set_converter(id);
//check the received packets
size_t num_accum_samps = 0;
@@ -508,9 +496,7 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_sequence_error){
for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++){
std::cout << "data check " << i << std::endl;
size_t num_samps_ret = handler.recv(
- buffs, NUM_SAMPS_PER_BUFF, metadata,
- uhd::io_type_t::COMPLEX_FLOAT32,
- uhd::device::RECV_MODE_ONE_PACKET, 1.0
+ buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0
);
if (i == NUM_PKTS_TO_TEST/2){
//must get the soft overflow here
@@ -532,9 +518,7 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_sequence_error){
for (size_t i = 0; i < 3; i++){
std::cout << "timeout check " << i << std::endl;
handler.recv(
- buffs, NUM_SAMPS_PER_BUFF, metadata,
- uhd::io_type_t::COMPLEX_FLOAT32,
- uhd::device::RECV_MODE_ONE_PACKET, 1.0
+ buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0
);
BOOST_CHECK_EQUAL(metadata.error_code, uhd::rx_metadata_t::ERROR_CODE_TIMEOUT);
}
@@ -543,10 +527,11 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_sequence_error){
////////////////////////////////////////////////////////////////////////
BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_time_error){
////////////////////////////////////////////////////////////////////////
- uhd::otw_type_t otw_type;
- otw_type.width = 16;
- otw_type.shift = 0;
- otw_type.byteorder = uhd::otw_type_t::BO_BIG_ENDIAN;
+ uhd::convert::id_type id;
+ id.input_markup = "sc16_item32_be";
+ id.num_inputs = 1;
+ id.output_markup = "fc32";
+ id.num_outputs = 1;
uhd::transport::vrt::if_packet_info_t ifpi;
ifpi.packet_type = uhd::transport::vrt::if_packet_info_t::PACKET_TYPE_DATA;
@@ -568,7 +553,7 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_time_error){
static const size_t NUM_SAMPS_PER_BUFF = 20;
static const size_t NCHANNELS = 4;
- std::vector<dummy_recv_xport_class> dummy_recv_xports(NCHANNELS, dummy_recv_xport_class(otw_type));
+ std::vector<dummy_recv_xport_class> dummy_recv_xports(NCHANNELS, dummy_recv_xport_class("big"));
//generate a bunch of packets
for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++){
@@ -591,7 +576,7 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_time_error){
for (size_t ch = 0; ch < NCHANNELS; ch++){
handler.set_xport_chan_get_buff(ch, boost::bind(&dummy_recv_xport_class::get_recv_buff, &dummy_recv_xports[ch], _1));
}
- handler.set_converter(otw_type);
+ handler.set_converter(id);
//check the received packets
size_t num_accum_samps = 0;
@@ -604,9 +589,7 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_time_error){
for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++){
std::cout << "data check " << i << std::endl;
size_t num_samps_ret = handler.recv(
- buffs, NUM_SAMPS_PER_BUFF, metadata,
- uhd::io_type_t::COMPLEX_FLOAT32,
- uhd::device::RECV_MODE_ONE_PACKET, 1.0
+ buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0
);
BOOST_CHECK_EQUAL(metadata.error_code, uhd::rx_metadata_t::ERROR_CODE_NONE);
BOOST_CHECK(not metadata.more_fragments);
@@ -623,9 +606,7 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_time_error){
for (size_t i = 0; i < 3; i++){
std::cout << "timeout check " << i << std::endl;
handler.recv(
- buffs, NUM_SAMPS_PER_BUFF, metadata,
- uhd::io_type_t::COMPLEX_FLOAT32,
- uhd::device::RECV_MODE_ONE_PACKET, 1.0
+ buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0
);
BOOST_CHECK_EQUAL(metadata.error_code, uhd::rx_metadata_t::ERROR_CODE_TIMEOUT);
}
@@ -634,10 +615,11 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_time_error){
////////////////////////////////////////////////////////////////////////
BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_fragment){
////////////////////////////////////////////////////////////////////////
- uhd::otw_type_t otw_type;
- otw_type.width = 16;
- otw_type.shift = 0;
- otw_type.byteorder = uhd::otw_type_t::BO_BIG_ENDIAN;
+ uhd::convert::id_type id;
+ id.input_markup = "sc16_item32_be";
+ id.num_inputs = 1;
+ id.output_markup = "fc32";
+ id.num_outputs = 1;
uhd::transport::vrt::if_packet_info_t ifpi;
ifpi.packet_type = uhd::transport::vrt::if_packet_info_t::PACKET_TYPE_DATA;
@@ -659,7 +641,7 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_fragment){
static const size_t NUM_SAMPS_PER_BUFF = 10;
static const size_t NCHANNELS = 4;
- std::vector<dummy_recv_xport_class> dummy_recv_xports(NCHANNELS, dummy_recv_xport_class(otw_type));
+ std::vector<dummy_recv_xport_class> dummy_recv_xports(NCHANNELS, dummy_recv_xport_class("big"));
//generate a bunch of packets
for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++){
@@ -679,7 +661,7 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_fragment){
for (size_t ch = 0; ch < NCHANNELS; ch++){
handler.set_xport_chan_get_buff(ch, boost::bind(&dummy_recv_xport_class::get_recv_buff, &dummy_recv_xports[ch], _1));
}
- handler.set_converter(otw_type);
+ handler.set_converter(id);
//check the received packets
size_t num_accum_samps = 0;
@@ -692,9 +674,7 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_fragment){
for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++){
std::cout << "data check " << i << std::endl;
size_t num_samps_ret = handler.recv(
- buffs, NUM_SAMPS_PER_BUFF, metadata,
- uhd::io_type_t::COMPLEX_FLOAT32,
- uhd::device::RECV_MODE_ONE_PACKET, 1.0
+ buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0
);
BOOST_CHECK_EQUAL(metadata.error_code, uhd::rx_metadata_t::ERROR_CODE_NONE);
BOOST_CHECK(metadata.has_time_spec);
@@ -705,9 +685,7 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_fragment){
if (not metadata.more_fragments) continue;
num_samps_ret = handler.recv(
- buffs, NUM_SAMPS_PER_BUFF, metadata,
- uhd::io_type_t::COMPLEX_FLOAT32,
- uhd::device::RECV_MODE_ONE_PACKET, 1.0
+ buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0
);
BOOST_CHECK_EQUAL(metadata.error_code, uhd::rx_metadata_t::ERROR_CODE_NONE);
BOOST_CHECK(not metadata.more_fragments);
@@ -722,9 +700,7 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_fragment){
for (size_t i = 0; i < 3; i++){
std::cout << "timeout check " << i << std::endl;
handler.recv(
- buffs, NUM_SAMPS_PER_BUFF, metadata,
- uhd::io_type_t::COMPLEX_FLOAT32,
- uhd::device::RECV_MODE_ONE_PACKET, 1.0
+ buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0
);
BOOST_CHECK_EQUAL(metadata.error_code, uhd::rx_metadata_t::ERROR_CODE_TIMEOUT);
}
diff --git a/host/tests/sph_send_test.cpp b/host/tests/sph_send_test.cpp
index ed2f54371..9a91008af 100644
--- a/host/tests/sph_send_test.cpp
+++ b/host/tests/sph_send_test.cpp
@@ -55,18 +55,18 @@ private:
**********************************************************************/
class dummy_send_xport_class{
public:
- dummy_send_xport_class(const uhd::otw_type_t &otw_type){
- _otw_type = otw_type;
+ dummy_send_xport_class(const std::string &end){
+ _end = end;
}
void pop_front_packet(
uhd::transport::vrt::if_packet_info_t &ifpi
){
ifpi.num_packet_words32 = _lens.front()/sizeof(boost::uint32_t);
- if (_otw_type.byteorder == uhd::otw_type_t::BO_BIG_ENDIAN){
+ if (_end == "big"){
uhd::transport::vrt::if_hdr_unpack_be(reinterpret_cast<boost::uint32_t *>(_mems.front().get()), ifpi);
}
- if (_otw_type.byteorder == uhd::otw_type_t::BO_LITTLE_ENDIAN){
+ if (_end == "little"){
uhd::transport::vrt::if_hdr_unpack_le(reinterpret_cast<boost::uint32_t *>(_mems.front().get()), ifpi);
}
_mems.pop_front();
@@ -85,18 +85,19 @@ private:
std::list<boost::shared_array<char> > _mems;
std::list<size_t> _lens;
std::list<dummy_msb> _msbs; //list means no-realloc
- uhd::otw_type_t _otw_type;
+ std::string _end;
};
////////////////////////////////////////////////////////////////////////
BOOST_AUTO_TEST_CASE(test_sph_send_one_channel_one_packet_mode){
////////////////////////////////////////////////////////////////////////
- uhd::otw_type_t otw_type;
- otw_type.width = 16;
- otw_type.shift = 0;
- otw_type.byteorder = uhd::otw_type_t::BO_BIG_ENDIAN;
+ uhd::convert::id_type id;
+ id.input_markup = "fc32";
+ id.num_inputs = 1;
+ id.output_markup = "sc16_item32_be";
+ id.num_outputs = 1;
- dummy_send_xport_class dummy_send_xport(otw_type);
+ dummy_send_xport_class dummy_send_xport("big");
static const double TICK_RATE = 100e6;
static const double SAMP_RATE = 10e6;
@@ -108,7 +109,7 @@ BOOST_AUTO_TEST_CASE(test_sph_send_one_channel_one_packet_mode){
handler.set_tick_rate(TICK_RATE);
handler.set_samp_rate(SAMP_RATE);
handler.set_xport_chan_get_buff(0, boost::bind(&dummy_send_xport_class::get_send_buff, &dummy_send_xport, _1));
- handler.set_converter(otw_type);
+ handler.set_converter(id);
handler.set_max_samples_per_packet(20);
//allocate metadata and buffer
@@ -122,9 +123,7 @@ BOOST_AUTO_TEST_CASE(test_sph_send_one_channel_one_packet_mode){
metadata.start_of_burst = (i == 0);
metadata.end_of_burst = (i == NUM_PKTS_TO_TEST-1);
const size_t num_sent = handler.send(
- &buff.front(), 10 + i%10, metadata,
- uhd::io_type_t::COMPLEX_FLOAT32,
- uhd::device::SEND_MODE_ONE_PACKET, 1.0
+ &buff.front(), 10 + i%10, metadata, 1.0
);
BOOST_CHECK_EQUAL(num_sent, 10 + i%10);
metadata.time_spec += uhd::time_spec_t(0, num_sent, SAMP_RATE);
@@ -150,12 +149,13 @@ BOOST_AUTO_TEST_CASE(test_sph_send_one_channel_one_packet_mode){
////////////////////////////////////////////////////////////////////////
BOOST_AUTO_TEST_CASE(test_sph_send_one_channel_full_buffer_mode){
////////////////////////////////////////////////////////////////////////
- uhd::otw_type_t otw_type;
- otw_type.width = 16;
- otw_type.shift = 0;
- otw_type.byteorder = uhd::otw_type_t::BO_BIG_ENDIAN;
+ uhd::convert::id_type id;
+ id.input_markup = "fc32";
+ id.num_inputs = 1;
+ id.output_markup = "sc16_item32_be";
+ id.num_outputs = 1;
- dummy_send_xport_class dummy_send_xport(otw_type);
+ dummy_send_xport_class dummy_send_xport("big");
static const double TICK_RATE = 100e6;
static const double SAMP_RATE = 10e6;
@@ -167,7 +167,7 @@ BOOST_AUTO_TEST_CASE(test_sph_send_one_channel_full_buffer_mode){
handler.set_tick_rate(TICK_RATE);
handler.set_samp_rate(SAMP_RATE);
handler.set_xport_chan_get_buff(0, boost::bind(&dummy_send_xport_class::get_send_buff, &dummy_send_xport, _1));
- handler.set_converter(otw_type);
+ handler.set_converter(id);
handler.set_max_samples_per_packet(20);
//allocate metadata and buffer
@@ -180,9 +180,7 @@ BOOST_AUTO_TEST_CASE(test_sph_send_one_channel_full_buffer_mode){
//generate the test data
const size_t num_sent = handler.send(
- &buff.front(), buff.size(), metadata,
- uhd::io_type_t::COMPLEX_FLOAT32,
- uhd::device::SEND_MODE_FULL_BUFF, 1.0
+ &buff.front(), buff.size(), metadata, 1.0
);
BOOST_CHECK_EQUAL(num_sent, buff.size());
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-28 04:48:53 +0000