fix src folder structure

src/main/java/alias/Alias.java

@@ -0,0 +1,354 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014-2016 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 alias;
+
+import java.awt.Color;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlRootElement;
+import javax.xml.bind.annotation.XmlSeeAlso;
+import javax.xml.bind.annotation.XmlTransient;
+
+import alias.action.AliasAction;
+import alias.id.AliasID;
+import alias.id.AliasIDType;
+import alias.id.broadcast.BroadcastChannel;
+import alias.id.nonrecordable.NonRecordable;
+import alias.id.priority.Priority;
+
+@XmlSeeAlso( { AliasID.class, AliasAction.class } )
+@XmlRootElement( name = "alias" )
+public class Alias
+{
+	private String mList;
+	private String mGroup;
+	private String mName;
+	private int mColor;
+	private String mIconName;
+	private List<AliasID> mAliasIDs = new ArrayList<AliasID>();
+	private List<AliasAction> mAliasActions = new ArrayList<AliasAction>();
+	
+	public Alias()
+	{
+	}
+
+	public Alias( String name )
+	{
+		mName = name;
+	}
+	
+	public String toString()
+	{
+		return getName();
+	}
+
+	@XmlAttribute( name="name" )
+	public String getName()
+	{
+		return mName;
+	}
+	
+	public void setName( String name )
+	{
+		mName = name;
+	}
+
+	@XmlAttribute( name="list" )
+	public String getList()
+	{
+		return mList;
+	}
+	
+	public void setList( String list )
+	{
+		mList = list;
+	}
+	
+	public boolean hasList()
+	{
+		return mList != null;
+	}
+
+	@XmlAttribute( name="group" )
+	public String getGroup()
+	{
+		return mGroup;
+	}
+	
+	public void setGroup( String group )
+	{
+		mGroup = group;
+	}
+	
+	public boolean hasGroup()
+	{
+		return mGroup != null;
+	}
+
+	@XmlAttribute
+	public int getColor()
+	{
+		return mColor;
+	}
+
+	public void setColor( int color )
+	{
+		mColor = color;
+	}
+
+	public Color getDisplayColor()
+	{
+		return new Color( getColor() );
+	}
+	
+	@XmlAttribute
+	public String getIconName()
+	{
+		return mIconName;
+	}
+	
+	public void setIconName( String iconName )
+	{
+		mIconName = iconName;
+	}
+	
+	@XmlElement( name="id" )
+	public List<AliasID> getId()
+	{
+		return mAliasIDs;
+	}
+	
+	public void setId( ArrayList<AliasID> id )
+	{
+		mAliasIDs = id;
+	}
+	
+	public void addAliasID( AliasID id )
+	{
+		mAliasIDs.add( id );
+	}
+	
+	public void removeAliasID( AliasID id )
+	{
+		mAliasIDs.remove( id );
+	}
+	
+	@XmlElement( name="action" )
+	public List<AliasAction> getAction()
+	{
+		return mAliasActions;
+	}
+	
+	public void setAction( List<AliasAction> actions )
+	{
+		mAliasActions = actions;
+	}
+	
+	public void addAliasAction( AliasAction action )
+	{
+		mAliasActions.add( action );
+	}
+	
+	public void removeAliasAction( AliasAction action )
+	{
+		mAliasActions.remove( action );
+	}
+	
+	public boolean hasActions()
+	{
+		return !mAliasActions.isEmpty();
+	}
+
+	/**
+	 * Perform any validation/cleanup actions on this alias.
+	 */
+	public void validate()
+	{
+	}
+	/**
+	 * Returns the priority level of this alias, if defined, or the default priority
+	 */
+	@XmlTransient
+	public int getCallPriority()
+	{
+		for( AliasID id: mAliasIDs )
+		{
+			if( id.getType() == AliasIDType.PRIORITY)
+			{
+				return ((Priority)id).getPriority();
+			}
+		}
+		
+		return Priority.DEFAULT_PRIORITY;
+	}
+	
+	public boolean hasCallPriority()
+	{
+		for( AliasID id: mAliasIDs )
+		{
+			if( id.getType() == AliasIDType.PRIORITY)
+			{
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	 * Sets or updates the call priority
+	 */
+	public void setCallPriority( int priority )
+	{
+		if( priority == Priority.DO_NOT_MONITOR ||
+			( Priority.MIN_PRIORITY <= priority && priority <= Priority.MAX_PRIORITY ) )
+		{
+			for( AliasID id: mAliasIDs )
+			{
+				if( id.getType() == AliasIDType.PRIORITY)
+				{
+					((Priority)id).setPriority( priority );
+					return;
+				}
+			}
+			
+			//If we don't find a priority id, create one
+			Priority p = new Priority();
+			p.setPriority( priority );
+			addAliasID( p );
+		}
+	}
+
+	/**
+	 * Inspects the alias for a non-recordable alias id.  Default is true;
+	 */
+	@XmlTransient
+	public boolean isRecordable()
+	{
+		for( AliasID id: getId() )
+		{
+			if( id.getType() == AliasIDType.NON_RECORDABLE)
+			{
+				return false;
+			}
+		}
+		
+		return true;
+	}
+
+	/**
+	 * Sets or removes the non-recordable alias ID for this alias.
+	 */
+	public void setRecordable( boolean recordable )
+	{
+		if( recordable )
+		{
+			AliasID toRemove = null;
+			
+			for( AliasID id: getId() )
+			{
+				if( id.getType() == AliasIDType.NON_RECORDABLE)
+				{
+					toRemove = id;
+					break;
+				}
+			}
+			
+			if( toRemove != null )
+			{
+				removeAliasID( toRemove );
+			}
+		}
+		else
+		{
+			for( AliasID id: getId() )
+			{
+				if( id.getType() == AliasIDType.NON_RECORDABLE)
+				{
+					return;
+				}
+			}
+			
+			addAliasID( new NonRecordable() );
+		}
+	}
+
+    /**
+     * Inspects the alias for broadcast channel/streamable alias ids.  Default is false;
+     */
+    @XmlTransient
+    public boolean isStreamable()
+    {
+        for( AliasID id: getId() )
+        {
+            if( id.getType() == AliasIDType.BROADCAST_CHANNEL)
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+	 * List of broadcast channels specified for this alias.
+	 */
+    @XmlTransient
+	public Set<BroadcastChannel> getBroadcastChannels()
+	{
+		Set<BroadcastChannel> broadcastChannels = new TreeSet<>();
+
+		for(AliasID id: getId())
+		{
+			if(id.getType() == AliasIDType.BROADCAST_CHANNEL)
+			{
+				broadcastChannels.add((BroadcastChannel)id);
+			}
+		}
+
+		return broadcastChannels;
+	}
+
+	/**
+	 * Indicates if this alias contains a broadcast channel alias id with the channel name.
+	 */
+	public boolean hasBroadcastChannel(String channel)
+	{
+		if(channel == null || channel.isEmpty())
+		{
+			return false;
+		}
+
+		for(AliasID id: getId())
+		{
+			if(id.getType() == AliasIDType.BROADCAST_CHANNEL &&
+			   ((BroadcastChannel)id).getChannelName().contentEquals(channel))
+			{
+				return true;
+			}
+		}
+
+		return false;
+	}
+}

src/main/java/alias/AliasController.java

@@ -0,0 +1,356 @@
+package alias;
+
+import audio.broadcast.BroadcastModel;
+import com.jidesoft.swing.JideSplitPane;
+import gui.editor.Editor;
+import icon.IconManager;
+import net.coderazzi.filters.gui.AutoChoices;
+import net.coderazzi.filters.gui.TableFilterHeader;
+import net.miginfocom.swing.MigLayout;
+
+import javax.swing.*;
+import javax.swing.event.ListSelectionEvent;
+import javax.swing.event.ListSelectionListener;
+import javax.swing.table.DefaultTableCellRenderer;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.util.ArrayList;
+import java.util.List;
+
+public class AliasController extends JPanel
+    implements ActionListener, ListSelectionListener
+{
+    private static final long serialVersionUID = 1L;
+
+    private AliasModel mAliasModel;
+    private JTable mAliasTable;
+    private TableFilterHeader mTableFilterHeader;
+    private AliasEditor mAliasEditor;
+    private MultipleAliasEditor mMultipleAliasEditor;
+    private JideSplitPane mSplitPane;
+
+    private static final String NEW_ALIAS = "New";
+    private static final String COPY_ALIAS = "Copy";
+    private static final String DELETE_ALIAS = "Delete";
+
+    private JButton mNewButton = new JButton(NEW_ALIAS);
+    private JButton mCopyButton = new JButton(COPY_ALIAS);
+    private JButton mDeleteButton = new JButton(DELETE_ALIAS);
+
+    private IconCellRenderer mIconCellRenderer;
+
+    public AliasController(AliasModel aliasModel, BroadcastModel broadcastModel, IconManager iconManager)
+    {
+        mAliasModel = aliasModel;
+
+        mAliasEditor = new AliasEditor(mAliasModel, broadcastModel, iconManager);
+        mMultipleAliasEditor = new MultipleAliasEditor(mAliasModel, broadcastModel, iconManager);
+
+        mIconCellRenderer = new IconCellRenderer(iconManager);
+
+        init();
+
+        mAliasModel.addListener(mAliasEditor);
+    }
+
+    private void init()
+    {
+        setLayout(new MigLayout("insets 0 0 0 0",
+            "[grow,fill]",
+            "[grow,fill]"));
+
+        //System Configuration View and Editor
+        mAliasTable = new JTable(mAliasModel);
+        mAliasTable.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
+        mAliasTable.getSelectionModel().addListSelectionListener(this);
+        mAliasTable.setAutoCreateRowSorter(true);
+
+        mAliasTable.getColumnModel().getColumn(AliasModel.COLUMN_COLOR)
+            .setCellRenderer(new ColorCellRenderer());
+
+        mAliasTable.getColumnModel().getColumn(AliasModel.COLUMN_ICON)
+            .setCellRenderer(mIconCellRenderer);
+
+        mTableFilterHeader = new TableFilterHeader(mAliasTable, AutoChoices.ENABLED);
+        mTableFilterHeader.setFilterOnUpdates(true);
+
+        JScrollPane tableScroller = new JScrollPane(mAliasTable);
+
+        JPanel buttonsPanel = new JPanel();
+
+        buttonsPanel.setLayout(
+            new MigLayout("insets 0 0 0 0", "[grow,fill][grow,fill][grow,fill]", "[]"));
+
+        mNewButton.addActionListener(this);
+        mNewButton.setToolTipText("Adds a new alias");
+        buttonsPanel.add(mNewButton);
+
+        mCopyButton.addActionListener(this);
+        mCopyButton.setEnabled(false);
+        mCopyButton.setToolTipText("Creates a copy of the currently selected alias and adds it");
+        buttonsPanel.add(mCopyButton);
+
+        mDeleteButton.addActionListener(this);
+        mDeleteButton.setEnabled(false);
+        mDeleteButton.setToolTipText("Deletes the currently selected alias");
+        buttonsPanel.add(mDeleteButton);
+
+        JPanel listAndButtonsPanel = new JPanel();
+
+        listAndButtonsPanel.setLayout(
+            new MigLayout("insets 0 0 0 0", "[grow,fill]", "[grow,fill][]"));
+
+        listAndButtonsPanel.add(tableScroller, "wrap");
+        listAndButtonsPanel.add(buttonsPanel);
+
+        mSplitPane = new JideSplitPane(JideSplitPane.HORIZONTAL_SPLIT);
+        mSplitPane.setDividerSize(5);
+        mSplitPane.setShowGripper(true);
+        mSplitPane.add(listAndButtonsPanel);
+        mSplitPane.add(mAliasEditor);
+
+        add(mSplitPane);
+    }
+
+    /**
+     * Sets the editor argument as the currently visible alias editor
+     */
+    private void setEditor(Editor<?> editor)
+    {
+        if(mSplitPane.getComponentCount() == 3)
+        {
+            Component component = mSplitPane.getComponent(2);
+
+            if(component instanceof Editor<?> && component != editor)
+            {
+                //Get current divider location so that we can reapply it after
+                //changing out the editors, so that the interface doesn't move
+                int location = mSplitPane.getDividerLocation(0);
+
+                ((Editor<?>) component).setItem(null);
+
+                mSplitPane.remove(component);
+                editor.setPreferredSize(new Dimension(100, 100));
+                mSplitPane.add(editor);
+
+                mSplitPane.validate();
+                mSplitPane.setDividerLocation(0, location);
+                mSplitPane.repaint();
+            }
+        }
+    }
+
+    private Alias getAlias(int selectedRow)
+    {
+        if(selectedRow >= 0)
+        {
+            int index = mAliasTable.convertRowIndexToModel(selectedRow);
+
+            return mAliasModel.getAliasAtIndex(index);
+        }
+
+        return null;
+    }
+
+    @Override
+    public void valueChanged(ListSelectionEvent event)
+    {
+        //Limits event firing to only when selection is complete
+        if(!event.getValueIsAdjusting())
+        {
+            int[] selectedRows = mAliasTable.getSelectedRows();
+
+            if(selectedRows.length == 0)
+            {
+                mAliasEditor.setItem(null);
+                mCopyButton.setEnabled(false);
+                mDeleteButton.setEnabled(false);
+            }
+            else if(selectedRows.length == 1)
+            {
+                setEditor(mAliasEditor);
+
+                Alias selectedAlias = getAlias(selectedRows[0]);
+
+                mAliasEditor.setItem(selectedAlias);
+
+                if(selectedAlias != null)
+                {
+                    mCopyButton.setEnabled(true);
+                    mDeleteButton.setEnabled(true);
+                }
+                else
+                {
+                    mCopyButton.setEnabled(false);
+                    mDeleteButton.setEnabled(false);
+                }
+            }
+            else
+            {
+                setEditor(mMultipleAliasEditor);
+
+                mCopyButton.setEnabled(true);
+                mDeleteButton.setEnabled(true);
+
+                List<Alias> selectedAliases = new ArrayList<Alias>();
+
+                for(int selectedRow : selectedRows)
+                {
+                    Alias alias = getAlias(selectedRow);
+
+                    selectedAliases.add(alias);
+                }
+
+                mMultipleAliasEditor.setItem(selectedAliases);
+            }
+        }
+    }
+
+    /**
+     * Adds the alias to the alias table/model and scrolls the view it
+     */
+    private void addAlias(Alias alias)
+    {
+        //HACK: when inserting a row to the model, the JTable gets
+        //notified and attempts to tell the coderazzi table filter
+        //adaptive choices filter to refresh before the table filter is
+        //notified of the row additions, causing an index out of bounds
+        //exception.  We turn off adaptive choices temporarily, add the
+        //channel, and turn on adaptive choices again.
+        mTableFilterHeader.setAdaptiveChoices(false);
+
+        int index = mAliasModel.addAlias(alias);
+
+        mTableFilterHeader.setAdaptiveChoices(true);
+
+        if(index >= 0)
+        {
+            int translatedIndex = mAliasTable.convertRowIndexToView(index);
+            mAliasTable.setRowSelectionInterval(translatedIndex, translatedIndex);
+            mAliasTable.scrollRectToVisible(
+                new Rectangle(mAliasTable.getCellRect(translatedIndex, 0, true)));
+        }
+    }
+
+    private List<Alias> getSelectedAliases()
+    {
+        List<Alias> selected = new ArrayList<>();
+
+        int[] rows = mAliasTable.getSelectedRows();
+
+        for(int row : rows)
+        {
+            if(row >= 0)
+            {
+                Alias alias = mAliasModel.getAliasAtIndex(mAliasTable.convertRowIndexToModel(row));
+
+                if(alias != null)
+                {
+                    selected.add(alias);
+                }
+            }
+        }
+
+        return selected;
+    }
+
+    /**
+     * Responds to New, Copy and Delete Channel button invocations
+     */
+    @Override
+    public void actionPerformed(ActionEvent event)
+    {
+        switch(event.getActionCommand())
+        {
+            case NEW_ALIAS:
+                addAlias(new Alias("New Alias"));
+                break;
+            case COPY_ALIAS:
+                for(Alias alias : getSelectedAliases())
+                {
+                    addAlias(AliasFactory.copyOf(alias));
+                }
+                break;
+            case DELETE_ALIAS:
+                List<Alias> toDelete = getSelectedAliases();
+
+                if(toDelete != null && !toDelete.isEmpty())
+                {
+                    String title = toDelete.size() == 1 ? "Delete Alias?" : "Delete Aliases?";
+                    String prompt = toDelete.size() == 1 ? "Do you want to delete this alias?" :
+                        "Do you want to delete these " + toDelete.size() + " aliases?";
+
+                    int choice = JOptionPane.showConfirmDialog(AliasController.this,
+                        prompt, title, JOptionPane.YES_NO_OPTION, JOptionPane.WARNING_MESSAGE);
+
+                    if(choice == JOptionPane.YES_OPTION)
+                    {
+                        for(Alias alias : toDelete)
+                        {
+                            mAliasModel.removeAlias(alias);
+                        }
+                    }
+                }
+                break;
+            default:
+                break;
+        }
+    }
+
+    /**
+     * Colorizes the cell based on the cell's integer value
+     */
+    public class ColorCellRenderer extends DefaultTableCellRenderer
+    {
+        private static final long serialVersionUID = 1L;
+
+        @Override
+        public Component getTableCellRendererComponent(JTable table,
+                                                       Object value, boolean isSelected, boolean hasFocus, int row,
+                                                       int column)
+        {
+            JLabel label = (JLabel) super.getTableCellRendererComponent(table,
+                value, isSelected, hasFocus, row, column);
+
+            label.setBackground(new Color((int) value));
+
+            label.setText("");
+
+            return label;
+        }
+    }
+
+    /**
+     * Displays cell's icon and name
+     */
+    public class IconCellRenderer extends DefaultTableCellRenderer
+    {
+        private static final long serialVersionUID = 1L;
+
+        private IconManager mIconManager;
+
+        public IconCellRenderer(IconManager iconManager)
+        {
+            mIconManager = iconManager;
+        }
+
+        @Override
+        public Component getTableCellRendererComponent(JTable table,
+                                                       Object value, boolean isSelected, boolean hasFocus, int row,
+                                                       int column)
+        {
+            JLabel label = (JLabel) super.getTableCellRendererComponent(table,
+                value, isSelected, hasFocus, row, column);
+
+            ImageIcon icon = mIconManager.getIcon(label.getText(), 12);
+
+            if(icon != null)
+            {
+                label.setIcon(icon);
+            }
+
+            return label;
+        }
+    }
+}

src/main/java/alias/AliasEditor.java

@@ -0,0 +1,164 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014-2016 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 alias;
+
+import audio.broadcast.BroadcastModel;
+import gui.editor.Editor;
+
+import java.awt.Color;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import javax.swing.JButton;
+import javax.swing.JLabel;
+import javax.swing.JSeparator;
+
+import icon.IconManager;
+import net.miginfocom.swing.MigLayout;
+import sample.Listener;
+import settings.SettingsManager;
+import alias.action.AliasActionEditor;
+import alias.id.AliasIdentifierEditor;
+
+import com.jidesoft.swing.JideTabbedPane;
+
+public class AliasEditor extends Editor<Alias> 
+			implements ActionListener, Listener<AliasEvent>
+{
+    private static final long serialVersionUID = 1L;
+
+	private static final String DEFAULT_NAME = "select an alias";
+
+	private AliasModel mAliasModel;
+	
+	private JLabel mAliasLabel;
+    private AliasNameEditor mAliasNameEditor;
+    private AliasIdentifierEditor mAliasIdentifierEditor;
+    private AliasActionEditor mAliasActionEditor;
+    
+    public AliasEditor(AliasModel aliasModel, BroadcastModel broadcastModel, IconManager iconManager )
+	{
+    	mAliasModel = aliasModel;
+    	mAliasNameEditor = new AliasNameEditor( mAliasModel, iconManager );
+    	mAliasIdentifierEditor = new AliasIdentifierEditor( aliasModel, broadcastModel );
+    	mAliasActionEditor = new AliasActionEditor( aliasModel );
+    	
+    	mAliasModel.addListener( this );
+		
+		init();
+	}
+
+    
+    @Override
+	public void setItem( Alias alias )
+	{
+		super.setItem( alias );
+		
+		if( hasItem() )
+		{
+    		mAliasLabel.setText( getItem().getName() );
+		}
+		else
+		{
+    		mAliasLabel.setText( DEFAULT_NAME );
+		}
+		
+		mAliasNameEditor.setItem( alias );
+		mAliasIdentifierEditor.setItem( alias );
+		mAliasActionEditor.setItem( alias );
+	}
+
+	private void init()
+	{
+		setLayout( new MigLayout( "fill,wrap 2", "[grow,fill][grow,fill]", 
+				"[][][][][][grow,fill]" ) );
+		
+		add( new JLabel( "Alias:" ), "align right" );
+		mAliasLabel = new JLabel( DEFAULT_NAME );
+		add( mAliasLabel, "align left" );
+		
+		add( new JSeparator( JSeparator.HORIZONTAL ), "span,growx,push" );
+		
+		JideTabbedPane tabs = new JideTabbedPane();
+		tabs.setFont( this.getFont() );
+    	tabs.setForeground( Color.BLACK );
+
+		tabs.addTab( "Alias", mAliasNameEditor );
+		tabs.addTab( "Audio / Identifier", mAliasIdentifierEditor );
+		tabs.addTab( "Action", mAliasActionEditor );
+		add( tabs, "span,grow" );
+		
+		//Playlist management buttons
+		JButton btnSave = new JButton( "Save" );
+		btnSave.setToolTipText( "Save alias changes to the playlist" );
+		btnSave.addActionListener( AliasEditor.this );
+		add( btnSave );
+
+		JButton btnReset = new JButton( "Reset" );
+		btnReset.setToolTipText( "Reset alias changes since last save" );
+		btnReset.addActionListener( AliasEditor.this );
+		add( btnReset, "wrap" );
+	}
+
+	@Override
+	public void receive( AliasEvent event )
+	{
+		//If this is the currently displayed alias, reload it
+		if( hasItem() && getItem() == event.getAlias() )
+		{
+			switch( event.getEvent() )
+			{
+				case CHANGE:
+					//Alias changed - reset the editor with changed alias
+					setItem( event.getAlias() );
+					break;
+				case DELETE:
+					setItem( null );
+					break;
+				default:
+					break;
+			}
+		}
+	}
+
+	@Override
+    public void actionPerformed( ActionEvent e )
+    {
+		if( hasItem() )
+		{
+			String command = e.getActionCommand();
+			
+			if( command.contentEquals( "Save" ) )
+			{
+				save();
+			}
+			else if( command.contentEquals( "Reset" ) )
+			{
+				reset();
+			}
+		}
+    }
+
+	@Override
+	public void save()
+	{
+		mAliasNameEditor.save();
+		mAliasIdentifierEditor.save();
+		mAliasActionEditor.save();
+	}
+}

src/main/java/alias/AliasEvent.java

@@ -0,0 +1,55 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014-2016 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 alias;
+
+public class AliasEvent
+{
+	private Alias mAlias;
+	private Event mEvent;
+
+	/**
+	 * AliasEvent - event describing any changes to an alias
+	 * @param alias - alias that changed
+	 * @param event - change event
+	 */
+	public AliasEvent( Alias alias, Event event )
+	{
+		mAlias = alias;
+		mEvent = event;
+	}
+	
+	public Alias getAlias()
+	{
+		return mAlias;
+	}
+	
+	public Event getEvent()
+	{
+		return mEvent;
+	}
+	
+	/**
+	 * Channel events to describe the specific event
+	 */
+	public enum Event
+	{
+		ADD,
+		CHANGE,
+		DELETE;
+	}
+}

src/main/java/alias/AliasFactory.java

@@ -0,0 +1,304 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014-2016 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 alias;
+
+import alias.action.AliasAction;
+import alias.action.AliasActionType;
+import alias.action.beep.BeepAction;
+import alias.action.beep.BeepActionEditor;
+import alias.action.clip.ClipAction;
+import alias.action.clip.ClipActionEditor;
+import alias.action.script.ScriptAction;
+import alias.action.script.ScriptActionEditor;
+import alias.id.AliasID;
+import alias.id.AliasIDType;
+import alias.id.broadcast.BroadcastChannel;
+import alias.id.broadcast.BroadcastChannelEditor;
+import alias.id.esn.ESNEditor;
+import alias.id.esn.Esn;
+import alias.id.fleetsync.FleetsyncID;
+import alias.id.fleetsync.FleetsyncIDEditor;
+import alias.id.lojack.LoJackFunctionAndID;
+import alias.id.lojack.LoJackIDEditor;
+import alias.id.mdc.MDC1200ID;
+import alias.id.mdc.MDC1200IDEditor;
+import alias.id.mobileID.MINEditor;
+import alias.id.mobileID.Min;
+import alias.id.mpt1327.MPT1327ID;
+import alias.id.mpt1327.MPT1327IDEditor;
+import alias.id.nonrecordable.NonRecordable;
+import alias.id.nonrecordable.NonRecordableEditor;
+import alias.id.priority.Priority;
+import alias.id.priority.PriorityEditor;
+import alias.id.siteID.SiteID;
+import alias.id.siteID.SiteIDEditor;
+import alias.id.status.StatusID;
+import alias.id.status.StatusIDEditor;
+import alias.id.talkgroup.TalkgroupID;
+import alias.id.talkgroup.TalkgroupIDEditor;
+import alias.id.uniqueID.UniqueID;
+import alias.id.uniqueID.UniqueIDEditor;
+import audio.broadcast.BroadcastModel;
+import gui.editor.Editor;
+import gui.editor.EmptyEditor;
+
+public class AliasFactory
+{
+	public static AliasID copyOf( AliasID id )
+	{
+		switch( id.getType() )
+		{
+			case BROADCAST_CHANNEL:
+				BroadcastChannel originalBroadcast = (BroadcastChannel)id;
+				BroadcastChannel copyBroadcast = new BroadcastChannel();
+				copyBroadcast.setChannelName(originalBroadcast.getChannelName());
+				return copyBroadcast;
+			case ESN:
+				Esn originalESN = (Esn)id;
+				Esn copyESN = new Esn();
+				copyESN.setEsn( originalESN.getEsn() );
+				return copyESN;
+			case FLEETSYNC:
+				FleetsyncID originalFleetsyncID = (FleetsyncID)id;
+				FleetsyncID copyFleetsyncID = new FleetsyncID();
+				copyFleetsyncID.setIdent( originalFleetsyncID.getIdent() );
+				return copyFleetsyncID;
+			case LTR_NET_UID:
+				UniqueID originalUniqueID = (UniqueID)id;
+				UniqueID copyUniqueID = new UniqueID();
+				copyUniqueID.setUid( originalUniqueID.getUid() );
+				return copyUniqueID;
+			case LOJACK:
+				LoJackFunctionAndID originalLoJackFunctionAndID = (LoJackFunctionAndID)id;
+				LoJackFunctionAndID copyLoJackFunctionAndID = new LoJackFunctionAndID();
+				copyLoJackFunctionAndID.setFunction( originalLoJackFunctionAndID.getFunction() );
+				copyLoJackFunctionAndID.setID( originalLoJackFunctionAndID.getID() );
+				return copyLoJackFunctionAndID;
+			case MDC1200:
+				MDC1200ID originalMDC1200ID = (MDC1200ID)id;
+				MDC1200ID copyMDC1200ID = new MDC1200ID();
+				copyMDC1200ID.setIdent( originalMDC1200ID.getIdent() );
+				return copyMDC1200ID;
+			case MIN:
+				Min originalMin = (Min)id;
+				Min copyMin = new Min();
+				copyMin.setMin( originalMin.getMin() );
+				return copyMin;
+			case MPT1327:
+				MPT1327ID originalMPT1327ID = (MPT1327ID)id;
+				MPT1327ID copyMPT1327ID = new MPT1327ID();
+				copyMPT1327ID.setIdent( originalMPT1327ID.getIdent() );
+				return copyMPT1327ID;
+			case NON_RECORDABLE:
+				return new NonRecordable();
+			case PRIORITY:
+				Priority originalPriority = (Priority)id;
+				Priority copyPriority = new Priority();
+				copyPriority.setPriority( originalPriority.getPriority() );
+				return copyPriority;
+			case SITE:
+				SiteID originalSiteID = (SiteID)id;
+				SiteID copySiteID = new SiteID();
+				copySiteID.setSite( originalSiteID.getSite() );
+				return copySiteID;
+			case TALKGROUP:
+				TalkgroupID originalTalkgroupID = (TalkgroupID)id;
+				TalkgroupID copyTalkgroupID = new TalkgroupID();
+				copyTalkgroupID.setTalkgroup( originalTalkgroupID.getTalkgroup() );
+				return copyTalkgroupID;
+			case STATUS:
+				StatusID originalStatusID = (StatusID)id;
+				StatusID copyStatusID = new StatusID();
+				copyStatusID.setStatus( originalStatusID.getStatus() );
+				return copyStatusID;
+			default:
+		}
+
+		return null;
+	}
+	
+	public static AliasAction copyOf( AliasAction action )
+	{
+		if( action instanceof BeepAction )
+		{
+			return new BeepAction();
+		}
+		else if( action instanceof ClipAction )
+		{
+			ClipAction originalClip = (ClipAction)action;
+			ClipAction copyClip = new ClipAction();
+			copyClip.setInterval( originalClip.getInterval() );
+			copyClip.setPath( originalClip.getPath() );
+			copyClip.setPeriod( originalClip.getPeriod() );
+			return copyClip;
+		}
+		else if( action instanceof ScriptAction )
+		{
+			ScriptAction originalScript = (ScriptAction)action;
+			ScriptAction copyScript = new ScriptAction();
+			copyScript.setInterval( originalScript.getInterval() );
+			copyScript.setPeriod( originalScript.getPeriod() );
+			copyScript.setScript( originalScript.getScript() );
+			return copyScript;
+		}
+		
+		return null;
+	}
+	
+	public static Alias copyOf( Alias original )
+	{
+		Alias copy = new Alias( original.getName() );
+		copy.setList( original.getList() );
+		copy.setGroup( original.getGroup() );
+		copy.setColor( original.getColor() );
+		copy.setIconName( original.getIconName() );
+		
+		for( AliasID id: original.getId() )
+		{
+			AliasID copyID = copyOf( id );
+			
+			if( copyID != null )
+			{
+				copy.addAliasID( copyID );
+			}
+		}
+
+		for( AliasAction action: original.getAction() )
+		{
+			AliasAction copyAction = copyOf( action );
+			
+			if( copyAction != null )
+			{
+				copy.addAliasAction( copyAction );
+			}
+		}
+		
+		return copy;
+	}
+
+	public static Editor<AliasID> getEditor( AliasID aliasID, BroadcastModel broadcastModel )
+	{
+		if( aliasID != null )
+		{
+			switch( aliasID.getType() )
+			{
+				case BROADCAST_CHANNEL:
+					return new BroadcastChannelEditor(aliasID, broadcastModel);
+				case ESN:
+					return new ESNEditor( aliasID );
+				case FLEETSYNC:
+					return new FleetsyncIDEditor( aliasID );
+				case LTR_NET_UID:
+					return new UniqueIDEditor( aliasID );
+				case LOJACK:
+					return new LoJackIDEditor( aliasID );
+				case MDC1200:
+					return new MDC1200IDEditor( aliasID );
+				case MIN:
+					return new MINEditor( aliasID );
+				case MPT1327:
+					return new MPT1327IDEditor( aliasID );
+				case NON_RECORDABLE:
+					return new NonRecordableEditor( aliasID );
+				case PRIORITY:
+					return new PriorityEditor( aliasID );
+				case SITE:
+					return new SiteIDEditor( aliasID );
+				case STATUS:
+					return new StatusIDEditor( aliasID );
+				case TALKGROUP:
+					return new TalkgroupIDEditor( aliasID );
+				default:
+					break;
+			}
+		}
+		
+		return new EmptyEditor<AliasID>();
+	}
+	
+	public static Editor<AliasAction> getEditor( AliasAction aliasAction )
+	{
+		if( aliasAction != null )
+		{
+			switch( aliasAction.getType() )
+			{
+				case BEEP:
+					return new BeepActionEditor( aliasAction );
+				case CLIP:
+					return new ClipActionEditor( aliasAction );
+				case SCRIPT:
+					return new ScriptActionEditor( aliasAction );
+				default:
+					break;
+			}
+		}
+		
+		return new EmptyEditor<AliasAction>();
+	}
+	
+	public static AliasID getAliasID( AliasIDType type )
+	{
+		switch( type )
+		{
+			case BROADCAST_CHANNEL:
+				return new BroadcastChannel();
+			case ESN:
+				return new Esn();
+			case FLEETSYNC:
+				return new FleetsyncID();
+			case LTR_NET_UID:
+				return new UniqueID();
+			case LOJACK:
+				return new LoJackFunctionAndID();
+			case MDC1200:
+				return new MDC1200ID();
+			case MIN:
+				return new Min();
+			case MPT1327:
+				return new MPT1327ID();
+			case NON_RECORDABLE:
+				return new NonRecordable();
+			case PRIORITY:
+				return new Priority();
+			case SITE:
+				return new SiteID();
+			case STATUS:
+				return new StatusID();
+			case TALKGROUP:
+				return new TalkgroupID();
+			default:
+				throw new IllegalArgumentException( "Unrecognized Alias ID type: " + type );
+		}
+	}
+	
+	public static AliasAction getAliasAction( AliasActionType type )
+	{
+		switch( type )
+		{
+			case BEEP:
+				return new BeepAction();
+			case CLIP:
+				return new ClipAction();
+			case SCRIPT:
+				return new ScriptAction();
+			default:
+				throw new IllegalArgumentException( "Unrecognized Alias Action type: " + type );
+		}
+	}
+	
+}

src/main/java/alias/AliasList.java

@@ -0,0 +1,677 @@
+/*******************************************************************************
+ * 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 alias;
+
+import alias.id.AliasID;
+import alias.id.WildcardID;
+import alias.id.esn.Esn;
+import alias.id.fleetsync.FleetsyncID;
+import alias.id.lojack.LoJackFunctionAndID;
+import alias.id.mdc.MDC1200ID;
+import alias.id.mobileID.Min;
+import alias.id.mpt1327.MPT1327ID;
+import alias.id.siteID.SiteID;
+import alias.id.status.StatusID;
+import alias.id.talkgroup.TalkgroupID;
+import alias.id.uniqueID.UniqueID;
+import module.decode.lj1200.LJ1200Message.Function;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import sample.Listener;
+
+import javax.xml.bind.annotation.XmlAttribute;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class AliasList implements Listener<AliasEvent>
+{
+    private final static Logger mLog = LoggerFactory.getLogger(AliasList.class);
+    public static final String WILDCARD = "*";
+    public static final String REGEX_WILDCARD = ".";
+
+    private Map<String,Alias> mESN = new HashMap<>();
+    private Map<String,Alias> mFleetsync = new HashMap<>();
+    private Map<LoJackFunctionAndID,Alias> mLoJack = new HashMap<>();
+    private Map<String,Alias> mMDC1200 = new HashMap<>();
+    private Map<String,Alias> mMobileID = new HashMap<>();
+    private Map<String,Alias> mMPT1327 = new HashMap<>();
+    private Map<String,Alias> mSiteID = new HashMap<>();
+    private Map<Integer,Alias> mStatus = new HashMap<>();
+    private Map<String,Alias> mTalkgroup = new HashMap<>();
+    private Map<Integer,Alias> mUniqueID = new HashMap<>();
+
+    private List<WildcardID> mESNWildcards = new ArrayList<>();
+    private List<WildcardID> mMobileIDWildcards = new ArrayList<>();
+    private List<WildcardID> mFleetsyncWildcards = new ArrayList<>();
+    private List<WildcardID> mMDC1200Wildcards = new ArrayList<>();
+    private List<WildcardID> mMPT1327Wildcards = new ArrayList<>();
+    private List<WildcardID> mSiteWildcards = new ArrayList<>();
+    private List<WildcardID> mTalkgroupWildcards = new ArrayList<>();
+
+    private String mName;
+
+    /**
+     * List of aliases where all aliases share the same list name.  Contains
+     * several methods for alias lookup from identifier values, like talkgroups.
+     *
+     * Responds to alias change events to keep the internal alias list updated.
+     */
+    public AliasList(String name)
+    {
+        mName = name;
+    }
+
+    /**
+     * Adds the alias to this list
+     */
+    public void addAlias(Alias alias)
+    {
+        if(alias != null)
+        {
+            for(AliasID aliasID : alias.getId())
+            {
+                addAliasID(aliasID, alias);
+            }
+        }
+    }
+
+    /**
+     * Adds the alias and alias identifier to the internal type mapping.
+     */
+    private void addAliasID(AliasID id, Alias alias)
+    {
+        if(id.isValid())
+        {
+            try
+            {
+                switch(id.getType())
+                {
+                    case ESN:
+                        String esn = ((Esn) id).getEsn();
+
+                        if(esn != null)
+                        {
+                            if(esn.contains(WILDCARD))
+                            {
+                                mESNWildcards.add(new WildcardID(esn));
+                                Collections.sort(mESNWildcards);
+                            }
+
+                            mESN.put(esn, alias);
+                        }
+                        break;
+                    case FLEETSYNC:
+                        String fleetsync = ((FleetsyncID) id).getIdent();
+
+                        if(fleetsync != null)
+                        {
+                            if(fleetsync.contains(WILDCARD))
+                            {
+                                mFleetsyncWildcards.add(new WildcardID(fleetsync));
+                                Collections.sort(mFleetsyncWildcards);
+                            }
+
+                            mFleetsync.put(fleetsync, alias);
+                        }
+                        break;
+                    case LOJACK:
+                        mLoJack.put((LoJackFunctionAndID) id, alias);
+                        break;
+                    case MDC1200:
+                        String mdc = ((MDC1200ID) id).getIdent();
+
+                        if(mdc != null)
+                        {
+                            if(mdc.contains(WILDCARD))
+                            {
+                                mMDC1200Wildcards.add(new WildcardID(mdc));
+                                Collections.sort(mMDC1200Wildcards);
+                            }
+
+                            mMDC1200.put(mdc, alias);
+                        }
+                        break;
+                    case MPT1327:
+                        String mpt = ((MPT1327ID) id).getIdent();
+
+                        if(mpt != null)
+                        {
+                            if(mpt.contains(WILDCARD))
+                            {
+                                mMPT1327Wildcards.add(new WildcardID(mpt));
+                                Collections.sort(mMPT1327Wildcards);
+                            }
+
+                            mMPT1327.put(mpt, alias);
+                        }
+                        break;
+                    case MIN:
+                        String min = ((Min) id).getMin();
+
+                        if(min != null)
+                        {
+                            if(min.contains(WILDCARD))
+                            {
+                                mMobileIDWildcards.add(new WildcardID(min));
+                                Collections.sort(mMobileIDWildcards);
+                            }
+
+                            mMobileID.put(min, alias);
+                        }
+                        break;
+                    case LTR_NET_UID:
+                        mUniqueID.put(((UniqueID) id).getUid(), alias);
+                        break;
+                    case SITE:
+                        String siteID = ((SiteID) id).getSite();
+
+                        if(siteID != null)
+                        {
+                            if(siteID.contains(WILDCARD))
+                            {
+                                mSiteWildcards.add(new WildcardID(siteID));
+                                Collections.sort(mSiteWildcards);
+                            }
+
+                            mSiteID.put(siteID, alias);
+                        }
+                        break;
+                    case STATUS:
+                        mStatus.put(((StatusID) id).getStatus(), alias);
+                        break;
+                    case TALKGROUP:
+                        String tgid = ((TalkgroupID) id).getTalkgroup();
+
+                        if(tgid != null)
+                        {
+                            if(tgid.contains(WILDCARD))
+                            {
+                                mTalkgroupWildcards.add(new WildcardID(tgid));
+                                Collections.sort(mTalkgroupWildcards);
+                            }
+
+                            mTalkgroup.put(tgid, alias);
+                        }
+                        break;
+                    case BROADCAST_CHANNEL:
+                    case NON_RECORDABLE:
+                    case PRIORITY:
+                        //We don't maintain lookups for these items
+                        break;
+                    default:
+                        mLog.warn("Unrecognized Alias ID Type:" + id.getType().name() + " - can't ADD to lookup table");
+                        break;
+                }
+            }
+            catch(Exception e)
+            {
+                mLog.error("Couldn't add alias ID " + id + " for alias " + alias);
+            }
+        }
+    }
+
+    /**
+     * Removes the alias from this list
+     */
+    public void removeAlias(Alias alias)
+    {
+        if(alias != null)
+        {
+            for(AliasID aliasID : alias.getId())
+            {
+                removeAliasID(aliasID, alias);
+            }
+        }
+    }
+
+    private void removeWildcard(String value, List<WildcardID> wildcards)
+    {
+        if(value != null)
+        {
+            for(WildcardID wildcardID : wildcards)
+            {
+                if(wildcardID.value().equals(value))
+                {
+                    wildcards.remove(wildcardID);
+                }
+            }
+        }
+    }
+
+    /**
+     * Removes the alias and alias identifier from internal mappings.
+     */
+    private void removeAliasID(AliasID id, Alias alias)
+    {
+        if(id.isValid())
+        {
+            switch(id.getType())
+            {
+                case ESN:
+                    String esn = ((Esn) id).getEsn();
+
+                    if(esn != null)
+                    {
+                        if(esn.contains(WILDCARD))
+                        {
+                            removeWildcard(esn, mESNWildcards);
+                        }
+                    }
+
+                    mESN.remove(esn);
+                    break;
+                case FLEETSYNC:
+                    String fleetsync = ((FleetsyncID) id).getIdent();
+
+                    if(fleetsync != null)
+                    {
+                        if(fleetsync.contains(WILDCARD))
+                        {
+                            removeWildcard(fleetsync, mFleetsyncWildcards);
+                        }
+
+                        mFleetsync.remove(fleetsync);
+                    }
+                    break;
+                case LOJACK:
+                    mLoJack.remove((LoJackFunctionAndID) id);
+                    break;
+                case MDC1200:
+                    String mdc = ((MDC1200ID) id).getIdent();
+
+                    if(mdc != null)
+                    {
+                        if(mdc.contains(WILDCARD))
+                        {
+                            removeWildcard(mdc, mMDC1200Wildcards);
+                        }
+
+                        mMDC1200.remove(mdc);
+                    }
+                    break;
+                case MPT1327:
+                    String mpt = ((MPT1327ID) id).getIdent();
+
+                    if(mpt != null)
+                    {
+                        if(mpt.contains(WILDCARD))
+                        {
+                            removeWildcard(mpt, mMPT1327Wildcards);
+                        }
+
+                        mMPT1327.remove(mpt);
+                    }
+                    break;
+                case MIN:
+                    String min = ((Min) id).getMin();
+
+                    if(min != null)
+                    {
+                        if(min.contains(WILDCARD))
+                        {
+                            removeWildcard(min, mMobileIDWildcards);
+                        }
+
+                        mMobileID.remove(min);
+                    }
+                    break;
+                case LTR_NET_UID:
+                    mUniqueID.remove(((UniqueID) id).getUid());
+                    break;
+                case SITE:
+                    mSiteID.remove(((SiteID) id).getSite());
+                    break;
+                case STATUS:
+                    mStatus.remove(((StatusID) id).getStatus());
+                    break;
+                case TALKGROUP:
+                    String tgid = ((TalkgroupID) id).getTalkgroup();
+
+                    if(tgid != null)
+                    {
+                        if(tgid.contains(WILDCARD))
+                        {
+                            removeWildcard(tgid, mTalkgroupWildcards);
+                        }
+
+                        mTalkgroup.remove(tgid);
+                    }
+                    break;
+                case NON_RECORDABLE:
+                case PRIORITY:
+                case BROADCAST_CHANNEL:
+                    //We don't maintain lookups for these items
+                    break;
+                default:
+                    mLog.warn("Unrecognized Alias ID Type:" + id.getType().name() + " - can't REMOVE from lookup table");
+                    break;
+            }
+        }
+    }
+
+    /**
+     * Returns the first matching regex wildcard from the list of wildcards that matches the
+     * identifier.
+     *
+     * @param id to match
+     * @param wildcards to match against
+     * @return matching wildcard ID or null
+     */
+    private String getWildcardMatch(String id, List<WildcardID> wildcards)
+    {
+        if(id != null)
+        {
+            for(WildcardID wildcard : wildcards)
+            {
+                if(wildcard.matches(id))
+                {
+                    return wildcard.value();
+                }
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Lookup alias by site ID
+     */
+    public Alias getSiteID(String siteID)
+    {
+        Alias alias = null;
+
+        if(siteID != null)
+        {
+            alias = mSiteID.get(siteID);
+
+            if(alias == null)
+            {
+                String wildcard = getWildcardMatch(siteID, mSiteWildcards);
+
+                if(wildcard != null)
+                {
+                    alias = mSiteID.get(wildcard);
+                }
+            }
+        }
+
+        return alias;
+    }
+
+    /**
+     * Lookup alias by status ID
+     */
+    public Alias getStatus(int status)
+    {
+        return mStatus.get(status);
+    }
+
+    /**
+     * Lookup alias by Unique ID (UID)
+     */
+    public Alias getUniqueID(int uniqueID)
+    {
+        return mUniqueID.get(uniqueID);
+    }
+
+    /**
+     * Lookup alias by ESN
+     */
+    public Alias getESNAlias(String esn)
+    {
+        Alias alias = null;
+
+        if(esn != null)
+        {
+            alias = mESN.get(esn);
+
+            if(alias == null)
+            {
+                String wildcard = getWildcardMatch(esn, mESNWildcards);
+
+                if(wildcard != null)
+                {
+                    alias = mESN.get(wildcard);
+                }
+            }
+        }
+
+        return alias;
+    }
+
+    /**
+     * Lookup alias by fleetsync ID
+     */
+    public Alias getFleetsyncAlias(String ident)
+    {
+        Alias alias = null;
+
+        if(ident != null)
+        {
+            alias = mFleetsync.get(ident);
+
+            if(alias == null)
+            {
+                String wildcard = getWildcardMatch(ident, mFleetsyncWildcards);
+
+                if(wildcard != null)
+                {
+                    alias = mFleetsync.get(wildcard);
+                }
+            }
+        }
+
+        return alias;
+    }
+
+    /**
+     * Lookup alias by lojack function and ID
+     */
+    public Alias getLoJackAlias(Function function, String id)
+    {
+        if(id != null)
+        {
+            for(LoJackFunctionAndID lojack : mLoJack.keySet())
+            {
+                if(lojack.matches(function, id))
+                {
+                    return mLoJack.get(lojack);
+                }
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Lookup alias by MDC1200 ID
+     */
+    public Alias getMDC1200Alias(String ident)
+    {
+        Alias alias = null;
+
+        if(ident != null)
+        {
+            alias = mMDC1200.get(ident);
+
+            if(alias == null)
+            {
+                String wildcard = getWildcardMatch(ident, mMDC1200Wildcards);
+
+                if(wildcard != null)
+                {
+                    alias = mMDC1200.get(wildcard);
+                }
+            }
+        }
+
+        return alias;
+    }
+
+    /**
+     * Lookup alias by MPT1327 Ident
+     */
+    public Alias getMPT1327Alias(String ident)
+    {
+        Alias alias = null;
+
+        if(ident != null)
+        {
+            alias = mMPT1327.get(ident);
+
+            if(alias == null)
+            {
+                String wildcard = getWildcardMatch(ident, mMPT1327Wildcards);
+
+                if(wildcard != null)
+                {
+                    alias = mMPT1327.get(wildcard);
+                }
+            }
+        }
+
+        return alias;
+    }
+
+    /**
+     * Lookup alias by Mobile ID Number (MIN)
+     */
+    public Alias getMobileIDNumberAlias(String ident)
+    {
+        Alias alias = null;
+
+        if(ident != null)
+        {
+            alias = mMobileID.get(ident);
+
+            if(alias == null)
+            {
+                String wildcard = getWildcardMatch(ident, mMobileIDWildcards);
+
+                if(wildcard != null)
+                {
+                    alias = mMobileID.get(wildcard);
+                }
+            }
+        }
+
+        return alias;
+    }
+
+    /**
+     * Lookup alias by talkgroup
+     *
+     * @param tgid to use when searching for an alias
+     * @param includeWildcards true if you want to additionally search for a matching alias that contains wildcard(s)
+     * when there is not a direct match to the TGID.
+     */
+    public Alias getTalkgroupAlias(String tgid, boolean includeWildcards)
+    {
+        Alias alias = null;
+
+        if(tgid != null)
+        {
+            alias = mTalkgroup.get(tgid);
+
+            if(alias == null && includeWildcards)
+            {
+                String wildcard = getWildcardMatch(tgid, mTalkgroupWildcards);
+
+                if(wildcard != null)
+                {
+                    alias = mTalkgroup.get(wildcard);
+                }
+            }
+        }
+
+        return alias;
+    }
+
+    /**
+     * Lookup alias by talkgroup.  Defaults to matching to wildcard talkgroups.
+     */
+    public Alias getTalkgroupAlias(String tgid)
+    {
+        return getTalkgroupAlias(tgid, true);
+    }
+
+    /**
+     * Alias list name
+     */
+    public String toString()
+    {
+        return mName;
+    }
+
+    /**
+     * Alias list name
+     */
+    @XmlAttribute
+    public String getName()
+    {
+        return mName;
+    }
+
+    /**
+     * Indicates if this alias list has a non-null, non-empty name
+     */
+    private boolean hasName()
+    {
+        return mName != null && !mName.isEmpty();
+    }
+
+    /**
+     * Receive alias change event notifications and modify this list accordingly
+     */
+    @Override
+    public void receive(AliasEvent event)
+    {
+        if(hasName())
+        {
+            Alias alias = event.getAlias();
+
+            switch(event.getEvent())
+            {
+                case ADD:
+                    if(alias.getList() != null && getName().equalsIgnoreCase(alias.getList()))
+                    {
+                        addAlias(alias);
+                    }
+                    break;
+                case CHANGE:
+                    if(alias.getList() != null && getName().equalsIgnoreCase(alias.getList()))
+                    {
+                        addAlias(alias);
+                    }
+                    break;
+                case DELETE:
+                    if(alias.getList() != null && getName().equalsIgnoreCase(alias.getList()))
+                    {
+                        removeAlias(alias);
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+}

src/main/java/alias/AliasModel.java

@@ -0,0 +1,350 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014-2016 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 alias;
+
+import alias.AliasEvent.Event;
+import alias.id.broadcast.BroadcastChannel;
+import sample.Broadcaster;
+import sample.Listener;
+
+import javax.swing.table.AbstractTableModel;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+/**
+ * Alias Model
+ */
+public class AliasModel extends AbstractTableModel
+{
+    private static final long serialVersionUID = 1L;
+
+    public static final int COLUMN_LIST = 0;
+    public static final int COLUMN_GROUP = 1;
+    public static final int COLUMN_NAME = 2;
+    public static final int COLUMN_ICON = 3;
+    public static final int COLUMN_COLOR = 4;
+
+    private List<Alias> mAliases = new CopyOnWriteArrayList<>();
+    private Broadcaster<AliasEvent> mAliasEventBroadcaster = new Broadcaster<>();
+    private Map<String,AliasList> mAliasListMap = new HashMap<>();
+
+    public AliasModel()
+    {
+    }
+
+    /**
+     * Unmodifiable list of all aliases currently in the model
+     */
+    public List<Alias> getAliases()
+    {
+        return Collections.unmodifiableList(mAliases);
+    }
+
+    public Alias getAliasAtIndex(int row)
+    {
+        if(mAliases.size() >= row)
+        {
+            return mAliases.get(row);
+        }
+
+        return null;
+    }
+
+    public AliasList getAliasList(String name)
+    {
+        if(name != null && mAliasListMap.containsKey(name))
+        {
+            return mAliasListMap.get(name);
+        }
+
+        AliasList aliasList = new AliasList(name);
+
+        if(name != null)
+        {
+            for(Alias alias : mAliases)
+            {
+                if(alias.hasList() && alias.getList().equalsIgnoreCase(name))
+                {
+                    aliasList.addAlias(alias);
+                }
+            }
+
+            mAliasListMap.put(name, aliasList);
+
+            //Register the new alias list to receive updates from this model
+            addListener(aliasList);
+        }
+
+        return aliasList;
+    }
+
+    /**
+     * Returns a list of unique alias list names from across the alias set
+     */
+    public List<String> getListNames()
+    {
+        List<String> listNames = new ArrayList<>();
+
+        for(Alias alias : mAliases)
+        {
+            if(alias.hasList() && !listNames.contains(alias.getList()))
+            {
+                listNames.add(alias.getList());
+            }
+        }
+
+        Collections.sort(listNames);
+
+        return listNames;
+    }
+
+    /**
+     * Returns a list of alias group names for all aliases
+     */
+    public List<String> getGroupNames()
+    {
+        List<String> groupNames = new ArrayList<>();
+
+        for(Alias alias : mAliases)
+        {
+            if(alias.hasGroup() && !groupNames.contains(alias.getGroup()))
+            {
+                groupNames.add(alias.getGroup());
+            }
+        }
+
+        Collections.sort(groupNames);
+
+        return groupNames;
+    }
+
+    /**
+     * Returns a list of alias group names for all aliases that have a matching
+     * list name value
+     */
+    public List<String> getGroupNames(String listName)
+    {
+        List<String> groupNames = new ArrayList<>();
+
+        if(listName != null)
+        {
+            for(Alias alias : mAliases)
+            {
+                if(alias.hasList() &&
+                    alias.hasGroup() &&
+                    listName.equals(alias.getList()) &&
+                    !groupNames.contains(alias.getGroup()))
+                {
+                    groupNames.add(alias.getGroup());
+                }
+            }
+        }
+
+        Collections.sort(groupNames);
+
+        return groupNames;
+    }
+
+    /**
+     * Bulk loading of aliases
+     */
+    public void addAliases(List<Alias> aliases)
+    {
+        for(Alias alias : aliases)
+        {
+            addAlias(alias);
+        }
+    }
+
+    /**
+     * Adds the alias to the model
+     */
+    public int addAlias(Alias alias)
+    {
+        if(alias != null)
+        {
+            mAliases.add(alias);
+
+            int index = mAliases.size() - 1;
+
+            fireTableRowsInserted(index, index);
+
+            broadcast(new AliasEvent(alias, Event.ADD));
+
+            return index;
+        }
+
+        return -1;
+    }
+
+    /**
+     * Removes the channel from the model and broadcasts a channel remove event
+     */
+    public void removeAlias(Alias alias)
+    {
+        if(alias != null)
+        {
+            int index = mAliases.indexOf(alias);
+
+            mAliases.remove(alias);
+
+            fireTableRowsDeleted(index, index);
+
+            broadcast(new AliasEvent(alias, Event.DELETE));
+        }
+    }
+
+    /**
+     * Renames any broadcast channels that have the previous name.
+     *
+     * @param previousName to rename
+     * @param newName to assign to the broadcast channel
+     */
+    public void renameBroadcastChannel(String previousName, String newName)
+    {
+        if(previousName == null || previousName.isEmpty() || newName == null || newName.isEmpty())
+        {
+            return;
+        }
+
+        for(Alias alias : mAliases)
+        {
+            if(alias.hasBroadcastChannel(previousName))
+            {
+                for(BroadcastChannel broadcastChannel : alias.getBroadcastChannels())
+                {
+                    if(broadcastChannel.getChannelName().contentEquals(previousName))
+                    {
+                        broadcastChannel.setChannelName(newName);
+                    }
+                }
+            }
+        }
+    }
+
+    @Override
+    public int getRowCount()
+    {
+        return mAliases.size();
+    }
+
+    @Override
+    public int getColumnCount()
+    {
+        return 5;
+    }
+
+    @Override
+    public String getColumnName(int columnIndex)
+    {
+        switch(columnIndex)
+        {
+            case COLUMN_LIST:
+                return "List";
+            case COLUMN_GROUP:
+                return "Group";
+            case COLUMN_NAME:
+                return "Name";
+            case COLUMN_ICON:
+                return "Icon";
+            case COLUMN_COLOR:
+                return "Color";
+        }
+
+        return null;
+    }
+
+    @Override
+    public Class<?> getColumnClass(int columnIndex)
+    {
+        if(columnIndex == COLUMN_COLOR)
+        {
+            return Integer.class;
+        }
+
+        return String.class;
+    }
+
+    @Override
+    public boolean isCellEditable(int rowIndex, int columnIndex)
+    {
+        return false;
+    }
+
+    @Override
+    public Object getValueAt(int rowIndex, int columnIndex)
+    {
+        Alias alias = mAliases.get(rowIndex);
+
+        switch(columnIndex)
+        {
+            case COLUMN_LIST:
+                return alias.getList();
+            case COLUMN_GROUP:
+                return alias.getGroup();
+            case COLUMN_NAME:
+                return alias.getName();
+            case COLUMN_ICON:
+                return alias.getIconName();
+            case COLUMN_COLOR:
+                return alias.getColor();
+        }
+
+        return null;
+    }
+
+    @Override
+    public void setValueAt(Object aValue, int rowIndex, int columnIndex)
+    {
+        throw new IllegalArgumentException("Not yet implemented");
+    }
+
+    public void broadcast(AliasEvent event)
+    {
+        Alias alias = event.getAlias();
+
+        //Validate the alias following a user action that changed the alias or any alias IDs
+        if(alias != null)
+        {
+            alias.validate();
+        }
+
+        if(event.getEvent() == Event.CHANGE)
+        {
+            int index = mAliases.indexOf(event.getAlias());
+
+            fireTableRowsUpdated(index, index);
+        }
+
+        mAliasEventBroadcaster.broadcast(event);
+    }
+
+    public void addListener(Listener<AliasEvent> listener)
+    {
+        mAliasEventBroadcaster.addListener(listener);
+    }
+
+    public void removeListener(Listener<AliasEvent> listener)
+    {
+        mAliasEventBroadcaster.removeListener(listener);
+    }
+}

src/main/java/alias/AliasNameEditor.java

@@ -0,0 +1,334 @@
+/*******************************************************************************
+ * 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 alias;
+
+import alias.AliasEvent.Event;
+import gui.editor.Editor;
+import icon.Icon;
+import icon.IconListCellRenderer;
+import icon.IconManager;
+import icon.IconTableModel;
+import net.miginfocom.swing.MigLayout;
+
+import javax.swing.*;
+import javax.swing.event.DocumentEvent;
+import javax.swing.event.DocumentListener;
+import javax.swing.event.TableModelEvent;
+import javax.swing.event.TableModelListener;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.util.List;
+
+public class AliasNameEditor extends Editor<Alias>
+{
+    private static final long serialVersionUID = 1L;
+
+    private static ComboBoxModel<String> EMPTY_LIST_MODEL = new DefaultComboBoxModel<>();
+    private static ComboBoxModel<String> EMPTY_GROUP_MODEL = new DefaultComboBoxModel<>();
+
+    private JComboBox<String> mListCombo = new JComboBox<>(EMPTY_LIST_MODEL);
+    private JComboBox<String> mGroupCombo = new JComboBox<>(EMPTY_GROUP_MODEL);
+    private JComboBox<Icon> mIconCombo;
+    private JTextField mName;
+    private JButton mButtonColor;
+    private JButton mBtnIconManager;
+
+    private AliasModel mAliasModel;
+    private IconManager mIconManager;
+
+    public AliasNameEditor(AliasModel aliasModel, IconManager iconManager)
+    {
+        mAliasModel = aliasModel;
+        mIconManager = iconManager;
+
+        mIconManager.getModel().addTableModelListener(new TableModelListener()
+        {
+            @Override
+            public void tableChanged(TableModelEvent e)
+            {
+                refreshIcons();
+            }
+        });
+
+        init();
+    }
+
+    private void init()
+    {
+        setLayout(new MigLayout("fill,wrap 2", "[right][grow,fill]", "[][][][][][][grow]"));
+
+        add(new JLabel("Name:"));
+        mName = new JTextField();
+        mName.getDocument().addDocumentListener(new DocumentListener()
+        {
+            @Override
+            public void removeUpdate(DocumentEvent e)
+            {
+                setModified(true);
+            }
+
+            @Override
+            public void insertUpdate(DocumentEvent e)
+            {
+                setModified(true);
+            }
+
+            @Override
+            public void changedUpdate(DocumentEvent e)
+            {
+            }
+        });
+        add(mName, "wrap");
+
+        add(new JLabel("List:"));
+        mListCombo.setEditable(true);
+        mListCombo.addActionListener(new ActionListener()
+        {
+            @Override
+            public void actionPerformed(ActionEvent e)
+            {
+                if(mListCombo.getSelectedItem() != null)
+                {
+                    List<String> groups = mAliasModel
+                        .getGroupNames((String) mListCombo.getSelectedItem());
+
+                    if(groups.isEmpty())
+                    {
+                        mGroupCombo.setModel(EMPTY_GROUP_MODEL);
+                    }
+                    else
+                    {
+                        mGroupCombo.setModel(new DefaultComboBoxModel<String>(
+                            groups.toArray(new String[groups.size()])));
+                        ;
+                    }
+                }
+
+                setModified(true);
+            }
+        });
+        add(mListCombo, "wrap");
+
+        add(new JLabel("Group:"));
+        mGroupCombo.setEditable(true);
+        mGroupCombo.addActionListener(new ActionListener()
+        {
+            @Override
+            public void actionPerformed(ActionEvent e)
+            {
+                setModified(true);
+            }
+        });
+        add(mGroupCombo, "wrap");
+
+        add(new JLabel("Color:"));
+
+        mButtonColor = new JButton("Select ...");
+        mButtonColor.addActionListener(new ActionListener()
+        {
+            @Override
+            public void actionPerformed(ActionEvent e)
+            {
+                Color newColor = JColorChooser.showDialog(
+                    AliasNameEditor.this,
+                    "Choose color for this alias",
+                    (hasItem() ? getItem().getDisplayColor() : null));
+
+                if(newColor != null)
+                {
+                    mButtonColor.setForeground(newColor);
+                    mButtonColor.setBackground(newColor);
+
+                    setModified(true);
+                }
+            }
+        });
+        add(mButtonColor, "wrap");
+
+        add(new JLabel("Icon:"));
+
+        mIconCombo = new JComboBox<Icon>(mIconManager.getIcons());
+
+        IconListCellRenderer renderer = new IconListCellRenderer(mIconManager);
+        renderer.setPreferredSize(new Dimension(200, 30));
+        mIconCombo.setRenderer(renderer);
+        mIconCombo.addActionListener(new ActionListener()
+        {
+            @Override
+            public void actionPerformed(ActionEvent e)
+            {
+                setModified(true);
+            }
+        });
+
+        add(mIconCombo, "wrap");
+
+        //Dummy place holder
+        add(new JLabel());
+
+        mBtnIconManager = new JButton("Icon Manager");
+        mBtnIconManager.addActionListener(new ActionListener()
+        {
+            @Override
+            public void actionPerformed(ActionEvent arg0)
+            {
+                mIconManager.showEditor(AliasNameEditor.this);
+            }
+        });
+
+        add(mBtnIconManager, "span 2,wrap");
+
+        setModified(false);
+    }
+
+    private void refreshIcons()
+    {
+        if(mIconCombo != null)
+        {
+            EventQueue.invokeLater(new Runnable()
+            {
+                @Override
+                public void run()
+                {
+                    mIconCombo.setModel(new DefaultComboBoxModel<>(mIconManager.getIcons()));
+
+                    if(hasItem())
+                    {
+                        String iconName = getItem().getIconName();
+                        Icon aliasIcon = mIconManager.getModel().getIcon(iconName);
+
+                        if(aliasIcon != null)
+                        {
+                            mIconCombo.setSelectedItem(aliasIcon);
+                        }
+                    }
+                }
+            });
+        }
+    }
+
+    @Override
+    public void setItem(Alias alias)
+    {
+        super.setItem(alias);
+
+        if(hasItem())
+        {
+            mName.setText(alias.getName());
+
+            mIconCombo.setModel(new DefaultComboBoxModel<>(mIconManager.getIcons()));
+
+            List<String> listNames = mAliasModel.getListNames();
+
+            if(listNames.isEmpty())
+            {
+                mListCombo.setModel(EMPTY_LIST_MODEL);
+            }
+            else
+            {
+                mListCombo.setModel(new DefaultComboBoxModel<String>(
+                    listNames.toArray(new String[listNames.size()])));
+                ;
+            }
+
+            mListCombo.setSelectedItem(alias.getList());
+
+            List<String> groupNames = mAliasModel.getGroupNames(alias.getList());
+
+            if(groupNames.isEmpty())
+            {
+                mGroupCombo.setModel(EMPTY_GROUP_MODEL);
+            }
+            else
+            {
+                mGroupCombo.setModel(new DefaultComboBoxModel<String>(
+                    groupNames.toArray(new String[groupNames.size()])));
+                ;
+            }
+
+            mGroupCombo.setSelectedItem(alias.getGroup());
+
+            Color color = alias.getDisplayColor();
+
+            mButtonColor.setBackground(color);
+            mButtonColor.setForeground(color);
+
+            String iconName = alias.getIconName();
+
+            if(iconName == null)
+            {
+                iconName = IconTableModel.DEFAULT_ICON;
+            }
+
+            Icon savedIcon = mIconManager.getModel().getIcon(iconName);
+
+            if(savedIcon != null)
+            {
+                mIconCombo.setSelectedItem(savedIcon);
+            }
+        }
+        else
+        {
+            mListCombo.setModel(EMPTY_LIST_MODEL);
+            mGroupCombo.setModel(EMPTY_GROUP_MODEL);
+            mName.setText(null);
+
+            mButtonColor.setBackground(getBackground());
+            mButtonColor.setForeground(getForeground());
+        }
+
+        repaint();
+
+        setModified(false);
+    }
+
+    @Override
+    public void save()
+    {
+        if(hasItem() && isModified())
+        {
+            Alias alias = getItem();
+
+            if(mListCombo.getSelectedItem() != null)
+            {
+                alias.setList((String) mListCombo.getSelectedItem());
+            }
+
+            if(mGroupCombo.getSelectedItem() != null)
+            {
+                alias.setGroup((String) mGroupCombo.getSelectedItem());
+            }
+
+            alias.setName(mName.getText());
+
+            alias.setColor(mButtonColor.getBackground().getRGB());
+
+            if(mIconCombo.getSelectedItem() != null)
+            {
+                alias.setIconName(((Icon) mIconCombo.getSelectedItem()).getName());
+            }
+
+            setModified(false);
+
+            //Broadcast an alias change event to save the updates
+            mAliasModel.broadcast(new AliasEvent(getItem(), Event.CHANGE));
+        }
+    }
+}

src/main/java/alias/ComponentEditor.java

@@ -0,0 +1,121 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014-2016 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 alias;
+
+import javax.swing.JPanel;
+import javax.swing.event.DocumentListener;
+
+public abstract class ComponentEditor<T> extends JPanel implements DocumentListener
+{
+    private static final long serialVersionUID = 1L;
+    private boolean mModified;
+    private ComponentModificationListener mListener;
+    protected T mComponent;
+    
+    /**
+     * Abstract class for editor with notifications when contents are modified
+     * and methods for saving or resetting the component values with the
+     * contents of the editor.
+     */
+    public ComponentEditor( T component )
+    {
+    	mComponent = component;
+    }
+    
+    public ComponentEditor()
+    {
+    }
+    
+    public void dispose()
+    {
+    	mComponent = null;
+    	mListener = null;
+    }
+    
+    public T getComponent()
+    {
+    	return mComponent;
+    }
+    
+    protected void setModified( boolean modified )
+    {
+    	mModified = modified;
+    	
+    	if( modified && mListener != null )
+    	{
+    		mListener.componentModified();
+    	}
+    }
+    
+    /**
+     * Indicates if the contents of the editor have been modified
+     */
+    public boolean isModified()
+    {
+    	return mModified;
+    }
+    
+	public void setComponentModificationListener( ComponentModificationListener listener )
+    {
+    	mListener = listener;
+    }
+    
+    /**
+     * Sets or resets the editable component
+     */
+    public abstract void setComponent( T t );
+    
+    /**
+     * Saves changed editor values to the component
+     */
+    public abstract void save();
+
+    /**
+     * Reloads the editor contents from the source component and resets the 
+     * modified flag
+     */
+    public void reset()
+    {
+    	setComponent( getComponent() );
+    }
+    
+    /**
+     * Validate contents of other editors against this component editor before 
+     * saving.  Override this method to allow controller to pass other editors
+     * to this editor for content inspection/validation before indicating that
+     * this editor passes validation.  This allows for validating editor contents
+     * that are contingent on settings in other editors.
+     * 
+     * @throws ComponentValidationException if the contents of the editor 
+     * argument cannot be validated, with the exception containing a detailed
+     * description of the issue.
+     */
+    public void validate( ComponentEditor<?> editor ) throws ComponentValidationException
+    {
+    }
+    
+    /**
+     * Listener interface to receive notification that the contents of the
+     * editor have been modified from the original component value and either 
+     * need to be saved or reset
+     */
+    public interface ComponentModificationListener
+    {
+    	public void componentModified();
+    }
+}

src/main/java/alias/ComponentValidationException.java

@@ -0,0 +1,14 @@
+package alias;
+
+public class ComponentValidationException extends Exception
+{
+	private static final long serialVersionUID = 1L;
+
+	/**
+	 * Component editor contents validation error
+	 */
+	public ComponentValidationException( String message )
+	{
+		super( message );
+	}
+}

src/main/java/alias/MultipleAliasEditor.java

@@ -0,0 +1,467 @@
+package alias;
+
+import alias.AliasEvent.Event;
+import alias.id.AliasIDType;
+import alias.id.broadcast.BroadcastChannel;
+import alias.id.priority.Priority;
+import audio.broadcast.BroadcastModel;
+import gui.editor.Editor;
+import icon.Icon;
+import icon.IconListCellRenderer;
+import icon.IconManager;
+import net.miginfocom.swing.MigLayout;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import sample.Listener;
+
+import javax.swing.*;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import javax.swing.event.TableModelEvent;
+import javax.swing.event.TableModelListener;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.util.List;
+
+public class MultipleAliasEditor extends Editor<List<Alias>>
+        implements Listener<AliasEvent>
+{
+    private static final long serialVersionUID = 1L;
+    private final static Logger mLog = LoggerFactory.getLogger(MultipleAliasEditor.class);
+
+    private static String HELP_TEXT =
+            "<html>Select attributes below to change for all selected aliases</html>";
+
+    private JLabel mAliasCountLabel;
+    private JLabel mAliasCount;
+
+    private JCheckBox mListCheckBox = new JCheckBox("List");
+    private JComboBox<String> mListCombo = new JComboBox<>();
+    private JCheckBox mGroupCheckBox = new JCheckBox("Group");
+    private JComboBox<String> mGroupCombo = new JComboBox<>();
+    private JCheckBox mIconCheckBox = new JCheckBox("Icon");
+    private JComboBox<Icon> mIconCombo;
+    private JCheckBox mColorCheckBox = new JCheckBox("Color");
+    private JButton mButtonColor;
+    private JButton mBtnIconManager;
+    private JCheckBox mRecordCheckBox = new JCheckBox("Record");
+    private JComboBox<Record> mRecordActionCombo = new JComboBox<>(Record.values());
+    private JCheckBox mPriorityCheckBox = new JCheckBox("Priority");
+    private JSlider mPrioritySlider;
+    private JLabel mPrioritySliderLabel;
+    private JCheckBox mStreamCheckBox = new JCheckBox("Stream");
+    private JComboBox<String> mStreamCombo;
+
+    private AliasModel mAliasModel;
+    private BroadcastModel mBroadcastModel;
+    private IconManager mIconManager;
+
+    public MultipleAliasEditor(AliasModel aliasModel, BroadcastModel broadcastModel, IconManager iconManager)
+    {
+        mAliasModel = aliasModel;
+        mBroadcastModel = broadcastModel;
+        mIconManager = iconManager;
+
+        mAliasModel.addListener(this);
+        mIconManager.getModel().addTableModelListener(new TableModelListener()
+        {
+            @Override
+            public void tableChanged(TableModelEvent e)
+            {
+                refreshIcons();
+            }
+        });
+
+        init();
+    }
+
+    public List<Alias> getAliases()
+    {
+        if (hasItem())
+        {
+            return (List<Alias>) getItem();
+        }
+
+        return null;
+    }
+
+    public void init()
+    {
+        setLayout(new MigLayout("fill,wrap 2", "[grow,fill][grow,fill]",
+                "[][][][][][][][][][][][][][grow,fill]"));
+
+        mAliasCountLabel = new JLabel("Alias:");
+        add(mAliasCountLabel);
+
+        mAliasCount = new JLabel("Multiple");
+        add(mAliasCount, "span");
+
+        add(new JSeparator(), "span");
+
+        add(new JLabel(HELP_TEXT), "span");
+
+        add(mListCheckBox);
+
+        mListCombo.setEditable(true);
+        add(mListCombo, "wrap");
+
+        add(mGroupCheckBox);
+
+        mGroupCombo.setEditable(true);
+        add(mGroupCombo, "wrap");
+
+        add(mColorCheckBox);
+
+        mButtonColor = new JButton("Select ...");
+        mButtonColor.addActionListener(new ActionListener()
+        {
+            @Override
+            public void actionPerformed(ActionEvent e)
+            {
+                Color newColor = JColorChooser.showDialog(
+                        MultipleAliasEditor.this,
+                        "Choose color for this alias", null);
+
+                if (newColor != null)
+                {
+                    mButtonColor.setForeground(newColor);
+                    mButtonColor.setBackground(newColor);
+                }
+            }
+        });
+        add(mButtonColor, "wrap");
+
+        add(mIconCheckBox);
+
+        mIconCombo = new JComboBox<Icon>(mIconManager.getIcons());
+
+        IconListCellRenderer renderer = new IconListCellRenderer(mIconManager);
+        renderer.setPreferredSize(new Dimension(200, 30));
+        mIconCombo.setRenderer(renderer);
+        add(mIconCombo, "wrap");
+
+        //Dummy place holder
+        add(new JLabel());
+
+        mBtnIconManager = new JButton("Icon Manager");
+        mBtnIconManager.addActionListener(new ActionListener()
+        {
+            @Override
+            public void actionPerformed(ActionEvent arg0)
+            {
+                mIconManager.showEditor(MultipleAliasEditor.this);
+            }
+        });
+
+        add(mBtnIconManager, "span,wrap");
+
+        add(mRecordCheckBox);
+        add(mRecordActionCombo);
+
+        //Placeholder
+        add(new JLabel(" "));
+        mPrioritySliderLabel = new JLabel("Audio Priority: " + Priority.MIN_PRIORITY);
+        add(mPrioritySliderLabel);
+
+        add(mPriorityCheckBox);
+
+        mPrioritySlider = new JSlider(JSlider.HORIZONTAL,
+                Priority.MIN_PRIORITY,
+                Priority.MAX_PRIORITY + 1,
+                Priority.MIN_PRIORITY);
+
+        mPrioritySlider.setMajorTickSpacing(20);
+        mPrioritySlider.setMinorTickSpacing(5);
+        mPrioritySlider.setPaintTicks(true);
+        mPrioritySlider.setLabelTable(mPrioritySlider.createStandardLabels(25, 25));
+        mPrioritySlider.setPaintLabels(true);
+        mPrioritySlider.addChangeListener(new ChangeListener()
+        {
+            @Override
+            public void stateChanged(ChangeEvent e)
+            {
+                int priority = mPrioritySlider.getValue();
+
+                if (priority > Priority.MAX_PRIORITY)
+                {
+                    mPrioritySliderLabel.setText("Audio Priority: Do Not Monitor");
+                }
+                else
+                {
+                    mPrioritySliderLabel.setText("Audio Priority: " + mPrioritySlider.getValue());
+                }
+            }
+        });
+        mPrioritySlider.setToolTipText(HELP_TEXT);
+
+        add(mPrioritySlider);
+
+        add(mStreamCheckBox);
+
+        mStreamCombo = new JComboBox<String>();
+        mStreamCombo.setEditable(true);
+        add(mStreamCombo, "wrap");
+
+        JButton saveButton = new JButton("Save");
+        saveButton.addActionListener(new ActionListener()
+        {
+            @Override
+            public void actionPerformed(ActionEvent e)
+            {
+                save();
+            }
+        });
+        add(saveButton);
+
+        JButton resetButton = new JButton("Reset");
+        resetButton.addActionListener(new ActionListener()
+        {
+            @Override
+            public void actionPerformed(ActionEvent e)
+            {
+                reset();
+            }
+        });
+        add(resetButton);
+
+        setModified(false);
+    }
+
+    private void refreshIcons()
+    {
+        if(mIconCombo != null)
+        {
+            EventQueue.invokeLater(new Runnable()
+            {
+                @Override
+                public void run()
+                {
+                    mIconCombo.setModel(new DefaultComboBoxModel<>(mIconManager.getIcons()));
+                }
+            });
+        }
+    }
+
+    @Override
+    public void setItem(List<Alias> item)
+    {
+        super.setItem(item);
+
+        StringBuilder sb = new StringBuilder();
+        sb.append("Multiple Selected [ ");
+
+        if (hasItem())
+        {
+            sb.append(String.valueOf(getAliases().size()));
+        }
+        else
+        {
+            sb.append("0");
+        }
+
+        sb.append(" ]");
+
+        mAliasCount.setText(sb.toString());
+
+        List<String> listNames = mAliasModel.getListNames();
+        listNames.add(0, "");
+        mListCombo.setModel(new DefaultComboBoxModel<String>(
+                listNames.toArray(new String[listNames.size()])));
+
+        List<String> groupNames = mAliasModel.getGroupNames();
+        groupNames.add(0, "");
+        mGroupCombo.setModel(new DefaultComboBoxModel<String>(
+                groupNames.toArray(new String[groupNames.size()])));
+
+        List<String> streamNames = mBroadcastModel.getBroadcastConfigurationNames();
+        mStreamCombo.setModel(new DefaultComboBoxModel<String>(streamNames.toArray(new String[streamNames.size()])));
+
+        mIconCombo.setModel(new DefaultComboBoxModel<>(mIconManager.getIcons()));
+
+        setCheckBoxesUnselected();
+
+        setModified(false);
+    }
+
+    private void setCheckBoxesUnselected()
+    {
+        mListCheckBox.setSelected(false);
+        mGroupCheckBox.setSelected(false);
+        mColorCheckBox.setSelected(false);
+        mIconCheckBox.setSelected(false);
+        mRecordCheckBox.setSelected(false);
+        mPriorityCheckBox.setSelected(false);
+        mStreamCheckBox.setSelected(false);
+    }
+
+    @Override
+    public void reset()
+    {
+        List<String> listNames = mAliasModel.getListNames();
+        listNames.add(0, "");
+        mListCombo.setModel(new DefaultComboBoxModel<String>(
+                listNames.toArray(new String[listNames.size()])));
+
+        List<String> groupNames = mAliasModel.getGroupNames();
+        groupNames.add(0, "");
+        mGroupCombo.setModel(new DefaultComboBoxModel<String>(
+                groupNames.toArray(new String[groupNames.size()])));
+
+        mButtonColor.setForeground(getForeground());
+        mButtonColor.setBackground(getBackground());
+
+        super.reset();
+    }
+
+    private boolean hasRequestedChanges()
+    {
+        return mListCheckBox.isSelected() ||
+                mGroupCheckBox.isSelected() ||
+                mColorCheckBox.isSelected() ||
+                mIconCheckBox.isSelected() ||
+                mRecordCheckBox.isSelected() ||
+                mPriorityCheckBox.isSelected() ||
+                mStreamCheckBox.isSelected();
+    }
+
+    @Override
+    public void save()
+    {
+        if (hasRequestedChanges() && hasItem())
+        {
+            List<Alias> aliases = getAliases();
+
+            for (Alias alias : aliases)
+            {
+                if (mListCheckBox.isSelected())
+                {
+                    String list = null;
+
+                    if (mListCombo.getSelectedItem() != null)
+                    {
+                        list = (String) mListCombo.getSelectedItem();
+                    }
+
+                    alias.setList(list);
+                }
+
+                if (mGroupCheckBox.isSelected())
+                {
+                    String group = null;
+
+                    if (mGroupCombo.getSelectedItem() != null)
+                    {
+                        group = (String) mGroupCombo.getSelectedItem();
+                    }
+
+                    alias.setGroup(group);
+                }
+
+                if (mColorCheckBox.isSelected())
+                {
+                    alias.setColor(mButtonColor.getForeground().getRGB());
+                }
+
+                if (mIconCheckBox.isSelected())
+                {
+                    if (mIconCombo.getSelectedItem() != null)
+                    {
+                        alias.setIconName(((Icon)mIconCombo.getSelectedItem()).getName());
+                    }
+                    else
+                    {
+                        alias.setIconName(null);
+                    }
+                }
+
+                if (mRecordCheckBox.isSelected())
+                {
+                    Record action =
+                            (Record) mRecordActionCombo.getSelectedItem();
+
+                    alias.setRecordable(action == Record.RECORDABLE);
+                }
+
+                if (mPriorityCheckBox.isSelected())
+                {
+                    int priority = mPrioritySlider.getValue();
+
+                    //This is a work-around -- we use max priority + 1 in the
+                    //gui to indicate do not monitor, and change the value here
+                    if (priority == Priority.MAX_PRIORITY + 1)
+                    {
+                        priority = Priority.DO_NOT_MONITOR;
+                    }
+
+                    alias.setCallPriority(priority);
+                }
+
+                if(mStreamCheckBox.isSelected())
+                {
+                    if(mStreamCombo.getSelectedItem() != null)
+                    {
+                        String streamName = (String)mStreamCombo.getSelectedItem();
+
+                        boolean hasChannel = false;
+
+                        //Ensure the alias doesn't already have the channel
+                        for(BroadcastChannel channel: alias.getBroadcastChannels())
+                        {
+                            if(channel.getChannelName().equals(streamName))
+                            {
+                                hasChannel = true;
+                                continue;
+                            }
+                        }
+
+                        if(!hasChannel)
+                        {
+                            BroadcastChannel channel = (BroadcastChannel)AliasFactory
+                                    .getAliasID(AliasIDType.BROADCAST_CHANNEL);
+
+                            channel.setChannelName(streamName);
+                            alias.addAliasID(channel);
+                        }
+                    }
+                }
+            }
+
+            for (Alias alias : aliases)
+            {
+                //Broadcast an alias change event to save the updates
+                mAliasModel.broadcast(new AliasEvent(alias, Event.CHANGE));
+            }
+        }
+    }
+
+    @Override
+    public void receive(AliasEvent event)
+    {
+        if (event.getEvent() == Event.DELETE &&
+                hasItem() &&
+                getAliases().contains(event.getAlias()))
+        {
+            getAliases().remove(event.getAlias());
+            setItem(getAliases());
+        }
+    }
+
+    public enum Record
+    {
+        NON_RECORDABLE("Non-Recordable"),
+        RECORDABLE("Recordable");
+
+        private String mLabel;
+
+        private Record(String label)
+        {
+            mLabel = label;
+        }
+
+        public String toString()
+        {
+            return mLabel;
+        }
+    }
+}

src/main/java/alias/PatchGroupAlias.java

@@ -0,0 +1,381 @@
+/*******************************************************************************
+ * 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 alias;
+
+import alias.action.AliasAction;
+import alias.id.AliasID;
+import alias.id.AliasIDType;
+import alias.id.broadcast.BroadcastChannel;
+import alias.id.priority.Priority;
+import alias.id.talkgroup.TalkgroupID;
+import gui.SDRTrunk;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import playlist.version1.System;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class PatchGroupAlias extends Alias
+{
+    private final static Logger mLog = LoggerFactory.getLogger(PatchGroupAlias.class);
+
+    private Alias mPatchGroupAlias;
+    private List<Alias> mPatchedAliases = new ArrayList<>();
+    private List<String> mPatchedTalkgroupIDs = new ArrayList<>();
+
+    /**
+     * Patch group alias is a single alias for a group of aliases that are temporarily patched together.  This will
+     * normally be used for patched talkgroups, but could be used with any type of alias identifiers that can be
+     * temporarily joined to form a patch group.
+     *
+     * Alias properties such as recordable, streamable and call priority are an aggregation from the set of patched
+     * aliases contained in this patch group alias and the patch group ID alias and where applicable, return the highest
+     * value/priority from the group of patched aliases.
+     */
+    public PatchGroupAlias()
+    {
+    }
+
+    @Override
+    public int getColor()
+    {
+        if(mPatchGroupAlias != null)
+        {
+            return mPatchGroupAlias.getColor();
+        }
+
+        return super.getColor();
+    }
+
+    /**
+     * Sets an alias for this patch group ID
+     */
+    public void setPatchGroupAlias(Alias alias)
+    {
+        mPatchGroupAlias = alias;
+    }
+
+    /**
+     * Alias for this patch group
+     */
+    public Alias getPatchGroupAlias()
+    {
+        return mPatchGroupAlias;
+    }
+
+    /**
+     * Indicates if this patch group has an alias
+     */
+    public boolean hasPatchGroupAlias()
+    {
+        return mPatchGroupAlias != null;
+    }
+
+    /**
+     * List of patched aliases contained in this patch group
+     */
+    public List<Alias> getPatchedAliases()
+    {
+        return mPatchedAliases;
+    }
+
+    /**
+     * Removes/clears all patched aliases from this patch alias group
+     */
+    public void clearPatchedAliases()
+    {
+        mPatchedAliases.clear();
+    }
+
+    /**
+     * Adds the patched alias to this patch alias group
+     */
+    public void addPatchedAlias(Alias alias)
+    {
+        if(alias == PatchGroupAlias.this)
+        {
+            throw new IllegalArgumentException("Can't add patch group alias to itself - would create an infinite loop");
+        }
+
+        mPatchedAliases.add(alias);
+    }
+
+    /**
+     * Removes the patched alias from this patch alias group
+     */
+    public void removePatchedAlias(Alias alias)
+    {
+        mPatchedAliases.remove(alias);
+    }
+
+    /**
+     * Sets the list of patched talkgroup IDs for this patch group
+     */
+    public void setPatchedTalkgroupIDs(List<String> talkgroupIDs)
+    {
+        mPatchedTalkgroupIDs = talkgroupIDs;
+    }
+
+    /**
+     * List of patched talkgroup IDs for this patch group
+     */
+    public List<String> getPatchedTalkgroupIDs()
+    {
+        return mPatchedTalkgroupIDs;
+    }
+
+    @Override
+    public String getName()
+    {
+        if(hasPatchGroupAlias())
+        {
+            return getPatchGroupAlias().getName();
+        }
+        else
+        {
+            for(AliasID id: getId())
+            {
+                if(id.getType() == AliasIDType.TALKGROUP)
+                {
+                    return "PATCH:" + ((TalkgroupID)id).getTalkgroup();
+                }
+            }
+        }
+
+        return "PATCH:****";
+    }
+
+    @Override
+    public List<AliasAction> getAction()
+    {
+        List<AliasAction> aliasActions = new ArrayList<>();
+
+        if(hasPatchGroupAlias())
+        {
+            aliasActions.addAll(getPatchGroupAlias().getAction());
+        }
+
+        for(Alias alias: mPatchedAliases)
+        {
+            if(!(alias instanceof PatchGroupAlias))
+            {
+                for(AliasAction action: alias.getAction())
+                {
+                    if(!aliasActions.contains(action))
+                    {
+                        aliasActions.add(action);
+                    }
+                }
+            }
+        }
+
+        return aliasActions;
+    }
+
+    @Override
+    public boolean hasActions()
+    {
+        for(Alias alias: mPatchedAliases)
+        {
+            if(!(alias instanceof PatchGroupAlias) && alias.hasActions())
+            {
+                return true;
+            }
+        }
+
+        return hasPatchGroupAlias() && getPatchGroupAlias().hasActions();
+    }
+
+    /**
+     * Returns the highest listenable audio priority defined among the aliases in the group, or returns 'Do Not Monitor'
+     * if that is the only priority defined.  Otherwise, returns default (100) priority.
+     */
+    @Override
+    public int getCallPriority()
+    {
+        boolean hasDoNotMonitor = false;
+
+        int highestPriority = (hasPatchGroupAlias() ? getPatchGroupAlias().getCallPriority() : Priority.DEFAULT_PRIORITY + 1);
+
+        for(Alias alias: mPatchedAliases)
+        {
+            if(!(alias instanceof PatchGroupAlias) && alias.hasCallPriority() && alias.getCallPriority() < highestPriority)
+            {
+                if(alias.getCallPriority() == Priority.DO_NOT_MONITOR)
+                {
+                    hasDoNotMonitor = true;
+                }
+                else
+                {
+                    highestPriority = alias.getCallPriority();
+                }
+            }
+        }
+
+        if(highestPriority <= Priority.DEFAULT_PRIORITY)
+        {
+            return highestPriority;
+        }
+        else if(hasDoNotMonitor)
+        {
+            return Priority.DO_NOT_MONITOR;
+        }
+        else
+        {
+            return Priority.DEFAULT_PRIORITY;
+        }
+    }
+
+    @Override
+    public boolean hasCallPriority()
+    {
+        if(hasPatchGroupAlias() && getPatchGroupAlias().hasCallPriority())
+        {
+            return true;
+        }
+
+        for(Alias alias: mPatchedAliases)
+        {
+            if(!(alias instanceof PatchGroupAlias) && alias.hasCallPriority())
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    @Override
+    public boolean isRecordable()
+    {
+        if(hasPatchGroupAlias() && getPatchGroupAlias().isRecordable())
+        {
+            return true;
+        }
+
+        for(Alias alias: mPatchedAliases)
+        {
+            if(!(alias instanceof PatchGroupAlias) && alias.isRecordable())
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    @Override
+    public boolean isStreamable()
+    {
+        if(hasPatchGroupAlias() && getPatchGroupAlias().isStreamable())
+        {
+            return true;
+        }
+
+        for(Alias alias: mPatchedAliases)
+        {
+            if(!(alias instanceof PatchGroupAlias) && alias.isStreamable())
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    @Override
+    public Set<BroadcastChannel> getBroadcastChannels()
+    {
+        Set<BroadcastChannel> broadcastChannels = new TreeSet<>();
+
+        if(hasPatchGroupAlias())
+        {
+            broadcastChannels.addAll(getPatchGroupAlias().getBroadcastChannels());
+        }
+
+        for(Alias alias: mPatchedAliases)
+        {
+            if(!(alias instanceof PatchGroupAlias))
+            {
+                broadcastChannels.addAll(alias.getBroadcastChannels());
+            }
+        }
+
+        return broadcastChannels;
+    }
+
+    @Override
+    public boolean hasBroadcastChannel(String channel)
+    {
+        if(hasPatchGroupAlias() && getPatchGroupAlias().hasBroadcastChannel(channel))
+        {
+            return true;
+        }
+
+        for(Alias alias: mPatchedAliases)
+        {
+            if(!(alias instanceof PatchGroupAlias) && alias.hasBroadcastChannel(channel))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public static void main(String[] args)
+    {
+        Alias a1 = new Alias("Alias 1");
+        a1.addAliasID(new BroadcastChannel("Channel 1"));
+        a1.addAliasID(new BroadcastChannel("Channel 2"));
+        a1.addAliasID(new BroadcastChannel("Channel 3"));
+        a1.addAliasID(new BroadcastChannel("Channel 4"));
+
+        Alias a2 = new Alias("Alias 1");
+        a1.addAliasID(new BroadcastChannel("Channel 1"));
+        a1.addAliasID(new BroadcastChannel("Channel 2"));
+        a1.addAliasID(new BroadcastChannel("Channel 3"));
+        a1.addAliasID(new BroadcastChannel("Channel 4"));
+
+        Alias a3 = new Alias("Alias 1");
+        a1.addAliasID(new BroadcastChannel("Channel 1"));
+        a1.addAliasID(new BroadcastChannel("Channel 2"));
+        a1.addAliasID(new BroadcastChannel("Channel 3"));
+        a1.addAliasID(new BroadcastChannel("Channel 4"));
+
+        Alias a4 = new Alias("Alias 1");
+        a1.addAliasID(new BroadcastChannel("Channel 1"));
+        a1.addAliasID(new BroadcastChannel("Channel 2"));
+        a1.addAliasID(new BroadcastChannel("Channel 3"));
+        a1.addAliasID(new BroadcastChannel("Channel 4"));
+
+        PatchGroupAlias pga = new PatchGroupAlias();
+        pga.setPatchGroupAlias(a1);
+        pga.addPatchedAlias(a2);
+        pga.addPatchedAlias(a3);
+        pga.addPatchedAlias(a4);
+
+        Set<BroadcastChannel> bc = pga.getBroadcastChannels();
+
+        mLog.debug("Channels:" + bc);
+    }
+}

src/main/java/alias/action/AliasAction.java

@@ -0,0 +1,58 @@
+/*******************************************************************************
+ * 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 alias.action;
+
+import alias.Alias;
+import alias.action.beep.BeepAction;
+import alias.action.clip.ClipAction;
+import alias.action.script.ScriptAction;
+import message.Message;
+
+import javax.xml.bind.annotation.XmlRootElement;
+import javax.xml.bind.annotation.XmlSeeAlso;
+import javax.xml.bind.annotation.XmlTransient;
+import java.util.concurrent.ScheduledExecutorService;
+
+/**
+ * Alias action defines an action to execute when an alias is detected active.
+ */
+@XmlSeeAlso( { BeepAction.class, ClipAction.class, ScriptAction.class } )
+@XmlRootElement( name = "action" )
+public abstract class AliasAction
+{
+	public AliasAction()
+	{
+	}
+
+	@XmlTransient
+	public abstract AliasActionType getType();
+	
+	/**
+	 * Task to execute when an alias action is defined.  The message argument is
+	 * the original message containing one or more aliases that have an alias
+	 * action attached.  The alias argument is the parent alias containing the
+	 * alias action.
+	 */
+	public abstract void execute( ScheduledExecutorService scheduledExecutorService, Alias alias, Message message );
+
+	/**
+	 * Dismiss a persistent alias action
+	 */
+	public abstract void dismiss( boolean reset );
+}

src/main/java/alias/action/AliasActionEditor.java

@@ -0,0 +1,350 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014-2016 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 alias.action;
+
+import gui.editor.Editor;
+import gui.editor.EmptyEditor;
+
+import java.awt.EventQueue;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+import javax.swing.DefaultListModel;
+import javax.swing.JButton;
+import javax.swing.JList;
+import javax.swing.JMenuItem;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JPopupMenu;
+import javax.swing.JScrollPane;
+import javax.swing.ListModel;
+import javax.swing.ListSelectionModel;
+import javax.swing.event.ListSelectionEvent;
+import javax.swing.event.ListSelectionListener;
+
+import net.miginfocom.swing.MigLayout;
+import alias.Alias;
+import alias.AliasEvent;
+import alias.AliasEvent.Event;
+import alias.AliasFactory;
+import alias.AliasModel;
+
+public class AliasActionEditor extends Editor<Alias>
+{
+	private static final long serialVersionUID = 1L;
+
+	private static ListModel<AliasAction> EMPTY_MODEL = new DefaultListModel<>();
+	private JList<AliasAction> mAliasActionList = new JList<>( EMPTY_MODEL );
+	private JButton mNewActionButton;
+	private JButton mCloneActionButton;
+	private JButton mDeleteActionButton;
+	private EditorContainer mEditorContainer = new EditorContainer();
+
+	private AliasModel mAliasModel;
+	
+	public AliasActionEditor( AliasModel model )
+	{
+		mAliasModel = model;
+		init();
+	}
+
+	private void init()
+	{
+		setLayout( new MigLayout( "fill,wrap 3", 
+			"[grow,fill][grow,fill][grow,fill]", "[][grow,fill][]" ) );
+
+		mAliasActionList.setVisibleRowCount( 6 );
+		mAliasActionList.setSelectionMode( ListSelectionModel.SINGLE_SELECTION );
+		mAliasActionList.setLayoutOrientation( JList.VERTICAL );
+		mAliasActionList.addListSelectionListener( new ListSelectionListener()
+		{
+			@Override
+			public void valueChanged( ListSelectionEvent event )
+			{
+				if( !event.getValueIsAdjusting() )
+				{
+					JList<?> list = (JList<?>)event.getSource();
+					
+					Object selectedItem = list.getSelectedValue();
+					
+					if( selectedItem != null && selectedItem instanceof AliasAction )
+					{
+						AliasAction selected = (AliasAction)selectedItem;
+
+						mEditorContainer.setAliasAction( selected );
+						
+						mCloneActionButton.setEnabled( true );
+						mDeleteActionButton.setEnabled( true );
+					}
+					else
+					{
+						mCloneActionButton.setEnabled( false );
+						mDeleteActionButton.setEnabled( false );
+					}
+				}
+			}
+		} );
+		
+		JScrollPane scroller = new JScrollPane( mAliasActionList );
+		add( scroller, "span,grow" );
+		
+		add( mEditorContainer, "span,grow" );
+
+		mNewActionButton = new JButton( "New ..." );
+		mNewActionButton.setToolTipText( "Create a new Alias Action" );
+		mNewActionButton.addMouseListener( new MouseAdapter()
+		{
+			@Override
+			public void mouseClicked( MouseEvent e )
+			{
+				JPopupMenu menu = new JPopupMenu();
+
+				menu.add( new AddAliasActionItem( AliasActionType.BEEP ) );
+				menu.add( new AddAliasActionItem( AliasActionType.CLIP ) );
+				menu.add( new AddAliasActionItem( AliasActionType.SCRIPT ) );
+				
+				menu.show( e.getComponent(), e.getX(), e.getY() );
+			}
+		} );
+		
+		add( mNewActionButton );
+		
+		mCloneActionButton = new JButton( "Clone" );
+		mCloneActionButton.setToolTipText( "Create a copy of the currently selected action" );
+		mCloneActionButton.setEnabled( false );
+		mCloneActionButton.addActionListener( new ActionListener()
+		{
+			@Override
+			public void actionPerformed( ActionEvent e )
+			{
+				AliasAction selected = mAliasActionList.getSelectedValue();
+				
+				if( selected != null )
+				{
+					AliasAction clone = AliasFactory.copyOf( selected );
+
+					if( clone != null )
+					{
+						addAliasActionToList( clone );
+					}
+				}
+			}
+		} );
+		add( mCloneActionButton );
+		
+		mDeleteActionButton = new JButton( "Delete" );
+		mDeleteActionButton.setToolTipText( "Delete the currently selected action" );
+		mDeleteActionButton.setEnabled( false );
+		mDeleteActionButton.addActionListener( new ActionListener()
+		{
+			@Override
+			public void actionPerformed( ActionEvent e )
+			{
+				final AliasAction selected = mAliasActionList.getSelectedValue();
+				
+				if( selected != null )
+				{
+					int choice = JOptionPane.showConfirmDialog( mDeleteActionButton, 
+						"Do you want to delete [" + selected.toString() + "]", 
+						"Are you sure?", JOptionPane.YES_NO_OPTION );
+					
+					if( choice == JOptionPane.YES_OPTION && hasItem() )
+					{
+						Alias alias = getItem();
+						
+						alias.removeAliasAction( selected );
+						
+						mAliasModel.broadcast( new AliasEvent( alias, Event.CHANGE ) );
+
+						setItem( alias );
+					}
+				}
+			}
+		} );
+		add( mDeleteActionButton, "wrap" );
+	}
+	
+	@Override
+	public void setItem( Alias alias )
+	{
+		super.setItem( alias );
+		
+		if( alias == null || alias.getAction().isEmpty() )
+		{
+			mAliasActionList.setModel( EMPTY_MODEL );
+		}
+		else
+		{
+			DefaultListModel<AliasAction> model = new DefaultListModel<>();
+
+			List<AliasAction> actions = alias.getAction();
+			
+			Collections.sort( actions, new Comparator<AliasAction>()
+			{
+				@Override
+				public int compare( AliasAction o1, AliasAction o2 )
+				{
+					return o1.toString().compareTo( o2.toString() );
+				}
+			} );
+			
+			for( AliasAction action: actions )
+			{
+				model.addElement( action );
+			}
+			
+			mAliasActionList.setModel( model );
+		}
+		
+		mEditorContainer.setAliasAction( null );
+	}
+	
+	@Override
+	public void save()
+	{
+		if( isModified() || mEditorContainer.isModified() )
+		{
+			if( mEditorContainer.isModified() )
+			{
+				mEditorContainer.save();
+			}
+			
+			setModified( false );
+			
+			if( hasItem() )
+			{
+				mAliasModel.broadcast( new AliasEvent( getItem(), Event.CHANGE ) );
+			}
+		}
+	}
+	
+	public class EditorContainer extends JPanel
+	{
+		private static final long serialVersionUID = 1L;
+
+		private Editor<AliasAction> mEditor = new EmptyEditor<>();
+
+		public EditorContainer()
+		{
+			setLayout( new MigLayout( "","[grow,fill]", "[grow,fill]" ) );
+
+			add( mEditor );
+		}
+		
+		public boolean isModified()
+		{
+			if( mEditor != null )
+			{
+				return mEditor.isModified();
+			}
+			
+			return false;
+		}
+		
+		public void save()
+		{
+			if( mEditor != null )
+			{
+				mEditor.save();
+			}
+		}
+		
+		public void setAliasAction( AliasAction aliasAction )
+		{
+			if( mEditor != null )
+			{
+				if( mEditor.isModified() )
+				{
+					int option = JOptionPane.showConfirmDialog( 
+							EditorContainer.this, 
+							"Action settings have changed.  Do you want to save these changes?", 
+							"Save Changes?",
+							JOptionPane.YES_NO_OPTION,
+							JOptionPane.QUESTION_MESSAGE );
+					
+					if( option == JOptionPane.YES_OPTION )
+					{
+						mEditor.save();
+					}
+				}
+			}
+			removeAll();
+			
+			//This will always give us an editor
+			mEditor = AliasFactory.getEditor( aliasAction );
+			
+			add( mEditor );
+
+			revalidate();
+		}
+	}
+	
+	private void addAliasActionToList( final AliasAction action )
+	{
+		if( action != null && hasItem() )
+		{
+			final Alias alias = getItem();
+			
+			alias.addAliasAction( action );
+			
+			EventQueue.invokeLater( new Runnable()
+			{
+				@Override
+				public void run()
+				{
+					setItem( alias );
+					
+					mAliasActionList.setSelectedValue( action, true );
+					
+					AliasActionEditor.this.setModified( true );
+				}
+			} );
+		}
+	}
+	
+	public class AddAliasActionItem extends JMenuItem
+	{
+		private static final long serialVersionUID = 1L;
+		
+		private AliasActionType mAliasActionType;
+
+		public AddAliasActionItem( AliasActionType type )
+		{
+			super( type.toString() );
+			
+			mAliasActionType = type;
+			
+			addActionListener( new ActionListener()
+			{
+				@Override
+				public void actionPerformed( ActionEvent e )
+				{
+					final AliasAction action = 
+							AliasFactory.getAliasAction( mAliasActionType );
+					
+					addAliasActionToList( action );
+				}
+			} );
+		}
+	}
+}

src/main/java/alias/action/AliasActionListener.java

@@ -0,0 +1,32 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014-2016 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 alias.action;
+
+import alias.AliasEvent;
+
+/**
+ * Interface for receiving alias events.  Each listener will receive
+ * notification of all alias events.
+ */
+public interface AliasActionListener
+{
+	/**
+	 * Notifies the listener that an alias event has occurred
+	 */
+	public void aliasChanged( AliasEvent event );
+}

src/main/java/alias/action/AliasActionManager.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 alias.action;
+
+import alias.Alias;
+import message.Message;
+import sample.Listener;
+import util.ThreadPool;
+
+import java.util.List;
+
+/**
+ * Manages all alias action events.  Each received message is interrogated for
+ * any alias entries and then each alias is interrogated for any alias actions.
+ *
+ * Each alias action is executed and provided a copy of the source message so
+ * that the contents of the message can be used as part of the action.
+ */
+public class AliasActionManager implements Listener<Message>
+{
+    public AliasActionManager()
+    {
+    }
+
+    @Override
+    public void receive(Message message)
+    {
+        if(message.isValid())
+        {
+            List<Alias> aliases = message.getAliases();
+
+            if(aliases != null)
+            {
+                for(Alias alias : aliases)
+                {
+                    if(alias.hasActions())
+                    {
+                        List<AliasAction> actions = alias.getAction();
+
+                        for(AliasAction action : actions)
+                        {
+                            /* Provide access to the thread pool manager in case the
+							 * action needs to setup a timer, and provide the original
+							 * message to be used as part of the action (e.g. sending
+							 * the message as a text message to a cell phone */
+                            action.execute(ThreadPool.SCHEDULED, alias, message);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

src/main/java/alias/action/AliasActionType.java

@@ -0,0 +1,37 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014-2016 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 alias.action;
+
+public enum AliasActionType
+{
+	BEEP( "Beep" ),
+	CLIP( "Play Clip" ),
+	SCRIPT( "Run Script" );
+	
+	private String mLabel;
+	
+	private AliasActionType( String label )
+	{
+		mLabel = label;
+	}
+	
+	public String toString()
+	{
+		return mLabel;
+	}
+}

src/main/java/alias/action/RecurringAction.java

@@ -0,0 +1,181 @@
+package alias.action;
+
+import alias.Alias;
+import message.Message;
+
+import javax.swing.*;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlTransient;
+import java.awt.*;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public abstract class RecurringAction extends AliasAction
+{
+    @XmlTransient
+    protected AtomicBoolean mRunning = new AtomicBoolean(false);
+    @XmlTransient
+    private ScheduledFuture<?> mPerpetualAction;
+    @XmlTransient
+    protected ScheduledExecutorService mScheduledExecutorService;
+
+    protected Interval mInterval = Interval.ONCE;
+    protected int mPeriod = 5;
+
+    public abstract void performAction(Alias alias, Message message);
+
+    @Override
+    public void execute(ScheduledExecutorService scheduledExecutorService, Alias alias, Message message)
+    {
+        mScheduledExecutorService = scheduledExecutorService;
+
+        if(mRunning.compareAndSet(false, true))
+        {
+            switch(mInterval)
+            {
+                case ONCE:
+                    performThreadedAction(alias, message);
+                    /* Don't reset */
+                    break;
+                case DELAYED_RESET:
+                    performThreadedAction(alias, message);
+                    mScheduledExecutorService.schedule(new ResetTask(), mPeriod, TimeUnit.SECONDS);
+                    break;
+                case UNTIL_DISMISSED:
+                    mPerpetualAction = mScheduledExecutorService.scheduleAtFixedRate(
+                        new PerformActionTask(alias, message), mPeriod, mPeriod, TimeUnit.SECONDS);
+
+                    StringBuilder sb = new StringBuilder();
+                    sb.append("<html><div width='250'>Alias [");
+                    sb.append(alias.getName());
+                    sb.append("] is active in message [");
+                    sb.append(message.toString());
+                    sb.append("]</div></html>");
+
+                    final String text = sb.toString();
+
+                    EventQueue.invokeLater(new Runnable()
+                    {
+                        @Override
+                        public void run()
+                        {
+                            JOptionPane.showMessageDialog(null, text,
+                                "Alias Alert", JOptionPane.INFORMATION_MESSAGE);
+
+                            dismiss(false);
+
+                            mScheduledExecutorService.schedule(new ResetTask(), 15, TimeUnit.SECONDS);
+                        }
+                    });
+                    break;
+                default:
+            }
+        }
+    }
+
+    /**
+     * Spawns the performAction() event into a new thread so that it doesn't
+     * delay any decoder actions.
+     */
+    private void performThreadedAction(final Alias alias, final Message message)
+    {
+        mScheduledExecutorService.schedule(new Runnable()
+        {
+            @Override
+            public void run()
+            {
+                performAction(alias, message);
+            }
+        }, 0, TimeUnit.SECONDS);
+    }
+
+    @Override
+    public void dismiss(boolean reset)
+    {
+        if(mPerpetualAction != null)
+        {
+            mPerpetualAction.cancel(true);
+
+            mPerpetualAction = null;
+        }
+
+        if(reset)
+        {
+            mRunning.set(false);
+        }
+    }
+
+    @XmlAttribute
+    public int getPeriod()
+    {
+        return mPeriod;
+    }
+
+    public void setPeriod(int period)
+    {
+        mPeriod = period;
+    }
+
+    @XmlAttribute
+    public Interval getInterval()
+    {
+        return mInterval;
+    }
+
+    public void setInterval(Interval interval)
+    {
+        mInterval = interval;
+
+        mRunning.set(false);
+    }
+
+    public enum Interval
+    {
+        ONCE("Once"),
+        DELAYED_RESET("Once, Reset After Delay"),
+        UNTIL_DISMISSED("Until Dismissed");
+
+        private String mLabel;
+
+        private Interval(String label)
+        {
+            mLabel = label;
+        }
+
+        public String toString()
+        {
+            return mLabel;
+        }
+    }
+
+    public class PerformActionTask implements Runnable
+    {
+        private Alias mAlias;
+        private Message mMessage;
+
+        public PerformActionTask(Alias alias, Message message)
+        {
+            mAlias = alias;
+            mMessage = message;
+        }
+
+        @Override
+        public void run()
+        {
+			/* Don't use the performThreadedAction() method, since this is
+			 * already running in a separate thread */
+            performAction(mAlias, mMessage);
+        }
+    }
+
+    public class ResetTask implements Runnable
+    {
+        @Override
+        public void run()
+        {
+            mRunning.set(false);
+        }
+    }
+}

src/main/java/alias/action/beep/BeepAction.java

@@ -0,0 +1,28 @@
+package alias.action.beep;
+
+import message.Message;
+import alias.Alias;
+import alias.action.AliasActionType;
+import alias.action.RecurringAction;
+
+public class BeepAction extends RecurringAction
+{
+
+	@Override
+	public AliasActionType getType()
+	{
+		return AliasActionType.BEEP;
+	}
+
+	@Override
+	public void performAction( Alias alias, Message message )
+	{
+		System.out.println( "\007" );
+	}
+
+	@Override
+	public String toString()
+	{
+		return "Beep";
+	}
+}

src/main/java/alias/action/beep/BeepActionEditor.java

@@ -0,0 +1,193 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014-2016 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 alias.action.beep;
+
+import gui.editor.DocumentListenerEditor;
+
+import java.awt.Color;
+import java.awt.Cursor;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+
+import javax.swing.JComboBox;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JSlider;
+import javax.swing.SpinnerModel;
+import javax.swing.SpinnerNumberModel;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+import net.miginfocom.swing.MigLayout;
+import alias.action.AliasAction;
+import alias.action.RecurringAction.Interval;
+
+public class BeepActionEditor extends DocumentListenerEditor<AliasAction>
+{
+    private static final long serialVersionUID = 1L;
+    
+	private static final String HELP_TEXT = 
+		"<html><h3>Beep Action</h3>"
+		+ "This action will sound a beep according to the interval<br>"
+		+ "that you select:<br><br>"
+		+ "<b>Once:</b> Beep the first time the alias is active and<br>"
+		+ "never again<br><br>"
+		+ "<b>Once, Reset After Delay:</b> Beep once and suppress<br>"
+		+ "subsequent beeps for the specified period in seconds.<br>"
+		+ "After the reset period, beep again when the alias is active.<br><br>"
+		+ "<b>Until Dismissed:</b> Beep every period seconds until you<br>"
+		+ "click OK on the dialog that appears. Alerting is suppressed<br>"
+		+ "for 15 seconds after you click OK.<br>"
+		+ "</html>";
+
+    private JComboBox<Interval> mComboInterval;
+    private JSlider mPeriodSlider;
+    private JLabel mPeriodSliderLabel;
+
+	public BeepActionEditor( AliasAction aliasAction )
+	{
+		init();
+
+		setItem( aliasAction );
+	}
+	
+	public BeepAction getBeepAction()
+	{
+		if( getItem() instanceof BeepAction )
+		{
+			return (BeepAction)getItem();
+		}
+		
+		return null;
+	}
+	
+	private void init()
+	{
+		setLayout( new MigLayout( "fill,wrap 2", "[right][left]", "[][][]" ) );
+
+		add( new JLabel( "Beep Interval:" ) );
+		
+		mComboInterval = new JComboBox<Interval>( Interval.values() );
+		mComboInterval.setToolTipText( HELP_TEXT );
+		mComboInterval.addActionListener( new ActionListener()
+		{
+			@Override
+           public void actionPerformed( ActionEvent e )
+           {
+				Interval selected = mComboInterval
+						.getItemAt( mComboInterval.getSelectedIndex() );
+				
+				if( selected != null )
+				{
+					/* Enable/disable period spinner based on selection */
+					boolean enabled = selected != Interval.ONCE;
+					
+					mPeriodSlider.setEnabled( enabled );
+					mPeriodSliderLabel.setEnabled( enabled );
+				}
+				
+				setModified( true );
+           }
+		});
+		add( mComboInterval, "wrap" );
+
+		final SpinnerModel model = new SpinnerNumberModel( 1, 1, 30, 1 );
+		model.addChangeListener( new ChangeListener() 
+		{
+			@Override
+			public void stateChanged( ChangeEvent e )
+			{
+				setModified( true );
+			}
+		} );
+		
+		mPeriodSlider = new JSlider( JSlider.HORIZONTAL, 1, 60, 1 );
+		mPeriodSlider.setMajorTickSpacing( 10 );
+		mPeriodSlider.setMinorTickSpacing( 2 );
+		mPeriodSlider.setPaintTicks( true );
+		mPeriodSlider.setLabelTable( mPeriodSlider.createStandardLabels( 10, 10 ) );
+		mPeriodSlider.setPaintLabels( true );
+		mPeriodSlider.addChangeListener( new ChangeListener()
+		{
+			@Override
+			public void stateChanged( ChangeEvent e )
+			{
+				mPeriodSliderLabel.setText( "Period: " + mPeriodSlider.getValue() );
+				setModified( true );
+			}
+		} );
+		mPeriodSlider.setToolTipText( HELP_TEXT );
+		
+		mPeriodSliderLabel = new JLabel( "Period: " + mPeriodSlider.getValue() + " " );
+		add( mPeriodSliderLabel );
+		add( mPeriodSlider, "wrap,grow" );
+		
+		JLabel help = new JLabel( "Help ..." );
+		help.setForeground( Color.BLUE.brighter() );
+		help.setCursor( new Cursor( Cursor.HAND_CURSOR ) );
+		help.addMouseListener( new MouseAdapter() 
+		{
+			@Override
+			public void mouseClicked( MouseEvent e )
+			{
+				JOptionPane.showMessageDialog( BeepActionEditor.this, 
+					HELP_TEXT, "Help", JOptionPane.INFORMATION_MESSAGE );
+			}
+		} );
+		add( help, "align left" );
+	}
+	
+	@Override
+	public void setItem( AliasAction item )
+	{
+		super.setItem( item );
+		
+		if( hasItem() )
+		{
+			BeepAction beep = getBeepAction();
+
+			Interval interval = beep.getInterval();
+			
+			mComboInterval.setSelectedItem( interval );
+
+			boolean enabled = interval != Interval.ONCE;
+			
+			mPeriodSliderLabel.setEnabled( enabled );
+			mPeriodSlider.setEnabled( enabled );
+			mPeriodSlider.setValue( beep.getPeriod() );
+		}
+		
+		setModified( false );
+	}
+
+	@Override
+	public void save()
+	{
+		if( hasItem() && isModified() )
+		{
+			BeepAction beep = getBeepAction();
+			
+			beep.setInterval( (Interval)mComboInterval.getSelectedItem() );
+			beep.setPeriod( mPeriodSlider.getValue() );
+		}
+		
+		setModified( false );
+	}
+}

src/main/java/alias/action/clip/ClipAction.java

@@ -0,0 +1,110 @@
+package alias.action.clip;
+
+import java.io.File;
+
+import javax.sound.sampled.AudioInputStream;
+import javax.sound.sampled.AudioSystem;
+import javax.sound.sampled.Clip;
+import javax.xml.bind.annotation.XmlTransient;
+
+import message.Message;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import alias.Alias;
+import alias.action.AliasActionType;
+import alias.action.RecurringAction;
+
+public class ClipAction extends RecurringAction
+{
+	private final static Logger mLog = LoggerFactory.getLogger( ClipAction.class );
+
+	private String mFilePath;
+
+	@XmlTransient
+	private Clip mClip;
+	
+	public ClipAction()
+	{
+	}
+	
+	@Override
+	public AliasActionType getType()
+	{
+		return AliasActionType.CLIP;
+	}
+
+	public String getPath()
+	{
+		return mFilePath;
+	}
+	
+	public void setPath( String path )
+	{
+		mFilePath = path;
+	}
+	
+	@Override
+	public void performAction( Alias alias, Message message )
+	{
+		try
+		{
+			play();
+		}
+		catch( Exception e )
+		{
+			mLog.error( "Couldn't play audio clip", e );
+		}
+	}
+	
+	public void play() throws Exception
+	{
+		try
+		{
+			if( mFilePath != null )
+			{
+				if( mClip == null )
+				{
+					mClip = AudioSystem.getClip();
+					
+					AudioInputStream ais = 
+							AudioSystem.getAudioInputStream( new File( mFilePath ) );
+					
+					mClip.open( ais );
+				}
+
+				if( mClip.isRunning() )
+				{
+					mClip.stop();
+				}
+				
+				mClip.setFramePosition( 0 );
+				
+				mClip.start();
+			}
+		}
+		catch( Exception e )
+		{
+			mClip = null;
+
+			mLog.error( "Error playing sound clip [" + mFilePath + "] - " + e.getMessage() );
+			
+			throw e;
+		}
+	}
+	
+
+	@Override
+	public String toString()
+	{
+		if( mFilePath == null )
+		{
+			return "Play Clip";
+		}
+		else
+		{
+			return "Play Clip: " + mFilePath;
+		}
+	}
+}

src/main/java/alias/action/clip/ClipActionEditor.java

@@ -0,0 +1,296 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014-2016 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 alias.action.clip;
+
+import gui.editor.DocumentListenerEditor;
+
+import java.awt.Color;
+import java.awt.Cursor;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.io.File;
+
+import javax.swing.JButton;
+import javax.swing.JComboBox;
+import javax.swing.JFileChooser;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JSlider;
+import javax.swing.JTextField;
+import javax.swing.SpinnerModel;
+import javax.swing.SpinnerNumberModel;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+import net.miginfocom.swing.MigLayout;
+import alias.action.AliasAction;
+import alias.action.RecurringAction.Interval;
+
+public class ClipActionEditor extends DocumentListenerEditor<AliasAction>
+{
+    private static final long serialVersionUID = 1L;
+    
+    private static final String PLEASE_SELECT_A_FILE = "Please select a file";
+	private static final String HELP_TEXT = 
+		"<html><h3>Clip Action</h3>"
+		+ "This action will play an audio clip according to the interval<br>"
+		+ "that you select:<br><br>"
+		+ "<b>Once:</b> play the first time the alias is active and<br>"
+		+ "never again<br><br>"
+		+ "<b>Once, Reset After Delay:</b> play once and suppress<br>"
+		+ "subsequent runs for the specified period in seconds.<br>"
+		+ "After the reset period, play again when the alias is active.<br><br>"
+		+ "<b>Until Dismissed:</b> play every period seconds until you<br>"
+		+ "click OK on the dialog that appears. Alerting is suppressed<br>"
+		+ "for 15 seconds after you click OK.<br>"
+		+ "</html>";
+
+    private JComboBox<Interval> mComboInterval;
+    private JSlider mPeriodSlider;
+    private JLabel mPeriodSliderLabel;
+    private JTextField mTextFilePath;
+
+	public ClipActionEditor( AliasAction aliasAction )
+	{
+		init();
+
+		setItem( aliasAction );
+	}
+	
+	public ClipAction getClipAction()
+	{
+		if( getItem() instanceof ClipAction )
+		{
+			return (ClipAction)getItem();
+		}
+		
+		return null;
+	}
+	
+	private void init()
+	{
+		setLayout( new MigLayout( "fill,wrap 2", "[right][left]", "[][][][][]" ) );
+
+		add( new JLabel( "Play Interval:" ) );
+		
+		mComboInterval = new JComboBox<Interval>( Interval.values() );
+		mComboInterval.setToolTipText( HELP_TEXT );
+		mComboInterval.addActionListener( new ActionListener()
+		{
+			@Override
+           public void actionPerformed( ActionEvent e )
+           {
+				Interval selected = mComboInterval
+						.getItemAt( mComboInterval.getSelectedIndex() );
+				
+				if( selected != null )
+				{
+					/* Enable/disable period slider based on selection */
+					boolean enabled = selected != Interval.ONCE;
+					
+					mPeriodSlider.setEnabled( enabled );
+					mPeriodSliderLabel.setEnabled( enabled );
+				}
+				
+				setModified( true );
+           }
+		});
+		add( mComboInterval );
+
+		final SpinnerModel model = new SpinnerNumberModel( 1, 1, 30, 1 );
+		model.addChangeListener( new ChangeListener() 
+		{
+			@Override
+			public void stateChanged( ChangeEvent e )
+			{
+				setModified( true );
+			}
+		} );
+		
+		mPeriodSlider = new JSlider( JSlider.HORIZONTAL, 1, 60, 1 );
+		mPeriodSlider.setMajorTickSpacing( 10 );
+		mPeriodSlider.setMinorTickSpacing( 2 );
+		mPeriodSlider.setPaintTicks( true );
+		mPeriodSlider.setLabelTable( mPeriodSlider.createStandardLabels( 10, 10 ) );
+		mPeriodSlider.setPaintLabels( true );
+		mPeriodSlider.addChangeListener( new ChangeListener()
+		{
+			@Override
+			public void stateChanged( ChangeEvent e )
+			{
+				mPeriodSliderLabel.setText( "Period: " + mPeriodSlider.getValue() );
+				setModified( true );
+			}
+		} );
+		mPeriodSlider.setToolTipText( HELP_TEXT );
+		
+		mPeriodSliderLabel = new JLabel( "Period: " + mPeriodSlider.getValue() + " " );
+		add( mPeriodSliderLabel );
+		add( mPeriodSlider, "wrap,grow" );
+		
+		mTextFilePath = new JTextField( PLEASE_SELECT_A_FILE );
+		add( mTextFilePath, "growx,span" );
+		
+		JButton fileButton = new JButton( "File" );
+		
+		fileButton.addActionListener( new ActionListener() 
+		{
+			@Override
+			public void actionPerformed( ActionEvent e )
+			{
+				final JFileChooser chooser = new JFileChooser();
+
+				int value = chooser.showOpenDialog( ClipActionEditor.this );
+
+				if( value == JFileChooser.APPROVE_OPTION )
+					{
+						File file = chooser.getSelectedFile();
+						
+						mTextFilePath.setText( file.getAbsolutePath() );
+						
+						setModified( true );
+					}
+				}
+		} );
+		
+		add( fileButton, "grow" );
+		
+		JButton testButton = new JButton( "Test" );
+		
+		testButton.addActionListener( new ActionListener()
+		{
+			@Override
+			public void actionPerformed( ActionEvent e )
+			{
+				if( hasItem() )
+				{
+					String path = mTextFilePath.getText();
+					
+					if( path == null || path.trim().isEmpty() )
+					{
+						JOptionPane.showMessageDialog( ClipActionEditor.this, 
+								"Please select an audio file", PLEASE_SELECT_A_FILE, 
+								JOptionPane.ERROR_MESSAGE );
+					}
+					else
+					{
+						if( isModified() )
+						{
+							int option = JOptionPane.showConfirmDialog( 
+								ClipActionEditor.this, 
+								"Settings have changed.  Do you want to save these changes?", 
+								"Save Changes?",
+								JOptionPane.YES_NO_OPTION,
+								JOptionPane.QUESTION_MESSAGE );
+							
+							if( option == JOptionPane.YES_OPTION )
+							{
+								save();
+							}
+						}
+
+						new Thread( new Runnable()
+						{
+							@Override
+							public void run()
+							{
+								try
+								{
+									getClipAction().play();
+								}
+								catch( Exception e1 )
+								{
+									JOptionPane.showMessageDialog( ClipActionEditor.this, 
+										"Couldn't play audio clip [" + e1.getMessage() + "]", 
+										"Error", JOptionPane.ERROR_MESSAGE );
+								}
+							}
+						}).start();
+					}
+				}
+			}
+		} );
+
+		add( testButton, "grow,wrap" );
+		
+		JLabel help = new JLabel( "Help ..." );
+		help.setForeground( Color.BLUE.brighter() );
+		help.setCursor( new Cursor( Cursor.HAND_CURSOR ) );
+		help.addMouseListener( new MouseAdapter() 
+		{
+			@Override
+			public void mouseClicked( MouseEvent e )
+			{
+				JOptionPane.showMessageDialog( ClipActionEditor.this, 
+					HELP_TEXT, "Help", JOptionPane.INFORMATION_MESSAGE );
+			}
+		} );
+		add( help, "align left" );
+	}
+	
+	@Override
+	public void setItem( AliasAction item )
+	{
+		super.setItem( item );
+		
+		if( hasItem() )
+		{
+			ClipAction clip = getClipAction();
+
+			Interval interval = clip.getInterval();
+			
+			mComboInterval.setSelectedItem( interval );
+
+			boolean enabled = interval != Interval.ONCE;
+			
+			mPeriodSliderLabel.setEnabled( enabled );
+			mPeriodSlider.setEnabled( enabled );
+			mPeriodSlider.setValue( clip.getPeriod() );
+			
+			String filepath = clip.getPath();
+			
+			if( filepath != null && !filepath.isEmpty() )
+			{
+				mTextFilePath.setText( filepath );
+			}
+			else
+			{
+				mTextFilePath.setText( PLEASE_SELECT_A_FILE );
+			}
+		}
+		
+		setModified( false );
+	}
+
+	@Override
+	public void save()
+	{
+		if( hasItem() && isModified() )
+		{
+			ClipAction script = getClipAction();
+			
+			script.setInterval( (Interval)mComboInterval.getSelectedItem() );
+			script.setPeriod( mPeriodSlider.getValue() );
+			script.setPath( mTextFilePath.getText() );
+		}
+		
+		setModified( false );
+	}
+}

src/main/java/alias/action/script/ScriptAction.java

@@ -0,0 +1,98 @@
+package alias.action.script;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+
+import message.Message;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import alias.Alias;
+import alias.action.AliasActionType;
+import alias.action.RecurringAction;
+
+public class ScriptAction extends RecurringAction
+{
+	private final static Logger mLog = LoggerFactory.getLogger( ScriptAction.class );
+
+	private String mScript;
+
+	public ScriptAction()
+	{
+	}
+	
+	@Override
+	public AliasActionType getType()
+	{
+		return AliasActionType.SCRIPT;
+	}
+
+	public String getScript()
+	{
+		return mScript;
+	}
+	
+	public void setScript( String script )
+	{
+		mScript = script;
+	}
+	
+	@Override
+	public void performAction( Alias alias, Message message )
+	{
+		try
+		{
+			play();
+		}
+		catch( Exception e )
+		{
+			mLog.error( "Couldn't execute script [" + mScript + "]", e );
+		}
+	}
+	
+	public void play() throws Exception
+	{
+		if( mScript != null )
+		{
+			ProcessBuilder pb = new ProcessBuilder( mScript );
+			
+			pb.redirectErrorStream( true );
+
+			Process p = pb.start();
+			
+			int exitCode = p.waitFor();
+			
+			BufferedReader reader = new BufferedReader( 
+					new InputStreamReader( p.getInputStream() ) );
+
+            String line = "";			
+
+            StringBuilder sb = new StringBuilder();
+            
+            while( ( line = reader.readLine() ) != null ) 
+            {
+            	sb.append(line + "\n");
+            }
+            
+            if( exitCode != 0 )
+            {
+            	throw new RuntimeException( "Exit Code: " + exitCode + 
+            			" Console:" + sb.toString() );
+            }
+		}
+	}
+	
+	@Override
+	public String toString()
+	{
+		if( mScript == null )
+		{
+			return "Run Script";
+		}
+		else
+		{
+			return "Run Script: " + mScript;
+		}
+	}
+}

src/main/java/alias/action/script/ScriptActionEditor.java

@@ -0,0 +1,292 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014-2016 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 alias.action.script;
+
+import gui.editor.DocumentListenerEditor;
+
+import java.awt.Color;
+import java.awt.Cursor;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.io.File;
+
+import javax.swing.JButton;
+import javax.swing.JComboBox;
+import javax.swing.JFileChooser;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JSlider;
+import javax.swing.JTextField;
+import javax.swing.SpinnerModel;
+import javax.swing.SpinnerNumberModel;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+import net.miginfocom.swing.MigLayout;
+import alias.action.AliasAction;
+import alias.action.RecurringAction.Interval;
+
+public class ScriptActionEditor extends DocumentListenerEditor<AliasAction>
+{
+    private static final long serialVersionUID = 1L;
+    
+    private static final String PLEASE_SELECT_A_FILE = "Please select a file";
+	private static final String HELP_TEXT = 
+		"<html><h3>Script Action</h3>"
+		+ "This action will run a script according to the interval<br>"
+		+ "that you select:<br><br>"
+		+ "<b>Once:</b> run the first time the alias is active and<br>"
+		+ "never again<br><br>"
+		+ "<b>Once, Reset After Delay:</b> run once and suppress<br>"
+		+ "subsequent runs for the specified period in seconds.<br>"
+		+ "After the reset period, run again when the alias is active.<br><br>"
+		+ "<b>Until Dismissed:</b> run every period seconds until you<br>"
+		+ "click OK on the dialog that appears. Alerting is suppressed<br>"
+		+ "for 15 seconds after you click OK.<br>"
+		+ "</html>";
+
+    private JComboBox<Interval> mComboInterval;
+    private JSlider mPeriodSlider;
+    private JLabel mPeriodSliderLabel;
+    private JTextField mTextFilePath;
+
+	public ScriptActionEditor( AliasAction aliasAction )
+	{
+		init();
+
+		setItem( aliasAction );
+	}
+	
+	public ScriptAction getScriptAction()
+	{
+		if( getItem() instanceof ScriptAction )
+		{
+			return (ScriptAction)getItem();
+		}
+		
+		return null;
+	}
+	
+	private void init()
+	{
+		setLayout( new MigLayout( "fill,wrap 2", "[right][left]", "[][][][][]" ) );
+
+		add( new JLabel( "Run Interval:" ) );
+		
+		mComboInterval = new JComboBox<Interval>( Interval.values() );
+		mComboInterval.setToolTipText( HELP_TEXT );
+		mComboInterval.addActionListener( new ActionListener()
+		{
+			@Override
+           public void actionPerformed( ActionEvent e )
+           {
+				Interval selected = mComboInterval
+						.getItemAt( mComboInterval.getSelectedIndex() );
+				
+				if( selected != null )
+				{
+					/* Enable/disable period slider based on selection */
+					boolean enabled = selected != Interval.ONCE;
+					
+					mPeriodSlider.setEnabled( enabled );
+					mPeriodSliderLabel.setEnabled( enabled );
+				}
+				
+				setModified( true );
+           }
+		});
+		add( mComboInterval );
+
+		final SpinnerModel model = new SpinnerNumberModel( 1, 1, 30, 1 );
+		model.addChangeListener( new ChangeListener() 
+		{
+			@Override
+			public void stateChanged( ChangeEvent e )
+			{
+				setModified( true );
+			}
+		} );
+		
+		mPeriodSlider = new JSlider( JSlider.HORIZONTAL, 1, 60, 1 );
+		mPeriodSlider.setMajorTickSpacing( 10 );
+		mPeriodSlider.setMinorTickSpacing( 2 );
+		mPeriodSlider.setPaintTicks( true );
+		mPeriodSlider.setLabelTable( mPeriodSlider.createStandardLabels( 10, 10 ) );
+		mPeriodSlider.setPaintLabels( true );
+		mPeriodSlider.addChangeListener( new ChangeListener()
+		{
+			@Override
+			public void stateChanged( ChangeEvent e )
+			{
+				mPeriodSliderLabel.setText( "Period: " + mPeriodSlider.getValue() );
+				setModified( true );
+			}
+		} );
+		mPeriodSlider.setToolTipText( HELP_TEXT );
+		
+		mPeriodSliderLabel = new JLabel( "Period: " + mPeriodSlider.getValue() + " " );
+		add( mPeriodSliderLabel );
+		add( mPeriodSlider, "wrap,grow" );
+		
+		mTextFilePath = new JTextField( PLEASE_SELECT_A_FILE );
+		add( mTextFilePath, "growx,span" );
+		
+		JButton fileButton = new JButton( "File" );
+		
+		fileButton.addActionListener( new ActionListener() 
+		{
+			@Override
+			public void actionPerformed( ActionEvent e )
+			{
+				final JFileChooser chooser = new JFileChooser();
+
+				int value = chooser.showOpenDialog( ScriptActionEditor.this );
+
+				if( value == JFileChooser.APPROVE_OPTION )
+					{
+						File file = chooser.getSelectedFile();
+						
+						mTextFilePath.setText( file.getAbsolutePath() );
+						
+						setModified( true );
+					}
+				}
+		} );
+		
+		add( fileButton, "grow" );
+		
+		JButton testButton = new JButton( "Test" );
+		testButton.addActionListener( new ActionListener() 
+		{
+			@Override
+			public void actionPerformed( ActionEvent actionEvent )
+			{
+				String script = mTextFilePath.getText();
+				
+				if( script == null || script.trim().isEmpty() )
+				{
+					JOptionPane.showMessageDialog( ScriptActionEditor.this, 
+							"Please select a script file", PLEASE_SELECT_A_FILE, 
+							JOptionPane.ERROR_MESSAGE );
+				}
+				else
+				{
+					if( isModified() )
+					{
+						int option = JOptionPane.showConfirmDialog( 
+							ScriptActionEditor.this, 
+							"Settings have changed.  Do you want to save these changes?", 
+							"Save Changes?",
+							JOptionPane.YES_NO_OPTION,
+							JOptionPane.QUESTION_MESSAGE );
+						
+						if( option == JOptionPane.YES_OPTION )
+						{
+							save();
+						}
+					}
+					
+					new Thread( new Runnable()
+					{
+						@Override
+						public void run()
+						{
+							try
+							{
+								getScriptAction().play();
+							}
+							catch( Exception e1 )
+							{
+								JOptionPane.showMessageDialog( ScriptActionEditor.this, 
+									e1.getMessage(), "Error", JOptionPane.ERROR_MESSAGE );
+							}
+						}
+					}).start();
+				}
+				
+			}
+		} );
+		
+		add( testButton, "grow,wrap" );
+		
+		JLabel help = new JLabel( "Help ..." );
+		help.setForeground( Color.BLUE.brighter() );
+		help.setCursor( new Cursor( Cursor.HAND_CURSOR ) );
+		help.addMouseListener( new MouseAdapter() 
+		{
+			@Override
+			public void mouseClicked( MouseEvent e )
+			{
+				JOptionPane.showMessageDialog( ScriptActionEditor.this, 
+					HELP_TEXT, "Help", JOptionPane.INFORMATION_MESSAGE );
+			}
+		} );
+		add( help, "align left" );
+	}
+	
+	@Override
+	public void setItem( AliasAction item )
+	{
+		super.setItem( item );
+		
+		if( hasItem() )
+		{
+			ScriptAction script = getScriptAction();
+
+			Interval interval = script.getInterval();
+			
+			mComboInterval.setSelectedItem( interval );
+
+			boolean enabled = interval != Interval.ONCE;
+			
+			mPeriodSliderLabel.setEnabled( enabled );
+			mPeriodSlider.setEnabled( enabled );
+			mPeriodSlider.setValue( script.getPeriod() );
+			
+			String filepath = script.getScript();
+			
+			if( filepath != null && !filepath.isEmpty() )
+			{
+				mTextFilePath.setText( filepath );
+			}
+			else
+			{
+				mTextFilePath.setText( PLEASE_SELECT_A_FILE );
+			}
+		}
+		
+		setModified( false );
+	}
+
+	@Override
+	public void save()
+	{
+		if( hasItem() && isModified() )
+		{
+			ScriptAction script = getScriptAction();
+			
+			script.setInterval( (Interval)mComboInterval.getSelectedItem() );
+			script.setPeriod( mPeriodSlider.getValue() );
+			script.setScript( mTextFilePath.getText() );
+		}
+		
+		setModified( false );
+	}
+}

src/main/java/alias/id/AliasID.java

@@ -0,0 +1,57 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014-2016 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 alias.id;
+
+import javax.xml.bind.annotation.XmlRootElement;
+import javax.xml.bind.annotation.XmlSeeAlso;
+import javax.xml.bind.annotation.XmlTransient;
+
+import alias.id.broadcast.BroadcastChannel;
+import playlist.version1.Group;
+import alias.id.esn.Esn;
+import alias.id.fleetsync.FleetsyncID;
+import alias.id.lojack.LoJackFunctionAndID;
+import alias.id.mdc.MDC1200ID;
+import alias.id.mobileID.Min;
+import alias.id.mpt1327.MPT1327ID;
+import alias.id.nonrecordable.NonRecordable;
+import alias.id.priority.Priority;
+import alias.id.siteID.SiteID;
+import alias.id.status.StatusID;
+import alias.id.talkgroup.TalkgroupID;
+import alias.id.uniqueID.UniqueID;
+
+@SuppressWarnings( "deprecation" )
+@XmlSeeAlso( {BroadcastChannel.class, Esn.class, FleetsyncID.class, Group.class, LoJackFunctionAndID.class,
+			   MDC1200ID.class, Min.class, MPT1327ID.class, NonRecordable.class,
+			   Priority.class, SiteID.class, StatusID.class, TalkgroupID.class,
+			   UniqueID.class } )
+@XmlRootElement( name = "id" )
+public abstract class AliasID
+{
+	public AliasID()
+	{
+	}
+	
+	public abstract AliasIDType getType();
+	
+	public abstract boolean matches( AliasID id );
+
+	@XmlTransient
+	public abstract boolean isValid();
+}

src/main/java/alias/id/AliasIDType.java

@@ -0,0 +1,49 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014-2016 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 alias.id;
+
+public enum AliasIDType
+{
+	ESN( "ESN" ),
+	FLEETSYNC( "Fleetsync" ),
+	LOJACK( "LoJack" ),
+	LTR_NET_UID( "LTR-Net UID" ),
+	MDC1200( "MDC-1200" ),
+	MIN( "Passport MIN" ),
+	MPT1327( "MPT-1327" ),
+	SITE( "Site" ),
+	STATUS( "Status" ),
+	TALKGROUP( "Talkgroup" ),
+
+	INVERT( "Audio Inversion" ),
+	PRIORITY( "Audio Priority" ),
+	NON_RECORDABLE( "Audio Non-Recordable" ),
+	BROADCAST_CHANNEL( "Audio Broadcast Channel" );
+	
+	private String mLabel;
+	
+	private AliasIDType( String label )
+	{
+		mLabel = label;
+	}
+	
+	public String toString()
+	{
+		return mLabel;
+	}
+}

src/main/java/alias/id/AliasIdentifierEditor.java

@@ -0,0 +1,379 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014-2016 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 alias.id;
+
+import audio.broadcast.BroadcastModel;
+import gui.editor.Editor;
+import gui.editor.EmptyEditor;
+
+import java.awt.EventQueue;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+import javax.swing.DefaultListModel;
+import javax.swing.JButton;
+import javax.swing.JList;
+import javax.swing.JMenuItem;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JPopupMenu;
+import javax.swing.JScrollPane;
+import javax.swing.ListModel;
+import javax.swing.ListSelectionModel;
+import javax.swing.event.ListSelectionEvent;
+import javax.swing.event.ListSelectionListener;
+
+import net.miginfocom.swing.MigLayout;
+import alias.Alias;
+import alias.AliasEvent;
+import alias.AliasEvent.Event;
+import alias.AliasFactory;
+import alias.AliasModel;
+
+public class AliasIdentifierEditor extends Editor<Alias>
+{
+	private static final long serialVersionUID = 1L;
+
+	private static ListModel<AliasID> EMPTY_MODEL = new DefaultListModel<>();
+	private JList<AliasID> mAliasIDList = new JList<>( EMPTY_MODEL );
+	private JButton mNewIDButton;
+	private JButton mCloneIDButton;
+	private JButton mDeleteIDButton;
+	private EditorContainer mEditorContainer = new EditorContainer();
+
+	private AliasModel mAliasModel;
+    private BroadcastModel mBroadcastModel;
+	
+	public AliasIdentifierEditor( AliasModel aliasModel, BroadcastModel broadcastModel )
+	{
+		mAliasModel = aliasModel;
+        mBroadcastModel = broadcastModel;
+
+		init();
+	}
+
+	private void init()
+	{
+		setLayout( new MigLayout( "fill,wrap 3", 
+			"[grow,fill][grow,fill][grow,fill]", "[][grow,fill][]" ) );
+
+		mAliasIDList.setVisibleRowCount( 6 );
+		mAliasIDList.setSelectionMode( ListSelectionModel.SINGLE_SELECTION );
+		mAliasIDList.setLayoutOrientation( JList.VERTICAL );
+		mAliasIDList.addListSelectionListener( new ListSelectionListener()
+		{
+			@Override
+			public void valueChanged( ListSelectionEvent event )
+			{
+				if( !event.getValueIsAdjusting() )
+				{
+					JList<?> list = (JList<?>)event.getSource();
+					
+					Object selectedItem = list.getSelectedValue();
+					
+					if( selectedItem != null && selectedItem instanceof AliasID )
+					{
+						AliasID selected = (AliasID)selectedItem;
+
+						mEditorContainer.setAliasID( selected );
+						
+						mCloneIDButton.setEnabled( true );
+						mDeleteIDButton.setEnabled( true );
+					}
+					else
+					{
+						mCloneIDButton.setEnabled( false );
+						mDeleteIDButton.setEnabled( false );
+					}
+				}
+			}
+		} );
+		
+		JScrollPane scroller = new JScrollPane( mAliasIDList );
+		add( scroller, "span,grow" );
+		
+		add( mEditorContainer, "span,grow" );
+
+		mNewIDButton = new JButton( "New ..." );
+		mNewIDButton.setToolTipText( "Create a new Alias Identifier" );
+		mNewIDButton.addMouseListener( new MouseAdapter()
+		{
+			@Override
+			public void mouseClicked( MouseEvent e )
+			{
+				JPopupMenu menu = new JPopupMenu();
+
+				menu.add( new AddAliasIdentifierItem( AliasIDType.ESN ) );
+				menu.add( new AddAliasIdentifierItem( AliasIDType.FLEETSYNC) );
+				menu.add( new AddAliasIdentifierItem( AliasIDType.LOJACK) );
+				menu.add( new AddAliasIdentifierItem( AliasIDType.LTR_NET_UID) );
+				menu.add( new AddAliasIdentifierItem( AliasIDType.MDC1200 ) );
+				menu.add( new AddAliasIdentifierItem( AliasIDType.MPT1327 ) );
+				menu.add( new AddAliasIdentifierItem( AliasIDType.MIN ) );
+				menu.add( new AddAliasIdentifierItem( AliasIDType.SITE) );
+				menu.add( new AddAliasIdentifierItem( AliasIDType.STATUS) );
+				menu.add( new AddAliasIdentifierItem( AliasIDType.TALKGROUP) );
+
+				menu.addSeparator();
+
+                menu.add( new AddAliasIdentifierItem( AliasIDType.BROADCAST_CHANNEL) );
+
+				if( hasItem() )
+				{
+					Alias alias = getItem();
+
+					if( alias.isRecordable() )
+					{
+						menu.add( new AddAliasIdentifierItem( AliasIDType.NON_RECORDABLE) );
+					}
+
+					if( !alias.hasCallPriority() )
+					{
+						menu.add( new AddAliasIdentifierItem( AliasIDType.PRIORITY) );
+					}
+				}
+
+				menu.show( e.getComponent(), e.getX(), e.getY() );
+			}
+		} );
+		
+		add( mNewIDButton );
+		
+		mCloneIDButton = new JButton( "Clone" );
+		mCloneIDButton.setToolTipText( "Create a copy of the currently selected identifier" );
+		mCloneIDButton.setEnabled( false );
+		mCloneIDButton.addActionListener( new ActionListener()
+		{
+			@Override
+			public void actionPerformed( ActionEvent e )
+			{
+				AliasID selected = mAliasIDList.getSelectedValue();
+				
+				if( selected != null )
+				{
+					AliasID clone = AliasFactory.copyOf( selected );
+
+					if( clone != null )
+					{
+						addAliasIDToList( clone );
+					}
+				}
+			}
+		} );
+		add( mCloneIDButton );
+		
+		mDeleteIDButton = new JButton( "Delete" );
+		mDeleteIDButton.setToolTipText( "Delete the currently selected identifier" );
+		mDeleteIDButton.setEnabled( false );
+		mDeleteIDButton.addActionListener( new ActionListener()
+		{
+			@Override
+			public void actionPerformed( ActionEvent e )
+			{
+				final AliasID selected = mAliasIDList.getSelectedValue();
+				
+				if( selected != null )
+				{
+					int choice = JOptionPane.showConfirmDialog( mDeleteIDButton, 
+						"Do you want to delete [" + selected.toString() + "]", 
+						"Are you sure?", JOptionPane.YES_NO_OPTION );
+					
+					if( choice == JOptionPane.YES_OPTION && hasItem() )
+					{
+						Alias alias = getItem();
+						
+						alias.removeAliasID( selected );
+						
+						mAliasModel.broadcast( new AliasEvent( alias, Event.CHANGE ) );
+
+						setItem( alias );
+					}
+				}
+			}
+		} );
+		add( mDeleteIDButton, "wrap" );
+	}
+	
+	@Override
+	public void setItem( Alias alias )
+	{
+		super.setItem( alias );
+		
+		if( alias == null || alias.getId().isEmpty() )
+		{
+			mAliasIDList.setModel( EMPTY_MODEL );
+		}
+		else
+		{
+			DefaultListModel<AliasID> model = new DefaultListModel<AliasID>();
+
+			List<AliasID> ids = alias.getId();
+			
+			Collections.sort( ids, new Comparator<AliasID>()
+			{
+				@Override
+				public int compare( AliasID o1, AliasID o2 )
+				{
+					return o1.toString().compareTo( o2.toString() );
+				}
+			} );
+			
+			for( AliasID id: ids )
+			{
+				model.addElement( id );
+			}
+			
+			mAliasIDList.setModel( model );
+		}
+		
+		mEditorContainer.setAliasID( null );
+	}
+	
+	@Override
+	public void save()
+	{
+		if( isModified() || mEditorContainer.isModified() )
+		{
+			if( mEditorContainer.isModified() )
+			{
+				mEditorContainer.save();
+			}
+			
+			setModified( false );
+			
+			if( hasItem() )
+			{
+				mAliasModel.broadcast( new AliasEvent( getItem(), Event.CHANGE ) );
+			}
+		}
+	}
+	
+	public class EditorContainer extends JPanel
+	{
+		private static final long serialVersionUID = 1L;
+
+		private Editor<AliasID> mEditor = new EmptyEditor<>();
+
+		public EditorContainer()
+		{
+			setLayout( new MigLayout( "","[grow,fill]", "[grow,fill]" ) );
+
+			add( mEditor );
+		}
+		
+		public boolean isModified()
+		{
+			if( mEditor != null )
+			{
+				return mEditor.isModified();
+			}
+			
+			return false;
+		}
+		
+		public void save()
+		{
+			if( mEditor != null )
+			{
+				mEditor.save();
+			}
+		}
+		
+		public void setAliasID( AliasID aliasID )
+		{
+			if( mEditor != null )
+			{
+				if( mEditor.isModified() )
+				{
+					int option = JOptionPane.showConfirmDialog( 
+							EditorContainer.this, 
+							"Identifier settings have changed.  Do you want to save these changes?", 
+							"Save Changes?",
+							JOptionPane.YES_NO_OPTION,
+							JOptionPane.QUESTION_MESSAGE );
+					
+					if( option == JOptionPane.YES_OPTION )
+					{
+						mEditor.save();
+					}
+				}
+			}
+			removeAll();
+			
+			//This will always give us an editor
+			mEditor = AliasFactory.getEditor( aliasID, mBroadcastModel );
+			
+			add( mEditor );
+
+			revalidate();
+		}
+	}
+	
+	private void addAliasIDToList( final AliasID id )
+	{
+		if( id != null && hasItem() )
+		{
+			final Alias alias = getItem();
+			
+			alias.addAliasID( id );
+			
+			EventQueue.invokeLater( new Runnable()
+			{
+				@Override
+				public void run()
+				{
+					setItem( alias );
+					
+					mAliasIDList.setSelectedValue( id, true );
+					
+					AliasIdentifierEditor.this.setModified( true );
+				}
+			} );
+		}
+	}
+	
+	public class AddAliasIdentifierItem extends JMenuItem
+	{
+		private static final long serialVersionUID = 1L;
+		
+		private AliasIDType mAliasIDType;
+
+		public AddAliasIdentifierItem( AliasIDType type )
+		{
+			super( type.toString() );
+			
+			mAliasIDType = type;
+			
+			addActionListener( new ActionListener()
+			{
+				@Override
+				public void actionPerformed( ActionEvent e )
+				{
+					final AliasID id = AliasFactory.getAliasID( mAliasIDType );
+					
+					addAliasIDToList( id );
+				}
+			} );
+		}
+	}
+}

src/main/java/alias/id/WildcardID.java

@@ -0,0 +1,113 @@
+/*******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2016 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 alias.id;
+
+import org.apache.commons.lang3.Validate;
+
+import java.util.regex.Pattern;
+
+public class WildcardID implements Comparable<WildcardID>
+{
+    public static final String WILDCARD = "*";
+    public static final String REGEX_WILDCARD = ".";
+
+    private String mValue;
+    private Pattern mPattern;
+    private int mWeight;
+
+    /**
+     * Wildcard identifier for matching to string identifiers containing single-character (*) wildcard values.
+     *
+     * Supports ordering from most-specific to least-specific using the build-in weighting calculation where identifier
+     * patterns containing fewer wildcards closer to the least significant digit will be weighted more heavily than
+     * identifier patterns containing more wildcards, or wildcard characters in the most significant digits.
+     *
+     * @param value is a string value containing one or more asterisk (*) single character wildcard with a maximum
+     * length of 10 characters.
+     *
+     * @throws AssertionError if the value is null, longer than 10 characters, or doesn't contain at least 1 asterisk
+     * @throws IllegalArgumentException if the value cannot be compiled as a regular expression after converting the
+     * asterisk characters to the regex single-character wildcard value (.)
+     */
+    public WildcardID(String value)
+    {
+        Validate.isTrue(value != null && value.contains(WILDCARD) && value.length() < 10);
+
+        mValue = value;
+
+        try
+        {
+            mPattern = Pattern.compile(value.replace(WILDCARD, REGEX_WILDCARD));
+        }
+        catch(Exception e)
+        {
+            throw new IllegalArgumentException("Invalid regex pattern for alias ID value [" + value + "]", e);
+        }
+
+        mWeight = calculateWeight();
+    }
+
+    public String value()
+    {
+        return mValue;
+    }
+
+    /**
+     * Indicates if the id matches the internal regex pattern for this wildcard alias ID
+     * @param id
+     * @return
+     */
+    public boolean matches(String id)
+    {
+        return id != null && mPattern.matcher(id).matches();
+    }
+
+    public int weight()
+    {
+        return mWeight;
+    }
+
+    /**
+     * Calculates a weighting value for wildcard character quantity and significant digit location
+     */
+    private int calculateWeight()
+    {
+        int weight = 0;
+        int characterCount = -1;
+
+        for( int x = 0; x < mValue.length(); x++)
+        {
+            if(mValue.substring(x, x + 1).equals(WILDCARD))
+            {
+                weight += (int)(Math.pow(2, mValue.length() - x - 1));         //Position weight
+                characterCount++;
+            }
+        }
+
+        weight += (int)(Math.pow(2, characterCount)) * 1000; //Character count weight
+
+        return weight;
+    }
+
+    @Override
+    public int compareTo(WildcardID otherWildcardID)
+    {
+        return Integer.compare(this.weight(), otherWildcardID.weight());
+    }
+}

src/main/java/alias/id/broadcast/BroadcastChannel.java

@@ -0,0 +1,130 @@
+/*******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2016 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 alias.id.broadcast;
+
+import alias.id.AliasID;
+import alias.id.AliasIDType;
+
+import javax.xml.bind.annotation.XmlAttribute;
+
+public class BroadcastChannel extends AliasID implements Comparable<BroadcastChannel>
+{
+    private String mChannelName;
+
+    public BroadcastChannel()
+    {
+        //JAXB Constructor
+    }
+
+    @Override
+    public int compareTo(BroadcastChannel other)
+    {
+        if(mChannelName != null && other.getChannelName() != null)
+        {
+            return mChannelName.compareTo(other.getChannelName());
+        }
+        else if(mChannelName != null)
+        {
+            return -1;
+        }
+        else
+        {
+            return 1;
+        }
+    }
+
+    @Override
+    public boolean equals(Object o)
+    {
+        if(this == o)
+        {
+            return true;
+        }
+        if(!(o instanceof BroadcastChannel))
+        {
+            return false;
+        }
+
+        BroadcastChannel that = (BroadcastChannel)o;
+
+        return getChannelName() != null ? getChannelName().equals(that.getChannelName()) : that.getChannelName() == null;
+    }
+
+    @Override
+    public int hashCode()
+    {
+        return getChannelName() != null ? getChannelName().hashCode() : 0;
+    }
+
+    /**
+     * Creates a named broadcast channel
+     */
+    public BroadcastChannel(String channelName)
+    {
+        mChannelName = channelName;
+    }
+
+    /**
+     * Name of the broadcastAudio channel configuration
+     */
+    @XmlAttribute(name = "channel")
+    public String getChannelName()
+    {
+        return mChannelName;
+    }
+
+    /**
+     * Sets the name of the broadcastAudio channel configuration
+     */
+    public void setChannelName(String channel)
+    {
+        mChannelName = channel;
+    }
+
+    @Override
+    public AliasIDType getType()
+    {
+        return AliasIDType.BROADCAST_CHANNEL;
+    }
+
+    @Override
+    public boolean isValid()
+    {
+        return mChannelName != null;
+    }
+
+    @Override
+    public boolean matches(AliasID id)
+    {
+        return false;
+    }
+
+    @Override
+    public String toString()
+    {
+        if(isValid())
+        {
+            return "Broadcast Channel: " + mChannelName;
+        }
+        else
+        {
+            return "Broadcast Channel: None Selected";
+        }
+    }
+}

src/main/java/alias/id/broadcast/BroadcastChannelEditor.java

@@ -0,0 +1,129 @@
+/*******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2016 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 alias.id.broadcast;
+
+import alias.id.AliasID;
+import audio.broadcast.BroadcastConfiguration;
+import audio.broadcast.BroadcastModel;
+import gui.editor.DocumentListenerEditor;
+import net.miginfocom.swing.MigLayout;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.util.List;
+
+public class BroadcastChannelEditor extends DocumentListenerEditor<AliasID>
+{
+    private static final long serialVersionUID = 1L;
+
+    private static final String HELP_TEXT = "<html>"
+    		+ "<h3>Audio Broadcast Channel</h3>"
+    		+ "Name of a audio streaming broadcast configuration<br>"
+			+ "to be used for streaming audio to an external<br>"
+			+ "streaming server";
+
+	private JComboBox<String> mBroadcastConfigurations;
+	private BroadcastModel mBroadcastModel;
+
+	public BroadcastChannelEditor(AliasID aliasID, BroadcastModel broadcastModel)
+	{
+		mBroadcastModel = broadcastModel;
+
+		initGUI();
+		setItem( aliasID );
+	}
+	
+	private void initGUI()
+	{
+		setLayout( new MigLayout( "fill,wrap 1", "[]", "[][]" ) );
+
+		add( new JLabel( "Broadcast Channel" ), "grow" );
+
+		List<String> channelNames = mBroadcastModel.getBroadcastConfigurationNames();
+
+		mBroadcastConfigurations = new JComboBox<String>(channelNames.toArray(new String[channelNames.size()]));
+		mBroadcastConfigurations.addActionListener(new ActionListener()
+		{
+			@Override
+			public void actionPerformed(ActionEvent e)
+			{
+				setModified(true);
+			}
+		});
+
+        add(mBroadcastConfigurations, "grow");
+
+		JLabel help = new JLabel( "Help ..." );
+		help.setForeground( Color.BLUE.brighter() );
+		help.setCursor( new Cursor( Cursor.HAND_CURSOR ) );
+		help.addMouseListener( new MouseAdapter() 
+		{
+			@Override
+			public void mouseClicked( MouseEvent e )
+			{
+				JOptionPane.showMessageDialog( BroadcastChannelEditor.this,
+					HELP_TEXT, "Help", JOptionPane.INFORMATION_MESSAGE );
+			}
+		} );
+
+		add( help, "align left" );
+	}
+
+	@Override
+	public void setItem(AliasID item)
+	{
+		super.setItem(item);
+
+		if(item instanceof BroadcastChannel)
+		{
+            BroadcastChannel channel = (BroadcastChannel)item;
+
+            if(channel.isValid())
+            {
+                mBroadcastConfigurations.setSelectedItem(channel.getChannelName());
+            }
+		}
+
+		setModified(false);
+	}
+
+	@Override
+	public void save()
+	{
+        String channel = (String)mBroadcastConfigurations.getSelectedItem();
+
+        BroadcastConfiguration selectedConfiguration = mBroadcastModel.getBroadcastConfiguration(channel);
+
+
+		if(selectedConfiguration != null)
+		{
+			((BroadcastChannel)getItem()).setChannelName(selectedConfiguration.getName());
+		}
+		else
+		{
+			((BroadcastChannel)getItem()).setChannelName(null);
+		}
+	}
+
+
+}

src/main/java/alias/id/esn/ESNEditor.java

@@ -0,0 +1,118 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014-2016 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 alias.id.esn;
+
+import gui.editor.DocumentListenerEditor;
+
+import java.awt.Color;
+import java.awt.Cursor;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JTextField;
+
+import net.miginfocom.swing.MigLayout;
+import alias.id.AliasID;
+
+public class ESNEditor extends DocumentListenerEditor<AliasID>
+{
+    private static final long serialVersionUID = 1L;
+
+    private static final String HELP_TEXT = 
+    		"<html><h3>Electronic Serial Number (ESN)</h3>"
+    		+ "<b>ESN:</b> hexadecimal 0-9, A-F (e.g. <u>ABCD1234</u> )<br>"
+    		+ "<b>Wildcard:</b> use an asterisk (*) to wildcard individual<br>"
+    		+ "digits (e.g. <u>ABCD123*</u> or <u>AB**1**4</u>)"
+    		+ "</html>";
+
+    private JTextField mTextField;
+
+	public ESNEditor( AliasID aliasID )
+	{
+		initGUI();
+		
+		setItem( aliasID );
+	}
+	
+	private void initGUI()
+	{
+		setLayout( new MigLayout( "fill,wrap 2", "[right][left]", "[][]" ) );
+
+		add( new JLabel( "ESN:" ) );
+		mTextField = new JTextField();
+		mTextField.getDocument().addDocumentListener( this );
+		mTextField.setToolTipText( HELP_TEXT );
+		add( mTextField, "growx,push" );
+
+		JLabel help = new JLabel( "Help ..." );
+		help.setForeground( Color.BLUE.brighter() );
+		help.setCursor( new Cursor( Cursor.HAND_CURSOR ) );
+		help.addMouseListener( new MouseAdapter() 
+		{
+			@Override
+			public void mouseClicked( MouseEvent e )
+			{
+				JOptionPane.showMessageDialog( ESNEditor.this, 
+					HELP_TEXT, "Help", JOptionPane.INFORMATION_MESSAGE );
+			}
+		} );
+		add( help, "align left" );
+	}
+	
+	public Esn getEsn()
+	{
+		if( getItem() instanceof Esn )
+		{
+			return (Esn)getItem();
+		}
+		
+		return null;
+	}
+
+	@Override
+	public void setItem( AliasID aliasID )
+	{
+		super.setItem( aliasID );
+		
+		Esn esn = getEsn();
+		
+		if( esn != null )
+		{
+			mTextField.setText( esn.getEsn() );
+		}
+		
+		setModified( false );
+		
+		repaint();
+	}
+
+	@Override
+	public void save()
+	{
+		Esn esn = getEsn();
+		
+		if( esn != null )
+		{
+			esn.setEsn( mTextField.getText() );
+		}
+		
+		setModified( false );
+	}
+}

src/main/java/alias/id/esn/Esn.java

@@ -0,0 +1,78 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014 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 alias.id.esn;
+
+import javax.xml.bind.annotation.XmlAttribute;
+
+import alias.id.AliasID;
+import alias.id.AliasIDType;
+
+public class Esn extends AliasID
+{
+	private String mEsn;
+	
+	public Esn()
+	{
+	}
+
+	@XmlAttribute
+	public String getEsn()
+	{
+		return mEsn;
+	}
+
+	@Override
+	public boolean isValid()
+	{
+		return mEsn != null;
+	}
+
+	public void setEsn(String esn )
+	{
+		mEsn = esn;
+	}
+	
+	public String toString()
+	{
+		return "ESN: " + mEsn;
+	}
+
+	@Override
+    public boolean matches( AliasID id )
+    {
+		boolean retVal = false;
+		
+		if( mEsn != null && id instanceof Esn )
+		{
+			Esn esn = (Esn)id;
+
+			//Create a pattern - replace * wildcards with regex single-char wildcard
+			String pattern = mEsn.replace( "*", ".?" );
+			
+			retVal = esn.getEsn().matches( pattern );
+		}
+		
+	    return retVal;
+    }
+
+	@Override
+    public AliasIDType getType()
+    {
+	    return AliasIDType.ESN;
+    }
+}

src/main/java/alias/id/fleetsync/FleetsyncID.java

@@ -0,0 +1,79 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014 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 alias.id.fleetsync;
+
+import javax.xml.bind.annotation.XmlAttribute;
+
+import alias.id.AliasID;
+import alias.id.AliasIDType;
+
+
+public class FleetsyncID extends AliasID
+{
+	private String mID;
+	
+	public FleetsyncID()
+	{
+	}
+
+	@XmlAttribute
+	public String getIdent()
+	{
+		return mID;
+	}
+
+	public void setIdent( String ident )
+	{
+		mID = ident;
+	}
+
+	@Override
+	public boolean isValid()
+	{
+		return mID != null;
+	}
+
+	public String toString()
+	{
+		return "Fleetsync: " + mID;
+	}
+
+	@Override
+    public boolean matches( AliasID id )
+    {
+		boolean retVal = false;
+		
+		if( mID != null && id instanceof FleetsyncID )
+		{
+			FleetsyncID tgid = (FleetsyncID)id;
+
+			//Create a pattern - replace * wildcards with regex single-char wildcard
+			String pattern = mID.replace( "*", ".?" );
+			
+			retVal = tgid.getIdent().matches( pattern );
+		}
+		
+	    return retVal;
+    }
+
+	@Override
+    public AliasIDType getType()
+    {
+	    return AliasIDType.FLEETSYNC;
+    }
+}

src/main/java/alias/id/fleetsync/FleetsyncIDEditor.java

@@ -0,0 +1,139 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014-2016 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 alias.id.fleetsync;
+
+import gui.editor.DocumentListenerEditor;
+
+import java.awt.Color;
+import java.awt.Cursor;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+
+import javax.swing.JFormattedTextField;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JTextField;
+import javax.swing.text.MaskFormatter;
+
+import net.miginfocom.swing.MigLayout;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import alias.id.AliasID;
+
+public class FleetsyncIDEditor extends DocumentListenerEditor<AliasID>
+{
+	private final static Logger mLog = LoggerFactory.getLogger( FleetsyncIDEditor.class );
+
+	private static final long serialVersionUID = 1L;
+
+    private static final String HELP_TEXT = "<html>"
+    		+ "<h3>Fleetsync Identifier</h3>"
+    		+ "<b>Fleetsync:</b> ggg-uuuu where g=Group and u=Unit (e.g. <u>001-0001</u>)<br>"
+    		+ "<b>Wildcard:</b> use an asterisk (*) for each digit (e.g. <u>001-****</u>)"
+    		+ "</html>";
+
+    private JTextField mTextField;
+
+	public FleetsyncIDEditor( AliasID aliasID )
+	{
+		initGUI();
+		
+		setItem( aliasID );
+	}
+	
+	private void initGUI()
+	{
+		setLayout( new MigLayout( "fill,wrap 2", "[right][left]", "[][]" ) );
+
+		add( new JLabel( "Fleetsync ID:" ) );
+
+		MaskFormatter formatter = null;
+
+		try
+		{
+			//Mask: 3 digits - 4 digits
+			formatter = new MaskFormatter( "###-####" );
+		}
+		catch( Exception e )
+		{
+			//Do nothing, the mask was invalid
+		}
+		
+		mTextField = new JFormattedTextField( formatter );
+		mTextField.getDocument().addDocumentListener( this );
+		mTextField.setToolTipText( HELP_TEXT );
+
+		add( mTextField, "growx,push" );
+		
+		JLabel help = new JLabel( "Help ..." );
+		help.setForeground( Color.BLUE.brighter() );
+		help.setCursor( new Cursor( Cursor.HAND_CURSOR ) );
+		help.addMouseListener( new MouseAdapter() 
+		{
+			@Override
+			public void mouseClicked( MouseEvent e )
+			{
+				JOptionPane.showMessageDialog( FleetsyncIDEditor.this, 
+					HELP_TEXT, "Help", JOptionPane.INFORMATION_MESSAGE );
+			}
+		} );
+		add( help, "align left" );
+	}
+	
+	public FleetsyncID getFleetsyncID()
+	{
+		if( getItem() instanceof FleetsyncID )
+		{
+			return (FleetsyncID)getItem();
+		}
+		
+		return null;
+	}
+
+	@Override
+	public void setItem( AliasID aliasID )
+	{
+		super.setItem( aliasID );
+		
+		FleetsyncID fleetsync = getFleetsyncID();
+		
+		if( fleetsync != null )
+		{
+			mTextField.setText( fleetsync.getIdent() );
+		}
+		
+		setModified( false );
+		
+		repaint();
+	}
+
+	@Override
+	public void save()
+	{
+		FleetsyncID fleetsync = getFleetsyncID();
+		
+		if( fleetsync != null )
+		{
+			fleetsync.setIdent( mTextField.getText() );
+		}
+		
+		setModified( false );
+	}
+}

src/main/java/alias/id/lojack/LoJackFunctionAndID.java

@@ -0,0 +1,138 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2015 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 alias.id.lojack;
+
+import javax.xml.bind.annotation.XmlAttribute;
+
+import module.decode.lj1200.LJ1200Message;
+import module.decode.lj1200.LJ1200Message.Function;
+import alias.id.AliasID;
+import alias.id.AliasIDType;
+
+public class LoJackFunctionAndID extends AliasID
+{
+	private LJ1200Message.Function mFunction = Function.F0_UNKNOWN;
+	private String mID = "*****";
+	
+	public LoJackFunctionAndID()
+	{
+	}
+
+	@XmlAttribute( name="id" )
+	public String getID()
+	{
+		return mID;
+	}
+
+	public void setID( String id )
+	{
+		mID = id;
+	}
+
+	@XmlAttribute( name="function" )
+	public Function getFunction()
+	{
+		return mFunction;
+	}
+
+	public void setFunction( Function function )
+	{
+		mFunction = function;
+	}
+
+	@Override
+	public boolean isValid()
+	{
+		return mFunction != null && mID != null;
+	}
+
+	public String toString()
+	{
+		return "LoJack FUNC: " + mFunction.getLabel() + " ID:" + ( mID == null ? "" : mID );
+	}
+
+	/**
+	 * Indicates if the function and id combination match this alias id
+	 */
+	public boolean matches( Function function, String id )
+	{
+		return mFunction == function &&
+			   mID != null && 
+			   id != null &&
+			   id.matches( mID.replace( "*", ".?" ) );
+	}
+
+	@Override
+    public boolean matches( AliasID id )
+    {
+		boolean retVal = false;
+		
+		if( mID != null && id instanceof LoJackFunctionAndID )
+		{
+			LoJackFunctionAndID otherLojack = (LoJackFunctionAndID)id;
+
+			if( otherLojack.getFunction() == mFunction )
+			{
+				//Create a pattern - replace * wildcards with regex single-char wildcard
+				String pattern = mID.replace( "*", ".?" );
+				
+				retVal = otherLojack.getID().matches( pattern );
+			}
+		}
+		
+	    return retVal;
+    }
+
+	@Override
+    public AliasIDType getType()
+    {
+	    return AliasIDType.LOJACK;
+    }
+	
+	@Override
+	public int hashCode()
+	{
+		final int prime = 31;
+		int result = 1;
+		result = prime * result
+				+ ( ( mFunction == null ) ? 0 : mFunction.hashCode() );
+		result = prime * result + ( ( mID == null ) ? 0 : mID.hashCode() );
+		return result;
+	}
+
+	@Override
+	public boolean equals( Object obj )
+	{
+		if ( this == obj )
+			return true;
+		if ( obj == null )
+			return false;
+		if ( getClass() != obj.getClass() )
+			return false;
+		LoJackFunctionAndID other = (LoJackFunctionAndID) obj;
+		if ( mFunction != other.mFunction )
+			return false;
+		if ( mID == null )
+		{
+			if ( other.mID != null )
+				return false;
+		} else if ( !mID.equals( other.mID ) )
+			return false;
+		return true;
+	}
+}

src/main/java/alias/id/lojack/LoJackIDEditor.java

@@ -0,0 +1,167 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014-2016 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 alias.id.lojack;
+
+import gui.editor.DocumentListenerEditor;
+
+import java.awt.Color;
+import java.awt.Cursor;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+
+import javax.swing.JComboBox;
+import javax.swing.JFormattedTextField;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JTextField;
+import javax.swing.text.MaskFormatter;
+
+import module.decode.lj1200.LJ1200Message;
+import module.decode.lj1200.LJ1200Message.Function;
+import net.miginfocom.swing.MigLayout;
+import alias.id.AliasID;
+
+public class LoJackIDEditor extends DocumentListenerEditor<AliasID>
+{
+    private static final long serialVersionUID = 1L;
+    
+    private JTextField mTextField;
+    
+    private JComboBox<LJ1200Message.Function> mFunctionCombo;
+
+    private static final String HELP_TEXT = "<html>"
+    		+ "<h3>LoJack Function and Identifier</h3>"
+    		+ "<b>Function Code:</b> <u>1Y-SITE ID</u><br>"
+    		+ "<b>ID:</b> 5 numbers or characters (e.g. <u>1BN47</u>)<br>"
+            + "<br>"
+            + "<b>Wildcard:</b> use an asterisk (*) to wildcard ID<br>"
+            + "characters (e.g. <u>AB*CD</u> or <u>***12</u> or <u>*****</u>)<br><br>"
+            + "The middle character in a reply ID code identifies the<br>"
+            + "entity.  Valid ID middle characters are:<br>"
+            + "<li><b>Tower:</b> X,Y</li>"
+            + "<li><b>Transponder:</b> 0-9,A,C-H,J-N,P-W</li>"
+            + "<li><b>Not Used:</b> B,I,O,Z</li>"
+    		+ "</html>";
+
+    public LoJackIDEditor( AliasID aliasID )
+	{
+		initGUI();
+		
+		setItem( aliasID );
+	}
+	
+	private void initGUI()
+	{
+		setLayout( new MigLayout( "fill,wrap 2", "[right][left]", "[][][]" ) );
+
+		add( new JLabel( "Function:" ) );
+		mFunctionCombo = new JComboBox<LJ1200Message.Function>( Function.values() );
+		mFunctionCombo.addActionListener( new ActionListener()
+		{
+			@Override
+			public void actionPerformed( ActionEvent e )
+			{
+				setModified( true );
+			}
+		} );
+		mFunctionCombo.setToolTipText( HELP_TEXT );
+		add( mFunctionCombo, "growx, push" );
+		
+		add( new JLabel( "ID:" ) );
+		
+		MaskFormatter formatter = null;
+
+		try
+		{
+			//Mask: any character or number, 5 places
+			formatter = new MaskFormatter( "AAAAA" );
+		}
+		catch( Exception e )
+		{
+			//Do nothing, the mask was invalid
+		}
+		
+		mTextField = new JFormattedTextField( formatter );
+		mTextField.getDocument().addDocumentListener( this );
+		mTextField.setToolTipText( HELP_TEXT );
+		add( mTextField, "growx,push" );
+		
+		JLabel help = new JLabel( "Help ..." );
+		help.setForeground( Color.BLUE.brighter() );
+		help.setCursor( new Cursor( Cursor.HAND_CURSOR ) );
+		help.addMouseListener( new MouseAdapter() 
+		{
+			@Override
+			public void mouseClicked( MouseEvent e )
+			{
+				JOptionPane.showMessageDialog( LoJackIDEditor.this, 
+					HELP_TEXT, "Help", JOptionPane.INFORMATION_MESSAGE );
+			}
+		} );
+		add( help, "align left" );
+	}
+	
+	public LoJackFunctionAndID getLoJackID()
+	{
+		if( getItem() instanceof LoJackFunctionAndID )
+		{
+			return (LoJackFunctionAndID)getItem();
+		}
+		
+		return null;
+	}
+
+	@Override
+	public void setItem( AliasID aliasID )
+	{
+		super.setItem( aliasID );
+		
+		LoJackFunctionAndID lojack = getLoJackID();
+		
+		if( lojack != null )
+		{
+			mFunctionCombo.setSelectedItem( lojack.getFunction() );
+			mTextField.setText( lojack.getID() );
+		}
+		else
+		{
+			mFunctionCombo.setSelectedItem( null );
+			mTextField.setText( null );
+		}
+		
+		setModified( false );
+		
+		repaint();
+	}
+
+	@Override
+	public void save()
+	{
+		LoJackFunctionAndID lojack = getLoJackID();
+		
+		if( lojack != null )
+		{
+			lojack.setID( mTextField.getText() );
+			lojack.setFunction( (Function)mFunctionCombo.getSelectedItem() );
+		}
+		
+		setModified( false );
+	}
+}

src/main/java/alias/id/mdc/MDC1200ID.java

@@ -0,0 +1,79 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014 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 alias.id.mdc;
+
+import javax.xml.bind.annotation.XmlAttribute;
+
+import alias.id.AliasID;
+import alias.id.AliasIDType;
+
+
+public class MDC1200ID extends AliasID
+{
+	private String mID;
+	
+	public MDC1200ID()
+	{
+	}
+
+	@XmlAttribute
+	public String getIdent()
+	{
+		return mID;
+	}
+
+	public void setIdent( String ident )
+	{
+		mID = ident;
+	}
+
+	@Override
+	public boolean isValid()
+	{
+		return mID != null;
+	}
+
+	public String toString()
+	{
+		return "MDC-1200: " + mID;
+	}
+
+	@Override
+    public boolean matches( AliasID id )
+    {
+		boolean retVal = false;
+		
+		if( mID != null && id instanceof MDC1200ID )
+		{
+			MDC1200ID tgid = (MDC1200ID)id;
+
+			//Create a pattern - replace * wildcards with regex single-char wildcard
+			String pattern = mID.replace( "*", ".?" );
+			
+			retVal = tgid.getIdent().matches( pattern );
+		}
+		
+	    return retVal;
+    }
+
+	@Override
+    public AliasIDType getType()
+    {
+	    return AliasIDType.MDC1200;
+    }
+}

src/main/java/alias/id/mdc/MDC1200IDEditor.java

@@ -0,0 +1,133 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014-2016 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 alias.id.mdc;
+
+import gui.editor.DocumentListenerEditor;
+
+import java.awt.Color;
+import java.awt.Cursor;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+
+import javax.swing.JFormattedTextField;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JTextField;
+import javax.swing.text.MaskFormatter;
+
+import net.miginfocom.swing.MigLayout;
+import alias.id.AliasID;
+
+public class MDC1200IDEditor extends DocumentListenerEditor<AliasID>
+{
+    private static final long serialVersionUID = 1L;
+
+    private static final String HELP_TEXT = "<html>"
+    		+ "<h3>MDC-1200 Identifier</h3>"
+    		+ "<b>MDC-1200:</b> four digit [0-9] value (e.g. <u>1234</u>)<br>"
+    		+ "<b>Wildcard:</b> use an asterisk (*) to wildcard individual<br>" 
+    		+ "digits (e.g. <u>123*</u> or <u>**34</u>)"
+    		+ "</html>";
+
+    private JTextField mTextField;
+
+	public MDC1200IDEditor( AliasID aliasID )
+	{
+		initGUI();
+		
+		setItem( aliasID );
+	}
+	
+	private void initGUI()
+	{
+		setLayout( new MigLayout( "fill,wrap 2", "[right][left]", "[][]" ) );
+
+		add( new JLabel( "MDC-1200 ID:" ) );
+
+		MaskFormatter formatter = null;
+
+		try
+		{
+			//Mask: 4 digits
+			formatter = new MaskFormatter( "####" );
+		}
+		catch( Exception e )
+		{
+			//Do nothing, the mask was invalid
+		}
+		
+		mTextField = new JFormattedTextField( formatter );
+		mTextField.getDocument().addDocumentListener( this );
+		mTextField.setToolTipText( HELP_TEXT );
+		add( mTextField, "growx,push" );
+		
+		JLabel help = new JLabel( "Help ..." );
+		help.setForeground( Color.BLUE.brighter() );
+		help.setCursor( new Cursor( Cursor.HAND_CURSOR ) );
+		help.addMouseListener( new MouseAdapter() 
+		{
+			@Override
+			public void mouseClicked( MouseEvent e )
+			{
+				JOptionPane.showMessageDialog( MDC1200IDEditor.this, 
+					HELP_TEXT, "Help", JOptionPane.INFORMATION_MESSAGE );
+			}
+		} );
+		add( help, "align left" );
+	}
+	
+	public MDC1200ID getMDC1200ID()
+	{
+		if( getItem() instanceof MDC1200ID )
+		{
+			return (MDC1200ID)getItem();
+		}
+		
+		return null;
+	}
+
+	@Override
+	public void setItem( AliasID aliasID )
+	{
+		super.setItem( aliasID );
+		
+		MDC1200ID mdc = getMDC1200ID();
+		
+		if( mdc != null )
+		{
+			mTextField.setText( mdc.getIdent() );
+		}
+		
+		setModified( false );
+		
+		repaint();
+	}
+
+	@Override
+	public void save()
+	{
+		MDC1200ID mdc = getMDC1200ID();
+		
+		if( mdc != null )
+		{
+			mdc.setIdent( mTextField.getText() );
+		}
+		
+		setModified( false );
+	}
+}

src/main/java/alias/id/mobileID/MINEditor.java

@@ -0,0 +1,133 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014-2016 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 alias.id.mobileID;
+
+import gui.editor.DocumentListenerEditor;
+
+import java.awt.Color;
+import java.awt.Cursor;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+
+import javax.swing.JFormattedTextField;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JTextField;
+import javax.swing.text.MaskFormatter;
+
+import net.miginfocom.swing.MigLayout;
+import alias.id.AliasID;
+
+public class MINEditor extends DocumentListenerEditor<AliasID>
+{
+    private static final long serialVersionUID = 1L;
+
+    private static final String HELP_TEXT = "<html>"
+    		+ "<h3>Passport Mobile ID (MIN)</h3>"
+    		+ "<b>MIN:</b> six character hex value (e.g. <u>AB12CD</u>)<br>"
+    		+ "<b>Wildcard:</b> use an asterisk (*) to wildcard individual<br>"
+    		+ "digits (e.g. <u>AB**CD</u> or <u>AB12**</u>)"
+    		+ "</html>";
+
+    private JTextField mTextField;
+
+	public MINEditor( AliasID aliasID )
+	{
+		initGUI();
+		
+		setItem( aliasID );
+	}
+	
+	private void initGUI()
+	{
+		setLayout( new MigLayout( "fill,wrap 2", "[right][left]", "[][]" ) );
+
+		add( new JLabel( "MIN:" ) );
+
+		MaskFormatter formatter = null;
+
+		try
+		{
+			//Mask: 6 hex characters
+			formatter = new MaskFormatter( "HHHHHH" );
+		}
+		catch( Exception e )
+		{
+			//Do nothing, the mask was invalid
+		}
+		
+		mTextField = new JFormattedTextField( formatter );
+		mTextField.getDocument().addDocumentListener( this );
+		mTextField.setToolTipText( HELP_TEXT );
+		add( mTextField, "growx,push" );
+		
+		JLabel help = new JLabel( "Help ..." );
+		help.setForeground( Color.BLUE.brighter() );
+		help.setCursor( new Cursor( Cursor.HAND_CURSOR ) );
+		help.addMouseListener( new MouseAdapter() 
+		{
+			@Override
+			public void mouseClicked( MouseEvent e )
+			{
+				JOptionPane.showMessageDialog( MINEditor.this, 
+					HELP_TEXT, "Help", JOptionPane.INFORMATION_MESSAGE );
+			}
+		} );
+		add( help, "align left" );
+	}
+	
+	public Min getMin()
+	{
+		if( getItem() instanceof Min )
+		{
+			return (Min)getItem();
+		}
+		
+		return null;
+	}
+
+	@Override
+	public void setItem( AliasID aliasID )
+	{
+		super.setItem( aliasID );
+		
+		Min min = getMin();
+		
+		if( min != null )
+		{
+			mTextField.setText( min.getMin() );
+		}
+		
+		setModified( false );
+		
+		repaint();
+	}
+
+	@Override
+	public void save()
+	{
+		Min min = getMin();
+		
+		if( min != null )
+		{
+			min.setMin( mTextField.getText() );
+		}
+		
+		setModified( false );
+	}
+}

src/main/java/alias/id/mobileID/Min.java

@@ -0,0 +1,81 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014 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 alias.id.mobileID;
+
+import javax.xml.bind.annotation.XmlAttribute;
+
+import alias.id.AliasID;
+import alias.id.AliasIDType;
+
+/**
+ * Mobile ID Number
+ */
+public class Min extends AliasID
+{
+	private String mMin;
+	
+	public Min()
+	{
+	}
+
+	@XmlAttribute
+	public String getMin()
+	{
+		return mMin;
+	}
+
+	public void setMin( String min )
+	{
+		mMin = min;
+	}
+
+	@Override
+	public boolean isValid()
+	{
+		return mMin != null;
+	}
+
+	public String toString()
+	{
+		return "MIN: " + mMin;
+	}
+
+	@Override
+    public boolean matches( AliasID id )
+    {
+		boolean retVal = false;
+		
+		if( mMin != null && id instanceof Min )
+		{
+			Min min = (Min)id;
+
+			//Create a pattern - replace * wildcards with regex single-char wildcard
+			String pattern = mMin.replace( "*", ".?" );
+			
+			retVal = min.getMin().matches( pattern );
+		}
+		
+	    return retVal;
+    }
+
+	@Override
+    public AliasIDType getType()
+    {
+	    return AliasIDType.MIN;
+    }
+}

src/main/java/alias/id/mpt1327/MPT1327ID.java

@@ -0,0 +1,78 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014 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 alias.id.mpt1327;
+
+import javax.xml.bind.annotation.XmlAttribute;
+
+import alias.id.AliasID;
+import alias.id.AliasIDType;
+
+public class MPT1327ID extends AliasID
+{
+	private String mID;
+	
+	public MPT1327ID()
+	{
+	}
+
+	@XmlAttribute
+	public String getIdent()
+	{
+		return mID;
+	}
+
+	public void setIdent( String ident )
+	{
+		mID = ident;
+	}
+
+	@Override
+	public boolean isValid()
+	{
+		return mID != null;
+	}
+
+	public String toString()
+	{
+		return "MPT-1327: " + mID;
+	}
+
+	@Override
+    public boolean matches( AliasID id )
+    {
+		boolean retVal = false;
+		
+		if( mID != null && id instanceof MPT1327ID )
+		{
+			MPT1327ID tgid = (MPT1327ID)id;
+
+			//Create a pattern - replace * wildcards with regex single-char wildcard
+			String pattern = mID.replace( "*", ".?" );
+			
+			retVal = tgid.getIdent().matches( pattern );
+		}
+		
+	    return retVal;
+    }
+
+	@Override
+    public AliasIDType getType()
+    {
+	    return AliasIDType.MPT1327;
+    }
+}

src/main/java/alias/id/mpt1327/MPT1327IDEditor.java

@@ -0,0 +1,135 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014-2016 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 alias.id.mpt1327;
+
+import gui.editor.DocumentListenerEditor;
+
+import java.awt.Color;
+import java.awt.Cursor;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+
+import javax.swing.JFormattedTextField;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JTextField;
+import javax.swing.text.MaskFormatter;
+
+import net.miginfocom.swing.MigLayout;
+import alias.id.AliasID;
+
+public class MPT1327IDEditor extends DocumentListenerEditor<AliasID>
+{
+	private static final long serialVersionUID = 1L;
+
+    private static final String HELP_TEXT = "<html>"
+    		+ "<h3>MPT-1327 Identifier</h3>"
+    		+ "<b>MPT-1327:</b> decimal (0-9) format ppp-iiii where<br>"
+    		+ "p=Prefix and i=Ident (e.g. <u>123-0001</u>)<br>"
+    		+ "<b>Wildcard:</b> use an asterisk (*) to wildcard individual<br>"
+    		+ "digits (e.g. <u>ABCD123*</u> or <u>AB**1**4</u>)"
+    		+ "</html>";
+
+    private JTextField mTextField;
+
+	public MPT1327IDEditor( AliasID aliasID )
+	{
+		initGUI();
+		
+		setItem( aliasID );
+	}
+	
+	private void initGUI()
+	{
+		setLayout( new MigLayout( "fill,wrap 2", "[right][left]", "[][]" ) );
+
+		add( new JLabel( "MPT-1327 ID:" ) );
+
+		MaskFormatter formatter = null;
+
+		try
+		{
+			//Mask: 3 digits - 4 digits
+			formatter = new MaskFormatter( "***-****" );
+		}
+		catch( Exception e )
+		{
+			//Do nothing, the mask was invalid
+		}
+		
+		mTextField = new JFormattedTextField( formatter );
+		mTextField.getDocument().addDocumentListener( this );
+		mTextField.setToolTipText( HELP_TEXT );
+
+		add( mTextField, "growx,push" );
+		
+		JLabel help = new JLabel( "Help ..." );
+		help.setForeground( Color.BLUE.brighter() );
+		help.setCursor( new Cursor( Cursor.HAND_CURSOR ) );
+		help.addMouseListener( new MouseAdapter() 
+		{
+			@Override
+			public void mouseClicked( MouseEvent e )
+			{
+				JOptionPane.showMessageDialog( MPT1327IDEditor.this, 
+					HELP_TEXT, "Help", JOptionPane.INFORMATION_MESSAGE );
+			}
+		} );
+		add( help, "align left" );
+	}
+	
+	public MPT1327ID getMPT1327ID()
+	{
+		if( getItem() instanceof MPT1327ID )
+		{
+			return (MPT1327ID)getItem();
+		}
+		
+		return null;
+	}
+
+	@Override
+	public void setItem( AliasID aliasID )
+	{
+		super.setItem( aliasID );
+		
+		MPT1327ID mpt = getMPT1327ID();
+		
+		if( mpt != null )
+		{
+			mTextField.setText( mpt.getIdent() );
+		}
+		
+		setModified( false );
+		
+		repaint();
+	}
+
+	@Override
+	public void save()
+	{
+		MPT1327ID mpt = getMPT1327ID();
+		
+		if( mpt != null )
+		{
+			mpt.setIdent( mTextField.getText() );
+		}
+		
+		setModified( false );
+	}
+}

src/main/java/alias/id/nonrecordable/NonRecordable.java

@@ -0,0 +1,31 @@
+package alias.id.nonrecordable;
+
+import alias.id.AliasID;
+import alias.id.AliasIDType;
+
+public class NonRecordable extends AliasID
+{
+	@Override
+	public AliasIDType getType()
+	{
+		return AliasIDType.NON_RECORDABLE;
+	}
+
+	@Override
+	public boolean isValid()
+	{
+		return true;
+	}
+
+	@Override
+	public boolean matches( AliasID id )
+	{
+		return false;
+	}
+	
+	@Override
+	public String toString()
+	{
+		return "Audio Non-Recordable";
+	}
+}

src/main/java/alias/id/nonrecordable/NonRecordableEditor.java

@@ -0,0 +1,78 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014-2016 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 alias.id.nonrecordable;
+
+import gui.editor.DocumentListenerEditor;
+
+import java.awt.Color;
+import java.awt.Cursor;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+
+import net.miginfocom.swing.MigLayout;
+import alias.id.AliasID;
+
+public class NonRecordableEditor extends DocumentListenerEditor<AliasID>
+{
+    private static final long serialVersionUID = 1L;
+
+    private static final String HELP_TEXT = "<html>"
+    		+ "<h3>Audio Non-Recordable</h3>"
+    		+ "This identifies an alias as non-recordable.<br><br>"
+    		+ "The alias can still be monitored but associated audio will<br>"
+    		+ "not be recorded.<br><br>"
+    		+ "The default behavior when audio recording is enabled for a<br>"
+    		+ "channel is to record all aliases except any alias with a<br>"
+    		+ "non-recordable identifier";
+
+	public NonRecordableEditor( AliasID aliasID )
+	{
+		initGUI();
+		
+		setItem( aliasID );
+	}
+	
+	private void initGUI()
+	{
+		setLayout( new MigLayout( "fill,wrap 1", "[]", "[][]" ) );
+
+		add( new JLabel( "Non-Recordable" ), "wrap" );
+		
+		JLabel help = new JLabel( "Help ..." );
+		help.setForeground( Color.BLUE.brighter() );
+		help.setCursor( new Cursor( Cursor.HAND_CURSOR ) );
+		help.addMouseListener( new MouseAdapter() 
+		{
+			@Override
+			public void mouseClicked( MouseEvent e )
+			{
+				JOptionPane.showMessageDialog( NonRecordableEditor.this, 
+					HELP_TEXT, "Help", JOptionPane.INFORMATION_MESSAGE );
+			}
+		} );
+		add( help, "align left" );
+	}
+	
+	@Override
+	public void save()
+	{
+	}
+}

src/main/java/alias/id/priority/Priority.java

@@ -0,0 +1,83 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014 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 alias.id.priority;
+
+import javax.xml.bind.annotation.XmlAttribute;
+
+import alias.id.AliasID;
+import alias.id.AliasIDType;
+
+/**
+ * Specifies an (audio) priority level for this alias.
+ */
+public class Priority extends AliasID
+{
+	public static final int DO_NOT_MONITOR = -1;
+	public static final int SELECTED_PRIORITY = 0;
+	public static final int MIN_PRIORITY = 1;
+	public static final int MAX_PRIORITY = 100;
+	public static final int DEFAULT_PRIORITY = 100;
+	
+	private int mPriority = DEFAULT_PRIORITY;
+	
+	public Priority()
+	{
+	}
+
+	@Override
+	public boolean isValid()
+	{
+		return true;
+	}
+
+	/**
+	 * Indicates the associated alias should not be monitored or tracked.
+	 */
+	public boolean isDoNotMonitor()
+	{
+		return mPriority == DO_NOT_MONITOR;
+	}
+
+	@XmlAttribute
+	public int getPriority()
+	{
+		return mPriority;
+	}
+
+	public void setPriority( int priority )
+	{
+		mPriority = priority;
+	}
+	
+	public String toString()
+	{
+		return "Audio Priority: " + ( isDoNotMonitor() ? "Do Not Monitor" : mPriority );
+	}
+
+	@Override
+    public boolean matches( AliasID id )
+    {
+	    return false;
+    }
+
+	@Override
+    public AliasIDType getType()
+    {
+	    return AliasIDType.PRIORITY;
+    }
+}

src/main/java/alias/id/priority/PriorityEditor.java

@@ -0,0 +1,168 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014-2016 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 alias.id.priority;
+
+import gui.editor.DocumentListenerEditor;
+
+import java.awt.Color;
+import java.awt.Cursor;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JSlider;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+import net.miginfocom.swing.MigLayout;
+import alias.id.AliasID;
+
+public class PriorityEditor extends DocumentListenerEditor<AliasID>
+{
+    private static final long serialVersionUID = 1L;
+
+	public static final String DO_NOT_MONITOR = "Do Not Monitor";
+
+	private static final String HELP_TEXT = "<html>"
+			+ "<h3>Call Audio Priority</h3>"
+			+ "Priority determines which calls have priority for playback<br>"
+			+ "over your computer speakers, or designates an alias for<br>"
+			+ "no-monitoring if you don't want to hear calls from an alias.<br><br>"
+			+ "Lower values indicate higher priority levels.<br><br>"
+			+ "<b>Do Not Monitor: </b> slide priority all the way to the right"
+    		+ "</html>";
+
+    private JSlider mPrioritySlider;
+    private JLabel mPrioritySliderLabel;
+
+	public PriorityEditor( AliasID aliasID )
+	{
+		initGUI();
+		
+		setItem( aliasID );
+	}
+	
+	private void initGUI()
+	{
+		setLayout( new MigLayout( "fill,wrap 2", "[right][left]", "[][]" ) );
+
+		mPrioritySlider = new JSlider( JSlider.HORIZONTAL,
+										Priority.MIN_PRIORITY,
+										Priority.MAX_PRIORITY + 1,
+										Priority.MIN_PRIORITY );
+		
+		mPrioritySlider.setMajorTickSpacing( 20 );
+		mPrioritySlider.setMinorTickSpacing( 5 );
+		mPrioritySlider.setPaintTicks( true );
+		mPrioritySlider.setLabelTable( mPrioritySlider.createStandardLabels( 20, 20 ) );
+		mPrioritySlider.setPaintLabels( true );
+		mPrioritySlider.addChangeListener( new ChangeListener()
+		{
+			@Override
+			public void stateChanged( ChangeEvent e )
+			{
+				int priority = mPrioritySlider.getValue();
+				
+				if( priority == Priority.MAX_PRIORITY + 1 )
+				{
+					mPrioritySliderLabel.setText( "Priority: Do Not Monitor" );
+				}
+				else
+				{
+					mPrioritySliderLabel.setText( "Priority: " + priority );
+				}
+				
+				setModified( true );
+			}
+		} );
+		mPrioritySlider.setToolTipText( HELP_TEXT );
+		
+		mPrioritySliderLabel = new JLabel( "Priority: " + mPrioritySlider.getValue() + " " );
+		add( mPrioritySliderLabel, "span,align center" );
+		add( mPrioritySlider, "span,grow" );
+		
+		JLabel help = new JLabel( "Help ..." );
+		help.setForeground( Color.BLUE.brighter() );
+		help.setCursor( new Cursor( Cursor.HAND_CURSOR ) );
+		help.addMouseListener( new MouseAdapter() 
+		{
+			@Override
+			public void mouseClicked( MouseEvent e )
+			{
+				JOptionPane.showMessageDialog( PriorityEditor.this, 
+					HELP_TEXT, "Help", JOptionPane.INFORMATION_MESSAGE );
+			}
+		} );
+		add( help, "align left" );
+	}
+	
+	public Priority getPriority()
+	{
+		if( getItem() instanceof Priority )
+		{
+			return (Priority)getItem();
+		}
+		
+		return null;
+	}
+
+	@Override
+	public void setItem( AliasID aliasID )
+	{
+		super.setItem( aliasID );
+
+		Priority priority = getPriority();
+		
+		if( priority != null )
+		{
+			int value = priority.getPriority();
+			
+			if( value == Priority.DO_NOT_MONITOR )
+			{
+				value = Priority.MAX_PRIORITY + 1;
+			}
+			
+			mPrioritySlider.setValue( value );
+		}
+		
+		setModified( false );
+		
+		repaint();
+	}
+
+	@Override
+	public void save()
+	{
+		Priority priority = getPriority();
+		
+		if( priority != null )
+		{
+			int value = mPrioritySlider.getValue();
+
+			if( value == Priority.MAX_PRIORITY + 1 )
+			{
+				value = Priority.DO_NOT_MONITOR;
+			}
+
+			priority.setPriority( value );
+		}
+		
+		setModified( false );
+	}
+}

src/main/java/alias/id/siteID/SiteID.java

@@ -0,0 +1,68 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014 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 alias.id.siteID;
+
+import javax.xml.bind.annotation.XmlAttribute;
+
+import alias.id.AliasID;
+import alias.id.AliasIDType;
+
+public class SiteID extends AliasID
+{
+	private String mSite;
+	
+	public SiteID()
+	{
+	}
+
+	@XmlAttribute
+	public String getSite()
+	{
+		return mSite;
+	}
+
+	public void setSite( String site )
+	{
+		mSite = site;
+	}
+
+	@Override
+	public boolean isValid()
+	{
+		return mSite != null;
+	}
+
+	public String toString()
+	{
+		return "Site: " + mSite;
+	}
+
+	@Override
+    public boolean matches( AliasID otherID )
+    {
+		return otherID != null && 
+			   otherID instanceof SiteID && 
+			   getSite().contentEquals( ( (SiteID)otherID).getSite() );
+    }
+
+	@Override
+    public AliasIDType getType()
+    {
+	    return AliasIDType.SITE;
+    }
+}

src/main/java/alias/id/siteID/SiteIDEditor.java

@@ -0,0 +1,121 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014-2016 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 alias.id.siteID;
+
+import gui.editor.DocumentListenerEditor;
+
+import java.awt.Color;
+import java.awt.Cursor;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JTextField;
+
+import net.miginfocom.swing.MigLayout;
+import alias.id.AliasID;
+
+public class SiteIDEditor extends DocumentListenerEditor<AliasID>
+{
+    private static final long serialVersionUID = 1L;
+
+    private static final String HELP_TEXT = "<html>"
+    		+ "<h3>Site Identifier</h3>"
+    		+ "<b>LTR-Net:</b> decimal (0-9) (e.g. <u>019</u>)<br>"
+    		+ "<b>MPT-1327:</b> 5 digits (0-9) (e.g. <u>23619</u>)<br>"
+    		+ "<b>Passport:</b> 3 digits (0-9) (e.g. <u>019</u>)<br>"
+    		+ "<b>P25:</b> hex (0-9, A-F) format RR-SS where RR = RF Subsystem<br>"
+    		+ "and SS = Site Number (e.g. RFSS 1 Site 1F: <u>01-1F</u>)"
+    		+ "</html>";
+
+    private JTextField mTextField;
+
+	public SiteIDEditor( AliasID aliasID )
+	{
+		initGUI();
+		
+		setItem( aliasID );
+	}
+	
+	private void initGUI()
+	{
+		setLayout( new MigLayout( "fill,wrap 2", "[right][left]", "[][]" ) );
+
+		add( new JLabel( "Site ID:" ) );
+		mTextField = new JTextField();
+		mTextField.getDocument().addDocumentListener( this );
+		mTextField.setToolTipText( HELP_TEXT );
+		add( mTextField, "growx,push" );
+
+		JLabel help = new JLabel( "Help ..." );
+		help.setForeground( Color.BLUE.brighter() );
+		help.setCursor( new Cursor( Cursor.HAND_CURSOR ) );
+		help.addMouseListener( new MouseAdapter() 
+		{
+			@Override
+			public void mouseClicked( MouseEvent e )
+			{
+				JOptionPane.showMessageDialog( SiteIDEditor.this, 
+					HELP_TEXT, "Help", JOptionPane.INFORMATION_MESSAGE );
+			}
+		} );
+		
+		add( help, "align left" );
+	}
+	
+	public SiteID getSiteID()
+	{
+		if( getItem() instanceof SiteID )
+		{
+			return (SiteID)getItem();
+		}
+		
+		return null;
+	}
+
+	@Override
+	public void setItem( AliasID aliasID )
+	{
+		super.setItem( aliasID );
+		
+		SiteID siteID = getSiteID();
+		
+		if( siteID != null )
+		{
+			mTextField.setText( siteID.getSite() );
+		}
+		
+		setModified( false );
+		
+		repaint();
+	}
+
+	@Override
+	public void save()
+	{
+		SiteID siteID = getSiteID();
+		
+		if( siteID != null )
+		{
+			siteID.setSite( mTextField.getText() );
+		}
+		
+		setModified( false );
+	}
+}

src/main/java/alias/id/status/StatusID.java

@@ -0,0 +1,75 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014 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 alias.id.status;
+
+import javax.xml.bind.annotation.XmlAttribute;
+
+import alias.id.AliasID;
+import alias.id.AliasIDType;
+
+public class StatusID extends AliasID
+{
+	private int mStatus;
+	
+	public StatusID()
+	{
+	}
+
+	@XmlAttribute
+	public int getStatus()
+	{
+		return mStatus;
+	}
+
+	public void setStatus( int status )
+	{
+		this.mStatus = status;
+	}
+
+	@Override
+	public boolean isValid()
+	{
+		return true;
+	}
+
+	public String toString()
+	{
+		return "Status: " + String.format( "%03d", mStatus );
+	}
+
+	@Override
+    public boolean matches( AliasID id )
+    {
+		boolean retVal = false;
+		
+		if( id instanceof StatusID )
+		{
+			StatusID statusId = (StatusID)id;
+			
+			retVal = ( mStatus == statusId.getStatus() );
+		}
+		
+	    return retVal;
+    }
+
+	@Override
+    public AliasIDType getType()
+    {
+	    return AliasIDType.STATUS;
+    }
+}

src/main/java/alias/id/status/StatusIDEditor.java

@@ -0,0 +1,146 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014-2016 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 alias.id.status;
+
+import gui.editor.DocumentListenerEditor;
+
+import java.awt.Color;
+import java.awt.Cursor;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+
+import javax.swing.JFormattedTextField;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JTextField;
+import javax.swing.text.MaskFormatter;
+
+import net.miginfocom.swing.MigLayout;
+import alias.id.AliasID;
+
+public class StatusIDEditor extends DocumentListenerEditor<AliasID>
+{
+    private static final long serialVersionUID = 1L;
+
+    private static final String HELP_TEXT = "<html>"
+    		+ "<h3>Status Identifier</h3>"
+    		+ "Status numbers are used in some protocols like Fleetsync.<br><br>"
+    		+ "The status number is assigned a meaning in the radio.  You<br>"
+    		+ "can assign a 3 digit status code (use leading zeros) to an<br>"
+    		+ "alias where the alias contains the status meaning.<br><br>"
+    		+ "<b>Status:</b> <u>001</u> engine start"
+    		+ "</html>";
+
+    private JTextField mTextField;
+
+	public StatusIDEditor( AliasID aliasID )
+	{
+		initGUI();
+		
+		setItem( aliasID );
+	}
+	
+	private void initGUI()
+	{
+		setLayout( new MigLayout( "fill,wrap 2", "[right][left]", "[][]" ) );
+
+		add( new JLabel( "Status:" ) );
+
+		MaskFormatter formatter = null;
+
+		try
+		{
+			//Mask: 3 digits
+			formatter = new MaskFormatter( "###" );
+		}
+		catch( Exception e )
+		{
+			//Do nothing, the mask was invalid
+		}
+		
+		mTextField = new JFormattedTextField( formatter );
+		mTextField.getDocument().addDocumentListener( this );
+		mTextField.setToolTipText( HELP_TEXT );
+		add( mTextField, "growx,push" );
+
+		JLabel help = new JLabel( "Help ..." );
+		help.setForeground( Color.BLUE.brighter() );
+		help.setCursor( new Cursor( Cursor.HAND_CURSOR ) );
+		help.addMouseListener( new MouseAdapter() 
+		{
+			@Override
+			public void mouseClicked( MouseEvent e )
+			{
+				JOptionPane.showMessageDialog( StatusIDEditor.this, 
+					HELP_TEXT, "Help", JOptionPane.INFORMATION_MESSAGE );
+			}
+		} );
+		add( help, "align left" );
+	}
+	
+	public StatusID getStatusID()
+	{
+		if( getItem() instanceof StatusID )
+		{
+			return (StatusID)getItem();
+		}
+		
+		return null;
+	}
+
+	@Override
+	public void setItem( AliasID aliasID )
+	{
+		super.setItem( aliasID );
+		
+		StatusID statusID = getStatusID();
+		
+		if( statusID != null )
+		{
+			mTextField.setText( String.format( "%03d", statusID.getStatus() ) );
+		}
+		
+		setModified( false );
+		
+		repaint();
+	}
+
+	@Override
+	public void save()
+	{
+		StatusID statusID = getStatusID();
+		
+		if( statusID != null )
+		{
+			int status = 0;
+			
+			try
+			{
+				status = Integer.valueOf( mTextField.getText() );
+			}
+			catch( Exception e )
+			{
+				//Do nothing, we couldn't parse the value
+			}
+			
+			statusID.setStatus( status );
+		}
+		
+		setModified( false );
+	}
+}

src/main/java/alias/id/talkgroup/TalkgroupID.java

@@ -0,0 +1,89 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014 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 alias.id.talkgroup;
+
+import alias.id.AliasID;
+import alias.id.AliasIDType;
+
+import javax.xml.bind.annotation.XmlAttribute;
+
+
+public class TalkgroupID extends AliasID
+{
+    private String mTalkgroup;
+
+    public TalkgroupID()
+    {
+        //No arg JAXB constructor
+    }
+
+    public TalkgroupID(String talkgroup)
+    {
+        mTalkgroup = talkgroup;
+    }
+
+    @XmlAttribute
+    public String getTalkgroup()
+    {
+        return mTalkgroup;
+    }
+
+    public void setTalkgroup(String talkgroup)
+    {
+        mTalkgroup = talkgroup;
+    }
+
+    @Override
+    public boolean isValid()
+    {
+        return mTalkgroup != null;
+    }
+
+    public String toString()
+    {
+        StringBuilder sb = new StringBuilder();
+
+        sb.append("Talkgroup: " + mTalkgroup);
+
+        return sb.toString();
+    }
+
+    @Override
+    public boolean matches(AliasID id)
+    {
+        boolean retVal = false;
+
+        if(id instanceof TalkgroupID)
+        {
+            TalkgroupID tgid = (TalkgroupID) id;
+
+            //Create a pattern - replace * wildcards with regex single-char wildcard
+            String pattern = mTalkgroup.replace("*", ".?");
+
+            retVal = tgid.getTalkgroup().matches(pattern);
+        }
+
+        return retVal;
+    }
+
+    @Override
+    public AliasIDType getType()
+    {
+        return AliasIDType.TALKGROUP;
+    }
+}

src/main/java/alias/id/talkgroup/TalkgroupIDEditor.java

@@ -0,0 +1,121 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014-2016 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 alias.id.talkgroup;
+
+import gui.editor.DocumentListenerEditor;
+
+import java.awt.Color;
+import java.awt.Cursor;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JTextField;
+
+import net.miginfocom.swing.MigLayout;
+import alias.id.AliasID;
+
+public class TalkgroupIDEditor extends DocumentListenerEditor<AliasID>
+{
+    private static final long serialVersionUID = 1L;
+
+    private static final String HELP_TEXT = 
+    		"<html><h3>Talkgroup Identifier</h3>"
+    		+ "<b>P25:</b> 4 or 6 hex characters (e.g. <u>AB12</u> or <u>ABC123</u>)<br>"
+    		+ "<b>LTR:</b> A-HH-TTT where A=Area H=Home T=Talkgroup (<u>0-01-128</u>)<br>"
+    		+ "<b>Passport</b>: 5-digit number (<u>12345</u> or <u>00023</u>)<br>"
+    		+ "<br>"
+            + "<b>Wildcard:</b> use an asterisk (*) in place of each talkgroup digit (e.g. <u>0*1*5</u>)"
+    		+ "</html>";
+
+    private JTextField mTextField;
+
+	public TalkgroupIDEditor( AliasID aliasID )
+	{
+		initGUI();
+		
+		setItem( aliasID );
+	}
+	
+	private void initGUI()
+	{
+		setLayout( new MigLayout( "fill,wrap 2", "[right][left]", "[][]" ) );
+
+		add( new JLabel( "Talkgroup:" ) );
+		
+		mTextField = new JTextField();
+		mTextField.getDocument().addDocumentListener( this );
+		mTextField.setToolTipText( HELP_TEXT );
+		add( mTextField, "growx,push" );
+
+		JLabel help = new JLabel( "Help ..." );
+		help.setForeground( Color.BLUE.brighter() );
+		help.setCursor( new Cursor( Cursor.HAND_CURSOR ) );
+		help.addMouseListener( new MouseAdapter() 
+		{
+			@Override
+			public void mouseClicked( MouseEvent e )
+			{
+				JOptionPane.showMessageDialog( TalkgroupIDEditor.this, 
+					HELP_TEXT, "Help", JOptionPane.INFORMATION_MESSAGE );
+			}
+		} );
+		add( help, "align left" );
+	}
+	
+	public TalkgroupID getTalkgroupID()
+	{
+		if( getItem() instanceof TalkgroupID )
+		{
+			return (TalkgroupID)getItem();
+		}
+		
+		return null;
+	}
+
+	@Override
+	public void setItem( AliasID aliasID )
+	{
+		super.setItem( aliasID );
+		
+		TalkgroupID talkgroup = getTalkgroupID();
+		
+		if( talkgroup != null )
+		{
+			mTextField.setText( talkgroup.getTalkgroup() );
+		}
+		
+		setModified( false );
+		
+		repaint();
+	}
+
+	@Override
+	public void save()
+	{
+		TalkgroupID talkgroup = getTalkgroupID();
+		
+		if( talkgroup != null )
+		{
+			talkgroup.setTalkgroup( mTextField.getText() );
+		}
+		
+		setModified( false );
+	}
+}

src/main/java/alias/id/uniqueID/UniqueID.java

@@ -0,0 +1,75 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014 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 alias.id.uniqueID;
+
+import javax.xml.bind.annotation.XmlAttribute;
+
+import alias.id.AliasID;
+import alias.id.AliasIDType;
+
+public class UniqueID extends AliasID
+{
+	private int mUid;
+	
+	public UniqueID()
+	{
+	}
+
+	@XmlAttribute
+	public int getUid()
+	{
+		return mUid;
+	}
+
+	public void setUid( int uid )
+	{
+		this.mUid = uid;
+	}
+
+	@Override
+	public boolean isValid()
+	{
+		return true;
+	}
+
+	public String toString()
+	{
+		return "UniqueID: " + mUid;
+	}
+
+	@Override
+    public boolean matches( AliasID id )
+    {
+		boolean retVal = false;
+		
+		if( id instanceof UniqueID )
+		{
+			UniqueID uid = (UniqueID)id;
+			
+			retVal = mUid == uid.getUid();
+		}
+		
+	    return retVal;
+    }
+
+	@Override
+    public AliasIDType getType()
+    {
+	    return AliasIDType.LTR_NET_UID;
+    }
+}

src/main/java/alias/id/uniqueID/UniqueIDEditor.java

@@ -0,0 +1,128 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014-2016 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 alias.id.uniqueID;
+
+import gui.editor.DocumentListenerEditor;
+
+import java.awt.Color;
+import java.awt.Cursor;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JTextField;
+
+import net.miginfocom.swing.MigLayout;
+import alias.id.AliasID;
+
+public class UniqueIDEditor extends DocumentListenerEditor<AliasID>
+{
+    private static final long serialVersionUID = 1L;
+
+    private static final String HELP_TEXT = "<html>"
+    		+ "<h3>LTR-Net Unique ID (UID)</h3>"
+    		+ "<b>UID:</b> identifier assigned to each radio in<br>"
+    		+ "the range <u>1 - 2097152</u>"
+    		+ "</html>";
+
+    private JTextField mTextField;
+
+	public UniqueIDEditor( AliasID aliasID )
+	{
+		initGUI();
+		
+		setItem( aliasID );
+	}
+	
+	private void initGUI()
+	{
+		setLayout( new MigLayout( "fill,wrap 2", "[right][left]", "[][]" ) );
+
+		add( new JLabel( "Unique ID:" ) );
+		mTextField = new JTextField();
+		mTextField.getDocument().addDocumentListener( this );
+		mTextField.setToolTipText( HELP_TEXT );
+		add( mTextField, "growx,push" );
+
+		JLabel help = new JLabel( "Help ..." );
+		help.setForeground( Color.BLUE.brighter() );
+		help.setCursor( new Cursor( Cursor.HAND_CURSOR ) );
+		help.addMouseListener( new MouseAdapter() 
+		{
+			@Override
+			public void mouseClicked( MouseEvent e )
+			{
+				JOptionPane.showMessageDialog( UniqueIDEditor.this, 
+					HELP_TEXT, "Help", JOptionPane.INFORMATION_MESSAGE );
+			}
+		} );
+		add( help, "align left" );
+	}
+	
+	public UniqueID getUniqueID()
+	{
+		if( getItem() instanceof UniqueID )
+		{
+			return (UniqueID)getItem();
+		}
+		
+		return null;
+	}
+
+	@Override
+	public void setItem( AliasID aliasID )
+	{
+		super.setItem( aliasID );
+		
+		UniqueID uid = getUniqueID();
+		
+		if( uid != null )
+		{
+			mTextField.setText( String.valueOf( uid.getUid() ) );
+		}
+		
+		setModified( false );
+		
+		repaint();
+	}
+
+	@Override
+	public void save()
+	{
+		UniqueID uid = getUniqueID();
+		
+		if( uid != null )
+		{
+			int id = 0;
+			
+			try
+			{
+				id = Integer.parseInt( mTextField.getText() );
+			}
+			catch( Exception e )
+			{
+				//Do nothing, we couldn't parse the value
+			}
+			
+			uid.setUid( id );
+		}
+		
+		setModified( false );
+	}
+}

src/main/java/audio/AudioChannelPanel.java

@@ -0,0 +1,253 @@
+/*******************************************************************************
+ * 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 audio;
+
+import alias.Alias;
+import audio.output.AudioOutput;
+import channel.metadata.Metadata;
+import icon.IconManager;
+import net.miginfocom.swing.MigLayout;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import properties.SystemProperties;
+import sample.Listener;
+import settings.ColorSetting;
+import settings.ColorSetting.ColorSettingName;
+import settings.Setting;
+import settings.SettingChangeListener;
+import settings.SettingsManager;
+
+import javax.swing.*;
+import java.awt.*;
+
+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 AudioOutput mAudioOutput;
+
+    private JLabel mMutedLabel = new JLabel("M");
+    private JLabel mChannelName = new JLabel(" ");
+    private JLabel mToAlias = new JLabel(" ");
+    private JLabel mTo = new JLabel("-----");
+
+    private boolean mConfigured = false;
+
+    public AudioChannelPanel(IconManager iconManager, SettingsManager settingsManager, AudioOutput audioOutput)
+    {
+        mIconManager = iconManager;
+        mSettingsManager = settingsManager;
+        mSettingsManager.addListener(this);
+
+        mAudioOutput = audioOutput;
+
+        if(mAudioOutput != null)
+        {
+            mAudioOutput.addAudioEventListener(this);
+            mAudioOutput.setMetadataListener(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();
+    }
+
+    private void init()
+    {
+        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);
+
+        mToAlias.setFont(mFont);
+        mToAlias.setForeground(mValueColor);
+        add(mToAlias);
+
+        mTo.setFont(mFont);
+        mTo.setForeground(mValueColor);
+        add(mTo,"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()
+    {
+        updateLabel(mTo, null, mToAlias, null);
+
+        mConfigured = false;
+    }
+
+    /**
+     * 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 updateLabel(JLabel textLabel, String value, JLabel iconLabel, Alias alias)
+    {
+        if(value != null)
+        {
+
+            if(alias != null)
+            {
+                iconLabel.setIcon(mIconManager.getIcon(alias.getIconName(), 18));
+
+                String aliasName = alias.getName();
+
+                //Truncate label if length exceeds 33 characters - hack!
+                if(aliasName.length() > 33)
+                {
+                    textLabel.setText(aliasName.substring(0,30) + "...");
+                }
+                else
+                {
+                    textLabel.setText(aliasName);
+                }
+            }
+            else
+            {
+                iconLabel.setIcon(null);
+                textLabel.setText(value);
+            }
+        }
+        else
+        {
+            iconLabel.setIcon(null);
+            textLabel.setText("-----");
+        }
+    }
+
+    /**
+     * Processes audio metadata to update this panel's display values
+     */
+    public class AudioMetadataProcessor implements Listener<Metadata>
+    {
+        @Override
+        public void receive(final Metadata metadata)
+        {
+            if(metadata.isUpdated() || !mConfigured)
+            {
+                EventQueue.invokeLater(new Runnable()
+                {
+                    @Override
+                    public void run()
+                    {
+                        updateLabel(mTo, metadata.getPrimaryAddressTo().getIdentifier(),
+                            mToAlias, metadata.getPrimaryAddressTo().getAlias());
+
+                        mConfigured = true;
+                    }
+                });
+
+            }
+        }
+    }
+
+
+    @Override
+    public void settingChanged(Setting setting)
+    {
+        if(setting instanceof ColorSetting)
+        {
+            ColorSetting colorSetting = (ColorSetting) setting;
+
+            switch(colorSetting.getColorSettingName())
+            {
+                case CHANNEL_STATE_LABEL_DECODER:
+                    if(mTo != null)
+                    {
+                        mTo.setForeground(mLabelColor);
+                    }
+                    if(mToAlias != null)
+                    {
+                        mToAlias.setForeground(mLabelColor);
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+
+    @Override
+    public void settingDeleted(Setting setting)
+    {
+    }
+}

src/main/java/audio/AudioChannelsPanel.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 audio;
+
+import audio.output.AudioOutput;
+import icon.IconManager;
+import net.miginfocom.swing.MigLayout;
+import settings.SettingsManager;
+
+import javax.swing.*;
+import java.awt.*;
+import java.util.List;
+
+public class AudioChannelsPanel extends JPanel
+{
+    private static final long serialVersionUID = 1L;
+
+    public AudioChannelsPanel(IconManager iconManager, SettingsManager settingsManager, IAudioController controller)
+    {
+        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, settingsManager, outputs.get(x)));
+
+            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, settingsManager, null), "growx");
+        }
+    }
+
+    private void addSeparator()
+    {
+        JSeparator separator = new JSeparator(JSeparator.VERTICAL);
+        separator.setBackground(Color.DARK_GRAY);
+        add(separator);
+    }
+}

src/main/java/audio/AudioEvent.java

@@ -0,0 +1,36 @@
+package audio;
+
+public class AudioEvent
+{
+	private Type mType;
+	private String mChannel;
+	
+	public AudioEvent( Type event, String channel )
+	{
+		mType = event;
+		mChannel = channel;
+	}
+	
+	public Type getType()
+	{
+		return mType;
+	}
+	
+	public String getChannel()
+	{
+		return mChannel;
+	}
+
+	public enum Type
+	{
+		AUDIO_MUTED,
+		AUDIO_UNMUTED,
+		AUDIO_SQUELCHED,
+		AUDIO_UNSQUELCHED,
+		AUDIO_STARTED,
+		AUDIO_STOPPED,
+		AUDIO_CONTINUATION,
+		AUDIO_CONFIGURATION_CHANGE_STARTED,
+		AUDIO_CONFIGURATION_CHANGE_COMPLETE;
+	}
+}

src/main/java/audio/AudioException.java

@@ -0,0 +1,16 @@
+package audio;
+
+public class AudioException extends Exception
+{
+	private static final long serialVersionUID = 1L;
+
+	public AudioException( String description )
+	{
+		super( description );
+	}
+	
+	public AudioException( String description, Throwable throwable )
+	{
+		super( description, throwable );
+	}
+}

src/main/java/audio/AudioFormats.java

@@ -0,0 +1,85 @@
+package audio;
+
+import javax.sound.sampled.AudioFormat;
+import javax.sound.sampled.DataLine;
+import javax.sound.sampled.Line;
+import javax.sound.sampled.SourceDataLine;
+
+public class AudioFormats
+{
+	public static final AudioFormat.Encoding IMBE_ENCODING = 
+			new AudioFormat.Encoding( "IMBE" );
+
+	public static final boolean LITTLE_ENDIAN = false;
+	public static final boolean BIG_ENDIAN = true;
+	
+	public static final float IMBE_FRAME_RATE = 50;
+	public static final float IMBE_SAMPLE_RATE = 50;
+	public static final float PCM_8KHZ_RATE = 8000;
+	public static final float PCM_48KHZ_RATE = 48000;
+	
+	public static final int IMBE_FRAME_SIZE_BYTES = 18;
+	public static final int IMBE_SAMPLE_SIZE_BITS = 144;
+	public static final int ONE_CHANNEL = 1;
+	public static final int TWO_CHANNELS = 2;
+	public static final int PCM_SAMPLE_SIZE_BITS = 16;
+	public static final int PCM_FRAME_SIZE_BYTES_MONO = 2;
+	public static final int PCM_FRAME_SIZE_BYTES_STEREO = 4;
+	
+	public static AudioFormat IMBE_AUDIO_FORMAT = 
+				new AudioFormat( IMBE_ENCODING, 
+								 IMBE_SAMPLE_RATE,
+								 IMBE_SAMPLE_SIZE_BITS,
+								 ONE_CHANNEL, 
+								 IMBE_FRAME_SIZE_BYTES, 
+								 IMBE_FRAME_RATE,
+								 LITTLE_ENDIAN );
+	
+	public static AudioFormat PCM_SIGNED_8KHZ_16BITS_MONO =
+						new AudioFormat( AudioFormat.Encoding.PCM_SIGNED, 
+								 PCM_8KHZ_RATE,
+								 PCM_SAMPLE_SIZE_BITS,
+								 ONE_CHANNEL, 
+								 PCM_FRAME_SIZE_BYTES_MONO, 
+								 PCM_8KHZ_RATE,
+								 LITTLE_ENDIAN );
+
+	public static AudioFormat PCM_SIGNED_8KHZ_16BITS_STEREO =
+			new AudioFormat( AudioFormat.Encoding.PCM_SIGNED,
+					PCM_8KHZ_RATE,
+					PCM_SAMPLE_SIZE_BITS,
+					TWO_CHANNELS,
+					PCM_FRAME_SIZE_BYTES_STEREO,
+					PCM_8KHZ_RATE,
+					LITTLE_ENDIAN );
+
+	public static AudioFormat PCM_SIGNED_48KHZ_16BITS_MONO =
+						new AudioFormat( AudioFormat.Encoding.PCM_SIGNED, 
+								 PCM_48KHZ_RATE,
+								 PCM_SAMPLE_SIZE_BITS,
+								 ONE_CHANNEL, 
+								 PCM_FRAME_SIZE_BYTES_MONO, 
+								 PCM_48KHZ_RATE,
+								 LITTLE_ENDIAN );
+	
+	public static AudioFormat PCM_SIGNED_48KHZ_16BITS_STEREO =
+						new AudioFormat( AudioFormat.Encoding.PCM_SIGNED, 
+								 PCM_48KHZ_RATE,
+								 PCM_SAMPLE_SIZE_BITS,
+								 TWO_CHANNELS, 
+								 PCM_FRAME_SIZE_BYTES_STEREO, 
+								 PCM_48KHZ_RATE,
+								 LITTLE_ENDIAN );
+	
+	/**
+	 * Source Data Line Info for a 48 kHz, 16-bits signed PCM one channel 
+	 */
+	public static final Line.Info MONO_SOURCE_DATALINE_INFO = 
+		new DataLine.Info( SourceDataLine.class, PCM_SIGNED_8KHZ_16BITS_MONO);
+	
+	/**
+	 * Source Data Line Info for a 48 kHz, 16-bits signed PCM two channels 
+	 */
+	public static final Line.Info STEREO_SOURCE_DATALINE_INFO = 
+		new DataLine.Info( SourceDataLine.class, PCM_SIGNED_8KHZ_16BITS_STEREO);
+}

src/main/java/audio/AudioManager.java

@@ -0,0 +1,568 @@
+/*******************************************************************************
+ * 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 audio;
+
+import audio.AudioEvent.Type;
+import audio.output.AudioOutput;
+import audio.output.MonoAudioOutput;
+import audio.output.StereoAudioOutput;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import properties.SystemProperties;
+import sample.Broadcaster;
+import sample.Listener;
+import source.mixer.MixerChannel;
+import source.mixer.MixerChannelConfiguration;
+import source.mixer.MixerManager;
+import util.ThreadPool;
+
+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 AudioManager implements Listener<AudioPacket>, IAudioController
+{
+    private static final Logger mLog = LoggerFactory.getLogger(AudioManager.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(Type.AUDIO_CONFIGURATION_CHANGE_STARTED, null);
+
+    public static final AudioEvent CONFIGURATION_CHANGE_COMPLETE =
+        new AudioEvent(Type.AUDIO_CONFIGURATION_CHANGE_COMPLETE, null);
+
+    private LinkedTransferQueue<AudioPacket> 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 AudioManager(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(AudioPacket 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.getChannelMetadataID()))
+            {
+                mChannelConnectionMap.remove(connection.getChannelMetadataID());
+                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(AudioPacket audioPacket)
+    {
+        int channelMetadataID = audioPacket.getMetadata().getMetadataID();
+
+        //Use an existing connection
+        if(mChannelConnectionMap.containsKey(channelMetadataID))
+        {
+            return mChannelConnectionMap.get(channelMetadataID);
+        }
+
+        //Connect to an unused, available connection
+        if(mAvailableConnectionCount > 0)
+        {
+            for(AudioOutputConnection connection : mAudioOutputConnections)
+            {
+                if(connection.isDisconnected())
+                {
+                    connection.connect(channelMetadataID, audioPacket.getMetadata().getAudioPriority());
+                    mChannelConnectionMap.put(channelMetadataID, connection);
+                    mAvailableConnectionCount--;
+                    return connection;
+                }
+            }
+        }
+        //Preempt an existing lower priority connection and connect when this is a higher priority packet
+        else
+        {
+            int priority = audioPacket.getMetadata().getAudioPriority();
+
+            AudioOutputConnection connection = mLowestPriorityConnection;
+
+            if(connection != null && priority < connection.getPriority())
+            {
+                mChannelConnectionMap.remove(connection.getChannelMetadataID());
+
+                connection.connect(channelMetadataID, priority);
+
+                mChannelConnectionMap.put(channelMetadataID, connection);
+
+                return connection;
+            }
+        }
+
+        return null;
+    }
+
+    public class AudioPacketProcessor implements Runnable
+    {
+        @Override
+        public void run()
+        {
+            try
+            {
+                disconnectInactiveChannelAssignments();
+
+                if(mAudioPacketQueue != null)
+                {
+                    List<AudioPacket> packets = new ArrayList<AudioPacket>();
+
+                    mAudioPacketQueue.drainTo(packets);
+
+                    for(AudioPacket packet : packets)
+                    {
+                        /* Don't process any packet's marked as do not monitor */
+                        if(!packet.getMetadata().isDoNotMonitor() && packet.getType() == AudioPacket.Type.AUDIO)
+                        {
+                            AudioOutputConnection connection = getConnection(packet);
+
+                            if(connection != null)
+                            {
+                                connection.receive(packet);
+                            }
+                        }
+                    }
+                }
+            }
+            catch(Exception e)
+            {
+                mLog.error("Encountered error while processing audio packets", e);
+            }
+        }
+    }
+
+    /**
+     * 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 = -1;
+
+        private AudioOutput mAudioOutput;
+        private int mPriority = 0;
+        private int mChannelMetadataID = DISCONNECTED;
+
+        public AudioOutputConnection(AudioOutput audioOutput)
+        {
+            mAudioOutput = audioOutput;
+        }
+
+        public void receive(AudioPacket packet)
+        {
+            if(packet.hasMetadata() && packet.getMetadata().getMetadataID() == mChannelMetadataID)
+            {
+                int priority = packet.getMetadata().getAudioPriority();
+
+                if(mPriority != priority)
+                {
+                    mPriority = priority;
+                    updateLowestPriorityAssignment();
+                }
+
+                if(mAudioOutput != null)
+                {
+                    mAudioOutput.receive(packet);
+                }
+            }
+            else
+            {
+                if(packet.hasMetadata())
+                {
+                    mLog.error("Received audio packet from channel metadata [" + packet.getMetadata().getMetadataID() +
+                        "] however this assignment is currently connected to metadata [" + mChannelMetadataID + "]");
+                }
+                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 mChannelMetadataID == 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)
+        {
+            mChannelMetadataID = source;
+            mPriority = priority;
+            updateLowestPriorityAssignment();
+
+            mAudioOutput.updateTimestamp();
+        }
+
+        /**
+         * Currently connected source or -1 if disconnected
+         */
+        public int getChannelMetadataID()
+        {
+            return mChannelMetadataID;
+        }
+
+        /**
+         * 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()
+        {
+            mChannelMetadataID = 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/audio/AudioModule.java

@@ -0,0 +1,188 @@
+/*******************************************************************************
+ * 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 audio;
+
+import audio.squelch.ISquelchStateListener;
+import audio.squelch.SquelchState;
+import channel.metadata.Metadata;
+import dsp.filter.design.FilterDesignException;
+import dsp.filter.fir.FIRFilterSpecification;
+import dsp.filter.fir.remez.RemezFIRFilterDesigner;
+import dsp.filter.polyphase.PolyphaseFIRDecimatingFilter_RB;
+import module.Module;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import sample.Listener;
+import sample.real.IFilteredRealBufferListener;
+import sample.real.RealBuffer;
+
+import java.util.concurrent.ScheduledExecutorService;
+
+/**
+ * Provides packaging of demodulated audio sample buffers into audio packets for
+ * broadcast to registered audio packet listeners.  Includes audio packet
+ * metadata in constructed audio packets.
+ *
+ * Incorporates audio squelch state listener to control if audio packets are
+ * broadcast or ignored.
+ */
+public class AudioModule extends Module implements IAudioPacketProvider, IFilteredRealBufferListener,
+    ISquelchStateListener, Listener<RealBuffer>
+{
+    protected static final Logger mLog = LoggerFactory.getLogger(AudioModule.class);
+
+    private static float[] mDecimationCoefficients;
+
+    static
+    {
+        //Band-pass filter to both decimate (48kHz to 8kHz) and block 0 - 300 Hz (LTR signalling).
+        FIRFilterSpecification specification = FIRFilterSpecification.bandPassBuilder()
+            .sampleRate(48000)
+            .stopFrequency1(150)
+            .passFrequencyBegin(300)
+            .passFrequencyEnd(3500)
+            .stopFrequency2(4000)
+            .stopRipple(0.0004)
+            .passRipple(0.008)
+            .build();
+
+        RemezFIRFilterDesigner designer = new RemezFIRFilterDesigner(specification);
+
+        try
+        {
+            if(!designer.isValid())
+            {
+                throw new FilterDesignException("Couldn't design the audio decimation filter");
+            }
+
+            mDecimationCoefficients = designer.getImpulseResponse();
+        }
+        catch(FilterDesignException e)
+        {
+            mLog.debug("Error designing filter", e);
+        }
+    }
+
+    private SquelchStateListener mSquelchStateListener = new SquelchStateListener();
+    private SquelchState mSquelchState = SquelchState.SQUELCH;
+    private Listener<AudioPacket> mAudioPacketListener;
+    private PolyphaseFIRDecimatingFilter_RB mAudioDecimationFilter;
+    private Metadata mMetadata;
+
+    public AudioModule(Metadata metadata)
+    {
+        mMetadata = metadata;
+
+        mAudioDecimationFilter = new PolyphaseFIRDecimatingFilter_RB(mDecimationCoefficients, 6, 2.0f);
+        mAudioDecimationFilter.setListener(new Listener<RealBuffer>()
+        {
+            @Override
+            public void receive(RealBuffer realBuffer)
+            {
+                if(mAudioPacketListener != null)
+                {
+                    AudioPacket packet = new AudioPacket(realBuffer.getSamples(), mMetadata.copyOf());
+                    mAudioPacketListener.receive(packet);
+                }
+            }
+        });
+    }
+
+    @Override
+    public void dispose()
+    {
+        mSquelchStateListener = null;
+        mAudioPacketListener = null;
+    }
+
+    @Override
+    public void reset()
+    {
+    }
+
+    @Override
+    public void start(ScheduledExecutorService executor)
+    {
+        /* No start operations provided */
+    }
+
+    @Override
+    public void stop()
+    {
+        /* Issue an end audio packet in case a recorder is still rolling */
+        if(mAudioPacketListener != null)
+        {
+            mAudioPacketListener.receive(new AudioPacket(AudioPacket.Type.END, mMetadata.copyOf()));
+        }
+    }
+
+    /**
+     * Processes demodulated audio samples into audio packets with current audio
+     * metadata and sends to the registered listener
+     */
+    @Override
+    public void receive(RealBuffer buffer)
+    {
+        if(mAudioPacketListener != null && mSquelchState == SquelchState.UNSQUELCH)
+        {
+            mAudioDecimationFilter.receive(buffer);
+        }
+    }
+
+    @Override
+    public Listener<RealBuffer> getFilteredRealBufferListener()
+    {
+        return this;
+    }
+
+    @Override
+    public void setAudioPacketListener(Listener<AudioPacket> listener)
+    {
+        mAudioPacketListener = listener;
+    }
+
+    @Override
+    public void removeAudioPacketListener()
+    {
+        mAudioPacketListener = null;
+    }
+
+    @Override
+    public Listener<SquelchState> getSquelchStateListener()
+    {
+        return mSquelchStateListener;
+    }
+
+    /**
+     * Wrapper for squelch state listener
+     */
+    public class SquelchStateListener implements Listener<SquelchState>
+    {
+        @Override
+        public void receive(SquelchState state)
+        {
+            if(state == SquelchState.SQUELCH && mAudioPacketListener != null)
+            {
+                mAudioPacketListener.receive(new AudioPacket(AudioPacket.Type.END, mMetadata.copyOf()));
+            }
+
+            mSquelchState = state;
+        }
+    }
+}

src/main/java/audio/AudioPacket.java

@@ -0,0 +1,78 @@
+/*******************************************************************************
+ * 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 audio;
+
+import channel.metadata.Metadata;
+import sample.real.RealBuffer;
+
+public class AudioPacket
+{
+    private Type mType;
+    private RealBuffer mAudioData;
+    private Metadata mMetadata;
+
+    public AudioPacket(Type type, Metadata metadata)
+    {
+        mType = type;
+        mMetadata = metadata;
+    }
+
+    public AudioPacket(float[] audio, Metadata metadata)
+    {
+        this(Type.AUDIO, metadata);
+
+        mAudioData = new RealBuffer(audio);
+    }
+
+    public boolean hasMetadata()
+    {
+        return mMetadata != null;
+    }
+
+    public Metadata getMetadata()
+    {
+        return mMetadata;
+    }
+
+    public void setMetadata(Metadata metadata)
+    {
+        mMetadata = metadata;
+    }
+
+    public Type getType()
+    {
+        return mType;
+    }
+
+    public RealBuffer getAudioBuffer()
+    {
+        return mAudioData;
+    }
+
+    public boolean hasAudioBuffer()
+    {
+        return mAudioData != null;
+    }
+
+    public enum Type
+    {
+        AUDIO,
+        END;
+    }
+}

src/main/java/audio/AudioPacketRateCounter.java

@@ -0,0 +1,56 @@
+package audio;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import sample.Listener;
+
+public class AudioPacketRateCounter implements Listener<AudioPacket>
+{
+	private final static Logger mLog = 
+			LoggerFactory.getLogger( AudioPacketRateCounter.class );
+
+	private Listener<AudioPacket> mListener;
+	private long mCount;
+	private long mStartTime = -1;
+	
+	private String mName;
+	
+	public AudioPacketRateCounter()
+	{
+		mName = "UNNAMED";
+	}
+	
+	public AudioPacketRateCounter( String name )
+	{
+		mName = name;
+	}
+	
+	@Override
+	public void receive( AudioPacket packet )
+	{
+		if( mStartTime == -1 )
+		{
+			mStartTime = System.currentTimeMillis();
+		}
+		
+		mCount += packet.getAudioBuffer().getSamples().length;
+
+		long elapsed = System.currentTimeMillis() - mStartTime;
+		
+		if( elapsed != 0 )
+		{
+			mLog.debug( "[" + mName + "] Audio Rate: " + ( mCount / elapsed ) + " kHz" );
+		}
+		
+		if( mListener != null )
+		{
+			mListener.receive( packet );
+		}
+	}
+	
+	public void setListener( Listener<AudioPacket> listener )
+	{
+		mListener = listener;
+	}
+}

src/main/java/audio/AudioPanel.java

@@ -0,0 +1,413 @@
+/*******************************************************************************
+ * 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 audio;
+
+import audio.output.AudioOutput;
+import icon.IconManager;
+import net.miginfocom.swing.MigLayout;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import sample.Listener;
+import settings.SettingsManager;
+import source.SourceManager;
+import source.mixer.MixerChannelConfiguration;
+
+import javax.sound.sampled.FloatControl;
+import javax.swing.*;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import java.awt.*;
+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(
+        new ImageIcon("images/audio_muted.png"), 20);
+    private static ImageIcon UNMUTED_ICON = IconManager.getScaledIcon(
+        new ImageIcon("images/audio_unmuted.png"), 20);
+
+    private IconManager mIconManager;
+    private SettingsManager mSettingsManager;
+    private SourceManager mSourceManager;
+    private IAudioController mController;
+
+    private JButton mMuteButton;
+    private AudioChannelsPanel mAudioChannelsPanel;
+
+    public AudioPanel(IconManager iconManager, SettingsManager settingsManager, SourceManager sourceManager,
+                      IAudioController controller)
+    {
+        mIconManager = iconManager;
+        mSettingsManager = settingsManager;
+        mSourceManager = sourceManager;
+        mController = controller;
+
+        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, mSettingsManager, mController);
+
+        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 = new AudioChannelsPanel(mIconManager, mSettingsManager, mController);
+
+                        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/audio/AudioUtils.java

@@ -0,0 +1,58 @@
+/*******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2016 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 audio;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import record.wave.RealBufferWaveRecorder;
+import sample.ConversionUtils;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.List;
+
+public class AudioUtils
+{
+    private final static Logger mLog = LoggerFactory.getLogger(AudioUtils.class);
+
+    /**
+     * Converts the audio packets into a byte array of 16-bit, little-endian audio samples
+     */
+    public static byte[] convertTo16BitSamples(List<AudioPacket> audioPackets)
+    {
+        ByteArrayOutputStream stream = new ByteArrayOutputStream();
+
+        try
+        {
+            for(AudioPacket packet: audioPackets)
+            {
+                //Converting from 32-bit floats to signed 16-bit samples
+                ByteBuffer buffer = ConversionUtils.convertToSigned16BitSamples(packet.getAudioBuffer().getSamples());
+                stream.write(buffer.array());
+            }
+        }
+        catch(IOException e)
+        {
+            mLog.error("Error writing converted PCM bytes to output stream");
+        }
+
+        return stream.toByteArray();
+    }
+}

src/main/java/audio/IAudioController.java

@@ -0,0 +1,24 @@
+package audio;
+
+import java.util.List;
+
+import sample.Listener;
+import source.mixer.MixerChannelConfiguration;
+import audio.output.AudioOutput;
+
+/**
+ * Interface for controlling one or more audio channels
+ */
+public interface IAudioController
+{
+	/* Current Mixer and MixerChannel configuration */
+	public void setMixerChannelConfiguration( MixerChannelConfiguration entry ) throws AudioException;
+	public MixerChannelConfiguration getMixerChannelConfiguration() throws AudioException;
+	
+	/* Audio Output(s) */
+	public List<AudioOutput> getAudioOutputs();
+
+	/* Controller Audio Event Listener */
+	public void addControllerListener( Listener<AudioEvent> listener );
+	public void removeControllerListener( Listener<AudioEvent> listener );
+}

src/main/java/audio/IAudioPacketListener.java

@@ -0,0 +1,8 @@
+package audio;
+
+import sample.Listener;
+
+public interface IAudioPacketListener
+{
+	public Listener<AudioPacket> getAudioPacketListener();
+}

src/main/java/audio/IAudioPacketProvider.java

@@ -0,0 +1,9 @@
+package audio;
+
+import sample.Listener;
+
+public interface IAudioPacketProvider
+{
+	public void setAudioPacketListener( Listener<AudioPacket> listener );
+	public void removeAudioPacketListener();
+}

src/main/java/audio/InversionFrequency.java

@@ -0,0 +1,59 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014 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 audio;
+
+/**
+ * Standard voice inversion foldover frequencies
+ * 
+ * Reference: http://en.wikipedia.org/wiki/Voice_inversion
+ */
+public enum InversionFrequency
+{
+	HZ_2500( 2500 ),
+	HZ_2550( 2550 ),
+	HZ_2600( 2600 ),
+	HZ_2632( 2632 ),
+	HZ_2675( 2675 ),
+	HZ_2718( 2718 ),
+	HZ_2800( 2800 ),
+	HZ_2868( 2868 ),
+	HZ_2950( 2950 ),
+	HZ_3023( 3023 ),
+	HZ_3075( 3075 ),
+	HZ_3107( 3107 ),
+	HZ_3150( 3150 ),
+	HZ_3196( 3196 ),
+	HZ_3333( 3333 ),
+	HZ_3339( 3339 ),
+	HZ_3400( 3400 ),
+	HZ_3496( 3496 ),
+	HZ_3729( 3729 ),
+	HZ_4096( 4096 );
+	
+	private int mFrequency;
+	
+	private InversionFrequency( int frequency )
+	{
+		mFrequency = frequency;
+	}
+
+	public int getFrequency()
+	{
+		return mFrequency;
+	}
+}

src/main/java/audio/broadcast/AudioBroadcaster.java

@@ -0,0 +1,469 @@
+/*******************************************************************************
+ * 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 audio.broadcast;
+
+import audio.convert.ISilenceGenerator;
+import channel.metadata.Metadata;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import sample.Listener;
+import util.ThreadPool;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.util.Queue;
+import java.util.concurrent.LinkedTransferQueue;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public abstract class AudioBroadcaster implements Listener<AudioRecording>
+{
+    private final static Logger mLog = LoggerFactory.getLogger(AudioBroadcaster.class);
+
+    public static final int PROCESSOR_RUN_INTERVAL_MS = 1000;
+
+    private ScheduledFuture mRecordingQueueProcessorFuture;
+
+    private RecordingQueueProcessor mRecordingQueueProcessor = new RecordingQueueProcessor();
+    private Queue<AudioRecording> mAudioRecordingQueue = new LinkedTransferQueue<>();
+
+    private ISilenceGenerator mSilenceGenerator;
+
+    private Listener<BroadcastEvent> mBroadcastEventListener;
+    private BroadcastState mBroadcastState = BroadcastState.READY;
+
+    private int mStreamedAudioCount = 0;
+    private int mAgedOffAudioCount = 0;
+    private BroadcastConfiguration mBroadcastConfiguration;
+    private long mDelay;
+    private long mMaximumRecordingAge;
+    private AtomicBoolean mStreaming = new AtomicBoolean();
+
+    /**
+     * AudioBroadcaster for streaming audio recordings to a remote streaming audio server.  Audio recordings are
+     * generated by an internal StreamManager that converts an inbound stream of AudioPackets into a recording of the
+     * desired audio format (e.g. MP3) and nominates the recording to an internal recording queue for streaming.  The
+     * broadcaster supports receiving audio packets from multiple audio sources.  Each audio packet's internal audio
+     * metadata source string is used to reassemble each packet stream.  Recordings are capped at 30 seconds length.
+     * If a source audio packet stream exceeds 30 seconds in length, it will be chunked into 30 second recordings.
+     *
+     * This broadcaster supports a time delay setting for delaying broadcast of audio recordings.  The delay setting is
+     * defined in the broadcast configuration.  When this delay is greater than zero, the recording will remain in the
+     * audio broadcaster queue until the recording start time + delay elapses.  Audio recordings are processed in a FIFO
+     * manner.
+     *
+     * Use the start() and stop() methods to connect to/disconnect from the remote server.  Audio recordings will be
+     * streamed to the remote server when available.  One second silence frames will be broadcast to the server when
+     * there are no recordings available, in order to maintain a connection with the remote server.  Any audio packet
+     * streams received while the broadcaster is stopped will be ignored.
+     *
+     * The last audio packet's metadata is automatically attached to the closed audio recording when it is enqueued for
+     * broadcast.  That metadata will be updated on the remote server once the audio recording is opened for streaming.
+     */
+    public AudioBroadcaster(BroadcastConfiguration broadcastConfiguration)
+    {
+        mBroadcastConfiguration = broadcastConfiguration;
+        mDelay = mBroadcastConfiguration.getDelay();
+        mMaximumRecordingAge = mBroadcastConfiguration.getMaximumRecordingAge();
+        mSilenceGenerator = BroadcastFactory.getSilenceGenerator(broadcastConfiguration.getBroadcastFormat());
+    }
+
+    /**
+     * Broadcast binary audio data frames or sequences.
+     */
+    protected abstract void broadcastAudio(byte[] audio);
+
+    /**
+     * Protocol-specific metadata updater
+     */
+    protected abstract IBroadcastMetadataUpdater getMetadataUpdater();
+
+    /**
+     * Broadcasts the next song's audio metadata prior to streaming the next song.
+     *
+     * @param metadata for the next recording that will be streamed
+     */
+    protected void broadcastMetadata(Metadata metadata)
+    {
+        IBroadcastMetadataUpdater metadataUpdater = getMetadataUpdater();
+
+        if(metadataUpdater != null)
+        {
+            metadataUpdater.update(metadata);
+        }
+    }
+
+    /**
+     * Disconnects the broadcaster from the remote server for a reset or final stop.
+     */
+    protected abstract void disconnect();
+
+    /**
+     * Connects to the remote server specified by the broadcast configuration and starts audio streaming.
+     */
+    public void start()
+    {
+        if(mStreaming.compareAndSet(false, true))
+        {
+            if(mRecordingQueueProcessorFuture == null)
+            {
+                mRecordingQueueProcessorFuture = ThreadPool.SCHEDULED.scheduleAtFixedRate(mRecordingQueueProcessor,
+                    0, PROCESSOR_RUN_INTERVAL_MS, TimeUnit.MILLISECONDS);
+            }
+        }
+    }
+
+    /**
+     * Disconnects from the remote server.
+     */
+    public void stop()
+    {
+        if(mStreaming.compareAndSet(true, false))
+        {
+            if(mRecordingQueueProcessorFuture != null)
+            {
+                mRecordingQueueProcessorFuture.cancel(true);
+                mRecordingQueueProcessorFuture = null;
+            }
+
+            disconnect();
+        }
+    }
+
+    /**
+     * Stream name for the broadcast configuration for this broadcaster
+     *
+     * @return stream name or null
+     */
+    public String getStreamName()
+    {
+        BroadcastConfiguration config = getBroadcastConfiguration();
+
+        if(config != null)
+        {
+            return config.getName();
+        }
+
+        return null;
+    }
+
+    /**
+     * Size of recording queue for recordings awaiting streaming
+     */
+    public int getQueueSize()
+    {
+        return mAudioRecordingQueue.size();
+    }
+
+    /**
+     * Number of audio recordings streamed to remote server
+     */
+    public int getStreamedAudioCount()
+    {
+        return mStreamedAudioCount;
+    }
+
+    /**
+     * Number of audio recordings that were removed for exceeding age limit
+     */
+    public int getAgedOffAudioCount()
+    {
+        return mAgedOffAudioCount;
+    }
+
+    /**
+     * Primary insert method for the stream manager to nominate completed audio recordings for broadcast.
+     *
+     * @param recording to queue for broadcasting
+     */
+    public void receive(AudioRecording recording)
+    {
+        if(connected())
+        {
+            mAudioRecordingQueue.offer(recording);
+            broadcast(new BroadcastEvent(this, BroadcastEvent.Event.BROADCASTER_QUEUE_CHANGE));
+        }
+    }
+
+    /**
+     * Broadcast configuration used by this broadcaster
+     */
+    public BroadcastConfiguration getBroadcastConfiguration()
+    {
+        return mBroadcastConfiguration;
+    }
+
+    /**
+     * Registers the listener to receive broadcast events/state changes
+     */
+    public void setListener(Listener<BroadcastEvent> listener)
+    {
+        mBroadcastEventListener = listener;
+    }
+
+    /**
+     * Removes the listener from receiving broadcast events/state changes
+     */
+    public void removeListener()
+    {
+        mBroadcastEventListener = null;
+    }
+
+    /**
+     * Broadcasts the event to any registered listener
+     */
+    public void broadcast(BroadcastEvent event)
+    {
+        if(mBroadcastEventListener != null)
+        {
+            mBroadcastEventListener.receive(event);
+        }
+    }
+
+    /**
+     * Sets the state of the broadcastAudio connection
+     */
+    protected void setBroadcastState(BroadcastState state)
+    {
+        if(mBroadcastState != state)
+        {
+            mLog.info("[" + getStreamName() + "] status: " + state);
+            mBroadcastState = state;
+
+            broadcast(new BroadcastEvent(this, BroadcastEvent.Event.BROADCASTER_STATE_CHANGE));
+
+            if(mBroadcastState.isErrorState())
+            {
+                stop();
+            }
+
+            if(!connected())
+            {
+                //Remove all pending audio recordings
+                while(!mAudioRecordingQueue.isEmpty())
+                {
+                    try
+                    {
+                        AudioRecording recording = mAudioRecordingQueue.remove();
+                        recording.removePendingReplay();
+                    }
+                    catch(Exception e)
+                    {
+                        //Ignore
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Current state of the broadcastAudio connection
+     */
+    public BroadcastState getBroadcastState()
+    {
+        return mBroadcastState;
+    }
+
+    /**
+     * Indicates if the broadcaster is currently connected to the remote server
+     */
+    protected boolean connected()
+    {
+        return getBroadcastState() == BroadcastState.CONNECTED;
+    }
+
+    /**
+     * Indicates if this broadcaster can connect and is not currently in an error state or a connected state.
+     */
+    public boolean canConnect()
+    {
+        BroadcastState state = getBroadcastState();
+
+        return state != BroadcastState.CONNECTED && !state.isErrorState();
+    }
+
+    /**
+     * Indicates if the current broadcast state is an error state, meaning that it cannot recover or connect using the
+     * current configuration.
+     */
+    protected boolean isErrorState()
+    {
+        return getBroadcastState().isErrorState();
+    }
+
+
+    /**
+     * Audio recording queue processor.  Fetches recordings from the queue and chunks the recording byte content
+     * to subclass implementations for broadcast in the appropriate manner.
+     */
+    public class RecordingQueueProcessor implements Runnable
+    {
+        private AtomicBoolean mProcessing = new AtomicBoolean();
+        private ByteArrayInputStream mInputStream;
+        private long mFinalSilencePadding = 0;
+        private int mBytesStreamedActual = 0;
+        private int mBytesStreamedRequired = 0;
+
+        @Override
+        public void run()
+        {
+            if(mProcessing.compareAndSet(false, true))
+            {
+                try
+                {
+                    if(mInputStream == null || mInputStream.available() <= 0)
+                    {
+                        if(mFinalSilencePadding > 0)
+                        {
+                            broadcastAudio(mSilenceGenerator.generate(mFinalSilencePadding));
+                            mFinalSilencePadding = 0;
+                        }
+
+                        nextRecording();
+                    }
+
+                    if(mInputStream != null)
+                    {
+                        //We need to stream at 13.888 fps (144 byte frame) to achieve 2000 Bps or 16 kbps
+                        mBytesStreamedRequired += 2000;  //2000 bytes per second for 16 kbps data rate
+                        int bytesToStream = mBytesStreamedRequired - mBytesStreamedActual;
+
+                        //Trim length to whole-frame intervals (144 byte frame)
+                        bytesToStream -= (bytesToStream % 144);
+
+                        int length = Math.min(bytesToStream, mInputStream.available());
+
+                        byte[] audio = new byte[length];
+
+                        try
+                        {
+                            mBytesStreamedActual += mInputStream.read(audio);
+
+                            broadcastAudio(audio);
+                        }
+                        catch(IOException ioe)
+                        {
+                            mLog.error("Error reading from in-memory audio recording input stream", ioe);
+                        }
+                    }
+                    else
+                    {
+                        broadcastAudio(mSilenceGenerator.generate(PROCESSOR_RUN_INTERVAL_MS));
+                    }
+                }
+                catch(Exception e)
+                {
+                    mLog.error("Error while processing audio streaming queue", e);
+                }
+
+                mProcessing.set(false);
+            }
+        }
+
+        /**
+         * Loads the next recording for broadcast
+         */
+        private void nextRecording()
+        {
+            mBytesStreamedActual = 0;
+            mBytesStreamedRequired = 0;
+
+            boolean metadataUpdateRequired = false;
+
+            if(mInputStream != null)
+            {
+                mStreamedAudioCount++;
+                broadcast(new BroadcastEvent(AudioBroadcaster.this,
+                    BroadcastEvent.Event.BROADCASTER_STREAMED_COUNT_CHANGE));
+                metadataUpdateRequired = true;
+            }
+
+            mInputStream = null;
+
+            //Peek at the next recording but don't remove it from the queue yet, so we can inspect the start time for
+            //age limits and/or delay elapsed
+            AudioRecording nextRecording = mAudioRecordingQueue.peek();
+
+            //Purge any recordings that have exceeded maximum recording age limit
+            while(nextRecording != null &&
+                (nextRecording.getStartTime() + mDelay + mMaximumRecordingAge) < java.lang.System.currentTimeMillis())
+            {
+                nextRecording = mAudioRecordingQueue.remove();
+                nextRecording.removePendingReplay();
+                mAgedOffAudioCount++;
+                broadcast(new BroadcastEvent(AudioBroadcaster.this,
+                    BroadcastEvent.Event.BROADCASTER_AGED_OFF_COUNT_CHANGE));
+                nextRecording = mAudioRecordingQueue.peek();
+            }
+
+            if(nextRecording != null && nextRecording.getStartTime() + mDelay <= System.currentTimeMillis())
+            {
+                nextRecording = mAudioRecordingQueue.remove();
+
+                try
+                {
+                    if(Files.exists(nextRecording.getPath()))
+                    {
+                        byte[] audio = Files.readAllBytes(nextRecording.getPath());
+
+                        if(audio != null && audio.length > 0)
+                        {
+                            mInputStream = new ByteArrayInputStream(audio);
+
+                            mFinalSilencePadding = PROCESSOR_RUN_INTERVAL_MS -
+                                (nextRecording.getRecordingLength() % PROCESSOR_RUN_INTERVAL_MS);
+
+                            while(mFinalSilencePadding >= PROCESSOR_RUN_INTERVAL_MS)
+                            {
+                                mFinalSilencePadding -= PROCESSOR_RUN_INTERVAL_MS;
+                            }
+
+                            if(connected())
+                            {
+                                broadcastMetadata(nextRecording.getMetadata());
+                            }
+
+                            metadataUpdateRequired = false;
+                        }
+                    }
+                }
+                catch(IOException ioe)
+                {
+                    mLog.error("Stream [" + getBroadcastConfiguration().getName() + "] error reading temporary audio " +
+                        "stream recording [" + nextRecording.getPath().toString() + "] - skipping recording - ", ioe);
+
+                    mInputStream = null;
+                    metadataUpdateRequired = false;
+                }
+
+                nextRecording.removePendingReplay();
+
+                broadcast(new BroadcastEvent(AudioBroadcaster.this, BroadcastEvent.Event.BROADCASTER_QUEUE_CHANGE));
+            }
+
+            //If we closed out a recording and don't have a new/next recording, send an empty metadata update
+            if(metadataUpdateRequired && connected())
+            {
+                broadcastMetadata(null);
+            }
+        }
+    }
+}

src/main/java/audio/broadcast/AudioRecording.java

@@ -0,0 +1,120 @@
+/*******************************************************************************
+ * 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 audio.broadcast;
+
+import channel.metadata.Metadata;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.nio.file.Path;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class AudioRecording implements Comparable<AudioRecording>
+{
+    private final static Logger mLog = LoggerFactory.getLogger(StreamManager.class);
+
+    private Path mPath;
+    private long mStartTime;
+    private long mRecordingLength;
+    private AtomicInteger mPendingReplayCount = new AtomicInteger();
+    private Metadata mMetadata;
+
+    /**
+     * Audio recording that is ready to be streamed
+     *
+     * @param path to the audio recording file
+     * @param metadata associated with the recording
+     * @param start time of recording in milliseconds since epoch
+     * @param recordingLength in milliseconds
+     */
+    public AudioRecording(Path path, Metadata metadata, long start, long recordingLength)
+    {
+        mPath = path;
+        mMetadata = metadata;
+        mStartTime = start;
+        mRecordingLength = recordingLength;
+    }
+
+    /**
+     * Path to the completed audio recording
+     */
+    public Path getPath()
+    {
+        return mPath;
+    }
+
+    /**
+     * Optional audio metadata for the recording.
+     */
+    public Metadata getMetadata()
+    {
+        return mMetadata;
+    }
+
+    /**
+     * Recording start time in milliseconds since epoch
+     */
+    public long getStartTime()
+    {
+        return mStartTime;
+    }
+
+    /**
+     * Recording length in milliseconds
+     */
+    public long getRecordingLength()
+    {
+        return mRecordingLength;
+    }
+
+
+    /**
+     * Implements comparable for sorting recordings based on start time in ascending order
+     */
+    @Override
+    public int compareTo(AudioRecording otherRecording)
+    {
+        return Long.compare(getStartTime(), otherRecording.getStartTime());
+    }
+
+    /**
+     * Increments the count of pending replays.
+     */
+    public void addPendingReplay()
+    {
+        mPendingReplayCount.incrementAndGet();
+    }
+
+    /**
+     * Decrements the count of pending replays.
+     */
+    public void removePendingReplay()
+    {
+        mPendingReplayCount.decrementAndGet();
+    }
+
+    /**
+     * Indicates if there are any remaining pending replays.  Once the pending replay count is less than or equal to
+     * zero, the recording can be deleted.
+     */
+    public boolean hasPendingReplays()
+    {
+        return mPendingReplayCount.get() > 0;
+    }
+}

src/main/java/audio/broadcast/BroadcastConfiguration.java

@@ -0,0 +1,301 @@
+/*******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2016 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 audio.broadcast;
+
+import audio.broadcast.broadcastify.BroadcastifyConfiguration;
+import audio.broadcast.icecast.IcecastHTTPConfiguration;
+import audio.broadcast.icecast.IcecastTCPConfiguration;
+import audio.broadcast.shoutcast.v1.ShoutcastV1Configuration;
+import audio.broadcast.shoutcast.v2.ShoutcastV2Configuration;
+
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlRootElement;
+import javax.xml.bind.annotation.XmlSeeAlso;
+import javax.xml.bind.annotation.XmlTransient;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+
+@XmlSeeAlso({BroadcastifyConfiguration.class,
+             IcecastTCPConfiguration.class,
+             IcecastHTTPConfiguration.class,
+             ShoutcastV1Configuration.class,
+             ShoutcastV2Configuration.class})
+@XmlRootElement(name = "stream")
+public abstract class BroadcastConfiguration
+{
+    private BroadcastFormat mBroadcastFormat = BroadcastFormat.MP3;
+    private String mName;
+    private String mHost;
+    private int mPort;
+    private String mPassword;
+    private long mDelay;
+    private long mMaximumRecordingAge = 10 * 60 * 1000; //10 minutes default
+    private boolean mEnabled = true;
+
+    public BroadcastConfiguration()
+    {
+        //No-arg constructor required for JAXB
+    }
+
+    /**
+     * Creates a copy/clone of the configuration
+     */
+    public abstract BroadcastConfiguration copyOf();
+
+    /**
+     * Broadcast audio streaming configuration.  Describes the streaming server and configuration details.
+     */
+    public BroadcastConfiguration(BroadcastFormat format)
+    {
+        mBroadcastFormat = format;
+    }
+
+    /**
+     * Broadcast server type
+     */
+    @XmlAttribute(name = "type")
+    public abstract BroadcastServerType getBroadcastServerType();
+
+    /**
+     * Name identifying this broadcastAudio configuration.
+     */
+    @XmlAttribute(name = "name")
+    public String getName()
+    {
+        return mName;
+    }
+
+    /**
+     * Sets the name name that identifies/describes this configuration
+     *
+     * @param name
+     */
+    public void setName(String name)
+    {
+        mName = name;
+    }
+
+    /**
+     * Indicates if this configuration has a name value
+     */
+    public boolean hasName()
+    {
+        return mName != null;
+    }
+
+    /**
+     * BROADCAST server host name.
+     */
+    @XmlAttribute(name = "host")
+    public String getHost()
+    {
+        return mHost;
+    }
+
+    /**
+     * Host name or IP address of the streaming server
+     *
+     * @param host
+     */
+    public void setHost(String host)
+    {
+        mHost = host;
+    }
+
+    /**
+     * Indicates if this configuration has a host value
+     */
+    public boolean hasHost()
+    {
+        return mHost != null;
+    }
+
+    /**
+     * BROADCAST server port number;
+     */
+    @XmlAttribute(name = "port")
+    public int getPort()
+    {
+        return mPort;
+    }
+
+    /**
+     * Port number of the streaming server to where the broadcastAudio will be directed.
+     *
+     * @param port
+     */
+    public void setPort(int port)
+    {
+        mPort = port;
+    }
+
+    /**
+     * Indicates if this configuration contains a port value
+     */
+    public boolean hasPort()
+    {
+        return mPort > 0;
+    }
+
+    public SocketAddress getAddress()
+    {
+        return new InetSocketAddress(getHost(), getPort());
+    }
+
+    /**
+     * Password to authenticate with the streaming server.
+     */
+    @XmlAttribute(name = "password")
+    public String getPassword()
+    {
+        return mPassword;
+    }
+
+    /**
+     * Sets the password used to authenticate the broadcastAudio broadcastAudio user to the streaming server
+     *
+     * @param password
+     */
+    public void setPassword(String password)
+    {
+        mPassword = password;
+    }
+
+    /**
+     * Indicates if this configuration has a password value
+     */
+    public boolean hasPassword()
+    {
+        return mPassword != null;
+    }
+
+    /**
+     * Audio broadcastAudio content type (e.g. mp3)
+     */
+    @XmlAttribute(name = "format")
+    public BroadcastFormat getBroadcastFormat()
+    {
+        return mBroadcastFormat;
+    }
+
+    public void setBroadcastFormat(BroadcastFormat format)
+    {
+        mBroadcastFormat = format;
+    }
+
+    /**
+     * Audio broadcastAudio delay from recording start until the audio file is broadcastAudio to the server.
+     */
+    @XmlAttribute(name = "delay")
+    public long getDelay()
+    {
+        return mDelay;
+    }
+
+    /**
+     * User specified delay in milli-seconds from audio call start until when the audio is broadcastAudio to the server.
+     * @param delay in milliseconds
+     */
+    public void setDelay(long delay)
+    {
+        mDelay = delay;
+    }
+
+    /**
+     * Gets maximum recording age which determines the maximum amount of elapsed time that a recording can set in the
+     * queue awaiting streaming before it is purged from the queue.  This value is in addition to the delay setting.
+     * @return age in milliseconds
+     */
+    @XmlAttribute(name = "maximum_recording_age")
+    public long getMaximumRecordingAge()
+    {
+        return mMaximumRecordingAge;
+    }
+
+    /**
+     * Sets maximum recording age which determines the maximum amount of elapsed time that a recording can set in the
+     * queue awaiting streaming before it is purged from the queue.  This value is in addition to the delay setting.
+     * @param age in milliseconds
+     */
+    public void setMaximumRecordingAge(long age)
+    {
+        mMaximumRecordingAge = age;
+    }
+
+    /**
+     * Indicates if this broadcaster is enable, meaning that it will automatically connect on startup.
+     */
+    @XmlAttribute(name = "enabled")
+    public boolean isEnabled()
+    {
+        return mEnabled;
+    }
+
+    public void setEnabled(boolean enabled)
+    {
+        mEnabled = enabled;
+    }
+
+    @Override
+    public boolean equals(Object o)
+    {
+        if (this == o)
+        {
+            return true;
+        }
+
+        if (!(o instanceof BroadcastConfiguration))
+        {
+            return false;
+        }
+
+        BroadcastConfiguration that = (BroadcastConfiguration) o;
+
+        if (getBroadcastFormat() != that.getBroadcastFormat())
+        {
+            return false;
+        }
+
+        if (getName() != null ? !getName().equals(that.getName()) : that.getName() != null)
+        {
+            return false;
+        }
+
+        return getBroadcastServerType() == that.getBroadcastServerType();
+    }
+
+    @Override
+    public int hashCode()
+    {
+        int result = getBroadcastFormat().hashCode();
+        result = 31 * result + (getName() != null ? getName().hashCode() : 0);
+        result = 31 * result + getBroadcastServerType().hashCode();
+        return result;
+    }
+
+    /**
+     * Indicates if this configuration is valid.  A minimal check will ensure that it contains at least a hostname and
+     * port number.
+     */
+    @XmlTransient
+    public boolean isValid()
+    {
+        return mHost != null && mPort > 0;
+    }
+}

src/main/java/audio/broadcast/BroadcastConfigurationEditor.java

@@ -0,0 +1,126 @@
+/*******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2016 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 audio.broadcast;
+
+import alias.AliasModel;
+import gui.editor.DocumentListenerEditor;
+import icon.IconManager;
+
+import javax.swing.*;
+
+public abstract class BroadcastConfigurationEditor extends DocumentListenerEditor<BroadcastConfiguration>
+{
+    protected IconManager mIconManager;
+    protected BroadcastModel mBroadcastModel;
+    protected AliasModel mAliasModel;
+
+    public BroadcastConfigurationEditor(BroadcastModel broadcastModel, AliasModel aliasModel, IconManager iconManager)
+    {
+        mBroadcastModel = broadcastModel;
+        mAliasModel = aliasModel;
+        mIconManager = iconManager;
+    }
+
+    /**
+     * Updates the configuration with the new name and prompts the user to update any aliases that have a broadcast
+     * channel alias id with the old name to update to the new name.
+     *
+     * @param broadcastConfiguration to assign a new channel name
+     * @param newName to assign to the broadcast configuration.  Note: assumes that validateConfiguration() has been
+     * invoked to verify that newName is non-null and non-empty
+     */
+    protected void updateConfigurationName(BroadcastConfiguration broadcastConfiguration, String newName)
+    {
+        String previousName = broadcastConfiguration.getName();
+
+        if(previousName == null || previousName.isEmpty())
+        {
+            broadcastConfiguration.setName(newName);
+            return;
+        }
+
+        if(!previousName.equals(newName))
+        {
+            mAliasModel.renameBroadcastChannel(previousName, newName);
+            broadcastConfiguration.setName(newName);
+        }
+    }
+
+    /**
+     * Validates a text field control for a non-null, non-empty value
+     * @param field to validate
+     * @param title to use for error dialog
+     * @param message to use for error dialog
+     * @return true if field contains a non-null, non-empty value
+     */
+    protected boolean validateTextField(JTextField field, String title, String message)
+    {
+        String text = field.getText();
+
+        if(text == null || text.isEmpty())
+        {
+            JOptionPane.showMessageDialog(BroadcastConfigurationEditor.this, message, title,
+                    JOptionPane.ERROR_MESSAGE);
+
+            field.requestFocus();
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Validates the text field control that contains an integer value for non-null, non-empty and within the
+     * specified min/max valid range.
+     * @param field to validate
+     * @param title to use for error dialog
+     * @param message to use for error dialog
+     * @param minValid value
+     * @param maxValid value
+     * @return true if field contains a non-null, non-empty value within the valid min/max range
+     */
+    protected boolean validateIntegerTextField(JTextField field, String title, String message, int minValid, int maxValid)
+    {
+        if(validateTextField(field, title, message))
+        {
+            String text = field.getText();
+
+            try
+            {
+                int value = Integer.parseInt(text);
+
+                if(minValid <= value && value <= maxValid)
+                {
+                    return true;
+                }
+            }
+            catch(Exception e)
+            {
+                //Do nothing, we couldn't parse the number value
+            }
+
+            JOptionPane.showMessageDialog(BroadcastConfigurationEditor.this, message, title,
+                    JOptionPane.ERROR_MESSAGE);
+
+            field.requestFocus();
+        }
+
+        return false;
+    }
+}

src/main/java/audio/broadcast/BroadcastEvent.java

@@ -0,0 +1,92 @@
+/*******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2016 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 audio.broadcast;
+
+public class BroadcastEvent
+{
+    private BroadcastConfiguration mBroadcastConfiguration;
+    private AudioBroadcaster mAudioBroadcaster;
+    private Event mEvent;
+
+    /**
+     * AliasEvent - event describing any changes to an alias
+     *
+     * @param configuration - alias that changed
+     * @param event - change event
+     */
+    public BroadcastEvent(BroadcastConfiguration configuration, Event event)
+    {
+        mBroadcastConfiguration = configuration;
+        mEvent = event;
+    }
+
+    public BroadcastEvent(AudioBroadcaster audioBroadcaster, Event event)
+    {
+        mAudioBroadcaster = audioBroadcaster;
+        mEvent = event;
+    }
+
+    public BroadcastConfiguration getBroadcastConfiguration()
+    {
+        return mBroadcastConfiguration;
+    }
+
+    public AudioBroadcaster getAudioBroadcaster()
+    {
+        return mAudioBroadcaster;
+    }
+
+    /**
+     * Indicates if this event pertains to an audio broadcaster
+     */
+    public boolean isAudioBroadcasterEvent()
+    {
+        return mAudioBroadcaster != null;
+    }
+
+    /**
+     * Indicates if this event pertains to a broadcast configuration
+     */
+    public boolean isBroadcastConfigurationEvent()
+    {
+        return mBroadcastConfiguration != null;
+    }
+
+    public Event getEvent()
+    {
+        return mEvent;
+    }
+
+    /**
+     * Channel events to describe the specific event
+     */
+    public enum Event
+    {
+        BROADCASTER_ADD,
+        BROADCASTER_QUEUE_CHANGE,
+        BROADCASTER_STATE_CHANGE,
+        BROADCASTER_STREAMED_COUNT_CHANGE,
+        BROADCASTER_AGED_OFF_COUNT_CHANGE,
+        BROADCASTER_DELETE,
+
+        CONFIGURATION_ADD,
+        CONFIGURATION_CHANGE,
+        CONFIGURATION_DELETE;
+    }
+}

src/main/java/audio/broadcast/BroadcastFactory.java

@@ -0,0 +1,210 @@
+/*******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2016 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 audio.broadcast;
+
+import alias.AliasModel;
+import audio.broadcast.broadcastify.BroadcastifyConfiguration;
+import audio.broadcast.broadcastify.BroadcastifyConfigurationEditor;
+import audio.broadcast.icecast.IcecastHTTPAudioBroadcaster;
+import audio.broadcast.icecast.IcecastHTTPConfiguration;
+import audio.broadcast.icecast.IcecastHTTPConfigurationEditor;
+import audio.broadcast.icecast.IcecastTCPAudioBroadcaster;
+import audio.broadcast.icecast.IcecastTCPConfiguration;
+import audio.broadcast.icecast.IcecastTCPConfigurationEditor;
+import audio.broadcast.shoutcast.v1.ShoutcastV1AudioBroadcaster;
+import audio.broadcast.shoutcast.v1.ShoutcastV1Configuration;
+import audio.broadcast.shoutcast.v1.ShoutcastV1ConfigurationEditor;
+import audio.broadcast.shoutcast.v2.ShoutcastV2AudioBroadcaster;
+import audio.broadcast.shoutcast.v2.ShoutcastV2Configuration;
+import audio.broadcast.shoutcast.v2.ShoutcastV2ConfigurationEditor;
+import audio.convert.IAudioConverter;
+import audio.convert.ISilenceGenerator;
+import audio.convert.MP3AudioConverter;
+import audio.convert.MP3SilenceGenerator;
+import gui.editor.Editor;
+import gui.editor.EmptyEditor;
+import icon.IconManager;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import record.AudioRecorder;
+import record.mp3.MP3Recorder;
+
+import java.nio.file.Path;
+
+public class BroadcastFactory
+{
+    private final static Logger mLog = LoggerFactory.getLogger(BroadcastFactory.class);
+
+    public static final int MP3_MONO_16_KHZ_BITRATE = 16;
+    public static final boolean MP3_CONSTANT_BITRATE = false;
+
+    /**
+     * Creates an audio streaming broadcaster for the configuration
+     *
+     * @param configuration describing the server and audio types
+     * @return configured broadcaster or null
+     */
+    public static AudioBroadcaster getBroadcaster(BroadcastConfiguration configuration)
+    {
+        if(configuration != null)
+        {
+            IAudioConverter converter = getAudioConverter(configuration);
+
+            if(converter != null)
+            {
+                switch(configuration.getBroadcastServerType())
+                {
+                    case BROADCASTIFY:
+                        return new IcecastTCPAudioBroadcaster((BroadcastifyConfiguration) configuration);
+                    case ICECAST_TCP:
+                        return new IcecastTCPAudioBroadcaster((IcecastTCPConfiguration) configuration);
+                    case ICECAST_HTTP:
+                        return new IcecastHTTPAudioBroadcaster((IcecastHTTPConfiguration) configuration);
+                    case SHOUTCAST_V1:
+                        return new ShoutcastV1AudioBroadcaster((ShoutcastV1Configuration) configuration);
+                    case SHOUTCAST_V2:
+                        return new ShoutcastV2AudioBroadcaster((ShoutcastV2Configuration) configuration);
+                    case UNKNOWN:
+                    default:
+                        mLog.info("Unrecognized broadcastAudio configuration: " + configuration.getBroadcastFormat().name());
+                        break;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Creates an audio convert to convert from 8 kHz PCM audio to the specified format
+     *
+     * @param configuration containing the requested output audio format
+     * @return audio convert or null
+     */
+    public static IAudioConverter getAudioConverter(BroadcastConfiguration configuration)
+    {
+        switch(configuration.getBroadcastFormat())
+        {
+            case MP3:
+                return new MP3AudioConverter(MP3_MONO_16_KHZ_BITRATE, MP3_CONSTANT_BITRATE);
+            default:
+                mLog.info("Unrecognized broadcastAudio format: " + configuration.getBroadcastFormat().name());
+        }
+
+        return null;
+    }
+
+    /**
+     * Creates a broadcastAudio configuration for the specified server type and format
+     *
+     * @param serverType for the configuration
+     * @param format for the output audio format
+     * @return constructed (empty) configuration
+     */
+    public static BroadcastConfiguration getConfiguration(BroadcastServerType serverType, BroadcastFormat format)
+    {
+        switch(serverType)
+        {
+            case BROADCASTIFY:
+                return new BroadcastifyConfiguration(format);
+            case ICECAST_HTTP:
+                return new IcecastHTTPConfiguration(format);
+            case ICECAST_TCP:
+                return new IcecastTCPConfiguration(format);
+            case SHOUTCAST_V1:
+                return new ShoutcastV1Configuration(format);
+            case SHOUTCAST_V2:
+                return new ShoutcastV2Configuration(format);
+            case UNKNOWN:
+            default:
+                mLog.info("Unrecognized broadcastAudio server type: " + serverType.name());
+                break;
+        }
+
+        return null;
+    }
+
+    /**
+     * Constructs an editor for the specified broadcastAudio configuration
+     *
+     * @param configuration to modify or view
+     * @param broadcastModel model for broadcastAudio configurations
+     * @return an editor for the specified broadcastAudio configuration
+     */
+    public static Editor<BroadcastConfiguration> getEditor(BroadcastConfiguration configuration,
+                                                           BroadcastModel broadcastModel,
+                                                           AliasModel aliasModel,
+                                                           IconManager iconManager)
+    {
+        Editor<BroadcastConfiguration> editor;
+
+        switch(configuration.getBroadcastServerType())
+        {
+            case BROADCASTIFY:
+                editor = new BroadcastifyConfigurationEditor(broadcastModel, aliasModel, iconManager);
+                break;
+            case ICECAST_TCP:
+                editor = new IcecastTCPConfigurationEditor(broadcastModel, aliasModel, iconManager);
+                break;
+            case ICECAST_HTTP:
+                editor = new IcecastHTTPConfigurationEditor(broadcastModel, aliasModel, iconManager);
+                break;
+            case SHOUTCAST_V1:
+                editor = new ShoutcastV1ConfigurationEditor(broadcastModel, aliasModel, iconManager);
+                break;
+            case SHOUTCAST_V2:
+                editor = new ShoutcastV2ConfigurationEditor(broadcastModel, aliasModel, iconManager);
+                break;
+            default:
+                editor = new EmptyEditor<BroadcastConfiguration>();
+                break;
+        }
+
+        editor.setItem(configuration);
+
+        return editor;
+    }
+
+    /**
+     * Creates an audio recorder for the specified broadcastAudio format using the specified path output file name
+     */
+    public static AudioRecorder getAudioRecorder(Path path, BroadcastFormat broadcastFormat)
+    {
+        switch(broadcastFormat)
+        {
+            case MP3:
+                return new MP3Recorder(path);
+            default:
+                mLog.debug("Unrecognized broadcastAudio format [" + broadcastFormat + "] cannot create audio recorder");
+                return null;
+        }
+    }
+
+    public static ISilenceGenerator getSilenceGenerator(BroadcastFormat format)
+    {
+        switch(format)
+        {
+            case MP3:
+                return new MP3SilenceGenerator();
+            default:
+                throw new IllegalArgumentException("Unrecognized broadcast format [" + format +
+                    "] can't create silence generator");
+        }
+    }
+}

src/main/java/audio/broadcast/BroadcastFormat.java

@@ -0,0 +1,43 @@
+/*******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2016 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 audio.broadcast;
+
+public enum BroadcastFormat
+{
+    MP3("audio/mpeg", ".mp3");
+
+    private String mValue;
+    private String mFileExtension;
+
+    private BroadcastFormat(String value, String fileExtension)
+    {
+        mValue = value;
+        mFileExtension = fileExtension;
+    }
+
+    public String getValue()
+    {
+        return mValue;
+    }
+
+    public String getFileExtension()
+    {
+        return mFileExtension;
+    }
+}

src/main/java/audio/broadcast/BroadcastModel.java

@@ -0,0 +1,772 @@
+/*******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2016 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 audio.broadcast;
+
+import alias.id.broadcast.BroadcastChannel;
+import audio.AudioPacket;
+import channel.metadata.Metadata;
+import icon.IconManager;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import properties.SystemProperties;
+import sample.Broadcaster;
+import sample.Listener;
+import util.ThreadPool;
+
+import javax.swing.*;
+import javax.swing.table.AbstractTableModel;
+import java.io.IOException;
+import java.nio.file.DirectoryStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class BroadcastModel extends AbstractTableModel implements Listener<AudioPacket>
+{
+    private final static Logger mLog = LoggerFactory.getLogger(BroadcastModel.class);
+
+    public static final String TEMPORARY_STREAM_DIRECTORY = "streaming";
+    public static final String TEMPORARY_STREAM_FILE_SUFFIX = "temporary_streaming_file_";
+
+    private static final String UNIQUE_NAME_REGEX = "(.*)\\((\\d*)\\)";
+
+    public static final int COLUMN_SERVER_ICON = 0;
+    public static final int COLUMN_STREAM_NAME = 1;
+    public static final int COLUMN_BROADCASTER_STATUS = 2;
+    public static final int COLUMN_BROADCASTER_QUEUE_SIZE = 3;
+    public static final int COLUMN_BROADCASTER_STREAMED_COUNT = 4;
+    public static final int COLUMN_BROADCASTER_AGED_OFF_COUNT = 5;
+
+    public static final String[] COLUMN_NAMES = new String[]
+        {"Streaming", "Name", "Status", "Queued", "Streamed", "Aged Off"};
+
+    private List<BroadcastConfiguration> mBroadcastConfigurations = new CopyOnWriteArrayList<>();
+    private List<AudioRecording> mRecordingQueue = new CopyOnWriteArrayList<>();
+
+    private Map<String,BroadcastConfiguration> mBroadcastConfigurationMap = new HashMap<>();
+    private Map<String,AudioBroadcaster> mBroadcasterMap = new HashMap<>();
+    private IconManager mIconManager;
+    private StreamManager mStreamManager;
+    private Broadcaster<BroadcastEvent> mBroadcastEventBroadcaster = new Broadcaster<>();
+
+    /**
+     * Model for managing Broadcast configurations and any associated broadcaster instances.
+     */
+    public BroadcastModel(IconManager iconManager)
+    {
+        mIconManager = iconManager;
+        mStreamManager = new StreamManager(new CompletedRecordingListener(), BroadcastFormat.MP3,
+            SystemProperties.getInstance().getApplicationFolder(TEMPORARY_STREAM_DIRECTORY));
+        mStreamManager.start();
+
+        //Monitor to remove temporary recording files that have been streamed by all audio broadcasters
+        ThreadPool.SCHEDULED.scheduleAtFixedRate(new RecordingDeletionMonitor(),
+            15l, 15l, TimeUnit.SECONDS);
+
+        removeOrphanedTemporaryRecordings();
+    }
+
+    /**
+     * List of broadcastAudio configuration names
+     */
+    public List<String> getBroadcastConfigurationNames()
+    {
+        List<String> names = new ArrayList<>();
+
+        for(BroadcastConfiguration configuration : mBroadcastConfigurations)
+        {
+            names.add(configuration.getName());
+        }
+
+        return names;
+    }
+
+    /**
+     * Current list of broadcastAudio configurations
+     */
+    public List<BroadcastConfiguration> getBroadcastConfigurations()
+    {
+        return mBroadcastConfigurations;
+    }
+
+    /**
+     * Adds the list of broadcastAudio configurations to this model
+     */
+    public void addBroadcastConfigurations(List<BroadcastConfiguration> configurations)
+    {
+        for(BroadcastConfiguration configuration : configurations)
+        {
+            addBroadcastConfiguration(configuration);
+        }
+    }
+
+    /**
+     * Adds the broadcastAudio configuration to this model
+     */
+    public void addBroadcastConfiguration(BroadcastConfiguration configuration)
+    {
+        if(configuration != null)
+        {
+            ensureUniqueName(configuration);
+
+            if(!mBroadcastConfigurations.contains(configuration))
+            {
+                mBroadcastConfigurations.add(configuration);
+
+                int index = mBroadcastConfigurations.size() - 1;
+
+                fireTableRowsInserted(index, index);
+
+                mBroadcastConfigurationMap.put(configuration.getName(), configuration);
+
+                process(new BroadcastEvent(configuration, BroadcastEvent.Event.CONFIGURATION_ADD));
+            }
+        }
+    }
+
+    /**
+     * Clones the configuration and adds it this model with a unique configuration name
+     */
+    public BroadcastConfiguration cloneBroadcastConfiguration(BroadcastConfiguration configuration)
+    {
+        if(configuration != null)
+        {
+            BroadcastConfiguration clone = configuration.copyOf();
+            addBroadcastConfiguration(clone);
+            return clone;
+        }
+
+        return null;
+    }
+
+    /**
+     * Updates the configuration's name so that it is unique among all other broadcast configurations
+     *
+     * @param configuration
+     */
+    private void ensureUniqueName(BroadcastConfiguration configuration)
+    {
+        if(configuration.getName() == null || configuration.getName().isEmpty())
+        {
+            configuration.setName("New Configuration");
+        }
+
+        while(!isUniqueName(configuration.getName(), configuration))
+        {
+            String currentName = configuration.getName();
+
+            if(currentName.matches(UNIQUE_NAME_REGEX))
+            {
+                int currentVersion = 1;
+
+                StringBuilder sb = new StringBuilder();
+                Matcher m = Pattern.compile(UNIQUE_NAME_REGEX).matcher(currentName);
+
+                if(m.find())
+                {
+                    String version = m.group(2);
+
+                    try
+                    {
+                        currentVersion = Integer.parseInt(version);
+                    }
+                    catch(Exception e)
+                    {
+                        //Couldn't parse the version number -- keep incrementing until we find a winner
+                    }
+
+                    currentVersion++;
+
+                    sb.append(m.group(1)).append("(").append(currentVersion).append(")");
+                }
+                else
+                {
+                    sb.append(configuration.getName()).append("(").append(currentVersion).append(")");
+                }
+
+                configuration.setName(sb.toString());
+            }
+            else
+            {
+                StringBuilder sb = new StringBuilder();
+                sb.append(configuration.getName()).append("(2)");
+                configuration.setName(sb.toString());
+            }
+        }
+
+    }
+
+    /**
+     * Indicates if the name is unique among all of the broadcast configurations.  Checks each of the configurations
+     * in this model for a name collision.  Assumes that the name argument will be assigned to the configuration
+     * argument if the name is unique, therefore, the name will not be checked against the configuration argument for
+     * a collision.
+     *
+     * @param name to check for uniqueness
+     * @param configuration to ignore when checking the name for uniqueness
+     * @return true if the name is not null and unique among all configurations managed by this model
+     */
+    public boolean isUniqueName(String name, BroadcastConfiguration configuration)
+    {
+        if(name == null || name.isEmpty())
+        {
+            return false;
+        }
+
+        for(BroadcastConfiguration configurationToCompare : mBroadcastConfigurations)
+        {
+            if(configurationToCompare != configuration &&
+                configurationToCompare.getName() != null &&
+                configurationToCompare.getName().equals(name))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public void removeBroadcastConfiguration(BroadcastConfiguration broadcastConfiguration)
+    {
+        if(broadcastConfiguration != null && mBroadcastConfigurations.contains(broadcastConfiguration))
+        {
+            int index = mBroadcastConfigurations.indexOf(broadcastConfiguration);
+
+            mBroadcastConfigurations.remove(broadcastConfiguration);
+
+            mBroadcastConfigurationMap.remove(broadcastConfiguration.getName());
+
+            process(new BroadcastEvent(broadcastConfiguration, BroadcastEvent.Event.CONFIGURATION_DELETE));
+
+            fireTableRowsDeleted(index, index);
+        }
+    }
+
+    /**
+     * Returns the broadcaster associated with the stream name or null if there is no broadcaster setup for the name.
+     */
+    public AudioBroadcaster getBroadcaster(String streamName)
+    {
+        return mBroadcasterMap.get(streamName);
+    }
+
+    @Override
+    public void receive(AudioPacket audioPacket)
+    {
+        if(audioPacket.hasMetadata() && audioPacket.getMetadata().isStreamable())
+        {
+            for(BroadcastChannel channel: audioPacket.getMetadata().getBroadcastChannels())
+            {
+                if(mBroadcasterMap.containsKey(channel.getChannelName()))
+                {
+                    mStreamManager.receive(audioPacket);
+                    return;
+                }
+            }
+        }
+    }
+
+    /**
+     * Creates a new broadcaster for the broadcast configuration and adds it to the model
+     */
+    private void createBroadcaster(BroadcastConfiguration broadcastConfiguration)
+    {
+        if(broadcastConfiguration != null && broadcastConfiguration.isEnabled() && broadcastConfiguration.isValid() &&
+            !mBroadcasterMap.containsKey(broadcastConfiguration.getName()))
+        {
+            AudioBroadcaster audioBroadcaster = BroadcastFactory.getBroadcaster(broadcastConfiguration);
+
+            if(audioBroadcaster != null)
+            {
+                audioBroadcaster.setListener(new Listener<BroadcastEvent>()
+                {
+                    @Override
+                    public void receive(BroadcastEvent broadcastEvent)
+                    {
+                        process(broadcastEvent);
+                    }
+                });
+
+                audioBroadcaster.start();
+
+                mBroadcasterMap.put(audioBroadcaster.getBroadcastConfiguration().getName(), audioBroadcaster);
+
+                int index = mBroadcastConfigurations.indexOf(audioBroadcaster.getBroadcastConfiguration());
+
+                if(index >= 0)
+                {
+                    fireTableRowsUpdated(index, index);
+                }
+
+                broadcast(new BroadcastEvent(audioBroadcaster, BroadcastEvent.Event.BROADCASTER_ADD));
+            }
+        }
+    }
+
+    /**
+     * Shut down a broadcaster created from the configuration and remove it from this model
+     */
+    private void deleteBroadcaster(String name)
+    {
+        if(name != null && mBroadcasterMap.containsKey(name))
+        {
+            AudioBroadcaster audioBroadcaster = mBroadcasterMap.remove(name);
+
+            if(audioBroadcaster != null)
+            {
+                audioBroadcaster.stop();
+                audioBroadcaster.removeListener();
+
+                int index = mBroadcastConfigurations.indexOf(audioBroadcaster.getBroadcastConfiguration());
+
+                if(index >= 0)
+                {
+                    fireTableRowsUpdated(index, index);
+                }
+
+                broadcast(new BroadcastEvent(audioBroadcaster, BroadcastEvent.Event.BROADCASTER_DELETE));
+            }
+        }
+    }
+
+    /**
+     * Returns the broadcast configuration identified by the stream name
+     */
+    public BroadcastConfiguration getBroadcastConfiguration(String streamName)
+    {
+        return mBroadcastConfigurationMap.get(streamName);
+    }
+
+    /**
+     * Registers the listener to receive broadcastAudio configuration events
+     */
+    public void addListener(Listener<BroadcastEvent> listener)
+    {
+        mBroadcastEventBroadcaster.addListener(listener);
+    }
+
+    /**
+     * Removes the listener from receiving broadcastAudio configuration events
+     */
+    public void removeListener(Listener<BroadcastEvent> listener)
+    {
+        mBroadcastEventBroadcaster.removeListener(listener);
+    }
+
+    /**
+     * Broadcasts the broadcastAudio configuration change event
+     */
+    private void broadcast(BroadcastEvent event)
+    {
+        mBroadcastEventBroadcaster.broadcast(event);
+    }
+
+    /**
+     * Process a broadcast event from one of the broadcasters managed by this model
+     */
+    public void process(BroadcastEvent broadcastEvent)
+    {
+        if(broadcastEvent.isBroadcastConfigurationEvent())
+        {
+            switch(broadcastEvent.getEvent())
+            {
+                case CONFIGURATION_ADD:
+                    createBroadcaster(broadcastEvent.getBroadcastConfiguration());
+                    break;
+                case CONFIGURATION_CHANGE:
+                    BroadcastConfiguration broadcastConfiguration = broadcastEvent.getBroadcastConfiguration();
+                    int index = mBroadcastConfigurations.indexOf(broadcastConfiguration);
+
+                    //Delete the existing broadcaster for any broadcast configuration changes
+                    String previousChannelName = cleanupMapAssociations(broadcastConfiguration);
+                    deleteBroadcaster(previousChannelName);
+
+                    //If the configuration is enabled, create a new broadcaster after a brief delay
+                    if(broadcastConfiguration.isEnabled())
+                    {
+                        //Delay restarting the broadcaster to allow remote server time to cleanup
+                        ThreadPool.SCHEDULED.schedule(new DelayedBroadcasterStartup(broadcastConfiguration),
+                            3, TimeUnit.SECONDS);
+                    }
+
+                    fireTableRowsUpdated(index, index);
+                    break;
+                case CONFIGURATION_DELETE:
+                    deleteBroadcaster(broadcastEvent.getBroadcastConfiguration().getName());
+                    break;
+            }
+        }
+        else if(broadcastEvent.isAudioBroadcasterEvent())
+        {
+            int row = mBroadcastConfigurations.indexOf(broadcastEvent.getAudioBroadcaster().getBroadcastConfiguration());
+
+            switch(broadcastEvent.getEvent())
+            {
+                case BROADCASTER_QUEUE_CHANGE:
+                    if(row >= 0)
+                    {
+                        fireTableCellUpdated(row, COLUMN_BROADCASTER_QUEUE_SIZE);
+                    }
+                    break;
+                case BROADCASTER_STATE_CHANGE:
+                    if(row >= 0)
+                    {
+                        fireTableCellUpdated(row, COLUMN_BROADCASTER_STATUS);
+                    }
+                    break;
+                case BROADCASTER_STREAMED_COUNT_CHANGE:
+                    if(row >= 0)
+                    {
+                        fireTableCellUpdated(row, COLUMN_BROADCASTER_STREAMED_COUNT);
+                    }
+                    break;
+                case BROADCASTER_AGED_OFF_COUNT_CHANGE:
+                    if(row >= 0)
+                    {
+                        fireTableCellUpdated(row, COLUMN_BROADCASTER_AGED_OFF_COUNT);
+                    }
+                    break;
+            }
+        }
+
+        //Rebroadcast the event to any listeners of this model
+        broadcast(broadcastEvent);
+    }
+
+    /**
+     * When the name of a broadcast configuration changes, remove the old map associations so that they can be replaced
+     * with the new map associations.  Remove any broadcaster that is associated with the old configuration name.
+     *
+     * @param broadcastConfiguration
+     * @return previous or current channel name that has been replaced with the current configuration channel name so
+     * that anything else associated with the previous name can be cleaned up.
+     */
+    private String cleanupMapAssociations(BroadcastConfiguration broadcastConfiguration)
+    {
+        String oldName = null;
+
+        for(Map.Entry<String,BroadcastConfiguration> entry : mBroadcastConfigurationMap.entrySet())
+        {
+            if(entry.getValue() == broadcastConfiguration)
+            {
+                oldName = entry.getKey();
+                continue;
+            }
+        }
+
+        if(oldName != null)
+        {
+            mBroadcastConfigurationMap.remove(oldName);
+        }
+
+        mBroadcastConfigurationMap.put(broadcastConfiguration.getName(), broadcastConfiguration);
+
+        return oldName;
+    }
+
+    @Override
+    public int getRowCount()
+    {
+        return mBroadcastConfigurations.size();
+    }
+
+    @Override
+    public int getColumnCount()
+    {
+        return COLUMN_NAMES.length;
+    }
+
+    @Override
+    public Object getValueAt(int rowIndex, int columnIndex)
+    {
+        try
+        {
+            if(rowIndex <= mBroadcastConfigurations.size())
+            {
+                BroadcastConfiguration configuration = mBroadcastConfigurations.get(rowIndex);
+
+                if(configuration != null)
+                {
+                    switch(columnIndex)
+                    {
+                        case COLUMN_SERVER_ICON:
+                            String iconPath = configuration.getBroadcastServerType().getIconPath();
+
+                            if(iconPath != null && mIconManager != null)
+                            {
+                                return mIconManager.getScaledIcon(new ImageIcon(iconPath), 14);
+                            }
+                            break;
+                        case COLUMN_STREAM_NAME:
+                            return configuration.getName();
+                        case COLUMN_BROADCASTER_STATUS:
+                            AudioBroadcaster audioBroadcasterA = mBroadcasterMap.get(configuration.getName());
+
+                            if(audioBroadcasterA != null)
+                            {
+                                return audioBroadcasterA.getBroadcastState();
+                            }
+                            else if(!configuration.isEnabled())
+                            {
+                                return BroadcastState.DISABLED;
+                            }
+                            else if(!configuration.isValid())
+                            {
+                                return BroadcastState.INVALID_SETTINGS;
+                            }
+                        case COLUMN_BROADCASTER_QUEUE_SIZE:
+                            AudioBroadcaster audioBroadcasterB = mBroadcasterMap.get(configuration.getName());
+
+                            if(audioBroadcasterB != null)
+                            {
+                                return audioBroadcasterB.getQueueSize();
+                            }
+                            break;
+                        case COLUMN_BROADCASTER_STREAMED_COUNT:
+                            AudioBroadcaster audioBroadcasterC = mBroadcasterMap.get(configuration.getName());
+
+                            if(audioBroadcasterC != null)
+                            {
+                                return audioBroadcasterC.getStreamedAudioCount();
+                            }
+                            break;
+                        case COLUMN_BROADCASTER_AGED_OFF_COUNT:
+                            AudioBroadcaster audioBroadcasterD = mBroadcasterMap.get(configuration.getName());
+
+                            if(audioBroadcasterD != null)
+                            {
+                                return audioBroadcasterD.getAgedOffAudioCount();
+                            }
+                            break;
+                        default:
+                            break;
+                    }
+                }
+            }
+        }
+        catch(Exception e)
+        {
+            mLog.error("Error accessing data in broadcast model", e);
+        }
+
+        return null;
+    }
+
+    @Override
+    public Class<?> getColumnClass(int columnIndex)
+    {
+        if(columnIndex == COLUMN_SERVER_ICON)
+        {
+            return ImageIcon.class;
+        }
+
+        return String.class;
+    }
+
+    /**
+     * Broadcast configuration at the specified model row
+     */
+    public BroadcastConfiguration getConfigurationAt(int rowIndex)
+    {
+        return mBroadcastConfigurations.get(rowIndex);
+    }
+
+    /**
+     * Model row number for the specified configuration
+     */
+    public int getRowForConfiguration(BroadcastConfiguration configuration)
+    {
+        return mBroadcastConfigurations.indexOf(configuration);
+    }
+
+    @Override
+    public String getColumnName(int column)
+    {
+        if(0 <= column && column < COLUMN_NAMES.length)
+        {
+            return COLUMN_NAMES[column];
+        }
+
+        return null;
+    }
+
+    /**
+     * Cleanup method to remove a temporary recording file from disk.
+     *
+     * @param recording to remove
+     */
+    private void removeRecording(AudioRecording recording)
+    {
+        try
+        {
+            Files.delete(recording.getPath());
+        }
+        catch(IOException ioe)
+        {
+            mLog.error("Error deleting temporary internet recording file: " + recording.getPath().toString() + " - " +
+                ioe.getMessage());
+        }
+    }
+
+
+    /**
+     * Removes any temporary stream recordings left-over from the previous application run.
+     *
+     * This should only be invoked on startup.
+     */
+    private void removeOrphanedTemporaryRecordings()
+    {
+        Path path = SystemProperties.getInstance().getApplicationFolder(BroadcastModel.TEMPORARY_STREAM_DIRECTORY);
+
+        if(path != null && Files.isDirectory(path))
+        {
+            StringBuilder sb = new StringBuilder();
+            sb.append(TEMPORARY_STREAM_FILE_SUFFIX);
+            sb.append("*.*");
+
+            try(DirectoryStream<Path> directoryStream = Files.newDirectoryStream(path, sb.toString()))
+            {
+                directoryStream.forEach(new Consumer<Path>()
+                {
+                    @Override
+                    public void accept(Path path)
+                    {
+                        try
+                        {
+                            Files.delete(path);
+                        }
+                        catch(IOException ioe)
+                        {
+                            mLog.error("Couldn't delete orphaned temporary recording: " + path.toString(), ioe);
+                        }
+                    }
+                });
+            }
+            catch(IOException ioe)
+            {
+                mLog.error("Error discovering orphaned temporary stream recording files", ioe);
+            }
+        }
+    }
+
+    /**
+     * Provides delayed startup of a broadcaster to allow for the remote server to complete a disconnection.
+     */
+    public class DelayedBroadcasterStartup implements Runnable
+    {
+        private BroadcastConfiguration mBroadcastConfiguration;
+
+        public DelayedBroadcasterStartup(BroadcastConfiguration configuration)
+        {
+            mBroadcastConfiguration = configuration;
+        }
+
+
+        @Override
+        public void run()
+        {
+            createBroadcaster(mBroadcastConfiguration);
+        }
+    }
+
+    /**
+     * Processes completed audio recordings and distributes them to the audio broadcasters.  Adds the recording to
+     * the audio recording queue to be monitored for deletion.
+     */
+    public class CompletedRecordingListener implements Listener<AudioRecording>
+    {
+        @Override
+        public void receive(AudioRecording audioRecording)
+        {
+            Metadata metadata = audioRecording.getMetadata();
+
+            if(metadata != null && metadata.isStreamable())
+            {
+                for(BroadcastChannel broadcastChannel : metadata.getBroadcastChannels())
+                {
+                    String channelName = broadcastChannel.getChannelName();
+
+                    if(channelName != null)
+                    {
+                        AudioBroadcaster audioBroadcaster = getBroadcaster(channelName);
+
+                        if(audioBroadcaster != null)
+                        {
+                            audioRecording.addPendingReplay();
+                            audioBroadcaster.receive(audioRecording);
+                        }
+                    }
+                }
+            }
+
+            mRecordingQueue.add(audioRecording);
+        }
+    }
+
+    /**
+     * Monitors the recording queue and removes any recordings that have no pending replays by audio broadcasters
+     */
+    public class RecordingDeletionMonitor implements Runnable
+    {
+        @Override
+        public void run()
+        {
+            try
+            {
+                List<AudioRecording> recordingsToDelete = new ArrayList<>();
+
+                Iterator<AudioRecording> it = mRecordingQueue.iterator();
+
+                AudioRecording recording;
+
+                while(it.hasNext())
+                {
+                    recording = it.next();
+
+                    if(!recording.hasPendingReplays())
+                    {
+                        recordingsToDelete.add(recording);
+                    }
+                }
+
+                if(!recordingsToDelete.isEmpty())
+                {
+                    for(AudioRecording recordingToDelete : recordingsToDelete)
+                    {
+                        mRecordingQueue.remove(recordingToDelete);
+                        removeRecording(recordingToDelete);
+                    }
+                }
+            }
+            catch(Exception e)
+            {
+                mLog.error("Error while checking audio recording queue for recordings to delete", e);
+            }
+        }
+    }
+}

src/main/java/audio/broadcast/BroadcastPanel.java

@@ -0,0 +1,260 @@
+/*******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2016 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 audio.broadcast;
+
+import alias.AliasModel;
+import com.jidesoft.swing.JideSplitPane;
+import gui.editor.Editor;
+import gui.editor.EmptyEditor;
+import icon.IconManager;
+import net.miginfocom.swing.MigLayout;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import settings.SettingsManager;
+
+import javax.swing.*;
+import javax.swing.event.ListSelectionEvent;
+import javax.swing.event.ListSelectionListener;
+import javax.swing.table.DefaultTableCellRenderer;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+
+public class BroadcastPanel extends JPanel implements ActionListener, ListSelectionListener
+{
+    private final static Logger mLog = LoggerFactory.getLogger( BroadcastPanel.class );
+
+    private static final String NEW_BROADCAST_CONFIGURATION = "New";
+    private static final String COPY_BROADCAST_CONFIGURATION = "Copy";
+    private static final String DELETE_BROADCAST_CONFIGURATION = "Delete";
+
+    private BroadcastModel mBroadcastModel;
+    private AliasModel mAliasModel;
+    private IconManager mIconManager;
+
+    private BroadcastStatusPanel mBroadcastStatusPanel;
+    private JideSplitPane mSplitPane;
+    private Editor<BroadcastConfiguration> mEmptyEditor = new EmptyEditor<>("Configuration:");
+    private Editor<BroadcastConfiguration> mEditor;
+    private JButton mNewButton = new JButton(NEW_BROADCAST_CONFIGURATION);
+    private JButton mCopyButton = new JButton(COPY_BROADCAST_CONFIGURATION);
+    private JButton mDeleteButton = new JButton(DELETE_BROADCAST_CONFIGURATION);
+
+    public BroadcastPanel(BroadcastModel broadcastModel, AliasModel aliasModel, IconManager iconManager)
+    {
+        mBroadcastModel = broadcastModel;
+        mAliasModel = aliasModel;
+        mIconManager = iconManager;
+        mEditor = mEmptyEditor;
+
+        init();
+    }
+
+    private void init()
+    {
+        setLayout(new MigLayout("insets 0 0 0 0 ", "[grow,fill]", "[grow,fill]"));
+
+        mBroadcastStatusPanel = new BroadcastStatusPanel(mBroadcastModel);
+
+        mBroadcastStatusPanel.getTable().setAutoCreateRowSorter(true);
+        mBroadcastStatusPanel.getTable().setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+        mBroadcastStatusPanel.getTable().getSelectionModel().addListSelectionListener(BroadcastPanel.this);
+
+        JPanel buttonsPanel = new JPanel();
+        buttonsPanel.setLayout(new MigLayout("insets 0 0 0 0", "[grow,fill][grow,fill][grow,fill]", "[]"));
+
+        mNewButton = new JButton("New ...");
+        mNewButton.setToolTipText("Create a new broadcast audio configuration");
+        mNewButton.addMouseListener(new MouseAdapter()
+        {
+            @Override
+            public void mouseClicked(MouseEvent e)
+            {
+                JPopupMenu menu = new JPopupMenu();
+
+                menu.add(new AddBroadcastConfigurationItem(BroadcastServerType.BROADCASTIFY));
+                menu.add(new AddBroadcastConfigurationItem(BroadcastServerType.ICECAST_TCP));
+                menu.add(new AddBroadcastConfigurationItem(BroadcastServerType.ICECAST_HTTP));
+                menu.add(new AddBroadcastConfigurationItem(BroadcastServerType.SHOUTCAST_V1));
+                menu.add(new AddBroadcastConfigurationItem(BroadcastServerType.SHOUTCAST_V2));
+
+                menu.show(e.getComponent(), e.getX(), e.getY());
+            }
+        });
+
+        buttonsPanel.add(mNewButton);
+
+        mCopyButton.addActionListener(this);
+        mCopyButton.setEnabled(false);
+        mCopyButton.setToolTipText("Creates a copy of the currently selected streaming configuration and adds it");
+        buttonsPanel.add(mCopyButton);
+
+        mDeleteButton.addActionListener(this);
+        mDeleteButton.setEnabled(false);
+        mDeleteButton.setToolTipText("Deletes the currently selected streaming configuration");
+        buttonsPanel.add(mDeleteButton);
+
+        JPanel listAndButtonsPanel = new JPanel();
+
+        listAndButtonsPanel.setLayout(new MigLayout("insets 0 0 0 0", "[grow,fill]", "[grow,fill][]"));
+
+        listAndButtonsPanel.add(mBroadcastStatusPanel, "wrap");
+        listAndButtonsPanel.add(buttonsPanel);
+
+        mSplitPane = new JideSplitPane(JideSplitPane.HORIZONTAL_SPLIT);
+        mSplitPane.setDividerSize(5);
+        mSplitPane.setShowGripper(true);
+        mSplitPane.add(listAndButtonsPanel);
+
+        mSplitPane.add(mEditor);
+
+        add(mSplitPane);
+    }
+
+    @Override
+    public void actionPerformed(ActionEvent e)
+    {
+        switch(e.getActionCommand())
+        {
+            case COPY_BROADCAST_CONFIGURATION:
+                BroadcastConfiguration copySelected = getSelectedBroadcastConfiguration();
+                mBroadcastModel.cloneBroadcastConfiguration(copySelected);
+                break;
+            case DELETE_BROADCAST_CONFIGURATION:
+                BroadcastConfiguration deleteSelected = getSelectedBroadcastConfiguration();
+
+                if(deleteSelected != null)
+                {
+                    int choice = JOptionPane.showConfirmDialog(BroadcastPanel.this, "Do you want to delete broadcast\n" +
+                            " configuration " + deleteSelected.getName() + "?", "Delete Broadcast Configuration?",
+                            JOptionPane.YES_NO_OPTION);
+
+                    if(choice == JOptionPane.YES_OPTION)
+                    {
+                        mBroadcastModel.removeBroadcastConfiguration(deleteSelected);
+                    }
+                }
+                break;
+        }
+
+    }
+
+    /**
+     * Returns the selected configuration
+     */
+    private BroadcastConfiguration getSelectedBroadcastConfiguration()
+    {
+        int viewRow = mBroadcastStatusPanel.getTable().getSelectedRow();
+
+        if(viewRow >= 0)
+        {
+            int modelRow = mBroadcastStatusPanel.getTable().convertRowIndexToModel(viewRow);
+
+            if(modelRow >= 0)
+            {
+                return mBroadcastModel.getConfigurationAt(modelRow);
+            }
+        }
+
+        return null;
+    }
+
+
+    @Override
+    public void valueChanged(ListSelectionEvent e)
+    {
+        if (!e.getValueIsAdjusting())
+        {
+            BroadcastConfiguration selectedConfiguration = getSelectedBroadcastConfiguration();
+
+            //Enable buttons accordingly
+            mCopyButton.setEnabled(selectedConfiguration != null);
+            mDeleteButton.setEnabled(selectedConfiguration != null);
+
+            if (mEditor.isModified())
+            {
+                int option = JOptionPane.showConfirmDialog(
+                        BroadcastPanel.this,
+                        "Configuration settings have changed.  Do you want to save these changes?",
+                        "Save Changes?",
+                        JOptionPane.YES_NO_OPTION,
+                        JOptionPane.QUESTION_MESSAGE);
+
+                if (option == JOptionPane.YES_OPTION)
+                {
+                    mEditor.save();
+                }
+            }
+
+            mSplitPane.removePane(mEditor);
+
+            if (selectedConfiguration != null)
+            {
+                mEditor = BroadcastFactory.getEditor(selectedConfiguration, mBroadcastModel, mAliasModel,
+                    mIconManager);
+            }
+            else
+            {
+                mEditor = mEmptyEditor;
+            }
+
+            mSplitPane.add(mEditor);
+
+            revalidate();
+        }
+    }
+
+    public class AddBroadcastConfigurationItem extends JMenuItem
+    {
+        private static final long serialVersionUID = 1L;
+
+        private BroadcastServerType mBroadcastServerType;
+
+        public AddBroadcastConfigurationItem(BroadcastServerType type)
+        {
+            super(type.toString(), mIconManager.getScaledIcon(new ImageIcon(type.getIconPath()), 14));
+
+            mBroadcastServerType = type;
+
+            setToolTipText("Add a new " + type.toString() + " audio stream configuration");
+
+            addActionListener(new ActionListener()
+            {
+                @Override
+                public void actionPerformed(ActionEvent e)
+                {
+                    final BroadcastConfiguration configuration =
+                            BroadcastFactory.getConfiguration(mBroadcastServerType, BroadcastFormat.MP3);
+
+                    if(configuration != null)
+                    {
+                        mBroadcastModel.addBroadcastConfiguration(configuration);
+
+                        int modelRow = mBroadcastModel.getRowForConfiguration(configuration);
+                        int tableRow = mBroadcastStatusPanel.getTable().convertRowIndexToView(modelRow);
+                        mBroadcastStatusPanel.getTable().changeSelection(tableRow, 0, false, false);
+                    }
+                }
+            });
+        }
+    }
+
+}

src/main/java/audio/broadcast/BroadcastServerType.java

@@ -0,0 +1,48 @@
+/*******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2016 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 audio.broadcast;
+
+public enum BroadcastServerType
+{
+    BROADCASTIFY("Broadcastify", "images/broadcastify.png"), //Icecast Server 2.3.2
+    ICECAST_HTTP("Icecast 2 (v2.4+)", "images/icecast.png"),
+    ICECAST_TCP("Icecast (v2.3)", "images/icecast.png"),
+    SHOUTCAST_V1("Shoutcast v1.x", "images/shoutcast.png"),
+    SHOUTCAST_V2("Shoutcast v2.x", "images/shoutcast.png"),
+    UNKNOWN("Unknown", null);
+
+    private String mLabel;
+    private String mIconPath;
+
+    BroadcastServerType(String label, String iconPath)
+    {
+        mLabel = label;
+        mIconPath = iconPath;
+    }
+
+    public String toString()
+    {
+        return mLabel;
+    }
+
+    public String getIconPath()
+    {
+        return mIconPath;
+    }
+}

src/main/java/audio/broadcast/BroadcastState.java

@@ -0,0 +1,116 @@
+/*******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2016 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 audio.broadcast;
+
+public enum BroadcastState
+{
+    /**
+     * General error in configuration that causes the remote server to reject the connection
+     */
+    CONFIGURATION_ERROR("Configuration Error", true),
+
+    /**
+     * Connected to the broadcastAudio server and capable of streaming
+     */
+    CONNECTED("Connected", false),
+
+    /**
+     * Connection interrupted, attempting to reconnect.
+     */
+    CONNECTING("Connecting", false),
+
+    /**
+     * Indicates the configuration is disabled
+     */
+    DISABLED("Disabled", true),
+
+    /**
+     * Disconnected from the broadcastAudio server
+     */
+    DISCONNECTED("Disconnected", false),
+
+    /**
+     * Invalid credentials - user name or password
+     */
+    INVALID_CREDENTIALS("Invalid User Name/Password", true),
+
+    /**
+     * Invalid mount point
+     */
+    INVALID_MOUNT_POINT("Invalid Mount/Stream ID", true),
+
+    /**
+     * Invalid configuration settings
+     */
+    INVALID_SETTINGS("Invalid Settings", true),
+
+    /**
+     * Remote server max sources has been exceeded
+     */
+    MAX_SOURCES_EXCEEDED("Max Sources Exceeded", true),
+
+    /**
+     * Specified mount point is already in use
+     */
+    MOUNT_POINT_IN_USE("Mount Point In Use", false),
+
+    /**
+     * Server is not known or reachable
+     */
+    NO_SERVER("No Server", false),
+
+    /**
+     * Initial state with no connection attempted.
+     */
+    READY("Ready", false),
+
+    /**
+     * Error while broadcasting stream data.  Temporary error state to allow connection to be reset.
+     */
+    TEMPORARY_BROADCAST_ERROR("Temporary Broadcast Error", false),
+
+    /**
+     * Unsupported audio format
+     */
+    UNSUPPORTED_AUDIO_FORMAT("Unsupported Audio Type", true),
+
+    /**
+     * Unspecified error
+     */
+    ERROR("Error", true);
+
+    private String mLabel;
+    private boolean mErrorState;
+
+    private BroadcastState(String label, boolean connected)
+    {
+        mLabel = label;
+        mErrorState = connected;
+    }
+
+    public String toString()
+    {
+        return mLabel;
+    }
+
+    public boolean isErrorState()
+    {
+        return mErrorState;
+    }
+}

src/main/java/audio/broadcast/BroadcastStatusPanel.java

@@ -0,0 +1,125 @@
+/*******************************************************************************
+ * 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 audio.broadcast;
+
+import net.miginfocom.swing.MigLayout;
+
+import javax.swing.*;
+import javax.swing.table.DefaultTableCellRenderer;
+import java.awt.*;
+
+public class BroadcastStatusPanel extends JPanel
+{
+    private JTable mTable;
+    private JScrollPane mScrollPane;
+    private BroadcastModel mBroadcastModel;
+
+    public BroadcastStatusPanel(BroadcastModel broadcastModel)
+    {
+        mBroadcastModel = broadcastModel;
+
+        init();
+    }
+
+    public JTable getTable()
+    {
+        return mTable;
+    }
+
+    private void init()
+    {
+        setLayout(new MigLayout("insets 0 0 0 0 ", "[grow,fill]", "[grow,fill]"));
+
+        mTable = new JTable(mBroadcastModel);
+
+        DefaultTableCellRenderer renderer = (DefaultTableCellRenderer)mTable.getDefaultRenderer(String.class);
+        renderer.setHorizontalAlignment(SwingConstants.CENTER);
+
+        mTable.getColumnModel().getColumn(BroadcastModel.COLUMN_BROADCASTER_STATUS).setCellRenderer(new StatusCellRenderer());
+
+        mScrollPane = new JScrollPane(mTable);
+
+        add(mScrollPane);
+    }
+
+    /**
+     * Custom cell renderer for the broadcast state column.
+     */
+    public class StatusCellRenderer extends DefaultTableCellRenderer
+    {
+        public StatusCellRenderer()
+        {
+            setOpaque(true);
+            setHorizontalAlignment(SwingConstants.CENTER);
+        }
+
+        @Override
+        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected,
+                                                       boolean hasFocus, int row, int column)
+        {
+            JLabel component = (JLabel)super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
+
+            if(isSelected)
+            {
+                setBackground(table.getSelectionBackground());
+                setForeground(table.getSelectionForeground());
+            }
+            else
+            {
+                if(value instanceof BroadcastState)
+                {
+                    BroadcastState state = (BroadcastState)value;
+
+                    if(state == BroadcastState.CONNECTED)
+                    {
+                        setBackground(Color.GREEN);
+                        setForeground(table.getForeground());
+                    }
+                    else if(state == BroadcastState.DISABLED)
+                    {
+                        setBackground(table.getBackground());
+                        setForeground(Color.LIGHT_GRAY);
+                    }
+                    else if(state == BroadcastState.INVALID_SETTINGS)
+                    {
+                        setBackground(Color.YELLOW);
+                        setForeground(table.getForeground());
+                    }
+                    else if(state.isErrorState())
+                    {
+                        setBackground(Color.RED);
+                        setForeground(table.getForeground());
+                    }
+                    else
+                    {
+                        setBackground(table.getBackground());
+                        setForeground(table.getForeground());
+                    }
+                }
+                else
+                {
+                    setForeground(table.getForeground());
+                    setBackground(table.getBackground());
+                }
+            }
+
+            return this;
+        }
+    }
+}

src/main/java/audio/broadcast/IBroadcastMetadataUpdater.java

@@ -0,0 +1,31 @@
+/*******************************************************************************
+ * 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 audio.broadcast;
+
+import channel.metadata.Metadata;
+
+public interface IBroadcastMetadataUpdater
+{
+    /**
+     * Updates broadcast audio metadata
+     *
+     * @param metadata containing metadata attributes
+     */
+    void update(Metadata metadata);
+}

src/main/java/audio/broadcast/StreamManager.java

@@ -0,0 +1,233 @@
+/*******************************************************************************
+ * 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 audio.broadcast;
+
+import audio.AudioPacket;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import record.AudioRecorder;
+import sample.Listener;
+import util.ThreadPool;
+import util.TimeStamp;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class StreamManager implements Listener<AudioPacket>
+{
+    private final static Logger mLog = LoggerFactory.getLogger(StreamManager.class);
+    private static final long MAXIMUM_RECORDER_LIFESPAN_MILLIS = 30000; //30 seconds
+
+    private static AtomicInteger sNextRecordingNumber = new AtomicInteger();
+
+    private Listener<AudioRecording> mAudioRecordingListener;
+    private BroadcastFormat mBroadcastFormat;
+    private Path mTempDirectory;
+    private Map<Integer,AudioRecorder> mStreamRecorders = new HashMap<>();
+    private Runnable mRecorderMonitor;
+    private ScheduledFuture<?> mRecorderMonitorFuture;
+    private AtomicBoolean mRunning = new AtomicBoolean();
+
+    /**
+     * Stream manager processes all incoming audio packets and reassembles individual audio streams, converts audio
+     * to desired output format and persists each stream to disc.  Each recording is capped at a maximum length to
+     * ensure that recordings don't run too long before they are streamed out and to ensure that inactive recordings
+     * are closed in a timely fashion.
+     *
+     * Completed streamable audio recordings are nominated to the output listener (for broadcast) upon completion
+     *
+     * @param listener to receive completed audio recordings
+     * @param tempDirectory where to store temporary audio recordings
+     */
+    public StreamManager(Listener<AudioRecording> listener, BroadcastFormat broadcastFormat, Path tempDirectory)
+    {
+        assert (tempDirectory != null && Files.isDirectory(tempDirectory));
+
+        mAudioRecordingListener = listener;
+        mBroadcastFormat = broadcastFormat;
+        mTempDirectory = tempDirectory;
+    }
+
+    /**
+     * Starts the stream manager.  Schedules a processor to monitor for inactive temporary stream recorders
+     * every 2 seconds.
+     */
+    public void start()
+    {
+        if(mRunning.compareAndSet(false, true))
+        {
+            if(mRecorderMonitor == null)
+            {
+                mRecorderMonitor = new RecorderMonitor();
+            }
+
+            mRecorderMonitorFuture = ThreadPool.SCHEDULED.scheduleAtFixedRate(mRecorderMonitor,
+                0,2, TimeUnit.SECONDS);
+        }
+    }
+
+    /**
+     * Stops the stream manager.  Stops the inactive temporary stream recorder monitoring thread.
+     */
+    public void stop()
+    {
+        if(mRunning.compareAndSet(true, false))
+        {
+            if(mRecorderMonitorFuture != null)
+            {
+                mRecorderMonitorFuture.cancel(true);
+            }
+
+            synchronized(mStreamRecorders)
+            {
+                List<Integer> streamKeys = new ArrayList<>(mStreamRecorders.keySet());
+
+                for(Integer streamKey : streamKeys)
+                {
+                    removeRecorder(streamKey);
+                }
+            }
+        }
+    }
+
+    @Override
+    public void receive(AudioPacket audioPacket)
+    {
+        if(mRunning.get() && audioPacket.hasMetadata())
+        {
+            synchronized(mStreamRecorders)
+            {
+                int channelMetadataID = audioPacket.getMetadata().getMetadataID();
+
+                AudioPacket.Type type = audioPacket.getType();
+
+                if(type == AudioPacket.Type.AUDIO)
+                {
+                    if(mStreamRecorders.containsKey(channelMetadataID))
+                    {
+                        AudioRecorder recorder = mStreamRecorders.get(channelMetadataID);
+
+                        if(recorder != null)
+                        {
+                            recorder.receive(audioPacket);
+                        }
+                    }
+                    else
+                    {
+                        AudioRecorder recorder = BroadcastFactory.getAudioRecorder(getTemporaryRecordingPath(),
+                            mBroadcastFormat);
+                        recorder.start(ThreadPool.SCHEDULED);
+                        recorder.receive(audioPacket);
+                        mStreamRecorders.put(channelMetadataID, recorder);
+                    }
+                }
+                else if(type == AudioPacket.Type.END)
+                {
+                    removeRecorder(channelMetadataID);
+                }
+                else
+                {
+                    mLog.info("Unrecognized Audio Packet Type: " + type);
+                }
+            }
+        }
+    }
+
+    /**
+     * Removes the recorder associated with the source channel ID.
+     *
+     * Note: this method invocation is not thread safe and must be invoked by a thread safe mechanism that protects the
+     * mStreamRecorders map.
+     *
+     * @param sourceChannelID identifying the recorder
+     */
+    private void removeRecorder(Integer sourceChannelID)
+    {
+        if(mStreamRecorders.containsKey(sourceChannelID))
+        {
+            AudioRecorder recorder = mStreamRecorders.remove(sourceChannelID);
+
+            recorder.close(new Listener<AudioRecorder>()
+            {
+                @Override
+                public void receive(AudioRecorder audioRecorder)
+                {
+                    AudioRecording audioRecording =
+                        new AudioRecording(audioRecorder.getPath(), audioRecorder.getMetadata(),
+                            audioRecorder.getTimeRecordingStart(), audioRecorder.getRecordingLength());
+
+                    if(mAudioRecordingListener != null)
+                    {
+                        mAudioRecordingListener.receive(audioRecording);
+                    }
+                }
+            });
+
+        }
+    }
+
+    /**
+     * Creates a temporary streaming recording file path
+     */
+    private Path getTemporaryRecordingPath()
+    {
+        StringBuilder sb = new StringBuilder();
+        sb.append(BroadcastModel.TEMPORARY_STREAM_FILE_SUFFIX);
+        sb.append(sNextRecordingNumber.incrementAndGet()).append("_");
+        sb.append(TimeStamp.getLongTimeStamp("_"));
+        sb.append(mBroadcastFormat.getFileExtension());
+
+        Path temporaryRecordingPath = mTempDirectory.resolve(sb.toString());
+
+        return temporaryRecordingPath;
+    }
+
+    /**
+     * Monitors recorders to ensure they don't exceed the maximum life-span allowed for a recording.
+     */
+    public class RecorderMonitor implements Runnable
+    {
+        @Override
+        public void run()
+        {
+            synchronized(mStreamRecorders)
+            {
+                long now = System.currentTimeMillis();
+
+                mStreamRecorders.entrySet().stream()
+                    .filter(entry -> entry.getValue().getTimeRecordingStart() + MAXIMUM_RECORDER_LIFESPAN_MILLIS < now)
+                    .forEach(entry ->
+                    {
+                        mLog.info("cycling recorder - max temporary streaming recording time limit reached [" +
+                            entry.getValue().getPath().toString() + "]");
+
+                        removeRecorder(entry.getKey());
+                    });
+            }
+        }
+    }
+}

src/main/java/audio/broadcast/broadcastify/BroadcastifyConfiguration.java

@@ -0,0 +1,96 @@
+/*******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2016 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 audio.broadcast.broadcastify;
+
+import audio.broadcast.BroadcastConfiguration;
+import audio.broadcast.BroadcastFormat;
+import audio.broadcast.BroadcastServerType;
+import audio.broadcast.icecast.IcecastTCPConfiguration;
+
+import javax.xml.bind.annotation.XmlAttribute;
+
+public class BroadcastifyConfiguration extends IcecastTCPConfiguration
+{
+    private int mFeedID;
+
+    public BroadcastifyConfiguration()
+    {
+        //No-arg constructor for JAXB
+        this(BroadcastFormat.MP3);
+    }
+
+    /**
+     * Broadcastify configuration for Icecast 2.3.2 compatible servers
+     *
+     * @param format of output audio (MP3)
+     */
+    public BroadcastifyConfiguration(BroadcastFormat format)
+    {
+        super(format);
+
+        setBitRate(16);
+        setChannels(1);
+        setSampleRate(8000);
+    }
+
+    @Override
+    public BroadcastConfiguration copyOf()
+    {
+        BroadcastifyConfiguration copy = new BroadcastifyConfiguration(getBroadcastFormat());
+
+        //Broadcast Configuration Parameters
+        copy.setName(getName());
+        copy.setHost(getHost());
+        copy.setPort(getPort());
+        copy.setPassword(getPassword());
+        copy.setDelay(getDelay());
+
+        copy.setEnabled(false);
+
+        //Icecast Configuration Parameters
+        copy.setUserName(getUserName());
+        copy.setMountPoint(getMountPoint());
+        copy.setDescription(getDescription());
+        copy.setGenre(getGenre());
+        copy.setPublic(isPublic());
+        copy.setURL(getURL());
+
+        //Broadcastify Configuration Parameters
+        copy.setFeedID(getFeedID());
+
+        return copy;
+    }
+
+    @Override
+    public BroadcastServerType getBroadcastServerType()
+    {
+        return BroadcastServerType.BROADCASTIFY;
+    }
+
+    @XmlAttribute(name="feed_id")
+    public int getFeedID()
+    {
+        return mFeedID;
+    }
+
+    public void setFeedID(int feedID)
+    {
+        mFeedID = feedID;
+    }
+}

src/main/java/audio/broadcast/broadcastify/BroadcastifyConfigurationEditor.java

@@ -0,0 +1,395 @@
+/*******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2016 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 audio.broadcast.broadcastify;
+
+import alias.AliasModel;
+import audio.broadcast.BroadcastConfiguration;
+import audio.broadcast.BroadcastConfigurationEditor;
+import audio.broadcast.BroadcastEvent;
+import audio.broadcast.BroadcastModel;
+import audio.broadcast.BroadcastServerType;
+import com.radioreference.api.soap2.UserFeedBroadcast;
+import icon.IconManager;
+import net.miginfocom.swing.MigLayout;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import sample.Listener;
+
+import javax.swing.*;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+public class BroadcastifyConfigurationEditor extends BroadcastConfigurationEditor implements Listener<UserFeedBroadcast>
+{
+    private final static Logger mLog = LoggerFactory.getLogger(BroadcastifyConfigurationEditor.class);
+
+    private static final int ONE_MINUTE_MS = 60000;
+
+    private JTextField mName;
+    private JTextField mServer;
+    private JTextField mPort;
+    private JTextField mMountPoint;
+    private JTextField mPassword;
+    private JTextField mFeedID;
+    private JSlider mDelay;
+    private JLabel mDelayValue;
+    private JSlider mMaximumRecordingAge;
+    private JLabel mMaximumRecordingAgeValue;
+    private JCheckBox mEnabled;
+    private JButton mSaveButton;
+    private JButton mResetButton;
+
+    public BroadcastifyConfigurationEditor(BroadcastModel broadcastModel, AliasModel aliasModel, IconManager iconManager)
+    {
+        super(broadcastModel, aliasModel, iconManager);
+
+        init();
+    }
+
+    private void init()
+    {
+        setLayout(new MigLayout("fill,wrap 2", "[align right][grow,fill]",
+            "[][][][][][][][][][][][][][][grow,fill]"));
+        setPreferredSize(new Dimension(150, 400));
+
+
+        JLabel channelLabel = new JLabel("Broadcastify Stream");
+
+        ImageIcon broadcastifyIcon = mIconManager.getScaledIcon(
+            new ImageIcon(BroadcastServerType.BROADCASTIFY.getIconPath()), 25);
+        channelLabel.setIcon(broadcastifyIcon);
+        add(channelLabel, "span, align center");
+
+        JButton lookupButton = new JButton("Lookup ...");
+        lookupButton.addActionListener(new ActionListener()
+        {
+            @Override
+            public void actionPerformed(ActionEvent e)
+            {
+                final UserFeedSelectionDialog dialog = new UserFeedSelectionDialog(BroadcastifyConfigurationEditor.this);
+
+                EventQueue.invokeLater(new Runnable()
+                {
+                    @Override
+                    public void run()
+                    {
+                        dialog.setLocationRelativeTo(BroadcastifyConfigurationEditor.this);
+                        dialog.setVisible(true);
+                    }
+                });
+            }
+        });
+
+        add(new JLabel(""));
+        add(lookupButton, "grow,wrap");
+
+        add(new JLabel("Name:"));
+        mName = new JTextField();
+        mName.getDocument().addDocumentListener(this);
+        mName.setToolTipText("Unique name for this stream");
+        add(mName);
+
+        add(new JLabel("Server:"));
+        mServer = new JTextField();
+        mServer.getDocument().addDocumentListener(this);
+        mServer.setToolTipText("Server address (e.g. audio3.broadcastify.com). See MyBCFY feed details, Technicals tab");
+        add(mServer);
+
+        add(new JLabel("Port:"));
+        mPort = new JTextField();
+        mPort.getDocument().addDocumentListener(this);
+        mPort.setToolTipText("Server port number (e.g. 80). See MyBCFY feed details, Technicals tab");
+        add(mPort);
+
+        add(new JLabel("Mount:"));
+        mMountPoint = new JTextField();
+        mMountPoint.getDocument().addDocumentListener(this);
+        mMountPoint.setToolTipText("Mount point (e.g. \\awlkejrlkjsd). See MyBCFY feed details, Technicals tab");
+        add(mMountPoint);
+
+        add(new JLabel("Password:"));
+        mPassword = new JTextField();
+        mPassword.getDocument().addDocumentListener(this);
+        mPassword.setToolTipText("Password. See MyBCFY feed details, Technicals tab");
+        add(mPassword);
+
+        add(new JLabel("Feed ID:"));
+        mFeedID = new JTextField();
+        mFeedID.getDocument().addDocumentListener(this);
+        mFeedID.setToolTipText("Feed ID (optional). See MyBCFY feed details");
+        add(mFeedID);
+
+
+        add(new JLabel());
+        mDelayValue = new JLabel("0 Minutes");
+        add(mDelayValue);
+
+        add(new JLabel("Delay:"));
+        mDelay = new JSlider(0, 60, 0);
+        mDelay.setMajorTickSpacing(10);
+        mDelay.setMinorTickSpacing(5);
+        mDelay.addChangeListener(new ChangeListener()
+        {
+            @Override
+            public void stateChanged(ChangeEvent e)
+            {
+                mDelayValue.setText(mDelay.getValue() + " Minutes");
+                setModified(true);
+            }
+        });
+        mDelay.setToolTipText("Audio broadcast delay in minutes");
+        add(mDelay);
+
+        add(new JLabel());
+        mMaximumRecordingAgeValue = new JLabel("1 Minute");
+        add(mMaximumRecordingAgeValue);
+
+        add(new JLabel("Age Limit:"));
+        mMaximumRecordingAge = new JSlider(1,60,5);
+        mMaximumRecordingAge.setMajorTickSpacing(10);
+        mMaximumRecordingAge.setMinorTickSpacing(5);
+        mMaximumRecordingAge.addChangeListener(new ChangeListener()
+        {
+            @Override
+            public void stateChanged(ChangeEvent e)
+            {
+                int value = mMaximumRecordingAge.getValue();
+
+                mMaximumRecordingAgeValue.setText(value + " Minute" + (value > 1 ? "s" : ""));
+                setModified(true);
+            }
+        });
+        mMaximumRecordingAge.setToolTipText("Maximum recording age (in addition to delay) to stream");
+        add(mMaximumRecordingAge);
+
+        mEnabled = new JCheckBox("Enabled");
+        mEnabled.setToolTipText("Enable (checked) or disable this stream");
+        mEnabled.addActionListener(new ActionListener()
+        {
+            @Override
+            public void actionPerformed(ActionEvent e)
+            {
+                setModified(true);
+            }
+        });
+        add(new JLabel());
+        add(mEnabled);
+
+        mSaveButton = new JButton("Save");
+        mSaveButton.setEnabled(false);
+        mSaveButton.setToolTipText("Click to save configuration information");
+        mSaveButton.addActionListener(new ActionListener()
+        {
+            @Override
+            public void actionPerformed(ActionEvent e)
+            {
+                save();
+            }
+        });
+        add(mSaveButton);
+
+        mResetButton = new JButton("Reset");
+        mResetButton.setEnabled(false);
+        mResetButton.setToolTipText("Click to reset any changes you've made\n since the last save");
+        mResetButton.addActionListener(new ActionListener()
+        {
+            @Override
+            public void actionPerformed(ActionEvent e)
+            {
+                setModified(false);
+                setItem(getItem());
+            }
+        });
+        add(mResetButton);
+    }
+
+    @Override
+    public void setModified(boolean modified)
+    {
+        super.setModified(modified);
+
+        mSaveButton.setEnabled(modified);
+        mResetButton.setEnabled(modified);
+    }
+
+    @Override
+    public void setItem(BroadcastConfiguration item)
+    {
+        super.setItem(item);
+
+        if(hasItem())
+        {
+            BroadcastifyConfiguration config = (BroadcastifyConfiguration) getItem();
+
+            mName.setText(config.getName());
+            mServer.setText(config.getHost());
+            mPort.setText(config.getPort() != 0 ? String.valueOf(config.getPort()) : null);
+            mMountPoint.setText(config.getMountPoint());
+            mPassword.setText(config.getPassword());
+            mFeedID.setText(String.valueOf(config.getFeedID()));
+            mDelay.setValue((int) (config.getDelay() / ONE_MINUTE_MS));
+            mMaximumRecordingAge.setValue((int)config.getMaximumRecordingAge() / ONE_MINUTE_MS);
+            mEnabled.setSelected(config.isEnabled());
+        }
+        else
+        {
+            mName.setText(null);
+            mServer.setText(null);
+            mPort.setText(null);
+            mMountPoint.setText(null);
+            mPassword.setText(null);
+            mFeedID.setText(null);
+            mDelay.setValue(0);
+            mMaximumRecordingAge.setValue(1);
+            mEnabled.setSelected(false);
+        }
+
+        setModified(false);
+    }
+
+    @Override
+    public void save()
+    {
+        BroadcastifyConfiguration config = (BroadcastifyConfiguration) getItem();
+
+        if(validateConfiguration())
+        {
+            updateConfigurationName(config, mName.getText());
+            config.setHost(mServer.getText());
+            config.setPort(getPort());
+            config.setMountPoint(mMountPoint.getText());
+            config.setPassword(mPassword.getText());
+            config.setFeedID(getFeedID());
+            config.setDelay(mDelay.getValue() * ONE_MINUTE_MS);
+            config.setMaximumRecordingAge(mMaximumRecordingAge.getValue() * ONE_MINUTE_MS);
+            config.setEnabled(mEnabled.isSelected());
+
+            setModified(false);
+
+            mBroadcastModel.process(new BroadcastEvent(getItem(), BroadcastEvent.Event.CONFIGURATION_CHANGE));
+        }
+    }
+
+    /**
+     * Validates the user specified values in the controls prior to saving them to the configuration
+     */
+    private boolean validateConfiguration()
+    {
+        String name = mName.getText();
+
+        //A unique stream name is required
+        if(!mBroadcastModel.isUniqueName(name, getItem()))
+        {
+            String message = (name == null || name.isEmpty()) ?
+                "Please specify a stream name." : "Stream name " + name +
+                "is already in use.\nPlease choose another name.";
+
+            JOptionPane.showMessageDialog(BroadcastifyConfigurationEditor.this,
+                message, "Invalid Stream Name", JOptionPane.ERROR_MESSAGE);
+
+            mName.requestFocus();
+
+            return false;
+        }
+
+        //Server address is optional, but required
+        if(!validateTextField(mServer, "Invalid Server Address", "Please specify a server address."))
+        {
+            return true;
+        }
+
+        //Port is optional, but required
+        if(!validateIntegerTextField(mPort, "Invalid Port Number", "Please specify a port number (1 <> 65535)", 1, 65535))
+        {
+            return true;
+        }
+
+        //Mount Point is optional, but required
+        if(!validateTextField(mMountPoint, "Invalid Mount Point", "Please specify a mount point."))
+        {
+            return true;
+        }
+
+        //Password is optional, but required
+        if(!validateTextField(mPassword, "Invalid Password", "Please specify a password."))
+        {
+            return true;
+        }
+
+        return true;
+    }
+
+    /**
+     * Parses an Integer from the port text control or returns 0 if the control doesn't contain an integer value.
+     */
+    private int getPort()
+    {
+        String port = mPort.getText();
+
+        if(port != null && !port.isEmpty())
+        {
+            try
+            {
+                return Integer.parseInt(port);
+            }
+            catch(Exception e)
+            {
+                //Do nothing, we couldn't parse the number value
+            }
+        }
+
+        return 0;
+    }
+
+    /**
+     * Parses an Integer from the port text control or returns 0 if the control doesn't contain an integer value.
+     */
+    private int getFeedID()
+    {
+        String feedID = mFeedID.getText();
+
+        if(feedID != null && !feedID.isEmpty())
+        {
+            try
+            {
+                return Integer.parseInt(feedID);
+            }
+            catch(Exception e)
+            {
+                //Do nothing, we couldn't parse the number value
+            }
+        }
+
+        return 0;
+    }
+
+    @Override
+    public void receive(UserFeedBroadcast userFeedBroadcast)
+    {
+        mName.setText(userFeedBroadcast.getDescr());
+        mServer.setText(userFeedBroadcast.getHostname());
+        mPort.setText(userFeedBroadcast.getPort());
+        mMountPoint.setText(userFeedBroadcast.getMount());
+        mPassword.setText(userFeedBroadcast.getPassword());
+        mFeedID.setText(String.valueOf(userFeedBroadcast.getFeedId()));
+    }
+}

src/main/java/audio/broadcast/broadcastify/UserFeedSelectionDialog.java

@@ -0,0 +1,247 @@
+/*******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2016 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 audio.broadcast.broadcastify;
+
+import com.radioreference.api.soap2.UserFeedBroadcast;
+import external.radioreference.RadioReferenceService;
+import net.miginfocom.swing.MigLayout;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import sample.Listener;
+
+import javax.swing.*;
+import javax.swing.event.DocumentEvent;
+import javax.swing.event.DocumentListener;
+import javax.swing.event.ListSelectionEvent;
+import javax.swing.event.ListSelectionListener;
+import javax.xml.rpc.ServiceException;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.net.UnknownHostException;
+import java.rmi.RemoteException;
+
+public class UserFeedSelectionDialog extends JDialog implements DocumentListener
+{
+    private final static Logger mLog = LoggerFactory.getLogger( UserFeedSelectionDialog.class );
+
+    private Listener<UserFeedBroadcast> mListener;
+    private JTextField mUserNameText;
+    private JTextField mPasswordText;
+    private JButton mLookupButton;
+    private JList mUserFeedBroadcastList;
+    private JButton mOKButton;
+
+    public UserFeedSelectionDialog(Listener<UserFeedBroadcast> listener)
+    {
+        mListener = listener;
+        init();
+    }
+
+    private void init()
+    {
+        JPanel panel = new JPanel();
+        panel.setLayout(new MigLayout("","[align right,grow,fill][align left,grow,fill][]","[][][][][grow][]"));
+
+        panel.add(new JLabel("Please enter your credentials"), "align left,span");
+
+        panel.add(new JLabel("User Name:"));
+        mUserNameText = new JTextField();
+        mUserNameText.getDocument().addDocumentListener(this);
+        panel.add(mUserNameText, "wrap");
+
+        panel.add(new JLabel("Password:"));
+        mPasswordText = new JTextField();
+        mPasswordText.getDocument().addDocumentListener(this);
+        panel.add(mPasswordText, "wrap");
+
+        mLookupButton = new JButton("Get Feeds");
+        mLookupButton.setEnabled(false);
+        mLookupButton.addActionListener(new ActionListener()
+        {
+            @Override
+            public void actionPerformed(ActionEvent e)
+            {
+                mLookupButton.setEnabled(false);
+
+                EventQueue.invokeLater(new Runnable()
+                {
+                    @Override
+                    public void run()
+                    {
+                        try
+                        {
+                            RadioReferenceService service =
+                                new RadioReferenceService(mUserNameText.getText(), mPasswordText.getText());
+
+                            UserFeedBroadcast[] feeds = service.getUserFeedBroadcasts();
+
+                            mUserFeedBroadcastList.setListData(feeds);
+                        }
+                        catch(ServiceException se)
+                        {
+                            JOptionPane.showMessageDialog(UserFeedSelectionDialog.this,
+                                "Unable to create radio reference web service client.  See log file.",
+                                "Error", JOptionPane.ERROR_MESSAGE);
+
+                            mLog.error("Error creating the radio reference web service client", se);
+                        }
+                        catch(RemoteException re)
+                        {
+                            Throwable cause = re.getCause();
+
+                            if(cause == null)
+                            {
+                                JOptionPane.showMessageDialog(UserFeedSelectionDialog.this,
+                                    re.getMessage(), "Error", JOptionPane.ERROR_MESSAGE);
+                            }
+                            else if(cause instanceof UnknownHostException)
+                            {
+                                JOptionPane.showMessageDialog(UserFeedSelectionDialog.this,
+                                    "Broadcastify server is unavailable", "No Server",
+                                    JOptionPane.ERROR_MESSAGE);
+                            }
+                            else
+                            {
+                                JOptionPane.showMessageDialog(UserFeedSelectionDialog.this,
+                                    "An unknown error has occurred.  Please see log file.", "" +
+                                        "Unknown Error", JOptionPane.ERROR_MESSAGE);
+
+                                mLog.error("Error retrieving user broadcast feed configurations from radio reference " +
+                                    "service: ", re);
+                            }
+                        }
+
+                        mLookupButton.setEnabled(true);
+                    }
+                });
+            }
+        });
+        panel.add(mLookupButton,"grow,span");
+
+        mUserFeedBroadcastList = new JList();
+        mUserFeedBroadcastList.setVisibleRowCount(3);
+        mUserFeedBroadcastList.setLayoutOrientation(JList.VERTICAL);
+        mUserFeedBroadcastList.setCellRenderer(new CellRenderer());
+        mUserFeedBroadcastList.addListSelectionListener(new ListSelectionListener()
+        {
+            @Override
+            public void valueChanged(ListSelectionEvent e)
+            {
+                mOKButton.setEnabled(mUserFeedBroadcastList.getSelectedValue() != null);
+            }
+        });
+
+        JScrollPane listScrollPane = new JScrollPane(mUserFeedBroadcastList);
+        panel.add(listScrollPane, "grow,span");
+
+        mOKButton = new JButton("Ok");
+        mOKButton.setEnabled(false);
+        mOKButton.addActionListener(new ActionListener()
+        {
+            @Override
+            public void actionPerformed(ActionEvent e)
+            {
+                if(mListener != null)
+                {
+                    mListener.receive((UserFeedBroadcast)mUserFeedBroadcastList.getSelectedValue());
+                }
+
+                dispose();
+            }
+        });
+        panel.add(mOKButton,"grow");
+
+        JButton cancelButton = new JButton("Cancel");
+        cancelButton.addActionListener(new ActionListener()
+        {
+            @Override
+            public void actionPerformed(ActionEvent e)
+            {
+                dispose();
+            }
+        });
+        panel.add(cancelButton, "wrap");
+
+        setTitle("Broadcastify Feed Lookup");
+        setLayout(new BorderLayout());
+        add(panel, BorderLayout.CENTER);
+        setSize(300,250);
+        setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
+        setModalityType(ModalityType.APPLICATION_MODAL);
+    }
+
+    private void updateButtons()
+    {
+        String username = mUserNameText.getText();
+        String password = mPasswordText.getText();
+
+        mLookupButton.setEnabled(username != null && !username.isEmpty() && password != null && !password.isEmpty());
+    }
+
+    @Override
+    public void insertUpdate(DocumentEvent e)
+    {
+        updateButtons();
+    }
+
+    @Override
+    public void removeUpdate(DocumentEvent e)
+    {
+        updateButtons();
+    }
+
+    @Override
+    public void changedUpdate(DocumentEvent e)
+    {
+        updateButtons();
+    }
+
+    private class CellRenderer extends JLabel implements ListCellRenderer<UserFeedBroadcast>
+    {
+        public CellRenderer()
+        {
+            setOpaque(true);
+            setHorizontalAlignment(LEFT);
+            setVerticalAlignment(CENTER);
+        }
+
+        @Override
+        public Component getListCellRendererComponent(JList<? extends UserFeedBroadcast> list,
+                                                      UserFeedBroadcast value,
+                                                      int index,
+                                                      boolean isSelected,
+                                                      boolean cellHasFocus)
+        {
+            if (isSelected)
+            {
+                setBackground(list.getSelectionBackground());
+                setForeground(list.getSelectionForeground());
+            }
+            else
+            {
+                setBackground(list.getBackground());
+                setForeground(list.getForeground());
+            }
+
+            setText(value.getDescr());
+
+            return this;        }
+    }
+}

src/main/java/audio/broadcast/icecast/IcecastAudioBroadcaster.java

@@ -0,0 +1,52 @@
+/*******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2016 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 audio.broadcast.icecast;
+
+import audio.broadcast.AudioBroadcaster;
+import audio.broadcast.BroadcastConfiguration;
+import audio.broadcast.IBroadcastMetadataUpdater;
+
+public abstract class IcecastAudioBroadcaster extends AudioBroadcaster
+{
+    private IBroadcastMetadataUpdater mMetadataUpdater;
+
+    public IcecastAudioBroadcaster(BroadcastConfiguration broadcastConfiguration)
+    {
+        super(broadcastConfiguration);
+    }
+
+    /**
+     * Icecast broadcast configuration
+     */
+    protected IcecastConfiguration getConfiguration()
+    {
+        return (IcecastConfiguration) getBroadcastConfiguration();
+    }
+
+    @Override
+    protected IBroadcastMetadataUpdater getMetadataUpdater()
+    {
+        if(mMetadataUpdater == null)
+        {
+            mMetadataUpdater = new IcecastBroadcastMetadataUpdater(getConfiguration());
+        }
+
+        return mMetadataUpdater;
+    }
+}

src/main/java/audio/broadcast/icecast/IcecastBroadcastMetadataUpdater.java

@@ -0,0 +1,279 @@
+/*******************************************************************************
+ * 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 audio.broadcast.icecast;
+
+import audio.broadcast.IBroadcastMetadataUpdater;
+import channel.metadata.Metadata;
+import org.apache.mina.core.future.ConnectFuture;
+import org.apache.mina.core.service.IoHandlerAdapter;
+import org.apache.mina.core.session.IoSession;
+import org.apache.mina.http.HttpClientCodec;
+import org.apache.mina.http.HttpRequestImpl;
+import org.apache.mina.http.api.HttpMethod;
+import org.apache.mina.http.api.HttpRequest;
+import org.apache.mina.http.api.HttpVersion;
+import org.apache.mina.transport.socket.nio.NioSocketConnector;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import properties.SystemProperties;
+import util.ThreadPool;
+
+import java.io.UnsupportedEncodingException;
+import java.net.ConnectException;
+import java.net.InetSocketAddress;
+import java.net.URLEncoder;
+import java.nio.channels.UnresolvedAddressException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Queue;
+import java.util.concurrent.LinkedTransferQueue;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class IcecastBroadcastMetadataUpdater implements IBroadcastMetadataUpdater
+{
+    private final static Logger mLog = LoggerFactory.getLogger(IcecastBroadcastMetadataUpdater.class);
+    private final static String UTF8 = "UTF-8";
+
+    private IcecastConfiguration mIcecastConfiguration;
+
+    private NioSocketConnector mSocketConnector;
+    private AtomicBoolean mUpdating = new AtomicBoolean();
+    private Queue<String> mMetadataQueue = new LinkedTransferQueue<>();
+    private Map<String,String> mHTTPHeaders;
+    private boolean mStackTraceLoggingSuppressed;
+
+    /**
+     * Icecast song metadata updater.  Each metadata update is processed in the order received and the dispatch of
+     * the HTTP update request is processed in a separate thread (runnable) to avoid delaying streaming of this
+     * broadcaster.  When multiple metadata updates are received prior to completion of the current ongoing update
+     * sequence, those updates will be queued and processed in the order received.
+     */
+    public IcecastBroadcastMetadataUpdater(IcecastConfiguration icecastConfiguration)
+    {
+        mIcecastConfiguration = icecastConfiguration;
+    }
+
+    /**
+     * Socket connector - lazy constructor.
+     */
+    private NioSocketConnector getSocketConnector()
+    {
+        if(mSocketConnector == null)
+        {
+            mSocketConnector = new NioSocketConnector();
+//            mSocketConnector.getFilterChain().addLast("logger", new LoggingFilter(IcecastBroadcastMetadataUpdater.class));
+            mSocketConnector.getFilterChain().addLast("http_client_codec", new HttpClientCodec());
+
+            //Each metadata update session is single-use, so we'll shut it down upon success or failure
+            mSocketConnector.setHandler(new IoHandlerAdapter()
+            {
+                @Override
+                public void exceptionCaught(IoSession session, Throwable cause) throws Exception
+                {
+                    //Single-use session - close it after we receive an error
+                    session.closeNow();
+
+                    mLog.error("Metadata update failed");
+                }
+
+                @Override
+                public void messageReceived(IoSession session, Object message) throws Exception
+                {
+                    //Single-use session - close it after we receive a response
+                    session.closeNow();
+                }
+            });
+        }
+
+        return mSocketConnector;
+    }
+
+    /**
+     * Sends a song metadata update to the remote server.  Additional metadata updates received while the updater
+     * is in the process of sending an existing metadata update will be queued and processed in received order.
+     *
+     * Note: due to thread timing, there is a slight chance that a concurrent update request will not be processed
+     * and will remain in the update queue until the next metadata update is requested.  However, this is a design
+     * trade-off to avoid having a scheduled runnable repeatedly processing the update queue.
+     */
+    public void update(Metadata metadata)
+    {
+        mMetadataQueue.offer(getSong(metadata));
+
+        if(mUpdating.compareAndSet(false, true))
+        {
+            String song = mMetadataQueue.poll();
+
+            while(song != null)
+            {
+                HttpRequest updateRequest = createUpdateRequest(song);
+
+                if(updateRequest != null)
+                {
+                    ThreadPool.SCHEDULED.schedule(new Runnable()
+                    {
+                        @Override
+                        public void run()
+                        {
+                            try
+                            {
+                                ConnectFuture connectFuture = getSocketConnector()
+                                    .connect(new InetSocketAddress(mIcecastConfiguration.getHost(),
+                                        mIcecastConfiguration.getPort()));
+                                connectFuture.awaitUninterruptibly();
+                                IoSession session = connectFuture.getSession();
+
+                                if(session != null)
+                                {
+                                    session.write(updateRequest);
+                                }
+                            }
+                            catch(UnresolvedAddressException uae)
+                            {
+                                //Do nothing - the server is temporarily unavailable
+                            }
+                            catch(Exception e)
+                            {
+                                Throwable throwableCause = e.getCause();
+
+                                if(throwableCause instanceof ConnectException)
+                                {
+                                    //Do nothing, the server is unavailable
+                                }
+                                else if(throwableCause instanceof UnresolvedAddressException)
+                                {
+                                    //Do nothing - the server is temporarily unavailable
+                                }
+                                else
+                                {
+                                    if(!mStackTraceLoggingSuppressed)
+                                    {
+                                        mLog.error("Error sending metadata update.  Future errors will " +
+                                            "be suppressed", e);
+
+                                        mStackTraceLoggingSuppressed = true;
+                                    }
+                                }
+                            }
+                        }
+                    }, 0l, TimeUnit.SECONDS);
+                }
+
+                //Fetch next metadata update to send
+                song = mMetadataQueue.poll();
+            }
+
+            mUpdating.set(false);
+        }
+    }
+
+    /**
+     * Creates the song information for a metadata update
+     */
+    private static String getSong(Metadata metadata)
+    {
+        StringBuilder sb = new StringBuilder();
+
+        if(metadata != null)
+        {
+            String to = metadata.getPrimaryAddressTo().getIdentifier();
+
+            sb.append("TO:");
+
+            if(metadata.getPrimaryAddressTo().hasAlias())
+            {
+                sb.append(metadata.getPrimaryAddressTo().getAlias().getName());
+            }
+            else if(metadata.getPrimaryAddressTo().hasIdentifier())
+            {
+                sb.append(metadata.getPrimaryAddressTo().getIdentifier());
+            }
+            else
+            {
+                sb.append("UNKNOWN");
+            }
+
+
+            sb.append(" FROM:");
+
+            if(metadata.getPrimaryAddressFrom().hasAlias())
+            {
+                sb.append(metadata.getPrimaryAddressFrom().getAlias().getName());
+            }
+            else if(metadata.getPrimaryAddressFrom().hasIdentifier())
+            {
+                sb.append(metadata.getPrimaryAddressFrom().getIdentifier());
+            }
+            else
+            {
+                sb.append("UNKNOWN");
+            }
+
+        }
+        else
+        {
+            sb.append("Scanning ....");
+        }
+
+        return sb.toString();
+    }
+
+    /**
+     * Creates an HTTP GET request to update the metadata on the remote server
+     */
+    private HttpRequest createUpdateRequest(String song)
+    {
+        try
+        {
+            StringBuilder sb = new StringBuilder();
+            sb.append("mode=updinfo");
+            sb.append("&mount=").append(URLEncoder.encode(mIcecastConfiguration.getMountPoint(), UTF8));
+            sb.append("&charset=UTF%2d8");
+            sb.append("&song=").append(URLEncoder.encode(song, UTF8));
+
+            HttpRequestImpl request = new HttpRequestImpl(HttpVersion.HTTP_1_1, HttpMethod.GET, "/admin/metadata",
+                sb.toString(), getHTTPHeaders());
+
+            return request;
+        }
+        catch(UnsupportedEncodingException e)
+        {
+            //This should never happen
+            mLog.error("UTF-8 encoding is not supported - can't update song metadata");
+        }
+
+        return null;
+    }
+
+    /**
+     * HTTP headers to use for a metadata update request.
+     */
+    private Map<String,String> getHTTPHeaders()
+    {
+        if(mHTTPHeaders == null)
+        {
+            mHTTPHeaders = new HashMap<>();
+            mHTTPHeaders.put(IcecastHeader.USER_AGENT.getValue(), SystemProperties.getInstance().getApplicationName());
+            mHTTPHeaders.put(IcecastHeader.AUTHORIZATION.getValue(), mIcecastConfiguration.getBase64EncodedCredentials());
+        }
+
+        return mHTTPHeaders;
+    }
+}

src/main/java/audio/broadcast/icecast/IcecastConfiguration.java

@@ -0,0 +1,292 @@
+/*******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2016 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 audio.broadcast.icecast;
+
+import audio.broadcast.BroadcastConfiguration;
+import audio.broadcast.BroadcastFormat;
+
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlTransient;
+import java.util.Base64;
+
+public abstract class IcecastConfiguration extends BroadcastConfiguration
+{
+    protected String mUserName = "source";
+    private String mMountPoint = "/stream";
+    private String mDescription;
+    private String mGenre;
+    private boolean mPublic;
+    private int mBitRate = 16;
+    private int mChannels = 1;
+    private int mSampleRate = 8000;
+    private String mURL;
+
+    public IcecastConfiguration(BroadcastFormat format)
+    {
+        super(format);
+    }
+
+    public IcecastConfiguration()
+    {
+    }
+
+    /**
+     * Base64 encoded version of the username and password with prepended 'Basic ' tag.
+     */
+    @XmlTransient
+    public String getBase64EncodedCredentials()
+    {
+        StringBuilder sb = new StringBuilder();
+
+        if(hasUserName())
+        {
+            sb.append(getUserName()).append(":").append(getPassword());
+        }
+        else
+        {
+            sb.append(getPassword());
+        }
+
+        String base64 = Base64.getEncoder().encodeToString(sb.toString().getBytes());
+
+        return "Basic " + base64;
+    }
+
+    @XmlAttribute( name="user_name" )
+    public String getUserName()
+    {
+        return mUserName;
+    }
+
+    public void setUserName(String userName)
+    {
+        mUserName = userName;
+    }
+
+    public boolean hasUserName()
+    {
+        return mUserName != null;
+    }
+
+    /**
+     * Mount point or path to the stream
+     * @return mount point
+     */
+    @XmlAttribute( name="mount_point" )
+    public String getMountPoint()
+    {
+        return mMountPoint;
+    }
+
+    /**
+     * Sets the mount point (path) for the stream
+     * @param mountPoint
+     */
+    public void setMountPoint(String mountPoint)
+    {
+        if(mountPoint != null && !mountPoint.isEmpty())
+        {
+            if(mountPoint.startsWith("/"))
+            {
+                mMountPoint = mountPoint;
+            }
+            else
+            {
+                mMountPoint = "/" + mountPoint;
+            }
+        }
+    }
+
+    public boolean hasMountPoint()
+    {
+        return mMountPoint != null;
+    }
+
+    @XmlAttribute( name="description" )
+    public String getDescription()
+    {
+        return mDescription;
+    }
+
+    public void setDescription(String description)
+    {
+        mDescription = description;
+    }
+
+    public boolean hasDescription()
+    {
+        return mDescription != null;
+    }
+
+    /**
+     * Stream genre
+     */
+    @XmlAttribute( name="genre" )
+    public String getGenre()
+    {
+        return mGenre;
+    }
+
+    /**
+     * Stream genre
+     * @param genre
+     */
+    public void setGenre(String genre)
+    {
+        mGenre = genre;
+    }
+
+    public boolean hasGenre()
+    {
+        return mGenre != null;
+    }
+
+    /**
+     * Public visibility of the broadcastAudio
+     */
+    @XmlAttribute( name="public" )
+    public boolean isPublic()
+    {
+        return mPublic;
+    }
+
+    /**
+     * Sets public visibility of the broadcastAudio
+     * @param isPublic indicates if the broadcastAudio should be visible to the public
+     */
+    public void setPublic(boolean isPublic)
+    {
+        mPublic = isPublic;
+    }
+
+    /**
+     * Number of audio channels in the broadcastAudio
+     */
+    @XmlAttribute( name="channels" )
+    public int getChannels()
+    {
+        return mChannels;
+    }
+
+    /**
+     * Sets the number of audio channels in the broadcastAudio
+     */
+    public void setChannels(int channels)
+    {
+        mChannels = channels;
+    }
+
+    public boolean hasChannels()
+    {
+        return mChannels > 0;
+    }
+
+    /**
+     * Bit rate in bits per second
+     */
+    @XmlAttribute( name="bitrate" )
+    public int getBitRate()
+    {
+        return mBitRate;
+    }
+
+    /**
+     * Bit rate
+     * @param bitRate in samples per second
+     */
+    public void setBitRate(int bitRate)
+    {
+        mBitRate = bitRate;
+    }
+
+    public boolean hasBitRate()
+    {
+        return mBitRate > 0;
+    }
+
+    @XmlAttribute( name="sample_rate" )
+    public int getSampleRate()
+    {
+        return mSampleRate;
+    }
+
+    public void setSampleRate(int sampleRate)
+    {
+        mSampleRate = sampleRate;
+    }
+
+    public boolean hasSampleRate()
+    {
+        return mSampleRate > 0;
+    }
+
+    /**
+     * URL associated with the broadcastAudio where users can find additional details.
+     */
+    @XmlAttribute( name="url" )
+    public String getURL()
+    {
+        return mURL;
+    }
+
+    /**
+     * URL associated with the broadcastAudio where users can find additional details.
+     * @param url
+     */
+    public void setURL(String url)
+    {
+        mURL = url;
+    }
+
+    public boolean hasURL()
+    {
+        return mURL != null;
+    }
+
+    @Override
+    public boolean isValid()
+    {
+        if(!super.isValid())
+        {
+            return false;
+        }
+        else if(getUserName() == null)
+        {
+            return false;
+        }
+        else if(getMountPoint() == null)
+        {
+            return false;
+        }
+        else if(getChannels() != 1)
+        {
+            return false;
+        }
+        else if(getSampleRate() <= 0)
+        {
+            return false;
+        }
+        else if(getBitRate() <= 0)
+        {
+            return false;
+        }
+
+        return true;
+    }
+}

src/main/java/audio/broadcast/icecast/IcecastHTTPAudioBroadcaster.java

@@ -0,0 +1,330 @@
+/*******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2016 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 audio.broadcast.icecast;
+
+import audio.broadcast.BroadcastState;
+import audio.convert.MP3AudioConverter;
+import org.apache.mina.core.RuntimeIoException;
+import org.apache.mina.core.buffer.IoBuffer;
+import org.apache.mina.core.future.ConnectFuture;
+import org.apache.mina.core.service.IoHandlerAdapter;
+import org.apache.mina.core.session.IoSession;
+import org.apache.mina.filter.codec.ProtocolDecoderException;
+import org.apache.mina.http.HttpClientCodec;
+import org.apache.mina.http.HttpException;
+import org.apache.mina.http.HttpRequestImpl;
+import org.apache.mina.http.api.DefaultHttpResponse;
+import org.apache.mina.http.api.HttpMethod;
+import org.apache.mina.http.api.HttpStatus;
+import org.apache.mina.http.api.HttpVersion;
+import org.apache.mina.transport.socket.nio.NioSocketConnector;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import properties.SystemProperties;
+import util.ThreadPool;
+
+import java.net.ConnectException;
+import java.net.InetSocketAddress;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class IcecastHTTPAudioBroadcaster extends IcecastAudioBroadcaster
+{
+    private static final Logger mLog = LoggerFactory.getLogger(IcecastHTTPAudioBroadcaster.class);
+    private static final long RECONNECT_INTERVAL_MILLISECONDS = 30000; //30 seconds
+
+    private NioSocketConnector mSocketConnector;
+    private IoSession mStreamingSession = null;
+    private Map<String,String> mHTTPHeaders;
+
+    private long mLastConnectionAttempt = 0;
+    private AtomicBoolean mConnecting = new AtomicBoolean();
+
+    /**
+     * Creates an Icecast 2.4.x compatible broadcaster using HTTP 1.1 protocol.  This broadcaster is
+     * compatible with Icecast version 2.4.x and newer versions of the server software.
+     *
+     * Note: use @see IcecastTCPAudioBroadcaster for Icecast version 2.3.x and older.
+     *
+     * This broadcaster uses the Apache Mina library for the streaming socket connection and for metadata updates.  The
+     * IcecastHTTPIOHandler manages all interaction with the Icecast server and manages the overall broadcast state.
+     *
+     * @param configuration for the Icecast stream
+     */
+    public IcecastHTTPAudioBroadcaster(IcecastHTTPConfiguration configuration)
+    {
+        super(configuration);
+    }
+
+    /**
+     * Broadcasts the audio frame or sequence
+     */
+    @Override
+    protected void broadcastAudio(byte[] audio)
+    {
+        if(audio != null && audio.length > 0 && connect() && mStreamingSession != null && mStreamingSession.isConnected())
+        {
+            IoBuffer buffer = IoBuffer.allocate(audio.length);
+            buffer.put(audio);
+            buffer.flip();
+
+            mStreamingSession.write(buffer);
+        }
+    }
+
+    /**
+     * (Re)Connects the broadcaster to the remote server if it currently is disconnected and indicates if the broadcaster
+     * is currently connected to the remote server following any connection attempts.
+     *
+     * Attempts to connect via this method when the broadcast state indicates an error condition will be ignored.
+     *
+     * @return true if the audio handler can stream audio
+     */
+    private boolean connect()
+    {
+        if(!connected() && canConnect() &&
+            (mLastConnectionAttempt + RECONNECT_INTERVAL_MILLISECONDS < System.currentTimeMillis()) &&
+            mConnecting.compareAndSet(false, true))
+        {
+            mLastConnectionAttempt = System.currentTimeMillis();
+
+            if(mSocketConnector == null)
+            {
+                mSocketConnector = new NioSocketConnector();
+                mSocketConnector.setConnectTimeoutCheckInterval(10000);
+
+//                mSocketConnector.getFilterChain().addLast("logger",
+//                    new LoggingFilter(IcecastTCPAudioBroadcaster.class));
+
+                mSocketConnector.getFilterChain().addLast("codec", new HttpClientCodec());
+                mSocketConnector.setHandler(new IcecastHTTPIOHandler());
+            }
+
+            mStreamingSession = null;
+
+            Runnable runnable = new Runnable()
+            {
+                @Override
+                public void run()
+                {
+                    setBroadcastState(BroadcastState.CONNECTING);
+
+                    try
+                    {
+                        ConnectFuture future = mSocketConnector
+                            .connect(new InetSocketAddress(getBroadcastConfiguration().getHost(),
+                                getBroadcastConfiguration().getPort()));
+                        future.awaitUninterruptibly();
+                        mStreamingSession = future.getSession();
+                    }
+                    catch(RuntimeIoException rie)
+                    {
+                        Throwable throwableCause = rie.getCause();
+
+                        if(throwableCause instanceof ConnectException)
+                        {
+                            setBroadcastState(BroadcastState.NO_SERVER);
+                        }
+                        else if(throwableCause != null)
+                        {
+                            setBroadcastState(BroadcastState.ERROR);
+                            mLog.debug("Failed to connect", rie);
+                        }
+                        else
+                        {
+                            setBroadcastState(BroadcastState.ERROR);
+                            mLog.debug("Failed to connect - no exception is available");
+                        }
+
+                        disconnect();
+                    }
+
+                    mConnecting.set(false);
+                }
+            };
+
+            ThreadPool.SCHEDULED.schedule(runnable, 0l, TimeUnit.SECONDS);
+
+        }
+
+        return connected();
+    }
+
+
+    /**
+     * Disconnect from the remote broadcast server and cleanup input/output streams and socket connection
+     */
+    public void disconnect()
+    {
+        if(mStreamingSession != null)
+        {
+            mStreamingSession.closeNow();
+        }
+    }
+
+    /**
+     * IO Handler for managing Icecast HTTP connection and credentials
+     */
+    public class IcecastHTTPIOHandler extends IoHandlerAdapter
+    {
+        @Override
+        public void sessionOpened(IoSession session) throws Exception
+        {
+            //Send stream configuration and user credentials upon connecting to remote server
+            HttpRequestImpl request = new HttpRequestImpl(HttpVersion.HTTP_1_1, HttpMethod.PUT,
+                getConfiguration().getMountPoint(), "", getHTTPHeaders());
+
+            session.write(request);
+        }
+
+        private Map<String,String> getHTTPHeaders()
+        {
+            if(mHTTPHeaders == null)
+            {
+                mHTTPHeaders = new HashMap<>();
+                mHTTPHeaders.put(IcecastHeader.ACCEPT.getValue(), "*/*");
+                mHTTPHeaders.put(IcecastHeader.CONTENT_TYPE.getValue(), getConfiguration().getBroadcastFormat().getValue());
+                mHTTPHeaders.put(IcecastHeader.USER_AGENT.getValue(), SystemProperties.getInstance().getApplicationName());
+                mHTTPHeaders.put(IcecastHeader.AUTHORIZATION.getValue(), getConfiguration().getBase64EncodedCredentials());
+                mHTTPHeaders.put(IcecastHeader.PUBLIC.getValue(), getConfiguration().isPublic() ? "1" : "0");
+
+                StringBuilder sb = new StringBuilder();
+                sb.append("samplerate=").append(getConfiguration().getSampleRate()).append(";");
+                sb.append("quality=").append(MP3AudioConverter.AUDIO_QUALITY).append(";");
+                sb.append("channels=").append(getConfiguration().getChannels());
+                mHTTPHeaders.put(IcecastHeader.AUDIO_INFO.getValue(), sb.toString());
+
+                if(getConfiguration().hasName())
+                {
+                    mHTTPHeaders.put(IcecastHeader.NAME.getValue(), getConfiguration().getName());
+                }
+
+                if(getConfiguration().hasDescription())
+                {
+                    mHTTPHeaders.put(IcecastHeader.DESCRIPTION.getValue(), getConfiguration().getDescription());
+                }
+
+                if(getConfiguration().hasURL())
+                {
+                    mHTTPHeaders.put(IcecastHeader.URL.getValue(), getConfiguration().getURL());
+                }
+
+                if(getConfiguration().hasGenre())
+                {
+                    mHTTPHeaders.put(IcecastHeader.GENRE.getValue(), getConfiguration().getGenre());
+                }
+
+
+                if(getConfiguration().hasBitRate())
+                {
+                    mHTTPHeaders.put(IcecastHeader.BITRATE.getValue(), String.valueOf(getConfiguration().getBitRate()));
+                }
+            }
+
+            return mHTTPHeaders;
+        }
+
+        @Override
+        public void sessionClosed(IoSession session) throws Exception
+        {
+            //If there is already an error state, don't override it.  Otherwise, set state to disconnected
+            if(!getBroadcastState().isErrorState())
+            {
+                setBroadcastState(BroadcastState.DISCONNECTED);
+            }
+
+            mSocketConnector.dispose();
+            mStreamingSession = null;
+            mSocketConnector = null;
+
+            mConnecting.set(false);
+
+            super.sessionClosed(session);
+        }
+
+        @Override
+        public void exceptionCaught(IoSession session, Throwable throwable) throws Exception
+        {
+            if(throwable instanceof ProtocolDecoderException)
+            {
+                Throwable cause = ((ProtocolDecoderException) throwable).getCause();
+
+                if(cause instanceof HttpException &&
+                    ((HttpException) cause).getStatusCode() == HttpStatus.CLIENT_ERROR_LENGTH_REQUIRED.code())
+                {
+                    //Ignore - Icecast 2.4 sometimes doesn't send any headers with their HTTP responses.  Mina expects a
+                    //content-length for HTTP responses.
+                }
+                else
+                {
+                    mLog.error("HTTP protocol decoder error", throwable);
+                    setBroadcastState(BroadcastState.TEMPORARY_BROADCAST_ERROR);
+                    disconnect();
+                }
+            }
+            else
+            {
+                mLog.error("Broadcast error", throwable);
+                setBroadcastState(BroadcastState.TEMPORARY_BROADCAST_ERROR);
+                disconnect();
+            }
+
+            mConnecting.set(false);
+        }
+
+        @Override
+        public void messageReceived(IoSession session, Object object) throws Exception
+        {
+            if(object instanceof DefaultHttpResponse)
+            {
+                DefaultHttpResponse response = (DefaultHttpResponse) object;
+
+                switch(response.getStatus())
+                {
+                    case INFORMATIONAL_CONTINUE:
+                        break;
+                    case SUCCESS_OK:
+                        setBroadcastState(BroadcastState.CONNECTED);
+                        mConnecting.set(false);
+                        break;
+                    case CLIENT_ERROR_UNAUTHORIZED:
+                        setBroadcastState(BroadcastState.INVALID_CREDENTIALS);
+                        disconnect();
+                        break;
+                    case CLIENT_ERROR_FORBIDDEN:
+                        setBroadcastState(BroadcastState.CONFIGURATION_ERROR);
+                        disconnect();
+                        break;
+                    default:
+                        setBroadcastState(BroadcastState.ERROR);
+                        disconnect();
+                        mLog.debug("Unspecified error: " + response.toString() + " Class:" + object.getClass());
+                        break;
+                }
+            }
+            else
+            {
+                mLog.error("Icecast HTTP broadcaster - unrecognized message [ " + object.getClass() +
+                    "] received:" + object.toString());
+            }
+        }
+    }
+}

src/main/java/audio/broadcast/icecast/IcecastHTTPConfiguration.java

@@ -0,0 +1,78 @@
+/*******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2016 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 audio.broadcast.icecast;
+
+import audio.broadcast.BroadcastConfiguration;
+import audio.broadcast.BroadcastFormat;
+import audio.broadcast.BroadcastServerType;
+
+import java.util.Base64;
+
+public class IcecastHTTPConfiguration extends IcecastConfiguration
+{
+    public IcecastHTTPConfiguration()
+    {
+        //no-arg JAXB constructor
+        this(BroadcastFormat.MP3);
+    }
+
+    /**
+     * Icecast 2.4.x+ compatible configuration
+     */
+    public IcecastHTTPConfiguration(BroadcastFormat format)
+    {
+        super(format);
+        setPassword("change me!");
+    }
+
+    @Override
+    public BroadcastConfiguration copyOf()
+    {
+        IcecastHTTPConfiguration copy = new IcecastHTTPConfiguration(getBroadcastFormat());
+
+        //Broadcast Configuration Parameters
+        copy.setName(getName());
+        copy.setHost(getHost());
+        copy.setPort(getPort());
+        copy.setPassword(getPassword());
+        copy.setDelay(getDelay());
+        copy.setEnabled(false);
+
+        //Icecast Configuration Parameters
+        copy.setUserName(getUserName());
+        copy.setMountPoint(getMountPoint());
+        copy.setDescription(getDescription());
+        copy.setGenre(getGenre());
+        copy.setPublic(isPublic());
+        copy.setBitRate(getBitRate());
+        copy.setChannels(getChannels());
+        copy.setSampleRate(getSampleRate());
+        copy.setURL(getURL());
+
+        return copy;
+    }
+
+    @Override
+    public BroadcastServerType getBroadcastServerType()
+    {
+        return BroadcastServerType.ICECAST_HTTP;
+    }
+
+
+}

src/main/java/audio/broadcast/icecast/IcecastHTTPConfigurationEditor.java

@@ -0,0 +1,378 @@
+/*******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2016 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 audio.broadcast.icecast;
+
+import alias.AliasModel;
+import audio.broadcast.BroadcastConfiguration;
+import audio.broadcast.BroadcastConfigurationEditor;
+import audio.broadcast.BroadcastEvent;
+import audio.broadcast.BroadcastModel;
+import audio.broadcast.BroadcastServerType;
+import icon.IconManager;
+import net.miginfocom.swing.MigLayout;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import settings.SettingsManager;
+
+import javax.swing.*;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+public class IcecastHTTPConfigurationEditor extends BroadcastConfigurationEditor
+{
+    private final static Logger mLog = LoggerFactory.getLogger( IcecastHTTPConfigurationEditor.class );
+
+    private static final int ONE_MINUTE_MS = 60000;
+
+    private JTextField mName;
+    private JTextField mServer;
+    private JTextField mPort;
+    private JTextField mMountPoint;
+    private JTextField mUsername;
+    private JTextField mPassword;
+    private JTextField mDescription;
+    private JTextField mGenre;
+    private JCheckBox mPublic;
+    private JSlider mDelay;
+    private JLabel mDelayValue;
+    private JSlider mMaximumRecordingAge;
+    private JLabel mMaximumRecordingAgeValue;
+    private JCheckBox mEnabled;
+    private JButton mSaveButton;
+    private JButton mResetButton;
+
+    public IcecastHTTPConfigurationEditor(BroadcastModel broadcastModel, AliasModel aliasModel, IconManager iconManager)
+    {
+        super(broadcastModel, aliasModel, iconManager);
+        init();
+    }
+
+    private void init()
+    {
+        setLayout( new MigLayout( "fill,wrap 2", "[align right][grow,fill]",
+            "[][][][][][][][][][][][][][][][][grow,fill]" ) );
+        setPreferredSize(new Dimension(150,400));
+
+        JLabel channelLabel = new JLabel("Icecast 2 (v2.4+) Stream");
+
+        ImageIcon icon = mIconManager.getScaledIcon(new ImageIcon(BroadcastServerType.ICECAST_HTTP.getIconPath()), 25);
+        channelLabel.setIcon(icon);
+
+        add(channelLabel, "span, align center");
+
+        add(new JLabel("Name:"));
+        mName = new JTextField();
+        mName.getDocument().addDocumentListener(this);
+        mName.setToolTipText("Unique name for this stream");
+        add(mName);
+
+        add(new JLabel("Server:"));
+        mServer = new JTextField();
+        mServer.getDocument().addDocumentListener(this);
+        mServer.setToolTipText("Server address (e.g. audio1.icecast.com or localhost)");
+        add(mServer);
+
+        add(new JLabel("Port:"));
+        mPort = new JTextField();
+        mPort.getDocument().addDocumentListener(this);
+        mPort.setToolTipText("Server port number (e.g. 80)");
+        add(mPort);
+
+        add(new JLabel("Mount:"));
+        mMountPoint = new JTextField();
+        mMountPoint.getDocument().addDocumentListener(this);
+        mMountPoint.setToolTipText("Mount point (e.g. /12345)");
+        add(mMountPoint);
+
+        add(new JLabel("User Name:"));
+        mUsername = new JTextField();
+        mUsername.getDocument().addDocumentListener(this);
+        mUsername.setToolTipText("User name for the stream. Default: source");
+        add(mUsername);
+
+        add(new JLabel("Password:"));
+        mPassword = new JTextField();
+        mPassword.getDocument().addDocumentListener(this);
+        mPassword.setToolTipText("Password for the stream");
+        add(mPassword);
+
+        add(new JLabel("Description:"));
+        mDescription = new JTextField();
+        mDescription.getDocument().addDocumentListener(this);
+        mDescription.setToolTipText("Description of the stream contents");
+        add(mDescription);
+
+        add(new JLabel("Genre:"));
+        mGenre = new JTextField();
+        mGenre.getDocument().addDocumentListener(this);
+        mGenre.setToolTipText("Genre (e.g. public safety)");
+        add(mGenre);
+
+        add(new JLabel("Public:"));
+        mPublic = new JCheckBox();
+        mPublic.addActionListener(new ActionListener()
+        {
+            @Override
+            public void actionPerformed(ActionEvent e)
+            {
+                setModified(true);
+            }
+        });
+        mPublic.setToolTipText("Designate stream as public (checked) or private");
+        add(mPublic);
+
+        add(new JLabel());
+        mDelayValue = new JLabel("0 Minutes");
+        add(mDelayValue);
+
+        add(new JLabel("Delay:"));
+        mDelay = new JSlider(0,60,0);
+        mDelay.setMajorTickSpacing(10);
+        mDelay.setMinorTickSpacing(5);
+        mDelay.addChangeListener(new ChangeListener()
+        {
+            @Override
+            public void stateChanged(ChangeEvent e)
+            {
+                mDelayValue.setText(mDelay.getValue() + " Minutes");
+                setModified(true);
+            }
+        });
+        mDelay.setToolTipText("Audio broadcast delay in minutes");
+        add(mDelay);
+
+        add(new JLabel());
+        mMaximumRecordingAgeValue = new JLabel("1 Minute");
+        add(mMaximumRecordingAgeValue);
+
+        add(new JLabel("Age Limit:"));
+        mMaximumRecordingAge = new JSlider(1,60,5);
+        mMaximumRecordingAge.setMajorTickSpacing(10);
+        mMaximumRecordingAge.setMinorTickSpacing(5);
+        mMaximumRecordingAge.addChangeListener(new ChangeListener()
+        {
+            @Override
+            public void stateChanged(ChangeEvent e)
+            {
+                int value = mMaximumRecordingAge.getValue();
+
+                mMaximumRecordingAgeValue.setText(value + " Minute" + (value > 1 ? "s" : ""));
+                setModified(true);
+            }
+        });
+        mMaximumRecordingAge.setToolTipText("Maximum recording age (in addition to delay) to stream");
+        add(mMaximumRecordingAge);
+
+        add(new JLabel("Enabled:"));
+        mEnabled = new JCheckBox();
+        mEnabled.setToolTipText("Enable (checked) or disable this stream");
+        mEnabled.addActionListener(new ActionListener()
+        {
+            @Override
+            public void actionPerformed(ActionEvent e)
+            {
+                setModified(true);
+            }
+        });
+        add(mEnabled);
+
+        mSaveButton = new JButton("Save");
+        mSaveButton.setEnabled(false);
+        mSaveButton.setToolTipText("Click to save configuration information");
+        mSaveButton.addActionListener(new ActionListener()
+        {
+            @Override
+            public void actionPerformed(ActionEvent e)
+            {
+                save();
+            }
+        });
+        add(mSaveButton);
+
+        mResetButton = new JButton("Reset");
+        mResetButton.setEnabled(false);
+        mResetButton.setToolTipText("Click to reset any changes you've made since the last save");
+        mResetButton.addActionListener(new ActionListener()
+        {
+            @Override
+            public void actionPerformed(ActionEvent e)
+            {
+                setModified(false);
+                setItem(getItem());
+            }
+        });
+        add(mResetButton);
+    }
+
+    @Override
+    public void setModified(boolean modified)
+    {
+        super.setModified(modified);
+
+        mSaveButton.setEnabled(modified);
+        mResetButton.setEnabled(modified);
+    }
+
+    @Override
+    public void setItem(BroadcastConfiguration item)
+    {
+        super.setItem(item);
+
+        if(hasItem())
+        {
+            IcecastHTTPConfiguration config = (IcecastHTTPConfiguration)getItem();
+
+            mName.setText(config.getName());
+            mServer.setText(config.getHost());
+            mPort.setText(config.getPort() != 0 ? String.valueOf(config.getPort()) : null);
+            mMountPoint.setText(config.getMountPoint());
+            mUsername.setText(config.getUserName());
+            mPassword.setText(config.getPassword());
+            mDescription.setText(config.getDescription());
+            mGenre.setText(config.getGenre());
+            mPublic.setSelected(config.isPublic());
+            mDelay.setValue((int)(config.getDelay() / ONE_MINUTE_MS));
+            mMaximumRecordingAge.setValue((int)config.getMaximumRecordingAge() / ONE_MINUTE_MS);
+            mEnabled.setSelected(config.isEnabled());
+        }
+        else
+        {
+            mName.setText(null);
+            mServer.setText(null);
+            mPort.setText(null);
+            mMountPoint.setText(null);
+            mUsername.setText(null);
+            mPassword.setText(null);
+            mDescription.setText(null);
+            mGenre.setText(null);
+            mPublic.setSelected(true);
+            mDelay.setValue(0);
+            mMaximumRecordingAge.setValue(1);
+            mEnabled.setSelected(false);
+        }
+
+        setModified(false);
+    }
+
+    @Override
+    public void save()
+    {
+        IcecastHTTPConfiguration config = (IcecastHTTPConfiguration)getItem();
+
+        if(validateConfiguration())
+        {
+            updateConfigurationName(config, mName.getText());
+            config.setHost(mServer.getText());
+            config.setPort(getPort());
+            config.setMountPoint(mMountPoint.getText());
+            config.setUserName(mUsername.getText());
+            config.setPassword(mPassword.getText());
+            config.setDescription(mDescription.getText());
+            config.setGenre(mGenre.getText());
+            config.setPublic(mPublic.isSelected());
+            config.setDelay(mDelay.getValue() * ONE_MINUTE_MS);
+            config.setMaximumRecordingAge(mMaximumRecordingAge.getValue() * ONE_MINUTE_MS);
+            config.setEnabled(mEnabled.isSelected());
+
+            setModified(false);
+
+            mBroadcastModel.process(new BroadcastEvent(getItem(), BroadcastEvent.Event.CONFIGURATION_CHANGE));
+        }
+    }
+
+    /**
+     * Validates the user specified values in the controls prior to saving them to the configuration
+     */
+    private boolean validateConfiguration()
+    {
+        String name = mName.getText();
+
+        //A unique stream name is required
+        if(!mBroadcastModel.isUniqueName(name, getItem()))
+        {
+            String message = (name == null || name.isEmpty()) ?
+                    "Please specify a stream name." : "Stream name " + name +
+                    "is already in use.\nPlease choose another name.";
+
+            JOptionPane.showMessageDialog(IcecastHTTPConfigurationEditor.this,
+                    message, "Invalid Stream Name", JOptionPane.ERROR_MESSAGE);
+
+            mName.requestFocus();
+
+            return false;
+        }
+
+        //Server address is optional, but required
+        if(!validateTextField(mServer, "Invalid Server Address", "Please specify a server address."))
+        {
+            return true;
+        }
+
+        //Port is optional, but required
+        if(!validateIntegerTextField(mPort, "Invalid Port Number", "Please specify a port number (1 <> 65535)", 1, 65535))
+        {
+            return true;
+        }
+
+        //Mount Point is required
+        if(!validateTextField(mMountPoint, "Invalid Mount Point", "Please specify a mount point."))
+        {
+            return false;
+        }
+
+        //User name is required
+        if(!validateTextField(mUsername, "Invalid User Name", "Please specify a user name."))
+        {
+            return false;
+        }
+
+        //Password is required
+        if(!validateTextField(mPassword, "Invalid Password", "Please specify a password."))
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Parses an Integer from the port text control or returns 0 if the control doesn't contain an integer value.
+     */
+    private int getPort()
+    {
+        String port = mPort.getText();
+
+        if(port != null && !port.isEmpty())
+        {
+            try
+            {
+                return Integer.parseInt(port);
+            }
+            catch(Exception e)
+            {
+                //Do nothing, we couldn't parse the number value
+            }
+        }
+
+        return 0;
+    }
+}

src/main/java/audio/broadcast/icecast/IcecastHeader.java

@@ -0,0 +1,50 @@
+/*******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2016 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 audio.broadcast.icecast;
+
+public enum IcecastHeader
+{
+    ACCEPT("Accept"),
+    AUDIO_INFO("ice-audio-info"),
+    AUTHORIZATION("Authorization"),
+    BITRATE("ice-bitrate"),
+    CONTENT_TYPE("Content-Type"),
+    DESCRIPTION("ice-description"),
+    EXPECT("Expect"),
+    GENRE("ice-genre"),
+    HOST("Host"),
+    NAME("ice-name"),
+    PUBLIC("ice-public"),
+    URL("ice-url"),
+    USER_AGENT("User-Agent"),
+
+    UNKNOWN("unknown");
+
+    private String mValue;
+
+    private IcecastHeader(String value)
+    {
+        mValue = value;
+    }
+
+    public String getValue()
+    {
+        return mValue;
+    }
+}

src/main/java/audio/broadcast/icecast/IcecastTCPAudioBroadcaster.java

@@ -0,0 +1,355 @@
+/*******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2016 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 audio.broadcast.icecast;
+
+import audio.broadcast.BroadcastState;
+import audio.broadcast.icecast.codec.IcecastCodecFactory;
+import audio.convert.MP3AudioConverter;
+import org.apache.mina.core.RuntimeIoException;
+import org.apache.mina.core.future.ConnectFuture;
+import org.apache.mina.core.service.IoHandlerAdapter;
+import org.apache.mina.core.session.IoSession;
+import org.apache.mina.core.write.WriteTimeoutException;
+import org.apache.mina.filter.codec.ProtocolCodecFilter;
+import org.apache.mina.transport.socket.nio.NioSocketConnector;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import properties.SystemProperties;
+import util.ThreadPool;
+
+import java.io.IOException;
+import java.net.ConnectException;
+import java.net.InetSocketAddress;
+import java.nio.channels.UnresolvedAddressException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class IcecastTCPAudioBroadcaster extends IcecastAudioBroadcaster
+{
+    private final static Logger mLog = LoggerFactory.getLogger(IcecastTCPAudioBroadcaster.class);
+    private final static String TERMINATOR = "\r\n";
+    private final static String SEPARATOR = ":";
+    private static final long RECONNECT_INTERVAL_MILLISECONDS = 3000; //3 seconds
+    private static final long CONNECTION_ATTEMPT_TIMEOUT = 5000; //5 seconds
+
+    private NioSocketConnector mSocketConnector;
+    private IoSession mStreamingSession = null;
+
+    private long mLastConnectionAttempt = 0;
+    private AtomicBoolean mConnecting = new AtomicBoolean();
+
+    /**
+     * Creates an Icecast 2.3.2 compatible broadcaster using TCP and a pseudo HTTP 1.0 protocol.  This broadcaster is
+     * compatible with Icecast version 2.3.2 and older versions of the server software.
+     *
+     * Note: use @see IcecastHTTPAudioBroadcaster for Icecast version 2.4.x and newer.
+     *
+     * This broadcaster uses the Apache Mina library for the streaming socket connection and for metadata updates.  The
+     * ShoutcastV2IOHandler manages all interaction with the Icecast server and manages the overall broadcast state.
+     *
+     * @param configuration for the Icecast stream
+     */
+    public IcecastTCPAudioBroadcaster(IcecastTCPConfiguration configuration)
+    {
+        super(configuration);
+    }
+
+    /**
+     * Broadcasts the audio frame or sequence
+     */
+    @Override
+    protected void broadcastAudio(byte[] audio)
+    {
+        if(audio != null && audio.length > 0 && connect() && mStreamingSession != null && mStreamingSession.isConnected())
+        {
+            mStreamingSession.write(audio);
+        }
+    }
+
+    /**
+     * (Re)Connects the broadcaster to the remote server if it currently is disconnected and indicates if the broadcaster
+     * is currently connected to the remote server following any connection attempts.
+     *
+     * Attempts to connect via this method when the broadcast state indicates an error condition will be ignored.
+     *
+     * @return true if the audio handler can stream audio
+     */
+    private boolean connect()
+    {
+        if(!connected() && canConnect() &&
+            (mLastConnectionAttempt + RECONNECT_INTERVAL_MILLISECONDS < System.currentTimeMillis()) &&
+            mConnecting.compareAndSet(false, true))
+        {
+            mLastConnectionAttempt = System.currentTimeMillis();
+
+            if(mSocketConnector == null)
+            {
+                mSocketConnector = new NioSocketConnector();
+                mSocketConnector.setConnectTimeoutCheckInterval(CONNECTION_ATTEMPT_TIMEOUT);
+
+//                LoggingFilter loggingFilter = new LoggingFilter(IcecastTCPAudioBroadcaster.class);
+//                loggingFilter.setMessageSentLogLevel(LogLevel.NONE);
+//                mSocketConnector.getFilterChain().addLast("logger", loggingFilter);
+
+                mSocketConnector.getFilterChain().addLast("codec",
+                    new ProtocolCodecFilter(new IcecastCodecFactory()));
+                mSocketConnector.setHandler(new IcecastTCPIOHandler());
+            }
+
+            mStreamingSession = null;
+
+            Runnable runnable = new Runnable()
+            {
+                @Override
+                public void run()
+                {
+                    setBroadcastState(BroadcastState.CONNECTING);
+
+                    try
+                    {
+                        ConnectFuture future = mSocketConnector
+                            .connect(new InetSocketAddress(getBroadcastConfiguration().getHost(),
+                                getBroadcastConfiguration().getPort()));
+
+                        boolean connected = future.await(CONNECTION_ATTEMPT_TIMEOUT, TimeUnit.MILLISECONDS);
+
+                        mStreamingSession = future.getSession();
+                    }
+                    catch(UnresolvedAddressException uae)
+                    {
+                        //What do you do with this?  Nothing.
+                    }
+                    catch(InterruptedException ie)
+                    {
+                        //We couldn't connect within the timeout period -- disconnect so that we can try again later
+                        disconnect();
+                    }
+                    catch(RuntimeIoException rie)
+                    {
+                        Throwable throwableCause = rie.getCause();
+
+                        if(throwableCause instanceof ConnectException)
+                        {
+                            setBroadcastState(BroadcastState.NO_SERVER);
+                        }
+                        else if(throwableCause != null)
+                        {
+                            setBroadcastState(BroadcastState.ERROR);
+                            mLog.debug("[" + getStreamName() + "] failed to connect", rie);
+                        }
+                        else
+                        {
+                            setBroadcastState(BroadcastState.ERROR);
+                            mLog.debug("[" + getStreamName() + "] failed to connect - no exception is available");
+                        }
+
+                        disconnect();
+                    }
+                    catch(Throwable t)
+                    {
+                        disconnect();
+                    }
+
+                    mConnecting.set(false);
+                }
+            };
+
+            ThreadPool.SCHEDULED.schedule(runnable, 0l, TimeUnit.SECONDS);
+        }
+
+        return connected();
+    }
+
+
+    /**
+     * Disconnect from the remote broadcast server and cleanup input/output streams and socket connection
+     */
+    public void disconnect()
+    {
+        if(connected() && mStreamingSession != null)
+        {
+            mStreamingSession.closeNow();
+        }
+        else
+        {
+            mLastConnectionAttempt = System.currentTimeMillis();
+        }
+    }
+
+    /**
+     * IO Handler for managing Icecast TCP connection and credentials
+     */
+    public class IcecastTCPIOHandler extends IoHandlerAdapter
+    {
+        /**
+         * Sends stream configuration and user credentials upon connecting to remote server
+         */
+        @Override
+        public void sessionOpened(IoSession session) throws Exception
+        {
+            StringBuilder sb = new StringBuilder();
+            sb.append("SOURCE ").append(getConfiguration().getMountPoint());
+            sb.append(" HTTP/1.0").append(TERMINATOR);
+
+            sb.append("Authorization: ").append(getConfiguration().getBase64EncodedCredentials()).append(TERMINATOR);
+            sb.append(IcecastHeader.USER_AGENT.getValue()).append(SEPARATOR)
+                .append(SystemProperties.getInstance().getApplicationName()).append(TERMINATOR);
+            sb.append(IcecastHeader.CONTENT_TYPE.getValue()).append(SEPARATOR)
+                .append(getConfiguration().getBroadcastFormat().getValue()).append(TERMINATOR);
+            sb.append(IcecastHeader.PUBLIC.getValue()).append(SEPARATOR)
+                .append(getConfiguration().isPublic() ? "1" : "0").append(TERMINATOR);
+
+            sb.append(IcecastHeader.AUDIO_INFO.getValue()).append(SEPARATOR);
+            sb.append("samplerate=").append(getConfiguration().getSampleRate()).append(";");
+            sb.append("quality=").append(MP3AudioConverter.AUDIO_QUALITY).append(";");
+            sb.append("channels=").append(getConfiguration().getChannels()).append(TERMINATOR);
+
+            if(getConfiguration().hasName())
+            {
+                sb.append(IcecastHeader.NAME.getValue()).append(SEPARATOR).append(getConfiguration().getName()).append(TERMINATOR);
+            }
+
+            if(getConfiguration().hasGenre())
+            {
+                sb.append(IcecastHeader.GENRE.getValue()).append(SEPARATOR)
+                    .append(getConfiguration().getGenre()).append(TERMINATOR);
+            }
+
+            if(getConfiguration().hasDescription())
+            {
+                sb.append(IcecastHeader.DESCRIPTION.getValue()).append(SEPARATOR)
+                    .append(getConfiguration().getDescription()).append(TERMINATOR);
+            }
+
+            sb.append(TERMINATOR).append(TERMINATOR);
+
+            session.write(sb.toString());
+        }
+
+        @Override
+        public void sessionClosed(IoSession session) throws Exception
+        {
+            mLastConnectionAttempt = System.currentTimeMillis();
+
+            //If there is already an error state, don't override it.  Otherwise, set state to disconnected
+            if(!getBroadcastState().isErrorState())
+            {
+                setBroadcastState(BroadcastState.DISCONNECTED);
+            }
+
+            mStreamingSession = null;
+
+            mConnecting.set(false);
+
+            super.sessionClosed(session);
+        }
+
+        @Override
+        public void exceptionCaught(IoSession session, Throwable cause) throws Exception
+        {
+            if(cause instanceof IOException)
+            {
+                IOException ioe = (IOException)cause;
+
+                if(ioe.getMessage() != null)
+                {
+                    String reason = ioe.getMessage();
+
+                    if(connected())
+                    {
+                        disconnect();
+                    }
+                    else if(reason.startsWith("Connection reset"))
+                    {
+                        disconnect();
+                    }
+                    else if(reason.startsWith("Operation timed out"))
+                    {
+                        disconnect();
+                    }
+                    else
+                    {
+                        setBroadcastState(BroadcastState.ERROR);
+                        disconnect();
+                    }
+                }
+                else if(ioe instanceof WriteTimeoutException)
+                {
+                    disconnect();
+                }
+                else
+                {
+                    setBroadcastState(BroadcastState.ERROR);
+                    disconnect();
+                    mLog.error("[" + getStreamName() + "] Unspecified IO error - streaming halted.", cause);
+                }
+            }
+            else
+            {
+                mLog.error("[" + getStreamName() + "] Broadcast error", cause);
+                setBroadcastState(BroadcastState.ERROR);
+                disconnect();
+            }
+        }
+
+        @Override
+        public void messageReceived(IoSession session, Object object) throws Exception
+        {
+            if(object instanceof String)
+            {
+                String message = (String) object;
+
+                if(message != null && !message.trim().isEmpty())
+                {
+                    if(message.startsWith("HTTP/1.0 200 OK"))
+                    {
+                        setBroadcastState(BroadcastState.CONNECTED);
+                    }
+                    else if(message.startsWith("HTTP/1.0 403 Mountpoint in use"))
+                    {
+                        setBroadcastState(BroadcastState.MOUNT_POINT_IN_USE);
+                    }
+                    else if(message.contains("Content-Type: text/html"))
+                    {
+                        //Disregard ... this normally follows the mount point in use error
+                    }
+                    else if(message.contains("Invalid Password") ||
+                        message.contains("Authentication Required"))
+                    {
+                        setBroadcastState(BroadcastState.INVALID_CREDENTIALS);
+                    }
+                    else if(message.contains("HTTP/1.1 501"))
+                    {
+                        disconnect(); //So that we can reconnect later
+                    }
+                    else
+                    {
+                        mLog.error("Unrecognized server response:" + message);
+                        setBroadcastState(BroadcastState.ERROR);
+                    }
+                }
+            }
+            else
+            {
+                mLog.error("[" + getStreamName() + "]Icecast TCP broadcaster - unrecognized message [ " + object.getClass() +
+                    "] received:" + object.toString());
+            }
+        }
+    }
+}

src/main/java/audio/broadcast/icecast/IcecastTCPConfiguration.java

@@ -0,0 +1,78 @@
+/*******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2016 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 audio.broadcast.icecast;
+
+import audio.broadcast.BroadcastConfiguration;
+import audio.broadcast.BroadcastFormat;
+import audio.broadcast.BroadcastServerType;
+import audio.broadcast.broadcastify.BroadcastifyConfiguration;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.xml.bind.annotation.XmlSeeAlso;
+
+@XmlSeeAlso( {BroadcastifyConfiguration.class } )
+public class IcecastTCPConfiguration extends IcecastConfiguration
+{
+    private final static Logger mLog = LoggerFactory.getLogger( IcecastTCPConfiguration.class );
+
+    public IcecastTCPConfiguration()
+    {
+        this(BroadcastFormat.MP3);
+    }
+
+    /**
+     * Icecast 2.3.x and 2.4.x compatible configuration
+     * @param format of audio
+     */
+    public IcecastTCPConfiguration(BroadcastFormat format)
+    {
+        super(format);
+    }
+
+    @Override
+    public BroadcastConfiguration copyOf()
+    {
+        IcecastTCPConfiguration copy = new IcecastTCPConfiguration(getBroadcastFormat());
+
+        //Broadcast Configuration Parameters
+        copy.setName(getName());
+        copy.setHost(getHost());
+        copy.setPort(getPort());
+        copy.setPassword(getPassword());
+        copy.setDelay(getDelay());
+        copy.setEnabled(false);
+
+        //Icecast Configuration Parameters
+        copy.setUserName(getUserName());
+        copy.setMountPoint(getMountPoint());
+        copy.setDescription(getDescription());
+        copy.setGenre(getGenre());
+        copy.setPublic(isPublic());
+        copy.setURL(getURL());
+
+        return copy;
+    }
+
+    @Override
+    public BroadcastServerType getBroadcastServerType()
+    {
+        return BroadcastServerType.ICECAST_TCP;
+    }
+}

src/main/java/audio/broadcast/icecast/IcecastTCPConfigurationEditor.java

@@ -0,0 +1,362 @@
+/*******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2016 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 audio.broadcast.icecast;
+
+import alias.AliasModel;
+import audio.broadcast.BroadcastConfiguration;
+import audio.broadcast.BroadcastConfigurationEditor;
+import audio.broadcast.BroadcastEvent;
+import audio.broadcast.BroadcastModel;
+import audio.broadcast.BroadcastServerType;
+import icon.IconManager;
+import net.miginfocom.swing.MigLayout;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import settings.SettingsManager;
+
+import javax.swing.*;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+public class IcecastTCPConfigurationEditor extends BroadcastConfigurationEditor
+{
+    private final static Logger mLog = LoggerFactory.getLogger( IcecastTCPConfigurationEditor.class );
+
+    private static final int ONE_MINUTE_MS = 60000;
+
+    private JTextField mName;
+    private JTextField mServer;
+    private JTextField mPort;
+    private JTextField mMountPoint;
+    private JTextField mPassword;
+    private JTextField mDescription;
+    private JTextField mGenre;
+    private JCheckBox mPublic;
+    private JSlider mDelay;
+    private JLabel mDelayValue;
+    private JSlider mMaximumRecordingAge;
+    private JLabel mMaximumRecordingAgeValue;
+    private JCheckBox mEnabled;
+    private JButton mSaveButton;
+    private JButton mResetButton;
+
+    public IcecastTCPConfigurationEditor(BroadcastModel broadcastModel, AliasModel aliasModel, IconManager iconManager)
+    {
+        super(broadcastModel, aliasModel, iconManager);
+        init();
+    }
+
+    private void init()
+    {
+        setLayout( new MigLayout( "fill,wrap 2", "[align right][grow,fill]",
+            "[][][][][][][][][][][][][][][][grow,fill]" ) );
+        setPreferredSize(new Dimension(150,400));
+
+        JLabel channelLabel = new JLabel("Icecast (v2.3) Stream");
+
+        ImageIcon icon = mIconManager.getScaledIcon(new ImageIcon(BroadcastServerType.ICECAST_TCP.getIconPath()), 25);
+        channelLabel.setIcon(icon);
+
+        add(channelLabel, "span, align center");
+
+        add(new JLabel("Name:"));
+        mName = new JTextField();
+        mName.getDocument().addDocumentListener(this);
+        mName.setToolTipText("Unique name for this stream");
+        add(mName);
+
+        add(new JLabel("Server:"));
+        mServer = new JTextField();
+        mServer.getDocument().addDocumentListener(this);
+        mServer.setToolTipText("Server address (e.g. audio1.icecast.com or localhost)");
+        add(mServer);
+
+        add(new JLabel("Port:"));
+        mPort = new JTextField();
+        mPort.getDocument().addDocumentListener(this);
+        mPort.setToolTipText("Server port number (e.g. 80)");
+        add(mPort);
+
+        add(new JLabel("Mount:"));
+        mMountPoint = new JTextField();
+        mMountPoint.getDocument().addDocumentListener(this);
+        mMountPoint.setToolTipText("Mount point (e.g. /12345)");
+        add(mMountPoint);
+
+        add(new JLabel("Password:"));
+        mPassword = new JTextField();
+        mPassword.getDocument().addDocumentListener(this);
+        mPassword.setToolTipText("Password for the stream");
+        add(mPassword);
+
+        add(new JLabel("Description:"));
+        mDescription = new JTextField();
+        mDescription.getDocument().addDocumentListener(this);
+        mDescription.setToolTipText("Description of the stream contents");
+        add(mDescription);
+
+        add(new JLabel("Genre:"));
+        mGenre = new JTextField();
+        mGenre.getDocument().addDocumentListener(this);
+        mGenre.setToolTipText("Genre (e.g. public safety)");
+        add(mGenre);
+
+        add(new JLabel("Public:"));
+        mPublic = new JCheckBox();
+        mPublic.addActionListener(new ActionListener()
+        {
+            @Override
+            public void actionPerformed(ActionEvent e)
+            {
+                setModified(true);
+            }
+        });
+        mPublic.setToolTipText("Designate stream as public (checked) or private");
+        add(mPublic);
+
+        add(new JLabel());
+        mDelayValue = new JLabel("0 Minutes");
+        add(mDelayValue);
+
+        add(new JLabel("Delay:"));
+        mDelay = new JSlider(0,60,0);
+        mDelay.setMajorTickSpacing(10);
+        mDelay.setMinorTickSpacing(5);
+        mDelay.addChangeListener(new ChangeListener()
+        {
+            @Override
+            public void stateChanged(ChangeEvent e)
+            {
+                mDelayValue.setText(mDelay.getValue() + " Minutes");
+                setModified(true);
+            }
+        });
+        mDelay.setToolTipText("Audio broadcast delay in minutes");
+        add(mDelay);
+
+        add(new JLabel());
+        mMaximumRecordingAgeValue = new JLabel("1 Minute");
+        add(mMaximumRecordingAgeValue);
+
+        add(new JLabel("Age Limit:"));
+        mMaximumRecordingAge = new JSlider(1,60,5);
+        mMaximumRecordingAge.setMajorTickSpacing(10);
+        mMaximumRecordingAge.setMinorTickSpacing(5);
+        mMaximumRecordingAge.addChangeListener(new ChangeListener()
+        {
+            @Override
+            public void stateChanged(ChangeEvent e)
+            {
+                int value = mMaximumRecordingAge.getValue();
+
+                mMaximumRecordingAgeValue.setText(value + " Minute" + (value > 1 ? "s" : ""));
+                setModified(true);
+            }
+        });
+        mMaximumRecordingAge.setToolTipText("Maximum recording age (in addition to delay) to stream");
+        add(mMaximumRecordingAge);
+
+        add(new JLabel("Enabled:")); //Empty
+        mEnabled = new JCheckBox();
+        mEnabled.setToolTipText("Enable (checked) or disable this stream");
+        mEnabled.addActionListener(new ActionListener()
+        {
+            @Override
+            public void actionPerformed(ActionEvent e)
+            {
+                setModified(true);
+            }
+        });
+        add(mEnabled);
+
+        mSaveButton = new JButton("Save");
+        mSaveButton.setEnabled(false);
+        mSaveButton.setToolTipText("Click to save configuration information");
+        mSaveButton.addActionListener(new ActionListener()
+        {
+            @Override
+            public void actionPerformed(ActionEvent e)
+            {
+                save();
+            }
+        });
+        add(mSaveButton);
+
+        mResetButton = new JButton("Reset");
+        mResetButton.setEnabled(false);
+        mResetButton.setToolTipText("Click to reset any changes you've made since the last save");
+        mResetButton.addActionListener(new ActionListener()
+        {
+            @Override
+            public void actionPerformed(ActionEvent e)
+            {
+                setModified(false);
+                setItem(getItem());
+            }
+        });
+        add(mResetButton);
+    }
+
+    @Override
+    public void setModified(boolean modified)
+    {
+        super.setModified(modified);
+
+        mSaveButton.setEnabled(modified);
+        mResetButton.setEnabled(modified);
+    }
+
+    @Override
+    public void setItem(BroadcastConfiguration item)
+    {
+        super.setItem(item);
+
+        if(hasItem())
+        {
+            IcecastTCPConfiguration config = (IcecastTCPConfiguration)getItem();
+
+            mName.setText(config.getName());
+            mServer.setText(config.getHost());
+            mPort.setText(config.getPort() != 0 ? String.valueOf(config.getPort()) : null);
+            mMountPoint.setText(config.getMountPoint());
+            mPassword.setText(config.getPassword());
+            mDescription.setText(config.getDescription());
+            mGenre.setText(config.getGenre());
+            mPublic.setSelected(config.isPublic());
+            mDelay.setValue((int)(config.getDelay() / ONE_MINUTE_MS));
+            mMaximumRecordingAge.setValue((int)config.getMaximumRecordingAge() / ONE_MINUTE_MS);
+            mEnabled.setSelected(config.isEnabled());
+        }
+        else
+        {
+            mName.setText(null);
+            mServer.setText(null);
+            mPort.setText(null);
+            mMountPoint.setText(null);
+            mPassword.setText(null);
+            mDescription.setText(null);
+            mGenre.setText(null);
+            mPublic.setSelected(true);
+            mDelay.setValue(0);
+            mMaximumRecordingAge.setValue(1);
+            mEnabled.setSelected(false);
+        }
+
+        setModified(false);
+    }
+
+    @Override
+    public void save()
+    {
+        IcecastTCPConfiguration config = (IcecastTCPConfiguration)getItem();
+
+        if(validateConfiguration())
+        {
+            updateConfigurationName(config, mName.getText());
+            config.setHost(mServer.getText());
+            config.setPort(getPort());
+            config.setMountPoint(mMountPoint.getText());
+            config.setPassword(mPassword.getText());
+            config.setDescription(mDescription.getText());
+            config.setGenre(mGenre.getText());
+            config.setPublic(mPublic.isSelected());
+            config.setDelay(mDelay.getValue() * ONE_MINUTE_MS);
+            config.setMaximumRecordingAge(mMaximumRecordingAge.getValue() * ONE_MINUTE_MS);
+            config.setEnabled(mEnabled.isSelected());
+
+            setModified(false);
+
+            mBroadcastModel.process(new BroadcastEvent(getItem(), BroadcastEvent.Event.CONFIGURATION_CHANGE));
+        }
+    }
+
+    /**
+     * Validates the user specified values in the controls prior to saving them to the configuration
+     */
+    private boolean validateConfiguration()
+    {
+        String name = mName.getText();
+
+        //A unique stream name is required
+        if(!mBroadcastModel.isUniqueName(name, getItem()))
+        {
+            String message = (name == null || name.isEmpty()) ?
+                    "Please specify a stream name." : "Stream name " + name +
+                    "is already in use.\nPlease choose another name.";
+
+            JOptionPane.showMessageDialog(IcecastTCPConfigurationEditor.this,
+                    message, "Invalid Stream Name", JOptionPane.ERROR_MESSAGE);
+
+            mName.requestFocus();
+
+            return false;
+        }
+
+        //Server address is optional, but required
+        if(!validateTextField(mServer, "Invalid Server Address", "Please specify a server address."))
+        {
+            return true;
+        }
+
+        //Port is optional, but required
+        if(!validateIntegerTextField(mPort, "Invalid Port Number", "Please specify a port number (1 <> 65535)", 1, 65535))
+        {
+            return true;
+        }
+
+        //Mount Point is optional, but required
+        if(!validateTextField(mMountPoint, "Invalid Mount Point", "Please specify a mount point."))
+        {
+            return true;
+        }
+
+        //Password is optional, but required
+        if(!validateTextField(mPassword, "Invalid Password", "Please specify a password."))
+        {
+            return true;
+        }
+
+        return true;
+    }
+
+    /**
+     * Parses an Integer from the port text control or returns 0 if the control doesn't contain an integer value.
+     */
+    private int getPort()
+    {
+        String port = mPort.getText();
+
+        if(port != null && !port.isEmpty())
+        {
+            try
+            {
+                return Integer.parseInt(port);
+            }
+            catch(Exception e)
+            {
+                //Do nothing, we couldn't parse the number value
+            }
+        }
+
+        return 0;
+    }
+}

src/main/java/audio/broadcast/icecast/codec/IcecastCodecFactory.java

@@ -0,0 +1,63 @@
+/*******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2016 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 audio.broadcast.icecast.codec;
+
+import org.apache.mina.core.session.IoSession;
+import org.apache.mina.filter.codec.ProtocolCodecFactory;
+import org.apache.mina.filter.codec.ProtocolDecoder;
+import org.apache.mina.filter.codec.ProtocolEncoder;
+import org.apache.mina.filter.codec.textline.LineDelimiter;
+import org.apache.mina.filter.codec.textline.TextLineDecoder;
+
+import java.nio.charset.StandardCharsets;
+
+public class IcecastCodecFactory implements ProtocolCodecFactory
+{
+    private ProtocolEncoder mProtocolEncoder;
+    private ProtocolDecoder mProtocolDecoder;
+
+    /**
+     * Factory for codecs to process Icecast string protocol and byte array audio frames for use with Apache Mina
+     */
+    public IcecastCodecFactory()
+    {
+    }
+
+    @Override
+    public ProtocolEncoder getEncoder(IoSession ioSession) throws Exception
+    {
+        if(mProtocolEncoder == null)
+        {
+            mProtocolEncoder = new IcecastEncoder();
+        }
+
+        return mProtocolEncoder;
+    }
+
+    @Override
+    public ProtocolDecoder getDecoder(IoSession ioSession) throws Exception
+    {
+        if(mProtocolDecoder == null)
+        {
+            mProtocolDecoder =  new TextLineDecoder(StandardCharsets.UTF_8, LineDelimiter.AUTO);
+        }
+
+        return mProtocolDecoder;
+    }
+}

src/main/java/audio/broadcast/icecast/codec/IcecastEncoder.java

@@ -0,0 +1,94 @@
+/*******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2016 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 audio.broadcast.icecast.codec;
+
+import org.apache.mina.core.buffer.IoBuffer;
+import org.apache.mina.core.session.AttributeKey;
+import org.apache.mina.core.session.IoSession;
+import org.apache.mina.filter.codec.ProtocolEncoderAdapter;
+import org.apache.mina.filter.codec.ProtocolEncoderOutput;
+import org.apache.mina.filter.codec.textline.LineDelimiter;
+import org.apache.mina.filter.codec.textline.TextLineEncoder;
+
+import java.nio.charset.Charset;
+import java.nio.charset.CharsetEncoder;
+import java.nio.charset.StandardCharsets;
+
+public class IcecastEncoder extends ProtocolEncoderAdapter
+{
+    private static final AttributeKey ENCODER = new AttributeKey(TextLineEncoder.class, "encoder");
+    private static final Charset mCharset = StandardCharsets.UTF_8;
+    private static final int MAX_LINE_LENGTH = 2147483647;
+
+    /**
+     * Icecast Protocol Encoder is an Apache Mina compliant protocol encoder that supports Icecast string-based
+     * connection negotiation as well as byte array audio frame data.
+     */
+    public IcecastEncoder()
+    {
+    }
+
+    @Override
+    public void encode(IoSession session, Object message, ProtocolEncoderOutput out) throws Exception
+    {
+        //Audio frame data
+        if(message instanceof byte[])
+        {
+            byte[] data = (byte[])message;
+
+            IoBuffer buf = IoBuffer.allocate(data.length).setAutoExpand(false);
+            buf.put(data);
+            buf.flip();
+            out.write(buf);
+        }
+        //Icecast connection messages
+        else if(message instanceof String)
+        {
+            CharsetEncoder encoder = (CharsetEncoder)session.getAttribute(ENCODER);
+
+            if(encoder == null)
+            {
+                encoder = mCharset.newEncoder();
+                session.setAttribute(ENCODER, encoder);
+            }
+
+            String value = (String)message;
+
+            IoBuffer buf = IoBuffer.allocate(value.length()).setAutoExpand(true);
+
+            buf.putString(value, encoder);
+
+
+            if(buf.position() > MAX_LINE_LENGTH)
+            {
+                throw new IllegalArgumentException("Line length: " + buf.position());
+            }
+            else
+            {
+                buf.putString(LineDelimiter.UNIX.getValue(), encoder);
+                buf.flip();
+                out.write(buf);
+            }
+        }
+        else
+        {
+            throw new IllegalArgumentException("Can't encode - unrecognized object type: " + message.getClass());
+        }
+    }
+}

src/main/java/audio/broadcast/shoutcast/v1/ShoutcastMetadata.java

@@ -0,0 +1,95 @@
+/*******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2016 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 audio.broadcast.shoutcast.v1;
+
+import audio.broadcast.BroadcastFormat;
+
+public enum ShoutcastMetadata
+{
+    AIM("icy-aim:"),
+    AUDIO_BIT_RATE("icy-br:"),
+    CHANNELS("icy-channels:"),
+    CONTENT_TYPE("Content-Type:"),
+    DESCRIPTION("icy-description:"),
+    GENRE("icy-genre:"),
+    ICE_AUDIO_INFO("ice-audio-info:"),
+    ICQ("icy-icq:"),
+    INTERNET_RELAY_CHAT("icy-irc:"),
+    METADATA_INTERVAL("icy-metaint:"),
+    METADATA_REQUEST("icy-metadata:"),
+    PRE_BUFFER("icy-prebuffer:"),
+    PUBLIC("icy-pub:"),
+    RESET("icy-reset:"),
+    SERVER("server:"),
+    STREAM_NAME("icy-name:"),
+    SONG_TITLE("icy-title:"),
+    URL("icy-url:"),
+    USER_AGENT("User-Agent:"),
+    UNKNOWN("Unknown");
+
+    private String mTag;
+
+    private ShoutcastMetadata(String tag)
+    {
+        mTag = tag;
+    }
+
+    public static final String COMMAND_TERMINATOR = "\n";
+
+    public String toString()
+    {
+        return mTag;
+    }
+
+    /**
+     * Encodes the metadata tag and value with an end-of-line character, appropriate for sending over the network.
+     */
+    public String encode(String value)
+    {
+        if(value != null && !value.isEmpty())
+        {
+            StringBuilder sb = new StringBuilder();
+            sb.append(mTag).append(value).append(COMMAND_TERMINATOR);
+            return sb.toString();
+        }
+
+        return null;
+    }
+
+    public String encode(boolean value)
+    {
+        StringBuilder sb = new StringBuilder();
+        sb.append(mTag).append(value ? "1" : "0").append(COMMAND_TERMINATOR);
+        return sb.toString();
+    }
+
+    public String encode(BroadcastFormat broadcastFormat)
+    {
+        StringBuilder sb = new StringBuilder();
+        sb.append(mTag).append(broadcastFormat.getValue()).append(COMMAND_TERMINATOR);
+        return sb.toString();
+    }
+
+    public String encode(int value)
+    {
+        StringBuilder sb = new StringBuilder();
+        sb.append(mTag).append(String.valueOf(value)).append(COMMAND_TERMINATOR);
+        return sb.toString();
+    }
+}

src/main/java/audio/broadcast/shoutcast/v1/ShoutcastV1AudioBroadcaster.java

@@ -0,0 +1,324 @@
+/*******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2016 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 audio.broadcast.shoutcast.v1;
+
+import audio.broadcast.AudioBroadcaster;
+import audio.broadcast.BroadcastState;
+import audio.broadcast.IBroadcastMetadataUpdater;
+import org.apache.mina.core.RuntimeIoException;
+import org.apache.mina.core.buffer.IoBuffer;
+import org.apache.mina.core.future.ConnectFuture;
+import org.apache.mina.core.service.IoHandlerAdapter;
+import org.apache.mina.core.session.IoSession;
+import org.apache.mina.filter.codec.ProtocolCodecFilter;
+import org.apache.mina.filter.codec.textline.TextLineCodecFactory;
+import org.apache.mina.transport.socket.nio.NioSocketConnector;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import util.ThreadPool;
+
+import java.io.IOException;
+import java.net.ConnectException;
+import java.net.InetSocketAddress;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class ShoutcastV1AudioBroadcaster extends AudioBroadcaster
+{
+    private final static Logger mLog = LoggerFactory.getLogger(ShoutcastV1AudioBroadcaster.class);
+    private static final long RECONNECT_INTERVAL_MILLISECONDS = 30000; //30 seconds
+
+    private NioSocketConnector mSocketConnector;
+    private IoSession mStreamingSession = null;
+    private IBroadcastMetadataUpdater mMetadataUpdater;
+
+    private long mLastConnectionAttempt = 0;
+    private AtomicBoolean mConnecting = new AtomicBoolean();
+
+    /**
+     * Creates a Shoutcast v1 compatible broadcaster using TCP protocol.
+     *
+     * Note: use @see ShoutcastV2AudioBroadcaster for Shoutcast version 2.x and newer.
+     *
+     * This broadcaster uses the Apache Mina library for the streaming socket connection and for metadata updates.  The
+     * ShoutcastV1IOHandler manages all interaction with the Shoutcast server and manages the overall broadcast state.
+     *
+     * @param configuration for the Shoutcast stream
+     */
+    public ShoutcastV1AudioBroadcaster(ShoutcastV1Configuration configuration)
+    {
+        super(configuration);
+    }
+
+    /**
+     * Shoutcast V1 broadcast configuration
+     */
+    private ShoutcastV1Configuration getConfiguration()
+    {
+        return (ShoutcastV1Configuration) getBroadcastConfiguration();
+    }
+
+    @Override
+    protected IBroadcastMetadataUpdater getMetadataUpdater()
+    {
+        if(mMetadataUpdater == null)
+        {
+            mMetadataUpdater = new ShoutcastV1BroadcastMetadataUpdater(getConfiguration());
+        }
+
+        return mMetadataUpdater;
+    }
+
+    /**
+     * Broadcasts the audio frame or sequence
+     */
+    @Override
+    protected void broadcastAudio(byte[] audio)
+    {
+        if(audio != null && audio.length > 0 && connect() && mStreamingSession != null && mStreamingSession.isConnected())
+        {
+            IoBuffer buf = IoBuffer.allocate(audio.length).setAutoExpand(false);
+            buf.put(audio);
+            buf.flip();
+            mStreamingSession.write(buf);
+        }
+    }
+
+    /**
+     * (Re)Connects the broadcaster to the remote server if it currently is disconnected and indicates if the broadcaster
+     * is currently connected to the remote server following any connection attempts.
+     *
+     * Attempts to connect via this method when the broadcast state indicates an error condition will be ignored.
+     *
+     * @return true if the audio handler can stream audio
+     */
+    private boolean connect()
+    {
+        if(!connected() && canConnect() &&
+            (mLastConnectionAttempt + RECONNECT_INTERVAL_MILLISECONDS < System.currentTimeMillis()) &&
+            mConnecting.compareAndSet(false, true))
+        {
+            mLastConnectionAttempt = System.currentTimeMillis();
+
+            if(mSocketConnector == null)
+            {
+                mSocketConnector = new NioSocketConnector();
+                mSocketConnector.setConnectTimeoutCheckInterval(10000);
+
+//                mSocketConnector.getFilterChain().addLast("logger",
+//                    new LoggingFilter(ShoutcastV1AudioBroadcaster.class));
+
+                mSocketConnector.getFilterChain().addLast("codec",
+                    new ProtocolCodecFilter(new TextLineCodecFactory()));
+
+                mSocketConnector.setHandler(new ShoutcastIOHandler());
+            }
+
+            mStreamingSession = null;
+
+            Runnable runnable = new Runnable()
+            {
+                @Override
+                public void run()
+                {
+                    setBroadcastState(BroadcastState.CONNECTING);
+
+                    try
+                    {
+                        ConnectFuture future = mSocketConnector
+                            .connect(new InetSocketAddress(getBroadcastConfiguration().getHost(),
+                                getBroadcastConfiguration().getPort()));
+                        future.awaitUninterruptibly();
+                        mStreamingSession = future.getSession();
+                    }
+                    catch(RuntimeIoException rie)
+                    {
+                        Throwable throwableCause = rie.getCause();
+
+                        if(throwableCause instanceof ConnectException)
+                        {
+                            setBroadcastState(BroadcastState.NO_SERVER);
+                        }
+                        else if(throwableCause != null)
+                        {
+                            setBroadcastState(BroadcastState.ERROR);
+                            mLog.debug("Failed to connect", rie);
+                        }
+                        else
+                        {
+                            setBroadcastState(BroadcastState.ERROR);
+                            mLog.debug("Failed to connect - no exception is available");
+                        }
+
+                        disconnect();
+                    }
+                    catch(Throwable t)
+                    {
+                        disconnect();
+                    }
+
+                    mConnecting.set(false);
+                }
+            };
+
+            ThreadPool.SCHEDULED.schedule(runnable, 0l, TimeUnit.SECONDS);
+        }
+
+        return connected();
+    }
+
+
+    /**
+     * Disconnect from the remote broadcast server and cleanup input/output streams and socket connection
+     */
+    public void disconnect()
+    {
+        if(connected() && mStreamingSession != null)
+        {
+            mStreamingSession.closeNow();
+        }
+        else
+        {
+            mLastConnectionAttempt = System.currentTimeMillis();
+        }
+    }
+
+    /**
+     * IO Handler for managing Icecast TCP connection and credentials
+     */
+    public class ShoutcastIOHandler extends IoHandlerAdapter
+    {
+        /**
+         * Sends stream configuration and user credentials upon connecting to remote server
+         */
+        @Override
+        public void sessionOpened(IoSession session) throws Exception
+        {
+            StringBuilder sb = new StringBuilder();
+
+            //Password
+            sb.append(getConfiguration().getPassword()).append(ShoutcastMetadata.COMMAND_TERMINATOR);
+
+            //Metadata
+            sb.append(ShoutcastMetadata.STREAM_NAME.encode(getConfiguration().getName()));
+            sb.append(ShoutcastMetadata.PUBLIC.encode(getConfiguration().isPublic()));
+            sb.append(ShoutcastMetadata.GENRE.encode(getConfiguration().getGenre()));
+            sb.append(ShoutcastMetadata.DESCRIPTION.encode(getConfiguration().getDescription()));
+            sb.append(ShoutcastMetadata.AUDIO_BIT_RATE.encode(getConfiguration().getBitRate()));
+
+            //End of connection string
+            sb.append(ShoutcastMetadata.COMMAND_TERMINATOR);
+
+            session.write(sb.toString());
+        }
+
+        @Override
+        public void sessionClosed(IoSession session) throws Exception
+        {
+            mLastConnectionAttempt = System.currentTimeMillis();
+
+            //If there is already an error state, don't override it.  Otherwise, set state to disconnected
+            if(!getBroadcastState().isErrorState())
+            {
+                setBroadcastState(BroadcastState.DISCONNECTED);
+            }
+
+            mStreamingSession = null;
+
+            mConnecting.set(false);
+            super.sessionClosed(session);
+        }
+
+        @Override
+        public void exceptionCaught(IoSession session, Throwable cause) throws Exception
+        {
+            if(cause instanceof IOException)
+            {
+                IOException ioe = (IOException)cause;
+
+                if(ioe.getMessage() != null)
+                {
+                    String reason = ioe.getMessage();
+
+                    if(reason.startsWith("Connection reset"))
+                    {
+                        mLog.info("Streaming connection reset by remote server - reestablishing connection");
+                        disconnect();
+                    }
+                    else if(reason.startsWith("Operation timed out"))
+                    {
+                        mLog.info("Streaming connection timed out - resetting connection");
+                        disconnect();
+                    }
+                    else
+                    {
+                        setBroadcastState(BroadcastState.ERROR);
+                        disconnect();
+                        mLog.error("Unrecognized IO error: " + reason + ". Streaming halted.");
+                    }
+                }
+                else
+                {
+                    setBroadcastState(BroadcastState.ERROR);
+                    disconnect();
+                    mLog.error("Unspecified IO error - streaming halted.");
+                }
+            }
+            else
+            {
+                mLog.error("Broadcast error", cause);
+                setBroadcastState(BroadcastState.ERROR);
+                disconnect();
+            }
+
+            mConnecting.set(false);
+        }
+
+        @Override
+        public void messageReceived(IoSession session, Object object) throws Exception
+        {
+            if(object instanceof String)
+            {
+                String message = (String) object;
+
+                if(message != null && !message.trim().isEmpty())
+                {
+                    if(message.startsWith("OK"))
+                    {
+                        setBroadcastState(BroadcastState.CONNECTED);
+                    }
+                    else if(message.startsWith("icy-caps:"))
+                    {
+                        //TODO: what does icy-caps:11 tell us?
+                    }
+                    else
+                    {
+                        mLog.error("Unrecognized server response:" + message);
+                        setBroadcastState(BroadcastState.ERROR);
+                    }
+                }
+            }
+            else
+            {
+                mLog.error("Icecast TCP broadcaster - unrecognized message [ " + object.getClass() +
+                    "] received:" + object.toString());
+            }
+        }
+    }
+}