uhd: Apply clang-format against all .cpp and .hpp files in host/

Note: template_lvbitx.{cpp,hpp} need to be excluded from the list of
files that clang-format gets applied against.

12 files changed, 785 insertions, 663 deletions

diff --git a/host/lib/convert/convert_common.hpp b/host/lib/convert/convert_common.hpp
index 0de344b75..6ee9a651a 100644
--- a/host/lib/convert/convert_common.hpp
+++ b/host/lib/convert/convert_common.hpp
@@ -13,24 +13,31 @@
 #include <stdint.h>
 #include <complex>
 
-#define _DECLARE_CONVERTER(name, in_form, num_in, out_form, num_out, prio) \
-    struct name : public uhd::convert::converter{ \
-        static sptr make(void){return sptr(new name());} \
-        double scale_factor; \
-        void set_scalar(const double s){scale_factor = s;} \
+#define _DECLARE_CONVERTER(name, in_form, num_in, out_form, num_out, prio)    \
+    struct name : public uhd::convert::converter                              \
+    {                                                                         \
+        static sptr make(void)                                                \
+        {                                                                     \
+            return sptr(new name());                                          \
+        }                                                                     \
+        double scale_factor;                                                  \
+        void set_scalar(const double s)                                       \
+        {                                                                     \
+            scale_factor = s;                                                 \
+        }                                                                     \
         void operator()(const input_type&, const output_type&, const size_t); \
-    }; \
-    UHD_STATIC_BLOCK(__register_##name##_##prio){ \
-        uhd::convert::id_type id; \
-        id.input_format = #in_form; \
-        id.num_inputs = num_in; \
-        id.output_format = #out_form; \
-        id.num_outputs = num_out; \
-        uhd::convert::register_converter(id, &name::make, prio); \
-    } \
-    void name::operator()( \
-        const input_type &inputs, const output_type &outputs, const size_t nsamps \
-    )
+    };                                                                        \
+    UHD_STATIC_BLOCK(__register_##name##_##prio)                              \
+    {                                                                         \
+        uhd::convert::id_type id;                                             \
+        id.input_format  = #in_form;                                          \
+        id.num_inputs    = num_in;                                            \
+        id.output_format = #out_form;                                         \
+        id.num_outputs   = num_out;                                           \
+        uhd::convert::register_converter(id, &name::make, prio);              \
+    }                                                                         \
+    void name::operator()(                                                    \
+        const input_type& inputs, const output_type& outputs, const size_t nsamps)
 
 /*! Convenience macro to declare a single-function converter
  *
@@ -41,76 +48,83 @@
  * which runs the conversion. Available parameters in this function block
  * are:
  * - `inputs`: Vector of pointers to the input data. Size of the vector == `num_in`
- * - `outputs`: Vector of pointers to where the output data goes. Size of the vector == `num_out`
+ * - `outputs`: Vector of pointers to where the output data goes. Size of the vector ==
+ * `num_out`
  * - `nsamps`: Number of items per input buffer to convert
  * - `scale_factor`: Scaling factor for float conversions
  */
-#define DECLARE_CONVERTER(in_form, num_in, out_form, num_out, prio) \
-    _DECLARE_CONVERTER(__convert_##in_form##_##num_in##_##out_form##_##num_out##_##prio, in_form, num_in, out_form, num_out, prio)
+#define DECLARE_CONVERTER(in_form, num_in, out_form, num_out, prio)                      \
+    _DECLARE_CONVERTER(__convert_##in_form##_##num_in##_##out_form##_##num_out##_##prio, \
+        in_form,                                                                         \
+        num_in,                                                                          \
+        out_form,                                                                        \
+        num_out,                                                                         \
+        prio)
 
 /***********************************************************************
  * Setup priorities
  **********************************************************************/
 static const int PRIORITY_GENERAL = 0;
-static const int PRIORITY_EMPTY = -1;
+static const int PRIORITY_EMPTY   = -1;
 
 #ifdef __ARM_NEON__
 static const int PRIORITY_SIMD = 2;
-static const int PRIORITY_TABLE = 1; //tables require large cache, so they are slower on arm
+static const int PRIORITY_TABLE =
+    1; // tables require large cache, so they are slower on arm
 #else
 // We used to have ORC, too, so SIMD is 3
-static const int PRIORITY_SIMD = 3;
+static const int PRIORITY_SIMD  = 3;
 static const int PRIORITY_TABLE = 1;
 #endif
 
 /***********************************************************************
  * Typedefs
  **********************************************************************/
-typedef std::complex<double>         fc64_t;
-typedef std::complex<float>          fc32_t;
+typedef std::complex<double> fc64_t;
+typedef std::complex<float> fc32_t;
 typedef std::complex<int32_t> sc32_t;
 typedef std::complex<int16_t> sc16_t;
-typedef std::complex<int8_t>  sc8_t;
-typedef double                       f64_t;
-typedef float                        f32_t;
-typedef int32_t               s32_t;
-typedef int16_t               s16_t;
-typedef int8_t                s8_t;
-typedef uint8_t               u8_t;
+typedef std::complex<int8_t> sc8_t;
+typedef double f64_t;
+typedef float f32_t;
+typedef int32_t s32_t;
+typedef int16_t s16_t;
+typedef int8_t s8_t;
+typedef uint8_t u8_t;
 
-typedef uint32_t              item32_t;
+typedef uint32_t item32_t;
 
 typedef item32_t (*xtox_t)(item32_t);
 
 /***********************************************************************
  * Convert xx to items32 sc16 buffer
  **********************************************************************/
-template <typename T> UHD_INLINE item32_t xx_to_item32_sc16_x1(
-    const std::complex<T> &num, const double scale_factor
-){
-    uint16_t real = int16_t(num.real()*float(scale_factor));
-    uint16_t imag = int16_t(num.imag()*float(scale_factor));
+template <typename T>
+UHD_INLINE item32_t xx_to_item32_sc16_x1(
+    const std::complex<T>& num, const double scale_factor)
+{
+    uint16_t real = int16_t(num.real() * float(scale_factor));
+    uint16_t imag = int16_t(num.imag() * float(scale_factor));
     return (item32_t(real) << 16) | (item32_t(imag) << 0);
 }
 
-template <> UHD_INLINE item32_t xx_to_item32_sc16_x1(
-    const sc16_t &num, const double
-){
+template <>
+UHD_INLINE item32_t xx_to_item32_sc16_x1(const sc16_t& num, const double)
+{
     uint16_t real = int16_t(num.real());
     uint16_t imag = int16_t(num.imag());
     return (item32_t(real) << 16) | (item32_t(imag) << 0);
 }
 
 template <xtox_t to_wire, typename T>
-UHD_INLINE void xx_to_item32_sc16(
-    const std::complex<T> *input,
-    item32_t *output,
+UHD_INLINE void xx_to_item32_sc16(const std::complex<T>* input,
+    item32_t* output,
     const size_t nsamps,
-    const double scale_factor
-){
-    for (size_t i = 0; i < nsamps; i++){
+    const double scale_factor)
+{
+    for (size_t i = 0; i < nsamps; i++) {
         const item32_t item = xx_to_item32_sc16_x1(input[i], scale_factor);
-        output[i] = to_wire(item);
+        output[i]           = to_wire(item);
     }
 }
 
@@ -137,33 +151,29 @@ UHD_FORCE_INLINE void xx_to_chdr_sc16(const std::complex<T>* input,
 /***********************************************************************
  * Convert items32 sc16 buffer to xx
  **********************************************************************/
-template <typename T> UHD_INLINE std::complex<T> item32_sc16_x1_to_xx(
-    const item32_t item, const double scale_factor
-){
-    return std::complex<T>(
-        T(int16_t(item >> 16)*float(scale_factor)),
-        T(int16_t(item >> 0)*float(scale_factor))
-    );
+template <typename T>
+UHD_INLINE std::complex<T> item32_sc16_x1_to_xx(
+    const item32_t item, const double scale_factor)
+{
+    return std::complex<T>(T(int16_t(item >> 16) * float(scale_factor)),
+        T(int16_t(item >> 0) * float(scale_factor)));
 }
 
-template <> UHD_INLINE sc16_t item32_sc16_x1_to_xx(
-    const item32_t item, const double
-){
-    return sc16_t(
-        int16_t(item >> 16), int16_t(item >> 0)
-    );
+template <>
+UHD_INLINE sc16_t item32_sc16_x1_to_xx(const item32_t item, const double)
+{
+    return sc16_t(int16_t(item >> 16), int16_t(item >> 0));
 }
 
 template <xtox_t to_host, typename T>
-UHD_INLINE void item32_sc16_to_xx(
-    const item32_t *input,
-    std::complex<T> *output,
+UHD_INLINE void item32_sc16_to_xx(const item32_t* input,
+    std::complex<T>* output,
     const size_t nsamps,
-    const double scale_factor
-){
-    for (size_t i = 0; i < nsamps; i++){
+    const double scale_factor)
+{
+    for (size_t i = 0; i < nsamps; i++) {
         const item32_t item_i = to_host(input[i]);
-        output[i] = item32_sc16_x1_to_xx<T>(item_i, scale_factor);
+        output[i]             = item32_sc16_x1_to_xx<T>(item_i, scale_factor);
     }
 }
 
@@ -189,60 +199,56 @@ UHD_FORCE_INLINE void chdr_sc16_to_xx(const sc16_t* input,
 /***********************************************************************
  * Convert xx to items32 sc8 buffer
  **********************************************************************/
-template <typename T> UHD_INLINE item32_t xx_to_item32_sc8_x1(
-    const std::complex<T> &in0, const std::complex<T> &in1, const double scale_factor
-){
-    uint8_t real1 = int8_t(in0.real()*float(scale_factor));
-    uint8_t imag1 = int8_t(in0.imag()*float(scale_factor));
-    uint8_t real0 = int8_t(in1.real()*float(scale_factor));
-    uint8_t imag0 = int8_t(in1.imag()*float(scale_factor));
-    return
-        (item32_t(real0) << 8) | (item32_t(imag0) << 0) |
-        (item32_t(real1) << 24) | (item32_t(imag1) << 16)
-    ;
+template <typename T>
+UHD_INLINE item32_t xx_to_item32_sc8_x1(
+    const std::complex<T>& in0, const std::complex<T>& in1, const double scale_factor)
+{
+    uint8_t real1 = int8_t(in0.real() * float(scale_factor));
+    uint8_t imag1 = int8_t(in0.imag() * float(scale_factor));
+    uint8_t real0 = int8_t(in1.real() * float(scale_factor));
+    uint8_t imag0 = int8_t(in1.imag() * float(scale_factor));
+    return (item32_t(real0) << 8) | (item32_t(imag0) << 0) | (item32_t(real1) << 24)
+           | (item32_t(imag1) << 16);
 }
 
-template <> UHD_INLINE item32_t xx_to_item32_sc8_x1(
-    const sc16_t &in0, const sc16_t &in1, const double
-){
+template <>
+UHD_INLINE item32_t xx_to_item32_sc8_x1(
+    const sc16_t& in0, const sc16_t& in1, const double)
+{
     uint8_t real1 = int8_t(in0.real());
     uint8_t imag1 = int8_t(in0.imag());
     uint8_t real0 = int8_t(in1.real());
     uint8_t imag0 = int8_t(in1.imag());
-    return
-        (item32_t(real0) << 8) | (item32_t(imag0) << 0) |
-        (item32_t(real1) << 24) | (item32_t(imag1) << 16)
-    ;
+    return (item32_t(real0) << 8) | (item32_t(imag0) << 0) | (item32_t(real1) << 24)
+           | (item32_t(imag1) << 16);
 }
 
-template <> UHD_INLINE item32_t xx_to_item32_sc8_x1(
-    const sc8_t &in0, const sc8_t &in1, const double
-){
+template <>
+UHD_INLINE item32_t xx_to_item32_sc8_x1(const sc8_t& in0, const sc8_t& in1, const double)
+{
     uint8_t real1 = int8_t(in0.real());
     uint8_t imag1 = int8_t(in0.imag());
     uint8_t real0 = int8_t(in1.real());
     uint8_t imag0 = int8_t(in1.imag());
-    return
-        (item32_t(real0) << 8) | (item32_t(imag0) << 0) |
-        (item32_t(real1) << 24) | (item32_t(imag1) << 16)
-    ;
+    return (item32_t(real0) << 8) | (item32_t(imag0) << 0) | (item32_t(real1) << 24)
+           | (item32_t(imag1) << 16);
 }
 
 template <xtox_t to_wire, typename T>
-UHD_INLINE void xx_to_item32_sc8(
-    const std::complex<T> *input,
-    item32_t *output,
+UHD_INLINE void xx_to_item32_sc8(const std::complex<T>* input,
+    item32_t* output,
     const size_t nsamps,
-    const double scale_factor
-){
-    const size_t num_pairs = nsamps/2;
-    for (size_t i = 0, j = 0; i < num_pairs; i++, j+=2){
-        const item32_t item = xx_to_item32_sc8_x1(input[j], input[j+1], scale_factor);
-        output[i] = to_wire(item);
+    const double scale_factor)
+{
+    const size_t num_pairs = nsamps / 2;
+    for (size_t i = 0, j = 0; i < num_pairs; i++, j += 2) {
+        const item32_t item = xx_to_item32_sc8_x1(input[j], input[j + 1], scale_factor);
+        output[i]           = to_wire(item);
     }
 
-    if (nsamps != num_pairs*2){
-        const item32_t item = xx_to_item32_sc8_x1(input[nsamps-1], std::complex<T>(0), scale_factor);
+    if (nsamps != num_pairs * 2) {
+        const item32_t item =
+            xx_to_item32_sc8_x1(input[nsamps - 1], std::complex<T>(0), scale_factor);
         output[num_pairs] = to_wire(item);
     }
 }
@@ -250,71 +256,59 @@ UHD_INLINE void xx_to_item32_sc8(
 /***********************************************************************
  * Convert items32 sc8 buffer to xx
  **********************************************************************/
-template <typename T> UHD_INLINE void item32_sc8_x1_to_xx(
-    const item32_t item, std::complex<T> &out0, std::complex<T> &out1, const double scale_factor
-){
-    out1 = std::complex<T>(
-        T(int8_t(item >> 8)*float(scale_factor)),
-        T(int8_t(item >> 0)*float(scale_factor))
-    );
-    out0 = std::complex<T>(
-        T(int8_t(item >> 24)*float(scale_factor)),
-        T(int8_t(item >> 16)*float(scale_factor))
-    );
+template <typename T>
+UHD_INLINE void item32_sc8_x1_to_xx(const item32_t item,
+    std::complex<T>& out0,
+    std::complex<T>& out1,
+    const double scale_factor)
+{
+    out1 = std::complex<T>(T(int8_t(item >> 8) * float(scale_factor)),
+        T(int8_t(item >> 0) * float(scale_factor)));
+    out0 = std::complex<T>(T(int8_t(item >> 24) * float(scale_factor)),
+        T(int8_t(item >> 16) * float(scale_factor)));
 }
 
-template <> UHD_INLINE void item32_sc8_x1_to_xx(
-    const item32_t item, sc16_t &out0, sc16_t &out1, const double
-){
-    out1 = sc16_t(
-        int16_t(int8_t(item >> 8)),
-        int16_t(int8_t(item >> 0))
-    );
-    out0 = sc16_t(
-        int16_t(int8_t(item >> 24)),
-        int16_t(int8_t(item >> 16))
-    );
+template <>
+UHD_INLINE void item32_sc8_x1_to_xx(
+    const item32_t item, sc16_t& out0, sc16_t& out1, const double)
+{
+    out1 = sc16_t(int16_t(int8_t(item >> 8)), int16_t(int8_t(item >> 0)));
+    out0 = sc16_t(int16_t(int8_t(item >> 24)), int16_t(int8_t(item >> 16)));
 }
 
-template <> UHD_INLINE void item32_sc8_x1_to_xx(
-    const item32_t item, sc8_t &out0, sc8_t &out1, const double
-){
-    out1 = sc8_t(
-        int8_t(int8_t(item >> 8)),
-        int8_t(int8_t(item >> 0))
-    );
-    out0 = sc8_t(
-        int8_t(int8_t(item >> 24)),
-        int8_t(int8_t(item >> 16))
-    );
+template <>
+UHD_INLINE void item32_sc8_x1_to_xx(
+    const item32_t item, sc8_t& out0, sc8_t& out1, const double)
+{
+    out1 = sc8_t(int8_t(int8_t(item >> 8)), int8_t(int8_t(item >> 0)));
+    out0 = sc8_t(int8_t(int8_t(item >> 24)), int8_t(int8_t(item >> 16)));
 }
 
 template <xtox_t to_host, typename T>
-UHD_INLINE void item32_sc8_to_xx(
-    const item32_t *input,
-    std::complex<T> *output,
+UHD_INLINE void item32_sc8_to_xx(const item32_t* input,
+    std::complex<T>* output,
     const size_t nsamps,
-    const double scale_factor
-){
-    input = reinterpret_cast<const item32_t *>(size_t(input) & ~0x3);
+    const double scale_factor)
+{
+    input = reinterpret_cast<const item32_t*>(size_t(input) & ~0x3);
     std::complex<T> dummy;
     size_t num_samps = nsamps;
 
-    if ((size_t(input) & 0x3) != 0){
+    if ((size_t(input) & 0x3) != 0) {
         const item32_t item0 = to_host(*input++);
         item32_sc8_x1_to_xx(item0, dummy, *output++, scale_factor);
         num_samps--;
     }
 
-    const size_t num_pairs = num_samps/2;
-    for (size_t i = 0, j = 0; i < num_pairs; i++, j+=2){
+    const size_t num_pairs = num_samps / 2;
+    for (size_t i = 0, j = 0; i < num_pairs; i++, j += 2) {
         const item32_t item_i = to_host(input[i]);
-        item32_sc8_x1_to_xx(item_i, output[j], output[j+1], scale_factor);
+        item32_sc8_x1_to_xx(item_i, output[j], output[j + 1], scale_factor);
     }
 
-    if (num_samps != num_pairs*2){
+    if (num_samps != num_pairs * 2) {
         const item32_t item_n = to_host(input[num_pairs]);
-        item32_sc8_x1_to_xx(item_n, output[num_samps-1], dummy, scale_factor);
+        item32_sc8_x1_to_xx(item_n, output[num_samps - 1], dummy, scale_factor);
     }
 }
 
diff --git a/host/lib/convert/convert_fc32_item32.cpp b/host/lib/convert/convert_fc32_item32.cpp
index b119fd877..713f565f5 100644
--- a/host/lib/convert/convert_fc32_item32.cpp
+++ b/host/lib/convert/convert_fc32_item32.cpp
@@ -18,9 +18,9 @@ typedef uint32_t (*to32_type)(uint32_t);
 template <typename type, to32_type tohost>
 struct convert_fc32_item32_1_to_star_1 : public converter
 {
-    convert_fc32_item32_1_to_star_1(void):_scalar(0.0)
+    convert_fc32_item32_1_to_star_1(void) : _scalar(0.0)
     {
-        //NOP
+        // NOP
     }
 
     void set_scalar(const double scalar)
@@ -28,19 +28,20 @@ struct convert_fc32_item32_1_to_star_1 : public converter
         _scalar = scalar;
     }
 
-    void operator()(const input_type &inputs, const output_type &outputs, const size_t nsamps)
+    void operator()(
+        const input_type& inputs, const output_type& outputs, const size_t nsamps)
     {
-        const item32_t *input = reinterpret_cast<const item32_t *>(inputs[0]);
-        std::complex<type> *output = reinterpret_cast<std::complex<type> *>(outputs[0]);
+        const item32_t* input      = reinterpret_cast<const item32_t*>(inputs[0]);
+        std::complex<type>* output = reinterpret_cast<std::complex<type>*>(outputs[0]);
 
         size_t i = 0;
-        for (size_t o = 0; o < nsamps; o++)
-        {
-            const item32_t i32 = tohost(input[i++]);
-            const item32_t q32 = tohost(input[i++]);
-            const float *i_f32p = reinterpret_cast<const float *>(&i32);
-            const float *q_f32p = reinterpret_cast<const float *>(&q32);
-            output[o] = std::complex<type>(type((*i_f32p)*_scalar), type((*q_f32p)*_scalar));
+        for (size_t o = 0; o < nsamps; o++) {
+            const item32_t i32  = tohost(input[i++]);
+            const item32_t q32  = tohost(input[i++]);
+            const float* i_f32p = reinterpret_cast<const float*>(&i32);
+            const float* q_f32p = reinterpret_cast<const float*>(&q32);
+            output[o] =
+                std::complex<type>(type((*i_f32p) * _scalar), type((*q_f32p) * _scalar));
         }
     }
 
@@ -50,9 +51,9 @@ struct convert_fc32_item32_1_to_star_1 : public converter
 template <typename type, to32_type towire>
 struct convert_star_1_to_fc32_item32_1 : public converter
 {
-    convert_star_1_to_fc32_item32_1(void):_scalar(0.0)
+    convert_star_1_to_fc32_item32_1(void) : _scalar(0.0)
     {
-        //NOP
+        // NOP
     }
 
     void set_scalar(const double scalar)
@@ -60,45 +61,66 @@ struct convert_star_1_to_fc32_item32_1 : public converter
         _scalar = scalar;
     }
 
-    void operator()(const input_type &inputs, const output_type &outputs, const size_t nsamps)
+    void operator()(
+        const input_type& inputs, const output_type& outputs, const size_t nsamps)
     {
-        const std::complex<type> *input = reinterpret_cast<const std::complex<type> *>(inputs[0]);
-        item32_t *output = reinterpret_cast<item32_t *>(outputs[0]);
+        const std::complex<type>* input =
+            reinterpret_cast<const std::complex<type>*>(inputs[0]);
+        item32_t* output = reinterpret_cast<item32_t*>(outputs[0]);
 
         size_t o = 0;
-        for (size_t i = 0; i < nsamps; i++)
-        {
-            const float i_f32 = type(input[i].real()*_scalar);
-            const float q_f32 = type(input[i].imag()*_scalar);
-            const item32_t *i32p = reinterpret_cast<const item32_t *>(&i_f32);
-            const item32_t *q32p = reinterpret_cast<const item32_t *>(&q_f32);
-            output[o++] = towire(*i32p);
-            output[o++] = towire(*q32p);
+        for (size_t i = 0; i < nsamps; i++) {
+            const float i_f32    = type(input[i].real() * _scalar);
+            const float q_f32    = type(input[i].imag() * _scalar);
+            const item32_t* i32p = reinterpret_cast<const item32_t*>(&i_f32);
+            const item32_t* q32p = reinterpret_cast<const item32_t*>(&q_f32);
+            output[o++]          = towire(*i32p);
+            output[o++]          = towire(*q32p);
         }
     }
 
     double _scalar;
 };
 
-#define __make_registrations(itype, otype, fcn, type, conv) \
-static converter::sptr make_convert_ ## itype ## _1_ ## otype ## _1(void) \
-{ \
-    return converter::sptr(new fcn<type, conv>()); \
-} \
-UHD_STATIC_BLOCK(register_convert_ ## itype ## _1_ ## otype ## _1) \
-{ \
-    uhd::convert::id_type id; \
-    id.num_inputs = 1; id.num_outputs = 1;  \
-    id.input_format = #itype; id.output_format = #otype; \
-    uhd::convert::register_converter(id, &make_convert_ ## itype ## _1_ ## otype ## _1, PRIORITY_GENERAL); \
-}
-
-__make_registrations(fc32_item32_le, fc32, convert_fc32_item32_1_to_star_1, float, uhd::wtohx)
-__make_registrations(fc32_item32_be, fc32, convert_fc32_item32_1_to_star_1, float, uhd::ntohx)
-__make_registrations(fc32_item32_le, fc64, convert_fc32_item32_1_to_star_1, double, uhd::wtohx)
-__make_registrations(fc32_item32_be, fc64, convert_fc32_item32_1_to_star_1, double, uhd::ntohx)
-
-__make_registrations(fc32, fc32_item32_le, convert_star_1_to_fc32_item32_1, float, uhd::wtohx)
-__make_registrations(fc32, fc32_item32_be, convert_star_1_to_fc32_item32_1, float, uhd::ntohx)
-__make_registrations(fc64, fc32_item32_le, convert_star_1_to_fc32_item32_1, double, uhd::wtohx)
-__make_registrations(fc64, fc32_item32_be, convert_star_1_to_fc32_item32_1, double, uhd::ntohx)
+#define __make_registrations(itype, otype, fcn, type, conv)               \
+    static converter::sptr make_convert_##itype##_1_##otype##_1(void)     \
+    {                                                                     \
+        return converter::sptr(new fcn<type, conv>());                    \
+    }                                                                     \
+    UHD_STATIC_BLOCK(register_convert_##itype##_1_##otype##_1)            \
+    {                                                                     \
+        uhd::convert::id_type id;                                         \
+        id.num_inputs    = 1;                                             \
+        id.num_outputs   = 1;                                             \
+        id.input_format  = #itype;                                        \
+        id.output_format = #otype;                                        \
+        uhd::convert::register_converter(                                 \
+            id, &make_convert_##itype##_1_##otype##_1, PRIORITY_GENERAL); \
+    }
+
+__make_registrations(
+    fc32_item32_le, fc32, convert_fc32_item32_1_to_star_1, float, uhd::wtohx)
+    __make_registrations(
+        fc32_item32_be, fc32, convert_fc32_item32_1_to_star_1, float, uhd::ntohx)
+        __make_registrations(
+            fc32_item32_le, fc64, convert_fc32_item32_1_to_star_1, double, uhd::wtohx)
+            __make_registrations(
+                fc32_item32_be, fc64, convert_fc32_item32_1_to_star_1, double, uhd::ntohx)
+
+                __make_registrations(fc32,
+                    fc32_item32_le,
+                    convert_star_1_to_fc32_item32_1,
+                    float,
+                    uhd::wtohx) __make_registrations(fc32,
+                    fc32_item32_be,
+                    convert_star_1_to_fc32_item32_1,
+                    float,
+                    uhd::ntohx) __make_registrations(fc64,
+                    fc32_item32_le,
+                    convert_star_1_to_fc32_item32_1,
+                    double,
+                    uhd::wtohx) __make_registrations(fc64,
+                    fc32_item32_be,
+                    convert_star_1_to_fc32_item32_1,
+                    double,
+                    uhd::ntohx)
diff --git a/host/lib/convert/convert_impl.cpp b/host/lib/convert/convert_impl.cpp
index 6385965f0..228f15552 100644
--- a/host/lib/convert/convert_impl.cpp
+++ b/host/lib/convert/convert_impl.cpp
@@ -6,91 +6,84 @@
 //
 
 #include <uhd/convert.hpp>
+#include <uhd/exception.hpp>
+#include <uhd/types/dict.hpp>
 #include <uhd/utils/log.hpp>
 #include <uhd/utils/static.hpp>
-#include <uhd/types/dict.hpp>
-#include <uhd/exception.hpp>
 #include <stdint.h>
 #include <boost/format.hpp>
 #include <complex>
 
 using namespace uhd;
 
-convert::converter::~converter(void){
+convert::converter::~converter(void)
+{
     /* NOP */
 }
 
-bool convert::operator==(const convert::id_type &lhs, const convert::id_type &rhs){
-    return true
-        and (lhs.input_format  == rhs.input_format)
-        and (lhs.num_inputs    == rhs.num_inputs)
-        and (lhs.output_format == rhs.output_format)
-        and (lhs.num_outputs   == rhs.num_outputs)
-    ;
+bool convert::operator==(const convert::id_type& lhs, const convert::id_type& rhs)
+{
+    return true and (lhs.input_format == rhs.input_format)
+           and (lhs.num_inputs == rhs.num_inputs)
+           and (lhs.output_format == rhs.output_format)
+           and (lhs.num_outputs == rhs.num_outputs);
 }
 
-std::string convert::id_type::to_pp_string(void) const{
-    return str(boost::format(
-        "conversion ID\n"
-        "  Input format:  %s\n"
-        "  Num inputs:    %d\n"
-        "  Output format: %s\n"
-        "  Num outputs:   %d\n"
-    )
-        % this->input_format
-        % this->num_inputs
-        % this->output_format
-        % this->num_outputs
-    );
+std::string convert::id_type::to_pp_string(void) const
+{
+    return str(boost::format("conversion ID\n"
+                             "  Input format:  %s\n"
+                             "  Num inputs:    %d\n"
+                             "  Output format: %s\n"
+                             "  Num outputs:   %d\n")
+               % this->input_format % this->num_inputs % this->output_format
+               % this->num_outputs);
 }
 
-std::string convert::id_type::to_string(void) const{
-    return str(boost::format("%s (%d) -> %s (%d)")
-        % this->input_format
-        % this->num_inputs
-        % this->output_format
-        % this->num_outputs
-    );
+std::string convert::id_type::to_string(void) const
+{
+    return str(boost::format("%s (%d) -> %s (%d)") % this->input_format % this->num_inputs
+               % this->output_format % this->num_outputs);
 }
 
 /***********************************************************************
  * Setup the table registry
  **********************************************************************/
-typedef uhd::dict<convert::id_type, uhd::dict<convert::priority_type, convert::function_type> > fcn_table_type;
+typedef uhd::dict<convert::id_type,
+    uhd::dict<convert::priority_type, convert::function_type>>
+    fcn_table_type;
 UHD_SINGLETON_FCN(fcn_table_type, get_table);
 
 /***********************************************************************
  * The registry functions
  **********************************************************************/
 void uhd::convert::register_converter(
-    const id_type &id,
-    const function_type &fcn,
-    const priority_type prio
-){
+    const id_type& id, const function_type& fcn, const priority_type prio)
+{
     get_table()[id][prio] = fcn;
 
     //----------------------------------------------------------------//
-    //UHD_LOG_TRACE("CONVERT", boost::format("register_converter: %s prio: %s") % id.to_string() % prio)
+    // UHD_LOG_TRACE("CONVERT", boost::format("register_converter: %s prio: %s") %
+    // id.to_string() % prio)
     //----------------------------------------------------------------//
 }
 
 /***********************************************************************
  * The converter functions
  **********************************************************************/
-convert::function_type convert::get_converter(
-    const id_type &id,
-    const priority_type prio
-){
-    if (not get_table().has_key(id)) throw uhd::key_error(
-        "Cannot find a conversion routine for " + id.to_pp_string());
-
-    //find a matching priority
+convert::function_type convert::get_converter(const id_type& id, const priority_type prio)
+{
+    if (not get_table().has_key(id))
+        throw uhd::key_error("Cannot find a conversion routine for " + id.to_pp_string());
+
+    // find a matching priority
     priority_type best_prio = -1;
-    for(priority_type prio_i:  get_table()[id].keys()){
+    for (priority_type prio_i : get_table()[id].keys()) {
         if (prio_i == prio) {
             //----------------------------------------------------------------//
-            UHD_LOGGER_DEBUG("CONVERT") << "get_converter: For converter ID: " << id.to_pp_string()
-                                        << " Using prio: " << prio;
+            UHD_LOGGER_DEBUG("CONVERT")
+                << "get_converter: For converter ID: " << id.to_pp_string()
+                << " Using prio: " << prio;
             ;
             //----------------------------------------------------------------//
             return get_table()[id][prio];
@@ -98,16 +91,18 @@ convert::function_type convert::get_converter(
         best_prio = std::max(best_prio, prio_i);
     }
 
-    //wanted a specific prio, didnt find
-    if (prio != -1) throw uhd::key_error(
-        "Cannot find a conversion routine [with prio] for " + id.to_pp_string());
+    // wanted a specific prio, didnt find
+    if (prio != -1)
+        throw uhd::key_error(
+            "Cannot find a conversion routine [with prio] for " + id.to_pp_string());
 
     //----------------------------------------------------------------//
-    UHD_LOGGER_DEBUG("CONVERT") << "get_converter: For converter ID: " << id.to_pp_string()
-                                << " Using prio: " << best_prio;
+    UHD_LOGGER_DEBUG("CONVERT")
+        << "get_converter: For converter ID: " << id.to_pp_string()
+        << " Using prio: " << best_prio;
     //----------------------------------------------------------------//
 
-    //otherwise, return best prio
+    // otherwise, return best prio
     return get_table()[id][best_prio];
 }
 
@@ -117,29 +112,31 @@ convert::function_type convert::get_converter(
 typedef uhd::dict<std::string, size_t> item_size_type;
 UHD_SINGLETON_FCN(item_size_type, get_item_size_table);
 
-void convert::register_bytes_per_item(
-    const std::string &format, const size_t size
-){
+void convert::register_bytes_per_item(const std::string& format, const size_t size)
+{
     get_item_size_table()[format] = size;
 }
 
-size_t convert::get_bytes_per_item(const std::string &format){
-    if (get_item_size_table().has_key(format)) return get_item_size_table()[format];
+size_t convert::get_bytes_per_item(const std::string& format)
+{
+    if (get_item_size_table().has_key(format))
+        return get_item_size_table()[format];
 
-    //OK. I am sorry about this.
-    //We didnt find a match, so lets find a match for the first term.
-    //This is partially a hack because of the way I append strings.
-    //But as long as life is kind, we can keep this.
+    // OK. I am sorry about this.
+    // We didnt find a match, so lets find a match for the first term.
+    // This is partially a hack because of the way I append strings.
+    // But as long as life is kind, we can keep this.
     const size_t pos = format.find("_");
-    if (pos != std::string::npos){
+    if (pos != std::string::npos) {
         return get_bytes_per_item(format.substr(0, pos));
     }
 
     throw uhd::key_error("[convert] Cannot find an item size for: `" + format + "'");
 }
 
-UHD_STATIC_BLOCK(convert_register_item_sizes){
-    //register standard complex types
+UHD_STATIC_BLOCK(convert_register_item_sizes)
+{
+    // register standard complex types
     convert::register_bytes_per_item("fc64", sizeof(std::complex<double>));
     convert::register_bytes_per_item("fc32", sizeof(std::complex<float>));
     convert::register_bytes_per_item("sc64", sizeof(std::complex<int64_t>));
@@ -147,7 +144,7 @@ UHD_STATIC_BLOCK(convert_register_item_sizes){
     convert::register_bytes_per_item("sc16", sizeof(std::complex<int16_t>));
     convert::register_bytes_per_item("sc8", sizeof(std::complex<int8_t>));
 
-    //register standard real types
+    // register standard real types
     convert::register_bytes_per_item("f64", sizeof(double));
     convert::register_bytes_per_item("f32", sizeof(float));
     convert::register_bytes_per_item("s64", sizeof(int64_t));
@@ -156,6 +153,6 @@ UHD_STATIC_BLOCK(convert_register_item_sizes){
     convert::register_bytes_per_item("s8", sizeof(int8_t));
     convert::register_bytes_per_item("u8", sizeof(uint8_t));
 
-    //register VITA types
+    // register VITA types
     convert::register_bytes_per_item("item32", sizeof(int32_t));
 }
diff --git a/host/lib/convert/convert_item32.cpp b/host/lib/convert/convert_item32.cpp
index 142a842bb..5d8361079 100644
--- a/host/lib/convert/convert_item32.cpp
+++ b/host/lib/convert/convert_item32.cpp
@@ -8,23 +8,25 @@
 #include "convert_common.hpp"
 #include <uhd/utils/byteswap.hpp>
 
-#define __DECLARE_ITEM32_CONVERTER(cpu_type, wire_type, xe, htoxx, xxtoh) \
-    DECLARE_CONVERTER(cpu_type, 1, wire_type ## _item32_ ## xe, 1, PRIORITY_GENERAL){ \
-        const cpu_type ## _t *input = reinterpret_cast<const cpu_type ## _t *>(inputs[0]); \
-        item32_t *output = reinterpret_cast<item32_t *>(outputs[0]); \
-        xx_to_item32_ ## wire_type<htoxx>(input, output, nsamps, scale_factor); \
-    } \
-    DECLARE_CONVERTER(wire_type ## _item32_ ## xe, 1, cpu_type, 1, PRIORITY_GENERAL){ \
-        const item32_t *input = reinterpret_cast<const item32_t *>(inputs[0]); \
-        cpu_type ## _t *output = reinterpret_cast<cpu_type ## _t *>(outputs[0]); \
-        item32_ ## wire_type ## _to_xx<xxtoh>(input, output, nsamps, scale_factor); \
+#define __DECLARE_ITEM32_CONVERTER(cpu_type, wire_type, xe, htoxx, xxtoh)             \
+    DECLARE_CONVERTER(cpu_type, 1, wire_type##_item32_##xe, 1, PRIORITY_GENERAL)      \
+    {                                                                                 \
+        const cpu_type##_t* input = reinterpret_cast<const cpu_type##_t*>(inputs[0]); \
+        item32_t* output          = reinterpret_cast<item32_t*>(outputs[0]);          \
+        xx_to_item32_##wire_type<htoxx>(input, output, nsamps, scale_factor);         \
+    }                                                                                 \
+    DECLARE_CONVERTER(wire_type##_item32_##xe, 1, cpu_type, 1, PRIORITY_GENERAL)      \
+    {                                                                                 \
+        const item32_t* input = reinterpret_cast<const item32_t*>(inputs[0]);         \
+        cpu_type##_t* output  = reinterpret_cast<cpu_type##_t*>(outputs[0]);          \
+        item32_##wire_type##_to_xx<xxtoh>(input, output, nsamps, scale_factor);       \
     }
 
-#define _DECLARE_ITEM32_CONVERTER(cpu_type, wire_type) \
+#define _DECLARE_ITEM32_CONVERTER(cpu_type, wire_type)                          \
     __DECLARE_ITEM32_CONVERTER(cpu_type, wire_type, be, uhd::htonx, uhd::ntohx) \
     __DECLARE_ITEM32_CONVERTER(cpu_type, wire_type, le, uhd::htowx, uhd::wtohx)
 
-#define DECLARE_ITEM32_CONVERTER(cpu_type) \
+#define DECLARE_ITEM32_CONVERTER(cpu_type)   \
     _DECLARE_ITEM32_CONVERTER(cpu_type, sc8) \
     _DECLARE_ITEM32_CONVERTER(cpu_type, sc16)
 
diff --git a/host/lib/convert/convert_pack_sc12.cpp b/host/lib/convert/convert_pack_sc12.cpp
index 97a4af206..ee28e00cd 100644
--- a/host/lib/convert/convert_pack_sc12.cpp
+++ b/host/lib/convert/convert_pack_sc12.cpp
@@ -12,9 +12,9 @@ using namespace uhd::convert;
 template <typename type, towire32_type towire>
 struct convert_star_1_to_sc12_item32_1 : public converter
 {
-    convert_star_1_to_sc12_item32_1(void):_scalar(0.0)
+    convert_star_1_to_sc12_item32_1(void) : _scalar(0.0)
     {
-        //NOP
+        // NOP
     }
 
     void set_scalar(const double scalar)
@@ -22,74 +22,99 @@ struct convert_star_1_to_sc12_item32_1 : public converter
         _scalar = scalar;
     }
 
-    void operator()(const input_type &inputs, const output_type &outputs, const size_t nsamps)
+    void operator()(
+        const input_type& inputs, const output_type& outputs, const size_t nsamps)
     {
-        const std::complex<type> *input = reinterpret_cast<const std::complex<type> *>(inputs[0]);
+        const std::complex<type>* input =
+            reinterpret_cast<const std::complex<type>*>(inputs[0]);
 
         /*
-         * Effectively outputs will point to a managed_buffer instance. These buffers are 32 bit aligned.
-         * For a detailed description see comments in 'convert_unpack_sc12.cpp'.
+         * Effectively outputs will point to a managed_buffer instance. These buffers are
+         * 32 bit aligned. For a detailed description see comments in
+         * 'convert_unpack_sc12.cpp'.
          */
         const size_t head_samps = size_t(outputs[0]) & 0x3;
         int enable;
         size_t rewind = 0;
-        switch(head_samps)
-        {
-            case 0: break;
-            case 1: rewind = 9; break;
-            case 2: rewind = 6; break;
-            case 3: rewind = 3; break;
+        switch (head_samps) {
+            case 0:
+                break;
+            case 1:
+                rewind = 9;
+                break;
+            case 2:
+                rewind = 6;
+                break;
+            case 3:
+                rewind = 3;
+                break;
         }
-        item32_sc12_3x *output = reinterpret_cast<item32_sc12_3x *>(size_t(outputs[0]) - rewind);
+        item32_sc12_3x* output =
+            reinterpret_cast<item32_sc12_3x*>(size_t(outputs[0]) - rewind);
 
-        //helper variables
+        // helper variables
         size_t i = 0, o = 0;
 
-        //handle the head case
-        switch (head_samps)
-        {
-        case 0:
-            break; //no head
-        case 1:
-            enable = CONVERT12_LINE2;
-            convert_star_4_to_sc12_item32_3<type, towire>(0, 0, 0, input[0], enable, output[o++], _scalar);
-            break;
-        case 2:
-            enable = CONVERT12_LINE2 | CONVERT12_LINE1;
-            convert_star_4_to_sc12_item32_3<type, towire>(0, 0, input[0], input[1], enable, output[o++], _scalar);
-            break;
-        case 3:
-            enable = CONVERT12_LINE2 | CONVERT12_LINE1 | CONVERT12_LINE0;
-            convert_star_4_to_sc12_item32_3<type, towire>(0, input[0], input[1], input[2], enable, output[o++], _scalar);
-            break;
+        // handle the head case
+        switch (head_samps) {
+            case 0:
+                break; // no head
+            case 1:
+                enable = CONVERT12_LINE2;
+                convert_star_4_to_sc12_item32_3<type, towire>(
+                    0, 0, 0, input[0], enable, output[o++], _scalar);
+                break;
+            case 2:
+                enable = CONVERT12_LINE2 | CONVERT12_LINE1;
+                convert_star_4_to_sc12_item32_3<type, towire>(
+                    0, 0, input[0], input[1], enable, output[o++], _scalar);
+                break;
+            case 3:
+                enable = CONVERT12_LINE2 | CONVERT12_LINE1 | CONVERT12_LINE0;
+                convert_star_4_to_sc12_item32_3<type, towire>(
+                    0, input[0], input[1], input[2], enable, output[o++], _scalar);
+                break;
         }
         i += head_samps;
 
-        //convert the body
-        while (i+3 < nsamps)
-        {
-            convert_star_4_to_sc12_item32_3<type, towire>(input[i+0], input[i+1], input[i+2], input[i+3], CONVERT12_LINE_ALL, output[o], _scalar);
-            o++; i += 4;
+        // convert the body
+        while (i + 3 < nsamps) {
+            convert_star_4_to_sc12_item32_3<type, towire>(input[i + 0],
+                input[i + 1],
+                input[i + 2],
+                input[i + 3],
+                CONVERT12_LINE_ALL,
+                output[o],
+                _scalar);
+            o++;
+            i += 4;
         }
 
-        //handle the tail case
+        // handle the tail case
         const size_t tail_samps = nsamps - i;
-        switch (tail_samps)
-        {
-        case 0:
-            break; //no tail
-        case 1:
-            enable = CONVERT12_LINE0;
-            convert_star_4_to_sc12_item32_3<type, towire>(input[i+0], 0, 0, 0, enable, output[o], _scalar);
-            break;
-        case 2:
-            enable = CONVERT12_LINE0 | CONVERT12_LINE1;
-            convert_star_4_to_sc12_item32_3<type, towire>(input[i+0], input[i+1], 0, 0, enable, output[o], _scalar);
-            break;
-        case 3:
-            enable = CONVERT12_LINE0 | CONVERT12_LINE1 | CONVERT12_LINE2;
-            convert_star_4_to_sc12_item32_3<type, towire>(input[i+0], input[i+1], input[i+2], 0, enable, output[o], _scalar);
-            break;
+        switch (tail_samps) {
+            case 0:
+                break; // no tail
+            case 1:
+                enable = CONVERT12_LINE0;
+                convert_star_4_to_sc12_item32_3<type, towire>(
+                    input[i + 0], 0, 0, 0, enable, output[o], _scalar);
+                break;
+            case 2:
+                enable = CONVERT12_LINE0 | CONVERT12_LINE1;
+                convert_star_4_to_sc12_item32_3<type, towire>(
+                    input[i + 0], input[i + 1], 0, 0, enable, output[o], _scalar);
+                break;
+            case 3:
+                enable = CONVERT12_LINE0 | CONVERT12_LINE1 | CONVERT12_LINE2;
+                convert_star_4_to_sc12_item32_3<type, towire>(input[i + 0],
+                    input[i + 1],
+                    input[i + 2],
+                    0,
+                    enable,
+                    output[o],
+                    _scalar);
+                break;
         }
     }
 
@@ -118,21 +143,25 @@ static converter::sptr make_convert_sc16_1_to_sc12_item32_be_1(void)
 
 UHD_STATIC_BLOCK(register_convert_pack_sc12)
 {
-    //uhd::convert::register_bytes_per_item("sc12", 3/*bytes*/); //registered in unpack
+    // uhd::convert::register_bytes_per_item("sc12", 3/*bytes*/); //registered in unpack
 
     uhd::convert::id_type id;
-    id.num_inputs = 1;
+    id.num_inputs  = 1;
     id.num_outputs = 1;
 
-    id.input_format = "fc32";
+    id.input_format  = "fc32";
     id.output_format = "sc12_item32_le";
-    uhd::convert::register_converter(id, &make_convert_fc32_1_to_sc12_item32_le_1, PRIORITY_GENERAL);
+    uhd::convert::register_converter(
+        id, &make_convert_fc32_1_to_sc12_item32_le_1, PRIORITY_GENERAL);
     id.output_format = "sc12_item32_be";
-    uhd::convert::register_converter(id, &make_convert_fc32_1_to_sc12_item32_be_1, PRIORITY_GENERAL);
+    uhd::convert::register_converter(
+        id, &make_convert_fc32_1_to_sc12_item32_be_1, PRIORITY_GENERAL);
 
-    id.input_format = "sc16";
+    id.input_format  = "sc16";
     id.output_format = "sc12_item32_le";
-    uhd::convert::register_converter(id, &make_convert_sc16_1_to_sc12_item32_le_1, PRIORITY_GENERAL);
+    uhd::convert::register_converter(
+        id, &make_convert_sc16_1_to_sc12_item32_le_1, PRIORITY_GENERAL);
     id.output_format = "sc12_item32_be";
-    uhd::convert::register_converter(id, &make_convert_sc16_1_to_sc12_item32_be_1, PRIORITY_GENERAL);
+    uhd::convert::register_converter(
+        id, &make_convert_sc16_1_to_sc12_item32_be_1, PRIORITY_GENERAL);
 }
diff --git a/host/lib/convert/convert_pack_sc12.hpp b/host/lib/convert/convert_pack_sc12.hpp
index 053236e6f..08ec98b10 100644
--- a/host/lib/convert/convert_pack_sc12.hpp
+++ b/host/lib/convert/convert_pack_sc12.hpp
@@ -5,9 +5,9 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 //
 
-#include <type_traits>
-#include <uhd/utils/byteswap.hpp>
 #include "convert_common.hpp"
+#include <uhd/utils/byteswap.hpp>
+#include <type_traits>
 
 using namespace uhd::convert;
 
@@ -26,9 +26,9 @@ struct item32_sc12_3x
 };
 
 enum item32_sc12_3x_enable {
-    CONVERT12_LINE0 = 0x01,
-    CONVERT12_LINE1 = 0x02,
-    CONVERT12_LINE2 = 0x04,
+    CONVERT12_LINE0    = 0x01,
+    CONVERT12_LINE1    = 0x02,
+    CONVERT12_LINE2    = 0x04,
     CONVERT12_LINE_ALL = 0x07,
 };
 
@@ -48,10 +48,10 @@ enum item32_sc12_3x_enable {
  * 31              0
  */
 template <towire32_type towire>
-void pack(item32_sc12_3x &output, int enable, const int32_t iq[8])
+void pack(item32_sc12_3x& output, int enable, const int32_t iq[8])
 {
     if (enable & CONVERT12_LINE0)
-        output.line0 = towire(iq[0] << 20 | iq[1] <<  8 | iq[2] >> 4);
+        output.line0 = towire(iq[0] << 20 | iq[1] << 8 | iq[2] >> 4);
     if (enable & CONVERT12_LINE1)
         output.line1 = towire(iq[2] << 28 | iq[3] << 16 | iq[4] << 4 | iq[5] >> 8);
     if (enable & CONVERT12_LINE2)
@@ -59,46 +59,40 @@ void pack(item32_sc12_3x &output, int enable, const int32_t iq[8])
 }
 
 template <typename type, towire32_type towire>
-void convert_star_4_to_sc12_item32_3
-(
-    const std::complex<type> &in0,
-    const std::complex<type> &in1,
-    const std::complex<type> &in2,
-    const std::complex<type> &in3,
+void convert_star_4_to_sc12_item32_3(const std::complex<type>& in0,
+    const std::complex<type>& in1,
+    const std::complex<type>& in2,
+    const std::complex<type>& in3,
     const int enable,
-    item32_sc12_3x &output,
+    item32_sc12_3x& output,
     const double scalar,
-    typename std::enable_if<std::is_floating_point<type>::value>::type* = NULL
-)
+    typename std::enable_if<std::is_floating_point<type>::value>::type* = NULL)
 {
-    int32_t iq[8] {
-        int32_t(in0.real()*scalar) & 0xfff,
-        int32_t(in0.imag()*scalar) & 0xfff,
-        int32_t(in1.real()*scalar) & 0xfff,
-        int32_t(in1.imag()*scalar) & 0xfff,
+    int32_t iq[8]{
+        int32_t(in0.real() * scalar) & 0xfff,
+        int32_t(in0.imag() * scalar) & 0xfff,
+        int32_t(in1.real() * scalar) & 0xfff,
+        int32_t(in1.imag() * scalar) & 0xfff,
 
-        int32_t(in2.real()*scalar) & 0xfff,
-        int32_t(in2.imag()*scalar) & 0xfff,
-        int32_t(in3.real()*scalar) & 0xfff,
-        int32_t(in3.imag()*scalar) & 0xfff,
+        int32_t(in2.real() * scalar) & 0xfff,
+        int32_t(in2.imag() * scalar) & 0xfff,
+        int32_t(in3.real() * scalar) & 0xfff,
+        int32_t(in3.imag() * scalar) & 0xfff,
     };
     pack<towire>(output, enable, iq);
 }
 
 template <typename type, towire32_type towire>
-void convert_star_4_to_sc12_item32_3
-(
-    const std::complex<type> &in0,
-    const std::complex<type> &in1,
-    const std::complex<type> &in2,
-    const std::complex<type> &in3,
+void convert_star_4_to_sc12_item32_3(const std::complex<type>& in0,
+    const std::complex<type>& in1,
+    const std::complex<type>& in2,
+    const std::complex<type>& in3,
     const int enable,
-    item32_sc12_3x &output,
+    item32_sc12_3x& output,
     const double,
-    typename std::enable_if<std::is_same<type, short>::value>::type* = NULL
-)
+    typename std::enable_if<std::is_same<type, short>::value>::type* = NULL)
 {
-    int32_t iq[8] {
+    int32_t iq[8]{
         int32_t(in0.real() >> 4) & 0xfff,
         int32_t(in0.imag() >> 4) & 0xfff,
         int32_t(in1.real() >> 4) & 0xfff,
diff --git a/host/lib/convert/convert_unpack_sc12.cpp b/host/lib/convert/convert_unpack_sc12.cpp
index 9f0a14a77..9ec43a5c3 100644
--- a/host/lib/convert/convert_unpack_sc12.cpp
+++ b/host/lib/convert/convert_unpack_sc12.cpp
@@ -12,25 +12,27 @@ using namespace uhd::convert;
 template <typename type, tohost32_type tohost>
 struct convert_sc12_item32_1_to_star_1 : public converter
 {
-    convert_sc12_item32_1_to_star_1(void):_scalar(0.0)
+    convert_sc12_item32_1_to_star_1(void) : _scalar(0.0)
     {
-        //NOP
+        // NOP
     }
 
     void set_scalar(const double scalar)
     {
         const int unpack_growth = 16;
-        _scalar = scalar/unpack_growth;
+        _scalar                 = scalar / unpack_growth;
     }
 
     /*
-     * This converter takes in 24 bits complex samples, 12 bits I and 12 bits Q, and converts them to type 'std::complex<type>'.
-     * 'type' is usually 'float'.
-     * For the converter to work correctly the used managed_buffer which holds all samples of one packet has to be 32 bits aligned.
-     * We assume 32 bits to be one line. This said the converter must be aware where it is supposed to start within 3 lines.
+     * This converter takes in 24 bits complex samples, 12 bits I and 12 bits Q, and
+     * converts them to type 'std::complex<type>'. 'type' is usually 'float'. For the
+     * converter to work correctly the used managed_buffer which holds all samples of one
+     * packet has to be 32 bits aligned. We assume 32 bits to be one line. This said the
+     * converter must be aware where it is supposed to start within 3 lines.
      *
      */
-    void operator()(const input_type &inputs, const output_type &outputs, const size_t nsamps)
+    void operator()(
+        const input_type& inputs, const output_type& outputs, const size_t nsamps)
     {
         /*
          * Looking at the line structure above we can identify 4 cases.
@@ -39,67 +41,102 @@ struct convert_sc12_item32_1_to_star_1 : public converter
          * Then the number of bytes the converter has to rewind are calculated.
          */
         const size_t head_samps = size_t(inputs[0]) & 0x3;
-        size_t rewind = 0;
-        switch(head_samps)
-        {
-            case 0: break;
-            case 1: rewind = 9; break;
-            case 2: rewind = 6; break;
-            case 3: rewind = 3; break;
+        size_t rewind           = 0;
+        switch (head_samps) {
+            case 0:
+                break;
+            case 1:
+                rewind = 9;
+                break;
+            case 2:
+                rewind = 6;
+                break;
+            case 3:
+                rewind = 3;
+                break;
         }
 
         /*
          * The pointer *input now points to the head of a 3 line block.
          */
-        const item32_sc12_3x *input = reinterpret_cast<const item32_sc12_3x *>(size_t(inputs[0]) - rewind);
-        std::complex<type> *output = reinterpret_cast<std::complex<type> *>(outputs[0]);
+        const item32_sc12_3x* input =
+            reinterpret_cast<const item32_sc12_3x*>(size_t(inputs[0]) - rewind);
+        std::complex<type>* output = reinterpret_cast<std::complex<type>*>(outputs[0]);
 
-        //helper variables
+        // helper variables
         std::complex<type> dummy0, dummy1, dummy2;
         size_t i = 0, o = 0;
 
         /*
          * handle the head case
          * head_samps holds the number of samples left in a block.
-         * The 3 line converter is called for the whole block and already processed samples are dumped.
-         * We don't run into the risk of a SIGSEGV because input will always point to valid memory within a managed_buffer.
-         * Furthermore the bytes in a buffer remain unchanged after they have been copied into it.
+         * The 3 line converter is called for the whole block and already processed
+         * samples are dumped. We don't run into the risk of a SIGSEGV because input will
+         * always point to valid memory within a managed_buffer. Furthermore the bytes in
+         * a buffer remain unchanged after they have been copied into it.
          */
-        switch (head_samps)
-        {
-        case 0: break; //no head
-        case 1: convert_sc12_item32_3_to_star_4<type, tohost>(input[i++], dummy0, dummy1, dummy2, output[0], _scalar); break;
-        case 2: convert_sc12_item32_3_to_star_4<type, tohost>(input[i++], dummy0, dummy1, output[0], output[1], _scalar); break;
-        case 3: convert_sc12_item32_3_to_star_4<type, tohost>(input[i++], dummy0, output[0], output[1], output[2], _scalar); break;
+        switch (head_samps) {
+            case 0:
+                break; // no head
+            case 1:
+                convert_sc12_item32_3_to_star_4<type, tohost>(
+                    input[i++], dummy0, dummy1, dummy2, output[0], _scalar);
+                break;
+            case 2:
+                convert_sc12_item32_3_to_star_4<type, tohost>(
+                    input[i++], dummy0, dummy1, output[0], output[1], _scalar);
+                break;
+            case 3:
+                convert_sc12_item32_3_to_star_4<type, tohost>(
+                    input[i++], dummy0, output[0], output[1], output[2], _scalar);
+                break;
         }
         o += head_samps;
 
-        //convert the body
-        while (o+3 < nsamps)
-        {
-            convert_sc12_item32_3_to_star_4<type, tohost>(input[i], output[o+0], output[o+1], output[o+2], output[o+3], _scalar);
-            i++; o += 4;
+        // convert the body
+        while (o + 3 < nsamps) {
+            convert_sc12_item32_3_to_star_4<type, tohost>(input[i],
+                output[o + 0],
+                output[o + 1],
+                output[o + 2],
+                output[o + 3],
+                _scalar);
+            i++;
+            o += 4;
         }
 
         /*
          * handle the tail case
          * The converter can be called with any number of samples to be converted.
          * This can end up in only a part of a block to be converted in one call.
-         * We never have to worry about SIGSEGVs here as long as we end in the middle of a managed_buffer.
-         * If we are at the end of managed_buffer there are 2 precautions to prevent SIGSEGVs.
-         * Firstly only a read operation is performed.
-         * Secondly managed_buffers allocate a fixed size memory which is always larger than the actually used size.
-         * e.g. The current sample maximum is 2000 samples in a packet over USB.
-         * With sc12 samples a packet consists of 6000kb but managed_buffers allocate 16kb each.
-         * Thus we don't run into problems here either.
+         * We never have to worry about SIGSEGVs here as long as we end in the middle of a
+         * managed_buffer. If we are at the end of managed_buffer there are 2 precautions
+         * to prevent SIGSEGVs. Firstly only a read operation is performed. Secondly
+         * managed_buffers allocate a fixed size memory which is always larger than the
+         * actually used size. e.g. The current sample maximum is 2000 samples in a packet
+         * over USB. With sc12 samples a packet consists of 6000kb but managed_buffers
+         * allocate 16kb each. Thus we don't run into problems here either.
          */
         const size_t tail_samps = nsamps - o;
-        switch (tail_samps)
-        {
-        case 0: break; //no tail
-        case 1: convert_sc12_item32_3_to_star_4<type, tohost>(input[i], output[o+0], dummy0, dummy1, dummy2, _scalar); break;
-        case 2: convert_sc12_item32_3_to_star_4<type, tohost>(input[i], output[o+0], output[o+1], dummy1, dummy2, _scalar); break;
-        case 3: convert_sc12_item32_3_to_star_4<type, tohost>(input[i], output[o+0], output[o+1], output[o+2], dummy2, _scalar); break;
+        switch (tail_samps) {
+            case 0:
+                break; // no tail
+            case 1:
+                convert_sc12_item32_3_to_star_4<type, tohost>(
+                    input[i], output[o + 0], dummy0, dummy1, dummy2, _scalar);
+                break;
+            case 2:
+                convert_sc12_item32_3_to_star_4<type, tohost>(
+                    input[i], output[o + 0], output[o + 1], dummy1, dummy2, _scalar);
+                break;
+            case 3:
+                convert_sc12_item32_3_to_star_4<type, tohost>(input[i],
+                    output[o + 0],
+                    output[o + 1],
+                    output[o + 2],
+                    dummy2,
+                    _scalar);
+                break;
         }
     }
 
@@ -128,20 +165,24 @@ static converter::sptr make_convert_sc12_item32_be_1_to_sc16_1(void)
 
 UHD_STATIC_BLOCK(register_convert_unpack_sc12)
 {
-    uhd::convert::register_bytes_per_item("sc12", 3/*bytes*/);
+    uhd::convert::register_bytes_per_item("sc12", 3 /*bytes*/);
     uhd::convert::id_type id;
-    id.num_inputs = 1;
+    id.num_inputs  = 1;
     id.num_outputs = 1;
 
     id.output_format = "fc32";
-    id.input_format = "sc12_item32_le";
-    uhd::convert::register_converter(id, &make_convert_sc12_item32_le_1_to_fc32_1, PRIORITY_GENERAL);
+    id.input_format  = "sc12_item32_le";
+    uhd::convert::register_converter(
+        id, &make_convert_sc12_item32_le_1_to_fc32_1, PRIORITY_GENERAL);
     id.input_format = "sc12_item32_be";
-    uhd::convert::register_converter(id, &make_convert_sc12_item32_be_1_to_fc32_1, PRIORITY_GENERAL);
+    uhd::convert::register_converter(
+        id, &make_convert_sc12_item32_be_1_to_fc32_1, PRIORITY_GENERAL);
 
     id.output_format = "sc16";
-    id.input_format = "sc12_item32_le";
-    uhd::convert::register_converter(id, &make_convert_sc12_item32_le_1_to_sc16_1, PRIORITY_GENERAL);
+    id.input_format  = "sc12_item32_le";
+    uhd::convert::register_converter(
+        id, &make_convert_sc12_item32_le_1_to_sc16_1, PRIORITY_GENERAL);
     id.input_format = "sc12_item32_be";
-    uhd::convert::register_converter(id, &make_convert_sc12_item32_be_1_to_sc16_1, PRIORITY_GENERAL);
+    uhd::convert::register_converter(
+        id, &make_convert_sc12_item32_be_1_to_sc16_1, PRIORITY_GENERAL);
 }
diff --git a/host/lib/convert/convert_unpack_sc12.hpp b/host/lib/convert/convert_unpack_sc12.hpp
index e612b035d..26e5f5d79 100644
--- a/host/lib/convert/convert_unpack_sc12.hpp
+++ b/host/lib/convert/convert_unpack_sc12.hpp
@@ -5,9 +5,9 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 //
 
-#include <type_traits>
-#include <uhd/utils/byteswap.hpp>
 #include "convert_common.hpp"
+#include <uhd/utils/byteswap.hpp>
+#include <type_traits>
 
 using namespace uhd::convert;
 
@@ -37,38 +37,35 @@ struct item32_sc12_3x
  * The numbers mark the position of one complex sample.
  */
 template <typename type, tohost32_type tohost>
-void convert_sc12_item32_3_to_star_4
-(
-    const item32_sc12_3x &input,
-    std::complex<type> &out0,
-    std::complex<type> &out1,
-    std::complex<type> &out2,
-    std::complex<type> &out3,
+void convert_sc12_item32_3_to_star_4(const item32_sc12_3x& input,
+    std::complex<type>& out0,
+    std::complex<type>& out1,
+    std::complex<type>& out2,
+    std::complex<type>& out3,
     const double scalar,
-    typename std::enable_if<std::is_floating_point<type>::value>::type* = NULL
-)
+    typename std::enable_if<std::is_floating_point<type>::value>::type* = NULL)
 {
-    //step 0: extract the lines from the input buffer
-    const item32_t line0 = tohost(input.line0);
-    const item32_t line1 = tohost(input.line1);
-    const item32_t line2 = tohost(input.line2);
+    // step 0: extract the lines from the input buffer
+    const item32_t line0  = tohost(input.line0);
+    const item32_t line1  = tohost(input.line1);
+    const item32_t line2  = tohost(input.line2);
     const uint64_t line01 = (uint64_t(line0) << 32) | line1;
     const uint64_t line12 = (uint64_t(line1) << 32) | line2;
 
-    //step 1: shift out and mask off the individual numbers
-    const type i0 = type(int16_t((line0 >> 16) & 0xfff0)*scalar);
-    const type q0 = type(int16_t((line0 >> 4) & 0xfff0)*scalar);
+    // step 1: shift out and mask off the individual numbers
+    const type i0 = type(int16_t((line0 >> 16) & 0xfff0) * scalar);
+    const type q0 = type(int16_t((line0 >> 4) & 0xfff0) * scalar);
 
-    const type i1 = type(int16_t((line01 >> 24) & 0xfff0)*scalar);
-    const type q1 = type(int16_t((line1 >> 12) & 0xfff0)*scalar);
+    const type i1 = type(int16_t((line01 >> 24) & 0xfff0) * scalar);
+    const type q1 = type(int16_t((line1 >> 12) & 0xfff0) * scalar);
 
-    const type i2 = type(int16_t((line1 >> 0) & 0xfff0)*scalar);
-    const type q2 = type(int16_t((line12 >> 20) & 0xfff0)*scalar);
+    const type i2 = type(int16_t((line1 >> 0) & 0xfff0) * scalar);
+    const type q2 = type(int16_t((line12 >> 20) & 0xfff0) * scalar);
 
-    const type i3 = type(int16_t((line2 >> 8) & 0xfff0)*scalar);
-    const type q3 = type(int16_t((line2 << 4) & 0xfff0)*scalar);
+    const type i3 = type(int16_t((line2 >> 8) & 0xfff0) * scalar);
+    const type q3 = type(int16_t((line2 << 4) & 0xfff0) * scalar);
 
-    //step 2: load the outputs
+    // step 2: load the outputs
     out0 = std::complex<type>(i0, q0);
     out1 = std::complex<type>(i1, q1);
     out2 = std::complex<type>(i2, q2);
@@ -76,27 +73,24 @@ void convert_sc12_item32_3_to_star_4
 }
 
 template <typename type, tohost32_type tohost>
-void convert_sc12_item32_3_to_star_4
-(
-    const item32_sc12_3x &input,
-    std::complex<type> &out0,
-    std::complex<type> &out1,
-    std::complex<type> &out2,
-    std::complex<type> &out3,
+void convert_sc12_item32_3_to_star_4(const item32_sc12_3x& input,
+    std::complex<type>& out0,
+    std::complex<type>& out1,
+    std::complex<type>& out2,
+    std::complex<type>& out3,
     const double,
-    typename std::enable_if<std::is_integral<type>::value>::type* = NULL
-)
+    typename std::enable_if<std::is_integral<type>::value>::type* = NULL)
 {
-    //step 0: extract the lines from the input buffer
-    const item32_t line0 = tohost(input.line0);
-    const item32_t line1 = tohost(input.line1);
-    const item32_t line2 = tohost(input.line2);
+    // step 0: extract the lines from the input buffer
+    const item32_t line0  = tohost(input.line0);
+    const item32_t line1  = tohost(input.line1);
+    const item32_t line2  = tohost(input.line2);
     const uint64_t line01 = (uint64_t(line0) << 32) | line1;
     const uint64_t line12 = (uint64_t(line1) << 32) | line2;
 
-    //step 1: extract and load the outputs
-    out0 = std::complex<type>(line0  >> 16 & 0xfff0, line0  >>  4 & 0xfff0);
-    out1 = std::complex<type>(line01 >> 24 & 0xfff0, line1  >> 12 & 0xfff0);
-    out2 = std::complex<type>(line1  >>  0 & 0xfff0, line12 >> 20 & 0xfff0);
-    out3 = std::complex<type>(line2  >>  8 & 0xfff0, line2  <<  4 & 0xfff0);
+    // step 1: extract and load the outputs
+    out0 = std::complex<type>(line0 >> 16 & 0xfff0, line0 >> 4 & 0xfff0);
+    out1 = std::complex<type>(line01 >> 24 & 0xfff0, line1 >> 12 & 0xfff0);
+    out2 = std::complex<type>(line1 >> 0 & 0xfff0, line12 >> 20 & 0xfff0);
+    out3 = std::complex<type>(line2 >> 8 & 0xfff0, line2 << 4 & 0xfff0);
 }
diff --git a/host/lib/convert/convert_with_neon.cpp b/host/lib/convert/convert_with_neon.cpp
index 8a3bd29d5..9aec68bab 100644
--- a/host/lib/convert/convert_with_neon.cpp
+++ b/host/lib/convert/convert_with_neon.cpp
@@ -10,119 +10,123 @@
 #include <arm_neon.h>
 
 extern "C" {
-void neon_item32_sc16_swap_16n(void *, void *, int iter);
+void neon_item32_sc16_swap_16n(void*, void*, int iter);
 }
 
 static const int SIMD_WIDTH = 16;
 
 using namespace uhd::convert;
 
-DECLARE_CONVERTER(fc32, 1, sc16_item32_le, 1, PRIORITY_SIMD){
-    const fc32_t *input = reinterpret_cast<const fc32_t *>(inputs[0]);
-    item32_t *output = reinterpret_cast<item32_t *>(outputs[0]);
+DECLARE_CONVERTER(fc32, 1, sc16_item32_le, 1, PRIORITY_SIMD)
+{
+    const fc32_t* input = reinterpret_cast<const fc32_t*>(inputs[0]);
+    item32_t* output    = reinterpret_cast<item32_t*>(outputs[0]);
 
     size_t i;
 
     float32x4_t Q0 = vdupq_n_f32(float(scale_factor));
-    for (i=0; i < (nsamps & ~0x0f); i+=8) {
-        float32x4_t Q1 = vld1q_f32(reinterpret_cast<const float *>(&input[i]));
-        float32x4_t Q4 = vld1q_f32(reinterpret_cast<const float *>(&input[i+2]));
-        float32x4_t Q7 = vld1q_f32(reinterpret_cast<const float *>(&input[i+4]));
-        float32x4_t Q10 = vld1q_f32(reinterpret_cast<const float *>(&input[i+6]));
+    for (i = 0; i < (nsamps & ~0x0f); i += 8) {
+        float32x4_t Q1  = vld1q_f32(reinterpret_cast<const float*>(&input[i]));
+        float32x4_t Q4  = vld1q_f32(reinterpret_cast<const float*>(&input[i + 2]));
+        float32x4_t Q7  = vld1q_f32(reinterpret_cast<const float*>(&input[i + 4]));
+        float32x4_t Q10 = vld1q_f32(reinterpret_cast<const float*>(&input[i + 6]));
 
         float32x4_t Q2 = vmulq_f32(Q1, Q0);
-        int32x4_t Q3 = vcvtq_s32_f32(Q2);
-        int16x4_t D8 = vmovn_s32(Q3);
-        int16x4_t D9 = vrev32_s16(D8);
-        vst1_s16((reinterpret_cast<int16_t *>(&output[i])), D9);
+        int32x4_t Q3   = vcvtq_s32_f32(Q2);
+        int16x4_t D8   = vmovn_s32(Q3);
+        int16x4_t D9   = vrev32_s16(D8);
+        vst1_s16((reinterpret_cast<int16_t*>(&output[i])), D9);
 
         float32x4_t Q5 = vmulq_f32(Q4, Q0);
-        int32x4_t Q6 = vcvtq_s32_f32(Q5);
-        int16x4_t D10 = vmovn_s32(Q6);
-        int16x4_t D11 = vrev32_s16(D10);
-        vst1_s16((reinterpret_cast<int16_t *>(&output[i+2])), D11);
+        int32x4_t Q6   = vcvtq_s32_f32(Q5);
+        int16x4_t D10  = vmovn_s32(Q6);
+        int16x4_t D11  = vrev32_s16(D10);
+        vst1_s16((reinterpret_cast<int16_t*>(&output[i + 2])), D11);
 
         float32x4_t Q8 = vmulq_f32(Q7, Q0);
-        int32x4_t Q9 = vcvtq_s32_f32(Q8);
-        int16x4_t D12 = vmovn_s32(Q9);
-        int16x4_t D13 = vrev32_s16(D12);
-        vst1_s16((reinterpret_cast<int16_t *>(&output[i+4])), D13);
+        int32x4_t Q9   = vcvtq_s32_f32(Q8);
+        int16x4_t D12  = vmovn_s32(Q9);
+        int16x4_t D13  = vrev32_s16(D12);
+        vst1_s16((reinterpret_cast<int16_t*>(&output[i + 4])), D13);
 
         float32x4_t Q11 = vmulq_f32(Q10, Q0);
-        int32x4_t Q13 = vcvtq_s32_f32(Q11);
-        int16x4_t D14 = vmovn_s32(Q13);
-        int16x4_t D15 = vrev32_s16(D14);
-        vst1_s16((reinterpret_cast<int16_t *>(&output[i+6])), D15);
+        int32x4_t Q13   = vcvtq_s32_f32(Q11);
+        int16x4_t D14   = vmovn_s32(Q13);
+        int16x4_t D15   = vrev32_s16(D14);
+        vst1_s16((reinterpret_cast<int16_t*>(&output[i + 6])), D15);
     }
 
-    xx_to_item32_sc16<uhd::htowx>(input+i, output+i, nsamps-i, scale_factor);
+    xx_to_item32_sc16<uhd::htowx>(input + i, output + i, nsamps - i, scale_factor);
 }
 
-DECLARE_CONVERTER(sc16_item32_le, 1, fc32, 1, PRIORITY_SIMD){
-    const item32_t *input = reinterpret_cast<const item32_t *>(inputs[0]);
-    fc32_t *output = reinterpret_cast<fc32_t *>(outputs[0]);
+DECLARE_CONVERTER(sc16_item32_le, 1, fc32, 1, PRIORITY_SIMD)
+{
+    const item32_t* input = reinterpret_cast<const item32_t*>(inputs[0]);
+    fc32_t* output        = reinterpret_cast<fc32_t*>(outputs[0]);
 
     size_t i;
 
     float32x4_t Q1 = vdupq_n_f32(float(scale_factor));
-    for (i=0; i < (nsamps & ~0xf); i+=8) {
-        int16x4_t D0 = vld1_s16(reinterpret_cast<const int16_t *>(&input[i]));
-        int16x4_t D2 = vld1_s16(reinterpret_cast<const int16_t *>(&input[i+2]));
-        int16x4_t D4 = vld1_s16(reinterpret_cast<const int16_t *>(&input[i+4]));
-        int16x4_t D6 = vld1_s16(reinterpret_cast<const int16_t *>(&input[i+6]));
-
-        int16x4_t D1 = vrev32_s16(D0);
-        int32x4_t Q2 = vmovl_s16(D1);
+    for (i = 0; i < (nsamps & ~0xf); i += 8) {
+        int16x4_t D0 = vld1_s16(reinterpret_cast<const int16_t*>(&input[i]));
+        int16x4_t D2 = vld1_s16(reinterpret_cast<const int16_t*>(&input[i + 2]));
+        int16x4_t D4 = vld1_s16(reinterpret_cast<const int16_t*>(&input[i + 4]));
+        int16x4_t D6 = vld1_s16(reinterpret_cast<const int16_t*>(&input[i + 6]));
+
+        int16x4_t D1   = vrev32_s16(D0);
+        int32x4_t Q2   = vmovl_s16(D1);
         float32x4_t Q3 = vcvtq_f32_s32(Q2);
         float32x4_t Q4 = vmulq_f32(Q3, Q1);
-        vst1q_f32((reinterpret_cast<float *>(&output[i])), Q4);
+        vst1q_f32((reinterpret_cast<float*>(&output[i])), Q4);
 
-        int16x4_t D3 = vrev32_s16(D2);
-        int32x4_t Q5 = vmovl_s16(D3);
+        int16x4_t D3   = vrev32_s16(D2);
+        int32x4_t Q5   = vmovl_s16(D3);
         float32x4_t Q6 = vcvtq_f32_s32(Q5);
         float32x4_t Q7 = vmulq_f32(Q6, Q1);
-        vst1q_f32((reinterpret_cast<float *>(&output[i+2])), Q7);
+        vst1q_f32((reinterpret_cast<float*>(&output[i + 2])), Q7);
 
-        int16x4_t D5 = vrev32_s16(D4);
-        int32x4_t Q8 = vmovl_s16(D5);
-        float32x4_t Q9 = vcvtq_f32_s32(Q8);
+        int16x4_t D5    = vrev32_s16(D4);
+        int32x4_t Q8    = vmovl_s16(D5);
+        float32x4_t Q9  = vcvtq_f32_s32(Q8);
         float32x4_t Q10 = vmulq_f32(Q9, Q1);
-        vst1q_f32((reinterpret_cast<float *>(&output[i+4])), Q10);
+        vst1q_f32((reinterpret_cast<float*>(&output[i + 4])), Q10);
 
-        int16x4_t D7 = vrev32_s16(D6);
-        int32x4_t Q11 = vmovl_s16(D7);
+        int16x4_t D7    = vrev32_s16(D6);
+        int32x4_t Q11   = vmovl_s16(D7);
         float32x4_t Q12 = vcvtq_f32_s32(Q11);
         float32x4_t Q13 = vmulq_f32(Q12, Q1);
-        vst1q_f32((reinterpret_cast<float *>(&output[i+6])), Q13);
+        vst1q_f32((reinterpret_cast<float*>(&output[i + 6])), Q13);
     }
 
-    item32_sc16_to_xx<uhd::htowx>(input+i, output+i, nsamps-i, scale_factor);
+    item32_sc16_to_xx<uhd::htowx>(input + i, output + i, nsamps - i, scale_factor);
 }
 
-DECLARE_CONVERTER(sc16, 1, sc16_item32_le, 1, PRIORITY_SIMD){
-    const sc16_t *input = reinterpret_cast<const sc16_t *>(inputs[0]);
-    item32_t *output = reinterpret_cast<item32_t *>(outputs[0]);
+DECLARE_CONVERTER(sc16, 1, sc16_item32_le, 1, PRIORITY_SIMD)
+{
+    const sc16_t* input = reinterpret_cast<const sc16_t*>(inputs[0]);
+    item32_t* output    = reinterpret_cast<item32_t*>(outputs[0]);
 
     size_t i = nsamps / SIMD_WIDTH;
 
     if (i)
-        neon_item32_sc16_swap_16n((void *) input, (void *) output, i);
+        neon_item32_sc16_swap_16n((void*)input, (void*)output, i);
 
     i *= SIMD_WIDTH;
 
-    xx_to_item32_sc16<uhd::htowx>(input+i, output+i, nsamps-i, scale_factor);
+    xx_to_item32_sc16<uhd::htowx>(input + i, output + i, nsamps - i, scale_factor);
 }
 
-DECLARE_CONVERTER(sc16_item32_le, 1, sc16, 1, PRIORITY_SIMD){
-    const item32_t *input = reinterpret_cast<const item32_t *>(inputs[0]);
-    sc16_t *output = reinterpret_cast<sc16_t *>(outputs[0]);
+DECLARE_CONVERTER(sc16_item32_le, 1, sc16, 1, PRIORITY_SIMD)
+{
+    const item32_t* input = reinterpret_cast<const item32_t*>(inputs[0]);
+    sc16_t* output        = reinterpret_cast<sc16_t*>(outputs[0]);
 
     size_t i = nsamps / SIMD_WIDTH;
 
     if (i)
-        neon_item32_sc16_swap_16n((void *) input, (void *) output, i);
+        neon_item32_sc16_swap_16n((void*)input, (void*)output, i);
 
     i *= SIMD_WIDTH;
 
-    item32_sc16_to_xx<uhd::wtohx>(input+i, output+i, nsamps-i, scale_factor);
+    item32_sc16_to_xx<uhd::wtohx>(input + i, output + i, nsamps - i, scale_factor);
 }
diff --git a/host/lib/convert/convert_with_tables.cpp b/host/lib/convert/convert_with_tables.cpp
index 5c9248052..86637171a 100644
--- a/host/lib/convert/convert_with_tables.cpp
+++ b/host/lib/convert/convert_with_tables.cpp
@@ -20,7 +20,8 @@ typedef uint16_t (*tohost16_type)(uint16_t);
  * Implementation for sc16 to sc8 lookup table
  *  - Lookup the real and imaginary parts individually
  **********************************************************************/
-template <bool swap> class convert_sc16_1_to_sc8_item32_1 : public converter
+template <bool swap>
+class convert_sc16_1_to_sc8_item32_1 : public converter
 {
 public:
     convert_sc16_1_to_sc8_item32_1(void) : _table(sc16_table_len) {}
diff --git a/host/lib/convert/ssse3_pack_sc12.cpp b/host/lib/convert/ssse3_pack_sc12.cpp
index e71c2288b..4ba14db3b 100644
--- a/host/lib/convert/ssse3_pack_sc12.cpp
+++ b/host/lib/convert/ssse3_pack_sc12.cpp
@@ -5,8 +5,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 //
 
-#include <tmmintrin.h>
 #include "convert_pack_sc12.hpp"
+#include <tmmintrin.h>
 
 /*
  * Shuffle Orderings - Single 128-bit SSE register
@@ -44,24 +44,21 @@
  *      -----------------------
  *     31                     0
  */
-#define SC12_SHIFT_MASK      0xfff0fff0, 0xfff0fff0, 0x0fff0fff, 0x0fff0fff
-#define SC12_PACK_SHUFFLE1   13,12,9,8,5,4,1,0,15,14,11,10,7,6,3,2
-#define SC12_PACK_SHUFFLE2   9,8,0,11,10,2,13,12,4,15,14,6,0,0,0,0
-#define SC12_PACK_SHUFFLE3   8,1,8,8,3,8,8,5,8,8,7,8,8,8,8,8
+#define SC12_SHIFT_MASK 0xfff0fff0, 0xfff0fff0, 0x0fff0fff, 0x0fff0fff
+#define SC12_PACK_SHUFFLE1 13, 12, 9, 8, 5, 4, 1, 0, 15, 14, 11, 10, 7, 6, 3, 2
+#define SC12_PACK_SHUFFLE2 9, 8, 0, 11, 10, 2, 13, 12, 4, 15, 14, 6, 0, 0, 0, 0
+#define SC12_PACK_SHUFFLE3 8, 1, 8, 8, 3, 8, 8, 5, 8, 8, 7, 8, 8, 8, 8, 8
 
 template <typename type>
-inline void convert_star_4_to_sc12_item32_3
-(
-    const std::complex<type> *in,
-    item32_sc12_3x &output,
+inline void convert_star_4_to_sc12_item32_3(const std::complex<type>* in,
+    item32_sc12_3x& output,
     const double scalar,
-    typename std::enable_if<std::is_same<type, float>::value>::type* = NULL
-)
+    typename std::enable_if<std::is_same<type, float>::value>::type* = NULL)
 {
     __m128 m0, m1, m2;
     m0 = _mm_set1_ps(scalar);
-    m1 = _mm_loadu_ps((const float *) &in[0]);
-    m2 = _mm_loadu_ps((const float *) &in[2]);
+    m1 = _mm_loadu_ps((const float*)&in[0]);
+    m2 = _mm_loadu_ps((const float*)&in[2]);
     m1 = _mm_mul_ps(m1, m0);
     m2 = _mm_mul_ps(m2, m0);
     m0 = _mm_shuffle_ps(m1, m2, _MM_SHUFFLE(2, 0, 2, 0));
@@ -84,17 +81,14 @@ inline void convert_star_4_to_sc12_item32_3
     m6 = _mm_or_si128(m6, m7);
 
     m6 = _mm_shuffle_epi32(m6, _MM_SHUFFLE(0, 1, 2, 3));
-    _mm_storeu_si128((__m128i*) &output, m6);
+    _mm_storeu_si128((__m128i*)&output, m6);
 }
 
 template <typename type>
-static void convert_star_4_to_sc12_item32_3
-(
-    const std::complex<type> *in,
-    item32_sc12_3x &output,
+static void convert_star_4_to_sc12_item32_3(const std::complex<type>* in,
+    item32_sc12_3x& output,
     const double,
-    typename std::enable_if<std::is_same<type, short>::value>::type* = NULL
-)
+    typename std::enable_if<std::is_same<type, short>::value>::type* = NULL)
 {
     __m128i m0, m1, m2, m3, m4, m5;
     m0 = _mm_set_epi32(SC12_SHIFT_MASK);
@@ -102,7 +96,7 @@ static void convert_star_4_to_sc12_item32_3
     m2 = _mm_set_epi8(SC12_PACK_SHUFFLE2);
     m3 = _mm_set_epi8(SC12_PACK_SHUFFLE3);
 
-    m4 = _mm_loadu_si128((__m128i*) in);
+    m4 = _mm_loadu_si128((__m128i*)in);
     m4 = _mm_shuffle_epi8(m4, m1);
     m5 = _mm_srli_epi16(m4, 4);
     m4 = _mm_shuffle_epi32(m4, _MM_SHUFFLE(0, 0, 3, 2));
@@ -115,57 +109,66 @@ static void convert_star_4_to_sc12_item32_3
     m3 = _mm_or_si128(m4, m5);
 
     m3 = _mm_shuffle_epi32(m3, _MM_SHUFFLE(0, 1, 2, 3));
-    _mm_storeu_si128((__m128i*) &output, m3);
+    _mm_storeu_si128((__m128i*)&output, m3);
 }
 
 template <typename type, towire32_type towire>
 struct convert_star_1_to_sc12_item32_2 : public converter
 {
-    convert_star_1_to_sc12_item32_2(void):_scalar(0.0)
-    {
-    }
+    convert_star_1_to_sc12_item32_2(void) : _scalar(0.0) {}
 
     void set_scalar(const double scalar)
     {
         _scalar = scalar;
     }
 
-    void operator()(const input_type &inputs, const output_type &outputs, const size_t nsamps)
+    void operator()(
+        const input_type& inputs, const output_type& outputs, const size_t nsamps)
     {
-        const std::complex<type> *input = reinterpret_cast<const std::complex<type> *>(inputs[0]);
+        const std::complex<type>* input =
+            reinterpret_cast<const std::complex<type>*>(inputs[0]);
 
         const size_t head_samps = size_t(outputs[0]) & 0x3;
         int enable;
         size_t rewind = 0;
-        switch(head_samps)
-        {
-            case 0: break;
-            case 1: rewind = 9; break;
-            case 2: rewind = 6; break;
-            case 3: rewind = 3; break;
+        switch (head_samps) {
+            case 0:
+                break;
+            case 1:
+                rewind = 9;
+                break;
+            case 2:
+                rewind = 6;
+                break;
+            case 3:
+                rewind = 3;
+                break;
         }
-        item32_sc12_3x *output = reinterpret_cast<item32_sc12_3x *>(size_t(outputs[0]) - rewind);
+        item32_sc12_3x* output =
+            reinterpret_cast<item32_sc12_3x*>(size_t(outputs[0]) - rewind);
 
-        //helper variables
+        // helper variables
         size_t i = 0, o = 0;
 
-        //handle the head case
-        switch (head_samps)
-        {
-        case 0:
-            break; //no head
-        case 1:
-            enable = CONVERT12_LINE2;
-            convert_star_4_to_sc12_item32_3<type, towire>(0, 0, 0, input[0], enable, output[o++], _scalar);
-            break;
-        case 2:
-            enable = CONVERT12_LINE2 | CONVERT12_LINE1;
-            convert_star_4_to_sc12_item32_3<type, towire>(0, 0, input[0], input[1], enable, output[o++], _scalar);
-            break;
-        case 3:
-            enable = CONVERT12_LINE2 | CONVERT12_LINE1 | CONVERT12_LINE0;
-            convert_star_4_to_sc12_item32_3<type, towire>(0, input[0], input[1], input[2], enable, output[o++], _scalar);
-            break;
+        // handle the head case
+        switch (head_samps) {
+            case 0:
+                break; // no head
+            case 1:
+                enable = CONVERT12_LINE2;
+                convert_star_4_to_sc12_item32_3<type, towire>(
+                    0, 0, 0, input[0], enable, output[o++], _scalar);
+                break;
+            case 2:
+                enable = CONVERT12_LINE2 | CONVERT12_LINE1;
+                convert_star_4_to_sc12_item32_3<type, towire>(
+                    0, 0, input[0], input[1], enable, output[o++], _scalar);
+                break;
+            case 3:
+                enable = CONVERT12_LINE2 | CONVERT12_LINE1 | CONVERT12_LINE0;
+                convert_star_4_to_sc12_item32_3<type, towire>(
+                    0, input[0], input[1], input[2], enable, output[o++], _scalar);
+                break;
         }
         i += head_samps;
 
@@ -174,34 +177,47 @@ struct convert_star_1_to_sc12_item32_2 : public converter
         // subsequent samples to be converted (writes will simply happen
         // twice). So set the conversion loop to force a tail case on the
         // final 4 or fewer samples.
-        while (i+4 < nsamps)
-        {
+        while (i + 4 < nsamps) {
             convert_star_4_to_sc12_item32_3<type>(&input[i], output[o], _scalar);
-            o++; i += 4;
+            o++;
+            i += 4;
         }
 
-        //handle the tail case
+        // handle the tail case
         const size_t tail_samps = nsamps - i;
-        switch (tail_samps)
-        {
-        case 0:
-            break; //no tail
-        case 1:
-            enable = CONVERT12_LINE0;
-            convert_star_4_to_sc12_item32_3<type, towire>(input[i+0], 0, 0, 0, enable, output[o], _scalar);
-            break;
-        case 2:
-            enable = CONVERT12_LINE0 | CONVERT12_LINE1;
-            convert_star_4_to_sc12_item32_3<type, towire>(input[i+0], input[i+1], 0, 0, enable, output[o], _scalar);
-            break;
-        case 3:
-            enable = CONVERT12_LINE0 | CONVERT12_LINE1 | CONVERT12_LINE2;
-            convert_star_4_to_sc12_item32_3<type, towire>(input[i+0], input[i+1], input[i+2], 0, enable, output[o], _scalar);
-            break;
-        case 4:
-            enable = CONVERT12_LINE_ALL;
-            convert_star_4_to_sc12_item32_3<type, towire>(input[i+0], input[i+1], input[i+2], input[i+3], enable, output[o], _scalar);
-            break;
+        switch (tail_samps) {
+            case 0:
+                break; // no tail
+            case 1:
+                enable = CONVERT12_LINE0;
+                convert_star_4_to_sc12_item32_3<type, towire>(
+                    input[i + 0], 0, 0, 0, enable, output[o], _scalar);
+                break;
+            case 2:
+                enable = CONVERT12_LINE0 | CONVERT12_LINE1;
+                convert_star_4_to_sc12_item32_3<type, towire>(
+                    input[i + 0], input[i + 1], 0, 0, enable, output[o], _scalar);
+                break;
+            case 3:
+                enable = CONVERT12_LINE0 | CONVERT12_LINE1 | CONVERT12_LINE2;
+                convert_star_4_to_sc12_item32_3<type, towire>(input[i + 0],
+                    input[i + 1],
+                    input[i + 2],
+                    0,
+                    enable,
+                    output[o],
+                    _scalar);
+                break;
+            case 4:
+                enable = CONVERT12_LINE_ALL;
+                convert_star_4_to_sc12_item32_3<type, towire>(input[i + 0],
+                    input[i + 1],
+                    input[i + 2],
+                    input[i + 3],
+                    enable,
+                    output[o],
+                    _scalar);
+                break;
         }
     }
 
@@ -221,14 +237,16 @@ static converter::sptr make_convert_sc16_1_to_sc12_item32_le_1(void)
 UHD_STATIC_BLOCK(register_sse_pack_sc12)
 {
     uhd::convert::id_type id;
-    id.num_inputs = 1;
+    id.num_inputs  = 1;
     id.num_outputs = 1;
 
-    id.input_format = "fc32";
+    id.input_format  = "fc32";
     id.output_format = "sc12_item32_le";
-    uhd::convert::register_converter(id, &make_convert_fc32_1_to_sc12_item32_le_1, PRIORITY_SIMD);
+    uhd::convert::register_converter(
+        id, &make_convert_fc32_1_to_sc12_item32_le_1, PRIORITY_SIMD);
 
-    id.input_format = "sc16";
+    id.input_format  = "sc16";
     id.output_format = "sc12_item32_le";
-    uhd::convert::register_converter(id, &make_convert_sc16_1_to_sc12_item32_le_1, PRIORITY_SIMD);
+    uhd::convert::register_converter(
+        id, &make_convert_sc16_1_to_sc12_item32_le_1, PRIORITY_SIMD);
 }
diff --git a/host/lib/convert/ssse3_unpack_sc12.cpp b/host/lib/convert/ssse3_unpack_sc12.cpp
index a6e147142..5494e0fd7 100644
--- a/host/lib/convert/ssse3_unpack_sc12.cpp
+++ b/host/lib/convert/ssse3_unpack_sc12.cpp
@@ -59,23 +59,20 @@ using namespace uhd::convert;
  * | 127                                 0 |
  *
  */
-#define SC12_SHIFT_MASK      0x0fff0fff, 0x0fff0fff, 0xfff0fff0, 0xfff0fff0
-#define SC12_PACK_SHUFFLE1   5,4,8,7,11,10,14,13,6,5,9,8,12,11,15,14
-#define SC12_PACK_SHUFFLE2   15,14,7,6,13,12,5,4,11,10,3,2,9,8,1,0
+#define SC12_SHIFT_MASK 0x0fff0fff, 0x0fff0fff, 0xfff0fff0, 0xfff0fff0
+#define SC12_PACK_SHUFFLE1 5, 4, 8, 7, 11, 10, 14, 13, 6, 5, 9, 8, 12, 11, 15, 14
+#define SC12_PACK_SHUFFLE2 15, 14, 7, 6, 13, 12, 5, 4, 11, 10, 3, 2, 9, 8, 1, 0
 
 template <typename type, tohost32_type tohost>
-inline void convert_sc12_item32_3_to_star_4
-(
-    const item32_sc12_3x &input,
-    std::complex<type> *out,
+inline void convert_sc12_item32_3_to_star_4(const item32_sc12_3x& input,
+    std::complex<type>* out,
     double scalar,
-    typename std::enable_if<std::is_same<type, float>::value>::type* = NULL
-)
+    typename std::enable_if<std::is_same<type, float>::value>::type* = NULL)
 {
     __m128i m0, m1, m2, m3, m4;
     m0 = _mm_set_epi32(SC12_SHIFT_MASK);
     m1 = _mm_set_epi8(SC12_PACK_SHUFFLE1);
-    m2 = _mm_loadu_si128((__m128i*) &input);
+    m2 = _mm_loadu_si128((__m128i*)&input);
     m2 = _mm_shuffle_epi32(m2, _MM_SHUFFLE(0, 1, 2, 3));
     m3 = _mm_shuffle_epi8(m2, m1);
     m3 = _mm_and_si128(m3, m0);
@@ -88,7 +85,7 @@ inline void convert_sc12_item32_3_to_star_4
     m4 = _mm_unpackhi_epi32(m1, m2);
 
     __m128 m5, m6, m7;
-    m5 = _mm_set_ps1(scalar/(1 << 16));
+    m5 = _mm_set_ps1(scalar / (1 << 16));
     m6 = _mm_cvtepi32_ps(m3);
     m7 = _mm_cvtepi32_ps(m4);
     m6 = _mm_mul_ps(m6, m5);
@@ -99,20 +96,17 @@ inline void convert_sc12_item32_3_to_star_4
 }
 
 template <typename type, tohost32_type tohost>
-inline void convert_sc12_item32_3_to_star_4
-(
-    const item32_sc12_3x &input,
-    std::complex<type> *out,
+inline void convert_sc12_item32_3_to_star_4(const item32_sc12_3x& input,
+    std::complex<type>* out,
     double,
-    typename std::enable_if<std::is_same<type, short>::value>::type* = NULL
-)
+    typename std::enable_if<std::is_same<type, short>::value>::type* = NULL)
 {
     __m128i m0, m1, m2, m3;
     m0 = _mm_set_epi32(SC12_SHIFT_MASK);
     m1 = _mm_set_epi8(SC12_PACK_SHUFFLE1);
     m2 = _mm_set_epi8(SC12_PACK_SHUFFLE2);
 
-    m3 = _mm_loadu_si128((__m128i*) &input);
+    m3 = _mm_loadu_si128((__m128i*)&input);
     m3 = _mm_shuffle_epi32(m3, _MM_SHUFFLE(0, 1, 2, 3));
     m3 = _mm_shuffle_epi8(m3, m1);
     m3 = _mm_and_si128(m3, m0);
@@ -122,62 +116,92 @@ inline void convert_sc12_item32_3_to_star_4
     m0 = _mm_unpackhi_epi64(m1, m0);
     m1 = _mm_shuffle_epi8(m0, m2);
 
-    _mm_storeu_si128((__m128i*) out, m1);
+    _mm_storeu_si128((__m128i*)out, m1);
 }
 
 template <typename type, tohost32_type tohost>
 struct convert_sc12_item32_1_to_star_2 : public converter
 {
-    convert_sc12_item32_1_to_star_2(void):_scalar(0.0)
+    convert_sc12_item32_1_to_star_2(void) : _scalar(0.0)
     {
-        //NOP
+        // NOP
     }
 
     void set_scalar(const double scalar)
     {
         const int unpack_growth = 16;
-        _scalar = scalar/unpack_growth;
+        _scalar                 = scalar / unpack_growth;
     }
 
-    void operator()(const input_type &inputs, const output_type &outputs, const size_t nsamps)
+    void operator()(
+        const input_type& inputs, const output_type& outputs, const size_t nsamps)
     {
         const size_t head_samps = size_t(inputs[0]) & 0x3;
-        size_t rewind = 0;
-        switch(head_samps)
-        {
-            case 0: break;
-            case 1: rewind = 9; break;
-            case 2: rewind = 6; break;
-            case 3: rewind = 3; break;
+        size_t rewind           = 0;
+        switch (head_samps) {
+            case 0:
+                break;
+            case 1:
+                rewind = 9;
+                break;
+            case 2:
+                rewind = 6;
+                break;
+            case 3:
+                rewind = 3;
+                break;
         }
 
-        const item32_sc12_3x *input = reinterpret_cast<const item32_sc12_3x *>(size_t(inputs[0]) - rewind);
-        std::complex<type> *output = reinterpret_cast<std::complex<type> *>(outputs[0]);
+        const item32_sc12_3x* input =
+            reinterpret_cast<const item32_sc12_3x*>(size_t(inputs[0]) - rewind);
+        std::complex<type>* output = reinterpret_cast<std::complex<type>*>(outputs[0]);
         std::complex<type> dummy;
         size_t i = 0, o = 0;
-        switch (head_samps)
-        {
-        case 0: break; //no head
-        case 1: convert_sc12_item32_3_to_star_4<type, tohost>(input[i++], dummy, dummy, dummy, output[0], _scalar); break;
-        case 2: convert_sc12_item32_3_to_star_4<type, tohost>(input[i++], dummy, dummy, output[0], output[1], _scalar); break;
-        case 3: convert_sc12_item32_3_to_star_4<type, tohost>(input[i++], dummy, output[0], output[1], output[2], _scalar); break;
+        switch (head_samps) {
+            case 0:
+                break; // no head
+            case 1:
+                convert_sc12_item32_3_to_star_4<type, tohost>(
+                    input[i++], dummy, dummy, dummy, output[0], _scalar);
+                break;
+            case 2:
+                convert_sc12_item32_3_to_star_4<type, tohost>(
+                    input[i++], dummy, dummy, output[0], output[1], _scalar);
+                break;
+            case 3:
+                convert_sc12_item32_3_to_star_4<type, tohost>(
+                    input[i++], dummy, output[0], output[1], output[2], _scalar);
+                break;
         }
         o += head_samps;
 
-        //convert the body
-        while (o+3 < nsamps)
-        {
-           convert_sc12_item32_3_to_star_4<type, tohost>(input[i], &output[o], _scalar);
-            i += 1; o += 4;
+        // convert the body
+        while (o + 3 < nsamps) {
+            convert_sc12_item32_3_to_star_4<type, tohost>(input[i], &output[o], _scalar);
+            i += 1;
+            o += 4;
         }
 
         const size_t tail_samps = nsamps - o;
-        switch (tail_samps)
-        {
-        case 0: break; //no tail
-        case 1: convert_sc12_item32_3_to_star_4<type, tohost>(input[i], output[o+0], dummy, dummy, dummy, _scalar); break;
-        case 2: convert_sc12_item32_3_to_star_4<type, tohost>(input[i], output[o+0], output[o+1], dummy, dummy, _scalar); break;
-        case 3: convert_sc12_item32_3_to_star_4<type, tohost>(input[i], output[o+0], output[o+1], output[o+2], dummy, _scalar); break;
+        switch (tail_samps) {
+            case 0:
+                break; // no tail
+            case 1:
+                convert_sc12_item32_3_to_star_4<type, tohost>(
+                    input[i], output[o + 0], dummy, dummy, dummy, _scalar);
+                break;
+            case 2:
+                convert_sc12_item32_3_to_star_4<type, tohost>(
+                    input[i], output[o + 0], output[o + 1], dummy, dummy, _scalar);
+                break;
+            case 3:
+                convert_sc12_item32_3_to_star_4<type, tohost>(input[i],
+                    output[o + 0],
+                    output[o + 1],
+                    output[o + 2],
+                    dummy,
+                    _scalar);
+                break;
         }
     }
 
@@ -197,13 +221,15 @@ static converter::sptr make_convert_sc12_item32_le_1_to_sc16_1(void)
 UHD_STATIC_BLOCK(register_sse_unpack_sc12)
 {
     uhd::convert::id_type id;
-    id.num_inputs = 1;
-    id.num_outputs = 1;
+    id.num_inputs    = 1;
+    id.num_outputs   = 1;
     id.output_format = "fc32";
-    id.input_format = "sc12_item32_le";
-    uhd::convert::register_converter(id, &make_convert_sc12_item32_le_1_to_fc32_1, PRIORITY_SIMD);
+    id.input_format  = "sc12_item32_le";
+    uhd::convert::register_converter(
+        id, &make_convert_sc12_item32_le_1_to_fc32_1, PRIORITY_SIMD);
 
     id.output_format = "sc16";
-    id.input_format = "sc12_item32_le";
-    uhd::convert::register_converter(id, &make_convert_sc12_item32_le_1_to_sc16_1, PRIORITY_SIMD);
+    id.input_format  = "sc12_item32_le";
+    uhd::convert::register_converter(
+        id, &make_convert_sc12_item32_le_1_to_sc16_1, PRIORITY_SIMD);
 }