aboutsummaryrefslogtreecommitdiffstats
path: root/host/lib/convert
diff options
context:
space:
mode:
Diffstat (limited to 'host/lib/convert')
-rw-r--r--host/lib/convert/CMakeLists.txt14
-rw-r--r--host/lib/convert/convert_common.hpp38
-rw-r--r--host/lib/convert/convert_fc32_item32.cpp113
-rw-r--r--host/lib/convert/convert_orc.orc1
-rw-r--r--host/lib/convert/convert_pack_sc12.cpp144
-rw-r--r--host/lib/convert/convert_unpack_sc12.cpp152
-rw-r--r--host/lib/convert/convert_with_orc.cpp4
-rw-r--r--host/lib/convert/convert_with_tables.cpp30
-rw-r--r--host/lib/convert/sse2_fc32_to_sc8.cpp6
-rw-r--r--host/lib/convert/sse2_fc64_to_sc8.cpp18
-rw-r--r--host/lib/convert/sse2_sc8_to_fc32.cpp6
-rw-r--r--host/lib/convert/sse2_sc8_to_fc64.cpp6
12 files changed, 471 insertions, 61 deletions
diff --git a/host/lib/convert/CMakeLists.txt b/host/lib/convert/CMakeLists.txt
index 0d9d0983f..00e129b78 100644
--- a/host/lib/convert/CMakeLists.txt
+++ b/host/lib/convert/CMakeLists.txt
@@ -1,5 +1,5 @@
#
-# Copyright 2011-2012 Ettus Research LLC
+# Copyright 2011-2013 Ettus Research LLC
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
@@ -24,12 +24,11 @@ MESSAGE(STATUS "")
########################################################################
# Look for Orc support
########################################################################
-FIND_PACKAGE(PkgConfig)
-IF(PKG_CONFIG_FOUND)
-PKG_CHECK_MODULES(ORC "orc-0.4 > 0.4.11")
-ENDIF(PKG_CONFIG_FOUND)
+FIND_PACKAGE(ORC)
-FIND_PROGRAM(ORCC_EXECUTABLE orcc)
+IF(NOT ORCC_EXECUTABLE)
+ FIND_PROGRAM(ORCC_EXECUTABLE orcc)
+ENDIF()
LIBUHD_REGISTER_COMPONENT("ORC" ENABLE_ORC ON "ENABLE_LIBUHD;ORC_FOUND;ORCC_EXECUTABLE" OFF)
@@ -122,4 +121,7 @@ LIBUHD_APPEND_SOURCES(
${CMAKE_CURRENT_SOURCE_DIR}/convert_with_tables.cpp
${CMAKE_CURRENT_SOURCE_DIR}/convert_impl.cpp
${CMAKE_CURRENT_SOURCE_DIR}/convert_item32.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/convert_pack_sc12.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/convert_unpack_sc12.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/convert_fc32_item32.cpp
)
diff --git a/host/lib/convert/convert_common.hpp b/host/lib/convert/convert_common.hpp
index 933978a8f..ceaa1151c 100644
--- a/host/lib/convert/convert_common.hpp
+++ b/host/lib/convert/convert_common.hpp
@@ -1,5 +1,5 @@
//
-// Copyright 2011-2012 Ettus Research LLC
+// Copyright 2011-2013 Ettus Research LLC
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
@@ -150,10 +150,10 @@ UHD_INLINE void item32_sc16_to_xx(
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
){
- boost::uint8_t real0 = boost::int8_t(in0.real()*float(scale_factor));
- boost::uint8_t imag0 = boost::int8_t(in0.imag()*float(scale_factor));
- boost::uint8_t real1 = boost::int8_t(in1.real()*float(scale_factor));
- boost::uint8_t imag1 = boost::int8_t(in1.imag()*float(scale_factor));
+ boost::uint8_t real1 = boost::int8_t(in0.real()*float(scale_factor));
+ boost::uint8_t imag1 = boost::int8_t(in0.imag()*float(scale_factor));
+ boost::uint8_t real0 = boost::int8_t(in1.real()*float(scale_factor));
+ boost::uint8_t imag0 = boost::int8_t(in1.imag()*float(scale_factor));
return
(item32_t(real0) << 8) | (item32_t(imag0) << 0) |
(item32_t(real1) << 24) | (item32_t(imag1) << 16)
@@ -163,10 +163,10 @@ template <typename T> UHD_INLINE item32_t xx_to_item32_sc8_x1(
template <> UHD_INLINE item32_t xx_to_item32_sc8_x1(
const sc16_t &in0, const sc16_t &in1, const double
){
- boost::uint8_t real0 = boost::int8_t(in0.real());
- boost::uint8_t imag0 = boost::int8_t(in0.imag());
- boost::uint8_t real1 = boost::int8_t(in1.real());
- boost::uint8_t imag1 = boost::int8_t(in1.imag());
+ boost::uint8_t real1 = boost::int8_t(in0.real());
+ boost::uint8_t imag1 = boost::int8_t(in0.imag());
+ boost::uint8_t real0 = boost::int8_t(in1.real());
+ boost::uint8_t imag0 = boost::int8_t(in1.imag());
return
(item32_t(real0) << 8) | (item32_t(imag0) << 0) |
(item32_t(real1) << 24) | (item32_t(imag1) << 16)
@@ -176,10 +176,10 @@ template <> UHD_INLINE item32_t xx_to_item32_sc8_x1(
template <> UHD_INLINE item32_t xx_to_item32_sc8_x1(
const sc8_t &in0, const sc8_t &in1, const double
){
- boost::uint8_t real0 = boost::int8_t(in0.real());
- boost::uint8_t imag0 = boost::int8_t(in0.imag());
- boost::uint8_t real1 = boost::int8_t(in1.real());
- boost::uint8_t imag1 = boost::int8_t(in1.imag());
+ boost::uint8_t real1 = boost::int8_t(in0.real());
+ boost::uint8_t imag1 = boost::int8_t(in0.imag());
+ boost::uint8_t real0 = boost::int8_t(in1.real());
+ boost::uint8_t imag0 = boost::int8_t(in1.imag());
return
(item32_t(real0) << 8) | (item32_t(imag0) << 0) |
(item32_t(real1) << 24) | (item32_t(imag1) << 16)
@@ -211,11 +211,11 @@ UHD_INLINE void xx_to_item32_sc8(
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
){
- out0 = std::complex<T>(
+ out1 = std::complex<T>(
T(boost::int8_t(item >> 8)*float(scale_factor)),
T(boost::int8_t(item >> 0)*float(scale_factor))
);
- out1 = std::complex<T>(
+ out0 = std::complex<T>(
T(boost::int8_t(item >> 24)*float(scale_factor)),
T(boost::int8_t(item >> 16)*float(scale_factor))
);
@@ -224,11 +224,11 @@ template <typename T> UHD_INLINE void item32_sc8_x1_to_xx(
template <> UHD_INLINE void item32_sc8_x1_to_xx(
const item32_t item, sc16_t &out0, sc16_t &out1, const double
){
- out0 = sc16_t(
+ out1 = sc16_t(
boost::int16_t(boost::int8_t(item >> 8)),
boost::int16_t(boost::int8_t(item >> 0))
);
- out1 = sc16_t(
+ out0 = sc16_t(
boost::int16_t(boost::int8_t(item >> 24)),
boost::int16_t(boost::int8_t(item >> 16))
);
@@ -237,11 +237,11 @@ template <> UHD_INLINE void item32_sc8_x1_to_xx(
template <> UHD_INLINE void item32_sc8_x1_to_xx(
const item32_t item, sc8_t &out0, sc8_t &out1, const double
){
- out0 = sc8_t(
+ out1 = sc8_t(
boost::int8_t(boost::int8_t(item >> 8)),
boost::int8_t(boost::int8_t(item >> 0))
);
- out1 = sc8_t(
+ out0 = sc8_t(
boost::int8_t(boost::int8_t(item >> 24)),
boost::int8_t(boost::int8_t(item >> 16))
);
diff --git a/host/lib/convert/convert_fc32_item32.cpp b/host/lib/convert/convert_fc32_item32.cpp
new file mode 100644
index 000000000..29bfefd46
--- /dev/null
+++ b/host/lib/convert/convert_fc32_item32.cpp
@@ -0,0 +1,113 @@
+//
+// Copyright 2013 Ettus Research LLC
+//
+// This program 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 of the License, or
+// (at your option) any later version.
+//
+// This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include "convert_common.hpp"
+#include <uhd/utils/byteswap.hpp>
+#include <uhd/utils/msg.hpp>
+#include <boost/math/special_functions/round.hpp>
+#include <vector>
+
+using namespace uhd::convert;
+
+typedef boost::uint32_t (*to32_type)(boost::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)
+ {
+ //NOP
+ }
+
+ void set_scalar(const double scalar)
+ {
+ _scalar = scalar;
+ }
+
+ 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]);
+
+ 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_f32 = reinterpret_cast<const float &>(i32);
+ const float q_f32 = reinterpret_cast<const float &>(q32);
+ output[o] = std::complex<type>(type(i_f32*_scalar), type(q_f32*_scalar));
+ }
+ }
+
+ double _scalar;
+};
+
+template <typename type, to32_type towire>
+struct convert_star_1_to_fc32_item32_1 : public converter
+{
+ convert_star_1_to_fc32_item32_1(void)
+ {
+ //NOP
+ }
+
+ void set_scalar(const double scalar)
+ {
+ _scalar = scalar;
+ }
+
+ 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]);
+
+ 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 i32 = towire(reinterpret_cast<const item32_t &>(i_f32));
+ const item32_t q32 = towire(reinterpret_cast<const item32_t &>(q_f32));
+ output[o++] = i32; output[o++] = q32;
+ }
+ }
+
+ 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)
diff --git a/host/lib/convert/convert_orc.orc b/host/lib/convert/convert_orc.orc
index f7075606e..ffb298f26 100644
--- a/host/lib/convert/convert_orc.orc
+++ b/host/lib/convert/convert_orc.orc
@@ -75,6 +75,5 @@ swapl dst, src
.floatparam 4 scalar
x2 mulf tmp, src, scalar
x2 convfl tmp, tmp
-swaplq tmp, tmp
x2 convlw tmp2, tmp
x2 convwb dst, tmp2
diff --git a/host/lib/convert/convert_pack_sc12.cpp b/host/lib/convert/convert_pack_sc12.cpp
new file mode 100644
index 000000000..680814994
--- /dev/null
+++ b/host/lib/convert/convert_pack_sc12.cpp
@@ -0,0 +1,144 @@
+//
+// Copyright 2013 Ettus Research LLC
+//
+// This program 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 of the License, or
+// (at your option) any later version.
+//
+// This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include "convert_common.hpp"
+#include <uhd/utils/byteswap.hpp>
+#include <uhd/utils/msg.hpp>
+#include <boost/math/special_functions/round.hpp>
+#include <vector>
+
+using namespace uhd::convert;
+
+typedef boost::uint32_t (*towire32_type)(boost::uint32_t);
+
+struct item32_sc12_3x
+{
+ item32_t line0;
+ item32_t line1;
+ item32_t line2;
+};
+
+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,
+ item32_sc12_3x &output,
+ const double scalar
+)
+{
+ const item32_t i0 = boost::int32_t(type(in0.real()*scalar)) & 0xfff;
+ const item32_t q0 = boost::int32_t(type(in0.imag()*scalar)) & 0xfff;
+
+ const item32_t i1 = boost::int32_t(type(in1.real()*scalar)) & 0xfff;
+ const item32_t q1 = boost::int32_t(type(in1.imag()*scalar)) & 0xfff;
+
+ const item32_t i2 = boost::int32_t(type(in2.real()*scalar)) & 0xfff;
+ const item32_t q2 = boost::int32_t(type(in2.imag()*scalar)) & 0xfff;
+
+ const item32_t i3 = boost::int32_t(type(in3.real()*scalar)) & 0xfff;
+ const item32_t q3 = boost::int32_t(type(in3.imag()*scalar)) & 0xfff;
+
+ const item32_t line0 = (i0 << 20) | (q0 << 8) | (i1 >> 4);
+ const item32_t line1 = (i1 << 28) | (q1 << 16) | (i2 << 4) | (q2 >> 8);
+ const item32_t line2 = (q2 << 24) | (i3 << 12) | (q3);
+
+ output.line0 = towire(line0);
+ output.line1 = towire(line1);
+ output.line2 = towire(line2);
+}
+
+template <typename type, towire32_type towire>
+struct convert_star_1_to_sc12_item32_1 : public converter
+{
+ convert_star_1_to_sc12_item32_1(void)
+ {
+ //NOP
+ }
+
+ void set_scalar(const double scalar)
+ {
+ _scalar = scalar;
+ }
+
+ 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_sc12_3x *output = reinterpret_cast<item32_sc12_3x *>(size_t(outputs[0]) & ~0x3);
+
+ //helper variables
+ size_t i = 0, o = 0;
+
+ //handle the head case
+ const size_t head_samps = size_t(outputs[0]) & 0x3;
+ switch (head_samps)
+ {
+ case 0: break; //no head
+ case 1: convert_star_4_to_sc12_item32_3<type, towire>(0, 0, 0, input[0], output[o++], _scalar); break;
+ case 2: convert_star_4_to_sc12_item32_3<type, towire>(0, 0, input[0], input[1], output[o++], _scalar); break;
+ case 3: convert_star_4_to_sc12_item32_3<type, towire>(0, input[0], input[1], input[2], 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], output[o], _scalar);
+ o++; i += 4;
+ }
+
+ //handle the tail case
+ const size_t tail_samps = nsamps - i;
+ switch (tail_samps)
+ {
+ case 0: break; //no tail
+ case 1: convert_star_4_to_sc12_item32_3<type, towire>(input[i+0], 0, 0, 0, output[o], _scalar); break;
+ case 2: convert_star_4_to_sc12_item32_3<type, towire>(input[i+0], input[i+1], 0, 0, output[o], _scalar); break;
+ case 3: convert_star_4_to_sc12_item32_3<type, towire>(input[i+0], input[i+1], input[i+2], 0, output[o], _scalar); break;
+ }
+ }
+
+ double _scalar;
+};
+
+static converter::sptr make_convert_fc32_1_to_sc12_item32_le_1(void)
+{
+ return converter::sptr(new convert_star_1_to_sc12_item32_1<float, uhd::wtohx>());
+}
+
+static converter::sptr make_convert_fc32_1_to_sc12_item32_be_1(void)
+{
+ return converter::sptr(new convert_star_1_to_sc12_item32_1<float, uhd::ntohx>());
+}
+
+UHD_STATIC_BLOCK(register_convert_pack_sc12)
+{
+ //uhd::convert::register_bytes_per_item("sc12", 3/*bytes*/); //registered in unpack
+
+ uhd::convert::id_type id;
+ id.num_inputs = 1;
+ id.num_outputs = 1;
+ 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);
+
+ id.output_format = "sc12_item32_be";
+ uhd::convert::register_converter(id, &make_convert_fc32_1_to_sc12_item32_be_1, PRIORITY_GENERAL);
+}
diff --git a/host/lib/convert/convert_unpack_sc12.cpp b/host/lib/convert/convert_unpack_sc12.cpp
new file mode 100644
index 000000000..f578b6c95
--- /dev/null
+++ b/host/lib/convert/convert_unpack_sc12.cpp
@@ -0,0 +1,152 @@
+//
+// Copyright 2013 Ettus Research LLC
+//
+// This program 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 of the License, or
+// (at your option) any later version.
+//
+// This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include "convert_common.hpp"
+#include <uhd/utils/byteswap.hpp>
+#include <uhd/utils/msg.hpp>
+#include <boost/math/special_functions/round.hpp>
+#include <vector>
+
+using namespace uhd::convert;
+
+typedef boost::uint32_t (*tohost32_type)(boost::uint32_t);
+
+struct item32_sc12_3x
+{
+ item32_t line0;
+ item32_t line1;
+ item32_t line2;
+};
+
+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,
+ const double scalar
+)
+{
+ //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 boost::uint64_t line01 = (boost::uint64_t(line0) << 32) | line1;
+ const boost::uint64_t line12 = (boost::uint64_t(line1) << 32) | line2;
+
+ //step 1: shift out and mask off the individual numbers
+ const type i0 = type(boost::int16_t(line0 >> 16)*scalar);
+ const type q0 = type(boost::int16_t(line0 >> 4)*scalar);
+
+ const type i1 = type(boost::int16_t(line01 >> 24)*scalar);
+ const type q1 = type(boost::int16_t(line1 >> 12)*scalar);
+
+ const type i2 = type(boost::int16_t(line1 >> 0)*scalar);
+ const type q2 = type(boost::int16_t(line12 >> 20)*scalar);
+
+ const type i3 = type(boost::int16_t(line2 >> 8)*scalar);
+ const type q3 = type(boost::int16_t(line2 << 4)*scalar);
+
+ //step 2: load the outputs
+ out0 = std::complex<type>(i0, q0);
+ out1 = std::complex<type>(i1, q1);
+ out2 = std::complex<type>(i2, q2);
+ out3 = std::complex<type>(i3, q3);
+}
+
+template <typename type, tohost32_type tohost>
+struct convert_sc12_item32_1_to_star_1 : public converter
+{
+ convert_sc12_item32_1_to_star_1(void)
+ {
+ //NOP
+ }
+
+ void set_scalar(const double scalar)
+ {
+ const int unpack_growth = 16;
+ _scalar = scalar/unpack_growth;
+ }
+
+ void operator()(const input_type &inputs, const output_type &outputs, const size_t nsamps)
+ {
+ const item32_sc12_3x *input = reinterpret_cast<const item32_sc12_3x *>(size_t(inputs[0]) & ~0x3);
+ std::complex<type> *output = reinterpret_cast<std::complex<type> *>(outputs[0]);
+
+ //helper variables
+ std::complex<type> dummy0, dummy1, dummy2;
+ size_t i = 0, o = 0;
+
+ //handle the head case
+ const size_t head_samps = size_t(inputs[0]) & 0x3;
+ 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;
+ }
+
+ //handle the tail case
+ 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;
+ }
+ }
+
+ double _scalar;
+};
+
+static converter::sptr make_convert_sc12_item32_le_1_to_fc32_1(void)
+{
+ return converter::sptr(new convert_sc12_item32_1_to_star_1<float, uhd::wtohx>());
+}
+
+static converter::sptr make_convert_sc12_item32_be_1_to_fc32_1(void)
+{
+ return converter::sptr(new convert_sc12_item32_1_to_star_1<float, uhd::ntohx>());
+}
+
+UHD_STATIC_BLOCK(register_convert_unpack_sc12)
+{
+ uhd::convert::register_bytes_per_item("sc12", 3/*bytes*/);
+
+ uhd::convert::id_type id;
+ 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_be";
+ uhd::convert::register_converter(id, &make_convert_sc12_item32_be_1_to_fc32_1, PRIORITY_GENERAL);
+}
diff --git a/host/lib/convert/convert_with_orc.cpp b/host/lib/convert/convert_with_orc.cpp
index e44c8ca73..19755fa44 100644
--- a/host/lib/convert/convert_with_orc.cpp
+++ b/host/lib/convert/convert_with_orc.cpp
@@ -1,5 +1,5 @@
//
-// Copyright 2011 Ettus Research LLC
+// Copyright 2011-2013 Ettus Research LLC
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
@@ -57,9 +57,9 @@ DECLARE_CONVERTER(sc16_item32_le, 1, sc16, 1, PRIORITY_LIBORC){
DECLARE_CONVERTER(fc32, 1, sc8_item32_be, 1, PRIORITY_LIBORC){
_convert_fc32_1_to_sc8_1_nswap_orc(outputs[0], inputs[0], scale_factor, nsamps);
- _convert_swap_byte_pairs_orc(outputs[0], outputs[0], (nsamps + 1)/2);
}
DECLARE_CONVERTER(fc32, 1, sc8_item32_le, 1, PRIORITY_LIBORC){
_convert_fc32_1_to_sc8_1_nswap_orc(outputs[0], inputs[0], scale_factor, nsamps);
+ _convert_swap_byte_pairs_orc(outputs[0], outputs[0], (nsamps + 1)/2);
}
diff --git a/host/lib/convert/convert_with_tables.cpp b/host/lib/convert/convert_with_tables.cpp
index cd7773d4b..4d295fa01 100644
--- a/host/lib/convert/convert_with_tables.cpp
+++ b/host/lib/convert/convert_with_tables.cpp
@@ -1,5 +1,5 @@
//
-// Copyright 2011-2012 Ettus Research LLC
+// Copyright 2011-2013 Ettus Research LLC
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
@@ -59,16 +59,16 @@ public:
item32_t lookup(const sc16_t &in0, const sc16_t &in1){
if (swap){ //hope this compiles out, its a template constant
return
- (item32_t(_table[boost::uint16_t(in0.real())]) << 16) |
- (item32_t(_table[boost::uint16_t(in0.imag())]) << 24) |
- (item32_t(_table[boost::uint16_t(in1.real())]) << 0) |
- (item32_t(_table[boost::uint16_t(in1.imag())]) << 8) ;
+ (item32_t(_table[boost::uint16_t(in1.real())]) << 16) |
+ (item32_t(_table[boost::uint16_t(in1.imag())]) << 24) |
+ (item32_t(_table[boost::uint16_t(in0.real())]) << 0) |
+ (item32_t(_table[boost::uint16_t(in0.imag())]) << 8) ;
}
return
- (item32_t(_table[boost::uint16_t(in0.real())]) << 8) |
- (item32_t(_table[boost::uint16_t(in0.imag())]) << 0) |
- (item32_t(_table[boost::uint16_t(in1.real())]) << 24) |
- (item32_t(_table[boost::uint16_t(in1.imag())]) << 16) ;
+ (item32_t(_table[boost::uint16_t(in1.real())]) << 8) |
+ (item32_t(_table[boost::uint16_t(in1.imag())]) << 0) |
+ (item32_t(_table[boost::uint16_t(in0.real())]) << 24) |
+ (item32_t(_table[boost::uint16_t(in0.imag())]) << 16) ;
}
private:
@@ -196,27 +196,27 @@ static converter::sptr make_convert_sc16_item32_le_1_to_fc64_1(void){
}
static converter::sptr make_convert_sc8_item32_be_1_to_fc32_1(void){
- return converter::sptr(new convert_sc8_item32_1_to_fcxx_1<float, uhd::ntohx, SHIFT_PAIR1>());
+ return converter::sptr(new convert_sc8_item32_1_to_fcxx_1<float, uhd::ntohx, SHIFT_PAIR0>());
}
static converter::sptr make_convert_sc8_item32_be_1_to_fc64_1(void){
- return converter::sptr(new convert_sc8_item32_1_to_fcxx_1<double, uhd::ntohx, SHIFT_PAIR1>());
+ return converter::sptr(new convert_sc8_item32_1_to_fcxx_1<double, uhd::ntohx, SHIFT_PAIR0>());
}
static converter::sptr make_convert_sc8_item32_le_1_to_fc32_1(void){
- return converter::sptr(new convert_sc8_item32_1_to_fcxx_1<float, uhd::wtohx, SHIFT_PAIR0>());
+ return converter::sptr(new convert_sc8_item32_1_to_fcxx_1<float, uhd::wtohx, SHIFT_PAIR1>());
}
static converter::sptr make_convert_sc8_item32_le_1_to_fc64_1(void){
- return converter::sptr(new convert_sc8_item32_1_to_fcxx_1<double, uhd::wtohx, SHIFT_PAIR0>());
+ return converter::sptr(new convert_sc8_item32_1_to_fcxx_1<double, uhd::wtohx, SHIFT_PAIR1>());
}
static converter::sptr make_convert_sc8_item32_be_1_to_sc16_1(void){
- return converter::sptr(new convert_sc8_item32_1_to_fcxx_1<s16_t, uhd::ntohx, SHIFT_PAIR1>());
+ return converter::sptr(new convert_sc8_item32_1_to_fcxx_1<s16_t, uhd::ntohx, SHIFT_PAIR0>());
}
static converter::sptr make_convert_sc8_item32_le_1_to_sc16_1(void){
- return converter::sptr(new convert_sc8_item32_1_to_fcxx_1<s16_t, uhd::wtohx, SHIFT_PAIR0>());
+ return converter::sptr(new convert_sc8_item32_1_to_fcxx_1<s16_t, uhd::wtohx, SHIFT_PAIR1>());
}
static converter::sptr make_convert_sc16_1_to_sc8_item32_be_1(void){
diff --git a/host/lib/convert/sse2_fc32_to_sc8.cpp b/host/lib/convert/sse2_fc32_to_sc8.cpp
index dd884640d..36aa68b0e 100644
--- a/host/lib/convert/sse2_fc32_to_sc8.cpp
+++ b/host/lib/convert/sse2_fc32_to_sc8.cpp
@@ -1,5 +1,5 @@
//
-// Copyright 2012 Ettus Research LLC
+// Copyright 2012-2013 Ettus Research LLC
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
@@ -47,7 +47,7 @@ DECLARE_CONVERTER(fc32, 1, sc8_item32_be, 1, PRIORITY_SIMD){
item32_t *output = reinterpret_cast<item32_t *>(outputs[0]);
const __m128 scalar = _mm_set_ps1(float(scale_factor));
- const int shuf = _MM_SHUFFLE(1, 0, 3, 2);
+ const int shuf = _MM_SHUFFLE(3, 2, 1, 0);
#define convert_fc32_1_to_sc8_item32_1_bswap_guts(_al_) \
for (size_t j = 0; i+7 < nsamps; i+=8, j+=4){ \
@@ -83,7 +83,7 @@ DECLARE_CONVERTER(fc32, 1, sc8_item32_le, 1, PRIORITY_SIMD){
item32_t *output = reinterpret_cast<item32_t *>(outputs[0]);
const __m128 scalar = _mm_set_ps1(float(scale_factor));
- const int shuf = _MM_SHUFFLE(2, 3, 0, 1);
+ const int shuf = _MM_SHUFFLE(0, 1, 2, 3);
#define convert_fc32_1_to_sc8_item32_1_nswap_guts(_al_) \
for (size_t j = 0; i+7 < nsamps; i+=8, j+=4){ \
diff --git a/host/lib/convert/sse2_fc64_to_sc8.cpp b/host/lib/convert/sse2_fc64_to_sc8.cpp
index bf3719e13..82a8e0bb0 100644
--- a/host/lib/convert/sse2_fc64_to_sc8.cpp
+++ b/host/lib/convert/sse2_fc64_to_sc8.cpp
@@ -1,5 +1,5 @@
//
-// Copyright 2012 Ettus Research LLC
+// Copyright 2012-2013 Ettus Research LLC
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
@@ -59,10 +59,10 @@ DECLARE_CONVERTER(fc64, 1, sc8_item32_be, 1, PRIORITY_SIMD){
\
/* interleave */ \
const __m128i tmpi = pack_sc8_item32_4x( \
- pack_sc32_4x(tmp0, tmp1, scalar), \
- pack_sc32_4x(tmp2, tmp3, scalar), \
- pack_sc32_4x(tmp4, tmp5, scalar), \
- pack_sc32_4x(tmp6, tmp7, scalar) \
+ pack_sc32_4x(tmp1, tmp0, scalar), \
+ pack_sc32_4x(tmp3, tmp2, scalar), \
+ pack_sc32_4x(tmp5, tmp4, scalar), \
+ pack_sc32_4x(tmp7, tmp6, scalar) \
); \
\
/* store to output */ \
@@ -103,10 +103,10 @@ DECLARE_CONVERTER(fc64, 1, sc8_item32_le, 1, PRIORITY_SIMD){
\
/* interleave */ \
__m128i tmpi = pack_sc8_item32_4x( \
- pack_sc32_4x(tmp1, tmp0, scalar), \
- pack_sc32_4x(tmp3, tmp2, scalar), \
- pack_sc32_4x(tmp5, tmp4, scalar), \
- pack_sc32_4x(tmp7, tmp6, scalar) \
+ pack_sc32_4x(tmp0, tmp1, scalar), \
+ pack_sc32_4x(tmp2, tmp3, scalar), \
+ pack_sc32_4x(tmp4, tmp5, scalar), \
+ pack_sc32_4x(tmp6, tmp7, scalar) \
); \
tmpi = _mm_or_si128(_mm_srli_epi16(tmpi, 8), _mm_slli_epi16(tmpi, 8)); /*byteswap*/\
\
diff --git a/host/lib/convert/sse2_sc8_to_fc32.cpp b/host/lib/convert/sse2_sc8_to_fc32.cpp
index c0e561814..724af0225 100644
--- a/host/lib/convert/sse2_sc8_to_fc32.cpp
+++ b/host/lib/convert/sse2_sc8_to_fc32.cpp
@@ -1,5 +1,5 @@
//
-// Copyright 2012 Ettus Research LLC
+// Copyright 2012-2013 Ettus Research LLC
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
@@ -48,7 +48,7 @@ DECLARE_CONVERTER(sc8_item32_be, 1, fc32, 1, PRIORITY_SIMD){
fc32_t *output = reinterpret_cast<fc32_t *>(outputs[0]);
const __m128 scalar = _mm_set_ps1(float(scale_factor)/(1 << 24));
- const int shuf = _MM_SHUFFLE(1, 0, 3, 2);
+ const int shuf = _MM_SHUFFLE(3, 2, 1, 0);
size_t i = 0, j = 0;
fc32_t dummy;
@@ -92,7 +92,7 @@ DECLARE_CONVERTER(sc8_item32_le, 1, fc32, 1, PRIORITY_SIMD){
fc32_t *output = reinterpret_cast<fc32_t *>(outputs[0]);
const __m128 scalar = _mm_set_ps1(float(scale_factor)/(1 << 24));
- const int shuf = _MM_SHUFFLE(2, 3, 0, 1);
+ const int shuf = _MM_SHUFFLE(0, 1, 2, 3);
size_t i = 0, j = 0;
fc32_t dummy;
diff --git a/host/lib/convert/sse2_sc8_to_fc64.cpp b/host/lib/convert/sse2_sc8_to_fc64.cpp
index ef9c0fdb4..94d8911f6 100644
--- a/host/lib/convert/sse2_sc8_to_fc64.cpp
+++ b/host/lib/convert/sse2_sc8_to_fc64.cpp
@@ -1,5 +1,5 @@
//
-// Copyright 2012 Ettus Research LLC
+// Copyright 2012-2013 Ettus Research LLC
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
@@ -77,7 +77,7 @@ DECLARE_CONVERTER(sc8_item32_be, 1, fc64, 1, PRIORITY_SIMD){
\
/* unpack */ \
__m128d tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; \
- unpack_sc32_8x(tmpi, tmp1, tmp0, tmp3, tmp2, tmp5, tmp4, tmp7, tmp6, scalar); \
+ unpack_sc32_8x(tmpi, tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, scalar); \
\
/* store to output */ \
_mm_store ## _al_ ## pd(reinterpret_cast<double *>(output+j+0), tmp0); \
@@ -125,7 +125,7 @@ DECLARE_CONVERTER(sc8_item32_le, 1, fc64, 1, PRIORITY_SIMD){
/* unpack */ \
__m128d tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; \
tmpi = _mm_or_si128(_mm_srli_epi16(tmpi, 8), _mm_slli_epi16(tmpi, 8)); /*byteswap*/\
- unpack_sc32_8x(tmpi, tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, scalar); \
+ unpack_sc32_8x(tmpi, tmp1, tmp0, tmp3, tmp2, tmp5, tmp4, tmp7, tmp6, scalar); \
\
/* store to output */ \
_mm_store ## _al_ ## pd(reinterpret_cast<double *>(output+j+0), tmp0); \
generated by cgit v1.2.3 (git 2.39.1) at 2025-01-06 07:53:46 +0000