Merge branch 'master' of ettus.sourcerepo.com:ettus/uhdpriv into usrp_e

8 files changed, 362 insertions, 169 deletions

diff --git a/host/include/uhd/utils/byteswap.hpp b/host/include/uhd/utils/byteswap.hpp
index 779b48ec9..dd5dcbc09 100644
--- a/host/include/uhd/utils/byteswap.hpp
+++ b/host/include/uhd/utils/byteswap.hpp
@@ -57,11 +57,10 @@ namespace uhd{
         return _byteswap_uint64(x);
     }
 
-#elif defined(__GNUC__) && __GNUC__ >= 4 && __GNUC_MINOR__ >= 3
-    #include <byteswap.h>
+#elif defined(__GNUC__) && __GNUC__ >= 4 && __GNUC_MINOR__ >= 2
 
     UHD_INLINE boost::uint16_t uhd::byteswap(boost::uint16_t x){
-        return bswap_16(x); //no __builtin_bswap16
+        return (x>>8) | (x<<8); //DNE return __builtin_bswap16(x);
     }
 
     UHD_INLINE boost::uint32_t uhd::byteswap(boost::uint32_t x){
@@ -72,7 +71,22 @@ namespace uhd{
         return __builtin_bswap64(x);
     }
 
-#else
+#elif defined(__FreeBSD__) || defined(__MACOSX__) || defined(__APPLE__)
+    #include <libkern/OSByteOrder.h>
+
+    UHD_INLINE boost::uint16_t uhd::byteswap(boost::uint16_t x){
+        return OSSwapInt16(x);
+    }
+
+    UHD_INLINE boost::uint32_t uhd::byteswap(boost::uint32_t x){
+        return OSSwapInt32(x);
+    }
+
+    UHD_INLINE boost::uint64_t uhd::byteswap(boost::uint64_t x){
+        return OSSwapInt64(x);
+    }
+
+#elif defined(linux) || defined(__linux)
     #include <byteswap.h>
 
     UHD_INLINE boost::uint16_t uhd::byteswap(boost::uint16_t x){
@@ -87,6 +101,20 @@ namespace uhd{
         return bswap_64(x);
     }
 
+#else //http://www.koders.com/c/fidB93B34CD44F0ECF724F1A4EAE3854BA2FE692F59.aspx
+
+    UHD_INLINE boost::uint16_t uhd::byteswap(boost::uint16_t x){
+        return (x>>8) | (x<<8);
+    }
+
+    UHD_INLINE boost::uint32_t uhd::byteswap(boost::uint32_t x){
+        return (boost::uint32_t(uhd::byteswap(boost::uint16_t(x&0xfffful)))<<16) | (uhd::byteswap(boost::uint16_t(x>>16)));
+    }
+
+    UHD_INLINE boost::uint64_t uhd::byteswap(boost::uint64_t x){
+        return (boost::uint64_t(uhd::byteswap(boost::uint32_t(x&0xffffffffull)))<<32) | (uhd::byteswap(boost::uint32_t(x>>32)));
+    }
+
 #endif
 
 #endif /* INCLUDED_UHD_UTILS_BYTESWAP_HPP */
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..af2bcc7cb
--- /dev/null
+++ b/host/lib/transport/gen_convert_types.py
@@ -0,0 +1,190 @@
+#!/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
+ **********************************************************************/
+static UHD_INLINE item32_t sc16_to_item32(sc16_t num){
+    boost::uint16_t real = boost::int16_t(num.real());
+    boost::uint16_t imag = boost::int16_t(num.imag());
+    return (item32_t(real) << 16) | (item32_t(imag) << 0);
+}
+
+static UHD_INLINE sc16_t item32_to_sc16(item32_t item){
+    return sc16_t(
+        boost::uint16_t(item >> 16),
+        boost::uint16_t(item >> 0)
+    );
+}
+
+static UHD_INLINE item32_t fc32_to_item32(fc32_t num){
+    boost::uint16_t real = boost::int16_t(num.real()*shorts_per_float);
+    boost::uint16_t imag = boost::int16_t(num.imag()*shorts_per_float);
+    return (item32_t(real) << 16) | (item32_t(imag) << 0);
+}
+
+static UHD_INLINE fc32_t item32_to_fc32(item32_t item){
+    return fc32_t(
+        float(boost::int16_t(item >> 16)*floats_per_short),
+        float(boost::int16_t(item >> 0)*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(2**$ph.nbits)
+    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
+
+    nbits = 2 #see above
+
+    @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/transport/gen_vrt.py b/host/lib/transport/gen_vrt.py
index 3279ae225..6cdd6645d 100755
--- a/host/lib/transport/gen_vrt.py
+++ b/host/lib/transport/gen_vrt.py
@@ -45,8 +45,6 @@ TMPL_TEXT = """
     \#define LE_MACRO(x) (x)
 \#endif
 
-#set $XE_MACRO = "BE_MACRO"
-
 using namespace uhd;
 using namespace uhd::transport;
 
@@ -131,10 +129,11 @@ void vrt::pack_$(suffix)(
     if (metadata.end_of_burst)   vrt_hdr_flags |= $hex(0x1 << 24);
 
     //fill in complete header word
-    header_buff[0] = $(XE_MACRO)(vrt_hdr_flags |
-        ((packet_count & 0xf) << 16) |
-        (num_packet_words32 & 0xffff)
-    );
+    header_buff[0] = $(XE_MACRO)(boost::uint32_t(0
+        | vrt_hdr_flags
+        | ((packet_count & 0xf) << 16)
+        | (num_packet_words32 & 0xffff)
+    ));
 }
 
 void vrt::unpack_$(suffix)(
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..1587be57f
--- /dev/null
+++ b/host/test/convert_types_test.cpp
@@ -0,0 +1,125 @@
+//
+// 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);
+
+static const float tolerance = float(0.1);
+
+BOOST_AUTO_TEST_CASE(test_convert_types_be_fc32){
+    fc32_t in_fc32[] = {
+        fc32_t(float(0), float(-0.2)), fc32_t(float(0.03), float(-0.16)),
+        fc32_t(float(1.0), float(.45)), fc32_t(float(0.09), float(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], tolerance);
+    BOOST_CHECK_CLOSE_COMPLEX(in_fc32[1], out_fc32[1], tolerance);
+    BOOST_CHECK_CLOSE_COMPLEX(in_fc32[2], out_fc32[2], tolerance);
+    BOOST_CHECK_CLOSE_COMPLEX(in_fc32[3], out_fc32[3], tolerance);
+}
+
+BOOST_AUTO_TEST_CASE(test_convert_types_le_fc32){
+    fc32_t in_fc32[] = {
+        fc32_t(float(0), float(-0.2)), fc32_t(float(0.03), float(-0.16)),
+        fc32_t(float(1.0), float(.45)), fc32_t(float(0.09), float(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], tolerance);
+    BOOST_CHECK_CLOSE_COMPLEX(in_fc32[1], out_fc32[1], tolerance);
+    BOOST_CHECK_CLOSE_COMPLEX(in_fc32[2], out_fc32[2], tolerance);
+    BOOST_CHECK_CLOSE_COMPLEX(in_fc32[3], out_fc32[3], tolerance);
+}