Remove all boost:: namespace prefix for uint32_t, int32_t etc. (fixed-width types)

- Also removes all references to boost/cstdint.hpp and replaces it with
  stdint.h (The 'correct' replacement would be <cstdint>, but not all of our
  compilers support that).

7 files changed, 106 insertions, 106 deletions

diff --git a/host/lib/convert/convert_common.hpp b/host/lib/convert/convert_common.hpp
index 6e73e9436..7ad7f1671 100644
--- a/host/lib/convert/convert_common.hpp
+++ b/host/lib/convert/convert_common.hpp
@@ -20,7 +20,7 @@
 
 #include <uhd/convert.hpp>
 #include <uhd/utils/static.hpp>
-#include <boost/cstdint.hpp>
+#include <stdint.h>
 #include <complex>
 
 #define _DECLARE_CONVERTER(name, in_form, num_in, out_form, num_out, prio) \
@@ -78,17 +78,17 @@ static const int PRIORITY_TABLE = 1;
  **********************************************************************/
 typedef std::complex<double>         fc64_t;
 typedef std::complex<float>          fc32_t;
-typedef std::complex<boost::int32_t> sc32_t;
-typedef std::complex<boost::int16_t> sc16_t;
-typedef std::complex<boost::int8_t>  sc8_t;
+typedef std::complex<int32_t> sc32_t;
+typedef std::complex<int16_t> sc16_t;
+typedef std::complex<int8_t>  sc8_t;
 typedef double                       f64_t;
 typedef float                        f32_t;
-typedef boost::int32_t               s32_t;
-typedef boost::int16_t               s16_t;
-typedef boost::int8_t                s8_t;
-typedef boost::uint8_t               u8_t;
+typedef int32_t               s32_t;
+typedef int16_t               s16_t;
+typedef int8_t                s8_t;
+typedef uint8_t               u8_t;
 
-typedef boost::uint32_t              item32_t;
+typedef uint32_t              item32_t;
 
 typedef item32_t (*xtox_t)(item32_t);
 
@@ -98,16 +98,16 @@ typedef item32_t (*xtox_t)(item32_t);
 template <typename T> UHD_INLINE item32_t xx_to_item32_sc16_x1(
     const std::complex<T> &num, const double scale_factor
 ){
-    boost::uint16_t real = boost::int16_t(num.real()*float(scale_factor));
-    boost::uint16_t imag = boost::int16_t(num.imag()*float(scale_factor));
+    uint16_t real = int16_t(num.real()*float(scale_factor));
+    uint16_t imag = int16_t(num.imag()*float(scale_factor));
     return (item32_t(real) << 16) | (item32_t(imag) << 0);
 }
 
 template <> UHD_INLINE item32_t xx_to_item32_sc16_x1(
     const sc16_t &num, const double
 ){
-    boost::uint16_t real = boost::int16_t(num.real());
-    boost::uint16_t imag = boost::int16_t(num.imag());
+    uint16_t real = int16_t(num.real());
+    uint16_t imag = int16_t(num.imag());
     return (item32_t(real) << 16) | (item32_t(imag) << 0);
 }
 
@@ -131,8 +131,8 @@ template <typename T> UHD_INLINE std::complex<T> item32_sc16_x1_to_xx(
     const item32_t item, const double scale_factor
 ){
     return std::complex<T>(
-        T(boost::int16_t(item >> 16)*float(scale_factor)),
-        T(boost::int16_t(item >> 0)*float(scale_factor))
+        T(int16_t(item >> 16)*float(scale_factor)),
+        T(int16_t(item >> 0)*float(scale_factor))
     );
 }
 
@@ -140,7 +140,7 @@ template <> UHD_INLINE sc16_t item32_sc16_x1_to_xx(
     const item32_t item, const double
 ){
     return sc16_t(
-        boost::int16_t(item >> 16), boost::int16_t(item >> 0)
+        int16_t(item >> 16), int16_t(item >> 0)
     );
 }
 
@@ -163,10 +163,10 @@ UHD_INLINE void item32_sc16_to_xx(
 template <typename T> UHD_INLINE item32_t xx_to_item32_sc8_x1(
     const std::complex<T> &in0, const std::complex<T> &in1, const double scale_factor
 ){
-    boost::uint8_t real1 = boost::int8_t(in0.real()*float(scale_factor));
-    boost::uint8_t imag1 = boost::int8_t(in0.imag()*float(scale_factor));
-    boost::uint8_t real0 = boost::int8_t(in1.real()*float(scale_factor));
-    boost::uint8_t imag0 = boost::int8_t(in1.imag()*float(scale_factor));
+    uint8_t real1 = int8_t(in0.real()*float(scale_factor));
+    uint8_t imag1 = int8_t(in0.imag()*float(scale_factor));
+    uint8_t real0 = int8_t(in1.real()*float(scale_factor));
+    uint8_t imag0 = int8_t(in1.imag()*float(scale_factor));
     return
         (item32_t(real0) << 8) | (item32_t(imag0) << 0) |
         (item32_t(real1) << 24) | (item32_t(imag1) << 16)
@@ -176,10 +176,10 @@ template <typename T> UHD_INLINE item32_t xx_to_item32_sc8_x1(
 template <> UHD_INLINE item32_t xx_to_item32_sc8_x1(
     const sc16_t &in0, const sc16_t &in1, const double
 ){
-    boost::uint8_t real1 = boost::int8_t(in0.real());
-    boost::uint8_t imag1 = boost::int8_t(in0.imag());
-    boost::uint8_t real0 = boost::int8_t(in1.real());
-    boost::uint8_t imag0 = boost::int8_t(in1.imag());
+    uint8_t real1 = int8_t(in0.real());
+    uint8_t imag1 = int8_t(in0.imag());
+    uint8_t real0 = int8_t(in1.real());
+    uint8_t imag0 = int8_t(in1.imag());
     return
         (item32_t(real0) << 8) | (item32_t(imag0) << 0) |
         (item32_t(real1) << 24) | (item32_t(imag1) << 16)
@@ -189,10 +189,10 @@ template <> UHD_INLINE item32_t xx_to_item32_sc8_x1(
 template <> UHD_INLINE item32_t xx_to_item32_sc8_x1(
     const sc8_t &in0, const sc8_t &in1, const double
 ){
-    boost::uint8_t real1 = boost::int8_t(in0.real());
-    boost::uint8_t imag1 = boost::int8_t(in0.imag());
-    boost::uint8_t real0 = boost::int8_t(in1.real());
-    boost::uint8_t imag0 = boost::int8_t(in1.imag());
+    uint8_t real1 = int8_t(in0.real());
+    uint8_t imag1 = int8_t(in0.imag());
+    uint8_t real0 = int8_t(in1.real());
+    uint8_t imag0 = int8_t(in1.imag());
     return
         (item32_t(real0) << 8) | (item32_t(imag0) << 0) |
         (item32_t(real1) << 24) | (item32_t(imag1) << 16)
@@ -225,12 +225,12 @@ template <typename T> UHD_INLINE void item32_sc8_x1_to_xx(
     const item32_t item, std::complex<T> &out0, std::complex<T> &out1, const double scale_factor
 ){
     out1 = std::complex<T>(
-        T(boost::int8_t(item >> 8)*float(scale_factor)),
-        T(boost::int8_t(item >> 0)*float(scale_factor))
+        T(int8_t(item >> 8)*float(scale_factor)),
+        T(int8_t(item >> 0)*float(scale_factor))
     );
     out0 = std::complex<T>(
-        T(boost::int8_t(item >> 24)*float(scale_factor)),
-        T(boost::int8_t(item >> 16)*float(scale_factor))
+        T(int8_t(item >> 24)*float(scale_factor)),
+        T(int8_t(item >> 16)*float(scale_factor))
     );
 }
 
@@ -238,12 +238,12 @@ template <> UHD_INLINE void item32_sc8_x1_to_xx(
     const item32_t item, sc16_t &out0, sc16_t &out1, const double
 ){
     out1 = sc16_t(
-        boost::int16_t(boost::int8_t(item >> 8)),
-        boost::int16_t(boost::int8_t(item >> 0))
+        int16_t(int8_t(item >> 8)),
+        int16_t(int8_t(item >> 0))
     );
     out0 = sc16_t(
-        boost::int16_t(boost::int8_t(item >> 24)),
-        boost::int16_t(boost::int8_t(item >> 16))
+        int16_t(int8_t(item >> 24)),
+        int16_t(int8_t(item >> 16))
     );
 }
 
@@ -251,12 +251,12 @@ template <> UHD_INLINE void item32_sc8_x1_to_xx(
     const item32_t item, sc8_t &out0, sc8_t &out1, const double
 ){
     out1 = sc8_t(
-        boost::int8_t(boost::int8_t(item >> 8)),
-        boost::int8_t(boost::int8_t(item >> 0))
+        int8_t(int8_t(item >> 8)),
+        int8_t(int8_t(item >> 0))
     );
     out0 = sc8_t(
-        boost::int8_t(boost::int8_t(item >> 24)),
-        boost::int8_t(boost::int8_t(item >> 16))
+        int8_t(int8_t(item >> 24)),
+        int8_t(int8_t(item >> 16))
     );
 }
 
diff --git a/host/lib/convert/convert_fc32_item32.cpp b/host/lib/convert/convert_fc32_item32.cpp
index 641fc2608..4a188780a 100644
--- a/host/lib/convert/convert_fc32_item32.cpp
+++ b/host/lib/convert/convert_fc32_item32.cpp
@@ -23,7 +23,7 @@
 
 using namespace uhd::convert;
 
-typedef boost::uint32_t (*to32_type)(boost::uint32_t);
+typedef uint32_t (*to32_type)(uint32_t);
 
 template <typename type, to32_type tohost>
 struct convert_fc32_item32_1_to_star_1 : public converter
diff --git a/host/lib/convert/convert_impl.cpp b/host/lib/convert/convert_impl.cpp
index 7dfbb33fd..d624bf970 100644
--- a/host/lib/convert/convert_impl.cpp
+++ b/host/lib/convert/convert_impl.cpp
@@ -20,7 +20,7 @@
 #include <uhd/utils/static.hpp>
 #include <uhd/types/dict.hpp>
 #include <uhd/exception.hpp>
-#include <boost/cstdint.hpp>
+#include <stdint.h>
 #include <boost/format.hpp>
 #include <boost/foreach.hpp>
 #include <complex>
@@ -159,20 +159,20 @@ UHD_STATIC_BLOCK(convert_register_item_sizes){
     //register standard complex types
     convert::register_bytes_per_item("fc64", sizeof(std::complex<double>));
     convert::register_bytes_per_item("fc32", sizeof(std::complex<float>));
-    convert::register_bytes_per_item("sc64", sizeof(std::complex<boost::int64_t>));
-    convert::register_bytes_per_item("sc32", sizeof(std::complex<boost::int32_t>));
-    convert::register_bytes_per_item("sc16", sizeof(std::complex<boost::int16_t>));
-    convert::register_bytes_per_item("sc8", sizeof(std::complex<boost::int8_t>));
+    convert::register_bytes_per_item("sc64", sizeof(std::complex<int64_t>));
+    convert::register_bytes_per_item("sc32", sizeof(std::complex<int32_t>));
+    convert::register_bytes_per_item("sc16", sizeof(std::complex<int16_t>));
+    convert::register_bytes_per_item("sc8", sizeof(std::complex<int8_t>));
 
     //register standard real types
     convert::register_bytes_per_item("f64", sizeof(double));
     convert::register_bytes_per_item("f32", sizeof(float));
-    convert::register_bytes_per_item("s64", sizeof(boost::int64_t));
-    convert::register_bytes_per_item("s32", sizeof(boost::int32_t));
-    convert::register_bytes_per_item("s16", sizeof(boost::int16_t));
-    convert::register_bytes_per_item("s8", sizeof(boost::int8_t));
-    convert::register_bytes_per_item("u8", sizeof(boost::uint8_t));
+    convert::register_bytes_per_item("s64", sizeof(int64_t));
+    convert::register_bytes_per_item("s32", sizeof(int32_t));
+    convert::register_bytes_per_item("s16", sizeof(int16_t));
+    convert::register_bytes_per_item("s8", sizeof(int8_t));
+    convert::register_bytes_per_item("u8", sizeof(uint8_t));
 
     //register VITA types
-    convert::register_bytes_per_item("item32", sizeof(boost::int32_t));
+    convert::register_bytes_per_item("item32", sizeof(int32_t));
 }
diff --git a/host/lib/convert/convert_pack_sc12.cpp b/host/lib/convert/convert_pack_sc12.cpp
index 370e4a3e4..fd32fc95f 100644
--- a/host/lib/convert/convert_pack_sc12.cpp
+++ b/host/lib/convert/convert_pack_sc12.cpp
@@ -23,7 +23,7 @@
 
 using namespace uhd::convert;
 
-typedef boost::uint32_t (*towire32_type)(boost::uint32_t);
+typedef uint32_t (*towire32_type)(uint32_t);
 
 /* C language specification requires this to be packed
  * (i.e., line0, line1, line2 will be in adjacent memory locations).
@@ -71,17 +71,17 @@ void convert_star_4_to_sc12_item32_3
     const double scalar
 )
 {
-    const item32_t i0 = boost::int32_t(type(in0.real()*scalar)) & 0xfff;
-    const item32_t q0 = boost::int32_t(type(in0.imag()*scalar)) & 0xfff;
+    const item32_t i0 = int32_t(type(in0.real()*scalar)) & 0xfff;
+    const item32_t q0 = int32_t(type(in0.imag()*scalar)) & 0xfff;
 
-    const item32_t i1 = boost::int32_t(type(in1.real()*scalar)) & 0xfff;
-    const item32_t q1 = boost::int32_t(type(in1.imag()*scalar)) & 0xfff;
+    const item32_t i1 = int32_t(type(in1.real()*scalar)) & 0xfff;
+    const item32_t q1 = int32_t(type(in1.imag()*scalar)) & 0xfff;
 
-    const item32_t i2 = boost::int32_t(type(in2.real()*scalar)) & 0xfff;
-    const item32_t q2 = boost::int32_t(type(in2.imag()*scalar)) & 0xfff;
+    const item32_t i2 = int32_t(type(in2.real()*scalar)) & 0xfff;
+    const item32_t q2 = int32_t(type(in2.imag()*scalar)) & 0xfff;
 
-    const item32_t i3 = boost::int32_t(type(in3.real()*scalar)) & 0xfff;
-    const item32_t q3 = boost::int32_t(type(in3.imag()*scalar)) & 0xfff;
+    const item32_t i3 = int32_t(type(in3.real()*scalar)) & 0xfff;
+    const item32_t q3 = int32_t(type(in3.imag()*scalar)) & 0xfff;
 
     const item32_t line0 = (i0 << 20) | (q0 << 8) | (i1 >> 4);
     const item32_t line1 = (i1 << 28) | (q1 << 16) | (i2 << 4) | (q2 >> 8);
diff --git a/host/lib/convert/convert_unpack_sc12.cpp b/host/lib/convert/convert_unpack_sc12.cpp
index 9f7a84300..acc815951 100644
--- a/host/lib/convert/convert_unpack_sc12.cpp
+++ b/host/lib/convert/convert_unpack_sc12.cpp
@@ -23,7 +23,7 @@
 
 using namespace uhd::convert;
 
-typedef boost::uint32_t (*tohost32_type)(boost::uint32_t);
+typedef uint32_t (*tohost32_type)(uint32_t);
 
 /* C language specification requires this to be packed
  * (i.e., line0, line1, line2 will be in adjacent memory locations).
@@ -63,21 +63,21 @@ void convert_sc12_item32_3_to_star_4
     const item32_t line0 = tohost(input.line0);
     const item32_t line1 = tohost(input.line1);
     const item32_t line2 = tohost(input.line2);
-    const boost::uint64_t line01 = (boost::uint64_t(line0) << 32) | line1;
-    const boost::uint64_t line12 = (boost::uint64_t(line1) << 32) | line2;
+    const uint64_t line01 = (uint64_t(line0) << 32) | line1;
+    const uint64_t line12 = (uint64_t(line1) << 32) | line2;
 
     //step 1: shift out and mask off the individual numbers
-    const type i0 = type(boost::int16_t((line0 >> 16) & 0xfff0)*scalar);
-    const type q0 = type(boost::int16_t((line0 >> 4) & 0xfff0)*scalar);
+    const type i0 = type(int16_t((line0 >> 16) & 0xfff0)*scalar);
+    const type q0 = type(int16_t((line0 >> 4) & 0xfff0)*scalar);
 
-    const type i1 = type(boost::int16_t((line01 >> 24) & 0xfff0)*scalar);
-    const type q1 = type(boost::int16_t((line1 >> 12) & 0xfff0)*scalar);
+    const type i1 = type(int16_t((line01 >> 24) & 0xfff0)*scalar);
+    const type q1 = type(int16_t((line1 >> 12) & 0xfff0)*scalar);
 
-    const type i2 = type(boost::int16_t((line1 >> 0) & 0xfff0)*scalar);
-    const type q2 = type(boost::int16_t((line12 >> 20) & 0xfff0)*scalar);
+    const type i2 = type(int16_t((line1 >> 0) & 0xfff0)*scalar);
+    const type q2 = type(int16_t((line12 >> 20) & 0xfff0)*scalar);
 
-    const type i3 = type(boost::int16_t((line2 >> 8) & 0xfff0)*scalar);
-    const type q3 = type(boost::int16_t((line2 << 4) & 0xfff0)*scalar);
+    const type i3 = type(int16_t((line2 >> 8) & 0xfff0)*scalar);
+    const type q3 = type(int16_t((line2 << 4) & 0xfff0)*scalar);
 
     //step 2: load the outputs
     out0 = std::complex<type>(i0, q0);
diff --git a/host/lib/convert/convert_with_tables.cpp b/host/lib/convert/convert_with_tables.cpp
index 4d295fa01..2dd1b42cc 100644
--- a/host/lib/convert/convert_with_tables.cpp
+++ b/host/lib/convert/convert_with_tables.cpp
@@ -24,7 +24,7 @@ using namespace uhd::convert;
 
 static const size_t sc16_table_len = size_t(1 << 16);
 
-typedef boost::uint16_t (*tohost16_type)(boost::uint16_t);
+typedef uint16_t (*tohost16_type)(uint16_t);
 
 /***********************************************************************
  * Implementation for sc16 to sc8 lookup table
@@ -37,8 +37,8 @@ public:
 
     void set_scalar(const double scalar){
         for (size_t i = 0; i < sc16_table_len; i++){
-            const boost::int16_t val = boost::uint16_t(i);
-            _table[i] = boost::int8_t(boost::math::iround(val * scalar / 32767.));
+            const int16_t val = uint16_t(i);
+            _table[i] = int8_t(boost::math::iround(val * scalar / 32767.));
         }
     }
 
@@ -59,20 +59,20 @@ public:
     item32_t lookup(const sc16_t &in0, const sc16_t &in1){
         if (swap){ //hope this compiles out, its a template constant
             return
-            (item32_t(_table[boost::uint16_t(in1.real())]) << 16) |
-            (item32_t(_table[boost::uint16_t(in1.imag())]) << 24) |
-            (item32_t(_table[boost::uint16_t(in0.real())]) << 0) |
-            (item32_t(_table[boost::uint16_t(in0.imag())]) << 8) ;
+            (item32_t(_table[uint16_t(in1.real())]) << 16) |
+            (item32_t(_table[uint16_t(in1.imag())]) << 24) |
+            (item32_t(_table[uint16_t(in0.real())]) << 0) |
+            (item32_t(_table[uint16_t(in0.imag())]) << 8) ;
         }
         return
-            (item32_t(_table[boost::uint16_t(in1.real())]) << 8) |
-            (item32_t(_table[boost::uint16_t(in1.imag())]) << 0) |
-            (item32_t(_table[boost::uint16_t(in0.real())]) << 24) |
-            (item32_t(_table[boost::uint16_t(in0.imag())]) << 16) ;
+            (item32_t(_table[uint16_t(in1.real())]) << 8) |
+            (item32_t(_table[uint16_t(in1.imag())]) << 0) |
+            (item32_t(_table[uint16_t(in0.real())]) << 24) |
+            (item32_t(_table[uint16_t(in0.imag())]) << 16) ;
     }
 
 private:
-    std::vector<boost::uint8_t> _table;
+    std::vector<uint8_t> _table;
 };
 
 /***********************************************************************
@@ -86,8 +86,8 @@ public:
 
     void set_scalar(const double scalar){
         for (size_t i = 0; i < sc16_table_len; i++){
-            const boost::uint16_t val = tohost(boost::uint16_t(i & 0xffff));
-            _table[i] = type(boost::int16_t(val)*scalar);
+            const uint16_t val = tohost(uint16_t(i & 0xffff));
+            _table[i] = type(int16_t(val)*scalar);
         }
     }
 
@@ -98,8 +98,8 @@ public:
         for (size_t i = 0; i < nsamps; i++){
             const item32_t item = input[i];
             output[i] = std::complex<type>(
-                _table[boost::uint16_t(item >> re_shift)],
-                _table[boost::uint16_t(item >> im_shift)]
+                _table[uint16_t(item >> re_shift)],
+                _table[uint16_t(item >> im_shift)]
             );
         }
     }
@@ -118,7 +118,7 @@ public:
     convert_sc8_item32_1_to_fcxx_1(void): _table(sc16_table_len){}
 
     //special case for sc16 type, 32767 undoes float normalization
-    static type conv(const boost::int8_t &num, const double scalar){
+    static type conv(const int8_t &num, const double scalar){
         if (sizeof(type) == sizeof(s16_t)){
             return type(boost::math::iround(num*scalar*32767));
         }
@@ -127,9 +127,9 @@ public:
 
     void set_scalar(const double scalar){
         for (size_t i = 0; i < sc16_table_len; i++){
-            const boost::uint16_t val = tohost(boost::uint16_t(i & 0xffff));
-            const type real = conv(boost::int8_t(val >> 8), scalar);
-            const type imag = conv(boost::int8_t(val >> 0), scalar);
+            const uint16_t val = tohost(uint16_t(i & 0xffff));
+            const type real = conv(int8_t(val >> 8), scalar);
+            const type imag = conv(int8_t(val >> 0), scalar);
             _table[i] = std::complex<type>(real, imag);
         }
     }
@@ -142,20 +142,20 @@ public:
 
         if ((size_t(inputs[0]) & 0x3) != 0){
             const item32_t item0 = *input++;
-            *output++ = _table[boost::uint16_t(item0 >> hi_shift)];
+            *output++ = _table[uint16_t(item0 >> hi_shift)];
             num_samps--;
         }
 
         const size_t num_pairs = num_samps/2;
         for (size_t i = 0, j = 0; i < num_pairs; i++, j+=2){
             const item32_t item_i = (input[i]);
-            output[j] = _table[boost::uint16_t(item_i >> lo_shift)];
-            output[j + 1] = _table[boost::uint16_t(item_i >> hi_shift)];
+            output[j] = _table[uint16_t(item_i >> lo_shift)];
+            output[j + 1] = _table[uint16_t(item_i >> hi_shift)];
         }
 
         if (num_samps != num_pairs*2){
             const item32_t item_n = input[num_pairs];
-            output[num_samps-1] = _table[boost::uint16_t(item_n >> lo_shift)];
+            output[num_samps-1] = _table[uint16_t(item_n >> lo_shift)];
         }
     }
 
diff --git a/host/lib/convert/gen_convert_general.py b/host/lib/convert/gen_convert_general.py
index 5c62d51df..6e38d9c81 100644
--- a/host/lib/convert/gen_convert_general.py
+++ b/host/lib/convert/gen_convert_general.py
@@ -149,18 +149,18 @@ DECLARE_CONVERTER(${cpu_type}, ${width}, sc16_item16_usrp1, 1, PRIORITY_GENERAL)
     % for w in range(width):
     const ${cpu_type}_t *input${w} = reinterpret_cast<const ${cpu_type}_t *>(inputs[${w}]);
     % endfor
-    boost::uint16_t *output = reinterpret_cast<boost::uint16_t *>(outputs[0]);
+    uint16_t *output = reinterpret_cast<uint16_t *>(outputs[0]);
 
     for (size_t i = 0, j = 0; i < nsamps; i++){
         % for w in range(width):
-        output[j++] = ${to_wire}(boost::uint16_t(boost::int16_t(input${w}[i].real()${do_scale})));
-        output[j++] = ${to_wire}(boost::uint16_t(boost::int16_t(input${w}[i].imag()${do_scale})));
+        output[j++] = ${to_wire}(uint16_t(int16_t(input${w}[i].real()${do_scale})));
+        output[j++] = ${to_wire}(uint16_t(int16_t(input${w}[i].imag()${do_scale})));
         % endfor
     }
 }
 
 DECLARE_CONVERTER(sc16_item16_usrp1, 1, ${cpu_type}, ${width}, PRIORITY_GENERAL){
-    const boost::uint16_t *input = reinterpret_cast<const boost::uint16_t *>(inputs[0]);
+    const uint16_t *input = reinterpret_cast<const uint16_t *>(inputs[0]);
     % for w in range(width):
     ${cpu_type}_t *output${w} = reinterpret_cast<${cpu_type}_t *>(outputs[${w}]);
     % endfor
@@ -168,8 +168,8 @@ DECLARE_CONVERTER(sc16_item16_usrp1, 1, ${cpu_type}, ${width}, PRIORITY_GENERAL)
     for (size_t i = 0, j = 0; i < nsamps; i++){
         % for w in range(width):
         output${w}[i] = ${cpu_type}_t(
-            boost::int16_t(${to_host}(input[j+0]))${do_scale},
-            boost::int16_t(${to_host}(input[j+1]))${do_scale}
+            int16_t(${to_host}(input[j+0]))${do_scale},
+            int16_t(${to_host}(input[j+1]))${do_scale}
         );
         j += 2;
         % endfor
@@ -177,7 +177,7 @@ DECLARE_CONVERTER(sc16_item16_usrp1, 1, ${cpu_type}, ${width}, PRIORITY_GENERAL)
 }
 
 DECLARE_CONVERTER(sc8_item16_usrp1, 1, ${cpu_type}, ${width}, PRIORITY_GENERAL){
-    const boost::uint16_t *input = reinterpret_cast<const boost::uint16_t *>(inputs[0]);
+    const uint16_t *input = reinterpret_cast<const uint16_t *>(inputs[0]);
     % for w in range(width):
     ${cpu_type}_t *output${w} = reinterpret_cast<${cpu_type}_t *>(outputs[${w}]);
     % endfor
@@ -185,10 +185,10 @@ DECLARE_CONVERTER(sc8_item16_usrp1, 1, ${cpu_type}, ${width}, PRIORITY_GENERAL){
     for (size_t i = 0, j = 0; i < nsamps; i++){
         % for w in range(width):
         {
-        const boost::uint16_t num = ${to_host}(input[j++]);
+        const uint16_t num = ${to_host}(input[j++]);
         output${w}[i] = ${cpu_type}_t(
-            boost::int8_t(num)${do_scale},
-            boost::int8_t(num >> 8)${do_scale}
+            int8_t(num)${do_scale},
+            int8_t(num >> 8)${do_scale}
         );
         }
         % endfor