2018-01-28 19:59:03 -05:00
|
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// Copyright (C) 2018 F4EXB //
|
|
|
|
// written by Edouard Griffiths //
|
|
|
|
// //
|
|
|
|
// 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 as version 3 of the License, or //
|
|
|
|
// //
|
|
|
|
// 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 V3 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/>. //
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
2019-02-16 21:40:11 -05:00
|
|
|
#include <algorithm>
|
|
|
|
|
2018-01-28 19:59:03 -05:00
|
|
|
#include "audionetsink.h"
|
2018-01-28 23:19:59 -05:00
|
|
|
#include "util/rtpsink.h"
|
2018-01-28 19:59:03 -05:00
|
|
|
|
2019-02-13 01:53:38 -05:00
|
|
|
#include <QDebug>
|
2018-03-07 18:16:24 -05:00
|
|
|
#include <QUdpSocket>
|
|
|
|
|
2018-01-28 19:59:03 -05:00
|
|
|
const int AudioNetSink::m_udpBlockSize = 512;
|
|
|
|
|
2018-03-27 03:04:10 -04:00
|
|
|
AudioNetSink::AudioNetSink(QObject *parent) :
|
2018-01-28 19:59:03 -05:00
|
|
|
m_type(SinkUDP),
|
2019-02-13 01:53:38 -05:00
|
|
|
m_codec(CodecL16),
|
2018-03-07 18:16:24 -05:00
|
|
|
m_rtpBufferAudio(0),
|
2019-02-16 19:32:32 -05:00
|
|
|
m_sampleRate(48000),
|
2019-02-14 11:21:14 -05:00
|
|
|
m_decimation(1),
|
|
|
|
m_decimationCount(0),
|
2018-03-07 18:16:24 -05:00
|
|
|
m_bufferIndex(0),
|
|
|
|
m_port(9998)
|
2018-01-28 19:59:03 -05:00
|
|
|
{
|
2019-02-16 21:40:11 -05:00
|
|
|
std::fill(m_data, m_data+m_dataBlockSize, 0);
|
2018-03-07 18:16:24 -05:00
|
|
|
m_udpSocket = new QUdpSocket(parent);
|
2018-03-27 03:04:10 -04:00
|
|
|
}
|
2018-03-27 02:13:06 -04:00
|
|
|
|
2018-03-27 03:04:10 -04:00
|
|
|
AudioNetSink::AudioNetSink(QObject *parent, int sampleRate, bool stereo) :
|
|
|
|
m_type(SinkUDP),
|
2019-02-13 01:53:38 -05:00
|
|
|
m_codec(CodecL16),
|
2018-03-27 03:04:10 -04:00
|
|
|
m_rtpBufferAudio(0),
|
2019-02-16 19:32:32 -05:00
|
|
|
m_sampleRate(48000),
|
2019-02-14 11:21:14 -05:00
|
|
|
m_decimation(1),
|
|
|
|
m_decimationCount(0),
|
2018-03-27 03:04:10 -04:00
|
|
|
m_bufferIndex(0),
|
|
|
|
m_port(9998)
|
|
|
|
{
|
2019-02-16 21:40:11 -05:00
|
|
|
std::fill(m_data, m_data+m_dataBlockSize, 0);
|
2018-03-27 03:04:10 -04:00
|
|
|
m_udpSocket = new QUdpSocket(parent);
|
|
|
|
m_rtpBufferAudio = new RTPSink(m_udpSocket, sampleRate, stereo);
|
2018-01-28 19:59:03 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
AudioNetSink::~AudioNetSink()
|
|
|
|
{
|
2018-01-30 18:40:54 -05:00
|
|
|
if (m_rtpBufferAudio) {
|
|
|
|
delete m_rtpBufferAudio;
|
|
|
|
}
|
2018-03-07 18:16:24 -05:00
|
|
|
|
|
|
|
m_udpSocket->deleteLater(); // this thread is not the owner thread (was moved)
|
2018-01-28 19:59:03 -05:00
|
|
|
}
|
|
|
|
|
2018-03-07 18:16:24 -05:00
|
|
|
bool AudioNetSink::isRTPCapable() const
|
|
|
|
{
|
2018-03-27 02:13:06 -04:00
|
|
|
return m_rtpBufferAudio && m_rtpBufferAudio->isValid();
|
2018-03-07 18:16:24 -05:00
|
|
|
}
|
2018-02-20 13:18:23 -05:00
|
|
|
|
2018-01-28 19:59:03 -05:00
|
|
|
bool AudioNetSink::selectType(SinkType type)
|
|
|
|
{
|
|
|
|
if (type == SinkUDP)
|
|
|
|
{
|
|
|
|
m_type = SinkUDP;
|
|
|
|
}
|
2018-06-21 13:28:11 -04:00
|
|
|
else // this is SinkRTP
|
2018-01-28 19:59:03 -05:00
|
|
|
{
|
|
|
|
m_type = SinkRTP;
|
|
|
|
}
|
2018-06-21 13:28:11 -04:00
|
|
|
|
|
|
|
return true;
|
2018-01-28 19:59:03 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
void AudioNetSink::setDestination(const QString& address, uint16_t port)
|
|
|
|
{
|
2018-03-07 18:16:24 -05:00
|
|
|
m_address.setAddress(const_cast<QString&>(address));
|
|
|
|
m_port = port;
|
|
|
|
|
2018-01-30 18:40:54 -05:00
|
|
|
if (m_rtpBufferAudio) {
|
|
|
|
m_rtpBufferAudio->setDestination(address, port);
|
2018-01-28 19:59:03 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void AudioNetSink::addDestination(const QString& address, uint16_t port)
|
|
|
|
{
|
2018-01-30 18:40:54 -05:00
|
|
|
if (m_rtpBufferAudio) {
|
|
|
|
m_rtpBufferAudio->addDestination(address, port);
|
2018-01-28 19:59:03 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void AudioNetSink::deleteDestination(const QString& address, uint16_t port)
|
|
|
|
{
|
2018-01-30 18:40:54 -05:00
|
|
|
if (m_rtpBufferAudio) {
|
|
|
|
m_rtpBufferAudio->deleteDestination(address, port);
|
2018-01-28 19:59:03 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-02-13 01:53:38 -05:00
|
|
|
void AudioNetSink::setParameters(Codec codec, bool stereo, int sampleRate)
|
2018-03-26 18:09:52 -04:00
|
|
|
{
|
2019-02-13 01:53:38 -05:00
|
|
|
qDebug() << "AudioNetSink::setParameters:"
|
|
|
|
<< " codec: " << codec
|
|
|
|
<< " stereo: " << stereo
|
|
|
|
<< " sampleRate: " << sampleRate;
|
|
|
|
|
|
|
|
m_codec = codec;
|
2019-02-16 19:32:32 -05:00
|
|
|
m_sampleRate = sampleRate;
|
2019-02-17 07:32:17 -05:00
|
|
|
|
|
|
|
setDecimationFilters();
|
2019-02-13 01:53:38 -05:00
|
|
|
|
|
|
|
if (m_rtpBufferAudio)
|
|
|
|
{
|
|
|
|
switch (m_codec)
|
|
|
|
{
|
|
|
|
case CodecPCMA:
|
|
|
|
m_audioCompressor.fillALaw();
|
|
|
|
m_rtpBufferAudio->setPayloadInformation(RTPSink::PayloadPCMA8, sampleRate);
|
|
|
|
break;
|
|
|
|
case CodecPCMU:
|
|
|
|
m_audioCompressor.fillULaw();
|
|
|
|
m_rtpBufferAudio->setPayloadInformation(RTPSink::PayloadPCMU8, sampleRate);
|
|
|
|
break;
|
2019-02-13 04:34:36 -05:00
|
|
|
case CodecL8:
|
|
|
|
m_rtpBufferAudio->setPayloadInformation(RTPSink::PayloadL8, sampleRate);
|
|
|
|
break;
|
2019-02-16 21:40:11 -05:00
|
|
|
case CodecG722:
|
|
|
|
m_rtpBufferAudio->setPayloadInformation(RTPSink::PayloadG722, sampleRate/2);
|
|
|
|
break;
|
2019-02-17 20:30:43 -05:00
|
|
|
case CodecOpus:
|
|
|
|
m_rtpBufferAudio->setPayloadInformation(RTPSink::PayloadOpus, sampleRate);
|
|
|
|
break;
|
2019-02-13 01:53:38 -05:00
|
|
|
case CodecL16: // actually no codec
|
|
|
|
default:
|
|
|
|
m_rtpBufferAudio->setPayloadInformation(stereo ? RTPSink::PayloadL16Stereo : RTPSink::PayloadL16Mono, sampleRate);
|
|
|
|
break;
|
|
|
|
}
|
2018-03-27 02:13:06 -04:00
|
|
|
}
|
2018-03-26 18:09:52 -04:00
|
|
|
}
|
|
|
|
|
2019-02-14 11:21:14 -05:00
|
|
|
void AudioNetSink::setDecimation(uint32_t decimation)
|
2018-01-28 19:59:03 -05:00
|
|
|
{
|
2019-02-14 11:21:14 -05:00
|
|
|
m_decimation = decimation < 1 ? 1 : decimation > 6 ? 6 : decimation;
|
|
|
|
qDebug() << "AudioNetSink::setDecimation: " << m_decimation << " from: " << decimation;
|
2019-02-17 07:32:17 -05:00
|
|
|
setDecimationFilters();
|
2019-02-14 11:21:14 -05:00
|
|
|
m_decimationCount = 0;
|
|
|
|
}
|
|
|
|
|
2019-02-17 07:32:17 -05:00
|
|
|
void AudioNetSink::setDecimationFilters()
|
|
|
|
{
|
|
|
|
int decimatedSampleRate = m_sampleRate / m_decimation;
|
|
|
|
|
|
|
|
switch (m_codec)
|
|
|
|
{
|
|
|
|
case CodecPCMA:
|
|
|
|
case CodecPCMU:
|
|
|
|
m_audioFilter.setDecimFilters(m_sampleRate, decimatedSampleRate, 3300.0, 300.0);
|
|
|
|
break;
|
|
|
|
case CodecG722:
|
|
|
|
m_audioFilter.setDecimFilters(m_sampleRate, decimatedSampleRate, 7000.0, 50.0);
|
|
|
|
break;
|
2019-02-17 20:30:43 -05:00
|
|
|
case CodecOpus:
|
2019-02-17 07:32:17 -05:00
|
|
|
case CodecL8:
|
|
|
|
case CodecL16:
|
|
|
|
default:
|
|
|
|
m_audioFilter.setDecimFilters(m_sampleRate, decimatedSampleRate, 0.45*decimatedSampleRate, 50.0);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-02-14 11:21:14 -05:00
|
|
|
void AudioNetSink::write(qint16 isample)
|
|
|
|
{
|
|
|
|
qint16& sample = isample;
|
|
|
|
|
|
|
|
if (m_decimation > 1)
|
|
|
|
{
|
2019-02-17 07:32:17 -05:00
|
|
|
float lpSample = m_audioFilter.run(sample / 32768.0f);
|
2019-02-14 11:21:14 -05:00
|
|
|
|
|
|
|
if (m_decimationCount >= m_decimation - 1)
|
|
|
|
{
|
|
|
|
sample = lpSample * 32768.0f;
|
|
|
|
m_decimationCount = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
m_decimationCount++;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-07 18:16:24 -05:00
|
|
|
if (m_type == SinkUDP)
|
|
|
|
{
|
2019-02-17 00:15:12 -05:00
|
|
|
if (m_codec == CodecG722)
|
2018-03-07 18:16:24 -05:00
|
|
|
{
|
2019-02-17 00:15:12 -05:00
|
|
|
if (m_bufferIndex >= 2*m_udpBlockSize)
|
|
|
|
{
|
|
|
|
m_udpSocket->writeDatagram((const char*) m_data, (qint64 ) m_udpBlockSize, m_address, m_port);
|
|
|
|
m_bufferIndex = 0;
|
|
|
|
}
|
2019-02-18 01:57:03 -05:00
|
|
|
}
|
|
|
|
else if (m_codec == CodecOpus)
|
|
|
|
{
|
|
|
|
|
2019-02-17 00:15:12 -05:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (m_bufferIndex >= m_udpBlockSize)
|
|
|
|
{
|
|
|
|
m_udpSocket->writeDatagram((const char*) m_data, (qint64 ) m_udpBlockSize, m_address, m_port);
|
|
|
|
m_bufferIndex = 0;
|
|
|
|
}
|
2018-03-07 18:16:24 -05:00
|
|
|
}
|
2019-02-16 21:40:11 -05:00
|
|
|
|
|
|
|
switch(m_codec)
|
2018-03-07 18:16:24 -05:00
|
|
|
{
|
2019-02-16 21:40:11 -05:00
|
|
|
case CodecPCMA:
|
|
|
|
case CodecPCMU:
|
|
|
|
{
|
|
|
|
qint8 *p = (qint8*) &m_data[m_bufferIndex];
|
|
|
|
*p = m_audioCompressor.compress8(sample);
|
|
|
|
m_bufferIndex += sizeof(qint8);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case CodecL8:
|
|
|
|
{
|
|
|
|
qint8 *p = (qint8*) &m_data[m_bufferIndex];
|
|
|
|
*p = sample / 256;
|
|
|
|
m_bufferIndex += sizeof(qint8);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case CodecG722:
|
|
|
|
{
|
|
|
|
qint16 *p = (qint16*) &m_data[m_udpBlockSize + 2*m_bufferIndex];
|
|
|
|
*p = sample;
|
|
|
|
m_bufferIndex += 1;
|
|
|
|
|
2019-02-17 00:15:12 -05:00
|
|
|
if (m_bufferIndex == 2*m_udpBlockSize) {
|
|
|
|
m_g722.encode((uint8_t *) m_data, (const int16_t*) &m_data[m_udpBlockSize], 2*m_udpBlockSize);
|
2019-02-13 01:53:38 -05:00
|
|
|
}
|
2019-02-18 01:57:03 -05:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case CodecOpus:
|
|
|
|
{
|
|
|
|
|
2018-03-07 18:16:24 -05:00
|
|
|
}
|
2019-02-16 21:40:11 -05:00
|
|
|
break;
|
|
|
|
case CodecL16:
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
qint16 *p = (qint16*) &m_data[m_bufferIndex];
|
|
|
|
*p = sample;
|
|
|
|
m_bufferIndex += sizeof(qint16);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2018-03-07 18:16:24 -05:00
|
|
|
}
|
|
|
|
else if (m_type == SinkRTP)
|
|
|
|
{
|
2019-02-13 01:53:38 -05:00
|
|
|
switch(m_codec)
|
|
|
|
{
|
|
|
|
case CodecPCMA:
|
|
|
|
case CodecPCMU:
|
|
|
|
{
|
|
|
|
qint8 p = m_audioCompressor.compress8(sample);
|
|
|
|
m_rtpBufferAudio->write((uint8_t *) &p);
|
|
|
|
}
|
|
|
|
break;
|
2019-02-13 04:34:36 -05:00
|
|
|
case CodecL8:
|
|
|
|
{
|
|
|
|
qint8 p = sample / 256;
|
|
|
|
m_rtpBufferAudio->write((uint8_t *) &p);
|
|
|
|
}
|
|
|
|
break;
|
2019-02-16 21:40:11 -05:00
|
|
|
case CodecG722:
|
|
|
|
{
|
2019-02-17 00:15:12 -05:00
|
|
|
|
|
|
|
if (m_bufferIndex >= 2*m_g722BlockSize)
|
2019-02-16 21:40:11 -05:00
|
|
|
{
|
2019-02-17 00:15:12 -05:00
|
|
|
m_g722.encode((uint8_t *) m_data, (const int16_t*) &m_data[m_g722BlockSize], 2*m_g722BlockSize);
|
2019-02-16 21:40:11 -05:00
|
|
|
m_bufferIndex = 0;
|
|
|
|
}
|
|
|
|
|
2019-02-17 00:15:12 -05:00
|
|
|
if (m_bufferIndex%2 == 0) {
|
|
|
|
m_rtpBufferAudio->write((uint8_t *) &m_data[m_bufferIndex/2]);
|
|
|
|
}
|
|
|
|
|
|
|
|
qint16 *p = (qint16*) &m_data[m_g722BlockSize + 2*m_bufferIndex];
|
2019-02-16 21:40:11 -05:00
|
|
|
*p = sample;
|
2019-02-17 00:15:12 -05:00
|
|
|
m_bufferIndex += 1;
|
2019-02-16 21:40:11 -05:00
|
|
|
}
|
|
|
|
break;
|
2019-02-13 01:53:38 -05:00
|
|
|
case CodecL16:
|
|
|
|
default:
|
|
|
|
m_rtpBufferAudio->write((uint8_t *) &sample);
|
|
|
|
break;
|
|
|
|
}
|
2018-01-28 19:59:03 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-02-14 11:21:14 -05:00
|
|
|
void AudioNetSink::write(qint16 ilSample, qint16 irSample)
|
2018-03-26 16:58:17 -04:00
|
|
|
{
|
2019-02-14 11:21:14 -05:00
|
|
|
qint16& lSample = ilSample;
|
|
|
|
qint16& rSample = irSample;
|
|
|
|
|
|
|
|
if (m_decimation > 1)
|
|
|
|
{
|
|
|
|
float lpLSample = m_audioFilter.runLP(lSample / 32768.0f);
|
|
|
|
float lpRSample = m_audioFilter.runLP(rSample / 32768.0f);
|
|
|
|
|
|
|
|
if (m_decimationCount >= m_decimation - 1)
|
|
|
|
{
|
|
|
|
lSample = lpLSample * 32768.0f;
|
|
|
|
rSample = lpRSample * 32768.0f;
|
|
|
|
m_decimationCount = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
m_decimationCount++;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-26 16:58:17 -04:00
|
|
|
if (m_type == SinkUDP)
|
|
|
|
{
|
|
|
|
if (m_bufferIndex >= m_udpBlockSize)
|
|
|
|
{
|
|
|
|
m_udpSocket->writeDatagram((const char*)m_data, (qint64 ) m_udpBlockSize, m_address, m_port);
|
|
|
|
m_bufferIndex = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
qint16 *p = (qint16*) &m_data[m_bufferIndex];
|
|
|
|
*p = lSample;
|
|
|
|
m_bufferIndex += sizeof(qint16);
|
|
|
|
p = (qint16*) &m_data[m_bufferIndex];
|
|
|
|
*p = rSample;
|
|
|
|
m_bufferIndex += sizeof(qint16);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (m_type == SinkRTP)
|
|
|
|
{
|
2018-03-29 19:19:02 -04:00
|
|
|
m_rtpBufferAudio->write((uint8_t *) &lSample, (uint8_t *) &rSample);
|
2018-03-26 16:58:17 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-05 20:23:47 -05:00
|
|
|
void AudioNetSink::moveToThread(QThread *thread)
|
|
|
|
{
|
2018-03-07 18:16:24 -05:00
|
|
|
m_udpSocket->moveToThread(thread);
|
2018-03-05 20:23:47 -05:00
|
|
|
}
|
2018-01-28 19:59:03 -05:00
|
|
|
|