mirror of
https://github.com/HifiExperiments/overte.git
synced 2025-04-07 00:23:34 +02:00
More review fixes since I missed 66 of them.
This commit is contained in:
parent
24669c98f6
commit
9a67ee19e0
4 changed files with 178 additions and 212 deletions
|
|
@ -18,36 +18,35 @@ static QLoggingCategory decoder("AthenaOpusDecoder");
|
|||
|
||||
static QString error_to_string(int error) {
|
||||
switch (error) {
|
||||
case OPUS_OK:
|
||||
return "OK";
|
||||
case OPUS_BAD_ARG:
|
||||
return "One or more invalid/out of range arguments.";
|
||||
case OPUS_BUFFER_TOO_SMALL:
|
||||
return "The mode struct passed is invalid.";
|
||||
case OPUS_INTERNAL_ERROR:
|
||||
return "An internal error was detected.";
|
||||
case OPUS_INVALID_PACKET:
|
||||
return "The compressed data passed is corrupted.";
|
||||
case OPUS_UNIMPLEMENTED:
|
||||
return "Invalid/unsupported request number.";
|
||||
case OPUS_INVALID_STATE:
|
||||
return "An encoder or decoder structure is invalid or already freed.";
|
||||
default:
|
||||
return QString("Unknown error code: %i").arg(error);
|
||||
case OPUS_OK:
|
||||
return "OK";
|
||||
case OPUS_BAD_ARG:
|
||||
return "One or more invalid/out of range arguments.";
|
||||
case OPUS_BUFFER_TOO_SMALL:
|
||||
return "The mode struct passed is invalid.";
|
||||
case OPUS_INTERNAL_ERROR:
|
||||
return "An internal error was detected.";
|
||||
case OPUS_INVALID_PACKET:
|
||||
return "The compressed data passed is corrupted.";
|
||||
case OPUS_UNIMPLEMENTED:
|
||||
return "Invalid/unsupported request number.";
|
||||
case OPUS_INVALID_STATE:
|
||||
return "An encoder or decoder structure is invalid or already freed.";
|
||||
default:
|
||||
return QString("Unknown error code: %i").arg(error);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
AthenaOpusDecoder::AthenaOpusDecoder(int sampleRate, int numChannels)
|
||||
{
|
||||
AthenaOpusDecoder::AthenaOpusDecoder(int sampleRate, int numChannels) {
|
||||
int error;
|
||||
|
||||
_opus_sample_rate = sampleRate;
|
||||
_opus_num_channels = numChannels;
|
||||
_opusSampleRate = sampleRate;
|
||||
_opusNumChannels = numChannels;
|
||||
|
||||
_decoder = opus_decoder_create(sampleRate, numChannels, &error);
|
||||
|
||||
if ( error != OPUS_OK ) {
|
||||
if (error != OPUS_OK) {
|
||||
qCCritical(decoder) << "Failed to initialize Opus encoder: " << error_to_string(error);
|
||||
_decoder = nullptr;
|
||||
return;
|
||||
|
|
@ -57,42 +56,39 @@ AthenaOpusDecoder::AthenaOpusDecoder(int sampleRate, int numChannels)
|
|||
qCDebug(decoder) << "Opus decoder initialized, sampleRate = " << sampleRate << "; numChannels = " << numChannels;
|
||||
}
|
||||
|
||||
AthenaOpusDecoder::~AthenaOpusDecoder()
|
||||
{
|
||||
if ( _decoder )
|
||||
AthenaOpusDecoder::~AthenaOpusDecoder() {
|
||||
if (_decoder)
|
||||
opus_decoder_destroy(_decoder);
|
||||
|
||||
}
|
||||
|
||||
void AthenaOpusDecoder::decode(const QByteArray &encodedBuffer, QByteArray &decodedBuffer)
|
||||
{
|
||||
void AthenaOpusDecoder::decode(const QByteArray &encodedBuffer, QByteArray &decodedBuffer) {
|
||||
assert(_decoder);
|
||||
PerformanceTimer perfTimer("AthenaOpusDecoder::decode");
|
||||
|
||||
// The audio system encodes and decodes always in fixed size chunks
|
||||
int buffer_size = AudioConstants::NETWORK_FRAME_SAMPLES_PER_CHANNEL * static_cast<int>(sizeof(int16_t))
|
||||
* _opus_num_channels;
|
||||
int bufferSize = AudioConstants::NETWORK_FRAME_SAMPLES_PER_CHANNEL * static_cast<int>(sizeof(int16_t))
|
||||
* _opusNumChannels;
|
||||
|
||||
decodedBuffer.resize( buffer_size );
|
||||
int buffer_frames = decodedBuffer.size() / _opus_num_channels / static_cast<int>(sizeof( opus_int16 ));
|
||||
decodedBuffer.resize(bufferSize);
|
||||
int bufferFrames = decodedBuffer.size() / _opusNumChannels / static_cast<int>(sizeof( opus_int16 ));
|
||||
|
||||
qCDebug(decoder) << "Opus decode: encodedBytes = " << encodedBuffer.length() << "; decodedBufferBytes = "
|
||||
<< decodedBuffer.size() << "; frameCount = " << buffer_frames;
|
||||
int decoded_frames = opus_decode( _decoder, reinterpret_cast<const unsigned char*>(encodedBuffer.data()),
|
||||
encodedBuffer.length(), reinterpret_cast<opus_int16*>(decodedBuffer.data()), buffer_frames, 0 );
|
||||
<< decodedBuffer.size() << "; frameCount = " << bufferFrames;
|
||||
int decoded_frames = opus_decode(_decoder, reinterpret_cast<const unsigned char*>(encodedBuffer.data()),
|
||||
encodedBuffer.length(), reinterpret_cast<opus_int16*>(decodedBuffer.data()), bufferFrames, 0);
|
||||
|
||||
if ( decoded_frames >= 0 ) {
|
||||
//qCDebug(decoder) << "Decoded " << decoded_frames << " Opus frames, " << buffer_frames << " expected";
|
||||
if (decoded_frames >= 0) {
|
||||
|
||||
if ( decoded_frames < buffer_frames ) {
|
||||
qCWarning(decoder) << "Opus decoder returned " << decoded_frames << ", but " << buffer_frames
|
||||
if (decoded_frames < bufferFrames) {
|
||||
qCWarning(decoder) << "Opus decoder returned " << decoded_frames << ", but " << bufferFrames
|
||||
<< " were expected!";
|
||||
|
||||
int start = decoded_frames * static_cast<int>(sizeof(int16_t)) * _opus_num_channels;
|
||||
int start = decoded_frames * static_cast<int>(sizeof(int16_t)) * _opusNumChannels;
|
||||
memset( &decodedBuffer.data()[start], 0, static_cast<size_t>(decodedBuffer.length() - start));
|
||||
} else if ( decoded_frames > buffer_frames ) {
|
||||
} else if (decoded_frames > bufferFrames) {
|
||||
// This should never happen
|
||||
qCCritical(decoder) << "Opus decoder returned " << decoded_frames << ", but only " << buffer_frames
|
||||
qCCritical(decoder) << "Opus decoder returned " << decoded_frames << ", but only " << bufferFrames
|
||||
<< " were expected! Buffer overflow!?";
|
||||
}
|
||||
} else {
|
||||
|
|
@ -102,40 +98,36 @@ void AthenaOpusDecoder::decode(const QByteArray &encodedBuffer, QByteArray &deco
|
|||
|
||||
}
|
||||
|
||||
void AthenaOpusDecoder::lostFrame(QByteArray &decodedBuffer)
|
||||
{
|
||||
void AthenaOpusDecoder::lostFrame(QByteArray &decodedBuffer) {
|
||||
assert(_decoder);
|
||||
|
||||
PerformanceTimer perfTimer("AthenaOpusDecoder::lostFrame");
|
||||
|
||||
int buffer_size = AudioConstants::NETWORK_FRAME_SAMPLES_PER_CHANNEL * static_cast<int>(sizeof(int16_t))
|
||||
* _opus_num_channels;
|
||||
decodedBuffer.resize( buffer_size );
|
||||
int buffer_frames = decodedBuffer.size() / _opus_num_channels / static_cast<int>(sizeof( opus_int16 ));
|
||||
int bufferSize = AudioConstants::NETWORK_FRAME_SAMPLES_PER_CHANNEL * static_cast<int>(sizeof(int16_t))
|
||||
* _opusNumChannels;
|
||||
decodedBuffer.resize(bufferSize);
|
||||
int bufferFrames = decodedBuffer.size() / _opusNumChannels / static_cast<int>(sizeof(opus_int16));
|
||||
|
||||
int decoded_frames = opus_decode( _decoder, nullptr, 0, reinterpret_cast<opus_int16*>(decodedBuffer.data()),
|
||||
buffer_frames, 1 );
|
||||
int decoded_frames = opus_decode(_decoder, nullptr, 0, reinterpret_cast<opus_int16*>(decodedBuffer.data()),
|
||||
bufferFrames, 1 );
|
||||
|
||||
if ( decoded_frames >= 0 ) {
|
||||
//qCDebug(decoder) << "Produced " << decoded_frames << " opus frames from a lost frame, " << buffer_frames
|
||||
// << " expected";
|
||||
if (decoded_frames >= 0) {
|
||||
|
||||
if ( decoded_frames < buffer_frames ) {
|
||||
qCWarning(decoder) << "Opus decoder returned " << decoded_frames << ", but " << buffer_frames
|
||||
if ( decoded_frames < bufferFrames ) {
|
||||
qCWarning(decoder) << "Opus decoder returned " << decoded_frames << ", but " << bufferFrames
|
||||
<< " were expected!";
|
||||
|
||||
int start = decoded_frames * static_cast<int>(sizeof(int16_t)) * _opus_num_channels;
|
||||
int start = decoded_frames * static_cast<int>(sizeof(int16_t)) * _opusNumChannels;
|
||||
memset( &decodedBuffer.data()[start], 0, static_cast<size_t>(decodedBuffer.length() - start));
|
||||
} else if ( decoded_frames > buffer_frames ) {
|
||||
} else if (decoded_frames > bufferFrames) {
|
||||
// This should never happen
|
||||
qCCritical(decoder) << "Opus decoder returned " << decoded_frames << ", but only " << buffer_frames
|
||||
qCCritical(decoder) << "Opus decoder returned " << decoded_frames << ", but only " << bufferFrames
|
||||
<< " were expected! Buffer overflow!?";
|
||||
}
|
||||
|
||||
} else {
|
||||
qCCritical(decoder) << "Failed to decode lost frame: " << error_to_string(decoded_frames);
|
||||
decodedBuffer.fill('\0');
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@
|
|||
|
||||
|
||||
#include <plugins/CodecPlugin.h>
|
||||
#include "opus/opus.h"
|
||||
#include <opus/opus.h>
|
||||
|
||||
|
||||
class AthenaOpusDecoder : public Decoder {
|
||||
|
|
@ -23,16 +23,16 @@ public:
|
|||
|
||||
|
||||
virtual void decode(const QByteArray& encodedBuffer, QByteArray& decodedBuffer) override;
|
||||
virtual void lostFrame( QByteArray &decodedBuffer) override;
|
||||
virtual void lostFrame(QByteArray &decodedBuffer) override;
|
||||
|
||||
|
||||
private:
|
||||
int _encodedSize;
|
||||
|
||||
OpusDecoder *_decoder = nullptr;
|
||||
int _opus_sample_rate = 0;
|
||||
int _opus_num_channels = 0;
|
||||
int _decoded_size = 0;
|
||||
int _opusSampleRate = 0;
|
||||
int _opusNumChannels = 0;
|
||||
int _decodedSize = 0;
|
||||
};
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -16,40 +16,39 @@
|
|||
|
||||
static QLoggingCategory encoder("AthenaOpusEncoder");
|
||||
|
||||
static QString error_to_string(int error) {
|
||||
static QString errorToString(int error) {
|
||||
switch (error) {
|
||||
case OPUS_OK:
|
||||
return "OK";
|
||||
case OPUS_BAD_ARG:
|
||||
return "One or more invalid/out of range arguments.";
|
||||
case OPUS_BUFFER_TOO_SMALL:
|
||||
return "The mode struct passed is invalid.";
|
||||
case OPUS_INTERNAL_ERROR:
|
||||
return "An internal error was detected.";
|
||||
case OPUS_INVALID_PACKET:
|
||||
return "The compressed data passed is corrupted.";
|
||||
case OPUS_UNIMPLEMENTED:
|
||||
return "Invalid/unsupported request number.";
|
||||
case OPUS_INVALID_STATE:
|
||||
return "An encoder or decoder structure is invalid or already freed.";
|
||||
default:
|
||||
return QString("Unknown error code: %i").arg(error);
|
||||
case OPUS_OK:
|
||||
return "OK";
|
||||
case OPUS_BAD_ARG:
|
||||
return "One or more invalid/out of range arguments.";
|
||||
case OPUS_BUFFER_TOO_SMALL:
|
||||
return "The mode struct passed is invalid.";
|
||||
case OPUS_INTERNAL_ERROR:
|
||||
return "An internal error was detected.";
|
||||
case OPUS_INVALID_PACKET:
|
||||
return "The compressed data passed is corrupted.";
|
||||
case OPUS_UNIMPLEMENTED:
|
||||
return "Invalid/unsupported request number.";
|
||||
case OPUS_INVALID_STATE:
|
||||
return "An encoder or decoder structure is invalid or already freed.";
|
||||
default:
|
||||
return QString("Unknown error code: %i").arg(error);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
AthenaOpusEncoder::AthenaOpusEncoder(int sampleRate, int numChannels)
|
||||
{
|
||||
_opus_sample_rate = sampleRate;
|
||||
_opus_channels = numChannels;
|
||||
AthenaOpusEncoder::AthenaOpusEncoder(int sampleRate, int numChannels) {
|
||||
_opusSampleRate = sampleRate;
|
||||
_opusChannels = numChannels;
|
||||
|
||||
int error;
|
||||
|
||||
_encoder = opus_encoder_create(sampleRate, numChannels, DEFAULT_APPLICATION, &error);
|
||||
|
||||
if ( error != OPUS_OK ) {
|
||||
qCCritical(encoder) << "Failed to initialize Opus encoder: " << error_to_string(error);
|
||||
if (error != OPUS_OK) {
|
||||
qCCritical(encoder) << "Failed to initialize Opus encoder: " << errorToString(error);
|
||||
_encoder = nullptr;
|
||||
return;
|
||||
}
|
||||
|
|
@ -62,8 +61,7 @@ AthenaOpusEncoder::AthenaOpusEncoder(int sampleRate, int numChannels)
|
|||
qCDebug(encoder) << "Opus encoder initialized, sampleRate = " << sampleRate << "; numChannels = " << numChannels;
|
||||
}
|
||||
|
||||
AthenaOpusEncoder::~AthenaOpusEncoder()
|
||||
{
|
||||
AthenaOpusEncoder::~AthenaOpusEncoder() {
|
||||
opus_encoder_destroy(_encoder);
|
||||
}
|
||||
|
||||
|
|
@ -75,225 +73,201 @@ void AthenaOpusEncoder::encode(const QByteArray& decodedBuffer, QByteArray& enco
|
|||
assert(_encoder);
|
||||
|
||||
encodedBuffer.resize( decodedBuffer.size() );
|
||||
int frame_size = decodedBuffer.length()/ _opus_channels / static_cast<int>(sizeof(opus_int16));
|
||||
int frameSize = decodedBuffer.length()/ _opusChannels / static_cast<int>(sizeof(opus_int16));
|
||||
|
||||
int bytes = opus_encode(_encoder, reinterpret_cast<const opus_int16*>(decodedBuffer.constData()), frame_size,
|
||||
int bytes = opus_encode(_encoder, reinterpret_cast<const opus_int16*>(decodedBuffer.constData()), frameSize,
|
||||
reinterpret_cast<unsigned char*>(encodedBuffer.data()), encodedBuffer.size() );
|
||||
|
||||
if ( bytes >= 0 ) {
|
||||
//qCDebug(encoder) << "Encoded " << decodedBuffer.length() << " bytes into " << bytes << " opus bytes";
|
||||
if (bytes >= 0) {
|
||||
encodedBuffer.resize(bytes);
|
||||
} else {
|
||||
encodedBuffer.resize(0);
|
||||
|
||||
qCWarning(encoder) << "Error when encoding " << decodedBuffer.length() << " bytes of audio: "
|
||||
<< error_to_string(bytes);
|
||||
<< errorToString(bytes);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
int AthenaOpusEncoder::getComplexity() const
|
||||
{
|
||||
int AthenaOpusEncoder::getComplexity() const {
|
||||
assert(_encoder);
|
||||
int ret;
|
||||
opus_encoder_ctl(_encoder, OPUS_GET_COMPLEXITY(&ret));
|
||||
return ret;
|
||||
int returnValue;
|
||||
opus_encoder_ctl(_encoder, OPUS_GET_COMPLEXITY(&returnValue));
|
||||
return returnValue;
|
||||
}
|
||||
|
||||
void AthenaOpusEncoder::setComplexity(int complexity)
|
||||
{
|
||||
void AthenaOpusEncoder::setComplexity(int complexity) {
|
||||
assert(_encoder);
|
||||
int ret = opus_encoder_ctl(_encoder, OPUS_SET_COMPLEXITY(complexity));
|
||||
int returnValue = opus_encoder_ctl(_encoder, OPUS_SET_COMPLEXITY(complexity));
|
||||
|
||||
if (ret != OPUS_OK) {
|
||||
qCWarning(encoder) << "Error when setting complexity to " << complexity << ": " << error_to_string(ret);
|
||||
if (returnValue != OPUS_OK) {
|
||||
qCWarning(encoder) << "Error when setting complexity to " << complexity << ": " << errorToString(returnValue);
|
||||
}
|
||||
}
|
||||
|
||||
int AthenaOpusEncoder::getBitrate() const
|
||||
{
|
||||
int AthenaOpusEncoder::getBitrate() const {
|
||||
assert(_encoder);
|
||||
int ret;
|
||||
opus_encoder_ctl(_encoder, OPUS_GET_BITRATE(&ret));
|
||||
return ret;
|
||||
int returnValue;
|
||||
opus_encoder_ctl(_encoder, OPUS_GET_BITRATE(&returnValue));
|
||||
return returnValue;
|
||||
}
|
||||
|
||||
void AthenaOpusEncoder::setBitrate(int bitrate)
|
||||
{
|
||||
void AthenaOpusEncoder::setBitrate(int bitrate) {
|
||||
assert(_encoder);
|
||||
int ret = opus_encoder_ctl(_encoder, OPUS_SET_BITRATE(bitrate));
|
||||
int errorCode = opus_encoder_ctl(_encoder, OPUS_SET_BITRATE(bitrate));
|
||||
|
||||
if (ret != OPUS_OK) {
|
||||
qCWarning(encoder) << "Error when setting bitrate to " << bitrate << ": " << error_to_string(ret);
|
||||
if (errorCode != OPUS_OK) {
|
||||
qCWarning(encoder) << "Error when setting bitrate to " << bitrate << ": " << errorToString(errorCode);
|
||||
}
|
||||
}
|
||||
|
||||
int AthenaOpusEncoder::getVBR() const
|
||||
{
|
||||
int AthenaOpusEncoder::getVBR() const {
|
||||
assert(_encoder);
|
||||
int ret;
|
||||
opus_encoder_ctl(_encoder, OPUS_GET_VBR(&ret));
|
||||
return ret;
|
||||
int returnValue;
|
||||
opus_encoder_ctl(_encoder, OPUS_GET_VBR(&returnValue));
|
||||
return returnValue;
|
||||
}
|
||||
|
||||
void AthenaOpusEncoder::setVBR(int vbr)
|
||||
{
|
||||
void AthenaOpusEncoder::setVBR(int vbr) {
|
||||
assert(_encoder);
|
||||
int ret = opus_encoder_ctl(_encoder, OPUS_SET_VBR(vbr));
|
||||
int errorCode = opus_encoder_ctl(_encoder, OPUS_SET_VBR(vbr));
|
||||
|
||||
if (ret != OPUS_OK) {
|
||||
qCWarning(encoder) << "Error when setting VBR to " << vbr << ": " << error_to_string(ret);
|
||||
if (errorCode != OPUS_OK) {
|
||||
qCWarning(encoder) << "Error when setting VBR to " << vbr << ": " << errorToString(errorCode);
|
||||
}
|
||||
}
|
||||
|
||||
int AthenaOpusEncoder::getVBRConstraint() const
|
||||
{
|
||||
int AthenaOpusEncoder::getVBRConstraint() const {
|
||||
assert(_encoder);
|
||||
int ret;
|
||||
opus_encoder_ctl(_encoder, OPUS_GET_VBR_CONSTRAINT(&ret));
|
||||
return ret;
|
||||
int returnValue;
|
||||
opus_encoder_ctl(_encoder, OPUS_GET_VBR_CONSTRAINT(&returnValue));
|
||||
return returnValue;
|
||||
}
|
||||
|
||||
void AthenaOpusEncoder::setVBRConstraint(int vbr_const)
|
||||
{
|
||||
void AthenaOpusEncoder::setVBRConstraint(int vbr_const) {
|
||||
assert(_encoder);
|
||||
int ret = opus_encoder_ctl(_encoder, OPUS_SET_VBR_CONSTRAINT(vbr_const));
|
||||
int errorCode = opus_encoder_ctl(_encoder, OPUS_SET_VBR_CONSTRAINT(vbr_const));
|
||||
|
||||
if (ret != OPUS_OK) {
|
||||
qCWarning(encoder) << "Error when setting VBR constraint to " << vbr_const << ": " << error_to_string(ret);
|
||||
if (errorCode != OPUS_OK) {
|
||||
qCWarning(encoder) << "Error when setting VBR constraint to " << vbr_const << ": " << errorToString(errorCode);
|
||||
}
|
||||
}
|
||||
|
||||
int AthenaOpusEncoder::getMaxBandwidth() const
|
||||
{
|
||||
int AthenaOpusEncoder::getMaxBandwidth() const {
|
||||
assert(_encoder);
|
||||
int ret;
|
||||
opus_encoder_ctl(_encoder, OPUS_GET_MAX_BANDWIDTH(&ret));
|
||||
return ret;
|
||||
int returnValue;
|
||||
opus_encoder_ctl(_encoder, OPUS_GET_MAX_BANDWIDTH(&returnValue));
|
||||
return returnValue;
|
||||
}
|
||||
|
||||
void AthenaOpusEncoder::setMaxBandwidth(int maxbw)
|
||||
{
|
||||
void AthenaOpusEncoder::setMaxBandwidth(int maxbw) {
|
||||
assert(_encoder);
|
||||
int ret = opus_encoder_ctl(_encoder, OPUS_SET_MAX_BANDWIDTH(maxbw));
|
||||
int errorCode = opus_encoder_ctl(_encoder, OPUS_SET_MAX_BANDWIDTH(maxbw));
|
||||
|
||||
if (ret != OPUS_OK) {
|
||||
qCWarning(encoder) << "Error when setting max bandwidth to " << maxbw << ": " << error_to_string(ret);
|
||||
if (errorCode != OPUS_OK) {
|
||||
qCWarning(encoder) << "Error when setting max bandwidth to " << maxbw << ": " << errorToString(errorCode);
|
||||
}
|
||||
}
|
||||
|
||||
int AthenaOpusEncoder::getBandwidth() const
|
||||
{
|
||||
int AthenaOpusEncoder::getBandwidth() const {
|
||||
assert(_encoder);
|
||||
int ret;
|
||||
opus_encoder_ctl(_encoder, OPUS_GET_BANDWIDTH(&ret));
|
||||
return ret;
|
||||
int bandwidth;
|
||||
opus_encoder_ctl(_encoder, OPUS_GET_BANDWIDTH(&bandwidth));
|
||||
return bandwidth;
|
||||
}
|
||||
|
||||
void AthenaOpusEncoder::setBandwidth(int bw)
|
||||
{
|
||||
void AthenaOpusEncoder::setBandwidth(int bandwidth) {
|
||||
assert(_encoder);
|
||||
int ret = opus_encoder_ctl(_encoder, OPUS_SET_BANDWIDTH(bw));
|
||||
int errorCode = opus_encoder_ctl(_encoder, OPUS_SET_BANDWIDTH(bandwidth));
|
||||
|
||||
if (ret != OPUS_OK) {
|
||||
qCWarning(encoder) << "Error when setting bandwidth to " << bw << ": " << error_to_string(ret);
|
||||
if (errorCode != OPUS_OK) {
|
||||
qCWarning(encoder) << "Error when setting bandwidth to " << bandwidth << ": " << errorToString(errorCode);
|
||||
}
|
||||
}
|
||||
|
||||
int AthenaOpusEncoder::getSignal() const
|
||||
{
|
||||
int AthenaOpusEncoder::getSignal() const {
|
||||
assert(_encoder);
|
||||
int ret;
|
||||
opus_encoder_ctl(_encoder, OPUS_GET_SIGNAL(&ret));
|
||||
return ret;
|
||||
int signal;
|
||||
opus_encoder_ctl(_encoder, OPUS_GET_SIGNAL(&signal));
|
||||
return signal;
|
||||
}
|
||||
|
||||
void AthenaOpusEncoder::setSignal(int signal)
|
||||
{
|
||||
void AthenaOpusEncoder::setSignal(int signal) {
|
||||
assert(_encoder);
|
||||
int ret = opus_encoder_ctl(_encoder, OPUS_SET_SIGNAL(signal));
|
||||
int errorCode = opus_encoder_ctl(_encoder, OPUS_SET_SIGNAL(signal));
|
||||
|
||||
if (ret != OPUS_OK) {
|
||||
qCWarning(encoder) << "Error when setting signal to " << signal << ": " << error_to_string(ret);
|
||||
if (errorCode != OPUS_OK) {
|
||||
qCWarning(encoder) << "Error when setting signal to " << signal << ": " << errorToString(errorCode);
|
||||
}
|
||||
}
|
||||
|
||||
int AthenaOpusEncoder::getApplication() const
|
||||
{
|
||||
int AthenaOpusEncoder::getApplication() const {
|
||||
assert(_encoder);
|
||||
int ret;
|
||||
opus_encoder_ctl(_encoder, OPUS_GET_APPLICATION(&ret));
|
||||
return ret;
|
||||
int applicationValue;
|
||||
opus_encoder_ctl(_encoder, OPUS_GET_APPLICATION(&applicationValue));
|
||||
return applicationValue;
|
||||
}
|
||||
|
||||
void AthenaOpusEncoder::setApplication(int application)
|
||||
{
|
||||
void AthenaOpusEncoder::setApplication(int application) {
|
||||
assert(_encoder);
|
||||
int ret = opus_encoder_ctl(_encoder, OPUS_SET_APPLICATION(application));
|
||||
int errorCode = opus_encoder_ctl(_encoder, OPUS_SET_APPLICATION(application));
|
||||
|
||||
if (ret != OPUS_OK) {
|
||||
qCWarning(encoder) << "Error when setting application to " << application << ": " << error_to_string(ret);
|
||||
if (errorCode != OPUS_OK) {
|
||||
qCWarning(encoder) << "Error when setting application to " << application << ": " << errorToString(errorCode);
|
||||
}
|
||||
}
|
||||
|
||||
int AthenaOpusEncoder::getLookahead() const
|
||||
{
|
||||
int AthenaOpusEncoder::getLookahead() const {
|
||||
assert(_encoder);
|
||||
int ret;
|
||||
opus_encoder_ctl(_encoder, OPUS_GET_LOOKAHEAD(&ret));
|
||||
return ret;
|
||||
int lookAhead;
|
||||
opus_encoder_ctl(_encoder, OPUS_GET_LOOKAHEAD(&lookAhead));
|
||||
return lookAhead;
|
||||
}
|
||||
|
||||
int AthenaOpusEncoder::getInbandFEC() const
|
||||
{
|
||||
int AthenaOpusEncoder::getInbandFEC() const {
|
||||
assert(_encoder);
|
||||
int ret;
|
||||
opus_encoder_ctl(_encoder, OPUS_GET_INBAND_FEC(&ret));
|
||||
return ret;
|
||||
int fec;
|
||||
opus_encoder_ctl(_encoder, OPUS_GET_INBAND_FEC(&fec));
|
||||
return fec;
|
||||
}
|
||||
|
||||
void AthenaOpusEncoder::setInbandFEC(int fec)
|
||||
{
|
||||
void AthenaOpusEncoder::setInbandFEC(int fec) {
|
||||
assert(_encoder);
|
||||
int ret = opus_encoder_ctl(_encoder, OPUS_SET_INBAND_FEC(fec));
|
||||
int errorCode = opus_encoder_ctl(_encoder, OPUS_SET_INBAND_FEC(fec));
|
||||
|
||||
if (ret != OPUS_OK) {
|
||||
qCWarning(encoder) << "Error when setting inband FEC to " << fec << ": " << error_to_string(ret);
|
||||
if (errorCode != OPUS_OK) {
|
||||
qCWarning(encoder) << "Error when setting inband FEC to " << fec << ": " << errorToString(errorCode);
|
||||
}
|
||||
}
|
||||
|
||||
int AthenaOpusEncoder::getExpectedPacketLossPercent() const
|
||||
{
|
||||
int AthenaOpusEncoder::getExpectedPacketLossPercent() const {
|
||||
assert(_encoder);
|
||||
int ret;
|
||||
opus_encoder_ctl(_encoder, OPUS_GET_PACKET_LOSS_PERC(&ret));
|
||||
return ret;
|
||||
int lossPercentage;
|
||||
opus_encoder_ctl(_encoder, OPUS_GET_PACKET_LOSS_PERC(&lossPercentage));
|
||||
return lossPercentage;
|
||||
}
|
||||
|
||||
void AthenaOpusEncoder::setExpectedPacketLossPercent(int perc)
|
||||
{
|
||||
void AthenaOpusEncoder::setExpectedPacketLossPercentage(int percent) {
|
||||
assert(_encoder);
|
||||
int ret = opus_encoder_ctl(_encoder, OPUS_SET_PACKET_LOSS_PERC(perc));
|
||||
int errorCode = opus_encoder_ctl(_encoder, OPUS_SET_PACKET_LOSS_PERC(percent));
|
||||
|
||||
if (ret != OPUS_OK) {
|
||||
qCWarning(encoder) << "Error when setting loss percent to " << perc << ": " << error_to_string(ret);
|
||||
if (errorCode != OPUS_OK) {
|
||||
qCWarning(encoder) << "Error when setting loss percent to " << percent << ": " << errorToString(errorCode);
|
||||
}
|
||||
}
|
||||
|
||||
int AthenaOpusEncoder::getDTX() const
|
||||
{
|
||||
int AthenaOpusEncoder::getDTX() const {
|
||||
assert(_encoder);
|
||||
int ret;
|
||||
opus_encoder_ctl(_encoder, OPUS_GET_DTX(&ret));
|
||||
return ret;
|
||||
int dtx;
|
||||
opus_encoder_ctl(_encoder, OPUS_GET_DTX(&dtx));
|
||||
return dtx;
|
||||
}
|
||||
|
||||
void AthenaOpusEncoder::setDTX(int dtx)
|
||||
{
|
||||
void AthenaOpusEncoder::setDTX(int dtx) {
|
||||
assert(_encoder);
|
||||
int ret = opus_encoder_ctl(_encoder, OPUS_SET_DTX(dtx));
|
||||
int errorCode = opus_encoder_ctl(_encoder, OPUS_SET_DTX(dtx));
|
||||
|
||||
if (ret != OPUS_OK) {
|
||||
qCWarning(encoder) << "Error when setting DTX to " << dtx << ": " << error_to_string(ret);
|
||||
if (errorCode != OPUS_OK) {
|
||||
qCWarning(encoder) << "Error when setting DTX to " << dtx << ": " << errorToString(errorCode);
|
||||
}
|
||||
}
|
||||
|
|
@ -58,7 +58,7 @@ public:
|
|||
void setInbandFEC(int fec);
|
||||
|
||||
int getExpectedPacketLossPercent() const;
|
||||
void setExpectedPacketLossPercent(int perc);
|
||||
void setExpectedPacketLossPercentage(int percent);
|
||||
|
||||
int getDTX() const;
|
||||
void setDTX(int dtx);
|
||||
|
|
@ -66,9 +66,9 @@ public:
|
|||
|
||||
private:
|
||||
|
||||
int _opus_sample_rate = 0;
|
||||
int _opus_channels = 0;
|
||||
int _opus_expected_loss = 0;
|
||||
int _opusSampleRate = 0;
|
||||
int _opusChannels = 0;
|
||||
int _opusExpectedLoss = 0;
|
||||
|
||||
|
||||
OpusEncoder* _encoder = nullptr;
|
||||
|
|
|
|||
Loading…
Reference in a new issue