uhd

    convert_types.ipp

#include <vector>

 * Convert IO samples to OWT samples + interleave.

 *

 * \param io_buffs buffers containing samples

 * \param io_type the type of these samples

 * \param otw_buff memory to write converted samples

 * \param otw_type the type of these samples

 * \param nsamps_per_io_buff samples per io_buff

 */

UHD_API void convert_io_type_to_otw_type(

    const std::vector<const void *> &io_buffs,

    const io_type_t &io_type,

    void *otw_buff,

    const otw_type_t &otw_type,

    size_t nsamps_per_io_buff

);

/*!

/*!

 * Convert OTW samples to IO samples + de-interleave.

 *

 * \param otw_buff memory containing samples

 * \param otw_type the type of these samples

 * \param io_buffs buffers to write converted samples

 * \param io_type the type of these samples

 * \param nsamps_per_io_buff samples per io_buff

 */

UHD_API void convert_otw_type_to_io_type(

    const void *otw_buff,

    const otw_type_t &otw_type,

    std::vector<void *> &io_buffs,

    const io_type_t &io_type,

    size_t nsamps_per_io_buff

);

#include <uhd/transport/convert_types.ipp>

//

// 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/>.

//

#ifndef INCLUDED_UHD_TRANSPORT_CONVERT_TYPES_IPP

#define INCLUDED_UHD_TRANSPORT_CONVERT_TYPES_IPP

UHD_INLINE void uhd::transport::convert_io_type_to_otw_type(

    const void *io_buff, const io_type_t &io_type,

    void *otw_buff, const otw_type_t &otw_type,

    size_t num_samps

){

    std::vector<const void *> buffs(1, io_buff);

    return uhd::transport::convert_io_type_to_otw_type(

        buffs, io_type, otw_buff, otw_type, num_samps

    );

}

UHD_INLINE void uhd::transport::convert_otw_type_to_io_type(

    const void *otw_buff, const otw_type_t &otw_type,

    void *io_buff, const io_type_t &io_type,

    size_t num_samps

){

    std::vector<void *> buffs(1, io_buff);

    return uhd::transport::convert_otw_type_to_io_type(

        otw_buff, otw_type, buffs, io_type, num_samps

    );

}

#endif /* INCLUDED_UHD_TRANSPORT_CONVERT_TYPES_IPP */

    const otw_type_t &otw_type,

    size_t num_chans

    switch(num_chans){

    case 1: pred |= $ph.chan1_p; break;

    case 2: pred |= $ph.chan2_p; break;

    case 3: pred |= $ph.chan3_p; break;

    case 4: pred |= $ph.chan4_p; break;

    default: throw std::runtime_error("unhandled number of channels");

    }

    const std::vector<const void *> &io_buffs,

    const io_type_t &io_type,

    void *otw_buff,

    const otw_type_t &otw_type,

    size_t nsamps_per_io_buff

    switch(get_pred(io_type, otw_type, io_buffs.size())){

        #set $num_chans = $ph.get_num_chans($pred)

        #set $converter = '_'.join([$in_type, 'to', $out_type])

        #if $num_chans == 1

        $(converter)_$ph.get_swap_type($pred)(

            reinterpret_cast<const $(in_type)_t *>(io_buffs.front()),

            reinterpret_cast<$(out_type)_t *>(otw_buff),

            nsamps_per_io_buff

        );

        #else

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

            #for $j in range($num_chans)

            reinterpret_cast<$(out_type)_t *>(otw_buff)[i*$num_chans + $j] =

                #if $ph.get_swap_type($pred) == 'bswap'

                uhd::byteswap($(converter)(reinterpret_cast<const $(in_type)_t *>(io_buffs[$j])[i]));

                #else

                $(converter)(reinterpret_cast<const $(in_type)_t *>(io_buffs[$j])[i]);

                #end if

            #end for

        }

        #end if

    const void *otw_buff,

    const otw_type_t &otw_type,

    std::vector<void *> &io_buffs,

    const io_type_t &io_type,

    size_t nsamps_per_io_buff

    switch(get_pred(io_type, otw_type, io_buffs.size())){

        #set $num_chans = $ph.get_num_chans($pred)

        #set $converter = '_'.join([$in_type, 'to', $out_type])

        #if $num_chans == 1

        $(converter)_$ph.get_swap_type($pred)(

            reinterpret_cast<const $(in_type)_t *>(otw_buff),

            reinterpret_cast<$(out_type)_t *>(io_buffs.front()),

            nsamps_per_io_buff

        );

        #else

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

            #for $j in range($num_chans)

            reinterpret_cast<$(out_type)_t *>(io_buffs[$j])[i] =

                #if $ph.get_swap_type($pred) == 'bswap'

                $(converter)(uhd::byteswap(reinterpret_cast<const $(in_type)_t *>(otw_buff)[i*$num_chans + $j]));

                #else

                $(converter)(reinterpret_cast<const $(in_type)_t *>(otw_buff)[i*$num_chans + $j]);

                #end if

            #end for

        }

        #end if

    chan1_p  = 0b00000

    chan2_p  = 0b00100

    chan3_p  = 0b01000

    chan4_p  = 0b01100

    nbits = 4 #see above

    def has(pred, mask, flag): return (pred & mask) == flag

        mask = 0b1

        if ph.has(pred, mask, ph.bswap_p): return 'bswap'

        if ph.has(pred, mask, ph.nswap_p): return 'nswap'

        mask = 0b0

        if ph.has(pred, mask, ph.item32_p): return 'item32'

        mask = 0b10

        if ph.has(pred, mask, ph.sc16_p): return 'sc16'

        if ph.has(pred, mask, ph.fc32_p): return 'fc32'

        raise NotImplementedError

    @staticmethod

    def get_num_chans(pred):

        mask = 0b1100

        if ph.has(pred, mask, ph.chan1_p): return 1

        if ph.has(pred, mask, ph.chan2_p): return 2

        if ph.has(pred, mask, ph.chan3_p): return 3

        if ph.has(pred, mask, ph.chan4_p): return 4