662 lines
17 KiB
C++
662 lines
17 KiB
C++
/**
|
|
* @file cusdr_dataIO.cpp
|
|
* @brief Data IO class
|
|
* @author Hermann von Hasseln, DL3HVH
|
|
* @version 0.1
|
|
* @date 2011-10-01
|
|
*/
|
|
|
|
/*
|
|
* Copyright 2011 Hermann von Hasseln, DL3HVH
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU Library General Public License version 2 as
|
|
* published by the Free Software Foundation
|
|
*
|
|
* 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 Library General Public
|
|
* License along with this program; if not, write to the
|
|
* Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#define LOG_DATAIO
|
|
|
|
#include "cusdr_dataIO.h"
|
|
#include "soundout.h"
|
|
|
|
#if defined(Q_OS_WIN32)
|
|
#include <winsock2.h>
|
|
#endif
|
|
#include <iostream>
|
|
using namespace std;
|
|
|
|
|
|
DataIO::DataIO(THPSDRParameter *ioData)
|
|
: QObject()
|
|
, set(Settings::instance())
|
|
, io(ioData)
|
|
, m_dataIOSocketOn(false)
|
|
, m_setNetworkDeviceHeader(true)
|
|
, m_sequence(0)
|
|
, m_oldSequence(-1)
|
|
, m_sequenceWideBand(0)
|
|
, m_oldSequenceWideBand(-1)
|
|
, m_wbBuffers(set->getWidebandBuffers() - 1)
|
|
, m_wbCount(0)
|
|
, m_socketBufferSize(set->getSocketBufferSize())
|
|
, m_sendEP4(false)
|
|
, m_manualBufferSize(set->getManualSocketBufferSize())
|
|
, m_packetsToggle(true)
|
|
, m_firstFrame(true)
|
|
, m_stopped(false)
|
|
{
|
|
m_dataIOSocket = 0;
|
|
|
|
m_metisGetDataSignature.resize(3);
|
|
m_metisGetDataSignature[0] = (char)0xEF;
|
|
m_metisGetDataSignature[1] = (char)0xFE;
|
|
m_metisGetDataSignature[2] = (char)0x01;
|
|
//m_metisGetDataSignature[3] = (char)0x06;
|
|
|
|
m_datagram.resize(1032);
|
|
m_wbDatagram.resize(0);
|
|
m_twoFramesDatagram.resize(0);
|
|
|
|
m_sendSequence = 0L;
|
|
m_oldSendSequence = 0L;
|
|
|
|
m_deviceSendDataSignature.resize(4);
|
|
m_deviceSendDataSignature[0] = (char)0xEF;
|
|
m_deviceSendDataSignature[1] = (char)0xFE;
|
|
m_deviceSendDataSignature[2] = (char)0x01;
|
|
m_deviceSendDataSignature[3] = (char)0x02;
|
|
|
|
m_packetLossTime.start();
|
|
|
|
CHECKED_CONNECT(
|
|
set,
|
|
SIGNAL(sampleRateChanged(QObject *, int)),
|
|
this,
|
|
SLOT(setSampleRate(QObject *, int)));
|
|
|
|
CHECKED_CONNECT(
|
|
set,
|
|
SIGNAL(manualSocketBufferChanged(QObject*, bool)),
|
|
this,
|
|
SLOT(setManualSocketBufferSize(QObject*, bool)));
|
|
|
|
CHECKED_CONNECT(
|
|
set,
|
|
SIGNAL(socketBufferSizeChanged(QObject*, int)),
|
|
this,
|
|
SLOT(setSocketBufferSize(QObject*, int)));
|
|
|
|
m_message = "m_sendSequence = %1, bytes sent: %2";
|
|
|
|
m_pSoundCardOut = new CSoundOut(this);
|
|
//RRK pass -1 to get the systems "default" audio device
|
|
m_pSoundCardOut->Start(-1, true, 48000, false);
|
|
m_pSoundCardOut->SetVolume(80);
|
|
}
|
|
|
|
DataIO::~DataIO() {
|
|
|
|
if (m_dataIOSocketOn) {
|
|
m_dataIOSocket->close();
|
|
delete m_dataIOSocket;
|
|
m_dataIOSocket = 0;
|
|
}
|
|
}
|
|
|
|
void DataIO::stop() {
|
|
|
|
io->networkIOMutex.lock();
|
|
m_stopped = true;
|
|
io->networkIOMutex.unlock();
|
|
|
|
if(m_pSoundCardOut) {
|
|
m_pSoundCardOut->Stop();
|
|
delete m_pSoundCardOut;
|
|
}
|
|
}
|
|
|
|
void DataIO::initDataReceiverSocket() {
|
|
|
|
m_dataIOSocket = new QUdpSocket();
|
|
|
|
int newBufferSize;
|
|
|
|
if (m_manualBufferSize) {
|
|
|
|
newBufferSize = m_socketBufferSize * 1024;//m_socketBufferSize * 1032;
|
|
io->networkIOMutex.lock();
|
|
DATAIO_DEBUG << "initDataReceiverSocket socket buffer size set to " << m_socketBufferSize << " kB.";
|
|
io->networkIOMutex.unlock();
|
|
}
|
|
else {
|
|
|
|
if (io->samplerate == 384000) {
|
|
|
|
newBufferSize = 128*1024;//128 * 1032;
|
|
io->networkIOMutex.lock();
|
|
DATAIO_DEBUG << "socket buffer size set to 128 kB.";
|
|
io->networkIOMutex.unlock();
|
|
}
|
|
else if (io->samplerate == 192000) {
|
|
|
|
newBufferSize = 64*1024;//64 * 1032;
|
|
io->networkIOMutex.lock();
|
|
DATAIO_DEBUG << "socket buffer size set to 64 kB.";
|
|
io->networkIOMutex.unlock();
|
|
}
|
|
else if (io->samplerate == 96000) {
|
|
|
|
newBufferSize = 32*1024;//32 * 1032;
|
|
io->networkIOMutex.lock();
|
|
DATAIO_DEBUG << "socket buffer size set to 32 kB.";
|
|
io->networkIOMutex.unlock();
|
|
}
|
|
else if (io->samplerate == 48000) {
|
|
|
|
newBufferSize = 16*1024;//16 * 1032;
|
|
io->networkIOMutex.lock();
|
|
DATAIO_DEBUG << "socket buffer size set to 16 kB.";
|
|
io->networkIOMutex.unlock();
|
|
}
|
|
}
|
|
|
|
if (m_dataIOSocket->bind(QHostAddress(set->getHPSDRDeviceLocalAddr()),
|
|
set->getMetisPort(),
|
|
QUdpSocket::DontShareAddress))
|
|
//QUdpSocket::ReuseAddressHint | QUdpSocket::ShareAddress))
|
|
{
|
|
|
|
#if defined(Q_OS_WIN32)
|
|
if (::setsockopt(m_dataIOSocket->socketDescriptor(), SOL_SOCKET,
|
|
SO_RCVBUF, (char *)&newBufferSize, sizeof(newBufferSize)) == -1) {
|
|
|
|
io->networkIOMutex.lock();
|
|
DATAIO_DEBUG << "dataIOSocket error!";
|
|
io->networkIOMutex.unlock();
|
|
}
|
|
#endif
|
|
|
|
|
|
//m_dataIOSocket->setSocketOption(QAbstractSocket::LowDelayOption, 1);
|
|
//m_dataIOSocket->setSocketOption(QAbstractSocket::KeepAliveOption, 1);
|
|
|
|
CHECKED_CONNECT(
|
|
m_dataIOSocket,
|
|
SIGNAL(error(QAbstractSocket::SocketError)),
|
|
this,
|
|
SLOT(displayDataReceiverSocketError(QAbstractSocket::SocketError)));
|
|
|
|
/*CHECKED_CONNECT_OPT(
|
|
m_dataIOSocket,
|
|
SIGNAL(readyRead()),
|
|
this,
|
|
SLOT(readDeviceData()),
|
|
Qt::DirectConnection);*/
|
|
|
|
CHECKED_CONNECT(
|
|
m_dataIOSocket,
|
|
SIGNAL(readyRead()),
|
|
this,
|
|
SLOT(readDeviceData()));
|
|
|
|
|
|
io->networkIOMutex.lock();
|
|
DATAIO_DEBUG << "data receiver socket bound successful to local port " << m_dataIOSocket->localPort();
|
|
io->networkIOMutex.unlock();
|
|
|
|
m_dataIOSocketOn = true;
|
|
set->setPacketLoss(1);
|
|
}
|
|
else {
|
|
|
|
io->networkIOMutex.lock();
|
|
DATAIO_DEBUG << "data receiver socket binding failed.";
|
|
io->networkIOMutex.unlock();
|
|
|
|
m_dataIOSocketOn = false;
|
|
}
|
|
}
|
|
|
|
void DataIO::readDeviceData() {
|
|
|
|
while (m_dataIOSocket->hasPendingDatagrams()) {
|
|
|
|
QMutexLocker locker(&io->networkIOMutex);
|
|
if (m_dataIOSocket->readDatagram(m_datagram.data(), m_datagram.size()) == METIS_DATA_SIZE) {
|
|
|
|
if (m_datagram.left(3) == m_metisGetDataSignature) {
|
|
|
|
if (m_datagram[3] == (char)0x06) {
|
|
|
|
m_sequence = (m_datagram[4] & 0xFF) << 24;
|
|
m_sequence += (m_datagram[5] & 0xFF) << 16;
|
|
m_sequence += (m_datagram[6] & 0xFF) << 8;
|
|
m_sequence += (m_datagram[7] & 0xFF);
|
|
|
|
if (m_sequence != m_oldSequence + 1) {
|
|
|
|
//DATAIO_DEBUG << "readData missed " << m_sequence - m_oldSequence << " packages.";
|
|
//RRK cout << "readData missed " << m_sequence - m_oldSequence << " packages." << endl;
|
|
|
|
if (m_packetLossTime.elapsed() > 100) {
|
|
|
|
set->setPacketLoss(2);
|
|
m_packetLossTime.restart();
|
|
}
|
|
}
|
|
|
|
m_oldSequence = m_sequence;
|
|
|
|
//// enqueue first half of the HPSDR frame from the HPSDR device
|
|
//io->iq_queue.enqueue(m_datagram.mid(METIS_HEADER_SIZE, BUFFER_SIZE/2));
|
|
//// enqueue second half of the HPSDR frame from the HPSDR device
|
|
//io->iq_queue.enqueue(m_datagram.right(BUFFER_SIZE/2));
|
|
|
|
// enqueue one frame from the HPSDR device
|
|
if (!io->iq_queue.isFull()) {
|
|
io->iq_queue.enqueue(m_datagram.mid(METIS_HEADER_SIZE, BUFFER_SIZE));
|
|
}
|
|
|
|
// collect two HPSDR frames
|
|
//if (m_firstFrame) {
|
|
|
|
// m_twoFramesDatagram += m_datagram.mid(METIS_HEADER_SIZE, BUFFER_SIZE);
|
|
// m_firstFrame = false;
|
|
//}
|
|
//else {
|
|
|
|
// m_twoFramesDatagram += m_datagram.mid(METIS_HEADER_SIZE, BUFFER_SIZE);
|
|
|
|
// //enqueue the two frames
|
|
// io->iq_queue.enqueue(m_twoFramesDatagram);
|
|
// m_firstFrame = true;
|
|
|
|
// m_twoFramesDatagram.resize(0);
|
|
//}
|
|
}
|
|
else if (m_datagram[3] == (char)0x04) { // wide band data
|
|
|
|
//qDebug() << "wideband data received!";
|
|
m_sequenceWideBand = (m_datagram[4] & 0xFF) << 24;
|
|
m_sequenceWideBand += (m_datagram[5] & 0xFF) << 16;
|
|
m_sequenceWideBand += (m_datagram[6] & 0xFF) << 8;
|
|
m_sequenceWideBand += (m_datagram[7] & 0xFF);
|
|
|
|
if (m_sequenceWideBand != m_oldSequenceWideBand + 1) {
|
|
|
|
DATAIO_DEBUG << "wideband readData missed " << m_sequenceWideBand - m_oldSequenceWideBand << " packages.";
|
|
|
|
if (m_packetLossTime.elapsed() > 100) {
|
|
|
|
set->setPacketLoss(2);
|
|
m_packetLossTime.restart();
|
|
}
|
|
}
|
|
|
|
m_oldSequenceWideBand = m_sequenceWideBand;
|
|
|
|
// three 'if's from KISS Konsole
|
|
if ((m_wbBuffers & m_datagram[7]) == 0)
|
|
{
|
|
m_sendEP4 = true;
|
|
m_wbCount = 0;
|
|
}
|
|
|
|
if (m_sendEP4)
|
|
{
|
|
m_wbDatagram.append(m_datagram.mid(METIS_HEADER_SIZE, BUFFER_SIZE));
|
|
}
|
|
|
|
if (m_wbCount++ == m_wbBuffers)
|
|
{
|
|
// enqueue
|
|
m_sendEP4 = false;
|
|
io->wb_queue.enqueue(m_wbDatagram);
|
|
m_wbDatagram.resize(0);
|
|
}
|
|
}
|
|
}
|
|
//DATA_RECEIVER_DEBUG << "got wrong HPSDR device signature!";
|
|
}
|
|
//DATA_RECEIVER_DEBUG << "got wrong HPSDR device data size!";
|
|
}
|
|
//DATA_RECEIVER_DEBUG << "no more pending datagrams.";
|
|
}
|
|
|
|
void DataIO::readData() {
|
|
|
|
qint64 length = io->inputBuffer.length();
|
|
|
|
//int buffers = qRound(length/(2*BUFFER_SIZE));
|
|
int buffers = qRound((float) length/128);
|
|
|
|
DATAIO_DEBUG << "input buffer length " << length << " buffers " << buffers;
|
|
|
|
while (!m_stopped) {
|
|
|
|
for (int i = 0; i < buffers; i++) {
|
|
|
|
//io->data_queue.enqueue(io->inputBuffer.mid(i*2*BUFFER_SIZE, 2*BUFFER_SIZE));
|
|
io->data_queue.enqueue(io->inputBuffer.mid(i*128, 128));
|
|
if (m_stopped) break;
|
|
}
|
|
}
|
|
m_stopped = false;
|
|
}
|
|
|
|
void DataIO::sendInitFramesToNetworkDevice(int rx) {
|
|
|
|
QByteArray initDatagram;
|
|
initDatagram.resize(1032);
|
|
|
|
initDatagram[0] = (char)0xEF;
|
|
initDatagram[1] = (char)0xFE;
|
|
initDatagram[2] = (char)0x01;
|
|
initDatagram[3] = (char)0x02;
|
|
initDatagram[4] = (char)0x00;
|
|
initDatagram[5] = (char)0x00;
|
|
initDatagram[6] = (char)0x00;
|
|
initDatagram[7] = (char)0x00;
|
|
|
|
initDatagram[8] = SYNC;
|
|
initDatagram[9] = SYNC;
|
|
initDatagram[10] = SYNC;
|
|
|
|
for (int i = 0; i < 5; i++) {
|
|
|
|
initDatagram[i + 11] = io->control_out[i];
|
|
}
|
|
|
|
for (int i = 16; i < 520; i++) {
|
|
|
|
initDatagram[i] = 0x00;
|
|
}
|
|
|
|
initDatagram[520] = SYNC;
|
|
initDatagram[521] = SYNC;
|
|
initDatagram[522] = SYNC;
|
|
|
|
initDatagram[523] = io->control_out[0] | ((rx + 2) << 1);
|
|
initDatagram[524] = set->getCtrFrequencies().at(rx) >> 24;
|
|
initDatagram[525] = set->getCtrFrequencies().at(rx) >> 16;
|
|
initDatagram[526] = set->getCtrFrequencies().at(rx) >> 8;
|
|
initDatagram[527] = set->getCtrFrequencies().at(rx) ;
|
|
|
|
|
|
for (int i = 528; i < 1032; i++) initDatagram[i] = 0x00;
|
|
|
|
// for (int i = 0; i < 5; i++) {
|
|
//
|
|
// if (m_dataIOSocket->writeDatagram(initDatagram.data(), initDatagram.size(), io->hpsdrDeviceIPAddress, DEVICE_PORT) < 0) {
|
|
//
|
|
// io->networkIOMutex.lock();
|
|
// DATAIO_DEBUG << "error sending init data to device: " << qPrintable(m_dataIOSocket->errorString());
|
|
// io->networkIOMutex.unlock();
|
|
// }
|
|
// else {
|
|
//
|
|
// if (i == 0) {
|
|
//
|
|
// io->networkIOMutex.lock();
|
|
// DATAIO_DEBUG << "init frames sent to network device.";
|
|
// io->networkIOMutex.unlock();
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
if (m_dataIOSocket->writeDatagram(initDatagram.data(), initDatagram.size(), io->hpsdrDeviceIPAddress, DEVICE_PORT) < 0) {
|
|
|
|
io->networkIOMutex.lock();
|
|
DATAIO_DEBUG << "error sending init data to device: " << qPrintable(m_dataIOSocket->errorString());
|
|
io->networkIOMutex.unlock();
|
|
}
|
|
else {
|
|
|
|
io->networkIOMutex.lock();
|
|
DATAIO_DEBUG << "init frames sent to network device.";
|
|
io->networkIOMutex.unlock();
|
|
}
|
|
|
|
SleeperThread::msleep(20);
|
|
|
|
if (m_dataIOSocket->writeDatagram(initDatagram.data(), initDatagram.size(), io->hpsdrDeviceIPAddress, DEVICE_PORT) < 0) {
|
|
|
|
io->networkIOMutex.lock();
|
|
DATAIO_DEBUG << "error sending init data to device: " << qPrintable(m_dataIOSocket->errorString());
|
|
io->networkIOMutex.unlock();
|
|
}
|
|
else {
|
|
|
|
io->networkIOMutex.lock();
|
|
DATAIO_DEBUG << "init frames sent to network device.";
|
|
io->networkIOMutex.unlock();
|
|
}
|
|
}
|
|
|
|
void DataIO::networkDeviceStartStop(char value) {
|
|
|
|
TNetworkDevicecard metis = set->getCurrentMetisCard();
|
|
//QUdpSocket socket;
|
|
|
|
// if (socket.bind(QHostAddress(set->getHPSDRDeviceLocalAddr()),
|
|
// set->getMetisPort(),
|
|
// //QUdpSocket::DefaultForPlatform))
|
|
// QUdpSocket::ReuseAddressHint | QUdpSocket::ShareAddress))
|
|
// {
|
|
//DATAIO_DEBUG << "device start/stop: socket bound successful to local port " << set->getMetisPort();
|
|
|
|
m_commandDatagram.resize(64);
|
|
m_commandDatagram[0] = (char)0xEF;
|
|
m_commandDatagram[1] = (char)0xFE;
|
|
m_commandDatagram[2] = (char)0x04;
|
|
m_commandDatagram[3] = (char)value;
|
|
|
|
for (int i = 4; i < 64; i++) m_commandDatagram[i] = 0x00;
|
|
|
|
if (m_dataIOSocket->writeDatagram(m_commandDatagram, metis.ip_address, DEVICE_PORT) == 64) {
|
|
|
|
//if (value == 1) {
|
|
if (value != 0) {
|
|
|
|
io->networkIOMutex.lock();
|
|
DATAIO_DEBUG << "sent start command to device at: "<< qPrintable(metis.ip_address.toString());
|
|
io->networkIOMutex.unlock();
|
|
m_networkDeviceRunning = true;
|
|
}
|
|
else {
|
|
|
|
//DATA_ENGINE_DEBUG << "sent stop command to Metis at"<< m_metisCards[0].ip_address.toString();
|
|
io->networkIOMutex.lock();
|
|
DATAIO_DEBUG << "sent stop command to device at: "<< qPrintable(metis.ip_address.toString());
|
|
io->networkIOMutex.unlock();
|
|
m_networkDeviceRunning = false;
|
|
}
|
|
}
|
|
else
|
|
DATAIO_DEBUG << "device start/stop: sending command to device failed.";
|
|
|
|
//socket.close();
|
|
// }
|
|
// else {
|
|
//
|
|
// DATAIO_DEBUG << "device start/stop: socket binding failed.";
|
|
// }
|
|
|
|
// socket.close();
|
|
// DATAIO_DEBUG << "device start/stop: socket closed.";
|
|
}
|
|
|
|
void DataIO::sendAudio(u_char *buf) {
|
|
//RRK send audio bytes here
|
|
static TYPECPX cbuf[252];
|
|
int i, j;
|
|
short sample;
|
|
|
|
for(i = 8, j = 0; i < 512; i += 8, j++) {
|
|
//bytes are L,R,I,Q skip the I,Q
|
|
sample = buf[i] << 8 | buf[i+1]; //left
|
|
cbuf[j].re = (double)sample;
|
|
sample = buf[i+2] << 8 | buf[i+3]; //right
|
|
cbuf[j].im = (double)sample;
|
|
}
|
|
|
|
if((m_stopped != true) && m_pSoundCardOut)
|
|
m_pSoundCardOut->PutOutQueue(63, cbuf);
|
|
}
|
|
|
|
void DataIO::writeData() {
|
|
|
|
if (m_setNetworkDeviceHeader) {
|
|
|
|
m_outDatagram.resize(0);
|
|
m_outDatagram += m_deviceSendDataSignature;
|
|
|
|
QByteArray seq(reinterpret_cast<const char*>(&m_sendSequence), sizeof(m_sendSequence));
|
|
|
|
m_outDatagram += seq;
|
|
m_outDatagram += io->audioDatagram;
|
|
|
|
m_sendSequence++;
|
|
m_setNetworkDeviceHeader = false;
|
|
}
|
|
else {
|
|
|
|
m_outDatagram += io->audioDatagram;
|
|
|
|
if (m_dataIOSocket->writeDatagram(m_outDatagram, set->getCurrentMetisCard().ip_address, DEVICE_PORT) < 0) {
|
|
DATAIO_DEBUG << "error sending data to device: " << m_dataIOSocket->errorString();
|
|
}
|
|
|
|
//if (m_sendSequence%100 == 0)
|
|
// DATAIO_DEBUG << m_sendSequence;
|
|
|
|
if (m_sendSequence != m_oldSendSequence + 1) {
|
|
DATAIO_DEBUG << "output sequence error: old = " << m_oldSendSequence << "; new =" << m_sendSequence;
|
|
}
|
|
|
|
m_oldSendSequence = m_sendSequence;
|
|
m_setNetworkDeviceHeader = true;
|
|
}
|
|
}
|
|
|
|
void DataIO::displayDataReceiverSocketError(QAbstractSocket::SocketError error) {
|
|
|
|
io->networkIOMutex.lock();
|
|
DATAIO_DEBUG << "data IO socket error: " << error;
|
|
io->networkIOMutex.unlock();
|
|
}
|
|
|
|
void DataIO::setManualSocketBufferSize(QObject *sender, bool value) {
|
|
|
|
Q_UNUSED (sender)
|
|
|
|
m_manualBufferSize = value;
|
|
DATAIO_DEBUG << "m_manualBufferSize to change = " << m_manualBufferSize;
|
|
int socketBufferSize = 1032 * set->getSocketBufferSize();
|
|
|
|
io->networkIOMutex.lock();
|
|
|
|
if (m_manualBufferSize) {
|
|
|
|
DATAIO_DEBUG << "set data IO socket BufferSize to " << m_socketBufferSize;
|
|
#if defined(Q_OS_WIN32)
|
|
if (::setsockopt(m_dataIOSocket->socketDescriptor(), SOL_SOCKET,
|
|
SO_RCVBUF, (char *)&socketBufferSize, sizeof(socketBufferSize)) == -1) {
|
|
|
|
io->networkIOMutex.lock();
|
|
DATAIO_DEBUG << "dataIOSocket error!";
|
|
io->networkIOMutex.unlock();
|
|
}
|
|
#endif
|
|
}
|
|
else {
|
|
|
|
DATAIO_DEBUG << "set data IO socket BufferSize to 32 kB.";
|
|
socketBufferSize = 1032 * 32;
|
|
#if defined(Q_OS_WIN32)
|
|
if (::setsockopt(m_dataIOSocket->socketDescriptor(), SOL_SOCKET,
|
|
SO_RCVBUF, (char *)&socketBufferSize, sizeof(socketBufferSize)) == -1) {
|
|
|
|
io->networkIOMutex.lock();
|
|
DATAIO_DEBUG << "dataIOSocket error!";
|
|
io->networkIOMutex.unlock();
|
|
}
|
|
#endif
|
|
}
|
|
io->networkIOMutex.unlock();
|
|
}
|
|
|
|
void DataIO::setSocketBufferSize(QObject *sender, int value) {
|
|
|
|
Q_UNUSED (sender)
|
|
|
|
int socketBufferSize = value * 1024;
|
|
DATAIO_DEBUG << "m_socketBufferSize = " << value;
|
|
|
|
io->networkIOMutex.lock();
|
|
#if defined(Q_OS_WIN32)
|
|
if (::setsockopt(m_dataIOSocket->socketDescriptor(), SOL_SOCKET,
|
|
SO_RCVBUF, (char *)&socketBufferSize, sizeof(socketBufferSize)) == -1) {
|
|
|
|
io->networkIOMutex.lock();
|
|
DATAIO_DEBUG << "dataIOSocket error!";
|
|
io->networkIOMutex.unlock();
|
|
}
|
|
#endif
|
|
io->networkIOMutex.unlock();
|
|
}
|
|
|
|
void DataIO::setSampleRate(QObject *sender, int value) {
|
|
|
|
Q_UNUSED(sender)
|
|
|
|
int bufferSize;
|
|
io->networkIOMutex.lock();
|
|
switch (value) {
|
|
|
|
case 48000:
|
|
bufferSize = 16*1024;//128 * 1032
|
|
DATAIO_DEBUG << "socket buffer size set to 16 kB.";
|
|
break;
|
|
|
|
case 96000:
|
|
bufferSize = 32*1024;//128 * 1032
|
|
DATAIO_DEBUG << "socket buffer size set to 32 kB.";
|
|
break;
|
|
|
|
case 192000:
|
|
bufferSize = 64*1024;//128 * 1032
|
|
DATAIO_DEBUG << "socket buffer size set to 64 kB.";
|
|
break;
|
|
|
|
case 384000:
|
|
bufferSize = 128*1024;//128 * 1032
|
|
DATAIO_DEBUG << "socket buffer size set to 128 kB.";
|
|
break;
|
|
|
|
default:
|
|
DATAIO_DEBUG << "invalid sample rate !\n";
|
|
break;
|
|
}
|
|
|
|
#if defined(Q_OS_WIN32)
|
|
if (::setsockopt(m_dataIOSocket->socketDescriptor(), SOL_SOCKET,
|
|
SO_RCVBUF, (char *)&bufferSize, sizeof(bufferSize)) == -1) {
|
|
|
|
DATAIO_DEBUG << "dataIOSocket error!";
|
|
}
|
|
#endif
|
|
|
|
io->networkIOMutex.unlock();
|
|
}
|