moved time gap history to PositionalAudioRingBuffer, untested

removed hard-coded jitter buffer length.

assignment-client/src/audio/AudioMixer.cpp

@@ -54,9 +54,6 @@
 
 #include "AudioMixer.h"
 
-const short JITTER_BUFFER_MSECS = 12;
-const short JITTER_BUFFER_SAMPLES = JITTER_BUFFER_MSECS * (SAMPLE_RATE / 1000.0);
-
 const float LOUDNESS_TO_DISTANCE_RATIO = 0.00001f;
 
 const QString AUDIO_MIXER_LOGGING_TARGET_NAME = "audio-mixer";
@@ -487,8 +484,7 @@ void AudioMixer::run() {
         
         foreach (const SharedNodePointer& node, nodeList->getNodeHash()) {
             if (node->getLinkedData()) {
-                ((AudioMixerClientData*) node->getLinkedData())->checkBuffersBeforeFrameSend(JITTER_BUFFER_SAMPLES,
+                ((AudioMixerClientData*) node->getLinkedData())->checkBuffersBeforeFrameSend(_sourceUnattenuatedZone,
-                                                                                             _sourceUnattenuatedZone,
                                                                                              _listenerUnattenuatedZone);
             }
         }

assignment-client/src/audio/AudioMixerClientData.cpp

@@ -98,10 +98,9 @@ int AudioMixerClientData::parseData(const QByteArray& packet) {
     return 0;
 }
 
-void AudioMixerClientData::checkBuffersBeforeFrameSend(int jitterBufferLengthSamples,
+void AudioMixerClientData::checkBuffersBeforeFrameSend(AABox* checkSourceZone, AABox* listenerZone) {
-                                                       AABox* checkSourceZone, AABox* listenerZone) {
     for (int i = 0; i < _ringBuffers.size(); i++) {
-        if (_ringBuffers[i]->shouldBeAddedToMix(jitterBufferLengthSamples)) {
+        if (_ringBuffers[i]->shouldBeAddedToMix()) {
             // this is a ring buffer that is ready to go
             // set its flag so we know to push its buffer when all is said and done
             _ringBuffers[i]->setWillBeAddedToMix(true);

assignment-client/src/audio/AudioMixerClientData.h

@@ -27,8 +27,7 @@ public:
     AvatarAudioRingBuffer* getAvatarAudioRingBuffer() const;
     
     int parseData(const QByteArray& packet);
-    void checkBuffersBeforeFrameSend(int jitterBufferLengthSamples,
+    void checkBuffersBeforeFrameSend(AABox* checkSourceZone = NULL, AABox* listenerZone = NULL);
-                                     AABox* checkSourceZone = NULL, AABox* listenerZone = NULL);
     void pushBuffersAfterFrameSend();
 private:
     QList<PositionalAudioRingBuffer*> _ringBuffers;

assignment-client/src/audio/AvatarAudioRingBuffer.cpp

@@ -19,7 +19,8 @@ AvatarAudioRingBuffer::AvatarAudioRingBuffer(bool isStereo) :
 }
 
 int AvatarAudioRingBuffer::parseData(const QByteArray& packet) {
-    _timeGapHistory.frameReceived();
+    _interframeTimeGapHistory.frameReceived();
+    updateDesiredJitterBufferNumSamples();
 
     _shouldLoopbackForNode = (packetTypeForPacket(packet) == PacketTypeMicrophoneAudioWithEcho);
     return PositionalAudioRingBuffer::parseData(packet);

libraries/audio/src/AudioRingBuffer.cpp

@@ -12,7 +12,6 @@
 #include <cstring>
 #include <functional>
 #include <math.h>
-#include "SharedUtil.h"
 
 #include <QtCore/QDebug>
 
@@ -20,62 +19,6 @@
 
 #include "AudioRingBuffer.h"
 
-InterframeTimeGapHistory::InterframeTimeGapHistory()
-    : _lastFrameReceivedTime(0),
-    _numSamplesInCurrentInterval(0),
-    _currentIntervalMaxGap(0),
-    _newestIntervalMaxGapAt(0),
-    _windowMaxGap(0),
-    _newWindowMaxGapAvailable(false)
-{
-    memset(_intervalMaxGaps, 0, TIME_GAP_NUM_INTERVALS_IN_WINDOW*sizeof(quint64));
-}
-
-void InterframeTimeGapHistory::frameReceived() {
-    quint64 now = usecTimestampNow();
-
-    // make sure this isn't the first time frameReceived() is called, meaning there's actually a gap to calculate.
-    if (_lastFrameReceivedTime != 0) {
-        quint64 gap = now - _lastFrameReceivedTime;
-
-        // update the current interval max
-        if (gap > _currentIntervalMaxGap) {
-            _currentIntervalMaxGap = gap;
-        }
-        _numSamplesInCurrentInterval++;
-
-        // if the current interval of samples is now full, record it in our interval maxes
-        if (_numSamplesInCurrentInterval == TIME_GAP_NUM_SAMPLES_IN_INTERVAL) {
-
-            // find location to insert this interval's max (increment index cyclically)
-            _newestIntervalMaxGapAt = _newestIntervalMaxGapAt == TIME_GAP_NUM_INTERVALS_IN_WINDOW - 1 ? 0 : _newestIntervalMaxGapAt + 1;
-
-            // record the current interval's max gap as the newest
-            _intervalMaxGaps[_newestIntervalMaxGapAt] = _currentIntervalMaxGap;
-
-            // update the window max gap, which is the max out of all the past intervals' max gaps
-            _windowMaxGap = 0;
-            for (int i = 0; i < TIME_GAP_NUM_INTERVALS_IN_WINDOW; i++) {
-                if (_intervalMaxGaps[i] > _windowMaxGap) {
-                    _windowMaxGap = _intervalMaxGaps[i];
-                }
-            }
-            _newWindowMaxGapAvailable = true;
-
-            // reset the current interval
-            _numSamplesInCurrentInterval = 0;
-            _currentIntervalMaxGap = 0;
-        }
-    }
-    _lastFrameReceivedTime = now;
-}
-
-quint64 InterframeTimeGapHistory::getPastWindowMaxGap() {
-    _newWindowMaxGapAvailable = false;
-    return _windowMaxGap;
-}
-
-
 AudioRingBuffer::AudioRingBuffer(int numFrameSamples, bool randomAccessMode) :
     NodeData(),
     _sampleCapacity(numFrameSamples * RING_BUFFER_LENGTH_FRAMES),

libraries/audio/src/AudioRingBuffer.h

@@ -21,31 +21,6 @@
 
 #include "NodeData.h"
 
-// this means that every 500 samples, the max for the past 10*500 samples will be calculated
-const int TIME_GAP_NUM_SAMPLES_IN_INTERVAL = 500;
-const int TIME_GAP_NUM_INTERVALS_IN_WINDOW = 10;
-
-// class used to track time between incoming frames for the purpose of varying the jitter buffer length
-class InterframeTimeGapHistory {
-public:
-    InterframeTimeGapHistory();
-
-    void frameReceived();
-    bool isNewWindowMaxGapAvailable() const { return _newWindowMaxGapAvailable; }
-    quint64 getPastWindowMaxGap();
-
-private:
-    quint64 _lastFrameReceivedTime;
-
-    int _numSamplesInCurrentInterval;
-    quint64 _currentIntervalMaxGap;
-    quint64 _intervalMaxGaps[TIME_GAP_NUM_INTERVALS_IN_WINDOW];
-    int _newestIntervalMaxGapAt;
-    quint64 _windowMaxGap;
-    bool _newWindowMaxGapAvailable;
-};
-
-
 const int SAMPLE_RATE = 24000;
 
 const int NETWORK_BUFFER_LENGTH_BYTES_STEREO = 1024;
@@ -99,15 +74,14 @@ public:
     bool hasStarted() const { return _hasStarted; }
     
     void addSilentFrame(int numSilentSamples);
-
+    
-    InterframeTimeGapHistory& getInterframeTimeGapHistory() { return _timeGapHistory; }
 protected:
     // disallow copying of AudioRingBuffer objects
     AudioRingBuffer(const AudioRingBuffer&);
     AudioRingBuffer& operator= (const AudioRingBuffer&);
     
     int16_t* shiftedPositionAccomodatingWrap(int16_t* position, int numSamplesShift) const;
-    
+
     int _sampleCapacity;
     int _numFrameSamples;
     int16_t* _nextOutput;
@@ -116,8 +90,6 @@ protected:
     bool _isStarved;
     bool _hasStarted;
     bool _randomAccessMode; /// will this ringbuffer be used for random access? if so, do some special processing
-
-    InterframeTimeGapHistory _timeGapHistory;
 };
 
 #endif // hifi_AudioRingBuffer_h

libraries/audio/src/InjectedAudioRingBuffer.cpp

@@ -31,7 +31,8 @@ InjectedAudioRingBuffer::InjectedAudioRingBuffer(const QUuid& streamIdentifier)
 const uchar MAX_INJECTOR_VOLUME = 255;
 
 int InjectedAudioRingBuffer::parseData(const QByteArray& packet) {
-    _timeGapHistory.frameReceived();
+    _interframeTimeGapHistory.frameReceived();
+    updateDesiredJitterBufferNumSamples();
 
     // setup a data stream to read from this packet
     QDataStream packetStream(packet);

libraries/audio/src/PositionalAudioRingBuffer.cpp

@@ -19,6 +19,63 @@
 #include <UUID.h>
 
 #include "PositionalAudioRingBuffer.h"
+#include "SharedUtil.h"
+
+InterframeTimeGapHistory::InterframeTimeGapHistory()
+    : _lastFrameReceivedTime(0),
+    _numSamplesInCurrentInterval(0),
+    _currentIntervalMaxGap(0),
+    _newestIntervalMaxGapAt(0),
+    _windowMaxGap(0),
+    _newWindowMaxGapAvailable(false)
+{
+    memset(_intervalMaxGaps, 0, TIME_GAP_NUM_INTERVALS_IN_WINDOW*sizeof(quint64));
+}
+
+void InterframeTimeGapHistory::frameReceived() {
+    quint64 now = usecTimestampNow();
+
+    // make sure this isn't the first time frameReceived() is called, meaning there's actually a gap to calculate.
+    if (_lastFrameReceivedTime != 0) {
+        quint64 gap = now - _lastFrameReceivedTime;
+
+        // update the current interval max
+        if (gap > _currentIntervalMaxGap) {
+            _currentIntervalMaxGap = gap;
+        }
+        _numSamplesInCurrentInterval++;
+
+        // if the current interval of samples is now full, record it in our interval maxes
+        if (_numSamplesInCurrentInterval == TIME_GAP_NUM_SAMPLES_IN_INTERVAL) {
+
+            // find location to insert this interval's max (increment index cyclically)
+            _newestIntervalMaxGapAt = _newestIntervalMaxGapAt == TIME_GAP_NUM_INTERVALS_IN_WINDOW - 1 ? 0 : _newestIntervalMaxGapAt + 1;
+
+            // record the current interval's max gap as the newest
+            _intervalMaxGaps[_newestIntervalMaxGapAt] = _currentIntervalMaxGap;
+
+            // update the window max gap, which is the max out of all the past intervals' max gaps
+            _windowMaxGap = 0;
+            for (int i = 0; i < TIME_GAP_NUM_INTERVALS_IN_WINDOW; i++) {
+                if (_intervalMaxGaps[i] > _windowMaxGap) {
+                    _windowMaxGap = _intervalMaxGaps[i];
+                }
+            }
+            _newWindowMaxGapAvailable = true;
+
+            // reset the current interval
+            _numSamplesInCurrentInterval = 0;
+            _currentIntervalMaxGap = 0;
+        }
+    }
+    _lastFrameReceivedTime = now;
+}
+
+quint64 InterframeTimeGapHistory::getWindowMaxGap() {
+    _newWindowMaxGapAvailable = false;
+    return _windowMaxGap;
+}
+
 
 PositionalAudioRingBuffer::PositionalAudioRingBuffer(PositionalAudioRingBuffer::Type type, bool isStereo) :
     AudioRingBuffer(isStereo ? NETWORK_BUFFER_LENGTH_SAMPLES_STEREO : NETWORK_BUFFER_LENGTH_SAMPLES_PER_CHANNEL),
@@ -29,7 +86,8 @@ PositionalAudioRingBuffer::PositionalAudioRingBuffer(PositionalAudioRingBuffer::
     _shouldLoopbackForNode(false),
     _shouldOutputStarveDebug(true),
     _isStereo(isStereo),
-    _listenerUnattenuatedZone(NULL)
+    _listenerUnattenuatedZone(NULL),
+    _desiredJitterBufferNumSamples(getNumSamplesPerFrame())
 {
 
 }
@@ -106,14 +164,17 @@ void PositionalAudioRingBuffer::updateNextOutputTrailingLoudness() {
     }
 }
 
-bool PositionalAudioRingBuffer::shouldBeAddedToMix(int numJitterBufferSamples) {
+bool PositionalAudioRingBuffer::shouldBeAddedToMix() {
-    if (!isNotStarvedOrHasMinimumSamples(NETWORK_BUFFER_LENGTH_SAMPLES_PER_CHANNEL + numJitterBufferSamples)) {
+
+    int samplesPerFrame = getNumSamplesPerFrame();
+
+    if (!isNotStarvedOrHasMinimumSamples(samplesPerFrame + _desiredJitterBufferNumSamples)) {
         if (_shouldOutputStarveDebug) {
             _shouldOutputStarveDebug = false;
         }
         
         return false;
-    } else if (samplesAvailable() < NETWORK_BUFFER_LENGTH_SAMPLES_PER_CHANNEL) {
+    } else if (samplesAvailable() < samplesPerFrame) {
         _isStarved = true;
         
         // reset our _shouldOutputStarveDebug to true so the next is printed
@@ -132,3 +193,13 @@ bool PositionalAudioRingBuffer::shouldBeAddedToMix(int numJitterBufferSamples) {
 
     return false;
 }
+
+void PositionalAudioRingBuffer::updateDesiredJitterBufferNumSamples() {
+
+    const float USECS_PER_FRAME = NETWORK_BUFFER_LENGTH_SAMPLES_PER_CHANNEL * USECS_PER_SECOND / (float)SAMPLE_RATE;
+
+    if (_interframeTimeGapHistory.hasNewWindowMaxGapAvailable()) {
+        int desiredJitterBufferNumFrames = (int)((float)_interframeTimeGapHistory.getWindowMaxGap() / USECS_PER_FRAME + 0.5f);
+        _desiredJitterBufferNumSamples = desiredJitterBufferNumFrames * getNumSamplesPerFrame();
+    }
+}

libraries/audio/src/PositionalAudioRingBuffer.h

@@ -18,6 +18,31 @@
 
 #include "AudioRingBuffer.h"
 
+// this means that every 500 samples, the max for the past 10*500 samples will be calculated
+const int TIME_GAP_NUM_SAMPLES_IN_INTERVAL = 500;
+const int TIME_GAP_NUM_INTERVALS_IN_WINDOW = 10;
+
+// class used to track time between incoming frames for the purpose of varying the jitter buffer length
+class InterframeTimeGapHistory {
+public:
+    InterframeTimeGapHistory();
+
+    void frameReceived();
+    bool hasNewWindowMaxGapAvailable() const { return _newWindowMaxGapAvailable; }
+    quint64 getWindowMaxGap();
+
+private:
+    quint64 _lastFrameReceivedTime;
+
+    int _numSamplesInCurrentInterval;
+    quint64 _currentIntervalMaxGap;
+    quint64 _intervalMaxGaps[TIME_GAP_NUM_INTERVALS_IN_WINDOW];
+    int _newestIntervalMaxGapAt;
+    quint64 _windowMaxGap;
+    bool _newWindowMaxGapAvailable;
+};
+
+
 class PositionalAudioRingBuffer : public AudioRingBuffer {
 public:
     enum Type {
@@ -34,7 +59,7 @@ public:
     void updateNextOutputTrailingLoudness();
     float getNextOutputTrailingLoudness() const { return _nextOutputTrailingLoudness; }
     
-    bool shouldBeAddedToMix(int numJitterBufferSamples);
+    bool shouldBeAddedToMix();
     
     bool willBeAddedToMix() const { return _willBeAddedToMix; }
     void setWillBeAddedToMix(bool willBeAddedToMix) { _willBeAddedToMix = willBeAddedToMix; }
@@ -50,10 +75,14 @@ public:
     AABox* getListenerUnattenuatedZone() const { return _listenerUnattenuatedZone; }
     void setListenerUnattenuatedZone(AABox* listenerUnattenuatedZone) { _listenerUnattenuatedZone = listenerUnattenuatedZone; }
     
+    int getNumSamplesPerFrame() const { return _isStereo ? NETWORK_BUFFER_LENGTH_SAMPLES_STEREO : NETWORK_BUFFER_LENGTH_BYTES_PER_CHANNEL; }
+
 protected:
     // disallow copying of PositionalAudioRingBuffer objects
     PositionalAudioRingBuffer(const PositionalAudioRingBuffer&);
     PositionalAudioRingBuffer& operator= (const PositionalAudioRingBuffer&);
+
+    void updateDesiredJitterBufferNumSamples();
     
     PositionalAudioRingBuffer::Type _type;
     glm::vec3 _position;
@@ -65,6 +94,9 @@ protected:
     
     float _nextOutputTrailingLoudness;
     AABox* _listenerUnattenuatedZone;
+
+    InterframeTimeGapHistory _interframeTimeGapHistory;
+    int _desiredJitterBufferNumSamples;
 };
 
 #endif // hifi_PositionalAudioRingBuffer_h