uhd: converted gr-uhd to v3.7 style.

author: Tom Rondeau <trondeau@vt.edu> 2013-02-19 14:50:50 -0500
committer: Tom Rondeau <trondeau@vt.edu> 2013-02-19 20:10:31 -0500
commit: a5bb5783fb20a4f136650c00d3fd94bb28add738 (patch)
tree: 51ebcd9f90f0403cfe8b10e59bb87092cd620318 /gr-uhd/lib
parent: f4762c567bf5ec85b998935ee330d7c0e986dc57 (diff)
11 files changed, 1639 insertions, 1172 deletions
diff --git a/gr-uhd/lib/CMakeLists.txt b/gr-uhd/lib/CMakeLists.txt
index c494fddad5..ab1448a673 100644
--- a/gr-uhd/lib/CMakeLists.txt
+++ b/gr-uhd/lib/CMakeLists.txt
@@ -38,9 +38,9 @@ link_directories(
 # Setup library
 ########################################################################
 list(APPEND gr_uhd_sources
-    gr_uhd_usrp_source.cc
-    gr_uhd_usrp_sink.cc
-    gr_uhd_amsg_source.cc
+    usrp_source_impl.cc
+    usrp_sink_impl.cc
+    amsg_source_impl.cc
 )
 
 list(APPEND uhd_libs
diff --git a/gr-uhd/lib/amsg_source_impl.cc b/gr-uhd/lib/amsg_source_impl.cc
new file mode 100644
index 0000000000..76603e4989
--- /dev/null
+++ b/gr-uhd/lib/amsg_source_impl.cc
@@ -0,0 +1,86 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2011-2013 Free Software Foundation, Inc.
+ *
+ * This file is part of GNU Radio
+ *
+ * GNU Radio 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, or (at your option)
+ * any later version.
+ *
+ * GNU Radio 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 GNU Radio; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "amsg_source_impl.h"
+#include "gr_uhd_common.h"
+#include <boost/bind.hpp>
+
+namespace gr {
+  namespace uhd {
+
+    amsg_source::sptr
+    amsg_source::make(const ::uhd::device_addr_t &device_addr,
+                      gr_msg_queue_sptr msgq)
+    {
+      check_abi();
+      return amsg_source::sptr
+        (new amsg_source_impl(device_addr, msgq));
+    }
+
+    ::uhd::async_metadata_t
+    amsg_source::msg_to_async_metadata_t(const gr_message_sptr msg)
+    {
+      return *(::uhd::async_metadata_t *)msg->msg();
+    }
+
+    amsg_source_impl::amsg_source_impl(const ::uhd::device_addr_t &device_addr,
+                                       gr_msg_queue_sptr msgq)
+      : _msgq(msgq), _running(true)
+    {
+      _dev = ::uhd::usrp::multi_usrp::make(device_addr);
+      _amsg_thread =
+        gruel::thread(boost::bind(&amsg_source_impl::recv_loop, this));
+    }
+
+    amsg_source_impl::~amsg_source_impl()
+    {
+      _running = false;
+      _amsg_thread.join();
+    }
+
+    void
+    amsg_source_impl::recv_loop()
+    {
+      gr_message_sptr msg;
+      ::uhd::async_metadata_t *md;
+
+      while(_running) {
+        msg = gr_make_message(0, 0.0, 0.0, sizeof(::uhd::async_metadata_t));
+        md = (::uhd::async_metadata_t*) msg->msg();
+
+        while(!_dev->get_device()->recv_async_msg(*md, 0.1)) {
+          if(!_running)
+            return;
+        }
+
+        post(msg);
+      }
+    }
+
+    void
+    amsg_source_impl::post(gr_message_sptr msg)
+    {
+      _msgq->insert_tail(msg);
+    }
+
+  } /* namespace uhd */
+} /* namespace gr */
diff --git a/gr-uhd/lib/amsg_source_impl.h b/gr-uhd/lib/amsg_source_impl.h
new file mode 100644
index 0000000000..2928e85adb
--- /dev/null
+++ b/gr-uhd/lib/amsg_source_impl.h
@@ -0,0 +1,48 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2011-2013 Free Software Foundation, Inc.
+ *
+ * This file is part of GNU Radio
+ *
+ * GNU Radio 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, or (at your option)
+ * any later version.
+ *
+ * GNU Radio 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 GNU Radio; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include <uhd/amsg_source.h>
+#include <gruel/thread.h>
+
+namespace gr {
+  namespace uhd {
+
+    class amsg_source_impl : public amsg_source
+    {
+    public:
+      amsg_source_impl(const ::uhd::device_addr_t &device_addr,
+                       gr_msg_queue_sptr msgq);
+      ~amsg_source_impl();
+
+      void recv_loop();
+      void post(gr_message_sptr msg);
+
+    protected:
+      ::uhd::usrp::multi_usrp::sptr _dev;
+      gruel::thread _amsg_thread;
+      gr_msg_queue_sptr _msgq;
+      bool _running;
+    };
+
+  } /* namespace uhd */
+} /* namespace gr */
+
diff --git a/gr-uhd/lib/gr_uhd_amsg_source.cc b/gr-uhd/lib/gr_uhd_amsg_source.cc
deleted file mode 100644
index d2e2dd0bf8..0000000000
--- a/gr-uhd/lib/gr_uhd_amsg_source.cc
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- * Copyright 2011-2012 Free Software Foundation, Inc.
- *
- * This file is part of GNU Radio
- *
- * GNU Radio 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, or (at your option)
- * any later version.
- *
- * GNU Radio 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 GNU Radio; see the file COPYING.  If not, write to
- * the Free Software Foundation, Inc., 51 Franklin Street,
- * Boston, MA 02110-1301, USA.
- */
-
-#include <gr_uhd_amsg_source.h>
-#include <boost/bind.hpp>
-#include <gruel/thread.h>
-#include "gr_uhd_common.h"
-
-/***********************************************************************
- * UHD Asynchronous Message Source Impl
- **********************************************************************/
-class uhd_amsg_source_impl : public uhd_amsg_source{
-public:
-    uhd_amsg_source_impl(
-        const uhd::device_addr_t &device_addr,
-        gr_msg_queue_sptr msgq
-    ):
-        _msgq(msgq), _running(true)
-    {
-        _dev = uhd::usrp::multi_usrp::make(device_addr);
-        _amsg_thread =
-            gruel::thread(boost::bind(&uhd_amsg_source_impl::recv_loop, this));
-    }
-
-    ~uhd_amsg_source_impl()
-    {
-        _running = false;
-        _amsg_thread.join();
-    }
-
-    void recv_loop()
-    {
-        gr_message_sptr msg;
-        uhd::async_metadata_t *md;
-
-        while (_running) {
-            msg = gr_make_message(0, 0.0, 0.0, sizeof(uhd::async_metadata_t));
-            md = (uhd::async_metadata_t *) msg->msg();
-
-            while (!_dev->get_device()->recv_async_msg(*md, 0.1)) {
-                if (!_running)
-                    return;
-            }
-
-            post(msg);
-        }
-    }
-
-    void post(gr_message_sptr msg)
-    {
-        _msgq->insert_tail(msg);
-    }
-
-protected:
-    uhd::usrp::multi_usrp::sptr _dev;
-    gruel::thread _amsg_thread;
-    gr_msg_queue_sptr _msgq;
-    bool _running;
-};
-
-uhd::async_metadata_t uhd_amsg_source::msg_to_async_metadata_t(const gr_message_sptr msg)
-{
-    return *(uhd::async_metadata_t *)msg->msg();
-}
-
-/***********************************************************************
- * Make UHD Asynchronous Message Source
- **********************************************************************/
-boost::shared_ptr<uhd_amsg_source> uhd_make_amsg_source(
-    const uhd::device_addr_t &device_addr,
-    gr_msg_queue_sptr msgq
-){
-    gr_uhd_check_abi();
-    return boost::shared_ptr<uhd_amsg_source>(
-        new uhd_amsg_source_impl(device_addr, msgq)
-    );
-}
diff --git a/gr-uhd/lib/gr_uhd_common.h b/gr-uhd/lib/gr_uhd_common.h
index f2433b288c..0c18fa4634 100644
--- a/gr-uhd/lib/gr_uhd_common.h
+++ b/gr-uhd/lib/gr_uhd_common.h
@@ -1,5 +1,6 @@
+/* -*- c++ -*- */
 /*
- * Copyright 2012 Free Software Foundation, Inc.
+ * Copyright 2012-2013 Free Software Foundation, Inc.
  *
  * This file is part of GNU Radio
  *
@@ -26,17 +27,26 @@
 #include <boost/format.hpp>
 #include <stdexcept>
 
-static inline void gr_uhd_check_abi(void){
-    #ifdef UHD_VERSION_ABI_STRING
-    if (std::string(UHD_VERSION_ABI_STRING) == uhd::get_abi_string()) return;
-    throw std::runtime_error(str(boost::format(
+namespace gr {
+  namespace uhd {
+
+    static inline void check_abi(void)
+    {
+#ifdef UHD_VERSION_ABI_STRING
+      if(std::string(UHD_VERSION_ABI_STRING) == ::uhd::get_abi_string())
+        return;
+
+      throw std::runtime_error(str(boost::format(
         "\nGR-UHD detected ABI compatibility mismatch with UHD library.\n"
         "GR-UHD was build against ABI: %s,\n"
         "but UHD library reports ABI: %s\n"
         "Suggestion: install an ABI compatible version of UHD,\n"
         "or rebuild GR-UHD component against this ABI version.\n"
-    ) % UHD_VERSION_ABI_STRING % uhd::get_abi_string()));
-    #endif
-}
+      ) % UHD_VERSION_ABI_STRING % ::uhd::get_abi_string()));
+#endif
+    }
+
+  } /* namespace uhd */
+} /* namespace gr */
 
 #endif /* INCLUDED_GR_UHD_COMMON_H */
diff --git a/gr-uhd/lib/gr_uhd_usrp_sink.cc b/gr-uhd/lib/gr_uhd_usrp_sink.cc
deleted file mode 100644
index 3b8fcea405..0000000000
--- a/gr-uhd/lib/gr_uhd_usrp_sink.cc
+++ /dev/null
@@ -1,503 +0,0 @@
-/*
- * Copyright 2010-2012 Free Software Foundation, Inc.
- *
- * This file is part of GNU Radio
- *
- * GNU Radio 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, or (at your option)
- * any later version.
- *
- * GNU Radio 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 GNU Radio; see the file COPYING.  If not, write to
- * the Free Software Foundation, Inc., 51 Franklin Street,
- * Boston, MA 02110-1301, USA.
- */
-
-#include <gr_uhd_usrp_sink.h>
-#include <gr_io_signature.h>
-#include <stdexcept>
-#include <boost/make_shared.hpp>
-#include "gr_uhd_common.h"
-
-static const pmt::pmt_t SOB_KEY = pmt::string_to_symbol("tx_sob");
-static const pmt::pmt_t EOB_KEY = pmt::string_to_symbol("tx_eob");
-static const pmt::pmt_t TIME_KEY = pmt::string_to_symbol("tx_time");
-
-#include <uhd/convert.hpp>
-inline gr_io_signature_sptr args_to_io_sig(const uhd::stream_args_t &args){
-    const size_t nchan = std::max<size_t>(args.channels.size(), 1);
-    #ifdef GR_UHD_USE_STREAM_API
-        const size_t size = uhd::convert::get_bytes_per_item(args.cpu_format);
-    #else
-        size_t size = 0;
-        if (args.cpu_format == "fc32") size = 8;
-        if (args.cpu_format == "sc16") size = 4;
-    #endif
-    return gr_make_io_signature(nchan, nchan, size);
-}
-
-/***********************************************************************
- * UHD Multi USRP Sink Impl
- **********************************************************************/
-class uhd_usrp_sink_impl : public uhd_usrp_sink{
-public:
-    uhd_usrp_sink_impl(
-        const uhd::device_addr_t &device_addr,
-        const uhd::stream_args_t &stream_args
-    ):
-        gr_sync_block(
-            "gr uhd usrp sink",
-            args_to_io_sig(stream_args),
-            gr_make_io_signature(0, 0, 0)
-        ),
-        _stream_args(stream_args),
-        _nchan(std::max<size_t>(1, stream_args.channels.size())),
-        _stream_now(_nchan == 1),
-        _start_time_set(false)
-    {
-        if (stream_args.cpu_format == "fc32") _type = boost::make_shared<uhd::io_type_t>(uhd::io_type_t::COMPLEX_FLOAT32);
-        if (stream_args.cpu_format == "sc16") _type = boost::make_shared<uhd::io_type_t>(uhd::io_type_t::COMPLEX_INT16);
-        _dev = uhd::usrp::multi_usrp::make(device_addr);
-    }
-
-    uhd::dict<std::string, std::string> get_usrp_info(size_t chan){
-        #ifdef UHD_USRP_MULTI_USRP_GET_USRP_INFO_API
-        return _dev->get_usrp_tx_info(chan);
-        #else
-        throw std::runtime_error("not implemented in this version");
-        #endif
-    }
-
-    void set_subdev_spec(const std::string &spec, size_t mboard){
-        return _dev->set_tx_subdev_spec(spec, mboard);
-    }
-
-    std::string get_subdev_spec(size_t mboard){
-        return _dev->get_tx_subdev_spec(mboard).to_string();
-    }
-
-    void set_samp_rate(double rate){
-        _dev->set_tx_rate(rate);
-        _sample_rate = this->get_samp_rate();
-    }
-
-    double get_samp_rate(void){
-        return _dev->get_tx_rate();
-    }
-
-    uhd::meta_range_t get_samp_rates(void){
-        #ifdef UHD_USRP_MULTI_USRP_GET_RATES_API
-        return _dev->get_tx_rates();
-        #else
-        throw std::runtime_error("not implemented in this version");
-        #endif
-    }
-
-    uhd::tune_result_t set_center_freq(
-        const uhd::tune_request_t tune_request, size_t chan
-    ){
-        return _dev->set_tx_freq(tune_request, chan);
-    }
-
-    double get_center_freq(size_t chan){
-        return _dev->get_tx_freq(chan);
-    }
-
-    uhd::freq_range_t get_freq_range(size_t chan){
-        return _dev->get_tx_freq_range(chan);
-    }
-
-    void set_gain(double gain, size_t chan){
-        return _dev->set_tx_gain(gain, chan);
-    }
-
-    void set_gain(double gain, const std::string &name, size_t chan){
-        return _dev->set_tx_gain(gain, name, chan);
-    }
-
-    double get_gain(size_t chan){
-        return _dev->get_tx_gain(chan);
-    }
-
-    double get_gain(const std::string &name, size_t chan){
-        return _dev->get_tx_gain(name, chan);
-    }
-
-    std::vector<std::string> get_gain_names(size_t chan){
-        return _dev->get_tx_gain_names(chan);
-    }
-
-    uhd::gain_range_t get_gain_range(size_t chan){
-        return _dev->get_tx_gain_range(chan);
-    }
-
-    uhd::gain_range_t get_gain_range(const std::string &name, size_t chan){
-        return _dev->get_tx_gain_range(name, chan);
-    }
-
-    void set_antenna(const std::string &ant, size_t chan){
-        return _dev->set_tx_antenna(ant, chan);
-    }
-
-    std::string get_antenna(size_t chan){
-        return _dev->get_tx_antenna(chan);
-    }
-
-    std::vector<std::string> get_antennas(size_t chan){
-        return _dev->get_tx_antennas(chan);
-    }
-
-    void set_bandwidth(double bandwidth, size_t chan){
-        return _dev->set_tx_bandwidth(bandwidth, chan);
-    }
-
-    void set_dc_offset(const std::complex<double> &offset, size_t chan){
-        #ifdef UHD_USRP_MULTI_USRP_FRONTEND_CAL_API
-        return _dev->set_tx_dc_offset(offset, chan);
-        #else
-        throw std::runtime_error("not implemented in this version");
-        #endif
-    }
-
-    void set_iq_balance(const std::complex<double> &correction, size_t chan){
-        #ifdef UHD_USRP_MULTI_USRP_FRONTEND_CAL_API
-        return _dev->set_tx_iq_balance(correction, chan);
-        #else
-        throw std::runtime_error("not implemented in this version");
-        #endif
-    }
-
-    uhd::sensor_value_t get_sensor(const std::string &name, size_t chan){
-        return _dev->get_tx_sensor(name, chan);
-    }
-
-    std::vector<std::string> get_sensor_names(size_t chan){
-        return _dev->get_tx_sensor_names(chan);
-    }
-
-    uhd::sensor_value_t get_mboard_sensor(const std::string &name, size_t mboard){
-        return _dev->get_mboard_sensor(name, mboard);
-    }
-
-    std::vector<std::string> get_mboard_sensor_names(size_t mboard){
-        return _dev->get_mboard_sensor_names(mboard);
-    }
-
-    void set_clock_config(const uhd::clock_config_t &clock_config, size_t mboard){
-        return _dev->set_clock_config(clock_config, mboard);
-    }
-
-    void set_time_source(const std::string &source, const size_t mboard){
-        #ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API
-        return _dev->set_time_source(source, mboard);
-        #else
-        throw std::runtime_error("not implemented in this version");
-        #endif
-    }
-
-    std::string get_time_source(const size_t mboard){
-        #ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API
-        return _dev->get_time_source(mboard);
-        #else
-        throw std::runtime_error("not implemented in this version");
-        #endif
-    }
-
-    std::vector<std::string> get_time_sources(const size_t mboard){
-        #ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API
-        return _dev->get_time_sources(mboard);
-        #else
-        throw std::runtime_error("not implemented in this version");
-        #endif
-    }
-
-    void set_clock_source(const std::string &source, const size_t mboard){
-        #ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API
-        return _dev->set_clock_source(source, mboard);
-        #else
-        throw std::runtime_error("not implemented in this version");
-        #endif
-    }
-
-    std::string get_clock_source(const size_t mboard){
-        #ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API
-        return _dev->get_clock_source(mboard);
-        #else
-        throw std::runtime_error("not implemented in this version");
-        #endif
-    }
-
-    std::vector<std::string> get_clock_sources(const size_t mboard){
-        #ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API
-        return _dev->get_clock_sources(mboard);
-        #else
-        throw std::runtime_error("not implemented in this version");
-        #endif
-    }
-
-    double get_clock_rate(size_t mboard){
-        return _dev->get_master_clock_rate(mboard);
-    }
-
-    void set_clock_rate(double rate, size_t mboard){
-        return _dev->set_master_clock_rate(rate, mboard);
-    }
-
-    uhd::time_spec_t get_time_now(size_t mboard = 0){
-        return _dev->get_time_now(mboard);
-    }
-
-    uhd::time_spec_t get_time_last_pps(size_t mboard){
-        return _dev->get_time_last_pps(mboard);
-    }
-
-    void set_time_now(const uhd::time_spec_t &time_spec, size_t mboard){
-        return _dev->set_time_now(time_spec, mboard);
-    }
-
-    void set_time_next_pps(const uhd::time_spec_t &time_spec){
-        return _dev->set_time_next_pps(time_spec);
-    }
-
-    void set_time_unknown_pps(const uhd::time_spec_t &time_spec){
-        return _dev->set_time_unknown_pps(time_spec);
-    }
-
-    void set_command_time(const uhd::time_spec_t &time_spec, size_t mboard){
-        #ifdef UHD_USRP_MULTI_USRP_COMMAND_TIME_API
-        return _dev->set_command_time(time_spec, mboard);
-        #else
-        throw std::runtime_error("not implemented in this version");
-        #endif
-    }
-
-    void clear_command_time(size_t mboard){
-        #ifdef UHD_USRP_MULTI_USRP_COMMAND_TIME_API
-        return _dev->clear_command_time(mboard);
-        #else
-        throw std::runtime_error("not implemented in this version");
-        #endif
-    }
-
-    uhd::usrp::dboard_iface::sptr get_dboard_iface(size_t chan){
-        return _dev->get_tx_dboard_iface(chan);
-    }
-
-    uhd::usrp::multi_usrp::sptr get_device(void){
-        return _dev;
-    }
-
-    void set_user_register(const uint8_t addr, const uint32_t data, size_t mboard){
-        #ifdef UHD_USRP_MULTI_USRP_USER_REGS_API
-        _dev->set_user_register(addr, data, mboard);
-        #else
-        throw std::runtime_error("not implemented in this version");
-        #endif
-    }
-
-
-/***********************************************************************
- * Work
- **********************************************************************/
-    int work(
-        int noutput_items,
-        gr_vector_const_void_star &input_items,
-        gr_vector_void_star &output_items
-    ){
-        int ninput_items = noutput_items; //cuz its a sync block
-
-        //send a mid-burst packet with time spec
-        _metadata.start_of_burst = false;
-        _metadata.end_of_burst = false;
-
-        //collect tags in this work()
-        const uint64_t samp0_count = nitems_read(0);
-        get_tags_in_range(_tags, 0, samp0_count, samp0_count + ninput_items);
-        if (not _tags.empty()) this->tag_work(ninput_items);
-
-        #ifdef GR_UHD_USE_STREAM_API
-        //send all ninput_items with metadata
-        const size_t num_sent = _tx_stream->send(
-            input_items, ninput_items, _metadata, 1.0
-        );
-        #else
-        const size_t num_sent = _dev->get_device()->send(
-            input_items, ninput_items, _metadata,
-            *_type, uhd::device::SEND_MODE_FULL_BUFF, 1.0
-        );
-        #endif
-
-        //increment the timespec by the number of samples sent
-        _metadata.time_spec += uhd::time_spec_t(0, num_sent, _sample_rate);
-        return num_sent;
-    }
-
-/***********************************************************************
- * Tag Work
- **********************************************************************/
-    inline void tag_work(int &ninput_items){
-        //the for loop below assumes tags sorted by count low -> high
-        std::sort(_tags.begin(), _tags.end(), gr_tag_t::offset_compare);
-
-        //extract absolute sample counts
-        const gr_tag_t &tag0 = _tags.front();
-        const uint64_t tag0_count = tag0.offset;
-        const uint64_t samp0_count = this->nitems_read(0);
-
-        //only transmit nsamples from 0 to the first tag
-        //this ensures that the next work starts on a tag
-        if (samp0_count != tag0_count){
-            ninput_items = tag0_count - samp0_count;
-            return;
-        }
-
-        //time will not be set unless a time tag is found
-        _metadata.has_time_spec = false;
-
-        //process all of the tags found with the same count as tag0
-        BOOST_FOREACH(const gr_tag_t &my_tag, _tags){
-            const uint64_t my_tag_count = my_tag.offset;
-            const pmt::pmt_t &key = my_tag.key;
-            const pmt::pmt_t &value = my_tag.value;
-
-            //determine how many samples to send...
-            //from zero until the next tag or end of work
-            if (my_tag_count != tag0_count){
-                ninput_items = my_tag_count - samp0_count;
-                break;
-            }
-
-            //handle end of burst with a mini end of burst packet
-            else if (pmt::equal(key, EOB_KEY)){
-                _metadata.end_of_burst = pmt::to_bool(value);
-                ninput_items = 1;
-                return;
-            }
-
-            //set the start of burst flag in the metadata
-            else if (pmt::equal(key, SOB_KEY)){
-                _metadata.start_of_burst = pmt::to_bool(value);
-            }
-
-            //set the time specification in the metadata
-            else if (pmt::equal(key, TIME_KEY)){
-                _metadata.has_time_spec = true;
-                _metadata.time_spec = uhd::time_spec_t(
-                    pmt::to_uint64(pmt::tuple_ref(value, 0)),
-                    pmt::to_double(pmt::tuple_ref(value, 1))
-                );
-            }
-        }
-    }
-
-    void set_start_time(const uhd::time_spec_t &time){
-        _start_time = time;
-        _start_time_set = true;
-        _stream_now = false;
-    }
-
-    //Send an empty start-of-burst packet to begin streaming.
-    //Set at a time in the near future to avoid late packets.
-    bool start(void){
-        #ifdef GR_UHD_USE_STREAM_API
-        _tx_stream = _dev->get_tx_stream(_stream_args);
-        #endif
-
-        _metadata.start_of_burst = true;
-        _metadata.end_of_burst = false;
-        _metadata.has_time_spec = not _stream_now;
-        if (_start_time_set){
-            _start_time_set = false; //cleared for next run
-            _metadata.time_spec = _start_time;
-        }
-        else{
-            _metadata.time_spec = get_time_now() + uhd::time_spec_t(0.01);
-        }
-
-        #ifdef GR_UHD_USE_STREAM_API
-        _tx_stream->send(
-            gr_vector_const_void_star(_nchan), 0, _metadata, 1.0
-        );
-        #else
-        _dev->get_device()->send(
-            gr_vector_const_void_star(_nchan), 0, _metadata,
-            *_type, uhd::device::SEND_MODE_ONE_PACKET, 1.0
-        );
-        #endif
-        return true;
-    }
-
-    //Send an empty end-of-burst packet to end streaming.
-    //Ending the burst avoids an underflow error on stop.
-    bool stop(void){
-        _metadata.start_of_burst = false;
-        _metadata.end_of_burst = true;
-        _metadata.has_time_spec = false;
-
-        #ifdef GR_UHD_USE_STREAM_API
-        _tx_stream->send(gr_vector_const_void_star(_nchan), 0, _metadata, 1.0);
-        #else
-        _dev->get_device()->send(
-            gr_vector_const_void_star(_nchan), 0, _metadata,
-            *_type, uhd::device::SEND_MODE_ONE_PACKET, 1.0
-        );
-        #endif
-        return true;
-    }
-
-private:
-    uhd::usrp::multi_usrp::sptr _dev;
-    const uhd::stream_args_t _stream_args;
-    boost::shared_ptr<uhd::io_type_t> _type;
-    #ifdef GR_UHD_USE_STREAM_API
-    uhd::tx_streamer::sptr _tx_stream;
-    #endif
-    size_t _nchan;
-    bool _stream_now;
-    uhd::tx_metadata_t _metadata;
-    double _sample_rate;
-
-    uhd::time_spec_t _start_time;
-    bool _start_time_set;
-
-    //stream tags related stuff
-    std::vector<gr_tag_t> _tags;
-};
-
-/***********************************************************************
- * Make UHD Multi USRP Sink
- **********************************************************************/
-boost::shared_ptr<uhd_usrp_sink> uhd_make_usrp_sink(
-    const uhd::device_addr_t &device_addr,
-    const uhd::io_type_t &io_type,
-    size_t num_channels
-){
-    //fill in the streamer args
-    uhd::stream_args_t stream_args;
-    switch(io_type.tid){
-    case uhd::io_type_t::COMPLEX_FLOAT32: stream_args.cpu_format = "fc32"; break;
-    case uhd::io_type_t::COMPLEX_INT16: stream_args.cpu_format = "sc16"; break;
-    default: throw std::runtime_error("only complex float and shorts known to work");
-    }
-    stream_args.otw_format = "sc16"; //only sc16 known to work
-    for (size_t chan = 0; chan < num_channels; chan++)
-        stream_args.channels.push_back(chan); //linear mapping
-
-    return uhd_make_usrp_sink(device_addr, stream_args);
-}
-
-boost::shared_ptr<uhd_usrp_sink> uhd_make_usrp_sink(
-    const uhd::device_addr_t &device_addr,
-    const uhd::stream_args_t &stream_args
-){
-    gr_uhd_check_abi();
-    return boost::shared_ptr<uhd_usrp_sink>(
-        new uhd_usrp_sink_impl(device_addr, stream_args)
-    );
-}
diff --git a/gr-uhd/lib/gr_uhd_usrp_source.cc b/gr-uhd/lib/gr_uhd_usrp_source.cc
deleted file mode 100644
index 6403d3d913..0000000000
--- a/gr-uhd/lib/gr_uhd_usrp_source.cc
+++ /dev/null
@@ -1,563 +0,0 @@
-/*
- * Copyright 2010-2012 Free Software Foundation, Inc.
- *
- * This file is part of GNU Radio
- *
- * GNU Radio 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, or (at your option)
- * any later version.
- *
- * GNU Radio 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 GNU Radio; see the file COPYING.  If not, write to
- * the Free Software Foundation, Inc., 51 Franklin Street,
- * Boston, MA 02110-1301, USA.
- */
-
-#include <gr_uhd_usrp_source.h>
-#include <gr_io_signature.h>
-#include <stdexcept>
-#include <iostream>
-#include <boost/format.hpp>
-#include <boost/thread/thread.hpp>
-#include <boost/make_shared.hpp>
-#include "gr_uhd_common.h"
-
-static const pmt::pmt_t TIME_KEY = pmt::string_to_symbol("rx_time");
-static const pmt::pmt_t RATE_KEY = pmt::string_to_symbol("rx_rate");
-static const pmt::pmt_t FREQ_KEY = pmt::string_to_symbol("rx_freq");
-
-#include <uhd/convert.hpp>
-inline gr_io_signature_sptr args_to_io_sig(const uhd::stream_args_t &args){
-    const size_t nchan = std::max<size_t>(args.channels.size(), 1);
-    #ifdef GR_UHD_USE_STREAM_API
-        const size_t size = uhd::convert::get_bytes_per_item(args.cpu_format);
-    #else
-        size_t size = 0;
-        if (args.cpu_format == "fc32") size = 8;
-        if (args.cpu_format == "sc16") size = 4;
-    #endif
-    return gr_make_io_signature(nchan, nchan, size);
-}
-
-/***********************************************************************
- * UHD Multi USRP Source Impl
- **********************************************************************/
-class uhd_usrp_source_impl : public uhd_usrp_source{
-public:
-    uhd_usrp_source_impl(
-        const uhd::device_addr_t &device_addr,
-        const uhd::stream_args_t &stream_args
-    ):
-        gr_sync_block(
-            "gr uhd usrp source",
-            gr_make_io_signature(0, 0, 0),
-            args_to_io_sig(stream_args)
-        ),
-        _stream_args(stream_args),
-        _nchan(std::max<size_t>(1, stream_args.channels.size())),
-        _stream_now(_nchan == 1),
-        _tag_now(false),
-        _start_time_set(false)
-    {
-        if (stream_args.cpu_format == "fc32") _type = boost::make_shared<uhd::io_type_t>(uhd::io_type_t::COMPLEX_FLOAT32);
-        if (stream_args.cpu_format == "sc16") _type = boost::make_shared<uhd::io_type_t>(uhd::io_type_t::COMPLEX_INT16);
-        std::stringstream str;
-        str << name() << unique_id();
-        _id = pmt::string_to_symbol(str.str());
-        _dev = uhd::usrp::multi_usrp::make(device_addr);
-    }
-
-    uhd::dict<std::string, std::string> get_usrp_info(size_t chan){
-        #ifdef UHD_USRP_MULTI_USRP_GET_USRP_INFO_API
-        return _dev->get_usrp_rx_info(chan);
-        #else
-        throw std::runtime_error("not implemented in this version");
-        #endif
-    }
-
-    void set_subdev_spec(const std::string &spec, size_t mboard){
-        return _dev->set_rx_subdev_spec(spec, mboard);
-    }
-
-    std::string get_subdev_spec(size_t mboard){
-        return _dev->get_rx_subdev_spec(mboard).to_string();
-    }
-
-    void set_samp_rate(double rate){
-        _dev->set_rx_rate(rate);
-        _samp_rate = this->get_samp_rate();
-        _tag_now = true;
-    }
-
-    double get_samp_rate(void){
-        return _dev->get_rx_rate();
-    }
-
-    uhd::meta_range_t get_samp_rates(void){
-        #ifdef UHD_USRP_MULTI_USRP_GET_RATES_API
-        return _dev->get_rx_rates();
-        #else
-        throw std::runtime_error("not implemented in this version");
-        #endif
-    }
-
-    uhd::tune_result_t set_center_freq(
-        const uhd::tune_request_t tune_request, size_t chan
-    ){
-        const uhd::tune_result_t res = _dev->set_rx_freq(tune_request, chan);
-        _center_freq = this->get_center_freq(chan);
-        _tag_now = true;
-        return res;
-    }
-
-    double get_center_freq(size_t chan){
-        return _dev->get_rx_freq(chan);
-    }
-
-    uhd::freq_range_t get_freq_range(size_t chan){
-        return _dev->get_rx_freq_range(chan);
-    }
-
-    void set_gain(double gain, size_t chan){
-        return _dev->set_rx_gain(gain, chan);
-    }
-
-    void set_gain(double gain, const std::string &name, size_t chan){
-        return _dev->set_rx_gain(gain, name, chan);
-    }
-
-    double get_gain(size_t chan){
-        return _dev->get_rx_gain(chan);
-    }
-
-    double get_gain(const std::string &name, size_t chan){
-        return _dev->get_rx_gain(name, chan);
-    }
-
-    std::vector<std::string> get_gain_names(size_t chan){
-        return _dev->get_rx_gain_names(chan);
-    }
-
-    uhd::gain_range_t get_gain_range(size_t chan){
-        return _dev->get_rx_gain_range(chan);
-    }
-
-    uhd::gain_range_t get_gain_range(const std::string &name, size_t chan){
-        return _dev->get_rx_gain_range(name, chan);
-    }
-
-    void set_antenna(const std::string &ant, size_t chan){
-        return _dev->set_rx_antenna(ant, chan);
-    }
-
-    std::string get_antenna(size_t chan){
-        return _dev->get_rx_antenna(chan);
-    }
-
-    std::vector<std::string> get_antennas(size_t chan){
-        return _dev->get_rx_antennas(chan);
-    }
-
-    void set_bandwidth(double bandwidth, size_t chan){
-        return _dev->set_rx_bandwidth(bandwidth, chan);
-    }
-
-    void set_auto_dc_offset(const bool enable, size_t chan){
-        #ifdef UHD_USRP_MULTI_USRP_FRONTEND_CAL_API
-        return _dev->set_rx_dc_offset(enable, chan);
-        #else
-        throw std::runtime_error("not implemented in this version");
-        #endif
-    }
-
-    void set_dc_offset(const std::complex<double> &offset, size_t chan){
-        #ifdef UHD_USRP_MULTI_USRP_FRONTEND_CAL_API
-        return _dev->set_rx_dc_offset(offset, chan);
-        #else
-        throw std::runtime_error("not implemented in this version");
-        #endif
-    }
-
-    void set_iq_balance(const std::complex<double> &correction, size_t chan){
-        #ifdef UHD_USRP_MULTI_USRP_FRONTEND_CAL_API
-        return _dev->set_rx_iq_balance(correction, chan);
-        #else
-        throw std::runtime_error("not implemented in this version");
-        #endif
-    }
-
-    uhd::sensor_value_t get_sensor(const std::string &name, size_t chan){
-        return _dev->get_rx_sensor(name, chan);
-    }
-
-    std::vector<std::string> get_sensor_names(size_t chan){
-        return _dev->get_rx_sensor_names(chan);
-    }
-
-    uhd::sensor_value_t get_mboard_sensor(const std::string &name, size_t mboard){
-        return _dev->get_mboard_sensor(name, mboard);
-    }
-
-    std::vector<std::string> get_mboard_sensor_names(size_t mboard){
-        return _dev->get_mboard_sensor_names(mboard);
-    }
-
-    void set_clock_config(const uhd::clock_config_t &clock_config, size_t mboard){
-        return _dev->set_clock_config(clock_config, mboard);
-    }
-
-    void set_time_source(const std::string &source, const size_t mboard){
-        #ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API
-        return _dev->set_time_source(source, mboard);
-        #else
-        throw std::runtime_error("not implemented in this version");
-        #endif
-    }
-
-    std::string get_time_source(const size_t mboard){
-        #ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API
-        return _dev->get_time_source(mboard);
-        #else
-        throw std::runtime_error("not implemented in this version");
-        #endif
-    }
-
-    std::vector<std::string> get_time_sources(const size_t mboard){
-        #ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API
-        return _dev->get_time_sources(mboard);
-        #else
-        throw std::runtime_error("not implemented in this version");
-        #endif
-    }
-
-    void set_clock_source(const std::string &source, const size_t mboard){
-        #ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API
-        return _dev->set_clock_source(source, mboard);
-        #else
-        throw std::runtime_error("not implemented in this version");
-        #endif
-    }
-
-    std::string get_clock_source(const size_t mboard){
-        #ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API
-        return _dev->get_clock_source(mboard);
-        #else
-        throw std::runtime_error("not implemented in this version");
-        #endif
-    }
-
-    std::vector<std::string> get_clock_sources(const size_t mboard){
-        #ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API
-        return _dev->get_clock_sources(mboard);
-        #else
-        throw std::runtime_error("not implemented in this version");
-        #endif
-    }
-
-    double get_clock_rate(size_t mboard){
-        return _dev->get_master_clock_rate(mboard);
-    }
-
-    void set_clock_rate(double rate, size_t mboard){
-        return _dev->set_master_clock_rate(rate, mboard);
-    }
-
-    uhd::time_spec_t get_time_now(size_t mboard = 0){
-        return _dev->get_time_now(mboard);
-    }
-
-    uhd::time_spec_t get_time_last_pps(size_t mboard){
-        return _dev->get_time_last_pps(mboard);
-    }
-
-    void set_time_now(const uhd::time_spec_t &time_spec, size_t mboard){
-        return _dev->set_time_now(time_spec, mboard);
-    }
-
-    void set_time_next_pps(const uhd::time_spec_t &time_spec){
-        return _dev->set_time_next_pps(time_spec);
-    }
-
-    void set_time_unknown_pps(const uhd::time_spec_t &time_spec){
-        return _dev->set_time_unknown_pps(time_spec);
-    }
-
-    void set_command_time(const uhd::time_spec_t &time_spec, size_t mboard){
-        #ifdef UHD_USRP_MULTI_USRP_COMMAND_TIME_API
-        return _dev->set_command_time(time_spec, mboard);
-        #else
-        throw std::runtime_error("not implemented in this version");
-        #endif
-    }
-
-    void clear_command_time(size_t mboard){
-        #ifdef UHD_USRP_MULTI_USRP_COMMAND_TIME_API
-        return _dev->clear_command_time(mboard);
-        #else
-        throw std::runtime_error("not implemented in this version");
-        #endif
-    }
-
-    uhd::usrp::dboard_iface::sptr get_dboard_iface(size_t chan){
-        return _dev->get_rx_dboard_iface(chan);
-    }
-
-    uhd::usrp::multi_usrp::sptr get_device(void){
-        return _dev;
-    }
-
-    void set_user_register(const uint8_t addr, const uint32_t data, size_t mboard){
-        #ifdef UHD_USRP_MULTI_USRP_USER_REGS_API
-        _dev->set_user_register(addr, data, mboard);
-        #else
-        throw std::runtime_error("not implemented in this version");
-        #endif
-    }
-
-/***********************************************************************
- * Work
- **********************************************************************/
-    int work(
-        int noutput_items,
-        gr_vector_const_void_star &input_items,
-        gr_vector_void_star &output_items
-    ){
-        #ifdef GR_UHD_USE_STREAM_API
-        //In order to allow for low-latency:
-        //We receive all available packets without timeout.
-        //This call can timeout under regular operation...
-        size_t num_samps = _rx_stream->recv(
-            output_items, noutput_items, _metadata, 0.0
-        );
-
-        //If receive resulted in a timeout condition:
-        //We now receive a single packet with a large timeout.
-        if (_metadata.error_code == uhd::rx_metadata_t::ERROR_CODE_TIMEOUT)
-        {
-            num_samps = _rx_stream->recv(
-                output_items, noutput_items, _metadata, 0.1, true/*one pkt*/
-            );
-        }
-        #else
-        size_t num_samps = _dev->get_device()->recv(
-            output_items, noutput_items, _metadata,
-            *_type, uhd::device::RECV_MODE_FULL_BUFF, 0.0
-        );
-        if (_metadata.error_code == uhd::rx_metadata_t::ERROR_CODE_TIMEOUT){
-            num_samps = _dev->get_device()->recv(
-                output_items, noutput_items, _metadata,
-                *_type, uhd::device::RECV_MODE_ONE_PACKET, 1.0
-            );
-        }
-        #endif
-
-        //handle possible errors conditions
-        switch(_metadata.error_code){
-        case uhd::rx_metadata_t::ERROR_CODE_NONE:
-            if (_tag_now){
-                _tag_now = false;
-                //create a timestamp pmt for the first sample
-                const pmt::pmt_t val = pmt::make_tuple(
-                    pmt::from_uint64(_metadata.time_spec.get_full_secs()),
-                    pmt::from_double(_metadata.time_spec.get_frac_secs())
-                );
-                //create a tag set for each channel
-                for (size_t i = 0; i < _nchan; i++){
-                    this->add_item_tag(i, nitems_written(0), TIME_KEY, val, _id);
-                    this->add_item_tag(i, nitems_written(0), RATE_KEY, pmt::from_double(_samp_rate), _id);
-                    this->add_item_tag(i, nitems_written(0), FREQ_KEY, pmt::from_double(_center_freq), _id);
-                }
-            }
-            break;
-
-        case uhd::rx_metadata_t::ERROR_CODE_TIMEOUT:
-            //its ok to timeout, perhaps the user is doing finite streaming
-            return 0;
-
-        case uhd::rx_metadata_t::ERROR_CODE_OVERFLOW:
-            _tag_now = true;
-            //ignore overflows and try work again
-            return work(noutput_items, input_items, output_items);
-
-        default:
-            std::cout << boost::format(
-                "UHD source block got error code 0x%x"
-            ) % _metadata.error_code << std::endl;
-            return num_samps;
-        }
-
-        return num_samps;
-    }
-
-    void set_start_time(const uhd::time_spec_t &time){
-        _start_time = time;
-        _start_time_set = true;
-        _stream_now = false;
-    }
-
-    void issue_stream_cmd(const uhd::stream_cmd_t &cmd)
-    {
-        _dev->issue_stream_cmd(cmd);
-    }
-
-    bool start(void){
-        #ifdef GR_UHD_USE_STREAM_API
-        _rx_stream = _dev->get_rx_stream(_stream_args);
-        _samps_per_packet = _rx_stream->get_max_num_samps();
-        #endif
-        //setup a stream command that starts streaming slightly in the future
-        static const double reasonable_delay = 0.1; //order of magnitude over RTT
-        uhd::stream_cmd_t stream_cmd(uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS);
-        stream_cmd.stream_now = _stream_now;
-        if (_start_time_set){
-            _start_time_set = false; //cleared for next run
-            stream_cmd.time_spec = _start_time;
-        }
-        else{
-            stream_cmd.time_spec = get_time_now() + uhd::time_spec_t(reasonable_delay);
-        }
-        _dev->issue_stream_cmd(stream_cmd);
-        _tag_now = true;
-        return true;
-    }
-
-    void flush(void){
-        const size_t nbytes = 4096;
-        gr_vector_void_star outputs;
-        std::vector<std::vector<char> > buffs(_nchan, std::vector<char>(nbytes));
-        for (size_t i = 0; i < _nchan; i++){
-            outputs.push_back(&buffs[i].front());
-        }
-        while (true){
-            #ifdef GR_UHD_USE_STREAM_API
-            const size_t bpi = uhd::convert::get_bytes_per_item(_stream_args.cpu_format);
-            _rx_stream->recv(
-                outputs, nbytes/bpi, _metadata, 0.0
-            );
-            #else
-            _dev->get_device()->recv(
-                outputs, nbytes/_type->size, _metadata,
-                *_type, uhd::device::RECV_MODE_FULL_BUFF, 0.0
-            );
-            #endif
-            if (_metadata.error_code == uhd::rx_metadata_t::ERROR_CODE_TIMEOUT) break;
-        }
-    }
-
-    bool stop(void){
-        _dev->issue_stream_cmd(uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS);
-
-        this->flush();
-
-        return true;
-    }
-
-    std::vector<std::complex<float> > finite_acquisition(const size_t nsamps){
-        if (_nchan != 1) throw std::runtime_error("finite_acquisition: usrp source has multiple channels, call finite_acquisition_v");
-        return finite_acquisition_v(nsamps).front();
-    }
-
-    std::vector<std::vector<std::complex<float> > > finite_acquisition_v(const size_t nsamps){
-        #ifdef GR_UHD_USE_STREAM_API
-
-        //kludgy way to ensure rx streamer exsists
-        if (!_rx_stream){
-            this->start();
-            this->stop();
-        }
-
-        //flush so there is no queued-up data
-        this->flush();
-
-        //create a multi-dimensional container to hold an array of sample buffers
-        std::vector<std::vector<std::complex<float> > > samps(_nchan, std::vector<std::complex<float> >(nsamps));
-
-        //load the void* vector of buffer pointers
-        std::vector<void *> buffs(_nchan);
-        for (size_t i = 0; i < _nchan; i++){
-            buffs[i] = &samps[i].front();
-        }
-
-        //tell the device to stream a finite amount
-        uhd::stream_cmd_t cmd(uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE);
-        cmd.num_samps = nsamps;
-        cmd.stream_now = _stream_now;
-        static const double reasonable_delay = 0.1; //order of magnitude over RTT
-        cmd.time_spec = get_time_now() + uhd::time_spec_t(reasonable_delay);
-        _dev->issue_stream_cmd(cmd);
-
-        //receive samples until timeout
-        const size_t actual_num_samps = _rx_stream->recv(
-            buffs, nsamps, _metadata, 1.0
-        );
-
-        //resize the resulting sample buffers
-        for (size_t i = 0; i < _nchan; i++){
-            samps[i].resize(actual_num_samps);
-        }
-
-        return samps;
-        #else
-        throw std::runtime_error("not implemented in this version");
-        #endif
-    }
-
-private:
-    uhd::usrp::multi_usrp::sptr _dev;
-    const uhd::stream_args_t _stream_args;
-    boost::shared_ptr<uhd::io_type_t> _type;
-    #ifdef GR_UHD_USE_STREAM_API
-    uhd::rx_streamer::sptr _rx_stream;
-    size_t _samps_per_packet;
-    #endif
-    size_t _nchan;
-    bool _stream_now, _tag_now;
-    uhd::rx_metadata_t _metadata;
-    pmt::pmt_t _id;
-
-    uhd::time_spec_t _start_time;
-    bool _start_time_set;
-
-    //tag shadows
-    double _samp_rate;
-    double _center_freq;
-};
-
-
-/***********************************************************************
- * Make UHD Multi USRP Source
- **********************************************************************/
-boost::shared_ptr<uhd_usrp_source> uhd_make_usrp_source(
-    const uhd::device_addr_t &device_addr,
-    const uhd::io_type_t &io_type,
-    size_t num_channels
-){
-    //fill in the streamer args
-    uhd::stream_args_t stream_args;
-    switch(io_type.tid){
-    case uhd::io_type_t::COMPLEX_FLOAT32: stream_args.cpu_format = "fc32"; break;
-    case uhd::io_type_t::COMPLEX_INT16: stream_args.cpu_format = "sc16"; break;
-    default: throw std::runtime_error("only complex float and shorts known to work");
-    }
-    stream_args.otw_format = "sc16"; //only sc16 known to work
-    for (size_t chan = 0; chan < num_channels; chan++)
-        stream_args.channels.push_back(chan); //linear mapping
-
-    return uhd_make_usrp_source(device_addr, stream_args);
-}
-
-boost::shared_ptr<uhd_usrp_source> uhd_make_usrp_source(
-    const uhd::device_addr_t &device_addr,
-    const uhd::stream_args_t &stream_args
-){
-    gr_uhd_check_abi();
-    return boost::shared_ptr<uhd_usrp_source>(
-        new uhd_usrp_source_impl(device_addr, stream_args)
-    );
-}
diff --git a/gr-uhd/lib/usrp_sink_impl.cc b/gr-uhd/lib/usrp_sink_impl.cc
new file mode 100644
index 0000000000..563917abaf
--- /dev/null
+++ b/gr-uhd/lib/usrp_sink_impl.cc
@@ -0,0 +1,575 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2010-2013 Free Software Foundation, Inc.
+ *
+ * This file is part of GNU Radio
+ *
+ * GNU Radio 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, or (at your option)
+ * any later version.
+ *
+ * GNU Radio 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 GNU Radio; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "usrp_sink_impl.h"
+#include "gr_uhd_common.h"
+#include <gr_io_signature.h>
+#include <boost/make_shared.hpp>
+#include <stdexcept>
+
+namespace gr {
+  namespace uhd {
+
+    usrp_sink::sptr
+    usrp_sink::make(const ::uhd::device_addr_t &device_addr,
+                    const ::uhd::io_type_t &io_type,
+                    size_t num_channels)
+    {
+      //fill in the streamer args
+      ::uhd::stream_args_t stream_args;
+      switch(io_type.tid) {
+      case ::uhd::io_type_t::COMPLEX_FLOAT32: stream_args.cpu_format = "fc32"; break;
+      case ::uhd::io_type_t::COMPLEX_INT16: stream_args.cpu_format = "sc16"; break;
+      default: throw std::runtime_error("only complex float and shorts known to work");
+      }
+
+      stream_args.otw_format = "sc16"; //only sc16 known to work
+      for(size_t chan = 0; chan < num_channels; chan++)
+        stream_args.channels.push_back(chan); //linear mapping
+
+      return usrp_sink::make(device_addr, stream_args);
+    }
+
+    usrp_sink::sptr
+    usrp_sink::make(const ::uhd::device_addr_t &device_addr,
+                    const ::uhd::stream_args_t &stream_args)
+    {
+      check_abi();
+      return usrp_sink::sptr
+        (new usrp_sink_impl(device_addr, stream_args));
+    }
+
+    usrp_sink_impl::usrp_sink_impl(const ::uhd::device_addr_t &device_addr,
+                                   const ::uhd::stream_args_t &stream_args)
+      : gr_sync_block("gr uhd usrp sink",
+                      args_to_io_sig(stream_args),
+                      gr_make_io_signature(0, 0, 0)),
+        _stream_args(stream_args),
+        _nchan(std::max<size_t>(1, stream_args.channels.size())),
+        _stream_now(_nchan == 1),
+        _start_time_set(false)
+    {
+      if(stream_args.cpu_format == "fc32")
+        _type = boost::make_shared< ::uhd::io_type_t >(::uhd::io_type_t::COMPLEX_FLOAT32);
+      if(stream_args.cpu_format == "sc16")
+        _type = boost::make_shared< ::uhd::io_type_t >(::uhd::io_type_t::COMPLEX_INT16);
+      _dev = ::uhd::usrp::multi_usrp::make(device_addr);
+    }
+
+    usrp_sink_impl::~usrp_sink_impl()
+    {
+    }
+
+    ::uhd::dict<std::string, std::string>
+    usrp_sink_impl::get_usrp_info(size_t chan)
+    {
+#ifdef UHD_USRP_MULTI_USRP_GET_USRP_INFO_API
+      return _dev->get_usrp_tx_info(chan);
+#else
+      throw std::runtime_error("not implemented in this version");
+#endif
+    }
+
+    void
+    usrp_sink_impl::set_subdev_spec(const std::string &spec,
+                                    size_t mboard)
+    {
+      return _dev->set_tx_subdev_spec(spec, mboard);
+    }
+
+    std::string
+    usrp_sink_impl::get_subdev_spec(size_t mboard)
+    {
+      return _dev->get_tx_subdev_spec(mboard).to_string();
+    }
+
+    void
+    usrp_sink_impl::set_samp_rate(double rate)
+    {
+      _dev->set_tx_rate(rate);
+      _sample_rate = this->get_samp_rate();
+    }
+
+    double
+    usrp_sink_impl::get_samp_rate(void)
+    {
+      return _dev->get_tx_rate();
+    }
+
+    ::uhd::meta_range_t
+    usrp_sink_impl::get_samp_rates(void)
+    {
+#ifdef UHD_USRP_MULTI_USRP_GET_RATES_API
+      return _dev->get_tx_rates();
+#else
+      throw std::runtime_error("not implemented in this version");
+#endif
+    }
+
+    ::uhd::tune_result_t
+    usrp_sink_impl::set_center_freq(const ::uhd::tune_request_t tune_request,
+                                    size_t chan)
+    {
+      return _dev->set_tx_freq(tune_request, chan);
+    }
+
+    double
+    usrp_sink_impl::get_center_freq(size_t chan)
+    {
+      return _dev->get_tx_freq(chan);
+    }
+
+    ::uhd::freq_range_t
+    usrp_sink_impl::get_freq_range(size_t chan)
+    {
+      return _dev->get_tx_freq_range(chan);
+    }
+
+    void
+    usrp_sink_impl::set_gain(double gain, size_t chan)
+    {
+      return _dev->set_tx_gain(gain, chan);
+    }
+
+    void
+    usrp_sink_impl::set_gain(double gain,
+                             const std::string &name,
+                             size_t chan)
+    {
+      return _dev->set_tx_gain(gain, name, chan);
+    }
+
+    double
+    usrp_sink_impl::get_gain(size_t chan)
+    {
+      return _dev->get_tx_gain(chan);
+    }
+
+    double
+    usrp_sink_impl::get_gain(const std::string &name, size_t chan)
+    {
+      return _dev->get_tx_gain(name, chan);
+    }
+
+    std::vector<std::string>
+    usrp_sink_impl::get_gain_names(size_t chan)
+    {
+      return _dev->get_tx_gain_names(chan);
+    }
+
+    ::uhd::gain_range_t
+    usrp_sink_impl::get_gain_range(size_t chan)
+    {
+      return _dev->get_tx_gain_range(chan);
+    }
+
+    ::uhd::gain_range_t
+    usrp_sink_impl::get_gain_range(const std::string &name,
+                                   size_t chan)
+    {
+      return _dev->get_tx_gain_range(name, chan);
+    }
+
+    void
+    usrp_sink_impl::set_antenna(const std::string &ant,
+                                size_t chan)
+    {
+      return _dev->set_tx_antenna(ant, chan);
+    }
+
+    std::string
+    usrp_sink_impl::get_antenna(size_t chan)
+    {
+      return _dev->get_tx_antenna(chan);
+    }
+
+    std::vector<std::string>
+    usrp_sink_impl::get_antennas(size_t chan)
+    {
+      return _dev->get_tx_antennas(chan);
+    }
+
+    void
+    usrp_sink_impl::set_bandwidth(double bandwidth, size_t chan)
+    {
+      return _dev->set_tx_bandwidth(bandwidth, chan);
+    }
+
+    void
+    usrp_sink_impl::set_dc_offset(const std::complex<double> &offset,
+                                  size_t chan)
+    {
+#ifdef UHD_USRP_MULTI_USRP_FRONTEND_CAL_API
+      return _dev->set_tx_dc_offset(offset, chan);
+#else
+      throw std::runtime_error("not implemented in this version");
+#endif
+    }
+
+    void
+    usrp_sink_impl::set_iq_balance(const std::complex<double> &correction,
+                                   size_t chan)
+    {
+#ifdef UHD_USRP_MULTI_USRP_FRONTEND_CAL_API
+      return _dev->set_tx_iq_balance(correction, chan);
+#else
+      throw std::runtime_error("not implemented in this version");
+#endif
+    }
+
+    ::uhd::sensor_value_t
+    usrp_sink_impl::get_sensor(const std::string &name, size_t chan)
+    {
+      return _dev->get_tx_sensor(name, chan);
+    }
+
+    std::vector<std::string>
+    usrp_sink_impl::get_sensor_names(size_t chan)
+    {
+      return _dev->get_tx_sensor_names(chan);
+    }
+
+    ::uhd::sensor_value_t
+    usrp_sink_impl::get_mboard_sensor(const std::string &name,
+                                       size_t mboard)
+    {
+      return _dev->get_mboard_sensor(name, mboard);
+    }
+
+    std::vector<std::string>
+    usrp_sink_impl::get_mboard_sensor_names(size_t mboard)
+    {
+      return _dev->get_mboard_sensor_names(mboard);
+    }
+
+    void
+    usrp_sink_impl::set_clock_config(const ::uhd::clock_config_t &clock_config,
+                                     size_t mboard)
+    {
+      return _dev->set_clock_config(clock_config, mboard);
+    }
+
+    void
+    usrp_sink_impl::set_time_source(const std::string &source,
+                                    const size_t mboard)
+    {
+#ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API
+      return _dev->set_time_source(source, mboard);
+#else
+      throw std::runtime_error("not implemented in this version");
+#endif
+    }
+
+    std::string
+    usrp_sink_impl::get_time_source(const size_t mboard)
+    {
+#ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API
+      return _dev->get_time_source(mboard);
+#else
+      throw std::runtime_error("not implemented in this version");
+#endif
+    }
+
+    std::vector<std::string>
+    usrp_sink_impl::get_time_sources(const size_t mboard)
+    {
+#ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API
+      return _dev->get_time_sources(mboard);
+#else
+      throw std::runtime_error("not implemented in this version");
+#endif
+    }
+
+    void
+    usrp_sink_impl::set_clock_source(const std::string &source,
+                                     const size_t mboard)
+    {
+#ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API
+      return _dev->set_clock_source(source, mboard);
+#else
+      throw std::runtime_error("not implemented in this version");
+#endif
+    }
+
+    std::string
+    usrp_sink_impl::get_clock_source(const size_t mboard)
+    {
+#ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API
+      return _dev->get_clock_source(mboard);
+#else
+      throw std::runtime_error("not implemented in this version");
+#endif
+    }
+
+    std::vector<std::string>
+    usrp_sink_impl::get_clock_sources(const size_t mboard)
+    {
+#ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API
+      return _dev->get_clock_sources(mboard);
+#else
+      throw std::runtime_error("not implemented in this version");
+#endif
+    }
+
+    double
+    usrp_sink_impl::get_clock_rate(size_t mboard)
+    {
+      return _dev->get_master_clock_rate(mboard);
+    }
+
+    void
+    usrp_sink_impl::set_clock_rate(double rate, size_t mboard)
+    {
+      return _dev->set_master_clock_rate(rate, mboard);
+    }
+
+    ::uhd::time_spec_t
+    usrp_sink_impl::get_time_now(size_t mboard)
+    {
+      return _dev->get_time_now(mboard);
+    }
+
+    ::uhd::time_spec_t
+    usrp_sink_impl::get_time_last_pps(size_t mboard)
+    {
+      return _dev->get_time_last_pps(mboard);
+    }
+
+    void
+    usrp_sink_impl::set_time_now(const ::uhd::time_spec_t &time_spec,
+                                 size_t mboard)
+    {
+      return _dev->set_time_now(time_spec, mboard);
+    }
+
+    void
+    usrp_sink_impl::set_time_next_pps(const ::uhd::time_spec_t &time_spec)
+    {
+      return _dev->set_time_next_pps(time_spec);
+    }
+
+    void
+    usrp_sink_impl::set_time_unknown_pps(const ::uhd::time_spec_t &time_spec)
+    {
+      return _dev->set_time_unknown_pps(time_spec);
+    }
+
+    void
+    usrp_sink_impl::set_command_time(const ::uhd::time_spec_t &time_spec,
+                                     size_t mboard)
+    {
+#ifdef UHD_USRP_MULTI_USRP_COMMAND_TIME_API
+      return _dev->set_command_time(time_spec, mboard);
+#else
+      throw std::runtime_error("not implemented in this version");
+#endif
+    }
+
+    void
+    usrp_sink_impl::clear_command_time(size_t mboard)
+    {
+#ifdef UHD_USRP_MULTI_USRP_COMMAND_TIME_API
+      return _dev->clear_command_time(mboard);
+#else
+      throw std::runtime_error("not implemented in this version");
+#endif
+    }
+
+    ::uhd::usrp::dboard_iface::sptr
+    usrp_sink_impl::get_dboard_iface(size_t chan)
+    {
+      return _dev->get_tx_dboard_iface(chan);
+    }
+
+    ::uhd::usrp::multi_usrp::sptr
+    usrp_sink_impl::get_device(void)
+    {
+      return _dev;
+    }
+
+    void
+    usrp_sink_impl::set_user_register(const uint8_t addr,
+                                      const uint32_t data,
+                                      size_t mboard)
+    {
+#ifdef UHD_USRP_MULTI_USRP_USER_REGS_API
+      _dev->set_user_register(addr, data, mboard);
+#else
+      throw std::runtime_error("not implemented in this version");
+#endif
+    }
+
+
+    /***********************************************************************
+     * Work
+     **********************************************************************/
+    int
+    usrp_sink_impl::work(int noutput_items,
+                         gr_vector_const_void_star &input_items,
+                         gr_vector_void_star &output_items)
+    {
+      int ninput_items = noutput_items; //cuz its a sync block
+
+      //send a mid-burst packet with time spec
+      _metadata.start_of_burst = false;
+      _metadata.end_of_burst = false;
+
+      //collect tags in this work()
+      const uint64_t samp0_count = nitems_read(0);
+      get_tags_in_range(_tags, 0, samp0_count, samp0_count + ninput_items);
+      if(not _tags.empty())
+        this->tag_work(ninput_items);
+
+#ifdef GR_UHD_USE_STREAM_API
+      //send all ninput_items with metadata
+      const size_t num_sent = _tx_stream->send
+        (input_items, ninput_items, _metadata, 1.0);
+#else
+      const size_t num_sent = _dev->get_device()->send
+        (input_items, ninput_items, _metadata,
+         *_type, ::uhd::device::SEND_MODE_FULL_BUFF, 1.0);
+#endif
+
+      //increment the timespec by the number of samples sent
+      _metadata.time_spec += ::uhd::time_spec_t(0, num_sent, _sample_rate);
+      return num_sent;
+    }
+
+    /***********************************************************************
+     * Tag Work
+     **********************************************************************/
+    void
+    usrp_sink_impl::tag_work(int &ninput_items)
+    {
+      //the for loop below assumes tags sorted by count low -> high
+      std::sort(_tags.begin(), _tags.end(), gr_tag_t::offset_compare);
+
+      //extract absolute sample counts
+      const gr_tag_t &tag0 = _tags.front();
+      const uint64_t tag0_count = tag0.offset;
+      const uint64_t samp0_count = this->nitems_read(0);
+
+      //only transmit nsamples from 0 to the first tag
+      //this ensures that the next work starts on a tag
+      if(samp0_count != tag0_count) {
+        ninput_items = tag0_count - samp0_count;
+        return;
+      }
+
+      //time will not be set unless a time tag is found
+      _metadata.has_time_spec = false;
+
+      //process all of the tags found with the same count as tag0
+      BOOST_FOREACH(const gr_tag_t &my_tag, _tags) {
+        const uint64_t my_tag_count = my_tag.offset;
+        const pmt::pmt_t &key = my_tag.key;
+        const pmt::pmt_t &value = my_tag.value;
+
+        //determine how many samples to send...
+        //from zero until the next tag or end of work
+        if(my_tag_count != tag0_count) {
+          ninput_items = my_tag_count - samp0_count;
+          break;
+        }
+
+        //handle end of burst with a mini end of burst packet
+        else if(pmt::equal(key, EOB_KEY)) {
+          _metadata.end_of_burst = pmt::to_bool(value);
+          ninput_items = 1;
+          return;
+        }
+
+        //set the start of burst flag in the metadata
+        else if(pmt::equal(key, SOB_KEY)) {
+          _metadata.start_of_burst = pmt::to_bool(value);
+        }
+
+        //set the time specification in the metadata
+        else if(pmt::equal(key, TIME_KEY)) {
+          _metadata.has_time_spec = true;
+          _metadata.time_spec = ::uhd::time_spec_t
+            (pmt::to_uint64(pmt::tuple_ref(value, 0)),
+             pmt::to_double(pmt::tuple_ref(value, 1)));
+        }
+      }
+    }
+
+    void
+    usrp_sink_impl::set_start_time(const ::uhd::time_spec_t &time)
+    {
+      _start_time = time;
+      _start_time_set = true;
+      _stream_now = false;
+    }
+
+    //Send an empty start-of-burst packet to begin streaming.
+    //Set at a time in the near future to avoid late packets.
+    bool
+    usrp_sink_impl::start(void)
+    {
+#ifdef GR_UHD_USE_STREAM_API
+      _tx_stream = _dev->get_tx_stream(_stream_args);
+#endif
+
+      _metadata.start_of_burst = true;
+      _metadata.end_of_burst = false;
+      _metadata.has_time_spec = not _stream_now;
+      if(_start_time_set) {
+        _start_time_set = false; //cleared for next run
+        _metadata.time_spec = _start_time;
+      }
+      else {
+        _metadata.time_spec = get_time_now() + ::uhd::time_spec_t(0.01);
+      }
+
+#ifdef GR_UHD_USE_STREAM_API
+      _tx_stream->send
+        (gr_vector_const_void_star(_nchan), 0, _metadata, 1.0);
+#else
+      _dev->get_device()->send
+        (gr_vector_const_void_star(_nchan), 0, _metadata,
+         *_type, ::uhd::device::SEND_MODE_ONE_PACKET, 1.0);
+#endif
+      return true;
+    }
+
+    //Send an empty end-of-burst packet to end streaming.
+    //Ending the burst avoids an underflow error on stop.
+    bool
+    usrp_sink_impl::stop(void)
+    {
+      _metadata.start_of_burst = false;
+      _metadata.end_of_burst = true;
+      _metadata.has_time_spec = false;
+
+#ifdef GR_UHD_USE_STREAM_API
+      _tx_stream->send(gr_vector_const_void_star(_nchan), 0, _metadata, 1.0);
+#else
+      _dev->get_device()->send
+        (gr_vector_const_void_star(_nchan), 0, _metadata,
+         *_type, ::uhd::device::SEND_MODE_ONE_PACKET, 1.0);
+#endif
+      return true;
+    }
+
+  } /* namespace uhd */
+} /* namespace gr */
diff --git a/gr-uhd/lib/usrp_sink_impl.h b/gr-uhd/lib/usrp_sink_impl.h
new file mode 100644
index 0000000000..d630e0f2fc
--- /dev/null
+++ b/gr-uhd/lib/usrp_sink_impl.h
@@ -0,0 +1,137 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2010-2013 Free Software Foundation, Inc.
+ *
+ * This file is part of GNU Radio
+ *
+ * GNU Radio 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, or (at your option)
+ * any later version.
+ *
+ * GNU Radio 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 GNU Radio; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include <uhd/usrp_sink.h>
+#include <uhd/convert.hpp>
+
+static const pmt::pmt_t SOB_KEY = pmt::string_to_symbol("tx_sob");
+static const pmt::pmt_t EOB_KEY = pmt::string_to_symbol("tx_eob");
+static const pmt::pmt_t TIME_KEY = pmt::string_to_symbol("tx_time");
+
+namespace gr {
+  namespace uhd {
+
+    inline gr_io_signature_sptr
+    args_to_io_sig(const ::uhd::stream_args_t &args)
+    {
+      const size_t nchan = std::max<size_t>(args.channels.size(), 1);
+#ifdef GR_UHD_USE_STREAM_API
+      const size_t size = ::uhd::convert::get_bytes_per_item(args.cpu_format);
+#else
+      size_t size = 0;
+      if(args.cpu_format == "fc32")
+        size = 8;
+      if(args.cpu_format == "sc16")
+        size = 4;
+#endif
+      return gr_make_io_signature(nchan, nchan, size);
+    }
+
+    /***********************************************************************
+     * UHD Multi USRP Sink Impl
+     **********************************************************************/
+    class usrp_sink_impl : public usrp_sink
+    {
+    public:
+       usrp_sink_impl(const ::uhd::device_addr_t &device_addr,
+                      const ::uhd::stream_args_t &stream_args);
+      ~usrp_sink_impl();
+
+      ::uhd::dict<std::string, std::string> get_usrp_info(size_t chan);
+      double get_samp_rate(void);
+      ::uhd::meta_range_t get_samp_rates(void);
+      double get_center_freq(size_t chan);
+      ::uhd::freq_range_t get_freq_range(size_t chan);
+      double get_gain(size_t chan);
+      double get_gain(const std::string &name, size_t chan);
+      std::vector<std::string> get_gain_names(size_t chan);
+      ::uhd::gain_range_t get_gain_range(size_t chan);
+      ::uhd::gain_range_t get_gain_range(const std::string &name, size_t chan);
+      std::string get_antenna(size_t chan);
+      std::vector<std::string> get_antennas(size_t chan);
+      ::uhd::sensor_value_t get_sensor(const std::string &name, size_t chan);
+      std::vector<std::string> get_sensor_names(size_t chan);
+      ::uhd::sensor_value_t get_mboard_sensor(const std::string &name, size_t mboard);
+      std::vector<std::string> get_mboard_sensor_names(size_t mboard);
+      std::string get_time_source(const size_t mboard);
+      std::vector<std::string> get_time_sources(const size_t mboard);
+      std::string get_clock_source(const size_t mboard);
+      std::vector<std::string> get_clock_sources(const size_t mboard);
+      double get_clock_rate(size_t mboard);
+      ::uhd::time_spec_t get_time_now(size_t mboard = 0);
+      ::uhd::time_spec_t get_time_last_pps(size_t mboard);
+      ::uhd::usrp::dboard_iface::sptr get_dboard_iface(size_t chan);
+      ::uhd::usrp::multi_usrp::sptr get_device(void);
+
+      void set_subdev_spec(const std::string &spec, size_t mboard);
+      std::string get_subdev_spec(size_t mboard);
+      void set_samp_rate(double rate);
+      ::uhd::tune_result_t set_center_freq(const ::uhd::tune_request_t tune_request,
+                                         size_t chan);
+      void set_gain(double gain, size_t chan);
+      void set_gain(double gain, const std::string &name, size_t chan);
+      void set_antenna(const std::string &ant, size_t chan);
+      void set_bandwidth(double bandwidth, size_t chan);
+      void set_dc_offset(const std::complex<double> &offset, size_t chan);
+      void set_iq_balance(const std::complex<double> &correction, size_t chan);
+      void set_clock_config(const ::uhd::clock_config_t &clock_config, size_t mboard);
+      void set_time_source(const std::string &source, const size_t mboard);
+      void set_clock_source(const std::string &source, const size_t mboard);
+      void set_clock_rate(double rate, size_t mboard);
+      void set_time_now(const ::uhd::time_spec_t &time_spec, size_t mboard);
+      void set_time_next_pps(const ::uhd::time_spec_t &time_spec);
+      void set_time_unknown_pps(const ::uhd::time_spec_t &time_spec);
+      void set_command_time(const ::uhd::time_spec_t &time_spec, size_t mboard);
+      void clear_command_time(size_t mboard);
+      void set_user_register(const uint8_t addr, const uint32_t data, size_t mboard);
+      void set_start_time(const ::uhd::time_spec_t &time);
+
+      bool start(void);
+      bool stop(void);
+
+      int work(int noutput_items,
+               gr_vector_const_void_star &input_items,
+               gr_vector_void_star &output_items);
+
+      inline void tag_work(int &ninput_items);
+
+    private:
+      ::uhd::usrp::multi_usrp::sptr _dev;
+      const ::uhd::stream_args_t _stream_args;
+      boost::shared_ptr< ::uhd::io_type_t > _type;
+#ifdef GR_UHD_USE_STREAM_API
+      ::uhd::tx_streamer::sptr _tx_stream;
+#endif
+      size_t _nchan;
+      bool _stream_now;
+      ::uhd::tx_metadata_t _metadata;
+      double _sample_rate;
+
+      ::uhd::time_spec_t _start_time;
+      bool _start_time_set;
+
+      //stream tags related stuff
+      std::vector<gr_tag_t> _tags;
+    };
+
+  } /* namespace uhd */
+} /* namespace gr */
diff --git a/gr-uhd/lib/usrp_source_impl.cc b/gr-uhd/lib/usrp_source_impl.cc
new file mode 100644
index 0000000000..9d6a55ae5a
--- /dev/null
+++ b/gr-uhd/lib/usrp_source_impl.cc
@@ -0,0 +1,628 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2010-2013 Free Software Foundation, Inc.
+ *
+ * This file is part of GNU Radio
+ *
+ * GNU Radio 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, or (at your option)
+ * any later version.
+ *
+ * GNU Radio 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 GNU Radio; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "usrp_source_impl.h"
+#include "gr_uhd_common.h"
+#include <gr_io_signature.h>
+#include <boost/format.hpp>
+#include <boost/thread/thread.hpp>
+#include <boost/make_shared.hpp>
+#include <stdexcept>
+#include <iostream>
+
+namespace gr {
+  namespace uhd {
+
+    usrp_source::sptr
+    usrp_source::make(const ::uhd::device_addr_t &device_addr,
+                      const ::uhd::io_type_t &io_type,
+                      size_t num_channels)
+    {
+      //fill in the streamer args
+      ::uhd::stream_args_t stream_args;
+      switch(io_type.tid) {
+      case ::uhd::io_type_t::COMPLEX_FLOAT32: stream_args.cpu_format = "fc32"; break;
+      case ::uhd::io_type_t::COMPLEX_INT16: stream_args.cpu_format = "sc16"; break;
+      default: throw std::runtime_error("only complex float and shorts known to work");
+      }
+
+      stream_args.otw_format = "sc16"; //only sc16 known to work
+      for(size_t chan = 0; chan < num_channels; chan++)
+        stream_args.channels.push_back(chan); //linear mapping
+
+      return usrp_source::make(device_addr, stream_args);
+    }
+
+    usrp_source::sptr
+    usrp_source::make(const ::uhd::device_addr_t &device_addr,
+                      const ::uhd::stream_args_t &stream_args)
+    {
+      check_abi();
+      return usrp_source::sptr
+        (new usrp_source_impl(device_addr, stream_args));
+    }
+
+    usrp_source_impl::usrp_source_impl(const ::uhd::device_addr_t &device_addr,
+                                       const ::uhd::stream_args_t &stream_args):
+      gr_sync_block("gr uhd usrp source",
+                    gr_make_io_signature(0, 0, 0),
+                    args_to_io_sig(stream_args)),
+      _stream_args(stream_args),
+      _nchan(std::max<size_t>(1, stream_args.channels.size())),
+      _stream_now(_nchan == 1),
+      _tag_now(false),
+      _start_time_set(false)
+    {
+      if(stream_args.cpu_format == "fc32")
+        _type = boost::make_shared< ::uhd::io_type_t >(::uhd::io_type_t::COMPLEX_FLOAT32);
+      if(stream_args.cpu_format == "sc16")
+        _type = boost::make_shared< ::uhd::io_type_t >(::uhd::io_type_t::COMPLEX_INT16);
+      std::stringstream str;
+      str << name() << unique_id();
+      _id = pmt::string_to_symbol(str.str());
+      _dev = ::uhd::usrp::multi_usrp::make(device_addr);
+    }
+
+    usrp_source_impl::~usrp_source_impl()
+    {
+    }
+
+    ::uhd::dict<std::string, std::string>
+    usrp_source_impl::get_usrp_info(size_t chan)
+    {
+#ifdef UHD_USRP_MULTI_USRP_GET_USRP_INFO_API
+      return _dev->get_usrp_rx_info(chan);
+#else
+      throw std::runtime_error("not implemented in this version");
+#endif
+    }
+
+    void
+    usrp_source_impl::set_subdev_spec(const std::string &spec, size_t mboard)
+    {
+      return _dev->set_rx_subdev_spec(spec, mboard);
+    }
+
+    std::string
+    usrp_source_impl::get_subdev_spec(size_t mboard)
+    {
+      return _dev->get_rx_subdev_spec(mboard).to_string();
+    }
+
+    void
+    usrp_source_impl::set_samp_rate(double rate)
+    {
+      _dev->set_rx_rate(rate);
+      _samp_rate = this->get_samp_rate();
+      _tag_now = true;
+    }
+
+    double 
+    usrp_source_impl::get_samp_rate(void)
+    {
+      return _dev->get_rx_rate();
+    }
+
+    ::uhd::meta_range_t
+    usrp_source_impl::get_samp_rates(void)
+    {
+#ifdef UHD_USRP_MULTI_USRP_GET_RATES_API
+      return _dev->get_rx_rates();
+#else
+      throw std::runtime_error("not implemented in this version");
+#endif
+    }
+
+    ::uhd::tune_result_t
+    usrp_source_impl::set_center_freq(const ::uhd::tune_request_t tune_request,
+                                      size_t chan)
+    {
+      const ::uhd::tune_result_t res = _dev->set_rx_freq(tune_request, chan);
+      _center_freq = this->get_center_freq(chan);
+      _tag_now = true;
+      return res;
+    }
+
+    double
+    usrp_source_impl::get_center_freq(size_t chan)
+    {
+      return _dev->get_rx_freq(chan);
+    }
+
+    ::uhd::freq_range_t
+    usrp_source_impl::get_freq_range(size_t chan)
+    {
+      return _dev->get_rx_freq_range(chan);
+    }
+
+    void
+    usrp_source_impl::set_gain(double gain, size_t chan)
+    {
+      return _dev->set_rx_gain(gain, chan);
+    }
+
+    void
+    usrp_source_impl::set_gain(double gain, const std::string &name, size_t chan)
+    {
+      return _dev->set_rx_gain(gain, name, chan);
+    }
+
+    double
+    usrp_source_impl::get_gain(size_t chan)
+    {
+      return _dev->get_rx_gain(chan);
+    }
+
+    double
+    usrp_source_impl::get_gain(const std::string &name, size_t chan)
+    {
+      return _dev->get_rx_gain(name, chan);
+    }
+
+    std::vector<std::string>
+    usrp_source_impl::get_gain_names(size_t chan)
+    {
+      return _dev->get_rx_gain_names(chan);
+    }
+
+    ::uhd::gain_range_t
+    usrp_source_impl::get_gain_range(size_t chan)
+    {
+      return _dev->get_rx_gain_range(chan);
+    }
+
+    ::uhd::gain_range_t
+    usrp_source_impl::get_gain_range(const std::string &name, size_t chan)
+    {
+      return _dev->get_rx_gain_range(name, chan);
+    }
+
+    void
+    usrp_source_impl::set_antenna(const std::string &ant, size_t chan)
+    {
+      return _dev->set_rx_antenna(ant, chan);
+    }
+
+    std::string
+    usrp_source_impl::get_antenna(size_t chan)
+    {
+      return _dev->get_rx_antenna(chan);
+    }
+
+    std::vector<std::string>
+    usrp_source_impl::get_antennas(size_t chan)
+    {
+      return _dev->get_rx_antennas(chan);
+    }
+
+    void
+    usrp_source_impl::set_bandwidth(double bandwidth, size_t chan)
+    {
+      return _dev->set_rx_bandwidth(bandwidth, chan);
+    }
+
+    void
+    usrp_source_impl::set_auto_dc_offset(const bool enable, size_t chan)
+    {
+#ifdef UHD_USRP_MULTI_USRP_FRONTEND_CAL_API
+      return _dev->set_rx_dc_offset(enable, chan);
+#else
+      throw std::runtime_error("not implemented in this version");
+#endif
+    }
+
+    void
+    usrp_source_impl::set_dc_offset(const std::complex<double> &offset,
+                                    size_t chan)
+    {
+#ifdef UHD_USRP_MULTI_USRP_FRONTEND_CAL_API
+      return _dev->set_rx_dc_offset(offset, chan);
+#else
+      throw std::runtime_error("not implemented in this version");
+#endif
+    }
+
+    void
+    usrp_source_impl::set_iq_balance(const std::complex<double> &correction,
+                                     size_t chan)
+    {
+#ifdef UHD_USRP_MULTI_USRP_FRONTEND_CAL_API
+      return _dev->set_rx_iq_balance(correction, chan);
+#else
+      throw std::runtime_error("not implemented in this version");
+#endif
+    }
+
+    ::uhd::sensor_value_t
+    usrp_source_impl::get_sensor(const std::string &name, size_t chan)
+    {
+      return _dev->get_rx_sensor(name, chan);
+    }
+
+    std::vector<std::string>
+    usrp_source_impl::get_sensor_names(size_t chan)
+    {
+      return _dev->get_rx_sensor_names(chan);
+    }
+
+    ::uhd::sensor_value_t
+    usrp_source_impl::get_mboard_sensor(const std::string &name, size_t mboard)
+    {
+      return _dev->get_mboard_sensor(name, mboard);
+    }
+
+    std::vector<std::string>
+    usrp_source_impl::get_mboard_sensor_names(size_t mboard)
+    {
+      return _dev->get_mboard_sensor_names(mboard);
+    }
+
+    void
+    usrp_source_impl::set_clock_config(const ::uhd::clock_config_t &clock_config,
+                                       size_t mboard)
+    {
+      return _dev->set_clock_config(clock_config, mboard);
+    }
+
+    void
+    usrp_source_impl::set_time_source(const std::string &source,
+                                      const size_t mboard)
+    {
+#ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API
+      return _dev->set_time_source(source, mboard);
+#else
+      throw std::runtime_error("not implemented in this version");
+#endif
+    }
+
+    std::string
+    usrp_source_impl::get_time_source(const size_t mboard)
+    {
+#ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API
+      return _dev->get_time_source(mboard);
+#else
+      throw std::runtime_error("not implemented in this version");
+#endif
+    }
+
+    std::vector<std::string>
+    usrp_source_impl::get_time_sources(const size_t mboard)
+    {
+#ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API
+      return _dev->get_time_sources(mboard);
+#else
+      throw std::runtime_error("not implemented in this version");
+#endif
+    }
+
+    void
+    usrp_source_impl::set_clock_source(const std::string &source,
+                                       const size_t mboard)
+    {
+#ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API
+      return _dev->set_clock_source(source, mboard);
+#else
+      throw std::runtime_error("not implemented in this version");
+#endif
+    }
+
+    std::string
+    usrp_source_impl::get_clock_source(const size_t mboard)
+    {
+#ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API
+      return _dev->get_clock_source(mboard);
+#else
+      throw std::runtime_error("not implemented in this version");
+#endif
+    }
+
+    std::vector<std::string>
+    usrp_source_impl::get_clock_sources(const size_t mboard)
+    {
+#ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API
+      return _dev->get_clock_sources(mboard);
+#else
+      throw std::runtime_error("not implemented in this version");
+#endif
+    }
+
+    double
+    usrp_source_impl::get_clock_rate(size_t mboard)
+    {
+      return _dev->get_master_clock_rate(mboard);
+    }
+
+    void
+    usrp_source_impl::set_clock_rate(double rate, size_t mboard)
+    {
+      return _dev->set_master_clock_rate(rate, mboard);
+    }
+
+    ::uhd::time_spec_t
+    usrp_source_impl::get_time_now(size_t mboard)
+    {
+      return _dev->get_time_now(mboard);
+    }
+
+    ::uhd::time_spec_t
+    usrp_source_impl::get_time_last_pps(size_t mboard)
+    {
+      return _dev->get_time_last_pps(mboard);
+    }
+
+    void
+    usrp_source_impl::set_time_now(const ::uhd::time_spec_t &time_spec,
+                                   size_t mboard)
+    {
+      return _dev->set_time_now(time_spec, mboard);
+    }
+
+    void
+    usrp_source_impl::set_time_next_pps(const ::uhd::time_spec_t &time_spec)
+    {
+      return _dev->set_time_next_pps(time_spec);
+    }
+
+    void
+    usrp_source_impl::set_time_unknown_pps(const ::uhd::time_spec_t &time_spec)
+    {
+      return _dev->set_time_unknown_pps(time_spec);
+    }
+
+    void
+    usrp_source_impl::set_command_time(const ::uhd::time_spec_t &time_spec, size_t mboard)
+    {
+#ifdef UHD_USRP_MULTI_USRP_COMMAND_TIME_API
+      return _dev->set_command_time(time_spec, mboard);
+#else
+      throw std::runtime_error("not implemented in this version");
+#endif
+    }
+
+    void
+    usrp_source_impl::clear_command_time(size_t mboard)
+    {
+#ifdef UHD_USRP_MULTI_USRP_COMMAND_TIME_API
+      return _dev->clear_command_time(mboard);
+#else
+      throw std::runtime_error("not implemented in this version");
+#endif
+    }
+
+    ::uhd::usrp::dboard_iface::sptr
+    usrp_source_impl::get_dboard_iface(size_t chan)
+    {
+      return _dev->get_rx_dboard_iface(chan);
+    }
+
+    ::uhd::usrp::multi_usrp::sptr
+    usrp_source_impl::get_device(void)
+    {
+      return _dev;
+    }
+
+    void
+    usrp_source_impl::set_user_register(const uint8_t addr,
+                                        const uint32_t data,
+                                        size_t mboard)
+    {
+#ifdef UHD_USRP_MULTI_USRP_USER_REGS_API
+      _dev->set_user_register(addr, data, mboard);
+#else
+      throw std::runtime_error("not implemented in this version");
+#endif
+    }
+
+    void
+    usrp_source_impl::set_start_time(const ::uhd::time_spec_t &time)
+    {
+      _start_time = time;
+      _start_time_set = true;
+      _stream_now = false;
+    }
+
+    void
+    usrp_source_impl::issue_stream_cmd(const ::uhd::stream_cmd_t &cmd)
+    {
+      _dev->issue_stream_cmd(cmd);
+    }
+
+    bool
+    usrp_source_impl::start(void)
+    {
+#ifdef GR_UHD_USE_STREAM_API
+      _rx_stream = _dev->get_rx_stream(_stream_args);
+      _samps_per_packet = _rx_stream->get_max_num_samps();
+#endif
+      //setup a stream command that starts streaming slightly in the future
+      static const double reasonable_delay = 0.1; //order of magnitude over RTT
+      ::uhd::stream_cmd_t stream_cmd(::uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS);
+      stream_cmd.stream_now = _stream_now;
+      if(_start_time_set) {
+        _start_time_set = false; //cleared for next run
+        stream_cmd.time_spec = _start_time;
+      }
+      else {
+        stream_cmd.time_spec = get_time_now() + ::uhd::time_spec_t(reasonable_delay);
+      }
+      _dev->issue_stream_cmd(stream_cmd);
+      _tag_now = true;
+      return true;
+    }
+
+    void
+    usrp_source_impl::flush(void)
+    {
+      const size_t nbytes = 4096;
+      gr_vector_void_star outputs;
+      std::vector<std::vector<char> > buffs(_nchan, std::vector<char>(nbytes));
+      for(size_t i = 0; i < _nchan; i++) {
+        outputs.push_back(&buffs[i].front());
+      }
+      while(true) {
+#ifdef GR_UHD_USE_STREAM_API
+        const size_t bpi = ::uhd::convert::get_bytes_per_item(_stream_args.cpu_format);
+        _rx_stream->recv(outputs, nbytes/bpi, _metadata, 0.0);
+#else
+        _dev->get_device()->recv
+          (outputs, nbytes/_type->size, _metadata, *_type,
+           ::uhd::device::RECV_MODE_FULL_BUFF, 0.0);
+#endif
+        if(_metadata.error_code == ::uhd::rx_metadata_t::ERROR_CODE_TIMEOUT)
+          break;
+      }
+    }
+
+    bool
+    usrp_source_impl::stop(void)
+    {
+      _dev->issue_stream_cmd(::uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS);
+
+      this->flush();
+
+      return true;
+    }
+
+    std::vector<std::complex<float> >
+    usrp_source_impl::finite_acquisition(const size_t nsamps)
+    {
+      if(_nchan != 1)
+        throw std::runtime_error("finite_acquisition: usrp source has multiple channels, call finite_acquisition_v");
+      return finite_acquisition_v(nsamps).front();
+    }
+
+    std::vector<std::vector<std::complex<float> > >
+    usrp_source_impl::finite_acquisition_v(const size_t nsamps)
+    {
+#ifdef GR_UHD_USE_STREAM_API
+      //kludgy way to ensure rx streamer exsists
+      if(!_rx_stream) {
+        this->start();
+        this->stop();
+      }
+
+      //flush so there is no queued-up data
+      this->flush();
+
+      //create a multi-dimensional container to hold an array of sample buffers
+      std::vector<std::vector<std::complex<float> > >
+        samps(_nchan, std::vector<std::complex<float> >(nsamps));
+
+      //load the void* vector of buffer pointers
+      std::vector<void *> buffs(_nchan);
+      for(size_t i = 0; i < _nchan; i++) {
+        buffs[i] = &samps[i].front();
+      }
+
+      //tell the device to stream a finite amount
+      ::uhd::stream_cmd_t cmd(::uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE);
+      cmd.num_samps = nsamps;
+      cmd.stream_now = _stream_now;
+      static const double reasonable_delay = 0.1; //order of magnitude over RTT
+      cmd.time_spec = get_time_now() + ::uhd::time_spec_t(reasonable_delay);
+      _dev->issue_stream_cmd(cmd);
+
+      //receive samples until timeout
+      const size_t actual_num_samps = _rx_stream->recv
+        (buffs, nsamps, _metadata, 1.0);
+
+      //resize the resulting sample buffers
+      for(size_t i = 0; i < _nchan; i++) {
+        samps[i].resize(actual_num_samps);
+      }
+
+      return samps;
+#else
+      throw std::runtime_error("not implemented in this version");
+#endif
+    }
+
+    int
+    usrp_source_impl::work(int noutput_items,
+                           gr_vector_const_void_star &input_items,
+                           gr_vector_void_star &output_items)
+    {
+#ifdef GR_UHD_USE_STREAM_API
+      //In order to allow for low-latency:
+      //We receive all available packets without timeout.
+      //This call can timeout under regular operation...
+      size_t num_samps = _rx_stream->recv
+        (output_items, noutput_items, _metadata, 0.0);
+
+      //If receive resulted in a timeout condition:
+      //We now receive a single packet with a large timeout.
+      if(_metadata.error_code == ::uhd::rx_metadata_t::ERROR_CODE_TIMEOUT) {
+        num_samps = _rx_stream->recv
+          (output_items, noutput_items, _metadata, 0.1, true/*one pkt*/);
+      }
+#else
+      size_t num_samps = _dev->get_device()->recv
+        (output_items, noutput_items, _metadata,
+         *_type, ::uhd::device::RECV_MODE_FULL_BUFF, 0.0);
+
+      if(_metadata.error_code == ::uhd::rx_metadata_t::ERROR_CODE_TIMEOUT) {
+        num_samps = _dev->get_device()->recv
+          (output_items, noutput_items, _metadata, *_type,
+           ::uhd::device::RECV_MODE_ONE_PACKET, 1.0);
+      }
+#endif
+
+      //handle possible errors conditions
+      switch(_metadata.error_code) {
+      case ::uhd::rx_metadata_t::ERROR_CODE_NONE:
+        if(_tag_now) {
+          _tag_now = false;
+          //create a timestamp pmt for the first sample
+          const pmt::pmt_t val = pmt::make_tuple
+            (pmt::from_uint64(_metadata.time_spec.get_full_secs()),
+             pmt::from_double(_metadata.time_spec.get_frac_secs()));
+          //create a tag set for each channel
+          for(size_t i = 0; i < _nchan; i++) {
+            this->add_item_tag(i, nitems_written(0), TIME_KEY, val, _id);
+            this->add_item_tag(i, nitems_written(0), RATE_KEY,
+                               pmt::from_double(_samp_rate), _id);
+            this->add_item_tag(i, nitems_written(0), FREQ_KEY,
+                               pmt::from_double(_center_freq), _id);
+          }
+        }
+        break;
+
+      case ::uhd::rx_metadata_t::ERROR_CODE_TIMEOUT:
+        //its ok to timeout, perhaps the user is doing finite streaming
+        return 0;
+
+      case ::uhd::rx_metadata_t::ERROR_CODE_OVERFLOW:
+        _tag_now = true;
+        //ignore overflows and try work again
+        return work(noutput_items, input_items, output_items);
+
+      default:
+        std::cout << boost::format("UHD source block got error code 0x%x")
+          % _metadata.error_code << std::endl;
+        return num_samps;
+      }
+
+      return num_samps;
+    }
+
+  } /* namespace uhd */
+} /* namespace gr */
diff --git a/gr-uhd/lib/usrp_source_impl.h b/gr-uhd/lib/usrp_source_impl.h
new file mode 100644
index 0000000000..b0b04a795b
--- /dev/null
+++ b/gr-uhd/lib/usrp_source_impl.h
@@ -0,0 +1,144 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2010-2013 Free Software Foundation, Inc.
+ *
+ * This file is part of GNU Radio
+ *
+ * GNU Radio 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, or (at your option)
+ * any later version.
+ *
+ * GNU Radio 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 GNU Radio; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include <uhd/usrp_source.h>
+#include <uhd/convert.hpp>
+
+static const pmt::pmt_t TIME_KEY = pmt::string_to_symbol("rx_time");
+static const pmt::pmt_t RATE_KEY = pmt::string_to_symbol("rx_rate");
+static const pmt::pmt_t FREQ_KEY = pmt::string_to_symbol("rx_freq");
+
+namespace gr {
+  namespace uhd {
+
+    inline gr_io_signature_sptr
+    args_to_io_sig(const ::uhd::stream_args_t &args)
+    {
+      const size_t nchan = std::max<size_t>(args.channels.size(), 1);
+#ifdef GR_UHD_USE_STREAM_API
+      const size_t size = ::uhd::convert::get_bytes_per_item(args.cpu_format);
+#else
+      size_t size = 0;
+      if(args.cpu_format == "fc32")
+        size = 8;
+      if(args.cpu_format == "sc16")
+        size = 4;
+#endif
+      return gr_make_io_signature(nchan, nchan, size);
+    }
+
+    /***********************************************************************
+     * UHD Multi USRP Source Impl
+     **********************************************************************/
+    class usrp_source_impl : public usrp_source
+    {
+    public:
+      usrp_source_impl(const ::uhd::device_addr_t &device_addr,
+                       const ::uhd::stream_args_t &stream_args);
+      ~usrp_source_impl();
+
+      // Get Commands
+      ::uhd::dict<std::string, std::string> get_usrp_info(size_t chan);
+      std::string get_subdev_spec(size_t mboard);
+      double get_samp_rate(void);
+      ::uhd::meta_range_t get_samp_rates(void);
+      double get_center_freq(size_t chan);
+      ::uhd::freq_range_t get_freq_range(size_t chan);
+      double get_gain(size_t chan);
+      double get_gain(const std::string &name, size_t chan);
+      std::vector<std::string> get_gain_names(size_t chan);
+      ::uhd::gain_range_t get_gain_range(size_t chan);
+      ::uhd::gain_range_t get_gain_range(const std::string &name, size_t chan);
+      std::string get_antenna(size_t chan);
+      std::vector<std::string> get_antennas(size_t chan);
+      ::uhd::sensor_value_t get_sensor(const std::string &name, size_t chan);
+      std::vector<std::string> get_sensor_names(size_t chan);
+      ::uhd::sensor_value_t get_mboard_sensor(const std::string &name, size_t mboard);
+      std::vector<std::string> get_mboard_sensor_names(size_t mboard);
+      std::string get_time_source(const size_t mboard);
+      std::vector<std::string> get_time_sources(const size_t mboard);
+      std::string get_clock_source(const size_t mboard);
+      std::vector<std::string> get_clock_sources(const size_t mboard);
+      double get_clock_rate(size_t mboard);
+      ::uhd::time_spec_t get_time_now(size_t mboard = 0);
+      ::uhd::time_spec_t get_time_last_pps(size_t mboard);
+      ::uhd::usrp::dboard_iface::sptr get_dboard_iface(size_t chan);
+      ::uhd::usrp::multi_usrp::sptr get_device(void);
+
+      // Set Commands
+      void set_subdev_spec(const std::string &spec, size_t mboard);
+      void set_samp_rate(double rate);
+      ::uhd::tune_result_t set_center_freq(const ::uhd::tune_request_t tune_request,
+                                         size_t chan);
+      void set_gain(double gain, size_t chan);
+      void set_gain(double gain, const std::string &name, size_t chan);
+      void set_antenna(const std::string &ant, size_t chan);
+      void set_bandwidth(double bandwidth, size_t chan);
+      void set_auto_dc_offset(const bool enable, size_t chan);
+      void set_dc_offset(const std::complex<double> &offset, size_t chan);
+      void set_iq_balance(const std::complex<double> &correction, size_t chan);
+      void set_clock_config(const ::uhd::clock_config_t &clock_config, size_t mboard);
+      void set_time_source(const std::string &source, const size_t mboard);
+      void set_clock_source(const std::string &source, const size_t mboard);
+      void set_clock_rate(double rate, size_t mboard);
+      void set_time_now(const ::uhd::time_spec_t &time_spec, size_t mboard);
+      void set_time_next_pps(const ::uhd::time_spec_t &time_spec);
+      void set_time_unknown_pps(const ::uhd::time_spec_t &time_spec);
+      void set_command_time(const ::uhd::time_spec_t &time_spec, size_t mboard);
+      void set_user_register(const uint8_t addr, const uint32_t data, size_t mboard);
+      void set_start_time(const ::uhd::time_spec_t &time);
+
+      void issue_stream_cmd(const ::uhd::stream_cmd_t &cmd);
+      void clear_command_time(size_t mboard);
+      void flush(void);
+      bool start(void);
+      bool stop(void);
+      std::vector<std::complex<float> > finite_acquisition(const size_t nsamps);
+      std::vector<std::vector<std::complex<float> > > finite_acquisition_v(const size_t nsamps);
+      int work(int noutput_items,
+               gr_vector_const_void_star &input_items,
+               gr_vector_void_star &output_items);
+ 
+    private:
+      ::uhd::usrp::multi_usrp::sptr _dev;
+      const ::uhd::stream_args_t _stream_args;
+      boost::shared_ptr< ::uhd::io_type_t > _type;
+
+#ifdef GR_UHD_USE_STREAM_API
+      ::uhd::rx_streamer::sptr _rx_stream;
+      size_t _samps_per_packet;
+#endif
+      size_t _nchan;
+      bool _stream_now, _tag_now;
+      ::uhd::rx_metadata_t _metadata;
+      pmt::pmt_t _id;
+
+      ::uhd::time_spec_t _start_time;
+      bool _start_time_set;
+
+      //tag shadows
+      double _samp_rate;
+      double _center_freq;
+    };
+
+  } /* namespace uhd */
+} /* namespace gr */
author	Tom Rondeau <trondeau@vt.edu>	2013-02-19 14:50:50 -0500
committer	Tom Rondeau <trondeau@vt.edu>	2013-02-19 20:10:31 -0500
commit	a5bb5783fb20a4f136650c00d3fd94bb28add738 (patch)
tree	51ebcd9f90f0403cfe8b10e59bb87092cd620318 /gr-uhd/lib
parent	f4762c567bf5ec85b998935ee330d7c0e986dc57 (diff)