uhd

//

// Copyright 2010 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 <uhd/transport/convert_types.hpp>

#include <boost/test/unit_test.hpp>

#include <boost/foreach.hpp>

#include <boost/cstdint.hpp>

#include <boost/asio/buffer.hpp>

#include <complex>

#include <vector>

#include <cstdlib>

using namespace uhd;

//typedefs for complex types

typedef std::complex<boost::int16_t> sc16_t;

typedef std::complex<float> fc32_t;

//extract pointer to POD since using &vector.front() throws in MSVC

template <typename T> void * pod2ptr(T &pod){

    return boost::asio::buffer_cast<void *>(boost::asio::buffer(pod));

}

template <typename T> const void * pod2ptr(const T &pod){

    return boost::asio::buffer_cast<const void *>(boost::asio::buffer(pod));

}

/***********************************************************************

 * Loopback runner:

 *    convert input buffer into intermediate buffer

 *    convert intermediate buffer into output buffer

 **********************************************************************/

template <typename Range> static void loopback(

    size_t nsamps,

    const io_type_t &io_type,

    const otw_type_t &otw_type,

    const Range &input,

    Range &output

){

    //item32 is largest device type

    std::vector<boost::uint32_t> dev(nsamps);

    //convert to dev type

    transport::convert_io_type_to_otw_type(

        pod2ptr(input), io_type,

        pod2ptr(dev), otw_type,

        nsamps

    );

    //convert back to host type

    transport::convert_otw_type_to_io_type(

        pod2ptr(dev), otw_type,

        pod2ptr(output), io_type,

        nsamps

    );

}

/***********************************************************************

 * Test short conversion

 **********************************************************************/

static void test_convert_types_sc16(

    size_t nsamps,

    const io_type_t &io_type,

    const otw_type_t &otw_type

){

    //fill the input samples

    std::vector<sc16_t> input(nsamps), output(nsamps);

    BOOST_FOREACH(sc16_t &in, input) in = sc16_t(

        std::rand()-(RAND_MAX/2),

        std::rand()-(RAND_MAX/2)

    );

    //run the loopback and test

    loopback(nsamps, io_type, otw_type, input, output);

    BOOST_CHECK_EQUAL_COLLECTIONS(input.begin(), input.end(), output.begin(), output.end());

}

BOOST_AUTO_TEST_CASE(test_convert_types_be_sc16){

    io_type_t io_type(io_type_t::COMPLEX_INT16);

    otw_type_t otw_type;

    otw_type.byteorder = otw_type_t::BO_BIG_ENDIAN;

    otw_type.width = 16;

    //try various lengths to test edge cases

    for (size_t nsamps = 0; nsamps < 16; nsamps++){

        test_convert_types_sc16(nsamps, io_type, otw_type);

    }

}

BOOST_AUTO_TEST_CASE(test_convert_types_le_sc16){

    io_type_t io_type(io_type_t::COMPLEX_INT16);

    otw_type_t otw_type;

    otw_type.byteorder = otw_type_t::BO_LITTLE_ENDIAN;

    otw_type.width = 16;

    //try various lengths to test edge cases

    for (size_t nsamps = 0; nsamps < 16; nsamps++){

        test_convert_types_sc16(nsamps, io_type, otw_type);

    }

}

/***********************************************************************

 * Test float conversion

 **********************************************************************/

static void test_convert_types_fc32(

    size_t nsamps,

    const io_type_t &io_type,

    const otw_type_t &otw_type

){

    //fill the input samples

    std::vector<fc32_t> input(nsamps), output(nsamps);

    BOOST_FOREACH(fc32_t &in, input) in = fc32_t(

        (std::rand()/float(RAND_MAX/2)) - 1,

        (std::rand()/float(RAND_MAX/2)) - 1

    );

    //run the loopback and test

    loopback(nsamps, io_type, otw_type, input, output);

    for (size_t i = 0; i < nsamps; i++){

        BOOST_CHECK_CLOSE_FRACTION(input[i].real(), output[i].real(), float(0.01));

        BOOST_CHECK_CLOSE_FRACTION(input[i].imag(), output[i].imag(), float(0.01));

    }

}

BOOST_AUTO_TEST_CASE(test_convert_types_be_fc32){

    io_type_t io_type(io_type_t::COMPLEX_FLOAT32);

    otw_type_t otw_type;

    otw_type.byteorder = otw_type_t::BO_BIG_ENDIAN;

    otw_type.width = 16;

    //try various lengths to test edge cases

    for (size_t nsamps = 0; nsamps < 16; nsamps++){

        test_convert_types_fc32(nsamps, io_type, otw_type);

    }

}

BOOST_AUTO_TEST_CASE(test_convert_types_le_fc32){

    io_type_t io_type(io_type_t::COMPLEX_FLOAT32);

    otw_type_t otw_type;

    otw_type.byteorder = otw_type_t::BO_LITTLE_ENDIAN;

    otw_type.width = 16;

    //try various lengths to test edge cases

    for (size_t nsamps = 0; nsamps < 16; nsamps++){

        test_convert_types_fc32(nsamps, io_type, otw_type);

    }

}

/***********************************************************************

 * Test float to short conversion loopback

 **********************************************************************/

BOOST_AUTO_TEST_CASE(test_convert_types_fc32_to_sc16){

    io_type_t io_type_in(io_type_t::COMPLEX_FLOAT32);

    io_type_t io_type_out(io_type_t::COMPLEX_INT16);

    otw_type_t otw_type;

    otw_type.byteorder = otw_type_t::BO_NATIVE;

    otw_type.width = 16;

    const size_t nsamps = 13;

    std::vector<fc32_t> input(nsamps);

    BOOST_FOREACH(fc32_t &in, input) in = fc32_t(

        (std::rand()/float(RAND_MAX/2)) - 1,

        (std::rand()/float(RAND_MAX/2)) - 1

    );

    //convert float to dev

    std::vector<boost::uint32_t> tmp(nsamps);

    transport::convert_io_type_to_otw_type(

        pod2ptr(input), io_type_in,

        pod2ptr(tmp), otw_type,

        nsamps

    );

    //convert dev to short

    std::vector<sc16_t> output(nsamps);

    transport::convert_otw_type_to_io_type(

        pod2ptr(tmp), otw_type,

        pod2ptr(output), io_type_out,

        nsamps

    );

    //test that the inputs and outputs match

    for (size_t i = 0; i < nsamps; i++){

        BOOST_CHECK_CLOSE_FRACTION(input[i].real(), output[i].real()/float(32767), float(0.01));

        BOOST_CHECK_CLOSE_FRACTION(input[i].imag(), output[i].imag()/float(32767), float(0.01));

    }

}

/***********************************************************************

 * Test short to float conversion loopback

 **********************************************************************/

BOOST_AUTO_TEST_CASE(test_convert_types_sc16_to_fc32){

    io_type_t io_type_in(io_type_t::COMPLEX_INT16);

    io_type_t io_type_out(io_type_t::COMPLEX_FLOAT32);

    otw_type_t otw_type;

    otw_type.byteorder = otw_type_t::BO_NATIVE;

    otw_type.width = 16;

    const size_t nsamps = 13;

    std::vector<sc16_t> input(nsamps);

    BOOST_FOREACH(sc16_t &in, input) in = sc16_t(

        std::rand()-(RAND_MAX/2),

        std::rand()-(RAND_MAX/2)

    );

    //convert short to dev

    std::vector<boost::uint32_t> tmp(nsamps);

    transport::convert_io_type_to_otw_type(

        pod2ptr(input), io_type_in,

        pod2ptr(tmp), otw_type,

        nsamps

    );

    //convert dev to float

    std::vector<fc32_t> output(nsamps);

    transport::convert_otw_type_to_io_type(

        pod2ptr(tmp), otw_type,

        pod2ptr(output), io_type_out,

        nsamps

    );

    //test that the inputs and outputs match

    for (size_t i = 0; i < nsamps; i++){

        BOOST_CHECK_CLOSE_FRACTION(input[i].real()/float(32767), output[i].real(), float(0.01));

        BOOST_CHECK_CLOSE_FRACTION(input[i].imag()/float(32767), output[i].imag(), float(0.01));

    }

}