Identifier Framework and Message/Event Processing Overhaul (#455)

* WIP on new P25 message framer.

* WIP on new P25 message framer.

* Adds new 1/2 and 3/4 rate trellis decoders.  Still trying to chase
down why there is a sync pattern mismatch in the NID buffer queue.

* WIP - new p25 message framer works correctly now.  PDU's are dectected
and decoded using the 1/2 and 3/4 rate trellis decoders.  Packet
Sequences are assembled.  Need to add a new packet sequence message
factory that can detect Motorola Auto Registration Service (ARS)
formatted UDP/ID packets and SNDCP command packets.

* WIP - removes nullify on channel results queue.

* WIP - updates message framer for TSBK 1/2/3 processing.

* WIP removing P25 sync pattern and nid bits from all message parsers.

* WIP - merges identifier framework branch changes into this branch.

* WIP on updating link control words to new format and identifier framework.

* WIP - implements rest of link control words for extended formats

* WIP - initial work on ISP/OSP TSBK message restructuring.

* WIP - adds more TSBK ISP and OSP messages

* WIP - finished updating most of the TSBK ISP and OSP messages.  Converted
all messages to no longer include the NID (nac + dataunitID) so that
each message can simply hold the parsed values.  Removed AliasList as
an argument to each message and updated all messges to use the new
IIdentifer and IAPCO25Channel interfaces.

Removed legacy TDU and LDU link control messages and replaced with a
single LinkControlWord class hierarchy.

P25 decoder state is not yet updated for the new message structure.

PDU message parsing is not fully implemented.

* WIP - adds some Multi-Block trunking control messages with Alternate
and Unconfirmed formats.

* WIP - Fully implements AMBTC and UMBTC PDU message parsers.

Some package restructuring.

* WIP - Resolves Link control parsing in LDU1 and 2 messages.

* WIP - finishes updating TSBK and Link Control messages.  Adds support
for moto link control messages for patch groups.

* WIP - finishes updating TSBK and Link Control messages.  Adds support
for moto link control messages for patch groups.  Adds support for moto
ARS service, IPV4 decoding, and UDP/IP packets.

* WIP - finishes SNDCP packet data with header parsing.  Compressed IP or
UDP headers are not yet supported, but are logged as such.

* WIP - converts all talkgroup identifiers to integers and updates
alias list to create a per-protocol map of talkgroup id's to alias.

Inserts a legacy talkgroup (ltr, p25, passport, mpt1327, mdc, etc.)
conversion utility to convert existing legacy (string) talkgroups to
new integer talkgroup format.

Creates an audio packet manager to insert metadata into audio packets
before streaming packets for playback, recording, and/or streaming.

Creates identifier collection to manage current identifiers in each of
the channel and decoder states.

Creates simplified channel metadata to maintain the now playing display.

Moves channel attributes (alias list, system, site, name) as configuration
identifiers in the channel state.

Many other refactoring and updates.

* WIP - numerous updates to push use of identifier collection throughout
the system.  Updates the channel metadata and audio packet processing
logic.  Implements a large portion of the P25 decode state processing.
Updates traffic channel management.  Adds user preferences for timestamp
and identifier formatting, however doesn't add a user interface yet.

* WIP - initial implementation of user preferences editor window.

* WIP - updates preferences editor window to close and dispose window but
retain javafx event thread running.

* WIP - fully updates p25 decoder state and traffic channel processing to
use the new identifier framework.

Cleans up channel event processing and removes channel model as the sole
broadcaster of channel events.  Channel processing manager now listens
for all start/stop events and requestors dispatch event directly to the
channel processing manager.

Resolves issue in airspy that was causing user interface to lock-up.  The
issue appears to occur when the dongle is plugged into a usb port that
can't fully support the data rate.  sdrtrunk now recognizes these errors
and warns the user that they should use another usb port.

* WIP - updates alias action manager and adds new talkgroup range alias identifier.

Updates playlist to incorporate a version number so that the playlist
updater only runs when needed, to update a playlist to the correct
version format.

Updates user preferences to use the google event bus to broadcast
preference update notifications to remove the need for listeners to
register directly on the user preferences instance.

* WIP - updates alias id editors to flag invalid values and moves legacy
alias ids to legacy package.

Updates event logging configuration to add traffic channel decode events
and decoded message logging.  Removes binary message logging since that
is now replaced with demodulated bitstream recording.

* Removes system properties from user preferences.  Preferences are stored
in the OS-dependent settings store (windows - registry)

* Updates MapService to use new PlottableDecodeEvent instead of monitoring
all of the decoded messages.

Updates Fleetsync decoder and related messages to identifier framework.

* Updates LTR-Net, Fleetsync and LJ1200 decoders to new identifier
framework and adds support for user preferences for formatting of
LTR-Net and fleetsync talkgroup identifiers.

Breaks LTR-Net messages into various message types and uses a new
message factory.

Removes alias list from message processing for ltr-net, fleetsync and
lj1200.

* Updates LTR-Standard messages to Identifier framework.

* Removes Plottable and IPlottable from codebase.

* wip

* WIP on MPT-1327 messages.

* Updates MPT1327 decoder to identifier framework and new traffic channel
manager.  This decoder still needs to be updated with a new message
parser factory and a sync detector like what is now used for P25.

* Updates MDC1200 decoder and message to identifier framework.

* Updates Tait1200 and Passport decoders to identifier framework.

* Merges changes from master branch.

* Removes legacy alias support classes.  Updates passport message processor
to only pass valid messages.  Adds support to playlist updater for
converting passport mobile ids to become passport talkgroup values.

* Updates P25 decoder state and channel state to better track allocated
traffic channels.  Resolves issue in timestamp manager for trackig
message timestamps. Resolves issue in airspy tuner that was causing
the tuner to stop sending samples to the application.

* Update P25 Decoder state to process SNDCP management messages and
PDU messages.

Updates P25 activity summary to display network and site details.

Resolves issue with overlay panel that prevented enabled channels from
rendering correctly when zoomed in.

* Creates a new FilePreferences as part of the user preferences to begin
the transition of SystemProperties over to user preferences and consolidate
file preferences in one location.

Updates playlist manager to use the new file preferences and to use
default.xml as the new default playlist name, following conversion of
a playlist_v2.xml format to the new format.

In the near future, the user will be able to edit file locations and to
create/use other playlists.

Resolved an issue with all decoder states where not all identifiers were
being included in decode events.

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

@@ -0,0 +1,292 @@
+/*
+ * ******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2018 Dennis Sheirer
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ * *****************************************************************************
+ */
+package io.github.dsheirer.audio.playback;
+
+import com.google.common.eventbus.Subscribe;
+import io.github.dsheirer.alias.Alias;
+import io.github.dsheirer.alias.AliasList;
+import io.github.dsheirer.alias.AliasModel;
+import io.github.dsheirer.audio.AudioEvent;
+import io.github.dsheirer.eventbus.MyEventBus;
+import io.github.dsheirer.icon.IconManager;
+import io.github.dsheirer.identifier.Identifier;
+import io.github.dsheirer.identifier.IdentifierClass;
+import io.github.dsheirer.identifier.IdentifierCollection;
+import io.github.dsheirer.identifier.Role;
+import io.github.dsheirer.preference.PreferenceType;
+import io.github.dsheirer.preference.UserPreferences;
+import io.github.dsheirer.preference.identifier.TalkgroupFormatPreference;
+import io.github.dsheirer.properties.SystemProperties;
+import io.github.dsheirer.sample.Listener;
+import io.github.dsheirer.settings.ColorSetting;
+import io.github.dsheirer.settings.Setting;
+import io.github.dsheirer.settings.SettingChangeListener;
+import io.github.dsheirer.settings.SettingsManager;
+import net.miginfocom.swing.MigLayout;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.swing.ImageIcon;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import java.awt.Color;
+import java.awt.EventQueue;
+import java.awt.Font;
+import java.util.List;
+
+public class AudioChannelPanel extends JPanel implements Listener<AudioEvent>, SettingChangeListener
+{
+    private static final long serialVersionUID = 1L;
+    private static final Logger mLog = LoggerFactory.getLogger(AudioChannelPanel.class);
+
+    public static final String PROPERTY_PREFIX = "audio.channel.panel.color.";
+    public static final String PROPERTY_COLOR_BACKGROUND = PROPERTY_PREFIX + "background";
+    public static final String PROPERTY_COLOR_LABEL = PROPERTY_PREFIX + "label";
+    public static final String PROPERTY_COLOR_MUTED = PROPERTY_PREFIX + "muted";
+    public static final String PROPERTY_COLOR_VALUE = PROPERTY_PREFIX + "value";
+
+    private Font mFont = new Font(Font.MONOSPACED, Font.PLAIN, 16);
+
+    private Color mBackgroundColor;
+    private Color mLabelColor;
+    private Color mMutedColor;
+    private Color mValueColor;
+
+    private IconManager mIconManager;
+    private SettingsManager mSettingsManager;
+    private UserPreferences mUserPreferences;
+    private TalkgroupFormatPreference mTalkgroupFormatPreference;
+    private AudioOutput mAudioOutput;
+
+    private JLabel mMutedLabel = new JLabel("M");
+    private JLabel mChannelName = new JLabel(" ");
+    private JLabel mIconLabel = new JLabel(" ");
+    private JLabel mIdentifierLabel = new JLabel("-----");
+    private Identifier mIdentifier;
+    private Alias mAlias;
+
+    private boolean mConfigured = false;
+    private AliasModel mAliasModel;
+
+    public AudioChannelPanel(IconManager iconManager, UserPreferences userPreferences, SettingsManager settingsManager,
+                             AudioOutput audioOutput, AliasModel aliasModel)
+    {
+        mIconManager = iconManager;
+        mSettingsManager = settingsManager;
+        mSettingsManager.addListener(this);
+        mAliasModel = aliasModel;
+        mUserPreferences = userPreferences;
+        mTalkgroupFormatPreference = mUserPreferences.getTalkgroupFormatPreference();
+        mAudioOutput = audioOutput;
+
+        if(mAudioOutput != null)
+        {
+            mAudioOutput.addAudioEventListener(this);
+            mAudioOutput.setIdentifierCollectionListener(new AudioMetadataProcessor());
+        }
+
+        mBackgroundColor = SystemProperties.getInstance().get(PROPERTY_COLOR_BACKGROUND, Color.BLACK);
+        mLabelColor = SystemProperties.getInstance().get(PROPERTY_COLOR_LABEL, Color.LIGHT_GRAY);
+        mMutedColor = SystemProperties.getInstance().get(PROPERTY_COLOR_MUTED, Color.RED);
+        mValueColor = SystemProperties.getInstance().get(PROPERTY_COLOR_VALUE, Color.GREEN);
+
+        init();
+    }
+
+    /**
+     * Receives preference update notifications via the event bus
+     * @param preferenceType that was updated
+     */
+    @Subscribe
+    public void preferenceUpdated(PreferenceType preferenceType)
+    {
+        if(preferenceType == PreferenceType.IDENTIFIER)
+        {
+            updateLabels();
+        }
+    }
+
+    public void dispose()
+    {
+        //Deregister from receiving preference update notifications
+        MyEventBus.getEventBus().unregister(this);
+    }
+
+    private void init()
+    {
+        //Register to receive preference updates
+        MyEventBus.getEventBus().register(this);
+
+        setLayout(new MigLayout("align center center, insets 0 0 0 0",
+            "[][][align right]0[grow,fill]", ""));
+        setBackground(mBackgroundColor);
+
+        mMutedLabel.setFont(mFont);
+        mMutedLabel.setForeground(mMutedColor);
+        mMutedLabel.setVisible(false);
+        add(mMutedLabel);
+
+        mChannelName = new JLabel(mAudioOutput != null ? mAudioOutput.getChannelName() : " ");
+        mChannelName.setFont(mFont);
+        mChannelName.setForeground(mLabelColor);
+        add(mChannelName);
+
+        mIconLabel.setFont(mFont);
+        mIconLabel.setForeground(mValueColor);
+        add(mIconLabel);
+
+        mIdentifierLabel.setFont(mFont);
+        mIdentifierLabel.setForeground(mValueColor);
+        add(mIdentifierLabel, "wmin 10lp");
+    }
+
+    @Override
+    public void receive(final AudioEvent audioEvent)
+    {
+        switch(audioEvent.getType())
+        {
+            case AUDIO_STOPPED:
+                EventQueue.invokeLater(new Runnable()
+                {
+                    @Override
+                    public void run()
+                    {
+                        resetLabels();
+                    }
+                });
+                break;
+            case AUDIO_MUTED:
+            case AUDIO_UNMUTED:
+                EventQueue.invokeLater(new Runnable()
+                {
+                    @Override
+                    public void run()
+                    {
+                        mMutedLabel.setVisible(mAudioOutput.isMuted());
+                    }
+                });
+                break;
+            default:
+                break;
+        }
+    }
+
+    /**
+     * Resets the from and to labels.  Note: this does not happen on the swing
+     * event thread.  Only invoke from the swing thread.
+     */
+    private void resetLabels()
+    {
+        mIdentifier = null;
+        mAlias = null;
+        updateLabels();
+        mConfigured = false;
+    }
+
+    /**
+     * Truncates the string to the specified length using an ellipses at the end
+     * @param value to optionally truncate
+     * @param length of the final formatted string
+     * @return formatted string or null
+     */
+    private static String truncate(String value, int length)
+    {
+        if(value != null && value.length() > length)
+        {
+            return value.substring(0, length - 3) + "...";
+        }
+
+        return value;
+    }
+
+    /**
+     * Updates the alias label with text and icon from the alias.  Note: this
+     * does not occur on the Swing event thread -- wrap any calls to this
+     * method with an event thread call.
+     */
+    private void updateLabels()
+    {
+        String identifier = mAlias != null ? mAlias.getName() : mTalkgroupFormatPreference.format(mIdentifier);
+        final ImageIcon icon = mAlias != null ? mIconManager.getIcon(mAlias.getIconName(), 18) : null;
+        final String identifierText = (identifier != null ? truncate(identifier, 33) : "-----");
+
+        EventQueue.invokeLater(new Runnable()
+        {
+            @Override
+            public void run()
+            {
+                mIdentifierLabel.setText(identifierText);
+                mIconLabel.setIcon(icon);
+                mConfigured = true;
+            }
+        });
+
+    }
+
+    /**
+     * Processes audio metadata to update this panel's display values
+     */
+    public class AudioMetadataProcessor implements Listener<IdentifierCollection>
+    {
+        @Override
+        public void receive(final IdentifierCollection identifierCollection)
+        {
+            if(identifierCollection != null && (identifierCollection.isUpdated() || !mConfigured))
+            {
+                List<Identifier> toIds = identifierCollection.getIdentifiers(IdentifierClass.USER, Role.TO);
+                mIdentifier = !toIds.isEmpty() ? toIds.get(0) : null;
+                AliasList aliasList = mAliasModel.getAliasList(identifierCollection);
+                mAlias = (aliasList != null ? aliasList.getAlias(mIdentifier) : null);
+                updateLabels();
+            }
+        }
+    }
+
+
+    @Override
+    public void settingChanged(Setting setting)
+    {
+        if(setting instanceof ColorSetting)
+        {
+            ColorSetting colorSetting = (ColorSetting)setting;
+
+            switch(colorSetting.getColorSettingName())
+            {
+                case CHANNEL_STATE_LABEL_DECODER:
+                    if(mIdentifierLabel != null)
+                    {
+                        mIdentifierLabel.setForeground(mLabelColor);
+                    }
+                    if(mIconLabel != null)
+                    {
+                        mIconLabel.setForeground(mLabelColor);
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+
+    @Override
+    public void settingDeleted(Setting setting)
+    {
+    }
+}

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

@@ -0,0 +1,89 @@
+/*
+ * ******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2018 Dennis Sheirer
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ * *****************************************************************************
+ */
+package io.github.dsheirer.audio.playback;
+
+import io.github.dsheirer.alias.AliasModel;
+import io.github.dsheirer.audio.IAudioController;
+import io.github.dsheirer.icon.IconManager;
+import io.github.dsheirer.preference.UserPreferences;
+import io.github.dsheirer.settings.SettingsManager;
+import net.miginfocom.swing.MigLayout;
+
+import javax.swing.JPanel;
+import javax.swing.JSeparator;
+import java.awt.Color;
+import java.awt.Component;
+import java.util.List;
+
+public class AudioChannelsPanel extends JPanel
+{
+    private static final long serialVersionUID = 1L;
+
+    public AudioChannelsPanel(IconManager iconManager, UserPreferences userPreferences, SettingsManager settingsManager,
+                              IAudioController controller, AliasModel aliasModel)
+    {
+        setLayout(new MigLayout("insets 0 0 0 0", "[][sg abc,grow,fill][][sg abc,grow,fill]", "[grow,fill]"));
+
+        setBackground(Color.BLACK);
+
+        List<AudioOutput> outputs = controller.getAudioOutputs();
+
+        addSeparator();
+
+        for(int x = 0; x < outputs.size(); x++)
+        {
+            add(new AudioChannelPanel(iconManager, userPreferences, settingsManager, outputs.get(x), aliasModel));
+
+            if(x < outputs.size() - 1)
+            {
+                addSeparator();
+            }
+        }
+
+		/* Add an empty channel panel so that the panel is sized appropriately
+         * for either a single channel or two channels */
+        if(outputs.size() == 1)
+        {
+            addSeparator();
+            add(new AudioChannelPanel(iconManager, userPreferences, settingsManager, null, aliasModel), "growx");
+        }
+    }
+
+    /**
+     * Prepares for dispose to allow deregistering from services
+     */
+    public void dispose()
+    {
+        for(Component component: getComponents())
+        {
+            if(component instanceof AudioChannelPanel)
+            {
+                ((AudioChannelPanel)component).dispose();
+            }
+        }
+    }
+
+    private void addSeparator()
+    {
+        JSeparator separator = new JSeparator(JSeparator.VERTICAL);
+        separator.setBackground(Color.DARK_GRAY);
+        add(separator);
+    }
+}

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

@@ -0,0 +1,451 @@
+/*
+ * ******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2018 Dennis Sheirer
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ * *****************************************************************************
+ */
+package io.github.dsheirer.audio.playback;
+
+import io.github.dsheirer.audio.AudioEvent;
+import io.github.dsheirer.identifier.IdentifierCollection;
+import io.github.dsheirer.sample.Broadcaster;
+import io.github.dsheirer.sample.Listener;
+import io.github.dsheirer.sample.buffer.ReusableAudioPacket;
+import io.github.dsheirer.source.mixer.MixerChannel;
+import io.github.dsheirer.util.ThreadPool;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.sound.sampled.AudioFormat;
+import javax.sound.sampled.BooleanControl;
+import javax.sound.sampled.Control;
+import javax.sound.sampled.FloatControl;
+import javax.sound.sampled.Line;
+import javax.sound.sampled.LineEvent;
+import javax.sound.sampled.LineListener;
+import javax.sound.sampled.LineUnavailableException;
+import javax.sound.sampled.Mixer;
+import javax.sound.sampled.SourceDataLine;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.LinkedTransferQueue;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public abstract class AudioOutput implements Listener<ReusableAudioPacket>, LineListener
+{
+    private final static Logger mLog = LoggerFactory.getLogger(AudioOutput.class);
+
+    private LinkedTransferQueue<ReusableAudioPacket> mBuffer = new LinkedTransferQueue<>();
+    private int mBufferStartThreshold;
+    private int mBufferStopThreshold;
+
+    private Listener<IdentifierCollection> mIdentifierCollectionListener;
+    private Broadcaster<AudioEvent> mAudioEventBroadcaster = new Broadcaster<>();
+
+    private ScheduledFuture<?> mProcessorTask;
+
+    private SourceDataLine mOutput;
+    private Mixer mMixer;
+    private MixerChannel mMixerChannel;
+    private FloatControl mGainControl;
+    private BooleanControl mMuteControl;
+
+    private AudioEvent mAudioStartEvent;
+    private AudioEvent mAudioStopEvent;
+
+    private boolean mCanProcessAudio = false;
+    private long mLastActivity = System.currentTimeMillis();
+
+    /**
+     * Single audio channel playback with automatic starting and stopping of the
+     * underlying sourcedataline specified by the mixer and mixer channel
+     * arguments.
+     *
+     * Maintains an internal non-blocking audio packet queue and processes this
+     * queue 25 times a second (every 40 ms).
+     *
+     * @param mixer to obtain source data line
+     * @param mixerChannel either mono or left/right stereo
+     * @param audioFormat to use during playback
+     * @param lineInfo to use when obtaining the source data line
+     * @param requestedBufferSize of approximately 1 second of audio
+     */
+    public AudioOutput(Mixer mixer, MixerChannel mixerChannel, AudioFormat audioFormat, Line.Info lineInfo,
+                       int requestedBufferSize)
+    {
+        mMixer = mixer;
+        mMixerChannel = mixerChannel;
+
+        try
+        {
+            mOutput = (SourceDataLine) mMixer.getLine(lineInfo);
+
+            if(mOutput != null)
+            {
+                mOutput.open(audioFormat, requestedBufferSize);
+
+                //Start threshold: buffer is full with 10% or less of capacity remaining
+                mBufferStartThreshold = (int) (mOutput.getBufferSize() * 0.10);
+
+                //Stop threshold: buffer is empty with 90% or more capacity available
+                mBufferStopThreshold = (int) (mOutput.getBufferSize() * 0.90);
+
+                mOutput.addLineListener(this);
+
+                if(mOutput != null)
+                {
+                    try
+                    {
+                        Control gain = mOutput.getControl(FloatControl.Type.MASTER_GAIN);
+                        mGainControl = (FloatControl) gain;
+                    }
+                    catch(IllegalArgumentException iae)
+                    {
+                        mLog.warn("Couldn't obtain MASTER GAIN control for stereo line [" +
+                            mixer.getMixerInfo().getName() + " | " + getChannelName() + "]");
+                    }
+
+                    try
+                    {
+                        Control mute = mOutput.getControl(BooleanControl.Type.MUTE);
+                        mMuteControl = (BooleanControl) mute;
+                    }
+                    catch(IllegalArgumentException iae)
+                    {
+                        mLog.warn("Couldn't obtain MUTE control for stereo line [" +
+                            mixer.getMixerInfo().getName() + " | " + getChannelName() + "]");
+                    }
+
+					/* Run the queue processor task every 40 milliseconds or 25 times a second */
+                    mProcessorTask = ThreadPool.SCHEDULED.scheduleAtFixedRate(new BufferProcessor(),
+                        0, 40, TimeUnit.MILLISECONDS);
+                }
+
+                mAudioStartEvent = new AudioEvent(AudioEvent.Type.AUDIO_STARTED,
+                    getChannelName());
+                mAudioStopEvent = new AudioEvent(AudioEvent.Type.AUDIO_STOPPED,
+                    getChannelName());
+
+                mCanProcessAudio = true;
+            }
+        }
+        catch(LineUnavailableException e)
+        {
+            mLog.error("Couldn't obtain audio source data line for "
+                + "audio output - mixer [" + mMixer.getMixerInfo().getName() + "]");
+        }
+    }
+
+    public void reset()
+    {
+        broadcast(new AudioEvent(AudioEvent.Type.AUDIO_STOPPED, getChannelName()));
+    }
+
+    public void dispose()
+    {
+        mCanProcessAudio = false;
+
+        if(mProcessorTask != null)
+        {
+            mProcessorTask.cancel(true);
+        }
+
+        mProcessorTask = null;
+
+        mBuffer.clear();
+
+        mAudioEventBroadcaster.dispose();
+        mAudioEventBroadcaster = null;
+        mIdentifierCollectionListener = null;
+
+        if(mOutput != null)
+        {
+            mOutput.close();
+        }
+
+        mOutput = null;
+        mGainControl = null;
+        mMuteControl = null;
+    }
+
+    /**
+     * Converts the audio packet data into a byte buffer format appropriate for
+     * the underlying source data line.
+     */
+    protected abstract ByteBuffer convert(ReusableAudioPacket packet);
+
+    /**
+     * Audio output channel name
+     */
+    public String getChannelName()
+    {
+        return mMixerChannel.getLabel();
+    }
+
+    /**
+     * Mixer Channel for this audio output
+     */
+    protected MixerChannel getMixerChannel()
+    {
+        return mMixerChannel;
+    }
+
+    /**
+     * Registers a single listener to receive audio start and audio stop events
+     */
+    public void addAudioEventListener(Listener<AudioEvent> listener)
+    {
+        mAudioEventBroadcaster.addListener(listener);
+    }
+
+    public void removeAudioEventListener(Listener<AudioEvent> listener)
+    {
+        mAudioEventBroadcaster.removeListener(listener);
+    }
+
+    /**
+     * Broadcasts an audio event to the registered listener
+     */
+    private void broadcast(AudioEvent audioEvent)
+    {
+        mAudioEventBroadcaster.broadcast(audioEvent);
+    }
+
+    /**
+     * Registers a single listener to receive the audio metadata from each
+     * audio packet
+     */
+    public void setIdentifierCollectionListener(Listener<IdentifierCollection> listener)
+    {
+        mIdentifierCollectionListener = listener;
+    }
+
+    public void removeAudioMetadataListener()
+    {
+        mIdentifierCollectionListener = null;
+    }
+
+    /**
+     * Broadcasts audio identifier collection metadata to the registered listener
+     */
+    private void broadcast(IdentifierCollection identifierCollection)
+    {
+        if(mIdentifierCollectionListener != null)
+        {
+            mIdentifierCollectionListener.receive(identifierCollection);
+        }
+    }
+
+    /**
+     * Timestamp of either last buffer received or last buffer processed
+     */
+    public long getLastActivityTimestamp()
+    {
+        return mLastActivity;
+    }
+
+    /**
+     * Updates the last activity timestamp to current system time
+     */
+    public void updateTimestamp()
+    {
+        mLastActivity = System.currentTimeMillis();
+    }
+
+    @Override
+    public void receive(ReusableAudioPacket packet)
+    {
+        if(mCanProcessAudio)
+        {
+            //Update the activity timestamp so that this audio output doesn't
+            //get disconnected before it starts processing the audio stream
+            updateTimestamp();
+
+            mBuffer.add(packet);
+        }
+        else
+        {
+            packet.decrementUserCount();
+        }
+    }
+
+    public class BufferProcessor implements Runnable
+    {
+        private AtomicBoolean mProcessing = new AtomicBoolean();
+        private List<ReusableAudioPacket> mAudioPackets = new ArrayList<ReusableAudioPacket>();
+
+
+        public BufferProcessor()
+        {
+        }
+
+        @Override
+        public void run()
+        {
+            try
+            {
+				/* The processing flag ensures that only one instance of the
+				 * processor can run at any given time */
+                if(mProcessing.compareAndSet(false, true))
+                {
+                    mBuffer.drainTo(mAudioPackets);
+
+                    for(ReusableAudioPacket packet : mAudioPackets)
+                    {
+                        if(packet.getType() == ReusableAudioPacket.Type.AUDIO)
+                        {
+                            broadcast(packet.getIdentifierCollection());
+
+                            ByteBuffer buffer = convert(packet);
+
+                            int wrote = 0;
+
+                            if(!mOutput.isRunning())
+                            {
+                                int toWrite = mOutput.available();
+
+                                if(toWrite > buffer.array().length)
+                                {
+                                    toWrite = buffer.array().length;
+                                }
+
+                                //Top off the buffer and check if we can start it
+                                wrote += mOutput.write(buffer.array(), 0, toWrite);
+
+                                checkStart();
+                            }
+
+                            if(mOutput.isRunning() && wrote < buffer.array().length)
+                            {
+                                //Blocking write
+                                wrote += mOutput.write(buffer.array(), wrote,
+                                    buffer.array().length - wrote);
+                            }
+
+                            updateTimestamp();
+                        }
+                        else
+                        {
+                            packet.decrementUserCount();
+                        }
+                    }
+
+                    mAudioPackets.clear();
+
+                    checkStop();
+
+                    mProcessing.set(false);
+                }
+            }
+            catch(Exception e)
+            {
+                mLog.error("Error while processing audio buffers", e);
+            }
+        }
+
+        /**
+         * Starts audio playback once audio buffer is almost full and remaining
+         * capacity falls below the start threshold.
+         */
+        private void checkStart()
+        {
+            if(mCanProcessAudio &&
+                !mOutput.isRunning() &&
+                mOutput.available() <= mBufferStartThreshold)
+            {
+                mOutput.start();
+            }
+        }
+
+        /**
+         * Stops audio playback and drains the audio buffer to empty when the
+         * audio buffer is mostly empty and the available buffer capacity
+         * exceeds the stop threshold
+         */
+        private void checkStop()
+        {
+            if(mCanProcessAudio &&
+                mOutput.isRunning() &&
+                mOutput.available() >= mBufferStopThreshold)
+            {
+                mOutput.drain();
+                mOutput.stop();
+            }
+        }
+    }
+
+    /**
+     * Sets the mute state for this audio output channel
+     */
+    public void setMuted(boolean muted)
+    {
+        if(mMuteControl != null)
+        {
+            mMuteControl.setValue(muted);
+
+            broadcast(new AudioEvent(muted ? AudioEvent.Type.AUDIO_MUTED :
+                AudioEvent.Type.AUDIO_UNMUTED, getChannelName()));
+        }
+    }
+
+    /**
+     * Current mute state for this audio output channel
+     */
+    public boolean isMuted()
+    {
+        if(mMuteControl != null)
+        {
+            return mMuteControl.getValue();
+        }
+
+        return false;
+    }
+
+    /**
+     * Gain/volume control for this audio output channel, if one is available.
+     */
+    public FloatControl getGainControl()
+    {
+        return mGainControl;
+    }
+
+    public boolean hasGainControl()
+    {
+        return mGainControl != null;
+    }
+
+    /**
+     * Monitors the source data line playback state and broadcasts audio events
+     * to the registered listener as the state changes
+     */
+    @Override
+    public void update(LineEvent event)
+    {
+        LineEvent.Type type = event.getType();
+
+        if(type == LineEvent.Type.START)
+        {
+            mAudioEventBroadcaster.broadcast(mAudioStartEvent);
+        }
+        else if(type == LineEvent.Type.STOP)
+        {
+            mAudioEventBroadcaster.broadcast(mAudioStopEvent);
+        }
+    }
+}

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

@@ -0,0 +1,426 @@
+/*
+ * ******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2018 Dennis Sheirer
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ * *****************************************************************************
+ */
+package io.github.dsheirer.audio.playback;
+
+import io.github.dsheirer.alias.AliasModel;
+import io.github.dsheirer.audio.AudioEvent;
+import io.github.dsheirer.audio.AudioException;
+import io.github.dsheirer.audio.IAudioController;
+import io.github.dsheirer.icon.IconManager;
+import io.github.dsheirer.preference.UserPreferences;
+import io.github.dsheirer.sample.Listener;
+import io.github.dsheirer.settings.SettingsManager;
+import io.github.dsheirer.source.SourceManager;
+import io.github.dsheirer.source.mixer.MixerChannelConfiguration;
+import net.miginfocom.swing.MigLayout;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.sound.sampled.FloatControl;
+import javax.swing.ImageIcon;
+import javax.swing.JButton;
+import javax.swing.JMenu;
+import javax.swing.JMenuItem;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JPopupMenu;
+import javax.swing.JSlider;
+import javax.swing.SwingUtilities;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import java.awt.Color;
+import java.awt.EventQueue;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseListener;
+
+public class AudioPanel extends JPanel implements Listener<AudioEvent>
+{
+    private static final long serialVersionUID = 1L;
+
+    private static final Logger mLog = LoggerFactory.getLogger(AudioPanel.class);
+
+    private static ImageIcon MUTED_ICON = IconManager.getScaledIcon("images/audio_muted.png", 20);
+    private static ImageIcon UNMUTED_ICON = IconManager.getScaledIcon("images/audio_unmuted.png", 20);
+
+    private IconManager mIconManager;
+    private SettingsManager mSettingsManager;
+    private SourceManager mSourceManager;
+    private IAudioController mController;
+    private AliasModel mAliasModel;
+    private UserPreferences mUserPreferences;
+
+    private JButton mMuteButton;
+    private AudioChannelsPanel mAudioChannelsPanel;
+
+    public AudioPanel(IconManager iconManager, UserPreferences userPreferences, SettingsManager settingsManager,
+                      SourceManager sourceManager, IAudioController controller, AliasModel aliasModel)
+    {
+        mIconManager = iconManager;
+        mSettingsManager = settingsManager;
+        mSourceManager = sourceManager;
+        mController = controller;
+        mAliasModel = aliasModel;
+        mUserPreferences = userPreferences;
+
+        mController.addControllerListener(this);
+
+        init();
+    }
+
+    private void init()
+    {
+        setLayout(new MigLayout("insets 0 0 0 0", "[]0[grow,fill]", "[fill]0[]"));
+        setBackground(Color.BLACK);
+
+        mMuteButton = new MuteButton();
+        mMuteButton.setBackground(getBackground());
+        add(mMuteButton);
+
+        mAudioChannelsPanel = new AudioChannelsPanel(mIconManager, mUserPreferences, mSettingsManager, mController, mAliasModel);
+
+        add(mAudioChannelsPanel);
+
+        addMouseListener(new MouseSelectionListener());
+    }
+
+    @Override
+    public void receive(AudioEvent event)
+    {
+        switch(event.getType())
+        {
+            case AUDIO_CONFIGURATION_CHANGE_STARTED:
+                break;
+            case AUDIO_CONFIGURATION_CHANGE_COMPLETE:
+                EventQueue.invokeLater(new Runnable()
+                {
+                    @Override
+                    public void run()
+                    {
+                        remove(mAudioChannelsPanel);
+                        mAudioChannelsPanel.dispose();
+                        mAudioChannelsPanel = new AudioChannelsPanel(mIconManager, mUserPreferences, mSettingsManager, mController, mAliasModel);
+                        add(mAudioChannelsPanel);
+                        mAudioChannelsPanel.repaint();
+                        revalidate();
+                        repaint();
+                    }
+                });
+                break;
+            default:
+                break;
+        }
+    }
+
+    /**
+     * Audio output mute control menu item.
+     */
+    public class AudioOutputMuteItem extends JMenuItem
+    {
+        private static final long serialVersionUID = 1L;
+
+        private AudioOutput mAudioOutput;
+
+        public AudioOutputMuteItem(AudioOutput audioOutput)
+        {
+            super(audioOutput.isMuted() ? "Unmute" : "Mute");
+
+            mAudioOutput = audioOutput;
+
+            addActionListener(new ActionListener()
+            {
+                @Override
+                public void actionPerformed(ActionEvent e)
+                {
+                    mAudioOutput.setMuted(!mAudioOutput.isMuted());
+                }
+            });
+        }
+    }
+
+    /**
+     * Mouse listener
+     */
+    public class MouseSelectionListener implements MouseListener
+    {
+        @Override
+        public void mouseClicked(MouseEvent event)
+        {
+            if(SwingUtilities.isRightMouseButton(event))
+            {
+                JPopupMenu popup = new JPopupMenu();
+
+				/* Audio mixer/output selection menus */
+                JMenu outputMenu = new JMenu("Audio Output");
+
+                MixerChannelConfiguration[] mixerConfigurations =
+                    mSourceManager.getMixerManager().getOutputMixers();
+
+                for(MixerChannelConfiguration mixerConfig : mixerConfigurations)
+                {
+                    MixerSelectionItem mixerItem = new MixerSelectionItem(mixerConfig);
+
+                    try
+                    {
+                        MixerChannelConfiguration current = mController.getMixerChannelConfiguration();
+
+                        if(current != null && current.equals(mixerConfig))
+                        {
+                            mixerItem.setSelected(true);
+                        }
+                    }
+                    catch(AudioException e)
+                    {
+                        mLog.error("Error while detecting current mixer "
+                            + "channel configuration", e);
+                    }
+
+                    outputMenu.add(mixerItem);
+                }
+
+                popup.add(outputMenu);
+
+				/* Audio output mute and volume control */
+                for(AudioOutput output : mController.getAudioOutputs())
+                {
+                    JMenu menu = new JMenu("Channel: " + output.getChannelName());
+
+                    menu.add(new AudioOutputMuteItem(output));
+
+                    if(output.hasGainControl())
+                    {
+                        JMenu volume = new JMenu("Volume");
+                        volume.add(new VolumeSlider(output.getGainControl()));
+                        menu.add(volume);
+                    }
+
+                    popup.add(menu);
+                }
+
+                popup.show(event.getComponent(), event.getX(), event.getY());
+            }
+        }
+
+        @Override
+        public void mousePressed(MouseEvent e)
+        {
+        }
+
+        @Override
+        public void mouseReleased(MouseEvent e)
+        {
+        }
+
+        @Override
+        public void mouseEntered(MouseEvent e)
+        {
+        }
+
+        @Override
+        public void mouseExited(MouseEvent e)
+        {
+        }
+    }
+
+    /**
+     * Audio volume (gain) adjustment slider control
+     */
+    public class VolumeSlider extends JSlider
+    {
+        private static final long serialVersionUID = 1L;
+
+        private FloatControl mFloatControl;
+
+        public VolumeSlider(FloatControl control)
+        {
+            super(0, 100, 0);
+
+            setMajorTickSpacing(25);
+            setMinorTickSpacing(5);
+            setPaintTicks(true);
+            setPaintLabels(true);
+
+            mFloatControl = control;
+
+            setValue(getIntegerValue(mFloatControl.getValue()));
+
+            addChangeListener(new ChangeListener()
+            {
+                @Override
+                public void stateChanged(ChangeEvent event)
+                {
+                    mFloatControl.shift(mFloatControl.getValue(),
+                        getFloatValue(VolumeSlider.this.getValue()),
+                        1000);
+                }
+            });
+
+            addMouseListener(new MouseListener()
+            {
+                @Override
+                public void mouseClicked(MouseEvent event)
+                {
+                    if(event.getClickCount() == 2)
+                    {
+                        VolumeSlider.this.setValue(50);
+                    }
+                }
+
+                public void mouseReleased(MouseEvent arg0)
+                {
+                }
+
+                public void mousePressed(MouseEvent arg0)
+                {
+                }
+
+                public void mouseExited(MouseEvent arg0)
+                {
+                }
+
+                public void mouseEntered(MouseEvent arg0)
+                {
+                }
+            });
+        }
+
+        /**
+         * Converts the integer value to a floating point value to use in the
+         * float control.  Assumes an integer value of 50 is the 0.0 dB mid
+         * point (ie no gain ) value.
+         */
+        private int getIntegerValue(float value)
+        {
+            if(value == 0.0f)
+            {
+                return 50;
+            }
+            else if(value < 0.0f)
+            {
+                float ratio = value / mFloatControl.getMinimum();
+
+                return 50 - (int) (ratio * 50.0f);
+            }
+            else
+            {
+                float ratio = value / mFloatControl.getMaximum();
+
+                return 50 + (int) (ratio * 50.0f);
+            }
+        }
+
+        private float getFloatValue(int value)
+        {
+            if(value == 50)
+            {
+                return 0.0f;
+            }
+            else if(value < 50)
+            {
+                return (float) (50 - value) / 50.0f * mFloatControl.getMinimum();
+            }
+            else
+            {
+                return (float) (value - 50) / 50.0f * mFloatControl.getMaximum();
+            }
+        }
+    }
+
+    /**
+     * Mixer/Channel configuration selection item
+     */
+    public class MixerSelectionItem extends JMenuItem
+    {
+        private static final long serialVersionUID = 1L;
+
+        private MixerChannelConfiguration mConfiguration;
+
+        public MixerSelectionItem(MixerChannelConfiguration config)
+        {
+            super(config.toString());
+
+            mConfiguration = config;
+
+            addActionListener(new ActionListener()
+            {
+                @Override
+                public void actionPerformed(ActionEvent e)
+                {
+                    try
+                    {
+                        mController.setMixerChannelConfiguration(mConfiguration);
+                    }
+                    catch(AudioException e1)
+                    {
+                        mLog.error("Couldn't set mixer channel configuration "
+                            + "to: " + mConfiguration.toString());
+
+                        JOptionPane.showMessageDialog(MixerSelectionItem.this,
+                            "Couldn't set [" + mConfiguration.toString() +
+                                "] as the audio output device");
+                    }
+                }
+            });
+        }
+    }
+
+    /**
+     * Mute button to mute all audio output channels exposed by the audio
+     * controller
+     */
+    public class MuteButton extends JButton
+    {
+        private static final long serialVersionUID = 1L;
+
+        private boolean mMuted = false;
+
+        public MuteButton()
+        {
+            setIcon(UNMUTED_ICON);
+            setBorderPainted(false);
+            getAccessibleContext().setAccessibleName("Mute");
+
+            addActionListener(new ActionListener()
+            {
+                @Override
+                public void actionPerformed(ActionEvent e)
+                {
+                    mMuted = !mMuted;
+
+                    for(AudioOutput output : mController.getAudioOutputs())
+                    {
+                        output.setMuted(mMuted);
+                    }
+
+                    EventQueue.invokeLater(new Runnable()
+                    {
+                        @Override
+                        public void run()
+                        {
+                            setIcon(mMuted ? MUTED_ICON : UNMUTED_ICON);
+                            getAccessibleContext().setAccessibleName(mMuted ? "Unmute" : "Mute");
+                        }
+                    });
+                }
+            });
+        }
+    }
+}

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

@@ -0,0 +1,585 @@
+/*
+ * ******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2018 Dennis Sheirer
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ * *****************************************************************************
+ */
+package io.github.dsheirer.audio.playback;
+
+import io.github.dsheirer.audio.AudioEvent;
+import io.github.dsheirer.audio.AudioException;
+import io.github.dsheirer.audio.IAudioController;
+import io.github.dsheirer.properties.SystemProperties;
+import io.github.dsheirer.sample.Broadcaster;
+import io.github.dsheirer.sample.Listener;
+import io.github.dsheirer.sample.buffer.ReusableAudioPacket;
+import io.github.dsheirer.source.mixer.MixerChannel;
+import io.github.dsheirer.source.mixer.MixerChannelConfiguration;
+import io.github.dsheirer.source.mixer.MixerManager;
+import io.github.dsheirer.util.ThreadPool;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.sound.sampled.AudioSystem;
+import javax.sound.sampled.Mixer;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.LinkedTransferQueue;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+
+public class AudioPlaybackManager implements Listener<ReusableAudioPacket>, IAudioController
+{
+    private static final Logger mLog = LoggerFactory.getLogger(AudioPlaybackManager.class);
+
+    public static final int AUDIO_TIMEOUT = 1000; //1 second
+
+    public static final String AUDIO_CHANNELS_PROPERTY = "audio.manager.channels";
+    public static final String AUDIO_MIXER_PROPERTY = "audio.manager.mixer";
+
+    public static final AudioEvent CONFIGURATION_CHANGE_STARTED =
+        new AudioEvent(AudioEvent.Type.AUDIO_CONFIGURATION_CHANGE_STARTED, null);
+
+    public static final AudioEvent CONFIGURATION_CHANGE_COMPLETE =
+        new AudioEvent(AudioEvent.Type.AUDIO_CONFIGURATION_CHANGE_COMPLETE, null);
+
+    private LinkedTransferQueue<ReusableAudioPacket> mAudioPacketQueue = new LinkedTransferQueue<>();
+    private Map<Integer,AudioOutputConnection> mChannelConnectionMap = new HashMap<>();
+    private List<AudioOutputConnection> mAudioOutputConnections = new ArrayList<>();
+    private AudioOutputConnection mLowestPriorityConnection;
+    private int mAvailableConnectionCount;
+
+    private Map<String,AudioOutput> mAudioOutputMap = new HashMap<>();
+
+    private Broadcaster<AudioEvent> mControllerBroadcaster = new Broadcaster<>();
+
+    private ScheduledFuture<?> mProcessingTask;
+    private MixerManager mMixerManager;
+    private MixerChannelConfiguration mMixerChannelConfiguration;
+
+
+    /**
+     * Processes all audio produced by the decoding channels and routes audio
+     * packets to any combination of outputs based on any alias audio routing
+     * options specified by the user.
+     */
+    public AudioPlaybackManager(MixerManager mixerManager)
+    {
+        mMixerManager = mixerManager;
+
+        loadSettings();
+    }
+
+    /**
+     * Loads the saved mixer configuration or a default configuration for audio playback.
+     */
+    private void loadSettings()
+    {
+        MixerChannelConfiguration configuration = null;
+
+        SystemProperties properties = SystemProperties.getInstance();
+
+        Mixer defaultMixer = AudioSystem.getMixer(null);
+
+        String mixer = properties.get(AUDIO_MIXER_PROPERTY, defaultMixer.getMixerInfo().getName());
+
+        String channels = properties.get(AUDIO_CHANNELS_PROPERTY, MixerChannel.MONO.name());
+
+        MixerChannelConfiguration[] mixerConfigurations = mMixerManager.getOutputMixers();
+
+        for(MixerChannelConfiguration mixerConfig : mixerConfigurations)
+        {
+            if(mixerConfig.matches(mixer, channels))
+            {
+                configuration = mixerConfig;
+            }
+        }
+
+        if(configuration == null)
+        {
+            configuration = getDefaultConfiguration();
+        }
+
+        try
+        {
+            setMixerChannelConfiguration(configuration, false);
+        }
+        catch(Exception e)
+        {
+            mLog.error("Couldn't set stored audio mixer/channel configuration - using default", e);
+
+            try
+            {
+                setMixerChannelConfiguration(getDefaultConfiguration());
+            }
+            catch(Exception e2)
+            {
+                mLog.error("Couldn't set default audio mixer/channel configuration - no audio will be available", e2);
+            }
+        }
+    }
+
+    /**
+     * Creates a default audio playback configuration with a mono audio playback channel.
+     */
+    private MixerChannelConfiguration getDefaultConfiguration()
+    {
+        /* Use the system default mixer and mono channel as default startup */
+        Mixer defaultMixer = AudioSystem.getMixer(null);
+
+        return new MixerChannelConfiguration(defaultMixer, MixerChannel.MONO);
+    }
+
+    public void dispose()
+    {
+        if(mProcessingTask != null)
+        {
+            mProcessingTask.cancel(true);
+        }
+
+        mAudioPacketQueue.clear();
+
+        mProcessingTask = null;
+
+        mChannelConnectionMap.clear();
+
+        for(AudioOutputConnection connection : mAudioOutputConnections)
+        {
+            connection.dispose();
+        }
+
+        mAudioOutputConnections.clear();
+    }
+
+    /**
+     * Primary ingest point for audio produced by all decoding channels, for distribution to audio playback devices.
+     */
+    @Override
+    public synchronized void receive(ReusableAudioPacket packet)
+    {
+        mAudioPacketQueue.add(packet);
+    }
+
+    /**
+     * Checks each audio channel assignment and disconnects any inactive connections
+     */
+    private void disconnectInactiveChannelAssignments()
+    {
+        boolean changed = false;
+
+        for(AudioOutputConnection connection : mAudioOutputConnections)
+        {
+            if(connection.isInactive() && mChannelConnectionMap.containsKey(connection.getAudioChannelId()))
+            {
+                mChannelConnectionMap.remove(connection.getAudioChannelId());
+                connection.disconnect();
+                mAvailableConnectionCount++;
+                changed = true;
+            }
+        }
+
+        if(changed)
+        {
+            updateLowestPriorityAssignment();
+        }
+    }
+
+    /**
+     * Identifies the lowest priority channel connection where the a higher value indicates a lower priority.
+     */
+    private void updateLowestPriorityAssignment()
+    {
+        mLowestPriorityConnection = null;
+
+        for(AudioOutputConnection connection : mAudioOutputConnections)
+        {
+            if(connection.isConnected() &&
+                (mLowestPriorityConnection == null || mLowestPriorityConnection.getPriority() < connection.getPriority()))
+            {
+                mLowestPriorityConnection = connection;
+            }
+        }
+    }
+
+    /**
+     * Configures audio playback to use the configuration specified in the entry argument.
+     *
+     * @param entry to use in configuring the audio playback setup.
+     * @throws AudioException if there is an error
+     */
+    @Override
+    public void setMixerChannelConfiguration(MixerChannelConfiguration entry) throws AudioException
+    {
+        setMixerChannelConfiguration(entry, true);
+    }
+
+    /**
+     * Configures audio playback to use the configuration specified in the entry argument.
+     *
+     * @param entry to use in configuring the audio playback setup.
+     * @param saveSettings to save the audio playback configuration settings in the properties file.
+     * @throws AudioException if there is an error
+     */
+    public void setMixerChannelConfiguration(MixerChannelConfiguration entry, boolean saveSettings) throws AudioException
+    {
+        if(entry != null && (entry.getMixerChannel() == MixerChannel.MONO || entry.getMixerChannel() == MixerChannel.STEREO))
+        {
+            mControllerBroadcaster.broadcast(CONFIGURATION_CHANGE_STARTED);
+
+            if(mProcessingTask != null)
+            {
+                mProcessingTask.cancel(true);
+            }
+
+            disposeCurrentConfiguration();
+
+            switch(entry.getMixerChannel())
+            {
+                case MONO:
+                    AudioOutput mono = new MonoAudioOutput(entry.getMixer());
+                    mAudioOutputConnections.add(new AudioOutputConnection(mono));
+                    mAvailableConnectionCount++;
+                    mAudioOutputMap.put(mono.getChannelName(), mono);
+                    break;
+                case STEREO:
+                    AudioOutput left = new StereoAudioOutput(entry.getMixer(), MixerChannel.LEFT);
+                    mAudioOutputConnections.add(new AudioOutputConnection(left));
+                    mAvailableConnectionCount++;
+                    mAudioOutputMap.put(left.getChannelName(), left);
+
+                    AudioOutput right = new StereoAudioOutput(entry.getMixer(), MixerChannel.RIGHT);
+                    mAudioOutputConnections.add(new AudioOutputConnection(right));
+                    mAvailableConnectionCount++;
+                    mAudioOutputMap.put(right.getChannelName(), right);
+                    break;
+                default:
+                    throw new AudioException("Unsupported mixer channel "
+                        + "configuration: " + entry.getMixerChannel());
+            }
+
+            mProcessingTask = ThreadPool.SCHEDULED.scheduleAtFixedRate(new AudioPacketProcessor(),
+                0, 15, TimeUnit.MILLISECONDS);
+
+            mControllerBroadcaster.broadcast(CONFIGURATION_CHANGE_COMPLETE);
+
+            if(saveSettings)
+            {
+                SystemProperties properties = SystemProperties.getInstance();
+                properties.set(AUDIO_MIXER_PROPERTY, entry.getMixer().getMixerInfo().getName());
+                properties.set(AUDIO_CHANNELS_PROPERTY, entry.getMixerChannel().name());
+            }
+        }
+    }
+
+    /**
+     * Clears all channel assignments and terminates all audio outputs in preparation for complete shutdown or change
+     * to another mixer/channel configuration
+     */
+    private void disposeCurrentConfiguration()
+    {
+        mChannelConnectionMap.clear();
+
+        for(AudioOutputConnection connection : mAudioOutputConnections)
+        {
+            connection.dispose();
+        }
+
+        mAvailableConnectionCount = 0;
+
+        mAudioOutputConnections.clear();
+
+        mAudioOutputMap.clear();
+
+        mLowestPriorityConnection = null;
+    }
+
+    /**
+     * Current audio playback mixer channel configuration setting.
+     */
+    @Override
+    public MixerChannelConfiguration getMixerChannelConfiguration() throws AudioException
+    {
+        return mMixerChannelConfiguration;
+    }
+
+    /**
+     * List of audio outputs available for the current mixer channel configuration
+     */
+    @Override
+    public List<AudioOutput> getAudioOutputs()
+    {
+        List<AudioOutput> outputs = new ArrayList<>(mAudioOutputMap.values());
+
+        Collections.sort(outputs, new Comparator<AudioOutput>()
+        {
+            @Override
+            public int compare(AudioOutput first, AudioOutput second)
+            {
+                return first.getChannelName().compareTo(second.getChannelName());
+            }
+        });
+
+        return outputs;
+    }
+
+    /**
+     * Adds an audio event listener to receive audio event notifications.
+     */
+    @Override
+    public void addControllerListener(Listener<AudioEvent> listener)
+    {
+        mControllerBroadcaster.addListener(listener);
+    }
+
+    /**
+     * Removes an audio event listener from receiving audio event notifications.
+     */
+    @Override
+    public void removeControllerListener(Listener<AudioEvent> listener)
+    {
+        mControllerBroadcaster.removeListener(listener);
+    }
+
+    /**
+     * Returns an audio output connection for the packet if one is available, or overrides an existing lower priority
+     * connection. Returns null if no connection is available for the audio packet.
+     *
+     * @param audioPacket from a decoding channel source
+     * @return an audio output connection or null
+     */
+    private AudioOutputConnection getConnection(ReusableAudioPacket audioPacket)
+    {
+        int audioChannelId = audioPacket.getAudioChannelId();
+
+        //Use an existing connection
+        if(mChannelConnectionMap.containsKey(audioChannelId))
+        {
+            return mChannelConnectionMap.get(audioChannelId);
+        }
+
+        //Connect to an unused, available connection
+        if(mAvailableConnectionCount > 0)
+        {
+            for(AudioOutputConnection connection : mAudioOutputConnections)
+            {
+                if(connection.isDisconnected())
+                {
+                    connection.connect(audioChannelId, audioPacket.getMonitoringPriority());
+                    mChannelConnectionMap.put(audioChannelId, connection);
+                    mAvailableConnectionCount--;
+                    return connection;
+                }
+            }
+        }
+        //Preempt an existing lower priority connection and connect when this is a higher priority packet
+        else
+        {
+            int priority = audioPacket.getMonitoringPriority();
+
+            AudioOutputConnection connection = mLowestPriorityConnection;
+
+            if(connection != null && priority < connection.getPriority())
+            {
+                mChannelConnectionMap.remove(connection.getAudioChannelId());
+
+                connection.connect(audioChannelId, priority);
+
+                mChannelConnectionMap.put(audioChannelId, connection);
+
+                return connection;
+            }
+        }
+
+        return null;
+    }
+
+    public class AudioPacketProcessor implements Runnable
+    {
+        private List<ReusableAudioPacket> mPackets = new ArrayList<>();
+
+        @Override
+        public void run()
+        {
+            try
+            {
+                disconnectInactiveChannelAssignments();
+
+                if(mAudioPacketQueue != null)
+                {
+                    mAudioPacketQueue.drainTo(mPackets);
+
+                    for(ReusableAudioPacket packet : mPackets)
+                    {
+                        /* Don't process any packet's marked as do not monitor */
+                        if(!packet.isDoNotMonitor() && packet.getType() == ReusableAudioPacket.Type.AUDIO)
+                        {
+                            AudioOutputConnection connection = getConnection(packet);
+
+                            if(connection != null)
+                            {
+                                connection.receive(packet);
+                            }
+                            else
+                            {
+                                packet.decrementUserCount();
+                            }
+                        }
+                        else
+                        {
+                            packet.decrementUserCount();
+                        }
+                    }
+
+                    mPackets.clear();
+                }
+            }
+            catch(Exception e)
+            {
+                mLog.error("Encountered error while processing audio packets", e);
+
+                while(mPackets.size() > 0)
+                {
+                    ReusableAudioPacket audioPacket = mPackets.remove(0);
+                    audioPacket.decrementUserCount();
+                }
+            }
+        }
+    }
+
+    /**
+     * Audio output connection manages a connection between a source and an audio
+     * output and maintains current state information about the audio activity
+     * received form the source.
+     */
+    public class AudioOutputConnection
+    {
+        private static final int DISCONNECTED = Integer.MIN_VALUE;
+
+        private AudioOutput mAudioOutput;
+        private int mPriority = 0;
+        private int mAudioChannelId = DISCONNECTED;
+
+        public AudioOutputConnection(AudioOutput audioOutput)
+        {
+            mAudioOutput = audioOutput;
+        }
+
+        public void receive(ReusableAudioPacket packet)
+        {
+            if(packet.hasIdentifierCollection() && packet.getAudioChannelId() == mAudioChannelId)
+            {
+                int priority = packet.getMonitoringPriority();
+
+                if(mPriority != priority)
+                {
+                    mPriority = priority;
+                    updateLowestPriorityAssignment();
+                }
+
+                if(mAudioOutput != null)
+                {
+                    mAudioOutput.receive(packet);
+                }
+            }
+            else
+            {
+                if(packet.hasIdentifierCollection())
+                {
+                    mLog.error("Received audio packet from channel metadata [" + packet.getAudioChannelId() +
+                        "] however this assignment is currently connected to metadata [" + mAudioChannelId + "]");
+                }
+                else
+                {
+                    mLog.error("Received audio packet with no metadata - cannot route audio packet");
+                }
+            }
+        }
+
+        /**
+         * Terminates the audio output and prepares this connection for disposal
+         */
+        public void dispose()
+        {
+            mAudioOutput.dispose();
+            mAudioOutput = null;
+        }
+
+        /**
+         * Indicates if this assignment is currently disconnected from a channel source
+         */
+        public boolean isDisconnected()
+        {
+            return mAudioChannelId == DISCONNECTED;
+        }
+
+        /**
+         * Indicates if this assignment is currently connected to a channel source
+         */
+        public boolean isConnected()
+        {
+            return !isDisconnected();
+        }
+
+        /**
+         * Connects this assignment to the indicated source so that audio
+         * packets from this source can be sent to the audio output
+         */
+        public void connect(int source, int priority)
+        {
+            mAudioChannelId = source;
+            mPriority = priority;
+            updateLowestPriorityAssignment();
+
+            mAudioOutput.updateTimestamp();
+        }
+
+        /**
+         * Currently connected source or -1 if disconnected
+         */
+        public int getAudioChannelId()
+        {
+            return mAudioChannelId;
+        }
+
+        /**
+         * Disconnects this assignment from the source and prevents any audio
+         * from being routed to the audio output until another source is assigned
+         */
+        public void disconnect()
+        {
+            mAudioChannelId = DISCONNECTED;
+            mPriority = 0;
+        }
+
+        /**
+         * Indicates if audio output is current inactive, meaning that the
+         * audio output hasn't recently processed any audio packets.
+         */
+        public boolean isInactive()
+        {
+            return (mAudioOutput.getLastActivityTimestamp() + AUDIO_TIMEOUT) < System.currentTimeMillis();
+        }
+
+        public int getPriority()
+        {
+            return mPriority;
+        }
+    }
+}

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

@@ -0,0 +1,69 @@
+/*******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2017 Dennis Sheirer
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ *
+ ******************************************************************************/
+package io.github.dsheirer.audio.playback;
+
+import io.github.dsheirer.audio.AudioFormats;
+import io.github.dsheirer.sample.buffer.ReusableAudioPacket;
+import io.github.dsheirer.source.mixer.MixerChannel;
+
+import javax.sound.sampled.Mixer;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.ShortBuffer;
+
+/**
+ * Mono Audio output implementation
+ */
+public class MonoAudioOutput extends AudioOutput
+{
+    private final static int BUFFER_SIZE = 8000;
+
+    public MonoAudioOutput(Mixer mixer)
+    {
+        super(mixer, MixerChannel.MONO, AudioFormats.PCM_SIGNED_8KHZ_16BITS_MONO,
+            AudioFormats.MONO_SOURCE_DATALINE_INFO, BUFFER_SIZE);
+    }
+
+    /**
+     * Converts the audio packet data into mono audio frames.
+     */
+    protected ByteBuffer convert(ReusableAudioPacket packet)
+    {
+        ByteBuffer buffer = null;
+
+        if(packet.hasAudioSamples())
+        {
+            float[] samples = packet.getAudioSamples();
+
+			/* Little-endian byte buffer */
+            buffer = ByteBuffer.allocate(samples.length * 2).order(ByteOrder.LITTLE_ENDIAN);
+
+            ShortBuffer shortBuffer = buffer.asShortBuffer();
+
+            for(float sample : samples)
+            {
+                shortBuffer.put((short) (sample * Short.MAX_VALUE));
+            }
+        }
+
+        packet.decrementUserCount();
+
+        return buffer;
+    }
+}

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

@@ -0,0 +1,83 @@
+/*******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2017 Dennis Sheirer
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ *
+ ******************************************************************************/
+package io.github.dsheirer.audio.playback;
+
+import io.github.dsheirer.audio.AudioFormats;
+import io.github.dsheirer.sample.buffer.ReusableAudioPacket;
+import io.github.dsheirer.source.mixer.MixerChannel;
+
+import javax.sound.sampled.Mixer;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.ShortBuffer;
+
+/**
+ * Stereo audio output implementation.
+ */
+public class StereoAudioOutput extends AudioOutput
+{
+    private final static int BUFFER_SIZE = 16000;
+
+    public StereoAudioOutput(Mixer mixer, MixerChannel channel)
+    {
+        super(mixer, channel, AudioFormats.PCM_SIGNED_8KHZ_16BITS_STEREO, AudioFormats.STEREO_SOURCE_DATALINE_INFO,
+            BUFFER_SIZE);
+    }
+
+    /**
+     * Converts the audio packet data into stereo audio frames with the mixer
+     * channel containing the audio and the other channel containing zero
+     * valued (silent) samples.
+     */
+    protected ByteBuffer convert(ReusableAudioPacket packet)
+    {
+        ByteBuffer buffer = null;
+
+        if(packet.hasAudioSamples())
+        {
+            float[] samples = packet.getAudioSamples();
+
+			/* Little-endian byte buffer */
+            buffer = ByteBuffer.allocate(samples.length * 4).order(ByteOrder.LITTLE_ENDIAN);
+
+            ShortBuffer shortBuffer = buffer.asShortBuffer();
+
+            if(getMixerChannel() == MixerChannel.LEFT)
+            {
+                for(float sample : samples)
+                {
+                    shortBuffer.put((short) (sample * Short.MAX_VALUE));
+                    shortBuffer.put((short) 0);
+                }
+            }
+            else
+            {
+                for(float sample : samples)
+                {
+                    shortBuffer.put((short) 0);
+                    shortBuffer.put((short) (sample * Short.MAX_VALUE));
+                }
+            }
+        }
+
+        packet.decrementUserCount();
+
+        return buffer;
+    }
+}