XTRXInputThread Class Reference

#include <xtrxinputthread.h>

Inheritance diagram for XTRXInputThread:

Collaboration diagram for XTRXInputThread:

Classes
struct	Channel

Public Member Functions
	XTRXInputThread (struct xtrx_dev *dev, unsigned int nbChannels, unsigned int uniqueChannelIndex=0, QObject *parent=0)
	~XTRXInputThread ()
virtual void	startWork ()
virtual void	stopWork ()
virtual bool	isRunning ()
unsigned int	getNbChannels () const
void	setLog2Decimation (unsigned int channel, unsigned int log2_decim)
unsigned int	getLog2Decimation (unsigned int channel) const
void	setFifo (unsigned int channel, SampleSinkFifo *sampleFifo)
SampleSinkFifo *	getFifo (unsigned int channel)

Private Member Functions
void	run ()
unsigned int	getNbFifos ()
void	callbackSI (const qint16 *buf, qint32 len)
void	callbackMI (const qint16 *buf0, const qint16 *buf1, qint32 len)

Private Attributes
QMutex	m_startWaitMutex
QWaitCondition	m_startWaiter
bool	m_running
struct xtrx_dev *	m_dev
Channel *	m_channels
	Array of channels dynamically allocated for the given number of Rx channels. More...
unsigned int	m_nbChannels
unsigned int	m_uniqueChannelIndex

Detailed Description

Definition at line 34 of file xtrxinputthread.h.

Constructor & Destructor Documentation

XTRXInputThread()

XTRXInputThread::XTRXInputThread	(	struct xtrx_dev *	dev,
		unsigned int	nbChannels,
		unsigned int	uniqueChannelIndex = 0,
		QObject *	parent = 0
	)

Definition at line 27 of file xtrxinputthread.cpp.

References DeviceXTRX::blockSize, i, m_channels, and XTRXInputThread::Channel::m_convertBuffer.

                                                                                                                                :
    QThread(parent),
    m_running(false),
    m_dev(dev),
    m_nbChannels(nbChannels),
    m_uniqueChannelIndex(uniqueChannelIndex)
{
    qDebug("XTRXInputThread::XTRXInputThread: nbChannels: %u uniqueChannelIndex: %u", nbChannels, uniqueChannelIndex);
    m_channels = new Channel[2];

    for (unsigned int i = 0; i < 2; i++) {
        m_channels[i].m_convertBuffer.resize(DeviceXTRX::blockSize, Sample{0,0});
    }
}

~XTRXInputThread()

XTRXInputThread::~XTRXInputThread

(

)

Definition at line 42 of file xtrxinputthread.cpp.

References m_channels, m_running, and stopWork().

{
    qDebug("XTRXInputThread::~XTRXInputThread");

    if (m_running) {
        stopWork();
    }

    delete[] m_channels;
}

Here is the call graph for this function:

Member Function Documentation

callbackMI()

void XTRXInputThread::callbackMI ( const qint16 *  buf0, const qint16 *  buf1, qint32  len  )

private

Definition at line 264 of file xtrxinputthread.cpp.

References callbackSI(), and m_uniqueChannelIndex.

Referenced by run().

{
    unsigned int uniqueChannelIndex = m_uniqueChannelIndex;

    // channel 0
    m_uniqueChannelIndex = 0;
    callbackSI(buf0, len);
    // channel 1
    m_uniqueChannelIndex = 1;
    callbackSI(buf1, len);

    m_uniqueChannelIndex = uniqueChannelIndex;
}

Here is the call graph for this function:

Here is the caller graph for this function:

callbackSI()

void XTRXInputThread::callbackSI ( const qint16 *  buf, qint32  len  )

private

Definition at line 226 of file xtrxinputthread.cpp.

References Decimators< StorageType, T, SdrBits, InputBits >::decimate1(), Decimators< StorageType, T, SdrBits, InputBits >::decimate16_cen(), Decimators< StorageType, T, SdrBits, InputBits >::decimate2_cen(), Decimators< StorageType, T, SdrBits, InputBits >::decimate32_cen(), Decimators< StorageType, T, SdrBits, InputBits >::decimate4_cen(), Decimators< StorageType, T, SdrBits, InputBits >::decimate64_cen(), Decimators< StorageType, T, SdrBits, InputBits >::decimate8_cen(), m_channels, XTRXInputThread::Channel::m_convertBuffer, XTRXInputThread::Channel::m_decimators, XTRXInputThread::Channel::m_sampleFifo, m_uniqueChannelIndex, and SampleSinkFifo::write().

Referenced by callbackMI(), and run().

{
    SampleVector::iterator it = m_channels[m_uniqueChannelIndex].m_convertBuffer.begin();

    if (m_channels[m_uniqueChannelIndex].m_log2Decim == 0)
    {
        m_channels[m_uniqueChannelIndex].m_decimators.decimate1(&it, buf, len);
    }
    else
    {
        switch (m_channels[m_uniqueChannelIndex].m_log2Decim)
        {
        case 1:
            m_channels[m_uniqueChannelIndex].m_decimators.decimate2_cen(&it, buf, len);
            break;
        case 2:
            m_channels[m_uniqueChannelIndex].m_decimators.decimate4_cen(&it, buf, len);
            break;
        case 3:
            m_channels[m_uniqueChannelIndex].m_decimators.decimate8_cen(&it, buf, len);
            break;
        case 4:
            m_channels[m_uniqueChannelIndex].m_decimators.decimate16_cen(&it, buf, len);
            break;
        case 5:
            m_channels[m_uniqueChannelIndex].m_decimators.decimate32_cen(&it, buf, len);
            break;
        case 6:
            m_channels[m_uniqueChannelIndex].m_decimators.decimate64_cen(&it, buf, len);
            break;
        default:
            break;
        }
    }

    m_channels[m_uniqueChannelIndex].m_sampleFifo->write(m_channels[m_uniqueChannelIndex].m_convertBuffer.begin(), it);
}

Here is the call graph for this function:

Here is the caller graph for this function:

getFifo()

SampleSinkFifo * XTRXInputThread::getFifo

(

unsigned int

channel

)

Definition at line 217 of file xtrxinputthread.cpp.

References m_channels, and XTRXInputThread::Channel::m_sampleFifo.

Referenced by getNbChannels(), and XTRXInput::start().

{
    if (channel < 2) {
        return m_channels[channel].m_sampleFifo;
    } else {
        return 0;
    }
}

Here is the caller graph for this function:

getLog2Decimation()

unsigned int XTRXInputThread::getLog2Decimation

(

unsigned int

channel

)

const

Definition at line 201 of file xtrxinputthread.cpp.

References m_channels, and XTRXInputThread::Channel::m_log2Decim.

Referenced by getNbChannels(), and XTRXInput::start().

{
    if (channel < 2) {
        return m_channels[channel].m_log2Decim;
    } else {
        return 0;
    }
}

Here is the caller graph for this function:

getNbChannels()

unsigned int XTRXInputThread::getNbChannels ( ) const

inline

Definition at line 45 of file xtrxinputthread.h.

References getFifo(), getLog2Decimation(), m_nbChannels, setFifo(), and setLog2Decimation().

Referenced by XTRXInput::start(), and XTRXInput::stop().

{ return m_nbChannels; }

Here is the call graph for this function:

Here is the caller graph for this function:

getNbFifos()

unsigned int XTRXInputThread::getNbFifos ( )

private

Definition at line 180 of file xtrxinputthread.cpp.

References i, and m_channels.

Referenced by run().

{
    unsigned int fifoCount = 0;

    for (unsigned int i = 0; i < 2; i++)
    {
        if (m_channels[i].m_sampleFifo) {
            fifoCount++;
        }
    }

    return fifoCount;
}

Here is the caller graph for this function:

isRunning()

virtual bool XTRXInputThread::isRunning ( )

inlinevirtual

Implements DeviceXTRXShared::ThreadInterface.

Definition at line 44 of file xtrxinputthread.h.

References m_running.

Referenced by XTRXInput::applySettings().

{ return m_running; }

Here is the caller graph for this function:

run()

void XTRXInputThread::run ( )

private

Definition at line 80 of file xtrxinputthread.cpp.

References DeviceXTRX::blockSize, callbackMI(), callbackSI(), getNbFifos(), i, m_dev, m_nbChannels, m_running, m_startWaiter, and m_uniqueChannelIndex.

{
    int res;

    m_running = true;
    m_startWaiter.wakeAll();

    unsigned int nbFifos = getNbFifos();

    if ((m_nbChannels != 0) && (nbFifos != 0))
    {
        xtrx_run_params params;
        xtrx_run_params_init(&params);

        params.dir = XTRX_RX;
        params.rx.chs = XTRX_CH_AB;
        params.rx.wfmt = XTRX_WF_16;
        params.rx.hfmt = XTRX_IQ_INT16;
        params.rx_stream_start = 2*DeviceXTRX::blockSize; // was 2*8192
        params.rx.paketsize = 2*DeviceXTRX::blockSize;

        if (m_nbChannels == 1)
        {
            qDebug("XTRXInputThread::run: SI mode for channel #%u", m_uniqueChannelIndex);
            params.rx.flags |= XTRX_RSP_SISO_MODE;

            if (m_uniqueChannelIndex == 1) {
                params.rx.flags |= XTRX_RSP_SWAP_AB;
            }
        }

        res = xtrx_run_ex(m_dev, &params);

        if (res != 0)
        {
            qCritical("XTRXInputThread::run: could not start stream err:%d", res);
            m_running = false;
        }
        else
        {
            std::this_thread::sleep_for(std::chrono::milliseconds(50));
            qDebug("XTRXInputThread::run: stream started");
        }

        const unsigned int elemSize = 4; // XTRX uses 4 byte I+Q samples
        std::vector<std::vector<char>> buffMem(m_nbChannels, std::vector<char>(elemSize*DeviceXTRX::blockSize));
        std::vector<void *> buffs(m_nbChannels);

        for (std::size_t i = 0; i < m_nbChannels; i++) {
            buffs[i] = buffMem[i].data();
        }

        xtrx_recv_ex_info_t nfo;
        nfo.samples = DeviceXTRX::blockSize;
        nfo.buffer_count = m_nbChannels;
        nfo.buffers = (void* const*) buffs.data();
        nfo.flags = RCVEX_DONT_INSER_ZEROS | RCVEX_DROP_OLD_ON_OVERFLOW;

        while (m_running)
        {
            res = xtrx_recv_sync_ex(m_dev, &nfo);

            if (res < 0)
            {
                qCritical("XTRXInputThread::run read error: %d", res);
                qDebug("XTRXInputThread::run: out_samples: %u out_events: %u", nfo.out_samples, nfo.out_events);
                break;
            }

            if (nfo.out_events & RCVEX_EVENT_OVERFLOW) {
                qDebug("XTRXInputThread::run: overflow");
            }

            if (m_nbChannels > 1) {
                callbackMI((const qint16*) buffs[0], (const qint16*) buffs[1], 2 * nfo.out_samples);
            } else {
                callbackSI((const qint16*) buffs[0], 2 * nfo.out_samples);
            }
        }

        res = xtrx_stop(m_dev, XTRX_RX);

        if (res != 0)
        {
            qCritical("XTRXInputThread::run: could not stop stream");
        }
        else
        {
            std::this_thread::sleep_for(std::chrono::milliseconds(50));
            qDebug("XTRXInputThread::run: stream stopped");
        }
    }
    else
    {
        qWarning("XTRXInputThread::run: no channels or FIFO allocated. Aborting");
    }

    m_running = false;
}

Here is the call graph for this function:

setFifo()

void XTRXInputThread::setFifo	(	unsigned int	channel,
		SampleSinkFifo *	sampleFifo
	)

Definition at line 210 of file xtrxinputthread.cpp.

References m_channels, and XTRXInputThread::Channel::m_sampleFifo.

Referenced by getNbChannels(), XTRXInput::start(), and XTRXInput::stop().

{
    if (channel < 2) {
        m_channels[channel].m_sampleFifo = sampleFifo;
    }
}

Here is the caller graph for this function:

setLog2Decimation()

void XTRXInputThread::setLog2Decimation	(	unsigned int	channel,
		unsigned int	log2_decim
	)

Definition at line 194 of file xtrxinputthread.cpp.

References m_channels, and XTRXInputThread::Channel::m_log2Decim.

Referenced by XTRXInput::applySettings(), getNbChannels(), XTRXInput::start(), and XTRXInput::stop().

{
    if (channel < 2) {
        m_channels[channel].m_log2Decim = log2_decim;
    }
}

Here is the caller graph for this function:

startWork()

void XTRXInputThread::startWork ( )

virtual

Implements DeviceXTRXShared::ThreadInterface.

Definition at line 53 of file xtrxinputthread.cpp.

References m_running, m_startWaiter, and m_startWaitMutex.

Referenced by XTRXInput::applySettings(), XTRXInput::start(), and XTRXInput::stop().

{
    if (m_running) {
        return; // return if running already
    }

    m_startWaitMutex.lock();
    start();

    while (!m_running) {
        m_startWaiter.wait(&m_startWaitMutex, 100);
    }

    m_startWaitMutex.unlock();
}

Here is the caller graph for this function:

stopWork()

void XTRXInputThread::stopWork ( )

virtual

Implements DeviceXTRXShared::ThreadInterface.

Definition at line 69 of file xtrxinputthread.cpp.

References m_running.

Referenced by XTRXInput::applySettings(), XTRXInput::start(), XTRXInput::stop(), and ~XTRXInputThread().

{
    if (!m_running) {
        return; // return if not running
    }

    m_running = false;
    wait();
}

Here is the caller graph for this function:

Member Data Documentation

m_channels

Channel* XTRXInputThread::m_channels

private

Array of channels dynamically allocated for the given number of Rx channels.

Definition at line 73 of file xtrxinputthread.h.

Referenced by callbackSI(), getFifo(), getLog2Decimation(), getNbFifos(), setFifo(), setLog2Decimation(), XTRXInputThread(), and ~XTRXInputThread().

m_dev

struct xtrx_dev* XTRXInputThread::m_dev

private

Definition at line 71 of file xtrxinputthread.h.

Referenced by run().

m_nbChannels

unsigned int XTRXInputThread::m_nbChannels

private

Definition at line 74 of file xtrxinputthread.h.

Referenced by getNbChannels(), and run().

m_running

bool XTRXInputThread::m_running

private

Definition at line 70 of file xtrxinputthread.h.

Referenced by isRunning(), run(), startWork(), stopWork(), and ~XTRXInputThread().

m_startWaiter

QWaitCondition XTRXInputThread::m_startWaiter

private

Definition at line 69 of file xtrxinputthread.h.

Referenced by run(), and startWork().

m_startWaitMutex

QMutex XTRXInputThread::m_startWaitMutex

private

Definition at line 68 of file xtrxinputthread.h.

Referenced by startWork().

m_uniqueChannelIndex

unsigned int XTRXInputThread::m_uniqueChannelIndex

private

Definition at line 75 of file xtrxinputthread.h.

Referenced by callbackMI(), callbackSI(), and run().

---

The documentation for this class was generated from the following files:

• plugins/samplesource/xtrxinput/xtrxinputthread.h
• plugins/samplesource/xtrxinput/xtrxinputthread.cpp