#2333 Fixes call audio prioritization (#2555)

Co-authored-by: denny <dennis.sheirer@gmail.com>

src/main/java/io/github/dsheirer/audio/playback/AudioChannel.java

@@ -46,6 +46,12 @@ public class AudioChannel implements Listener<IdentifierUpdateNotification>
      * sample rate.
      */
     public static final int SAMPLES_PER_INTERVAL = 160;
+    /**
+     * Quantity of consecutive intervals without new audio (1 second) before an incomplete audio segment is treated as
+     * stalled and abandoned.  An audio segment is delivered once to a single channel, so abandoning a segment that is
+     * still live loses the rest of the call.  This has to tolerate decoder gaps, such as a missed P25 LDU (180 ms).
+     */
+    static final int MAX_STALLED_INTERVALS = 50;
     private static final Logger LOGGER = LoggerFactory.getLogger(AudioChannel.class);
     private final AudioBuffer mAudioBuffer = new AudioBuffer();
     private final Broadcaster<AudioEvent> mAudioEventBroadcaster = new Broadcaster<>();
@@ -225,7 +231,7 @@ public class AudioChannel implements Listener<IdentifierUpdateNotification>
         }
 
         //Dispose completed/fully-played audio segments and segments that have stalled/failed to progress
-        if(mCurrentAudioSegment != null && ((mNoAudioFromSegmentIntervalCount >= 6) ||
+        if(mCurrentAudioSegment != null && ((mNoAudioFromSegmentIntervalCount >= MAX_STALLED_INTERVALS) ||
           (mCurrentAudioSegment.isComplete() && (mCurrentBufferIndex >= mCurrentAudioSegment.getAudioBufferCount()))))
         {
             disposeCurrentAudioSegment();
@@ -401,6 +407,24 @@ public class AudioChannel implements Listener<IdentifierUpdateNotification>
         return mAudioSegmentQueue.isEmpty();
     }
 
+    /**
+     * Next audio segment queued for playback, without removing it from the queue.
+     * @return queued audio segment or null if the queue is empty.
+     */
+    AudioSegment peekQueuedAudioSegment()
+    {
+        return mAudioSegmentQueue.peek();
+    }
+
+    /**
+     * Removes the next audio segment from the queue, transferring it (and its consumer count) to the caller.
+     * @return queued audio segment or null if the queue is empty.
+     */
+    AudioSegment pollQueuedAudioSegment()
+    {
+        return mAudioSegmentQueue.poll();
+    }
+
     /**
      * Schedules the audio segment for playback.  The audio segment user count should already be incremented by the
      * calling entity.
@@ -475,6 +499,7 @@ public class AudioChannel implements Listener<IdentifierUpdateNotification>
         }
 
         mCurrentBufferIndex = -1;
+        mNoAudioFromSegmentIntervalCount = 0;
     }
 
     /**

src/main/java/io/github/dsheirer/audio/playback/AudioPlaybackManager.java

@@ -173,6 +173,7 @@ public class AudioPlaybackManager implements Listener<AudioSegment>, IAudioContr
         {
             Iterator<AudioSegment> it = mAudioSegments.iterator();
             AudioSegment audioSegment;
+            List<AudioSegment> displaced = new ArrayList<>();
 
             //Remove any audio segments flagged as do not monitor.  Don't remove completed segments yet, because
             //we want to give them a brief chance at playback.  Automatically assign linked audio segments to the
@@ -200,6 +201,16 @@ public class AudioPlaybackManager implements Listener<AudioSegment>, IAudioContr
                                 if(audioOutput.isLinkedTo(audioSegment))
                                 {
                                     it.remove();
+
+                                    //Linked audio continues the current call, so it goes ahead of anything queued
+                                    AudioSegment queued = audioOutput.pollQueuedAudioSegment();
+
+                                    while(queued != null)
+                                    {
+                                        displaced.add(queued);
+                                        queued = audioOutput.pollQueuedAudioSegment();
+                                    }
+
                                     audioOutput.play(audioSegment);
                                 }
                             }
@@ -212,6 +223,8 @@ public class AudioPlaybackManager implements Listener<AudioSegment>, IAudioContr
                 }
             }
 
+            mAudioSegments.addAll(displaced);
+
             //Sort audio segments by playback priority and assign to empty audio outputs
             if(!mAudioSegments.isEmpty() && mAudioOutput != null)
             {
@@ -232,6 +245,8 @@ public class AudioPlaybackManager implements Listener<AudioSegment>, IAudioContr
                             }
                         }
                     }
+
+                    replaceLowerPriorityQueuedSegments(mAudioSegments, mAudioOutput.getAudioProvider().getAudioChannels());
                 }
                 finally
                 {
@@ -255,6 +270,40 @@ public class AudioPlaybackManager implements Listener<AudioSegment>, IAudioContr
         }
     }
 
+    /**
+     * Swaps audio segments queued on the audio channels for waiting audio segments that have a higher playback priority,
+     * so that a segment queued behind the current playback can't hold a higher priority segment out of the channel.
+     * Audio that is currently playing is not interrupted.  Displaced segments are returned to the waiting list.
+     *
+     * @param waiting audio segments, sorted by playback priority.
+     * @param audioChannels to evaluate.
+     */
+    static void replaceLowerPriorityQueuedSegments(List<AudioSegment> waiting, List<AudioChannel> audioChannels)
+    {
+        for(AudioChannel audioChannel: audioChannels)
+        {
+            if(waiting.isEmpty())
+            {
+                return;
+            }
+
+            AudioSegment queued = audioChannel.peekQueuedAudioSegment();
+
+            if(queued != null &&
+               waiting.getFirst().monitorPriorityProperty().get() < queued.monitorPriorityProperty().get())
+            {
+                //The audio thread may have taken the queued segment since the peek, so only return what we removed.
+                queued = audioChannel.pollQueuedAudioSegment();
+                audioChannel.play(waiting.removeFirst());
+
+                if(queued != null)
+                {
+                    waiting.add(queued);
+                }
+            }
+        }
+    }
+
     public void dispose()
     {
         MyEventBus.getGlobalEventBus().unregister(this);