uhd: renamed convert markup to format

removed convert args

added simd level

got orc and neon updated

16 files changed, 110 insertions, 123 deletions

diff --git a/host/include/uhd/convert.hpp b/host/include/uhd/convert.hpp
index a0b502ab0..c42edfdec 100644
--- a/host/include/uhd/convert.hpp
+++ b/host/include/uhd/convert.hpp
@@ -42,17 +42,17 @@ namespace uhd{ namespace convert{
     enum priority_type{
         PRIORITY_GENERAL = 0,
         PRIORITY_LIBORC = 1,
-        PRIORITY_CUSTOM = 2,
+        PRIORITY_SIMD = 2,
+        PRIORITY_CUSTOM = 3,
         PRIORITY_EMPTY = -1,
     };
 
     //! Identify a conversion routine in the registry
     struct id_type : boost::equality_comparable<id_type>{
-        std::string input_markup;
+        std::string input_format;
         size_t num_inputs;
-        std::string output_markup;
+        std::string output_format;
         size_t num_outputs;
-        std::string args;
         std::string to_pp_string(void) const;
     };
 
@@ -80,15 +80,15 @@ namespace uhd{ namespace convert{
 
     /*!
      * Register the size of a particular item.
-     * \param markup the item markup
+     * \param format the item format
      * \param size the size in bytes
      */
     UHD_API void register_bytes_per_item(
-        const std::string &markup, const size_t size
+        const std::string &format, const size_t size
     );
 
-    //! Convert an item markup to a size in bytes
-    UHD_API size_t get_bytes_per_item(const std::string &markup);
+    //! Convert an item format to a size in bytes
+    UHD_API size_t get_bytes_per_item(const std::string &format);
 
 }} //namespace
 
diff --git a/host/lib/convert/convert_common.hpp b/host/lib/convert/convert_common.hpp
index 56b718292..34fb848c3 100644
--- a/host/lib/convert/convert_common.hpp
+++ b/host/lib/convert/convert_common.hpp
@@ -23,30 +23,28 @@
 #include <boost/cstdint.hpp>
 #include <complex>
 
-#define _DECLARE_CONVERTER(fcn, in_mark, num_in, out_mark, num_out, prio) \
+#define _DECLARE_CONVERTER(fcn, in_form, num_in, out_form, num_out, prio) \
     static void fcn( \
         const uhd::convert::input_type &inputs, \
         const uhd::convert::output_type &outputs, \
-        const size_t nsamps, \
-        const double scale_factor \
+        const size_t nsamps, const double scale_factor \
     ); \
     UHD_STATIC_BLOCK(__register_##fcn##_##prio){ \
         uhd::convert::id_type id; \
-        id.input_markup = #in_mark; \
+        id.input_format = #in_form; \
         id.num_inputs = num_in; \
-        id.output_markup = #out_mark; \
+        id.output_format = #out_form; \
         id.num_outputs = num_out; \
         uhd::convert::register_converter(id, fcn, prio); \
     } \
     static void fcn( \
         const uhd::convert::input_type &inputs, \
         const uhd::convert::output_type &outputs, \
-        const size_t nsamps, \
-        const double scale_factor \
+        const size_t nsamps, const double scale_factor \
     )
 
-#define DECLARE_CONVERTER(in_mark, num_in, out_mark, num_out, prio) \
-    _DECLARE_CONVERTER(__convert_##in_mark##_##num_in##_##out_mark##_##num_out, in_mark, num_in, out_mark, num_out, prio)
+#define DECLARE_CONVERTER(in_form, num_in, out_form, num_out, prio) \
+    _DECLARE_CONVERTER(__convert_##in_form##_##num_in##_##out_form##_##num_out, in_form, num_in, out_form, num_out, prio)
 
 /***********************************************************************
  * Typedefs
diff --git a/host/lib/convert/convert_fc32_with_sse2.cpp b/host/lib/convert/convert_fc32_with_sse2.cpp
index b8d1aa8cc..24a939d6c 100644
--- a/host/lib/convert/convert_fc32_with_sse2.cpp
+++ b/host/lib/convert/convert_fc32_with_sse2.cpp
@@ -21,7 +21,7 @@
 
 using namespace uhd::convert;
 
-DECLARE_CONVERTER(fc32, 1, sc16_item32_le, 1, PRIORITY_CUSTOM){
+DECLARE_CONVERTER(fc32, 1, sc16_item32_le, 1, PRIORITY_SIMD){
     const fc32_t *input = reinterpret_cast<const fc32_t *>(inputs[0]);
     item32_t *output = reinterpret_cast<item32_t *>(outputs[0]);
 
@@ -64,7 +64,7 @@ DECLARE_CONVERTER(fc32, 1, sc16_item32_le, 1, PRIORITY_CUSTOM){
     }
 }
 
-DECLARE_CONVERTER(fc32, 1, sc16_item32_be, 1, PRIORITY_CUSTOM){
+DECLARE_CONVERTER(fc32, 1, sc16_item32_be, 1, PRIORITY_SIMD){
     const fc32_t *input = reinterpret_cast<const fc32_t *>(inputs[0]);
     item32_t *output = reinterpret_cast<item32_t *>(outputs[0]);
 
@@ -106,7 +106,7 @@ DECLARE_CONVERTER(fc32, 1, sc16_item32_be, 1, PRIORITY_CUSTOM){
     }
 }
 
-DECLARE_CONVERTER(sc16_item32_le, 1, fc32, 1, PRIORITY_CUSTOM){
+DECLARE_CONVERTER(sc16_item32_le, 1, fc32, 1, PRIORITY_SIMD){
     const item32_t *input = reinterpret_cast<const item32_t *>(inputs[0]);
     fc32_t *output = reinterpret_cast<fc32_t *>(outputs[0]);
 
@@ -151,7 +151,7 @@ DECLARE_CONVERTER(sc16_item32_le, 1, fc32, 1, PRIORITY_CUSTOM){
     }
 }
 
-DECLARE_CONVERTER(sc16_item32_be, 1, fc32, 1, PRIORITY_CUSTOM){
+DECLARE_CONVERTER(sc16_item32_be, 1, fc32, 1, PRIORITY_SIMD){
     const item32_t *input = reinterpret_cast<const item32_t *>(inputs[0]);
     fc32_t *output = reinterpret_cast<fc32_t *>(outputs[0]);
 
diff --git a/host/lib/convert/convert_fc64_with_sse2.cpp b/host/lib/convert/convert_fc64_with_sse2.cpp
index a4f2df2e7..837bb584e 100644
--- a/host/lib/convert/convert_fc64_with_sse2.cpp
+++ b/host/lib/convert/convert_fc64_with_sse2.cpp
@@ -21,7 +21,7 @@
 
 using namespace uhd::convert;
 
-DECLARE_CONVERTER(fc64, 1, sc16_item32_le, 1, PRIORITY_CUSTOM){
+DECLARE_CONVERTER(fc64, 1, sc16_item32_le, 1, PRIORITY_SIMD){
     const fc64_t *input = reinterpret_cast<const fc64_t *>(inputs[0]);
     item32_t *output = reinterpret_cast<item32_t *>(outputs[0]);
 
@@ -68,7 +68,7 @@ DECLARE_CONVERTER(fc64, 1, sc16_item32_le, 1, PRIORITY_CUSTOM){
     }
 }
 
-DECLARE_CONVERTER(fc64, 1, sc16_item32_be, 1, PRIORITY_CUSTOM){
+DECLARE_CONVERTER(fc64, 1, sc16_item32_be, 1, PRIORITY_SIMD){
     const fc64_t *input = reinterpret_cast<const fc64_t *>(inputs[0]);
     item32_t *output = reinterpret_cast<item32_t *>(outputs[0]);
 
@@ -114,7 +114,7 @@ DECLARE_CONVERTER(fc64, 1, sc16_item32_be, 1, PRIORITY_CUSTOM){
     }
 }
 
-DECLARE_CONVERTER(sc16_item32_le, 1, fc64, 1, PRIORITY_CUSTOM){
+DECLARE_CONVERTER(sc16_item32_le, 1, fc64, 1, PRIORITY_SIMD){
     const item32_t *input = reinterpret_cast<const item32_t *>(inputs[0]);
     fc64_t *output = reinterpret_cast<fc64_t *>(outputs[0]);
 
@@ -163,7 +163,7 @@ DECLARE_CONVERTER(sc16_item32_le, 1, fc64, 1, PRIORITY_CUSTOM){
     }
 }
 
-DECLARE_CONVERTER(sc16_item32_be, 1, fc64, 1, PRIORITY_CUSTOM){
+DECLARE_CONVERTER(sc16_item32_be, 1, fc64, 1, PRIORITY_SIMD){
     const item32_t *input = reinterpret_cast<const item32_t *>(inputs[0]);
     fc64_t *output = reinterpret_cast<fc64_t *>(outputs[0]);
 
diff --git a/host/lib/convert/convert_impl.cpp b/host/lib/convert/convert_impl.cpp
index 280957c2a..df03b44f9 100644
--- a/host/lib/convert/convert_impl.cpp
+++ b/host/lib/convert/convert_impl.cpp
@@ -27,29 +27,26 @@
 using namespace uhd;
 
 bool convert::operator==(const convert::id_type &lhs, const convert::id_type &rhs){
-    return
-        (lhs.input_markup == rhs.input_markup) and
-        (lhs.num_inputs == rhs.num_inputs) and
-        (lhs.output_markup == rhs.output_markup) and
-        (lhs.num_outputs == rhs.num_outputs) and
-        (lhs.args == rhs.args)
+    return true
+        and (lhs.input_format  == rhs.input_format)
+        and (lhs.num_inputs    == rhs.num_inputs)
+        and (lhs.output_format == rhs.output_format)
+        and (lhs.num_outputs   == rhs.num_outputs)
     ;
 }
 
 std::string convert::id_type::to_pp_string(void) const{
     return str(boost::format(
         "conversion ID\n"
-        "  Input markup: %s\n"
+        "  Input format: %s\n"
         "  Num inputs: %d\n"
-        "  Output markup: %s\n"
+        "  Output format: %s\n"
         "  Num outputs: %d\n"
-        "  Optional args: %s\n"
     )
-        % this->input_markup
+        % this->input_format
         % this->num_inputs
-        % this->output_markup
+        % this->output_format
         % this->num_outputs
-        % this->args
     );
 }
 
@@ -101,30 +98,30 @@ convert::function_type convert::get_converter(const id_type &id){
 }
 
 /***********************************************************************
- * Mappings for item markup to byte size for all items we can
+ * Mappings for item format to byte size for all items we can
  **********************************************************************/
 typedef uhd::dict<std::string, size_t> item_size_type;
 UHD_SINGLETON_FCN(item_size_type, get_item_size_table);
 
 void register_bytes_per_item(
-    const std::string &markup, const size_t size
+    const std::string &format, const size_t size
 ){
-    get_item_size_table()[markup] = size;
+    get_item_size_table()[format] = size;
 }
 
-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];
+size_t convert::get_bytes_per_item(const std::string &format){
+    if (get_item_size_table().has_key(format)) return get_item_size_table()[format];
 
     //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("_");
+    const size_t pos = format.find("_");
     if (pos != std::string::npos){
-        return get_bytes_per_item(markup.substr(0, pos));
+        return get_bytes_per_item(format.substr(0, pos));
     }
 
-    throw uhd::key_error("Cannot find an item size:\n" + markup);
+    throw uhd::key_error("Cannot find an item size:\n" + format);
 }
 
 UHD_STATIC_BLOCK(convert_register_item_sizes){
diff --git a/host/lib/convert/convert_with_neon.cpp b/host/lib/convert/convert_with_neon.cpp
index e5f08cad9..c7ad62104 100644
--- a/host/lib/convert/convert_with_neon.cpp
+++ b/host/lib/convert/convert_with_neon.cpp
@@ -20,7 +20,7 @@
 
 using namespace uhd::convert;
 
-DECLARE_CONVERTER(convert_fc32_1_to_item32_1_nswap, PRIORITY_CUSTOM){
+DECLARE_CONVERTER(fc32, 1, sc16_item32_le, 1, PRIORITY_SIMD){
     const fc32_t *input = reinterpret_cast<const fc32_t *>(inputs[0]);
     item32_t *output = reinterpret_cast<item32_t *>(outputs[0]);
 
@@ -37,10 +37,10 @@ DECLARE_CONVERTER(convert_fc32_1_to_item32_1_nswap, PRIORITY_CUSTOM){
     }
 
     for (; i < nsamps; i++)
-        output[i] = fc32_to_item32(input[i], float(scale_factor));
+        output[i] = fc32_to_item32_sc16(input[i], scale_factor);
 }
 
-DECLARE_CONVERTER(convert_item32_1_to_fc32_1_nswap, PRIORITY_CUSTOM){
+DECLARE_CONVERTER(sc16_item32_le, 1, fc32, 1, PRIORITY_SIMD){
     const item32_t *input = reinterpret_cast<const item32_t *>(inputs[0]);
     fc32_t *output = reinterpret_cast<fc32_t *>(outputs[0]);
 
@@ -57,5 +57,5 @@ DECLARE_CONVERTER(convert_item32_1_to_fc32_1_nswap, PRIORITY_CUSTOM){
     }
 
     for (; i < nsamps; i++)
-        output[i] = item32_to_fc32(input[i], float(scale_factor));
+        output[i] = item32_sc16_to_fc32(input[i], scale_factor);
 }
diff --git a/host/lib/convert/convert_with_orc.cpp b/host/lib/convert/convert_with_orc.cpp
index 844c2595c..0c46bcf1e 100644
--- a/host/lib/convert/convert_with_orc.cpp
+++ b/host/lib/convert/convert_with_orc.cpp
@@ -29,26 +29,26 @@ extern void _convert_sc16_1_to_item32_1_nswap_orc(void *, const void *, float, i
 extern void _convert_item32_1_to_sc16_1_nswap_orc(void *, const void *, float, int);
 }
 
-DECLARE_CONVERTER(convert_fc32_1_to_item32_1_nswap, PRIORITY_LIBORC){
+DECLARE_CONVERTER(fc32, 1, sc16_item32_le, 1, PRIORITY_LIBORC){
     _convert_fc32_1_to_item32_1_nswap_orc(outputs[0], inputs[0], scale_factor, nsamps);
 }
 
-DECLARE_CONVERTER(convert_fc32_1_to_item32_1_bswap, PRIORITY_LIBORC){
+DECLARE_CONVERTER(fc32, 1, sc16_item32_be, 1, PRIORITY_LIBORC){
     _convert_fc32_1_to_item32_1_bswap_orc(outputs[0], inputs[0], scale_factor, nsamps);
 }
 
-DECLARE_CONVERTER(convert_item32_1_to_fc32_1_nswap, PRIORITY_LIBORC){
+DECLARE_CONVERTER(sc16_item32_le, 1, fc32, 1, PRIORITY_LIBORC){
     _convert_item32_1_to_fc32_1_nswap_orc(outputs[0], inputs[0], scale_factor, nsamps);
 }
 
-DECLARE_CONVERTER(convert_item32_1_to_fc32_1_bswap, PRIORITY_LIBORC){
+DECLARE_CONVERTER(sc16_item32_be, 1, fc32, 1, PRIORITY_LIBORC){
     _convert_item32_1_to_fc32_1_bswap_orc(outputs[0], inputs[0], scale_factor, nsamps);
 }
 
-DECLARE_CONVERTER(convert_sc16_1_to_item32_1_nswap, PRIORITY_LIBORC){
+DECLARE_CONVERTER(sc16, 1, sc16_item32_le, 1, PRIORITY_LIBORC){
     _convert_sc16_1_to_item32_1_nswap_orc(outputs[0], inputs[0], scale_factor, nsamps);
 }
 
-DECLARE_CONVERTER(convert_item32_1_to_sc16_1_nswap, PRIORITY_LIBORC){
+DECLARE_CONVERTER(sc16_item32_le, 1, sc16, 1, PRIORITY_LIBORC){
     _convert_item32_1_to_sc16_1_nswap_orc(outputs[0], inputs[0], scale_factor, nsamps);
 }
diff --git a/host/lib/transport/super_recv_packet_handler.hpp b/host/lib/transport/super_recv_packet_handler.hpp
index 6762a8a00..2310d6aea 100644
--- a/host/lib/transport/super_recv_packet_handler.hpp
+++ b/host/lib/transport/super_recv_packet_handler.hpp
@@ -125,8 +125,8 @@ public:
     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.input_markup);
-        _bytes_per_cpu_item = uhd::convert::get_bytes_per_item(id.output_markup);
+        _bytes_per_otw_item = uhd::convert::get_bytes_per_item(id.input_format);
+        _bytes_per_cpu_item = uhd::convert::get_bytes_per_item(id.output_format);
     }
 
     //! Set the transport channel's overflow handler
diff --git a/host/lib/transport/super_send_packet_handler.hpp b/host/lib/transport/super_send_packet_handler.hpp
index 5b5ee2981..779259d4f 100644
--- a/host/lib/transport/super_send_packet_handler.hpp
+++ b/host/lib/transport/super_send_packet_handler.hpp
@@ -101,8 +101,8 @@ public:
     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.output_markup);
-        _bytes_per_cpu_item = uhd::convert::get_bytes_per_item(id.input_markup);
+        _bytes_per_otw_item = uhd::convert::get_bytes_per_item(id.output_format);
+        _bytes_per_cpu_item = uhd::convert::get_bytes_per_item(id.input_format);
     }
 
     /*!
diff --git a/host/lib/usrp/b100/io_impl.cpp b/host/lib/usrp/b100/io_impl.cpp
index 82298dca6..28b19f14e 100644
--- a/host/lib/usrp/b100/io_impl.cpp
+++ b/host/lib/usrp/b100/io_impl.cpp
@@ -218,11 +218,10 @@ rx_streamer::sptr b100_impl::get_rx_stream(const uhd::stream_args_t &args_){
 
     //set the converter
     uhd::convert::id_type id;
-    id.input_markup = args.otw_format + "_item32_le";
+    id.input_format = args.otw_format + "_item32_le";
     id.num_inputs = 1;
-    id.output_markup = args.cpu_format;
+    id.output_format = args.cpu_format;
     id.num_outputs = 1;
-    id.args = args.args;
     my_streamer->set_converter(id);
 
     //bind callbacks for the handler
@@ -276,11 +275,10 @@ tx_streamer::sptr b100_impl::get_tx_stream(const uhd::stream_args_t &args_){
 
     //set the converter
     uhd::convert::id_type id;
-    id.input_markup = args.cpu_format;
+    id.input_format = args.cpu_format;
     id.num_inputs = 1;
-    id.output_markup = args.otw_format + "_item32_le";
+    id.output_format = args.otw_format + "_item32_le";
     id.num_outputs = 1;
-    id.args = args.args;
     my_streamer->set_converter(id);
 
     //bind callbacks for the handler
diff --git a/host/lib/usrp/e100/io_impl.cpp b/host/lib/usrp/e100/io_impl.cpp
index 5936ee2d7..c47eb8940 100644
--- a/host/lib/usrp/e100/io_impl.cpp
+++ b/host/lib/usrp/e100/io_impl.cpp
@@ -294,11 +294,10 @@ rx_streamer::sptr e100_impl::get_rx_stream(const uhd::stream_args_t &args_){
 
     //set the converter
     uhd::convert::id_type id;
-    id.input_markup = args.otw_format + "_item32_le";
+    id.input_format = args.otw_format + "_item32_le";
     id.num_inputs = 1;
-    id.output_markup = args.cpu_format;
+    id.output_format = args.cpu_format;
     id.num_outputs = 1;
-    id.args = args.args;
     my_streamer->set_converter(id);
 
     //bind callbacks for the handler
@@ -352,11 +351,10 @@ tx_streamer::sptr e100_impl::get_tx_stream(const uhd::stream_args_t &args_){
 
     //set the converter
     uhd::convert::id_type id;
-    id.input_markup = args.cpu_format;
+    id.input_format = args.cpu_format;
     id.num_inputs = 1;
-    id.output_markup = args.otw_format + "_item32_le";
+    id.output_format = args.otw_format + "_item32_le";
     id.num_outputs = 1;
-    id.args = args.args;
     my_streamer->set_converter(id);
 
     //bind callbacks for the handler
diff --git a/host/lib/usrp/usrp1/io_impl.cpp b/host/lib/usrp/usrp1/io_impl.cpp
index f46f4741b..534d33959 100644
--- a/host/lib/usrp/usrp1/io_impl.cpp
+++ b/host/lib/usrp/usrp1/io_impl.cpp
@@ -600,11 +600,10 @@ rx_streamer::sptr usrp1_impl::get_rx_stream(const uhd::stream_args_t &args_){
 
     //set the converter
     uhd::convert::id_type id;
-    id.input_markup = args.otw_format + "_item16_usrp1";
+    id.input_format = args.otw_format + "_item16_usrp1";
     id.num_inputs = 1;
-    id.output_markup = args.cpu_format;
+    id.output_format = args.cpu_format;
     id.num_outputs = args.channels.size();
-    id.args = args.args;
     my_streamer->set_converter(id);
 
     //save as weak ptr for update access
@@ -653,11 +652,10 @@ tx_streamer::sptr usrp1_impl::get_tx_stream(const uhd::stream_args_t &args_){
 
     //set the converter
     uhd::convert::id_type id;
-    id.input_markup = args.cpu_format;
+    id.input_format = args.cpu_format;
     id.num_inputs = args.channels.size();
-    id.output_markup = args.otw_format + "_item16_usrp1";
+    id.output_format = args.otw_format + "_item16_usrp1";
     id.num_outputs = 1;
-    id.args = args.args;
     my_streamer->set_converter(id);
 
     //save as weak ptr for update access
diff --git a/host/lib/usrp/usrp2/io_impl.cpp b/host/lib/usrp/usrp2/io_impl.cpp
index f1d0aee2a..660156285 100644
--- a/host/lib/usrp/usrp2/io_impl.cpp
+++ b/host/lib/usrp/usrp2/io_impl.cpp
@@ -391,11 +391,10 @@ rx_streamer::sptr usrp2_impl::get_rx_stream(const uhd::stream_args_t &args_){
 
     //set the converter
     uhd::convert::id_type id;
-    id.input_markup = args.otw_format + "_item32_be";
+    id.input_format = args.otw_format + "_item32_be";
     id.num_inputs = 1;
-    id.output_markup = args.cpu_format;
+    id.output_format = args.cpu_format;
     id.num_outputs = 1;
-    id.args = args.args;
     my_streamer->set_converter(id);
 
     //bind callbacks for the handler
@@ -459,11 +458,10 @@ tx_streamer::sptr usrp2_impl::get_tx_stream(const uhd::stream_args_t &args_){
 
     //set the converter
     uhd::convert::id_type id;
-    id.input_markup = args.cpu_format;
+    id.input_format = args.cpu_format;
     id.num_inputs = 1;
-    id.output_markup = args.otw_format + "_item32_be";
+    id.output_format = args.otw_format + "_item32_be";
     id.num_outputs = 1;
-    id.args = args.args;
     my_streamer->set_converter(id);
 
     //bind callbacks for the handler
diff --git a/host/tests/convert_test.cpp b/host/tests/convert_test.cpp
index 9dabcf54e..b63ff6752 100644
--- a/host/tests/convert_test.cpp
+++ b/host/tests/convert_test.cpp
@@ -75,7 +75,7 @@ static void test_convert_types_sc16(
     //run the loopback and test
     convert::id_type in_id = id;
     convert::id_type out_id = id;
-    std::swap(out_id.input_markup, out_id.output_markup);
+    std::swap(out_id.input_format, out_id.output_format);
     std::swap(out_id.num_inputs, out_id.num_outputs);
     loopback(nsamps, in_id, out_id, input, output);
     BOOST_CHECK_EQUAL_COLLECTIONS(input.begin(), input.end(), output.begin(), output.end());
@@ -83,9 +83,9 @@ static void test_convert_types_sc16(
 
 BOOST_AUTO_TEST_CASE(test_convert_types_be_sc16){
     convert::id_type id;
-    id.input_markup = "sc16";
+    id.input_format = "sc16";
     id.num_inputs = 1;
-    id.output_markup = "sc16_item32_be";
+    id.output_format = "sc16_item32_be";
     id.num_outputs = 1;
 
     //try various lengths to test edge cases
@@ -96,9 +96,9 @@ BOOST_AUTO_TEST_CASE(test_convert_types_be_sc16){
 
 BOOST_AUTO_TEST_CASE(test_convert_types_le_sc16){
     convert::id_type id;
-    id.input_markup = "sc16";
+    id.input_format = "sc16";
     id.num_inputs = 1;
-    id.output_markup = "sc16_item32_le";
+    id.output_format = "sc16_item32_le";
     id.num_outputs = 1;
 
     //try various lengths to test edge cases
@@ -126,7 +126,7 @@ static void test_convert_types_for_floats(
     //run the loopback and test
     convert::id_type in_id = id;
     convert::id_type out_id = id;
-    std::swap(out_id.input_markup, out_id.output_markup);
+    std::swap(out_id.input_format, out_id.output_format);
     std::swap(out_id.num_inputs, out_id.num_outputs);
     loopback(nsamps, in_id, out_id, input, output);
     for (size_t i = 0; i < nsamps; i++){
@@ -137,9 +137,9 @@ static void test_convert_types_for_floats(
 
 BOOST_AUTO_TEST_CASE(test_convert_types_be_fc32){
     convert::id_type id;
-    id.input_markup = "fc32";
+    id.input_format = "fc32";
     id.num_inputs = 1;
-    id.output_markup = "sc16_item32_be";
+    id.output_format = "sc16_item32_be";
     id.num_outputs = 1;
 
     //try various lengths to test edge cases
@@ -150,9 +150,9 @@ BOOST_AUTO_TEST_CASE(test_convert_types_be_fc32){
 
 BOOST_AUTO_TEST_CASE(test_convert_types_le_fc32){
     convert::id_type id;
-    id.input_markup = "fc32";
+    id.input_format = "fc32";
     id.num_inputs = 1;
-    id.output_markup = "sc16_item32_le";
+    id.output_format = "sc16_item32_le";
     id.num_outputs = 1;
 
     //try various lengths to test edge cases
@@ -163,9 +163,9 @@ BOOST_AUTO_TEST_CASE(test_convert_types_le_fc32){
 
 BOOST_AUTO_TEST_CASE(test_convert_types_be_fc64){
     convert::id_type id;
-    id.input_markup = "fc64";
+    id.input_format = "fc64";
     id.num_inputs = 1;
-    id.output_markup = "sc16_item32_be";
+    id.output_format = "sc16_item32_be";
     id.num_outputs = 1;
 
     //try various lengths to test edge cases
@@ -176,9 +176,9 @@ BOOST_AUTO_TEST_CASE(test_convert_types_be_fc64){
 
 BOOST_AUTO_TEST_CASE(test_convert_types_le_fc64){
     convert::id_type id;
-    id.input_markup = "fc64";
+    id.input_format = "fc64";
     id.num_inputs = 1;
-    id.output_markup = "sc16_item32_le";
+    id.output_format = "sc16_item32_le";
     id.num_outputs = 1;
 
     //try various lengths to test edge cases
@@ -192,15 +192,15 @@ BOOST_AUTO_TEST_CASE(test_convert_types_le_fc64){
  **********************************************************************/
 BOOST_AUTO_TEST_CASE(test_convert_types_fc32_to_sc16){
     convert::id_type in_id;
-    in_id.input_markup = "fc32";
+    in_id.input_format = "fc32";
     in_id.num_inputs = 1;
-    in_id.output_markup = "sc16_item32_le";
+    in_id.output_format = "sc16_item32_le";
     in_id.num_outputs = 1;
 
     convert::id_type out_id;
-    out_id.input_markup = "sc16_item32_le";
+    out_id.input_format = "sc16_item32_le";
     out_id.num_inputs = 1;
-    out_id.output_markup = "sc16";
+    out_id.output_format = "sc16";
     out_id.num_outputs = 1;
 
     const size_t nsamps = 13;
@@ -233,15 +233,15 @@ BOOST_AUTO_TEST_CASE(test_convert_types_fc32_to_sc16){
  **********************************************************************/
 BOOST_AUTO_TEST_CASE(test_convert_types_sc16_to_fc32){
     convert::id_type in_id;
-    in_id.input_markup = "sc16";
+    in_id.input_format = "sc16";
     in_id.num_inputs = 1;
-    in_id.output_markup = "sc16_item32_le";
+    in_id.output_format = "sc16_item32_le";
     in_id.num_outputs = 1;
 
     convert::id_type out_id;
-    out_id.input_markup = "sc16_item32_le";
+    out_id.input_format = "sc16_item32_le";
     out_id.num_inputs = 1;
-    out_id.output_markup = "fc32";
+    out_id.output_format = "fc32";
     out_id.num_outputs = 1;
 
     const size_t nsamps = 13;
diff --git a/host/tests/sph_recv_test.cpp b/host/tests/sph_recv_test.cpp
index 6fab2ad5f..85d06aa0d 100644
--- a/host/tests/sph_recv_test.cpp
+++ b/host/tests/sph_recv_test.cpp
@@ -107,9 +107,9 @@ private:
 BOOST_AUTO_TEST_CASE(test_sph_recv_one_channel_normal){
 ////////////////////////////////////////////////////////////////////////
     uhd::convert::id_type id;
-    id.input_markup = "sc16_item32_be";
+    id.input_format = "sc16_item32_be";
     id.num_inputs = 1;
-    id.output_markup = "fc32";
+    id.output_format = "fc32";
     id.num_outputs = 1;
 
     dummy_recv_xport_class dummy_recv_xport("big");
@@ -178,9 +178,9 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_one_channel_normal){
 BOOST_AUTO_TEST_CASE(test_sph_recv_one_channel_sequence_error){
 ////////////////////////////////////////////////////////////////////////
     uhd::convert::id_type id;
-    id.input_markup = "sc16_item32_be";
+    id.input_format = "sc16_item32_be";
     id.num_inputs = 1;
-    id.output_markup = "fc32";
+    id.output_format = "fc32";
     id.num_outputs = 1;
 
     dummy_recv_xport_class dummy_recv_xport("big");
@@ -259,9 +259,9 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_one_channel_sequence_error){
 BOOST_AUTO_TEST_CASE(test_sph_recv_one_channel_inline_message){
 ////////////////////////////////////////////////////////////////////////
     uhd::convert::id_type id;
-    id.input_markup = "sc16_item32_be";
+    id.input_format = "sc16_item32_be";
     id.num_inputs = 1;
-    id.output_markup = "fc32";
+    id.output_format = "fc32";
     id.num_outputs = 1;
 
     dummy_recv_xport_class dummy_recv_xport("big");
@@ -351,9 +351,9 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_one_channel_inline_message){
 BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_normal){
 ////////////////////////////////////////////////////////////////////////
     uhd::convert::id_type id;
-    id.input_markup = "sc16_item32_be";
+    id.input_format = "sc16_item32_be";
     id.num_inputs = 1;
-    id.output_markup = "fc32";
+    id.output_format = "fc32";
     id.num_outputs = 1;
 
     uhd::transport::vrt::if_packet_info_t ifpi;
@@ -434,9 +434,9 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_normal){
 BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_sequence_error){
 ////////////////////////////////////////////////////////////////////////
     uhd::convert::id_type id;
-    id.input_markup = "sc16_item32_be";
+    id.input_format = "sc16_item32_be";
     id.num_inputs = 1;
-    id.output_markup = "fc32";
+    id.output_format = "fc32";
     id.num_outputs = 1;
 
     uhd::transport::vrt::if_packet_info_t ifpi;
@@ -527,9 +527,9 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_sequence_error){
 BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_time_error){
 ////////////////////////////////////////////////////////////////////////
     uhd::convert::id_type id;
-    id.input_markup = "sc16_item32_be";
+    id.input_format = "sc16_item32_be";
     id.num_inputs = 1;
-    id.output_markup = "fc32";
+    id.output_format = "fc32";
     id.num_outputs = 1;
 
     uhd::transport::vrt::if_packet_info_t ifpi;
@@ -615,9 +615,9 @@ BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_time_error){
 BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_fragment){
 ////////////////////////////////////////////////////////////////////////
     uhd::convert::id_type id;
-    id.input_markup = "sc16_item32_be";
+    id.input_format = "sc16_item32_be";
     id.num_inputs = 1;
-    id.output_markup = "fc32";
+    id.output_format = "fc32";
     id.num_outputs = 1;
 
     uhd::transport::vrt::if_packet_info_t ifpi;
diff --git a/host/tests/sph_send_test.cpp b/host/tests/sph_send_test.cpp
index 9a91008af..25a3f97ee 100644
--- a/host/tests/sph_send_test.cpp
+++ b/host/tests/sph_send_test.cpp
@@ -92,9 +92,9 @@ private:
 BOOST_AUTO_TEST_CASE(test_sph_send_one_channel_one_packet_mode){
 ////////////////////////////////////////////////////////////////////////
     uhd::convert::id_type id;
-    id.input_markup = "fc32";
+    id.input_format = "fc32";
     id.num_inputs = 1;
-    id.output_markup = "sc16_item32_be";
+    id.output_format = "sc16_item32_be";
     id.num_outputs = 1;
 
     dummy_send_xport_class dummy_send_xport("big");
@@ -150,9 +150,9 @@ 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::convert::id_type id;
-    id.input_markup = "fc32";
+    id.input_format = "fc32";
     id.num_inputs = 1;
-    id.output_markup = "sc16_item32_be";
+    id.output_format = "sc16_item32_be";
     id.num_outputs = 1;
 
     dummy_send_xport_class dummy_send_xport("big");