diff options
| -rw-r--r-- | host/lib/transport/CMakeLists.txt | 6 | ||||
| -rw-r--r-- | host/lib/transport/convert_types.cpp | 153 | ||||
| -rwxr-xr-x | host/lib/transport/gen_convert_types.py | 189 | ||||
| -rw-r--r-- | host/lib/usrp/dsp_utils.hpp | 9 | ||||
| -rw-r--r-- | host/test/CMakeLists.txt | 1 | ||||
| -rw-r--r-- | host/test/convert_types_test.cpp | 123 |
6 files changed, 322 insertions, 159 deletions
diff --git a/host/lib/transport/CMakeLists.txt b/host/lib/transport/CMakeLists.txt index a74f7d527..872865d6c 100644 --- a/host/lib/transport/CMakeLists.txt +++ b/host/lib/transport/CMakeLists.txt @@ -44,8 +44,12 @@ LIBUHD_PYTHON_GEN_SOURCE( ${CMAKE_BINARY_DIR}/lib/transport/vrt.cpp ) +LIBUHD_PYTHON_GEN_SOURCE( + ${CMAKE_SOURCE_DIR}/lib/transport/gen_convert_types.py + ${CMAKE_BINARY_DIR}/lib/transport/convert_types.cpp +) + LIBUHD_APPEND_SOURCES( - ${CMAKE_SOURCE_DIR}/lib/transport/convert_types.cpp ${CMAKE_SOURCE_DIR}/lib/transport/if_addrs.cpp ${CMAKE_SOURCE_DIR}/lib/transport/udp_simple.cpp ${CMAKE_SOURCE_DIR}/lib/transport/udp_zero_copy_asio.cpp diff --git a/host/lib/transport/convert_types.cpp b/host/lib/transport/convert_types.cpp deleted file mode 100644 index 374479eee..000000000 --- a/host/lib/transport/convert_types.cpp +++ /dev/null @@ -1,153 +0,0 @@ -// -// Copyright 2010 Ettus Research LLC -// -// This program is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with this program. If not, see <http://www.gnu.org/licenses/>. -// - -#include <uhd/config.hpp> -#include <uhd/transport/convert_types.hpp> -#include <uhd/utils/assert.hpp> -#include <boost/asio.hpp> //endianness conversion -#include <boost/cstdint.hpp> -#include <boost/detail/endian.hpp> -#include <complex> - -using namespace uhd; - -/*********************************************************************** - * Constants - **********************************************************************/ -typedef std::complex<float> fc32_t; - -static const float shorts_per_float = float(1 << 15); -static const float floats_per_short = float(1.0/shorts_per_float); - -#define unrolled_loop(__inst, __len){ \ - size_t __i = 0; \ - for(; __i < (__len & ~0x3); __i+= 4){ \ - __inst(__i+0); __inst(__i+1); \ - __inst(__i+2); __inst(__i+3); \ - } \ - for(; __i < __len; __i++){ \ - __inst(__i); \ - } \ -} - -// set a boolean flag that indicates the endianess -#ifdef BOOST_BIG_ENDIAN -static const bool is_big_endian = true; -#else -static const bool is_big_endian = false; -#endif - -static UHD_INLINE void host_floats_to_usrp2_items( - boost::uint32_t *usrp2_items, - const fc32_t *host_floats, - size_t num_samps -){ - #define host_floats_to_usrp2_items_i(i){ \ - boost::uint16_t real = boost::int16_t(host_floats[i].real()*shorts_per_float); \ - boost::uint16_t imag = boost::int16_t(host_floats[i].imag()*shorts_per_float); \ - usrp2_items[i] = htonl((real << 16) | (imag << 0)); \ - } - unrolled_loop(host_floats_to_usrp2_items_i, num_samps); -} - -static UHD_INLINE void usrp2_items_to_host_floats( - fc32_t *host_floats, - const boost::uint32_t *usrp2_items, - size_t num_samps -){ - #define usrp2_items_to_host_floats_i(i){ \ - boost::uint32_t item = ntohl(usrp2_items[i]); \ - boost::int16_t real = boost::uint16_t(item >> 16); \ - boost::int16_t imag = boost::uint16_t(item >> 0); \ - host_floats[i] = fc32_t(float(real*floats_per_short), float(imag*floats_per_short)); \ - } - unrolled_loop(usrp2_items_to_host_floats_i, num_samps); -} - -static UHD_INLINE void host_items_to_usrp2_items( - boost::uint32_t *usrp2_items, - const boost::uint32_t *host_items, - size_t num_samps -){ - #define host_items_to_usrp2_items_i(i) usrp2_items[i] = htonl(host_items[i]) - if (is_big_endian){ - std::memcpy(usrp2_items, host_items, num_samps*sizeof(boost::uint32_t)); - } - else{ - unrolled_loop(host_items_to_usrp2_items_i, num_samps); - } -} - -static UHD_INLINE void usrp2_items_to_host_items( - boost::uint32_t *host_items, - const boost::uint32_t *usrp2_items, - size_t num_samps -){ - #define usrp2_items_to_host_items_i(i) host_items[i] = ntohl(usrp2_items[i]) - if (is_big_endian){ - std::memcpy(host_items, usrp2_items, num_samps*sizeof(boost::uint32_t)); - } - else{ - unrolled_loop(usrp2_items_to_host_items_i, num_samps); - } -} - -void transport::convert_io_type_to_otw_type( - const void *io_buff, const io_type_t &io_type, - void *otw_buff, const otw_type_t &otw_type, - size_t num_samps -){ - //all we handle for now: - UHD_ASSERT_THROW(otw_type.width == 16 and otw_type.byteorder == otw_type_t::BO_BIG_ENDIAN); - - switch(io_type.tid){ - case io_type_t::COMPLEX_FLOAT32: - host_floats_to_usrp2_items((boost::uint32_t *)otw_buff, (const fc32_t*)io_buff, num_samps); - return; - case io_type_t::COMPLEX_INT16: - host_items_to_usrp2_items((boost::uint32_t *)otw_buff, (const boost::uint32_t*)io_buff, num_samps); - return; - case io_type_t::CUSTOM_TYPE: - std::memcpy(otw_buff, io_buff, num_samps*io_type.size); - return; - default: - throw std::runtime_error(str(boost::format("convert_types: cannot handle type \"%c\"") % io_type.tid)); - } -} - -void transport::convert_otw_type_to_io_type( - const void *otw_buff, const otw_type_t &otw_type, - void *io_buff, const io_type_t &io_type, - size_t num_samps -){ - //all we handle for now: - UHD_ASSERT_THROW(otw_type.width == 16 and otw_type.byteorder == otw_type_t::BO_BIG_ENDIAN); - - switch(io_type.tid){ - case io_type_t::COMPLEX_FLOAT32: - usrp2_items_to_host_floats((fc32_t*)io_buff, (const boost::uint32_t *)otw_buff, num_samps); - return; - case io_type_t::COMPLEX_INT16: - usrp2_items_to_host_items((boost::uint32_t*)io_buff, (const boost::uint32_t *)otw_buff, num_samps); - return; - case io_type_t::CUSTOM_TYPE: - std::memcpy(io_buff, otw_buff, num_samps*io_type.size); - return; - default: - throw std::runtime_error(str(boost::format("convert_types: cannot handle type \"%c\"") % io_type.tid)); - } -} diff --git a/host/lib/transport/gen_convert_types.py b/host/lib/transport/gen_convert_types.py new file mode 100755 index 000000000..1b6b71e00 --- /dev/null +++ b/host/lib/transport/gen_convert_types.py @@ -0,0 +1,189 @@ +#!/usr/bin/env python +# +# Copyright 2010 Ettus Research LLC +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. +# + +TMPL_TEXT = """ +#import time +/*********************************************************************** + * This file was generated by $file on $time.strftime("%c") + **********************************************************************/ + +\#include <uhd/config.hpp> +\#include <uhd/transport/convert_types.hpp> +\#include <uhd/utils/byteswap.hpp> +\#include <boost/cstdint.hpp> +\#include <boost/detail/endian.hpp> +\#include <stdexcept> +\#include <complex> + +//define the endian macros to convert integers +\#ifdef BOOST_BIG_ENDIAN + \#define BE_MACRO(x) x + \#define LE_MACRO(x) uhd::byteswap(x) + static const bool is_big_endian = true; +\#else + \#define BE_MACRO(x) uhd::byteswap(x) + \#define LE_MACRO(x) x + static const bool is_big_endian = false; +\#endif + +using namespace uhd; + +/*********************************************************************** + * Constants + **********************************************************************/ +typedef std::complex<float> fc32_t; +typedef std::complex<boost::int16_t> sc16_t; +typedef boost::uint32_t item32_t; + +static const float shorts_per_float = float(32767); +static const float floats_per_short = float(1.0/shorts_per_float); + +/*********************************************************************** + * Single-sample converters + **********************************************************************/ +template<typename outptr_type, typename inptr_type> +static UHD_INLINE outptr_type conv_ptr(inptr_type inptr){ + return reinterpret_cast<outptr_type>(inptr); +} + +static UHD_INLINE item32_t sc16_to_item32(sc16_t num){ + return *conv_ptr<item32_t*>(&num); +} + +static UHD_INLINE sc16_t item32_to_sc16(item32_t item){ + return *conv_ptr<sc16_t*>(&item); +} + +static UHD_INLINE item32_t fc32_to_item32(fc32_t num){ + return sc16_to_item32(sc16_t( + boost::int16_t(num.real()*shorts_per_float), + boost::int16_t(num.imag()*shorts_per_float) + )); +} + +static UHD_INLINE fc32_t item32_to_fc32(item32_t item){ + sc16_t num = item32_to_sc16(item); return fc32_t( + float(num.real()*floats_per_short), + float(num.imag()*floats_per_short) + ); +} + +/*********************************************************************** + * Sample-buffer converters + **********************************************************************/ +UHD_INLINE boost::uint8_t get_pred( + const io_type_t &io_type, + const otw_type_t &otw_type +){ + boost::uint8_t pred = 0; + + switch(otw_type.byteorder){ + case otw_type_t::BO_BIG_ENDIAN: pred |= $ph.be_p; break; + case otw_type_t::BO_LITTLE_ENDIAN: pred |= $ph.le_p; break; + ##let the compiler determine the native byte order (we could use python sys.byteorder) + case otw_type_t::BO_NATIVE: pred |= (is_big_endian)? $ph.be_p : $ph.le_p; break; + default: throw std::runtime_error("unhandled byteorder type"); + } + + switch(otw_type.width){ + case 16: pred |= $ph.w16_p; break; + default: throw std::runtime_error("unhandled bit width"); + } + + switch(io_type.tid){ + case io_type_t::COMPLEX_INT16: pred |= $ph.sc16_p; break; + case io_type_t::COMPLEX_FLOAT32: pred |= $ph.fc32_p; break; + default: throw std::runtime_error("unhandled io type id"); + } + + return pred; +} + +void transport::convert_io_type_to_otw_type( + const void *io_buff, const io_type_t &io_type, + void *otw_buff, const otw_type_t &otw_type, + size_t num_samps +){ + switch(get_pred(io_type, otw_type)){ + #for $pred in range(4) + case $pred: + #set $out_type = $ph.get_dev_type($pred) + #set $in_type = $ph.get_host_type($pred) + #set $converter = $in_type+"_to_"+$out_type + #set $xe_macro = $ph.get_xe_macro($pred) + for (size_t i = 0; i < num_samps; i++){ + (($(out_type)_t *)otw_buff)[i] = $(xe_macro)($(converter)(((const $(in_type)_t *)io_buff)[i])); + } + break; + #end for + } +} + +void transport::convert_otw_type_to_io_type( + const void *otw_buff, const otw_type_t &otw_type, + void *io_buff, const io_type_t &io_type, + size_t num_samps +){ + switch(get_pred(io_type, otw_type)){ + #for $pred in range(4) + case $pred: + #set $out_type = $ph.get_host_type($pred) + #set $in_type = $ph.get_dev_type($pred) + #set $converter = $in_type+"_to_"+$out_type + #set $xe_macro = $ph.get_xe_macro($pred) + for (size_t i = 0; i < num_samps; i++){ + (($(out_type)_t *)io_buff)[i] = $(converter)($(xe_macro)(((const $(in_type)_t *)otw_buff)[i])); + } + break; + #end for + } +} + +""" + +def parse_tmpl(_tmpl_text, **kwargs): + from Cheetah.Template import Template + return str(Template(_tmpl_text, kwargs)) + +class ph: + be_p = 0b00001 + le_p = 0b00000 + w16_p = 0b00000 + sc16_p = 0b00010 + fc32_p = 0b00000 + + @staticmethod + def get_xe_macro(pred): + if (pred & ph.be_p) == ph.be_p: return 'BE_MACRO' + if (pred & ph.le_p) == ph.le_p: return 'LE_MACRO' + raise NotImplementedError + + @staticmethod + def get_dev_type(pred): + if (pred & ph.w16_p) == ph.w16_p: return 'item32' + raise NotImplementedError + + @staticmethod + def get_host_type(pred): + if (pred & ph.sc16_p) == ph.sc16_p: return 'sc16' + if (pred & ph.fc32_p) == ph.fc32_p: return 'fc32' + raise NotImplementedError + +if __name__ == '__main__': + import sys + open(sys.argv[1], 'w').write(parse_tmpl(TMPL_TEXT, file=__file__, ph=ph)) diff --git a/host/lib/usrp/dsp_utils.hpp b/host/lib/usrp/dsp_utils.hpp index 8a6afb292..cfe5375f8 100644 --- a/host/lib/usrp/dsp_utils.hpp +++ b/host/lib/usrp/dsp_utils.hpp @@ -81,15 +81,14 @@ namespace dsp_type1{ /*! * Calculate the IQ scale factor word from I and Q components. - * \param i the I component - * \param q the Q component + * \param i the I component of the scalar + * \param q the Q component of the scalar * \return the 32-bit scale factor control word */ static inline boost::uint32_t calc_iq_scale_word( - boost::int16_t i, - boost::int16_t q + boost::int16_t i, boost::int16_t q ){ - return (boost::uint16_t(i) << 16) | (boost::uint16_t(q) << 0); + return (boost::uint32_t(i) << 16) | (boost::uint32_t(q) << 0); } /*! diff --git a/host/test/CMakeLists.txt b/host/test/CMakeLists.txt index 7fd3dd401..74f3376e6 100644 --- a/host/test/CMakeLists.txt +++ b/host/test/CMakeLists.txt @@ -23,6 +23,7 @@ ADD_EXECUTABLE(main_test addr_test.cpp buffer_test.cpp byteswap_test.cpp + convert_types_test.cpp dict_test.cpp error_test.cpp gain_handler_test.cpp diff --git a/host/test/convert_types_test.cpp b/host/test/convert_types_test.cpp new file mode 100644 index 000000000..096da441b --- /dev/null +++ b/host/test/convert_types_test.cpp @@ -0,0 +1,123 @@ +// +// Copyright 2010 Ettus Research LLC +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see <http://www.gnu.org/licenses/>. +// + +#include <uhd/transport/convert_types.hpp> +#include <boost/test/unit_test.hpp> +#include <boost/cstdint.hpp> +#include <complex> + +using namespace uhd; + +template <typename host_type, typename dev_type, size_t nsamps> +void loopback( + const io_type_t &io_type, + const otw_type_t &otw_type, + const host_type *input, + host_type *output +){ + dev_type dev[nsamps]; + + //convert to dev type + transport::convert_io_type_to_otw_type( + input, io_type, + dev, otw_type, + nsamps + ); + + //convert back to host type + transport::convert_otw_type_to_io_type( + dev, otw_type, + output, io_type, + nsamps + ); +} + +typedef std::complex<boost::uint16_t> sc16_t; + +BOOST_AUTO_TEST_CASE(test_convert_types_be_sc16){ + sc16_t in_sc16[] = { + sc16_t(0, -1234), sc16_t(4321, 1234), + sc16_t(9876, -4567), sc16_t(8912, 0) + }, out_sc16[4]; + + io_type_t io_type(io_type_t::COMPLEX_INT16); + otw_type_t otw_type; + otw_type.byteorder = otw_type_t::BO_BIG_ENDIAN; + otw_type.width = 16; + + loopback<sc16_t, boost::uint32_t, 4>(io_type, otw_type, in_sc16, out_sc16); + BOOST_CHECK_EQUAL_COLLECTIONS(in_sc16, in_sc16+4, out_sc16, out_sc16+4); +} + +BOOST_AUTO_TEST_CASE(test_convert_types_le_sc16){ + sc16_t in_sc16[] = { + sc16_t(0, -1234), sc16_t(4321, 1234), + sc16_t(9876, -4567), sc16_t(8912, 0) + }, out_sc16[4]; + + io_type_t io_type(io_type_t::COMPLEX_INT16); + otw_type_t otw_type; + otw_type.byteorder = otw_type_t::BO_LITTLE_ENDIAN; + otw_type.width = 16; + + loopback<sc16_t, boost::uint32_t, 4>(io_type, otw_type, in_sc16, out_sc16); + BOOST_CHECK_EQUAL_COLLECTIONS(in_sc16, in_sc16+4, out_sc16, out_sc16+4); +} + +typedef std::complex<float> fc32_t; + +#define BOOST_CHECK_CLOSE_COMPLEX(a1, a2, p) \ + BOOST_CHECK_CLOSE(a1.real(), a2.real(), p); \ + BOOST_CHECK_CLOSE(a1.imag(), a2.imag(), p); + +BOOST_AUTO_TEST_CASE(test_convert_types_be_fc32){ + fc32_t in_fc32[] = { + fc32_t(0, -0.2), fc32_t(0.03, -0.16), + fc32_t(1.0, .45), fc32_t(0.09, 0) + }, out_fc32[4]; + + io_type_t io_type(io_type_t::COMPLEX_FLOAT32); + otw_type_t otw_type; + otw_type.byteorder = otw_type_t::BO_BIG_ENDIAN; + otw_type.width = 16; + + loopback<fc32_t, boost::uint32_t, 4>(io_type, otw_type, in_fc32, out_fc32); + + BOOST_CHECK_CLOSE_COMPLEX(in_fc32[0], out_fc32[0], 0.1); + BOOST_CHECK_CLOSE_COMPLEX(in_fc32[1], out_fc32[1], 0.1); + BOOST_CHECK_CLOSE_COMPLEX(in_fc32[2], out_fc32[2], 0.1); + BOOST_CHECK_CLOSE_COMPLEX(in_fc32[3], out_fc32[3], 0.1); +} + +BOOST_AUTO_TEST_CASE(test_convert_types_le_fc32){ + fc32_t in_fc32[] = { + fc32_t(0, -0.2), fc32_t(0.03, -0.16), + fc32_t(1.0, .45), fc32_t(0.09, 0) + }, out_fc32[4]; + + io_type_t io_type(io_type_t::COMPLEX_FLOAT32); + otw_type_t otw_type; + otw_type.byteorder = otw_type_t::BO_LITTLE_ENDIAN; + otw_type.width = 16; + + loopback<fc32_t, boost::uint32_t, 4>(io_type, otw_type, in_fc32, out_fc32); + + BOOST_CHECK_CLOSE_COMPLEX(in_fc32[0], out_fc32[0], 0.1); + BOOST_CHECK_CLOSE_COMPLEX(in_fc32[1], out_fc32[1], 0.1); + BOOST_CHECK_CLOSE_COMPLEX(in_fc32[2], out_fc32[2], 0.1); + BOOST_CHECK_CLOSE_COMPLEX(in_fc32[3], out_fc32[3], 0.1); +} |