diff --git a/plugins/opusCodec/src/OpusDecoder.cpp b/plugins/opusCodec/src/OpusDecoder.cpp index 3e436c58e4..e95d813fb4 100644 --- a/plugins/opusCodec/src/OpusDecoder.cpp +++ b/plugins/opusCodec/src/OpusDecoder.cpp @@ -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(sizeof(int16_t)) - * _opus_num_channels; + int bufferSize = AudioConstants::NETWORK_FRAME_SAMPLES_PER_CHANNEL * static_cast(sizeof(int16_t)) + * _opusNumChannels; - decodedBuffer.resize( buffer_size ); - int buffer_frames = decodedBuffer.size() / _opus_num_channels / static_cast(sizeof( opus_int16 )); + decodedBuffer.resize(bufferSize); + int bufferFrames = decodedBuffer.size() / _opusNumChannels / static_cast(sizeof( opus_int16 )); qCDebug(decoder) << "Opus decode: encodedBytes = " << encodedBuffer.length() << "; decodedBufferBytes = " - << decodedBuffer.size() << "; frameCount = " << buffer_frames; - int decoded_frames = opus_decode( _decoder, reinterpret_cast(encodedBuffer.data()), - encodedBuffer.length(), reinterpret_cast(decodedBuffer.data()), buffer_frames, 0 ); + << decodedBuffer.size() << "; frameCount = " << bufferFrames; + int decoded_frames = opus_decode(_decoder, reinterpret_cast(encodedBuffer.data()), + encodedBuffer.length(), reinterpret_cast(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(sizeof(int16_t)) * _opus_num_channels; + int start = decoded_frames * static_cast(sizeof(int16_t)) * _opusNumChannels; memset( &decodedBuffer.data()[start], 0, static_cast(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(sizeof(int16_t)) - * _opus_num_channels; - decodedBuffer.resize( buffer_size ); - int buffer_frames = decodedBuffer.size() / _opus_num_channels / static_cast(sizeof( opus_int16 )); + int bufferSize = AudioConstants::NETWORK_FRAME_SAMPLES_PER_CHANNEL * static_cast(sizeof(int16_t)) + * _opusNumChannels; + decodedBuffer.resize(bufferSize); + int bufferFrames = decodedBuffer.size() / _opusNumChannels / static_cast(sizeof(opus_int16)); - int decoded_frames = opus_decode( _decoder, nullptr, 0, reinterpret_cast(decodedBuffer.data()), - buffer_frames, 1 ); + int decoded_frames = opus_decode(_decoder, nullptr, 0, reinterpret_cast(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(sizeof(int16_t)) * _opus_num_channels; + int start = decoded_frames * static_cast(sizeof(int16_t)) * _opusNumChannels; memset( &decodedBuffer.data()[start], 0, static_cast(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'); } } - - diff --git a/plugins/opusCodec/src/OpusDecoder.h b/plugins/opusCodec/src/OpusDecoder.h index 01722fcc6c..f7ae6eb6da 100644 --- a/plugins/opusCodec/src/OpusDecoder.h +++ b/plugins/opusCodec/src/OpusDecoder.h @@ -13,7 +13,7 @@ #include -#include "opus/opus.h" +#include 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; }; diff --git a/plugins/opusCodec/src/OpusEncoder.cpp b/plugins/opusCodec/src/OpusEncoder.cpp index 700164427e..e0b20a6e65 100644 --- a/plugins/opusCodec/src/OpusEncoder.cpp +++ b/plugins/opusCodec/src/OpusEncoder.cpp @@ -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(sizeof(opus_int16)); + int frameSize = decodedBuffer.length()/ _opusChannels / static_cast(sizeof(opus_int16)); - int bytes = opus_encode(_encoder, reinterpret_cast(decodedBuffer.constData()), frame_size, + int bytes = opus_encode(_encoder, reinterpret_cast(decodedBuffer.constData()), frameSize, reinterpret_cast(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); } } \ No newline at end of file diff --git a/plugins/opusCodec/src/OpusEncoder.h b/plugins/opusCodec/src/OpusEncoder.h index 920423a96d..fc1ca0b827 100644 --- a/plugins/opusCodec/src/OpusEncoder.h +++ b/plugins/opusCodec/src/OpusEncoder.h @@ -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;