& stats);
+
+signals:
+
+ /*@jsdoc
+ * Triggered when the mixer's stream statistics have been updated.
+ * @function AudioStats.mixerStreamChanged
+ * @returns {Signal}
+ */
+ void mixerStreamChanged();
+
+ /*@jsdoc
+ * Triggered when the client's stream statisticss have been updated.
+ * @function AudioStats.clientStreamChanged
+ * @returns {Signal}
+ */
+ void clientStreamChanged();
+
+ /*@jsdoc
+ * Triggered when the injector streams' statistics have been updated.
+ * Note: The injector streams' statistics are currently not provided.
+ * @function AudioStats.injectorStreamsChanged
+ * @returns {Signal}
+ */
+ void injectorStreamsChanged();
+
+private:
+ friend class AudioIOStats;
+ AudioStatsInterface(QObject* parent);
+ AudioStreamStatsInterface* _client;
+ AudioStreamStatsInterface* _mixer;
+ QObject* _injectors;
+};
+
+class AudioIOStats : public QObject {
+ Q_OBJECT
+public:
+ AudioIOStats(MixedProcessedAudioStream* receivedAudioStream);
+
+ void reset();
+
+ AudioStatsInterface* data() const { return _interface; }
+
+ void updateInputMsRead(float ms) const { _inputMsRead.update(ms); }
+ void updateInputMsUnplayed(float ms) const { _inputMsUnplayed.update(ms); }
+ void updateOutputMsUnplayed(float ms) const { _outputMsUnplayed.update(ms); }
+ void sentPacket() const;
+
+ void publish();
+
+public slots:
+ void processStreamStatsPacket(QSharedPointer message, SharedNodePointer sendingNode);
+
+private:
+ AudioStatsInterface* _interface;
+
+ mutable MovingMinMaxAvg _inputMsRead;
+ mutable MovingMinMaxAvg _inputMsUnplayed;
+ mutable MovingMinMaxAvg _outputMsUnplayed;
+
+ mutable quint64 _lastSentPacketTime;
+ mutable MovingMinMaxAvg _packetTimegaps;
+
+ MixedProcessedAudioStream* _receivedAudioStream;
+ QHash _injectorStreams;
+};
+
+#endif // hifi_AudioIOStats_h
diff --git a/libraries/audio-client-core/src/AudioPacketHandler.h b/libraries/audio-client-core/src/AudioPacketHandler.h
new file mode 100644
index 00000000000..181cb8583b1
--- /dev/null
+++ b/libraries/audio-client-core/src/AudioPacketHandler.h
@@ -0,0 +1,462 @@
+//
+// AudioPacketHandler.h
+// libraries/audio-client-core/src
+//
+// Created by Nshan G. on 4 July 2022
+// Copyright 2013 High Fidelity, Inc.
+// Copyright 2022 Vircadia contributors.
+// Copyright 2022 DigiSomni LLC.
+//
+// Distributed under the Apache License, Version 2.0.
+// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#ifndef LIBRARIES_AUDIO_CLIENT_CORE_SRC_AUDIOPACKETHANDLER_H
+#define LIBRARIES_AUDIO_CLIENT_CORE_SRC_AUDIOPACKETHANDLER_H
+
+#include
+#include
+#include
+#include
+#include
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include "AudioIOStats.h"
+
+#if defined(WEBRTC_AUDIO)
+# define WEBRTC_APM_DEBUG_DUMP 0
+# include
+# include "modules/audio_processing/audio_processing_impl.h"
+#endif
+
+#ifdef _WIN32
+#pragma warning( push )
+#pragma warning( disable : 4273 )
+#pragma warning( disable : 4305 )
+#endif
+
+#ifdef _WIN32
+#pragma warning( pop )
+#endif
+
+#if defined (Q_OS_ANDROID)
+#define VOICE_RECOGNITION "voicerecognition"
+#define VOICE_COMMUNICATION "voicecommunication"
+
+#define SETTING_AEC_KEY "Android/aec"
+#define DEFAULT_AEC_ENABLED true
+#endif
+
+class QIODevice;
+
+class Transform;
+class NLPacket;
+
+#define DEFAULT_STARVE_DETECTION_ENABLED true
+#define DEFAULT_BUFFER_FRAMES 1
+
+inline auto defaultAudioPositionGetter() {
+ return Vectors::ZERO;
+}
+
+inline auto defaultAudioOrientationGetter() {
+ return Quaternions::IDENTITY;
+}
+
+struct AudioFormat {
+ enum SampleTag {
+ Signed16,
+ Float
+ };
+
+ SampleTag sampleType = SampleTag(-1);
+ int sampleRate = -1;
+ int channelCount = -1;
+
+ int getSampleSize() const {
+ switch(sampleType) {
+ case Signed16: return sizeof(int16_t);
+ case Float: return sizeof(float) ;
+ default: return 0;
+ };
+ };
+
+ int getSampleBits() const {
+ return getSampleSize() * CHAR_BIT;
+ };
+
+ qint32 bytesForDuration(qint64 microseconds) const {
+ return microseconds * sampleRate * channelCount * getSampleSize() / USECS_PER_SECOND;
+ }
+
+ bool operator==(const AudioFormat& other) const {
+ return sampleType == other.sampleType && sampleRate == other.sampleRate && channelCount == other.channelCount;
+ }
+ bool operator!=(const AudioFormat& other) const {
+ return !(*this == other);
+ }
+
+ bool isValid() const {
+ return sampleRate != -1 && channelCount != -1 &&
+ (sampleType == Signed16 || sampleType == Float);
+ }
+};
+
+template
+class AudioPacketHandler {
+ using LocalInjectorsStream = AudioMixRingBuffer;
+public:
+ static constexpr int MIN_BUFFER_FRAMES = 1;
+ static constexpr int MAX_BUFFER_FRAMES = 20;
+
+ using AudioPositionGetter = std::function;
+ using AudioOrientationGetter = std::function;
+
+ using Mutex = std::mutex;
+ using Lock = std::unique_lock;
+
+ class AudioOutputIODevice : public QIODevice {
+ public:
+ AudioOutputIODevice(LocalInjectorsStream& localInjectorsStream, MixedProcessedAudioStream& receivedAudioStream,
+ AudioPacketHandler* audio) :
+ _localInjectorsStream(localInjectorsStream), _receivedAudioStream(receivedAudioStream),
+ _audio(audio), _unfulfilledReads(0) {}
+
+ void open() { QIODevice::open(QIODevice::ReadOnly | QIODevice::Unbuffered); }
+ qint64 readData(char* data, qint64 maxSize) override;
+ qint64 writeData(const char* data, qint64 maxSize) override { return 0; }
+ int getRecentUnfulfilledReads() { int unfulfilledReads = _unfulfilledReads; _unfulfilledReads = 0; return unfulfilledReads; }
+ private:
+ using QIODevice::open; // silence overloaded virtual warning
+
+ LocalInjectorsStream& _localInjectorsStream;
+ MixedProcessedAudioStream& _receivedAudioStream;
+ AudioPacketHandler* _audio;
+ int _unfulfilledReads;
+ };
+
+ void startThread();
+ void negotiateAudioFormat();
+ void selectAudioFormat(const QString& selectedCodecName);
+
+ Q_INVOKABLE QString getSelectedAudioFormat() const { return _selectedCodecName; }
+ Q_INVOKABLE bool getNoiseGateOpen() const { return _audioGateOpen; }
+ Q_INVOKABLE float getSilentInboundPPS() const { return _silentInbound.rate(); }
+ Q_INVOKABLE float getAudioInboundPPS() const { return _audioInbound.rate(); }
+ Q_INVOKABLE float getSilentOutboundPPS() const { return _silentOutbound.rate(); }
+ Q_INVOKABLE float getAudioOutboundPPS() const { return _audioOutbound.rate(); }
+
+ const MixedProcessedAudioStream& getReceivedAudioStream() const { return _receivedAudioStream; }
+ MixedProcessedAudioStream& getReceivedAudioStream() { return _receivedAudioStream; }
+
+ float getLastInputLoudness() const { return _lastInputLoudness; }
+
+ float getTimeSinceLastClip() const { return _timeSinceLastClip; }
+ float getAudioAverageInputLoudness() const { return _lastInputLoudness; }
+
+ const AudioIOStats& getStats() const { return _stats; }
+
+ bool isSimulatingJitter() { return _gate.isSimulatingJitter(); }
+ void setIsSimulatingJitter(bool enable) { _gate.setIsSimulatingJitter(enable); }
+
+ int getGateThreshold() { return _gate.getThreshold(); }
+ void setGateThreshold(int threshold) { _gate.setThreshold(threshold); }
+
+ void setPositionGetter(AudioPositionGetter positionGetter) { _positionGetter = positionGetter; }
+ void setOrientationGetter(AudioOrientationGetter orientationGetter) { _orientationGetter = orientationGetter; }
+
+ void setIsPlayingBackRecording(bool isPlayingBackRecording) { _isPlayingBackRecording = isPlayingBackRecording; }
+
+ Q_INVOKABLE void setAvatarBoundingBoxParameters(glm::vec3 corner, glm::vec3 scale);
+
+ // FIXME: CRTP should override virtual member of in audio-client/sec/AudioClient
+ bool outputLocalInjector(const AudioInjectorPointer& injector);
+
+ // HifiAudioDeviceInfo getActiveAudioDevice(QAudio::Mode mode) const;
+ // QList getAudioDevices(QAudio::Mode mode) const;
+
+ // void enablePeakValues(bool enable) { _enablePeakValues = enable; }
+ // bool peakValuesAvailable() const;
+
+ // bool getNamedAudioDeviceForModeExists(QAudio::Mode mode, const QString& deviceName);
+
+ void setAudioPaused(bool pause);
+
+ // FIXME: CRTP should override virtual member of in audio-client/sec/AudioClient
+ AudioSolo& getAudioSolo() { return _solo; }
+
+ int getNumLocalInjectors();
+
+ void start();
+ void stop();
+
+ void handleAudioEnvironmentDataPacket(QSharedPointer message);
+ void handleAudioDataPacket(QSharedPointer message);
+ void handleNoisyMutePacket(QSharedPointer message);
+ void handleMuteEnvironmentPacket(QSharedPointer message);
+ void handleSelectedAudioFormat(QSharedPointer message);
+ void handleMismatchAudioFormat(SharedNodePointer node, const QString& currentCodec, const QString& recievedCodec);
+
+ void sendDownstreamAudioStatsPacket() { _stats.publish(); }
+ void handleMicAudioInput(const char* data, int size);
+ void sendInput();
+ void handleRecordedAudioInput(const QByteArray& audio);
+ void reset();
+ void audioMixerKilled();
+
+ void setMuted(bool muted, bool emitSignal = true);
+ bool isMuted() { return _isMuted; }
+
+ void setNoiseReduction(bool isNoiseGateEnabled, bool emitSignal = true);
+ bool isNoiseReductionEnabled() const { return _isNoiseGateEnabled; }
+
+ void setNoiseReductionAutomatic(bool isNoiseGateAutomatic, bool emitSignal = true);
+ bool isNoiseReductionAutomatic() const { return _isNoiseReductionAutomatic; }
+
+ void setNoiseReductionThreshold(float noiseReductionThreshold, bool emitSignal = true);
+ float noiseReductionThreshold() const { return _noiseReductionThreshold; }
+
+ void setAcousticEchoCancellation(bool isAECEnabled, bool emitSignal = true);
+ bool isAcousticEchoCancellationEnabled() const { return _isAECEnabled; }
+
+ // FIXME: CRTP these should override virtual members of in audio-client/sec/AudioClient
+ bool getServerEcho() { return _shouldEchoToServer; }
+ void setServerEcho(bool serverEcho) { _shouldEchoToServer = serverEcho; }
+ void toggleServerEcho() { _shouldEchoToServer = !_shouldEchoToServer; }
+
+ void processReceivedSamples(const QByteArray& inputBuffer, QByteArray& outputBuffer);
+ void sendMuteEnvironmentPacket();
+
+ int setOutputBufferSize(int numFrames, bool persist = true);
+
+ void setReverb(bool reverb);
+ void setReverbOptions(const AudioEffectOptions* options);
+
+ void setLocalInjectorGain(float gain) { _localInjectorGain = gain; };
+ void setSystemInjectorGain(float gain) { _systemInjectorGain = gain; };
+ void setOutputGain(float gain) { _outputGain = gain; };
+
+protected:
+ AudioPacketHandler();
+ ~AudioPacketHandler();
+
+ void cleanupInput();
+ bool setupInput(AudioFormat);
+ void setupDummyInput();
+ bool isDummyInput();
+
+ void cleanupOutput();
+ bool setupOutput(AudioFormat);
+
+ AudioOutputIODevice _audioOutputIODevice {_localInjectorsStream, _receivedAudioStream, this};
+ bool _isMuted {false};
+ glm::vec3 avatarBoundingBoxCorner {};
+ glm::vec3 avatarBoundingBoxScale {};
+ AudioFormat _inputFormat {};
+ AudioFormat _outputFormat {};
+ QString _selectedCodecName;
+
+private:
+ static const int RECEIVED_AUDIO_STREAM_CAPACITY_FRAMES{ 100 };
+ // OUTPUT_CHANNEL_COUNT is audio pipeline output format, which is always 2 channel.
+ // _outputFormat.channelCount() is device output format, which may be 1 or multichannel.
+ static const int OUTPUT_CHANNEL_COUNT{ 2 };
+ static const int STARVE_DETECTION_THRESHOLD{ 3 };
+ static const int STARVE_DETECTION_PERIOD{ 10 * 1000 }; // 10 Seconds
+
+ friend class CheckDevicesThread;
+ friend class LocalInjectorsThread;
+
+ Derived& derived();
+ const Derived& derived() const;
+
+ float loudnessToLevel(float loudness);
+
+ void outputFormatChanged();
+ void handleAudioInput(QByteArray& audioBuffer);
+ void prepareLocalAudioInjectors(std::unique_ptr localAudioLock = nullptr);
+ bool mixLocalAudioInjectors(float* mixBuffer);
+ float azimuthForSource(const glm::vec3& relativePosition);
+ float gainForSource(float distance, float volume);
+
+ class Gate {
+ public:
+ Gate(AudioPacketHandler* audioClient);
+
+ bool isSimulatingJitter() { return _isSimulatingJitter; }
+ void setIsSimulatingJitter(bool enable);
+
+ int getThreshold() { return _threshold; }
+ void setThreshold(int threshold);
+
+ void insert(QSharedPointer message);
+
+ private:
+ void flush();
+
+ AudioPacketHandler* _audioClient;
+ std::queue> _queue;
+ std::mutex _mutex;
+
+ int _index {0};
+ int _threshold {1};
+ bool _isSimulatingJitter {false};
+ };
+
+ Gate _gate{ this };
+
+ Mutex _injectorsMutex;
+ QTimer* _dummyAudioInput {nullptr};
+ AudioFormat _desiredInputFormat;
+ std::atomic _audioOutputInitialized {false};
+ AudioFormat _desiredOutputFormat;
+ int _outputFrameSize {0};
+ int _numOutputCallbackBytes {0};
+ std::vector _inputTypeConversionBuffer {};
+ AudioRingBuffer _inputRingBuffer {0};
+ LocalInjectorsStream _localInjectorsStream {0 , 1};
+ // In order to use _localInjectorsStream as a lock-free pipe,
+ // use it with a single producer/consumer, and track available samples and injectors
+ std::atomic _localSamplesAvailable {0};
+ std::atomic _localInjectorsAvailable {false};
+ MixedProcessedAudioStream _receivedAudioStream {RECEIVED_AUDIO_STREAM_CAPACITY_FRAMES};
+
+ quint64 _outputStarveDetectionStartTimeMsec {0};
+ int _outputStarveDetectionCount {0};
+
+ int _sessionOutputBufferSizeFrames {DEFAULT_BUFFER_FRAMES};
+
+ float _lastRawInputLoudness {0.0f}; // before mute/gate
+ float _lastSmoothedRawInputLoudness {0.0f};
+ float _lastInputLoudness {0.0f}; // after mute/gate
+ float _timeSinceLastClip {-1.0f};
+ int _totalInputAudioSamples;
+
+ bool _shouldEchoLocally {false};
+ bool _shouldEchoToServer {false};
+ bool _isNoiseGateEnabled {true};
+ bool _isNoiseReductionAutomatic {true};
+ float _noiseReductionThreshold {0.1f};
+ bool _isAECEnabled {true};
+
+ bool _reverb {false};
+ AudioEffectOptions _scriptReverbOptions;
+ AudioEffectOptions _zoneReverbOptions;
+ AudioEffectOptions* _reverbOptions {&_scriptReverbOptions};
+ AudioReverb _sourceReverb {AudioConstants::SAMPLE_RATE};
+ AudioReverb _listenerReverb {AudioConstants::SAMPLE_RATE};
+ AudioReverb _localReverb {AudioConstants::SAMPLE_RATE};
+
+ // possible streams needed for resample
+ AudioSRC* _inputToNetworkResampler {nullptr};
+ AudioSRC* _networkToOutputResampler {nullptr};
+ AudioSRC* _localToOutputResampler {nullptr};
+
+ // for network audio (used by network audio thread)
+ int16_t _networkScratchBuffer[AudioConstants::NETWORK_FRAME_SAMPLES_AMBISONIC];
+
+ // for output audio (used by this thread)
+ int _outputPeriod {0};
+ float* _outputMixBuffer {NULL};
+ int16_t* _outputScratchBuffer {NULL};
+ std::atomic _outputGain {1.0f};
+ float _lastOutputGain {1.0f};
+
+ // for local audio (used by audio injectors thread)
+ std::atomic _localInjectorGain {1.0f};
+ std::atomic _systemInjectorGain {1.0f};
+ float _localMixBuffer[AudioConstants::NETWORK_FRAME_SAMPLES_STEREO];
+ int16_t _localScratchBuffer[AudioConstants::NETWORK_FRAME_SAMPLES_AMBISONIC];
+ float* _localOutputMixBuffer {NULL};
+ Mutex _localAudioMutex;
+ AudioLimiter _audioLimiter {AudioConstants::SAMPLE_RATE, OUTPUT_CHANNEL_COUNT};
+
+ // Adds Reverb
+ void configureReverb();
+ void updateReverbOptions();
+
+#if defined(WEBRTC_AUDIO)
+ static const int WEBRTC_SAMPLE_RATE_MAX = 96000;
+ static const int WEBRTC_CHANNELS_MAX = 2;
+ static const int WEBRTC_FRAMES_MAX = webrtc::AudioProcessing::kChunkSizeMs * WEBRTC_SAMPLE_RATE_MAX / 1000;
+
+ webrtc::AudioProcessing* _apm {nullptr};
+
+ int16_t _fifoFarEnd[WEBRTC_CHANNELS_MAX * WEBRTC_FRAMES_MAX] {};
+ int _numFifoFarEnd = 0; // numFrames saved in fifo
+
+ void configureWebrtc();
+ void processWebrtcFarEnd(const int16_t* samples, int numFrames, int numChannels, int sampleRate);
+ void processWebrtcNearEnd(int16_t* samples, int numFrames, int numChannels, int sampleRate);
+#endif
+
+ // Callback acceleration dependent calculations
+ int calculateNumberOfInputCallbackBytes(const AudioFormat& format) const;
+ int calculateNumberOfFrameSamples(int numBytes) const;
+
+ quint16 _outgoingAvatarAudioSequenceNumber {0};
+
+ AudioIOStats _stats {&_receivedAudioStream};
+
+ AudioGate* _audioGate {nullptr};
+ bool _audioGateOpen {true};
+
+ AudioPositionGetter _positionGetter{ defaultAudioPositionGetter };
+ AudioOrientationGetter _orientationGetter{ defaultAudioOrientationGetter };
+
+ bool _hasReceivedFirstPacket {false};
+
+ QVector _activeLocalAudioInjectors;
+
+ bool _isPlayingBackRecording {false};
+ bool _audioPaused {false};
+
+ std::shared_ptr _codec;
+ Encoder* _encoder {nullptr}; // for outbound mic stream
+
+ RateCounter<> _silentOutbound;
+ RateCounter<> _audioOutbound;
+ RateCounter<> _silentInbound;
+ RateCounter<> _audioInbound;
+
+#if defined(Q_OS_ANDROID)
+ bool _shouldRestartInputSetup {true}; // Should we restart the input device because of an unintended stop?
+#endif
+
+ AudioSolo _solo;
+
+ QFuture _localPrepInjectorFuture;
+
+ bool _isRecording {false};
+};
+
+#endif /* end of include guard */
diff --git a/libraries/audio-client-core/src/AudioPacketHandler.hpp b/libraries/audio-client-core/src/AudioPacketHandler.hpp
new file mode 100644
index 00000000000..b75d0487a18
--- /dev/null
+++ b/libraries/audio-client-core/src/AudioPacketHandler.hpp
@@ -0,0 +1,2033 @@
+//
+// AudioPacketHandler.hpp
+// libraries/audio-client-core/src
+//
+// Created by Nshan G on 4 July 2022.
+// Copyright 2013 High Fidelity, Inc.
+// Copyright 2022 Vircadia contributors.
+// Copyright 2022 DigiSomni LLC.
+//
+// Distributed under the Apache License, Version 2.0.
+// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#ifndef LIBRARIES_AUDIO_CLIENT_CORE_SRC_AUDIOPACKETHANDLER_HPP
+#define LIBRARIES_AUDIO_CLIENT_CORE_SRC_AUDIOPACKETHANDLER_HPP
+
+#include "AudioPacketHandler.h"
+
+#include
+#include
+#include
+
+#include
+#include
+#include
+
+#ifdef __APPLE__
+#include
+#endif
+
+#ifdef WIN32
+#define WIN32_LEAN_AND_MEAN 1
+#include
+#include
+#include
+#include
+#include
+#include
+#endif
+
+#include
+#include
+#include
+
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include "AudioClientLogging.h"
+#include "AudioLogging.h"
+#include "AudioHelpers.h"
+
+using Lock = std::unique_lock;
+
+inline QDebug& operator<<(QDebug& debug, const AudioFormat& audioFormat) {
+ QString sampleTypeString = audioFormat.sampleType == AudioFormat::Signed16 ? "Signed 16bit" :
+ audioFormat.sampleType == AudioFormat::Float ? "Float" :
+ "!INVALID!";
+ return debug << QString("AudioFormat{ sampleType: %1, sampleRate: %2, channelCount: %3 }")
+ .arg(sampleTypeString, QString::number(audioFormat.sampleRate), QString::number(audioFormat.channelCount));
+}
+
+template
+auto channelUpmix(const Source* source, Destination* destination, int numSamples, int numExtraChannels) {
+ Source* dest = reinterpret_cast(destination);
+ for (int i = 0; i < numSamples/2; i++) {
+
+ *dest++ = *source++; // left
+ *dest++ = *source++; // right
+ // and the rest
+ for (int n = 0; n < numExtraChannels; n++) {
+ *dest++ = 0;
+ }
+ }
+ return reinterpret_cast(dest) - reinterpret_cast(destination);
+}
+
+template
+auto channelDownmix(const Source* source, Destination* destination, int numSamples) {
+ Source* dest = reinterpret_cast(destination);
+ for (int i = 0; i < numSamples/2; i++) {
+
+ // read 2 samples
+ int16_t left = *source++;
+ int16_t right = *source++;
+
+ // write 1 sample
+ *dest++ = (left + right) / 2;
+ }
+ return reinterpret_cast(dest) - reinterpret_cast(destination);
+}
+
+template
+auto copyWithChannelConversion(const Source* source, int sourceChannels, Destination* destination, int destinationChannels, int numSamples) {
+ if (destinationChannels == sourceChannels) {
+ const std::ptrdiff_t byteCount = numSamples * sizeof(Source);
+ memcpy(destination, source, byteCount);
+ return byteCount;
+ } else if (destinationChannels > sourceChannels) {
+ int extraChannels = destinationChannels - sourceChannels;
+ return channelUpmix(source, destination, numSamples, extraChannels);
+ } else {
+ return channelDownmix(source, destination, numSamples);
+ }
+}
+
+inline bool detectClipping(int16_t* samples, int numSamples, int numChannels) {
+
+ const int32_t CLIPPING_THRESHOLD = 32392; // -0.1 dBFS
+ const int CLIPPING_DETECTION = 3; // consecutive samples over threshold
+
+ bool isClipping = false;
+
+ if (numChannels == 2) {
+ int oversLeft = 0;
+ int oversRight = 0;
+
+ for (int i = 0; i < numSamples/2; i++) {
+ int32_t left = std::abs((int32_t)samples[2*i+0]);
+ int32_t right = std::abs((int32_t)samples[2*i+1]);
+
+ if (left > CLIPPING_THRESHOLD) {
+ isClipping |= (++oversLeft >= CLIPPING_DETECTION);
+ } else {
+ oversLeft = 0;
+ }
+ if (right > CLIPPING_THRESHOLD) {
+ isClipping |= (++oversRight >= CLIPPING_DETECTION);
+ } else {
+ oversRight = 0;
+ }
+ }
+ } else {
+ int overs = 0;
+
+ for (int i = 0; i < numSamples; i++) {
+ int32_t sample = std::abs((int32_t)samples[i]);
+
+ if (sample > CLIPPING_THRESHOLD) {
+ isClipping |= (++overs >= CLIPPING_DETECTION);
+ } else {
+ overs = 0;
+ }
+ }
+ }
+
+ return isClipping;
+}
+
+inline float computeLoudness(int16_t* samples, int numSamples) {
+
+ float scale = numSamples ? 1.0f / numSamples : 0.0f;
+
+ int32_t loudness = 0;
+ for (int i = 0; i < numSamples; i++) {
+ loudness += std::abs((int32_t)samples[i]);
+ }
+ return (float)loudness * scale;
+}
+
+template
+static void applyGainSmoothing(float* buffer, int numFrames, float gain0, float gain1) {
+
+ // fast path for unity gain
+ if (gain0 == 1.0f && gain1 == 1.0f) {
+ return;
+ }
+
+ // cubic poly from gain0 to gain1
+ float c3 = -2.0f * (gain1 - gain0);
+ float c2 = 3.0f * (gain1 - gain0);
+ float c0 = gain0;
+
+ float t = 0.0f;
+ float tStep = 1.0f / numFrames;
+
+ for (int i = 0; i < numFrames; i++) {
+
+ // evaluate poly over t=[0,1)
+ float gain = (c3 * t + c2) * t * t + c0;
+ t += tStep;
+
+ // apply gain to all channels
+ for (int ch = 0; ch < NUM_CHANNELS; ch++) {
+ buffer[NUM_CHANNELS*i + ch] *= gain;
+ }
+ }
+}
+
+inline float convertToFloat(int16_t sample) {
+ return static_cast(sample * (1.f / std::numeric_limits::max()));
+}
+
+inline float convertToSignedInt(float sample) {
+ return static_cast(sample * std::numeric_limits::max());
+}
+
+template
+Derived& AudioPacketHandler::derived() {
+ return *static_cast(this);
+}
+
+template
+const Derived& AudioPacketHandler::derived() const {
+ return *static_cast(this);
+}
+
+// FIXME: CRTP this will be needed in audio-client/src/AudioClient
+// QAudioFormat qAudioFormatFrom(AudioFormat format) {
+// QAudioFormat result;
+// result.setSampleRate(format.sampleRate);
+// result.setSampleSize(format.getSampleBits());
+// result.setCodec("audio/pcm");
+// result.setSampleType(format.sampleType == AudioFormat::Signed16 ? QAudioFormat::SignedInt :
+// format.sampleType == AudioFormat::Float ? QAudioFormat::Float :
+// QAudioFormat::Unknown);
+// result.setByteOrder(QAudioFormat::LittleEndian);
+// result.setChannelCount(format.channelCount);
+// return result;
+// }
+
+template
+AudioPacketHandler::AudioPacketHandler() {
+
+ // FIXME: CRTP,
+ // _sessionOutputBufferSizeFrames = _outputBufferSizeFrames.get();
+
+ // set up the desired audio format
+ _desiredInputFormat.sampleRate = AudioConstants::SAMPLE_RATE;
+ _desiredInputFormat.sampleType = AudioFormat::Signed16;
+ _desiredInputFormat.channelCount = AudioConstants::MONO;
+
+ _desiredOutputFormat = _desiredInputFormat;
+ _desiredOutputFormat.channelCount = OUTPUT_CHANNEL_COUNT;
+
+
+ // avoid putting a lock in the device callback
+ assert(_localSamplesAvailable.is_lock_free());
+}
+
+template
+AudioPacketHandler::~AudioPacketHandler() {
+
+ stop();
+
+ if (_codec && _encoder) {
+ _codec->releaseEncoder(_encoder);
+ _encoder = nullptr;
+ }
+
+ if (_dummyAudioInput) {
+ _dummyAudioInput->stop();
+ _dummyAudioInput->deleteLater();
+ _dummyAudioInput = nullptr;
+ }
+}
+
+template
+void AudioPacketHandler::handleMismatchAudioFormat(SharedNodePointer node, const QString& currentCodec, const QString& receivedCodec) {
+ qCDebug(audioclient) << __FUNCTION__ << "sendingNode:" << *node << "currentCodec:" << currentCodec << "receivedCodec:" << receivedCodec;
+ selectAudioFormat(receivedCodec);
+}
+
+template
+void AudioPacketHandler::reset() {
+ _receivedAudioStream.reset();
+ _stats.reset();
+ _sourceReverb.reset();
+ _listenerReverb.reset();
+ _localReverb.reset();
+}
+
+template
+void AudioPacketHandler::audioMixerKilled() {
+ _hasReceivedFirstPacket = false;
+ _outgoingAvatarAudioSequenceNumber = 0;
+ _stats.reset();
+ // FIXME: CRTP
+ // emit disconnected();
+}
+
+template
+void AudioPacketHandler::setAudioPaused(bool pause) {
+ if (_audioPaused != pause) {
+ _audioPaused = pause;
+
+ if (!_audioPaused) {
+ negotiateAudioFormat();
+ }
+ }
+}
+
+bool sampleChannelConversion(const int16_t* sourceSamples, int16_t* destinationSamples, int numSourceSamples,
+ const int sourceChannelCount, const int destinationChannelCount) {
+ if (sourceChannelCount == 2 && destinationChannelCount == 1) {
+ // loop through the stereo input audio samples and average every two samples
+ for (int i = 0; i < numSourceSamples; i += 2) {
+ destinationSamples[i / 2] = (sourceSamples[i] / 2) + (sourceSamples[i + 1] / 2);
+ }
+
+ return true;
+ } else if (sourceChannelCount == 1 && destinationChannelCount == 2) {
+
+ // loop through the mono input audio and repeat each sample twice
+ for (int i = 0; i < numSourceSamples; ++i) {
+ destinationSamples[i * 2] = destinationSamples[(i * 2) + 1] = sourceSamples[i];
+ }
+
+ return true;
+ }
+
+ return false;
+}
+
+int possibleResampling(AudioSRC* resampler,
+ const int16_t* sourceSamples, int16_t* destinationSamples,
+ int numSourceSamples, int maxDestinationSamples,
+ const int sourceChannelCount, const int destinationChannelCount) {
+
+ int numSourceFrames = numSourceSamples / sourceChannelCount;
+ int numDestinationFrames = 0;
+
+ if (numSourceSamples > 0) {
+ if (!resampler) {
+ if (!sampleChannelConversion(sourceSamples, destinationSamples, numSourceSamples,
+ sourceChannelCount, destinationChannelCount)) {
+ // no conversion, we can copy the samples directly across
+ memcpy(destinationSamples, sourceSamples, numSourceSamples * AudioConstants::SAMPLE_SIZE);
+ }
+ numDestinationFrames = numSourceFrames;
+ } else {
+ if (sourceChannelCount != destinationChannelCount) {
+
+ int16_t* channelConversionSamples = new int16_t[numSourceFrames * destinationChannelCount];
+
+ sampleChannelConversion(sourceSamples, channelConversionSamples, numSourceSamples,
+ sourceChannelCount, destinationChannelCount);
+
+ numDestinationFrames = resampler->render(channelConversionSamples, destinationSamples, numSourceFrames);
+
+ delete[] channelConversionSamples;
+ } else {
+ numDestinationFrames = resampler->render(sourceSamples, destinationSamples, numSourceFrames);
+ }
+ }
+ }
+
+ int numDestinationSamples = numDestinationFrames * destinationChannelCount;
+ if (numDestinationSamples > maxDestinationSamples) {
+ qCWarning(audioclient) << "Resampler overflow! numDestinationSamples =" << numDestinationSamples
+ << "but maxDestinationSamples =" << maxDestinationSamples;
+ }
+ return numDestinationSamples;
+}
+
+template
+void AudioPacketHandler::start() {
+ // deprecate legacy settings
+ {
+ Setting::Handle::Deprecated("maxFramesOverDesired", InboundAudioStream::MAX_FRAMES_OVER_DESIRED);
+ Setting::Handle::Deprecated("windowStarveThreshold", InboundAudioStream::WINDOW_STARVE_THRESHOLD);
+ Setting::Handle::Deprecated("windowSecondsForDesiredCalcOnTooManyStarves", InboundAudioStream::WINDOW_SECONDS_FOR_DESIRED_CALC_ON_TOO_MANY_STARVES);
+ Setting::Handle::Deprecated("windowSecondsForDesiredReduction", InboundAudioStream::WINDOW_SECONDS_FOR_DESIRED_REDUCTION);
+ Setting::Handle::Deprecated("useStDevForJitterCalc", InboundAudioStream::USE_STDEV_FOR_JITTER);
+ Setting::Handle::Deprecated("repetitionWithFade", InboundAudioStream::REPETITION_WITH_FADE);
+ }
+
+ derived().connect(&_receivedAudioStream, &MixedProcessedAudioStream::processSamples,
+ &derived(), [this](const QByteArray& decodedBuffer, QByteArray& outputBuffer)
+ { processReceivedSamples(decodedBuffer, outputBuffer); },
+ Qt::DirectConnection);
+
+ // FIXME: CRTP
+ // connect(this, &AudioClient::changeDevice, this, [=](const HifiAudioDeviceInfo& outputDeviceInfo) {
+ // qCDebug(audioclient)<< "got AudioClient::changeDevice signal, about to call switchOutputToAudioDevice() outputDeviceInfo: ["<< outputDeviceInfo.deviceName() << "]";
+ // switchOutputToAudioDevice(outputDeviceInfo);
+ // });
+
+ derived().connect(&_receivedAudioStream, &InboundAudioStream::mismatchedAudioCodec,
+ &derived(), [this](SharedNodePointer node, const QString& currentCodec, const QString& receivedCodec)
+ { handleMismatchAudioFormat(node, currentCodec, receivedCodec); });
+
+ // FIXME: CRTP
+ // initialize wasapi; if getAvailableDevices is called from the CheckDevicesThread before this, it will crash
+ // defaultAudioDeviceName(QAudio::AudioInput);
+ // defaultAudioDeviceName(QAudio::AudioOutput);
+
+ // FIXME: CRTP
+ // start a thread to detect any device changes
+ // _checkDevicesTimer = new QTimer(this);
+ // const unsigned long DEVICE_CHECK_INTERVAL_MSECS = 2 * 1000;
+ // connect(_checkDevicesTimer, &QTimer::timeout, this, [=] {
+ // QtConcurrent::run(QThreadPool::globalInstance(), [=] {
+ // checkDevices();
+ // // On some systems (Ubuntu) checking all the audio devices can take more than 2 seconds. To
+ // // avoid consuming all of the thread pool, don't start the check interval until the previous
+ // // check has completed.
+ // QMetaObject::invokeMethod(_checkDevicesTimer, "start", Q_ARG(int, DEVICE_CHECK_INTERVAL_MSECS));
+ // });
+ // });
+ // _checkDevicesTimer->setSingleShot(true);
+ // _checkDevicesTimer->start(DEVICE_CHECK_INTERVAL_MSECS);
+
+ // FIXME: CRTP
+ // start a thread to detect peak value changes
+ // _checkPeakValuesTimer = new QTimer(this);
+ // connect(_checkPeakValuesTimer, &QTimer::timeout, this, [this] {
+ // QtConcurrent::run(QThreadPool::globalInstance(), [this] { checkPeakValues(); });
+ // });
+ // const unsigned long PEAK_VALUES_CHECK_INTERVAL_MSECS = 50;
+ // _checkPeakValuesTimer->start(PEAK_VALUES_CHECK_INTERVAL_MSECS);
+ //
+ // configureReverb();
+
+#if defined(WEBRTC_AUDIO)
+ configureWebrtc();
+#endif
+
+ auto nodeList = DependencyManager::get();
+ auto& packetReceiver = nodeList->getPacketReceiver();
+ packetReceiver.registerListener(PacketType::AudioStreamStats,
+ PacketReceiver::makeSourcedListenerReference(&_stats, &AudioIOStats::processStreamStatsPacket));
+ packetReceiver.registerListener(PacketType::AudioEnvironment,
+ PacketReceiver::makeUnsourcedListenerReference(&derived(), &AudioPacketHandler::handleAudioEnvironmentDataPacket));
+ packetReceiver.registerListener(PacketType::SilentAudioFrame,
+ PacketReceiver::makeUnsourcedListenerReference(&derived(), &AudioPacketHandler::handleAudioDataPacket));
+ packetReceiver.registerListener(PacketType::MixedAudio,
+ PacketReceiver::makeUnsourcedListenerReference(&derived(), &AudioPacketHandler::handleAudioDataPacket));
+ packetReceiver.registerListener(PacketType::NoisyMute,
+ PacketReceiver::makeUnsourcedListenerReference(&derived(), &AudioPacketHandler::handleNoisyMutePacket));
+ packetReceiver.registerListener(PacketType::MuteEnvironment,
+ PacketReceiver::makeUnsourcedListenerReference(&derived(), &AudioPacketHandler::handleMuteEnvironmentPacket));
+ packetReceiver.registerListener(PacketType::SelectedAudioFormat,
+ PacketReceiver::makeUnsourcedListenerReference(&derived(), &AudioPacketHandler::handleSelectedAudioFormat));
+
+ auto& domainHandler = nodeList->getDomainHandler();
+ derived().connect(&domainHandler, &DomainHandler::disconnectedFromDomain, &derived(), [this] {
+ _solo.reset();
+ });
+ derived().connect(nodeList.data(), &NodeList::nodeActivated, &derived(), [this](SharedNodePointer node) {
+ if (node->getType() == NodeType::AudioMixer) {
+ _solo.resend();
+ negotiateAudioFormat();
+ }
+ });
+
+ //initialize input to the dummy device to prevent starves
+ cleanupInput();
+ setupDummyInput();
+
+ derived().onStart();
+
+// FIXME: CRTP
+// switchOutputToAudioDevice(defaultAudioDeviceForMode(QAudio::AudioOutput, QString()));
+// #if defined(Q_OS_ANDROID)
+// connect(&_checkInputTimer, &QTimer::timeout, this, &AudioClient::checkInputTimeout);
+// _checkInputTimer.start(CHECK_INPUT_READS_MSECS);
+// #endif
+}
+
+template
+void AudioPacketHandler::stop() {
+ qCDebug(audioclient) << "AudioPacketHandler::stop(), requesting audio input device to shut down";
+ cleanupInput();
+ qCDebug(audioclient) << "The audio input device has shut down.";
+
+
+ qCDebug(audioclient) << "AudioPacketHandler::stop(), requesting audio output device to shut down";
+ cleanupOutput();
+ qCDebug(audioclient) << "The audio output device has shut down.";
+
+ // FIXME: CRTP
+ // Stop triggering the checks
+ // QObject::disconnect(_checkPeakValuesTimer, &QTimer::timeout, nullptr, nullptr);
+ // QObject::disconnect(_checkDevicesTimer, &QTimer::timeout, nullptr, nullptr);
+ // Destruction of the pointers will occur when the parent object (this) is destroyed)
+ // {
+ // Lock lock(_checkDevicesMutex);
+ // _checkDevicesTimer->stop();
+ // _checkDevicesTimer = nullptr;
+ // }
+ // {
+ // Lock lock(_checkPeakValuesMutex);
+ // _checkPeakValuesTimer = nullptr;
+ // }
+
+// FIXME: CRTP
+// #if defined(Q_OS_ANDROID)
+// _checkInputTimer.stop();
+// disconnect(&_checkInputTimer, &QTimer::timeout, 0, 0);
+// #endif
+}
+
+template
+void AudioPacketHandler::handleAudioEnvironmentDataPacket(QSharedPointer message) {
+ char bitset;
+ message->readPrimitive(&bitset);
+
+ bool hasReverb = oneAtBit(bitset, HAS_REVERB_BIT);
+
+ if (hasReverb) {
+ float reverbTime, wetLevel;
+ message->readPrimitive(&reverbTime);
+ message->readPrimitive(&wetLevel);
+ _receivedAudioStream.setReverb(reverbTime, wetLevel);
+ } else {
+ _receivedAudioStream.clearReverb();
+ }
+}
+
+template
+void AudioPacketHandler::handleAudioDataPacket(QSharedPointer message) {
+ if (message->getType() == PacketType::SilentAudioFrame) {
+ _silentInbound.increment();
+ } else {
+ _audioInbound.increment();
+ }
+
+ auto nodeList = DependencyManager::get();
+ nodeList->flagTimeForConnectionStep(LimitedNodeList::ConnectionStep::ReceiveFirstAudioPacket);
+
+ if (_audioOutputInitialized.load(std::memory_order_acquire)) {
+
+ if (!_hasReceivedFirstPacket) {
+ _hasReceivedFirstPacket = true;
+
+ // have the audio scripting interface emit a signal to say we just connected to mixer
+ // FIXME: CRTP
+ // emit receivedFirstPacket();
+ }
+
+#if DEV_BUILD || PR_BUILD
+ _gate.insert(message);
+#else
+ // Audio output must exist and be correctly set up if we're going to process received audio
+ _receivedAudioStream.parseData(*message);
+#endif
+ }
+}
+
+template
+AudioPacketHandler::Gate::Gate(AudioPacketHandler* audioClient) :
+ _audioClient(audioClient) {}
+
+template
+void AudioPacketHandler::Gate::setIsSimulatingJitter(bool enable) {
+ std::lock_guard lock(_mutex);
+ flush();
+ _isSimulatingJitter = enable;
+}
+
+template
+void AudioPacketHandler::Gate::setThreshold(int threshold) {
+ std::lock_guard lock(_mutex);
+ flush();
+ _threshold = std::max(threshold, 1);
+}
+
+template
+void AudioPacketHandler::Gate::insert(QSharedPointer message) {
+ std::lock_guard lock(_mutex);
+
+ // Short-circuit for normal behavior
+ if (_threshold == 1 && !_isSimulatingJitter) {
+ _audioClient->_receivedAudioStream.parseData(*message);
+ return;
+ }
+
+ // Throttle the current packet until the next flush
+ _queue.push(message);
+ _index++;
+
+ // When appropriate, flush all held packets to the received audio stream
+ if (_isSimulatingJitter) {
+ // The JITTER_FLUSH_CHANCE defines the discrete probability density function of jitter (ms),
+ // where f(t) = pow(1 - JITTER_FLUSH_CHANCE, (t / 10) * JITTER_FLUSH_CHANCE
+ // for t (ms) = 10, 20, ... (because typical packet timegap is 10ms),
+ // because there is a JITTER_FLUSH_CHANCE of any packet instigating a flush of all held packets.
+ static const float JITTER_FLUSH_CHANCE = 0.6f;
+ // It is set at 0.6 to give a low chance of spikes (>30ms, 2.56%) so that they are obvious,
+ // but settled within the measured 5s window in audio network stats.
+ if (randFloat() < JITTER_FLUSH_CHANCE) {
+ flush();
+ }
+ } else if (!(_index % _threshold)) {
+ flush();
+ }
+}
+
+template
+void AudioPacketHandler::Gate::flush() {
+ // Send all held packets to the received audio stream to be (eventually) played
+ while (!_queue.empty()) {
+ _audioClient->_receivedAudioStream.parseData(*_queue.front());
+ _queue.pop();
+ }
+ _index = 0;
+}
+
+
+template
+void AudioPacketHandler::handleNoisyMutePacket(QSharedPointer message) {
+ if (!_isMuted) {
+ setMuted(true);
+
+ derived().onMutedByMixer();
+ // FIXME: CRTP
+ // have the audio scripting interface emit a signal to say we were muted by the mixer
+ // emit mutedByMixer();
+ }
+}
+
+template
+void AudioPacketHandler::handleMuteEnvironmentPacket(QSharedPointer message) {
+ glm::vec3 position;
+ float radius;
+
+ message->readPrimitive(&position);
+ message->readPrimitive(&radius);
+
+ // FIXME: CRTP
+ // emit muteEnvironmentRequested(position, radius);
+}
+
+template
+void AudioPacketHandler::negotiateAudioFormat() {
+ auto nodeList = DependencyManager::get();
+ auto negotiateFormatPacket = NLPacket::create(PacketType::NegotiateAudioFormat);
+ const auto& codecs = derived().getSupportedCodecs();
+ // FIXME: CRTP
+ // const auto& codecPlugins = PluginManager::getInstance()->getCodecPlugins();
+ quint8 numberOfCodecs = (quint8)codecs.size();
+ negotiateFormatPacket->writePrimitive(numberOfCodecs);
+ for (const auto& codec : codecs) {
+ auto codecName = codec->getName();
+ negotiateFormatPacket->writeString(codecName);
+ }
+
+ // grab our audio mixer from the NodeList, if it exists
+ SharedNodePointer audioMixer = nodeList->soloNodeOfType(NodeType::AudioMixer);
+
+ if (audioMixer) {
+ // send off this mute packet
+ nodeList->sendPacket(std::move(negotiateFormatPacket), *audioMixer);
+ }
+}
+
+template
+void AudioPacketHandler::handleSelectedAudioFormat(QSharedPointer message) {
+ QString selectedCodecName = message->readString();
+ selectAudioFormat(selectedCodecName);
+}
+
+template
+void AudioPacketHandler::selectAudioFormat(const QString& selectedCodecName) {
+
+ _selectedCodecName = selectedCodecName;
+
+ qCDebug(audioclient) << "Selected codec:" << _selectedCodecName << "; Is stereo input:" << (_desiredInputFormat.channelCount == AudioConstants::STEREO);
+
+ // release any old codec encoder/decoder first...
+ if (_codec && _encoder) {
+ _codec->releaseEncoder(_encoder);
+ _encoder = nullptr;
+ _codec = nullptr;
+ }
+ _receivedAudioStream.cleanupCodec();
+
+ const auto& codecs = derived().getSupportedCodecs();
+ // FIXME: CRTP
+ // const auto& codecPlugins = PluginManager::getInstance()->getCodecPlugins();
+ for (const auto& codec : codecs) {
+ if (_selectedCodecName == codec->getName()) {
+ _codec = codec;
+ _receivedAudioStream.setupCodec(codec, _selectedCodecName, AudioConstants::STEREO);
+ _encoder = codec->createEncoder(_desiredInputFormat.sampleRate, _desiredInputFormat.channelCount);
+ qCDebug(audioclient) << "Selected codec:" << _codec.get();
+ break;
+ }
+ }
+
+}
+
+template
+void AudioPacketHandler::configureReverb() {
+ ReverbParameters p;
+
+ p.sampleRate = AudioConstants::SAMPLE_RATE;
+ p.bandwidth = _reverbOptions->getBandwidth();
+ p.preDelay = _reverbOptions->getPreDelay();
+ p.lateDelay = _reverbOptions->getLateDelay();
+ p.reverbTime = _reverbOptions->getReverbTime();
+ p.earlyDiffusion = _reverbOptions->getEarlyDiffusion();
+ p.lateDiffusion = _reverbOptions->getLateDiffusion();
+ p.roomSize = _reverbOptions->getRoomSize();
+ p.density = _reverbOptions->getDensity();
+ p.bassMult = _reverbOptions->getBassMult();
+ p.bassFreq = _reverbOptions->getBassFreq();
+ p.highGain = _reverbOptions->getHighGain();
+ p.highFreq = _reverbOptions->getHighFreq();
+ p.modRate = _reverbOptions->getModRate();
+ p.modDepth = _reverbOptions->getModDepth();
+ p.earlyGain = _reverbOptions->getEarlyGain();
+ p.lateGain = _reverbOptions->getLateGain();
+ p.earlyMixLeft = _reverbOptions->getEarlyMixLeft();
+ p.earlyMixRight = _reverbOptions->getEarlyMixRight();
+ p.lateMixLeft = _reverbOptions->getLateMixLeft();
+ p.lateMixRight = _reverbOptions->getLateMixRight();
+ p.wetDryMix = _reverbOptions->getWetDryMix();
+
+ _listenerReverb.setParameters(&p);
+ _localReverb.setParameters(&p);
+
+ // used only for adding self-reverb to loopback audio
+ p.sampleRate = _outputFormat.sampleRate;
+ p.wetDryMix = 100.0f;
+ p.preDelay = 0.0f;
+ p.earlyGain = -96.0f; // disable ER
+ p.lateGain += _reverbOptions->getWetDryMix() * (24.0f / 100.0f) - 24.0f; // -0dB to -24dB, based on wetDryMix
+ p.lateMixLeft = 0.0f;
+ p.lateMixRight = 0.0f;
+
+ _sourceReverb.setParameters(&p);
+}
+
+template
+void AudioPacketHandler::updateReverbOptions() {
+ bool reverbChanged = false;
+ if (_receivedAudioStream.hasReverb()) {
+
+ if (_zoneReverbOptions.getReverbTime() != _receivedAudioStream.getRevebTime()) {
+ _zoneReverbOptions.setReverbTime(_receivedAudioStream.getRevebTime());
+ reverbChanged = true;
+ }
+ if (_zoneReverbOptions.getWetDryMix() != _receivedAudioStream.getWetLevel()) {
+ _zoneReverbOptions.setWetDryMix(_receivedAudioStream.getWetLevel());
+ reverbChanged = true;
+ }
+
+ if (_reverbOptions != &_zoneReverbOptions) {
+ _reverbOptions = &_zoneReverbOptions;
+ reverbChanged = true;
+ }
+ } else if (_reverbOptions != &_scriptReverbOptions) {
+ _reverbOptions = &_scriptReverbOptions;
+ reverbChanged = true;
+ }
+
+ if (reverbChanged) {
+ configureReverb();
+ }
+}
+
+template
+void AudioPacketHandler::setReverb(bool reverb) {
+ _reverb = reverb;
+
+ if (!_reverb) {
+ _sourceReverb.reset();
+ _listenerReverb.reset();
+ _localReverb.reset();
+ }
+}
+
+template
+void AudioPacketHandler::setReverbOptions(const AudioEffectOptions* options) {
+ // Save the new options
+ _scriptReverbOptions.setBandwidth(options->getBandwidth());
+ _scriptReverbOptions.setPreDelay(options->getPreDelay());
+ _scriptReverbOptions.setLateDelay(options->getLateDelay());
+ _scriptReverbOptions.setReverbTime(options->getReverbTime());
+ _scriptReverbOptions.setEarlyDiffusion(options->getEarlyDiffusion());
+ _scriptReverbOptions.setLateDiffusion(options->getLateDiffusion());
+ _scriptReverbOptions.setRoomSize(options->getRoomSize());
+ _scriptReverbOptions.setDensity(options->getDensity());
+ _scriptReverbOptions.setBassMult(options->getBassMult());
+ _scriptReverbOptions.setBassFreq(options->getBassFreq());
+ _scriptReverbOptions.setHighGain(options->getHighGain());
+ _scriptReverbOptions.setHighFreq(options->getHighFreq());
+ _scriptReverbOptions.setModRate(options->getModRate());
+ _scriptReverbOptions.setModDepth(options->getModDepth());
+ _scriptReverbOptions.setEarlyGain(options->getEarlyGain());
+ _scriptReverbOptions.setLateGain(options->getLateGain());
+ _scriptReverbOptions.setEarlyMixLeft(options->getEarlyMixLeft());
+ _scriptReverbOptions.setEarlyMixRight(options->getEarlyMixRight());
+ _scriptReverbOptions.setLateMixLeft(options->getLateMixLeft());
+ _scriptReverbOptions.setLateMixRight(options->getLateMixRight());
+ _scriptReverbOptions.setWetDryMix(options->getWetDryMix());
+
+ if (_reverbOptions == &_scriptReverbOptions) {
+ // Apply them to the reverb instances
+ configureReverb();
+ }
+}
+
+#if defined(WEBRTC_AUDIO)
+
+static void deinterleaveToFloat(const int16_t* src, float* const* dst, int numFrames, int numChannels) {
+ for (int i = 0; i < numFrames; i++) {
+ for (int ch = 0; ch < numChannels; ch++) {
+ float f = *src++;
+ f *= (1/32768.0f); // scale
+ dst[ch][i] = f; // deinterleave
+ }
+ }
+}
+
+static void interleaveToInt16(const float* const* src, int16_t* dst, int numFrames, int numChannels) {
+ for (int i = 0; i < numFrames; i++) {
+ for (int ch = 0; ch < numChannels; ch++) {
+ float f = src[ch][i];
+ f *= 32768.0f; // scale
+ f += (f < 0.0f) ? -0.5f : 0.5f; // round
+ f = std::max(std::min(f, 32767.0f), -32768.0f); // saturate
+ *dst++ = (int16_t)f; // interleave
+ }
+ }
+}
+
+template
+void AudioPacketHandler::configureWebrtc() {
+ _apm = webrtc::AudioProcessingBuilder().Create();
+
+ webrtc::AudioProcessing::Config config;
+
+ config.pre_amplifier.enabled = false;
+ config.high_pass_filter.enabled = false;
+ config.echo_canceller.enabled = true;
+ config.echo_canceller.mobile_mode = false;
+#if defined(WEBRTC_LEGACY)
+ config.echo_canceller.use_legacy_aec = false;
+#endif
+ config.noise_suppression.enabled = false;
+ config.noise_suppression.level = webrtc::AudioProcessing::Config::NoiseSuppression::kModerate;
+ config.voice_detection.enabled = false;
+ config.gain_controller1.enabled = false;
+ config.gain_controller2.enabled = false;
+ config.gain_controller2.fixed_digital.gain_db = 0.0f;
+ config.gain_controller2.adaptive_digital.enabled = false;
+ config.residual_echo_detector.enabled = true;
+ config.level_estimation.enabled = false;
+
+ _apm->ApplyConfig(config);
+}
+
+// rebuffer into 10ms chunks
+template
+void AudioPacketHandler::processWebrtcFarEnd(const int16_t* samples, int numFrames, int numChannels, int sampleRate) {
+
+ const webrtc::StreamConfig streamConfig = webrtc::StreamConfig(sampleRate, numChannels);
+ const int numChunk = (int)streamConfig.num_frames();
+
+ static int32_t lastWarningHash = 0;
+ if (sampleRate > WEBRTC_SAMPLE_RATE_MAX || numChannels > WEBRTC_CHANNELS_MAX) {
+ if (lastWarningHash != ((sampleRate << 8) | numChannels)) {
+ lastWarningHash = ((sampleRate << 8) | numChannels);
+ qCWarning(audioclient) << "AEC not unsupported for output format: sampleRate =" << sampleRate << "numChannels =" << numChannels;
+ }
+ return;
+ }
+
+ while (numFrames > 0) {
+
+ // number of frames to fill
+ int numFill = std::min(numFrames, numChunk - _numFifoFarEnd);
+
+ // refill fifo
+ memcpy(&_fifoFarEnd[_numFifoFarEnd], samples, numFill * numChannels * sizeof(int16_t));
+ samples += numFill * numChannels;
+ numFrames -= numFill;
+ _numFifoFarEnd += numFill;
+
+ if (_numFifoFarEnd == numChunk) {
+
+ // convert audio format
+ float buffer[WEBRTC_CHANNELS_MAX][WEBRTC_FRAMES_MAX];
+ float* const buffers[WEBRTC_CHANNELS_MAX] = { buffer[0], buffer[1] };
+ deinterleaveToFloat(_fifoFarEnd, buffers, numChunk, numChannels);
+
+ // process one chunk
+ int error = _apm->ProcessReverseStream(buffers, streamConfig, streamConfig, buffers);
+ if (error != _apm->kNoError) {
+ qCWarning(audioclient) << "WebRTC ProcessReverseStream() returned ERROR:" << error;
+ }
+ _numFifoFarEnd = 0;
+ }
+ }
+}
+
+template
+void AudioPacketHandler::processWebrtcNearEnd(int16_t* samples, int numFrames, int numChannels, int sampleRate) {
+
+ const webrtc::StreamConfig streamConfig = webrtc::StreamConfig(sampleRate, numChannels);
+ assert(numFrames == (int)streamConfig.num_frames()); // WebRTC requires exactly 10ms of input
+
+ static int32_t lastWarningHash = 0;
+ if (sampleRate > WEBRTC_SAMPLE_RATE_MAX || numChannels > WEBRTC_CHANNELS_MAX) {
+ if (lastWarningHash != ((sampleRate << 8) | numChannels)) {
+ lastWarningHash = ((sampleRate << 8) | numChannels);
+ qCWarning(audioclient) << "AEC not unsupported for input format: sampleRate =" << sampleRate << "numChannels =" << numChannels;
+ }
+ return;
+ }
+
+ // convert audio format
+ float buffer[WEBRTC_CHANNELS_MAX][WEBRTC_FRAMES_MAX];
+ float* const buffers[WEBRTC_CHANNELS_MAX] = { buffer[0], buffer[1] };
+ deinterleaveToFloat(samples, buffers, numFrames, numChannels);
+
+ // process one chunk
+ int error = _apm->ProcessStream(buffers, streamConfig, streamConfig, buffers);
+ if (error != _apm->kNoError) {
+ qCWarning(audioclient) << "WebRTC ProcessStream() returned ERROR:" << error;
+ } else {
+ // modify samples in-place
+ interleaveToInt16(buffers, samples, numFrames, numChannels);
+ }
+}
+
+#endif // WEBRTC_AUDIO
+
+template
+float AudioPacketHandler::loudnessToLevel(float loudness) {
+ float level = loudness * (1 / 32768.0f); // level in [0, 1]
+ level = 6.02059991f * fastLog2f(level); // convert to dBFS
+ level = (level + 48.0f) * (1 / 42.0f); // map [-48, -6] dBFS to [0, 1]
+ return glm::clamp(level, 0.0f, 1.0f);
+}
+
+template
+void AudioPacketHandler::handleAudioInput(QByteArray& audioBuffer) {
+ if (!_audioPaused) {
+
+ bool audioGateOpen = false;
+
+ if (!_isMuted) {
+ int16_t* samples = reinterpret_cast(audioBuffer.data());
+ int numSamples = audioBuffer.size() / AudioConstants::SAMPLE_SIZE;
+ int numFrames = numSamples / _desiredInputFormat.channelCount;
+
+ if (_isNoiseGateEnabled && _isNoiseReductionAutomatic) {
+ // The audio gate includes DC removal
+ audioGateOpen = _audioGate->render(samples, samples, numFrames);
+ } else if (_isNoiseGateEnabled && !_isNoiseReductionAutomatic &&
+ loudnessToLevel(_lastSmoothedRawInputLoudness) >= _noiseReductionThreshold) {
+ audioGateOpen = _audioGate->removeDC(samples, samples, numFrames);
+ } else if (_isNoiseGateEnabled && !_isNoiseReductionAutomatic) {
+ audioGateOpen = false;
+ } else {
+ audioGateOpen = _audioGate->removeDC(samples, samples, numFrames);
+ }
+
+ // FIXME: CRTP
+ // emit inputReceived(audioBuffer);
+ }
+
+ // loudness after mute/gate
+ _lastInputLoudness = (_isMuted || !audioGateOpen) ? 0.0f : _lastRawInputLoudness;
+
+ // detect gate opening and closing
+ bool openedInLastBlock = !_audioGateOpen && audioGateOpen; // the gate just opened
+ bool closedInLastBlock = _audioGateOpen && !audioGateOpen; // the gate just closed
+ _audioGateOpen = audioGateOpen;
+
+ if (openedInLastBlock) {
+ //FIXME: CRTP
+ // emit noiseGateOpened();
+ } else if (closedInLastBlock) {
+ //FIXME: CRTP
+ // emit noiseGateClosed();
+ }
+
+ // the codec must be flushed to silence before sending silent packets,
+ // so delay the transition to silent packets by one packet after becoming silent.
+ auto packetType = _shouldEchoToServer ? PacketType::MicrophoneAudioWithEcho : PacketType::MicrophoneAudioNoEcho;
+ if (!audioGateOpen && !closedInLastBlock) {
+ packetType = PacketType::SilentAudioFrame;
+ _silentOutbound.increment();
+ } else {
+ _audioOutbound.increment();
+ }
+
+ QByteArray encodedBuffer;
+ if (_encoder) {
+ _encoder->encode(audioBuffer, encodedBuffer);
+ } else {
+ encodedBuffer = audioBuffer;
+ }
+
+ AbstractAudioInterface::emitAudioPacket(encodedBuffer.data(), encodedBuffer.size(), _outgoingAvatarAudioSequenceNumber, _desiredInputFormat.channelCount == AudioConstants::STEREO,
+ {_positionGetter(), _orientationGetter()}, avatarBoundingBoxCorner, avatarBoundingBoxScale,
+ packetType, _selectedCodecName);
+ _stats.sentPacket();
+ }
+}
+
+// CRTP: replaced libraries/audio-client/AudioClient::handleMicAudioInput
+// void AudioClient::handleMicAudioInput() {
+// if (!_inputDevice || _isPlayingBackRecording) {
+// return;
+// }
+// QByteArray inputByteArray = _inputDevice->readAll();
+//
+// #if defined(Q_OS_ANDROID)
+// _inputReadsSinceLastCheck++;
+// #endif
+//
+// handleLocalEchoAndReverb(inputByteArray);
+//
+// handleMicAudioInput(inputByteArray.data(), inputByteArray.size());
+// sendInput();
+// }
+
+template
+void AudioPacketHandler::handleMicAudioInput(const char* data, int size) {
+
+ const auto sampleBytes = _inputFormat.getSampleSize();
+ const auto trailingBytes = size % sampleBytes;
+ if (trailingBytes != 0) {
+ qCWarning(audioclient) << "Input buffer trailing bytes: " << trailingBytes;
+ size -= trailingBytes; // we ignore trailing bytes
+ }
+
+ if (_inputFormat.sampleType == AudioFormat::Float) {
+ _inputTypeConversionBuffer.resize(size / sizeof(float));
+ const auto floats = reinterpret_cast(data);
+ for (int i = 0; i < (int)_inputTypeConversionBuffer.size(); i+= _inputFormat.channelCount) {
+ for (int j = 0; j < _inputFormat.channelCount; ++j) {
+ _inputTypeConversionBuffer[i+j] = convertToSignedInt(floats[i+j]);
+ }
+ }
+
+ data = reinterpret_cast(_inputTypeConversionBuffer.data());
+ size = _inputTypeConversionBuffer.size() * sizeof(int16_t);
+ }
+
+ _inputRingBuffer.writeData(data, size);
+
+ float audioInputMsecsRead = size / (float)(_inputFormat.bytesForDuration(USECS_PER_MSEC));
+ _stats.updateInputMsRead(audioInputMsecsRead);
+}
+
+template
+void AudioPacketHandler::sendInput() {
+ const int numNetworkBytes = _desiredInputFormat.channelCount == AudioConstants::STEREO
+ ? AudioConstants::NETWORK_FRAME_BYTES_STEREO
+ : AudioConstants::NETWORK_FRAME_BYTES_PER_CHANNEL;
+ const int numNetworkSamples = _desiredInputFormat.channelCount == AudioConstants::STEREO
+ ? AudioConstants::NETWORK_FRAME_SAMPLES_STEREO
+ : AudioConstants::NETWORK_FRAME_SAMPLES_PER_CHANNEL;
+
+ // input samples required to produce exactly NETWORK_FRAME_SAMPLES of output
+ const int inputSamplesRequired = (_inputToNetworkResampler ?
+ _inputToNetworkResampler->getMinInput(AudioConstants::NETWORK_FRAME_SAMPLES_PER_CHANNEL) :
+ AudioConstants::NETWORK_FRAME_SAMPLES_PER_CHANNEL) * _inputFormat.channelCount;
+
+ static int16_t networkAudioSamples[AudioConstants::NETWORK_FRAME_SAMPLES_STEREO];
+ while (_inputRingBuffer.samplesAvailable() >= inputSamplesRequired) {
+
+ // TODO: this should at least be an std::vector to avoid
+ // unnecessary re-allocations, and better resized in
+ // setupInput() not here.
+ const auto inputAudioSamples = std::unique_ptr(new int16_t[inputSamplesRequired]);
+
+ _inputRingBuffer.readSamples(inputAudioSamples.get(), inputSamplesRequired);
+
+ // detect clipping on the raw input
+ bool isClipping = detectClipping(inputAudioSamples.get(), inputSamplesRequired, _inputFormat.channelCount);
+ if (isClipping) {
+ _timeSinceLastClip = 0.0f;
+ } else if (_timeSinceLastClip >= 0.0f) {
+ _timeSinceLastClip += AudioConstants::NETWORK_FRAME_SECS;
+ }
+ isClipping = (_timeSinceLastClip >= 0.0f) && (_timeSinceLastClip < 2.0f); // 2 second hold time
+
+#if defined(WEBRTC_AUDIO)
+ if (_isAECEnabled) {
+ processWebrtcNearEnd(inputAudioSamples.get(), inputSamplesRequired / _inputFormat.channelCount,
+ _inputFormat.channelCount, _inputFormat.sampleRate);
+ }
+#endif
+
+ float loudness = computeLoudness(inputAudioSamples.get(), inputSamplesRequired);
+ _lastRawInputLoudness = loudness;
+
+ // envelope detection
+ float tc = (loudness > _lastSmoothedRawInputLoudness) ? 0.378f : 0.967f; // 10ms attack, 300ms release @ 100Hz
+ loudness += tc * (_lastSmoothedRawInputLoudness - loudness);
+ _lastSmoothedRawInputLoudness = loudness;
+
+ // FIXME: CRTP
+ // emit inputLoudnessChanged(_lastSmoothedRawInputLoudness, isClipping);
+
+ if (!_isMuted) {
+ possibleResampling(_inputToNetworkResampler,
+ inputAudioSamples.get(), networkAudioSamples,
+ inputSamplesRequired, numNetworkSamples,
+ _inputFormat.channelCount, _desiredInputFormat.channelCount);
+ }
+ int bytesInInputRingBuffer = _inputRingBuffer.samplesAvailable() * AudioConstants::SAMPLE_SIZE;
+ float msecsInInputRingBuffer = bytesInInputRingBuffer / (float)(_inputFormat.bytesForDuration(USECS_PER_MSEC));
+ _stats.updateInputMsUnplayed(msecsInInputRingBuffer);
+
+ QByteArray audioBuffer(reinterpret_cast(networkAudioSamples), numNetworkBytes);
+ handleAudioInput(audioBuffer);
+ }
+}
+
+template
+void AudioPacketHandler::handleRecordedAudioInput(const QByteArray& audio) {
+ QByteArray audioBuffer(audio);
+ handleAudioInput(audioBuffer);
+}
+
+template
+void AudioPacketHandler::prepareLocalAudioInjectors(std::unique_ptr localAudioLock) {
+ bool doSynchronously = localAudioLock.operator bool();
+ if (!localAudioLock) {
+ localAudioLock.reset(new Lock(_localAudioMutex));
+ }
+
+ int samplesNeeded = std::numeric_limits::max();
+ while (samplesNeeded > 0) {
+ if (!doSynchronously) {
+ // unlock between every write to allow device switching
+ localAudioLock->unlock();
+ localAudioLock->lock();
+ }
+
+ // in case of a device switch, consider bufferCapacity volatile across iterations
+ if (_outputPeriod == 0) {
+ return;
+ }
+
+ int bufferCapacity = _localInjectorsStream.getSampleCapacity();
+ int maxOutputSamples = AudioConstants::NETWORK_FRAME_SAMPLES_PER_CHANNEL * AudioConstants::STEREO;
+ if (_localToOutputResampler) {
+ maxOutputSamples =
+ _localToOutputResampler->getMaxOutput(AudioConstants::NETWORK_FRAME_SAMPLES_PER_CHANNEL) *
+ AudioConstants::STEREO;
+ }
+
+ samplesNeeded = bufferCapacity - _localSamplesAvailable.load(std::memory_order_relaxed);
+ if (samplesNeeded < maxOutputSamples) {
+ // avoid overwriting the buffer to prevent losing frames
+ break;
+ }
+
+ // get a network frame of local injectors' audio
+ if (!mixLocalAudioInjectors(_localMixBuffer)) {
+ break;
+ }
+
+ // reverb
+ if (_reverb) {
+ _localReverb.render(_localMixBuffer, _localMixBuffer, AudioConstants::NETWORK_FRAME_SAMPLES_PER_CHANNEL);
+ }
+
+ int samples;
+ if (_localToOutputResampler) {
+ // resample to output sample rate
+ int frames = _localToOutputResampler->render(_localMixBuffer, _localOutputMixBuffer,
+ AudioConstants::NETWORK_FRAME_SAMPLES_PER_CHANNEL);
+
+ // write to local injectors' ring buffer
+ samples = frames * AudioConstants::STEREO;
+ _localInjectorsStream.writeSamples(_localOutputMixBuffer, samples);
+
+ } else {
+ // write to local injectors' ring buffer
+ samples = AudioConstants::NETWORK_FRAME_SAMPLES_STEREO;
+ _localInjectorsStream.writeSamples(_localMixBuffer,
+ AudioConstants::NETWORK_FRAME_SAMPLES_STEREO);
+ }
+
+ _localSamplesAvailable.fetch_add(samples, std::memory_order_release);
+ samplesNeeded -= samples;
+ }
+}
+
+template
+bool AudioPacketHandler::mixLocalAudioInjectors(float* mixBuffer) {
+ // check the flag for injectors before attempting to lock
+ if (!_localInjectorsAvailable.load(std::memory_order_acquire)) {
+ return false;
+ }
+
+ // lock the injectors
+ Lock lock(_injectorsMutex);
+
+ QVector injectorsToRemove;
+
+ memset(mixBuffer, 0, AudioConstants::NETWORK_FRAME_SAMPLES_STEREO * sizeof(float));
+
+ for (const AudioInjectorPointer& injector : _activeLocalAudioInjectors) {
+ // the lock guarantees that injectorBuffer, if found, is invariant
+ auto injectorBuffer = injector->getLocalBuffer();
+ if (injectorBuffer) {
+
+ auto options = injector->getOptions();
+
+ static const int HRTF_DATASET_INDEX = 1;
+
+ int numChannels = options.ambisonic ? AudioConstants::AMBISONIC : (options.stereo ? AudioConstants::STEREO : AudioConstants::MONO);
+ size_t bytesToRead = numChannels * AudioConstants::NETWORK_FRAME_BYTES_PER_CHANNEL;
+
+ // get one frame from the injector
+ memset(_localScratchBuffer, 0, bytesToRead);
+ if (0 < injectorBuffer->readData((char*)_localScratchBuffer, bytesToRead)) {
+
+ bool isSystemSound = !options.positionSet && !options.ambisonic;
+
+ float gain = options.volume * (isSystemSound ? _systemInjectorGain : _localInjectorGain);
+
+ if (options.ambisonic) {
+
+ if (options.positionSet) {
+
+ // distance attenuation
+ glm::vec3 relativePosition = options.position - _positionGetter();
+ float distance = glm::max(glm::length(relativePosition), EPSILON);
+ gain = gainForSource(distance, gain);
+ }
+
+ //
+ // Calculate the soundfield orientation relative to the listener.
+ // Injector orientation can be used to align a recording to our world coordinates.
+ //
+ glm::quat relativeOrientation = options.orientation * glm::inverse(_orientationGetter());
+
+ // convert from Y-up (OpenGL) to Z-up (Ambisonic) coordinate system
+ float qw = relativeOrientation.w;
+ float qx = -relativeOrientation.z;
+ float qy = -relativeOrientation.x;
+ float qz = relativeOrientation.y;
+
+ // spatialize into mixBuffer
+ injector->getLocalFOA().render(_localScratchBuffer, mixBuffer, HRTF_DATASET_INDEX,
+ qw, qx, qy, qz, gain, AudioConstants::NETWORK_FRAME_SAMPLES_PER_CHANNEL);
+ } else if (options.stereo) {
+
+ if (options.positionSet) {
+
+ // distance attenuation
+ glm::vec3 relativePosition = options.position - _positionGetter();
+ float distance = glm::max(glm::length(relativePosition), EPSILON);
+ gain = gainForSource(distance, gain);
+ }
+
+ // direct mix into mixBuffer
+ injector->getLocalHRTF().mixStereo(_localScratchBuffer, mixBuffer, gain,
+ AudioConstants::NETWORK_FRAME_SAMPLES_PER_CHANNEL);
+ } else { // injector is mono
+
+ if (options.positionSet) {
+
+ // distance attenuation
+ glm::vec3 relativePosition = options.position - _positionGetter();
+ float distance = glm::max(glm::length(relativePosition), EPSILON);
+ gain = gainForSource(distance, gain);
+
+ float azimuth = azimuthForSource(relativePosition);
+
+ // spatialize into mixBuffer
+ injector->getLocalHRTF().render(_localScratchBuffer, mixBuffer, HRTF_DATASET_INDEX,
+ azimuth, distance, gain, AudioConstants::NETWORK_FRAME_SAMPLES_PER_CHANNEL);
+ } else {
+
+ // direct mix into mixBuffer
+ injector->getLocalHRTF().mixMono(_localScratchBuffer, mixBuffer, gain,
+ AudioConstants::NETWORK_FRAME_SAMPLES_PER_CHANNEL);
+ }
+ }
+
+ } else {
+
+ //qCDebug(audioclient) << "injector has no more data, marking finished for removal";
+ injector->finishLocalInjection();
+ injectorsToRemove.append(injector);
+ }
+
+ } else {
+
+ //qCDebug(audioclient) << "injector has no local buffer, marking as finished for removal";
+ injector->finishLocalInjection();
+ injectorsToRemove.append(injector);
+ }
+ }
+
+ for (const AudioInjectorPointer& injector : injectorsToRemove) {
+ //qCDebug(audioclient) << "removing injector";
+ _activeLocalAudioInjectors.removeOne(injector);
+ }
+
+ // update the flag
+ _localInjectorsAvailable.exchange(!_activeLocalAudioInjectors.empty(), std::memory_order_release);
+
+ return true;
+}
+
+template
+void AudioPacketHandler::processReceivedSamples(const QByteArray& decodedBuffer, QByteArray& outputBuffer) {
+
+ const int16_t* decodedSamples = reinterpret_cast(decodedBuffer.data());
+ assert(decodedBuffer.size() == AudioConstants::NETWORK_FRAME_BYTES_STEREO);
+
+ outputBuffer.resize(_outputFrameSize * AudioConstants::SAMPLE_SIZE);
+ int16_t* outputSamples = reinterpret_cast