usrp2: work on alternative OTW formats

4 files changed, 96 insertions, 26 deletions

diff --git a/host/lib/convert/convert_common.hpp b/host/lib/convert/convert_common.hpp
index 612fa312b..56b718292 100644
--- a/host/lib/convert/convert_common.hpp
+++ b/host/lib/convert/convert_common.hpp
@@ -65,18 +65,18 @@ typedef boost::int8_t                s8_t;
 typedef boost::uint32_t              item32_t;
 
 /***********************************************************************
- * Convert complex short buffer to items32
+ * Convert complex short buffer to items32 sc16
  **********************************************************************/
-static UHD_INLINE item32_t sc16_to_item32(sc16_t num, double){
+static UHD_INLINE item32_t sc16_to_item32_sc16(sc16_t num, double){
     boost::uint16_t real = num.real();
     boost::uint16_t imag = num.imag();
     return (item32_t(real) << 16) | (item32_t(imag) << 0);
 }
 
 /***********************************************************************
- * Convert items32 buffer to complex short
+ * Convert items32 sc16 buffer to complex short
  **********************************************************************/
-static UHD_INLINE sc16_t item32_to_sc16(item32_t item, double){
+static UHD_INLINE sc16_t item32_sc16_to_sc16(item32_t item, double){
     return sc16_t(
         boost::int16_t(item >> 16),
         boost::int16_t(item >> 0)
@@ -84,18 +84,18 @@ static UHD_INLINE sc16_t item32_to_sc16(item32_t item, double){
 }
 
 /***********************************************************************
- * Convert complex float buffer to items32 (no swap)
+ * Convert complex float buffer to items32 sc16
  **********************************************************************/
-static UHD_INLINE item32_t fc32_to_item32(fc32_t num, double scale_factor){
+static UHD_INLINE item32_t fc32_to_item32_sc16(fc32_t num, 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));
     return (item32_t(real) << 16) | (item32_t(imag) << 0);
 }
 
 /***********************************************************************
- * Convert items32 buffer to complex float
+ * Convert items32 sc16 buffer to complex float
  **********************************************************************/
-static UHD_INLINE fc32_t item32_to_fc32(item32_t item, double scale_factor){
+static UHD_INLINE fc32_t item32_sc16_to_fc32(item32_t item, double scale_factor){
     return fc32_t(
         float(boost::int16_t(item >> 16)*float(scale_factor)),
         float(boost::int16_t(item >> 0)*float(scale_factor))
@@ -103,22 +103,64 @@ static UHD_INLINE fc32_t item32_to_fc32(item32_t item, double scale_factor){
 }
 
 /***********************************************************************
- * Convert complex double buffer to items32 (no swap)
+ * Convert complex double buffer to items32 sc16
  **********************************************************************/
-static UHD_INLINE item32_t fc64_to_item32(fc64_t num, double scale_factor){
+static UHD_INLINE item32_t fc64_to_item32_sc16(fc64_t num, double scale_factor){
     boost::uint16_t real = boost::int16_t(num.real()*scale_factor);
     boost::uint16_t imag = boost::int16_t(num.imag()*scale_factor);
     return (item32_t(real) << 16) | (item32_t(imag) << 0);
 }
 
 /***********************************************************************
- * Convert items32 buffer to complex double
+ * Convert items32 sc16 buffer to complex double
  **********************************************************************/
-static UHD_INLINE fc64_t item32_to_fc64(item32_t item, double scale_factor){
+static UHD_INLINE fc64_t item32_sc16_to_fc64(item32_t item, double scale_factor){
     return fc64_t(
         float(boost::int16_t(item >> 16)*scale_factor),
         float(boost::int16_t(item >> 0)*scale_factor)
     );
 }
 
+/***********************************************************************
+ * Convert items32 sc8 buffer to complex short
+ **********************************************************************/
+static UHD_INLINE void item32_sc8_to_sc16(item32_t item, sc16_t &out0, sc16_t &out1, double){
+    out0 = sc16_t(
+        boost::int8_t(item >> 8),
+        boost::int8_t(item >> 0)
+    );
+    out1 = sc16_t(
+        boost::int8_t(item >> 24),
+        boost::int8_t(item >> 16)
+    );
+}
+
+/***********************************************************************
+ * Convert items32 sc8 buffer to complex float
+ **********************************************************************/
+static UHD_INLINE void item32_sc8_to_fc32(item32_t item, fc32_t &out0, fc32_t &out1, double scale_factor){
+    out0 = fc32_t(
+        float(boost::int8_t(item >> 8)*float(scale_factor)),
+        float(boost::int8_t(item >> 0)*float(scale_factor))
+    );
+    out1 = fc32_t(
+        float(boost::int8_t(item >> 24)*float(scale_factor)),
+        float(boost::int8_t(item >> 16)*float(scale_factor))
+    );
+}
+
+/***********************************************************************
+ * Convert items32 sc8 buffer to complex double
+ **********************************************************************/
+static UHD_INLINE void item32_sc8_to_fc64(item32_t item, fc64_t &out0, fc64_t &out1, double scale_factor){
+    out0 = fc64_t(
+        float(boost::int8_t(item >> 8)*scale_factor),
+        float(boost::int8_t(item >> 0)*scale_factor)
+    );
+    out1 = fc64_t(
+        float(boost::int8_t(item >> 24)*scale_factor),
+        float(boost::int8_t(item >> 16)*scale_factor)
+    );
+}
+
 #endif /* INCLUDED_LIBUHD_CONVERT_COMMON_HPP */
diff --git a/host/lib/convert/convert_fc32_with_sse2.cpp b/host/lib/convert/convert_fc32_with_sse2.cpp
index 34c85db80..b8d1aa8cc 100644
--- a/host/lib/convert/convert_fc32_with_sse2.cpp
+++ b/host/lib/convert/convert_fc32_with_sse2.cpp
@@ -51,7 +51,7 @@ DECLARE_CONVERTER(fc32, 1, sc16_item32_le, 1, PRIORITY_CUSTOM){
     //dispatch according to alignment
     switch (size_t(input) & 0xf){
     case 0x8:
-        output[i] = fc32_to_item32(input[i], float(scale_factor)); i++;
+        output[i] = fc32_to_item32_sc16(input[i], float(scale_factor)); i++;
     case 0x0:
         convert_fc32_1_to_item32_1_nswap_guts(_)
         break;
@@ -60,7 +60,7 @@ DECLARE_CONVERTER(fc32, 1, sc16_item32_le, 1, PRIORITY_CUSTOM){
 
     //convert remainder
     for (; i < nsamps; i++){
-        output[i] = fc32_to_item32(input[i], float(scale_factor));
+        output[i] = fc32_to_item32_sc16(input[i], float(scale_factor));
     }
 }
 
@@ -93,7 +93,7 @@ DECLARE_CONVERTER(fc32, 1, sc16_item32_be, 1, PRIORITY_CUSTOM){
     //dispatch according to alignment
     switch (size_t(input) & 0xf){
     case 0x8:
-        output[i] = uhd::byteswap(fc32_to_item32(input[i], float(scale_factor))); i++;
+        output[i] = uhd::byteswap(fc32_to_item32_sc16(input[i], float(scale_factor))); i++;
     case 0x0:
         convert_fc32_1_to_item32_1_bswap_guts(_)
         break;
@@ -102,7 +102,7 @@ DECLARE_CONVERTER(fc32, 1, sc16_item32_be, 1, PRIORITY_CUSTOM){
 
     //convert remainder
     for (; i < nsamps; i++){
-        output[i] = uhd::byteswap(fc32_to_item32(input[i], float(scale_factor)));
+        output[i] = uhd::byteswap(fc32_to_item32_sc16(input[i], float(scale_factor)));
     }
 }
 
@@ -138,7 +138,7 @@ DECLARE_CONVERTER(sc16_item32_le, 1, fc32, 1, PRIORITY_CUSTOM){
     //dispatch according to alignment
     switch (size_t(output) & 0xf){
     case 0x8:
-        output[i] = item32_to_fc32(input[i], float(scale_factor)); i++;
+        output[i] = item32_sc16_to_fc32(input[i], float(scale_factor)); i++;
     case 0x0:
         convert_item32_1_to_fc32_1_nswap_guts(_)
         break;
@@ -147,7 +147,7 @@ DECLARE_CONVERTER(sc16_item32_le, 1, fc32, 1, PRIORITY_CUSTOM){
 
     //convert remainder
     for (; i < nsamps; i++){
-        output[i] = item32_to_fc32(input[i], float(scale_factor));
+        output[i] = item32_sc16_to_fc32(input[i], float(scale_factor));
     }
 }
 
@@ -182,7 +182,7 @@ DECLARE_CONVERTER(sc16_item32_be, 1, fc32, 1, PRIORITY_CUSTOM){
     //dispatch according to alignment
     switch (size_t(output) & 0xf){
     case 0x8:
-        output[i] = item32_to_fc32(uhd::byteswap(input[i]), float(scale_factor)); i++;
+        output[i] = item32_sc16_to_fc32(uhd::byteswap(input[i]), float(scale_factor)); i++;
     case 0x0:
         convert_item32_1_to_fc32_1_bswap_guts(_)
         break;
@@ -191,6 +191,6 @@ DECLARE_CONVERTER(sc16_item32_be, 1, fc32, 1, PRIORITY_CUSTOM){
 
     //convert remainder
     for (; i < nsamps; i++){
-        output[i] = item32_to_fc32(uhd::byteswap(input[i]), float(scale_factor));
+        output[i] = item32_sc16_to_fc32(uhd::byteswap(input[i]), float(scale_factor));
     }
 }
diff --git a/host/lib/convert/convert_fc64_with_sse2.cpp b/host/lib/convert/convert_fc64_with_sse2.cpp
index 2093cf476..a4f2df2e7 100644
--- a/host/lib/convert/convert_fc64_with_sse2.cpp
+++ b/host/lib/convert/convert_fc64_with_sse2.cpp
@@ -64,7 +64,7 @@ DECLARE_CONVERTER(fc64, 1, sc16_item32_le, 1, PRIORITY_CUSTOM){
 
     //convert remainder
     for (; i < nsamps; i++){
-        output[i] = fc64_to_item32(input[i], scale_factor);
+        output[i] = fc64_to_item32_sc16(input[i], scale_factor);
     }
 }
 
@@ -110,7 +110,7 @@ DECLARE_CONVERTER(fc64, 1, sc16_item32_be, 1, PRIORITY_CUSTOM){
 
     //convert remainder
     for (; i < nsamps; i++){
-        output[i] = uhd::byteswap(fc64_to_item32(input[i], scale_factor));
+        output[i] = uhd::byteswap(fc64_to_item32_sc16(input[i], scale_factor));
     }
 }
 
@@ -159,7 +159,7 @@ DECLARE_CONVERTER(sc16_item32_le, 1, fc64, 1, PRIORITY_CUSTOM){
 
     //convert remainder
     for (; i < nsamps; i++){
-        output[i] = item32_to_fc64(input[i], scale_factor);
+        output[i] = item32_sc16_to_fc64(input[i], scale_factor);
     }
 }
 
@@ -207,6 +207,6 @@ DECLARE_CONVERTER(sc16_item32_be, 1, fc64, 1, PRIORITY_CUSTOM){
 
     //convert remainder
     for (; i < nsamps; i++){
-        output[i] = item32_to_fc64(uhd::byteswap(input[i]), scale_factor);
+        output[i] = item32_sc16_to_fc64(uhd::byteswap(input[i]), scale_factor);
     }
 }
diff --git a/host/lib/convert/gen_convert_general.py b/host/lib/convert/gen_convert_general.py
index 0cd4155fa..43e1f9967 100644
--- a/host/lib/convert/gen_convert_general.py
+++ b/host/lib/convert/gen_convert_general.py
@@ -34,7 +34,7 @@ DECLARE_CONVERTER($(cpu_type), 1, sc16_item32_$(end), 1, PRIORITY_GENERAL){
     item32_t *output = reinterpret_cast<item32_t *>(outputs[0]);
 
     for (size_t i = 0; i < nsamps; i++){
-        output[i] = $(to_wire)($(cpu_type)_to_item32(input[i], scale_factor));
+        output[i] = $(to_wire)($(cpu_type)_to_item32_sc16(input[i], scale_factor));
     }
 }
 
@@ -43,7 +43,35 @@ DECLARE_CONVERTER(sc16_item32_$(end), 1, $(cpu_type), 1, PRIORITY_GENERAL){
     $(cpu_type)_t *output = reinterpret_cast<$(cpu_type)_t *>(outputs[0]);
 
     for (size_t i = 0; i < nsamps; i++){
-        output[i] = item32_to_$(cpu_type)($(to_host)(input[i]), scale_factor);
+        output[i] = item32_sc16_to_$(cpu_type)($(to_host)(input[i]), scale_factor);
+    }
+}
+
+DECLARE_CONVERTER(sc8_item32_$(end), 1, $(cpu_type), 1, PRIORITY_GENERAL){
+    const item32_t *input = reinterpret_cast<const item32_t *>(size_t(inputs[0]) & ~0x3);
+    $(cpu_type)_t *output = reinterpret_cast<$(cpu_type)_t *>(outputs[0]);
+    $(cpu_type)_t dummy;
+
+    const bool head_case = ((size_t(inputs[0]) & 0x3) != 0);
+    const bool tail_case = ((nsamps & 0x1) == 0)? head_case : not head_case;
+    const size_t num_pairs = (head_case? nsamps-1 : nsamps)/2;
+    size_t i = 0, j = 0;
+
+    //special head case, probably from a partial recv
+    if (head_case){
+        const item32_t item0 = $(to_host)(input[i++]);
+        item32_sc8_to_$(cpu_type)(item0, dummy, output[j++], scale_factor);
+    }
+
+    for (; i < num_pairs; i++, j+=2){
+        const item32_t item_i = $(to_host)(input[i]);
+        item32_sc8_to_$(cpu_type)(item_i, output[j], output[j+1], scale_factor);
+    }
+
+    //special tail case, finished on an odd number
+    if (tail_case){
+        const item32_t item_i = $(to_host)(input[i]);
+        item32_sc8_to_$(cpu_type)(item_i, output[j], dummy, scale_factor);
     }
 }
 """