uhd: replaced frame params for the zero copy interfaces with a device address

the device address gives a key, value pair of infinite optional capabilities

added a cast option to the device address to cast string to type T

added call to the zero_copy_if to get send and recv frame sizes

changed the usrp2 impl to calculate recv/send spp from the data transport

5 files changed, 48 insertions, 24 deletions

diff --git a/host/include/uhd/transport/udp_zero_copy.hpp b/host/include/uhd/transport/udp_zero_copy.hpp
index 818709973..bbba97b21 100644
--- a/host/include/uhd/transport/udp_zero_copy.hpp
+++ b/host/include/uhd/transport/udp_zero_copy.hpp
@@ -20,6 +20,7 @@
 
 #include <uhd/config.hpp>
 #include <uhd/transport/zero_copy.hpp>
+#include <uhd/types/device_addr.hpp>
 #include <boost/shared_ptr.hpp>
 
 namespace uhd{ namespace transport{
@@ -50,14 +51,12 @@ public:
      *
      * \param addr a string representing the destination address
      * \param port a string representing the destination port
-     * \param recv_buff_size size in bytes for the recv buffer, 0 for automatic
-     * \param send_buff_size size in bytes for the send buffer, 0 for automatic
+     * \param hints optional parameters to pass to the underlying transport
      */
     static sptr make(
         const std::string &addr,
         const std::string &port,
-        size_t recv_buff_size = 0,
-        size_t send_buff_size = 0
+        const device_addr_t &hints = device_addr_t()
     );
 };
 
diff --git a/host/include/uhd/transport/usb_control.hpp b/host/include/uhd/transport/usb_control.hpp
index f9829c3ec..e6c32f78e 100644
--- a/host/include/uhd/transport/usb_control.hpp
+++ b/host/include/uhd/transport/usb_control.hpp
@@ -18,7 +18,7 @@
 #ifndef INCLUDED_UHD_TRANSPORT_USB_CONTROL_HPP
 #define INCLUDED_UHD_TRANSPORT_USB_CONTROL_HPP
 
-#include "usb_device_handle.hpp"
+#include <uhd/transport/usb_device_handle.hpp>
 
 namespace uhd { namespace transport {
 
diff --git a/host/include/uhd/transport/usb_zero_copy.hpp b/host/include/uhd/transport/usb_zero_copy.hpp
index 61bf380ba..b39171fba 100644
--- a/host/include/uhd/transport/usb_zero_copy.hpp
+++ b/host/include/uhd/transport/usb_zero_copy.hpp
@@ -18,8 +18,9 @@
 #ifndef INCLUDED_UHD_TRANSPORT_USB_ZERO_COPY_HPP
 #define INCLUDED_UHD_TRANSPORT_USB_ZERO_COPY_HPP
 
-#include "usb_device_handle.hpp"
+#include <uhd/transport/usb_device_handle.hpp>
 #include <uhd/transport/zero_copy.hpp>
+#include <uhd/types/device_addr.hpp>
 
 namespace uhd { namespace transport {
 
@@ -47,19 +48,13 @@ public:
      * \param handle a device handle that uniquely identifying the device
      * \param recv_endpoint an integer specifiying an IN endpoint number
      * \param send_endpoint an integer specifiying an OUT endpoint number
-     * \param recv_xfer_size the number of bytes for each receive transfer
-     * \param recv_num_xfers the number of simultaneous receive transfers
-     * \param send_xfer_size the number of bytes for each send transfer
-     * \param send_num_xfers the number of simultaneous send transfers
+     * \param hints optional parameters to pass to the underlying transport
      */
     static sptr make(
         usb_device_handle::sptr handle,
-        unsigned int recv_endpoint,
-        unsigned int send_endpoint,
-        size_t recv_xfer_size = 0,
-        size_t recv_num_xfers = 0,
-        size_t send_xfer_size = 0,
-        size_t send_num_xfers = 0
+        size_t recv_endpoint,
+        size_t send_endpoint,
+        const device_addr_t &hints = device_addr_t()
     );
 };
 
diff --git a/host/include/uhd/transport/zero_copy.hpp b/host/include/uhd/transport/zero_copy.hpp
index 9dd16280c..7d8fb4b83 100644
--- a/host/include/uhd/transport/zero_copy.hpp
+++ b/host/include/uhd/transport/zero_copy.hpp
@@ -155,15 +155,20 @@ namespace uhd{ namespace transport{
         virtual managed_recv_buffer::sptr get_recv_buff(double timeout = 0.1) = 0;
 
         /*!
-         * Get the maximum number of receive frames:
-         *   The maximum number of valid managed recv buffers,
-         *   or the maximum number of frames in the ring buffer,
-         *   depending upon the underlying implementation.
+         * Get the number of receive frames:
+         * The number of simultaneous receive buffers in use.
          * \return number of frames
          */
         virtual size_t get_num_recv_frames(void) const = 0;
 
         /*!
+         * Get the size of a receive frame:
+         * The maximum capacity of a single receive buffer.
+         * \return frame size in bytes
+         */
+        virtual size_t get_recv_frame_size(void) const = 0;
+
+        /*!
          * Get a new send buffer from this transport object.
          * \param timeout the timeout to get the buffer in seconds
          * \return a managed buffer, or null sptr on timeout/error
@@ -171,14 +176,19 @@ namespace uhd{ namespace transport{
         virtual managed_send_buffer::sptr get_send_buff(double timeout = 0.1) = 0;
 
         /*!
-         * Get the maximum number of send frames:
-         *   The maximum number of valid managed send buffers,
-         *   or the maximum number of frames in the ring buffer,
-         *   depending upon the underlying implementation.
+         * Get the number of send frames:
+         * The number of simultaneous send buffers in use.
          * \return number of frames
          */
         virtual size_t get_num_send_frames(void) const = 0;
 
+        /*!
+         * Get the size of a send frame:
+         * The maximum capacity of a single send buffer.
+         * \return frame size in bytes
+         */
+        virtual size_t get_send_frame_size(void) const = 0;
+
     };
 
 }} //namespace
diff --git a/host/include/uhd/types/device_addr.hpp b/host/include/uhd/types/device_addr.hpp
index e359d9467..eb3394230 100644
--- a/host/include/uhd/types/device_addr.hpp
+++ b/host/include/uhd/types/device_addr.hpp
@@ -20,6 +20,8 @@
 
 #include <uhd/config.hpp>
 #include <uhd/types/dict.hpp>
+#include <boost/lexical_cast.hpp>
+#include <stdexcept>
 #include <vector>
 #include <string>
 
@@ -62,6 +64,24 @@ namespace uhd{
          * \return a string with delimiter markup
          */
         std::string to_string(void) const;
+
+        /*!
+         * Lexically cast a parameter to the specified type,
+         * or use the default value if the key is not found.
+         * \param key the key as one of the address parameters
+         * \param def the value to use when key is not present
+         * \return the casted value as type T or the default
+         * \throw error when the parameter cannot be casted
+         */
+        template <typename T> T cast(const std::string &key, const T &def) const{
+            if (not this->has_key(key)) return def;
+            try{
+                return boost::lexical_cast<T>((*this)[key]);
+            }
+            catch(const boost::bad_lexical_cast &){
+                throw std::runtime_error("cannot cast " + key + " = " + (*this)[key]);
+            }
+        }
     };
 
     //handy typedef for a vector of device addresses