Initial commit of redesigned internal processing and audio management.

Note: Several of the decoders are currently non-functioning in this
commit.  If you want the latest functioning codebase, please checkout
the commit prior to this one.  All decoders will eventually be updated
with this new architecture.

Currently broken:
- Logging and recording
- Aux decoders (Fleetsync/MDC/LoJack/Tait)
- LTR/Passport decoders

Changes in this commit:
- Module architecture for decoders and components with central
provisioning by the DecoderFactory
- Transition from Complex sample stream processing to float buffer
processing for improved memory management
- Redesigned filter structures - to support buffers and streams
- Resolved several memory leak issues
- Universal sharing of the thread pool manager
- Added centralized audio management with call/user prioritization and
new gui with mute/volume controls
- Embedded audio metadata for eventual streaming support
- Redesigned ProcessingChain to support independent re-use
- Added new TrafficChannelManager to handle traffic channel allocations
- Traffic Channel pool size and Call timeout available in P25 and
MPT1327 configs
- Redesigned channel and decoder gui components

src/module/decode/ltrstandard/DecodeConfigLTRStandard.java

@@ -0,0 +1,45 @@
+/*******************************************************************************
+ *     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 module.decode.ltrstandard;
+
+import javax.xml.bind.annotation.XmlAttribute;
+
+import message.MessageDirection;
+import module.decode.DecoderType;
+import module.decode.config.DecodeConfiguration;
+
+public class DecodeConfigLTRStandard extends DecodeConfiguration
+{
+	private MessageDirection mMessageDirection = MessageDirection.OSW; 
+
+	public DecodeConfigLTRStandard()
+    {
+	    super( DecoderType.LTR_STANDARD );
+    }
+
+	@XmlAttribute( name = "direction" )
+	public MessageDirection getMessageDirection()
+	{
+		return mMessageDirection;
+	}
+	
+	public void setMessageDirection( MessageDirection direction )
+	{
+		mMessageDirection = direction;
+	}
+}

src/module/decode/ltrstandard/LTRStandardDecoder.java

@@ -0,0 +1,78 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014,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 module.decode.ltrstandard;
+
+import sample.Listener;
+import sample.real.IRealBufferListener;
+import sample.real.RealBuffer;
+import message.MessageDirection;
+import module.decode.Decoder;
+import module.decode.DecoderType;
+import module.decode.config.DecodeConfiguration;
+import alias.AliasList;
+import bits.MessageFramer;
+import bits.SyncPattern;
+import dsp.fsk.LTRFSKDecoder;
+
+public class LTRStandardDecoder extends Decoder implements IRealBufferListener
+{
+	public static final int LTR_STANDARD_MESSAGE_LENGTH = 40;
+
+	private LTRFSKDecoder mLTRFSKDecoder;
+	private MessageFramer mLTRMessageFramer;
+	private LTRStandardMessageProcessor mLTRMessageProcessor;
+    
+	public LTRStandardDecoder( AliasList aliasList,
+							   MessageDirection direction )
+	{
+		super( new LTRStandardDecoderState( aliasList ) );
+
+		mLTRFSKDecoder = new LTRFSKDecoder();
+
+		if( direction == MessageDirection.OSW )
+		{
+			mLTRMessageFramer = 
+					new MessageFramer( SyncPattern.LTR_STANDARD_OSW.getPattern(),
+							LTR_STANDARD_MESSAGE_LENGTH );
+		}
+		else
+		{
+			mLTRMessageFramer = 
+					new MessageFramer( SyncPattern.LTR_STANDARD_ISW.getPattern(),
+							LTR_STANDARD_MESSAGE_LENGTH );
+		}
+		
+		mLTRFSKDecoder.addListener( mLTRMessageFramer );
+
+		mLTRMessageProcessor = new LTRStandardMessageProcessor( direction, aliasList );
+		mLTRMessageFramer.addMessageListener( mLTRMessageProcessor );
+		mLTRMessageProcessor.setMessageListener( mMessageBroadcaster );
+	}
+
+	@Override
+	public DecoderType getDecoderType()
+	{
+		return DecoderType.LTR_STANDARD;
+	}
+
+	@Override
+	public Listener<RealBuffer> getRealBufferListener()
+	{
+		return mLTRFSKDecoder;
+	}
+}

src/module/decode/ltrstandard/LTRStandardDecoderPanel.java

@@ -0,0 +1,157 @@
+/*******************************************************************************
+ *     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 module.decode.ltrstandard;
+
+import java.awt.EventQueue;
+
+import javax.swing.JLabel;
+
+import module.decode.state.ChangedAttribute;
+import module.decode.state.DecoderPanel;
+import settings.ColorSetting;
+import settings.Setting;
+import settings.SettingsManager;
+import alias.Alias;
+
+public class LTRStandardDecoderPanel extends DecoderPanel
+{
+    private static final long serialVersionUID = 1L;
+
+    private JLabel mProtocol = new JLabel( "LTR Standard" );
+    private JLabel mTalkgroup = new JLabel();
+    private JLabel mTalkgroupAlias = new JLabel();
+
+    private JLabel mLCN = new JLabel( "LCN:" );
+    
+	public LTRStandardDecoderPanel( SettingsManager settingsManager, LTRStandardDecoder decoder )
+	{
+		super( settingsManager, decoder );
+		
+		init();
+	}
+	
+	public void dispose()
+	{
+		super.dispose();
+	}
+	
+	public void init()
+	{
+		mProtocol.setFont( mFontDecoder );
+		mProtocol.setForeground( mColorLabelDecoder );
+
+		mTalkgroup.setFont( mFontDecoder );
+		mTalkgroup.setForeground( mColorLabelDecoder );
+
+		mTalkgroupAlias.setFont( mFontDecoder );
+		mTalkgroupAlias.setForeground( mColorLabelDecoder );
+
+        mLCN.setFont( mFontDecoder );
+        mLCN.setForeground( mColorLabelDecoder );
+
+		add( mProtocol );
+		add( mTalkgroup );
+		add( mTalkgroupAlias, "wrap" );
+		
+		add( mLCN, "wrap" );
+	}
+	
+	private LTRStandardDecoderState getDecoderState()
+	{
+		return (LTRStandardDecoderState)getDecoder().getDecoderState();
+	}
+
+    @Override
+    public void receive( final ChangedAttribute attribute )
+    {
+		EventQueue.invokeLater( new Runnable()
+		{
+			@Override
+            public void run()
+            {
+				LTRStandardDecoderState state = getDecoderState();
+				
+	            switch( attribute )
+	            {
+	                case CHANNEL_NUMBER:
+	                    if( state.getChannelNumber() != 0 )
+	                    {
+    						mLCN.setText( "LCN: " + state.getChannelNumber() );
+	                    }
+	                    break;
+	                case TO_TALKGROUP:
+	                    mTalkgroup.setText( state.getTalkgroup() );
+	                    /* fall-through */
+	                case TO_TALKGROUP_ALIAS:
+	                    Alias alias = state.getTalkgroupAlias();
+	                    
+	    	    		if( alias != null )
+	    	    		{
+	    					mTalkgroupAlias.setText( alias.getName() );
+	    					mTalkgroupAlias.setIcon( mSettingsManager
+    							.getImageIcon( alias.getIconName(), 12 ) );
+	    	    		}
+	    	    		else
+	    	    		{
+	    	    			mTalkgroupAlias.setText( null );
+	    	    			mTalkgroupAlias.setIcon( null );
+	    	    		}
+	                default:
+	                	break;
+	            }
+				
+				repaint();
+            }
+		});
+    }
+
+	@Override
+    public void settingChanged( Setting setting )
+    {
+		super.settingChanged( setting );
+		
+		if( setting instanceof ColorSetting )
+		{
+			ColorSetting colorSetting = (ColorSetting)setting;
+			
+			switch( colorSetting.getColorSettingName() )
+			{
+				case CHANNEL_STATE_LABEL_DECODER:
+					if( mProtocol != null )
+					{
+						mProtocol.setForeground( mColorLabelDecoder );
+					}
+					if( mTalkgroup != null )
+					{
+						mTalkgroup.setForeground( mColorLabelDecoder );
+					}
+					if( mTalkgroupAlias != null )
+					{
+						mTalkgroupAlias.setForeground( mColorLabelDecoder );
+					}
+					if( mLCN != null )
+					{
+						mLCN.setForeground( mColorLabelDecoder );
+					}
+					break;
+				default:
+					break;
+			}
+		}
+    }
+}

src/module/decode/ltrstandard/LTRStandardDecoderState.java

@@ -0,0 +1,398 @@
+/*******************************************************************************
+ *     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 module.decode.ltrstandard;
+
+import java.text.DecimalFormat;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.TreeSet;
+
+import message.Message;
+import module.decode.event.CallEvent.CallEventType;
+import module.decode.ltrnet.LTRCallEvent;
+import module.decode.state.ChangedAttribute;
+import module.decode.state.DecoderState;
+import module.decode.state.DecoderStateEvent;
+import module.decode.state.DecoderStateEvent.Event;
+import module.decode.state.State;
+import alias.Alias;
+import alias.AliasList;
+
+public class LTRStandardDecoderState extends DecoderState
+{
+	private static final int sINT_NULL_VALUE = -1;
+	private DecimalFormat mDecimalFormatter = new DecimalFormat("0.00000");
+
+    private HashMap<Integer,String> mActiveCalls = new HashMap<Integer,String>();
+	private HashSet<String> mTalkgroupsFirstHeard = new HashSet<String>();
+	private TreeSet<String> mTalkgroups = new TreeSet<String>();
+	private TreeSet<Integer> mActiveLCNs = new TreeSet<Integer>();
+	private int mMonitoredLCN;
+	
+	private String mTalkgroup;
+	private Alias mTalkgroupAlias;
+    private int mChannelNumber;
+    
+    private long mFrequency;
+	
+	public LTRStandardDecoderState( AliasList aliasList )
+	{
+		super( aliasList );
+	}
+	
+	private LTRCallEvent getCurrentCallEvent()
+	{
+		return (LTRCallEvent)mCurrentCallEvent;
+	}
+
+	@Override
+    public void receive( Message message )
+    {
+		if( message.isValid() )
+		{
+			if( message instanceof LTRStandardOSWMessage )
+			{
+				LTRStandardOSWMessage ltr = ((LTRStandardOSWMessage)message);
+				
+				switch( ltr.getMessageType() )
+				{
+					case CA_STRT:
+					    if( 0 < ltr.getChannel() && ltr.getChannel() <=20 )
+					    {
+					    	/* If we haven't captured the LCN yet ... */
+					    	if( mChannelNumber == 0 )
+					    	{
+	                            mChannelNumber = ltr.getChannel();
+	                            broadcast( ChangedAttribute.CHANNEL_NUMBER );
+					    	}
+
+	                        /* If this call event is for this channel, then update
+	                         * talkgroup and alias */
+	                        if( ltr.getChannel() == mChannelNumber )
+	                        {
+	                            mTalkgroup = ltr.getTalkgroupID();
+	                            broadcast( ChangedAttribute.TO_TALKGROUP );
+	                            
+	                            mTalkgroupAlias = ltr.getTalkgroupIDAlias();
+	                            broadcast( ChangedAttribute.TO_TALKGROUP_ALIAS );
+	                            
+	                        	LTRCallEvent current = getCurrentCallEvent();
+	                        	
+	                        	/* If we have an ongoing call, then add this message
+	                        	 * to the current event - if addMessage returns 
+	                        	 * false, then we have a different talkgroup and a
+	                        	 * new call event, so close out the old one. */
+	                        	if( current != null && !current.addMessage( ltr ) )
+	                        	{
+	                        		mCurrentCallEvent.setEnd( System.currentTimeMillis() );
+	                        		broadcast( mCurrentCallEvent );
+	                        		mCurrentCallEvent = null;
+	                        	}
+	                        	
+	                    		if( current == null )
+	                    		{
+	                    			mCurrentCallEvent = 
+    	                        		new LTRCallEvent.Builder( CallEventType.CALL )
+        	                            .to( ltr.getTalkgroupID() )
+        	                            .aliasList( getAliasList() )
+        	                            .channel( String.valueOf( ltr.getChannel() ) )
+        	                            .frequency( mFrequency )
+        	                            .build();
+
+	                    			broadcast( mCurrentCallEvent );
+	                    			
+		                    		broadcast( new DecoderStateEvent( this, Event.START, State.CALL ) );
+	                    		}
+	                    		else
+	                    		{
+		                    		broadcast( new DecoderStateEvent( this, Event.CONTINUATION, State.CALL ) );
+	                    		}
+	                        }
+					    }
+						break;
+					case CA_ENDD:
+	                    mTalkgroup = ltr.getTalkgroupID();
+	                    broadcast( ChangedAttribute.FROM_TALKGROUP );
+
+	                    mTalkgroupAlias = ltr.getTalkgroupIDAlias();
+	                    broadcast( ChangedAttribute.FROM_TALKGROUP_ALIAS );
+
+	                    if( mCurrentCallEvent != null )
+	                    {
+	                    	mCurrentCallEvent.setEnd( System.currentTimeMillis() );
+	                    	broadcast( mCurrentCallEvent );
+                    		broadcast( new DecoderStateEvent( this, Event.END, State.FADE ) );
+                    		mCurrentCallEvent = null;
+	                    }
+
+						int home = ltr.getHomeRepeater();
+					    
+					    if( 0 < home && home <= 20 )
+					    {
+	                        String talkgroup = ltr.getTalkgroupID( false );
+	                        
+	                        if( mTalkgroupsFirstHeard.contains( talkgroup ) )
+	                        {
+	                            mTalkgroups.add( talkgroup );
+	                        }
+	                        else
+	                        {
+	                            mTalkgroupsFirstHeard.add( talkgroup );
+	                        }
+					    }
+
+					    int channel = ltr.getChannel();
+					    
+					    if( 0 < channel && channel <= 20 )
+					    {
+	                        if( channel == home )
+	                        {
+	                        	if( mMonitoredLCN != channel )
+	                        	{
+		                            mMonitoredLCN = channel;
+		                            broadcast( ChangedAttribute.CHANNEL_NUMBER );
+	                        	}
+	                        	
+	                            mActiveLCNs.add( channel );
+	                        }
+	                        
+	                        int free = ltr.getFree();
+	                        
+	                        if( 0 < free && free <= 20 )
+	                        {
+	                            mActiveLCNs.add( free );
+	                        }
+					    }
+
+						break;
+					case SY_IDLE:
+					    int idleChannel = ltr.getChannel();
+					    
+					    if( idleChannel == ltr.getHomeRepeater() &&
+					        idleChannel == ltr.getFree() )
+					    {
+                        	if( mMonitoredLCN != idleChannel )
+                        	{
+	                            mMonitoredLCN = idleChannel;
+	                            broadcast( ChangedAttribute.CHANNEL_NUMBER );
+                        	}
+                        	
+	                        mActiveLCNs.add( idleChannel );
+					    }
+					    broadcast( new DecoderStateEvent( this, Event.CONTINUATION, State.IDLE ) );
+						break;
+					case UN_KNWN:
+					default:
+						break;
+				}
+			}
+		}
+    }
+	
+//    /**
+//     * Intercept the fade event so that we can generate a call end event
+//     */
+//    @Override
+//    public void fade( final CallEventType type )
+//    {
+//        /* We can receive multiple call tear-down messages -- only respond to
+//         * the message that can change the state to fade */
+//        if( getState().canChangeTo( State.FADE ) )
+//        {
+//            mActiveCalls.clear();
+//            
+//            LTRCallEvent current = getCurrentLTRCallEvent();
+//            
+//            if( current != null )
+//            {
+//            	/* Close out the call event.  If we only received 1 call 
+//            	 * message, then flag it as noise and remove the call event */
+//            	if( current.isValid() )
+//            	{
+//            		mCallEventModel.setEnd( current );
+//            	}
+//            	else
+//            	{
+//            		mCallEventModel.remove( current );
+//            	}
+//            }
+//            
+//    		setCurrentCallEvent( null );
+//        }
+//        
+//        super.fade( type );
+//    }
+    
+	public void reset()
+	{
+		resetState();
+		
+		if( mCurrentCallEvent != null )
+		{
+			mCurrentCallEvent.setEnd( System.currentTimeMillis() );
+			broadcast( mCurrentCallEvent );
+			mCurrentCallEvent = null;
+		}
+		
+	}
+	
+	private void resetState()
+	{
+		mTalkgroup = null;
+		broadcast( ChangedAttribute.FROM_TALKGROUP );
+
+		mTalkgroupAlias = null;
+        broadcast( ChangedAttribute.FROM_TALKGROUP_ALIAS );
+	}
+	
+	public String getTalkgroup()
+	{
+		return mTalkgroup;
+	}
+	
+	public Alias getTalkgroupAlias()
+	{
+		return mTalkgroupAlias;
+	}
+	
+    public boolean hasChannelNumber()
+    {
+        return mChannelNumber != 0;
+    }
+    
+    public int getChannelNumber()
+    {
+        return mChannelNumber;
+    }
+
+	@Override
+	public void init()
+	{
+		
+	}
+
+	@Override
+	public void receiveDecoderStateEvent( DecoderStateEvent event )
+	{
+		switch( event.getEvent() )
+		{
+			case RESET:
+				resetState();
+				break;
+			case SOURCE_FREQUENCY:
+				mFrequency = event.getFrequency();
+				break;
+			default:
+				break;
+		}
+	}
+	
+	@Override
+    public String getActivitySummary()
+    {
+		StringBuilder sb = new StringBuilder();
+
+		sb.append( "Activity Summary\n\n" );
+		
+		sb.append( "Decoder:\tLTR-Standard\n" );
+		
+		sb.append( "Monitored LCN: " );
+		
+		if( mMonitoredLCN > 0 )
+		{
+	        sb.append( mMonitoredLCN );
+		}
+		else
+		{
+		    sb.append( "unknown" );
+		}
+		
+		sb.append( "\n" );
+		
+		Integer[] lcns = mActiveLCNs.toArray( new Integer[0] );
+		
+		sb.append( "Active LCNs:\t" );
+		
+		if( lcns.length > 0 )
+		{
+	        sb.append(  Arrays.toString( lcns ) );
+		}
+		else
+		{
+		    sb.append( "none" );
+		}
+		sb.append( "\n\n" );
+
+		sb.append( "Talkgroups\n" );
+		
+		if( mTalkgroups.isEmpty() )
+		{
+			sb.append( "  None\n" );
+		}
+		else
+		{
+			Iterator<String> it = mTalkgroups.iterator();
+			
+			while( it.hasNext() )
+			{
+				String tgid = it.next();
+				
+				sb.append( "  " );
+				sb.append( formatTalkgroup( tgid ) );
+				sb.append( " " );
+				
+				if( hasAliasList() )
+				{
+					Alias alias = getAliasList().getTalkgroupAlias( tgid );
+					
+					if( alias != null )
+					{
+						sb.append( alias.getName() );
+					}
+				}
+				
+				sb.append( "\n" );
+			}
+		}
+		
+	    return sb.toString();
+    }
+	
+	public static String formatTalkgroup( String talkgroup )
+	{
+		StringBuilder sb = new StringBuilder();
+		
+		if( talkgroup.length() == 6 )
+		{
+			sb.append( talkgroup.substring( 0, 1 ) );
+			sb.append( "-" );
+			sb.append( talkgroup.substring( 1, 3 ) );
+			sb.append( "-" );
+			sb.append( talkgroup.substring( 3, 6 ) );
+
+			return sb.toString();
+		}
+		else
+		{
+			return talkgroup;
+		}
+	}
+	
+}

src/module/decode/ltrstandard/LTRStandardEditor.java

@@ -0,0 +1,71 @@
+/*******************************************************************************
+ *     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 module.decode.ltrstandard;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import javax.swing.DefaultComboBoxModel;
+import javax.swing.JComboBox;
+import javax.swing.JLabel;
+
+import message.MessageDirection;
+import module.decode.DecodeEditor;
+import module.decode.config.DecodeConfiguration;
+
+public class LTRStandardEditor extends DecodeEditor
+{
+    private static final long serialVersionUID = 1L;
+
+    private JComboBox<MessageDirection> mComboDirection;
+    
+	public LTRStandardEditor( DecodeConfiguration config )
+	{
+		super( config );
+		
+		initGUI();
+	}
+	
+	private void initGUI()
+	{
+		mComboDirection = new JComboBox<MessageDirection>();
+
+		mComboDirection.setModel( 
+				new DefaultComboBoxModel<MessageDirection>( MessageDirection.values() ) );
+		
+		mComboDirection.setSelectedItem( ((DecodeConfigLTRStandard)mConfig).getMessageDirection() );
+		
+		mComboDirection.addActionListener( new ActionListener() 
+		{
+			@Override
+            public void actionPerformed( ActionEvent e )
+            {
+				MessageDirection selected = mComboDirection
+						.getItemAt( mComboDirection.getSelectedIndex() );
+				
+				if( selected != null )
+				{
+					((DecodeConfigLTRStandard)mConfig).setMessageDirection( selected );
+				}
+            }
+		} );
+
+		add( new JLabel( "Format:" ) );
+		add( mComboDirection, "wrap" );
+	}
+}

src/module/decode/ltrstandard/LTRStandardISWMessage.java

@@ -0,0 +1,238 @@
+/*******************************************************************************
+ *     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 module.decode.ltrstandard;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+import map.Plottable;
+import message.MessageDirection;
+import message.MessageType;
+import alias.Alias;
+import alias.AliasList;
+import bits.BinaryMessage;
+
+public class LTRStandardISWMessage extends LTRStandardMessage
+{
+	private static final int sCALL_END = 31;
+	private static final int sIDLE = 255;
+
+	public LTRStandardISWMessage( BinaryMessage message, AliasList list )
+    {
+    	super( message, MessageDirection.OSW, list );
+        mMessageType = getType();
+    }
+
+	@Override
+    public String toString()
+    {
+		StringBuilder sb = new StringBuilder();
+    	sb.append( mDatestampFormatter.format( 
+    			new Date( System.currentTimeMillis() ) ) );
+		sb.append( " LTR OSW [" );
+		sb.append( mCRC.getAbbreviation() );
+		sb.append( "] " );
+		sb.append( getMessage() );
+		pad(  sb, 100 );
+		sb.append( mMessage.toString() );
+		
+	    return sb.toString();
+    }
+
+	@Override
+    public String getMessage()
+    {
+		StringBuilder sb = new StringBuilder();
+
+		switch( mMessageType )
+		{
+			case SY_IDLE:
+				sb.append( "IDLE AREA:" );
+				sb.append( getArea() );
+				sb.append( " LCN:" );
+				sb.append( format( getChannel(), 2 ) );
+				sb.append( " HOME:" );
+				sb.append( format( getHomeRepeater(), 2 ) );
+				sb.append( " GRP:" );
+				sb.append( format( getGroup(), 3 ) );
+				sb.append( " FREE:" );
+				sb.append( format( getFree(), 2 ) );
+				break;
+			case CA_STRT:
+				sb.append( "CALL LCN:" );
+				sb.append( format( getChannel(), 2 ) );
+				sb.append( " TG [ " );
+				sb.append( getTalkgroupID() );
+				sb.append( "/" );
+				sb.append( getTalkgroupIDAlias() );
+				sb.append( " ] FREE:" );
+				sb.append( format( getFree(), 2 ) );
+				break;
+			case CA_ENDD:
+				sb.append( "END* AREA:" );
+				sb.append( getArea() );
+				sb.append( " LCN:" );
+				sb.append( format( getChannel(), 2 ) );
+				sb.append( " TG [" );
+				sb.append( getTalkgroupID() );
+				sb.append( "/" );
+				sb.append( getTalkgroupIDAlias() );
+				sb.append( "] FREE:" );
+				sb.append( format( getFree(), 2 ) );
+				break;
+			default:
+				sb.append( "UNKNOWN A:" );
+				sb.append( getArea() );
+				sb.append( " C:" );
+				sb.append( format( getChannel(), 2 ) );
+				sb.append( " H:" );
+				sb.append( format( getHomeRepeater(), 2 ) );
+				sb.append( " G:" );
+				sb.append( format( getGroup(), 3 ) );
+				sb.append( " F:" );
+				sb.append( format( getFree(), 2 ) );
+		}
+
+	    return sb.toString();
+    }
+	
+	public String getTalkgroupID()
+	{
+		return getTalkgroupID( true );
+	}
+	
+	public String getTalkgroupID( boolean format )
+	{
+		StringBuilder sb = new StringBuilder();
+		
+		sb.append( getArea() );
+		
+		if( format )
+		{
+			sb.append( "-" );
+		}
+
+		sb.append( format( getHomeRepeater(), 2 ) );
+		
+		if( format )
+		{
+			sb.append( "-" );
+		}
+
+		sb.append( format( getGroup(), 3 ) );
+		
+		return sb.toString();
+	}
+	
+	public Alias getTalkgroupIDAlias()
+	{
+		StringBuilder sb = new StringBuilder();
+		sb.append( getArea() );
+		sb.append( format( getHomeRepeater(), 2 ) );
+		sb.append( format( getGroup(), 3 ) );
+
+		return mAliasList.getTalkgroupAlias( sb.toString() );
+	}
+	
+	public MessageType getType()
+	{
+		MessageType retVal = MessageType.UN_KNWN; 
+		
+		int group = getGroup();
+
+		if( group == sIDLE )
+		{
+			retVal = MessageType.SY_IDLE;
+		}
+		else
+		{
+			int channel = getChannel();
+
+			if( channel == sCALL_END )
+			{
+				retVal = MessageType.CA_ENDD;
+			}
+			else
+			{
+				retVal = MessageType.CA_STRT;
+			}
+		}
+		
+		return retVal;
+	}
+	
+	@Override
+    public String getFromID()
+    {
+		if( mMessageType == MessageType.CA_STRT || 
+			mMessageType == MessageType.CA_ENDD )
+		{
+		    return getTalkgroupID();
+		}
+		else
+		{
+			return null;
+		}
+    }
+
+	@Override
+    public Alias getFromIDAlias()
+    {
+		if( mMessageType == MessageType.CA_STRT || 
+			mMessageType == MessageType.CA_ENDD )
+		{
+		    return getTalkgroupIDAlias();
+		}
+		else
+		{
+			return null;
+		}
+    }
+
+	@Override
+    public Plottable getPlottable()
+    {
+	    // TODO Auto-generated method stub
+	    return null;
+    }
+	
+	/**
+	 * Provides a listing of aliases contained in the message.  
+	 */
+	public List<Alias> getAliases()
+	{
+		List<Alias> aliases = new ArrayList<Alias>();
+		
+		Alias from = getFromIDAlias();
+		
+		if( from != null )
+		{
+			aliases.add( from );
+		}
+
+		Alias to = getToIDAlias();
+		
+		if( to != null )
+		{
+			aliases.add( to );
+		}
+		
+		return aliases;
+	}
+}

src/module/decode/ltrstandard/LTRStandardMessage.java

@@ -0,0 +1,254 @@
+/*******************************************************************************
+ *     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 module.decode.ltrstandard;
+
+import java.text.DecimalFormat;
+import java.text.SimpleDateFormat;
+
+import message.Message;
+import message.MessageDirection;
+import message.MessageType;
+import module.decode.DecoderType;
+import alias.Alias;
+import alias.AliasList;
+import bits.BinaryMessage;
+import edac.CRC;
+import edac.CRCLTR;
+
+public abstract class LTRStandardMessage extends Message
+{
+	protected static final String sUNKNOWN = "**UNKNOWN**";
+	protected static final int sINT_NULL_VALUE = -1;
+	protected static final double sDOUBLE_NULL_VALUE = -1.0D;
+	protected SimpleDateFormat mDatestampFormatter = 
+			new SimpleDateFormat( "yyyyMMdd HHmmss" );
+	protected DecimalFormat mDecimalFormatter = new DecimalFormat("0.00000");
+	
+    protected static final int[] sSYNC = { 8,7,6,5,4,3,2,1,0 };
+	protected static final int[] sAREA = { 9 };
+	protected static final int[] sCHANNEL = { 14,13,12,11,10 };
+	protected static final int[] sHOME_REPEATER = { 19,18,17,16,15 };
+	protected static final int[] sGROUP = { 27,26,25,24,23,22,21,20 };
+	protected static final int[] sFREE = { 32,31,30,29,28 };
+	protected static final int[] sCRC = { 39,38,37,36,35,34,33 };
+	
+	protected BinaryMessage mMessage;
+	protected MessageType mMessageType;
+	protected CRC mCRC;
+	protected AliasList mAliasList;
+	
+    public LTRStandardMessage( BinaryMessage message, 
+    					  MessageDirection direction,
+    					  AliasList list )
+    {
+        mMessage = message;
+        mCRC = CRCLTR.check( message, direction );
+        mAliasList = list;
+    }
+    
+    public MessageType getMessageType()
+    {
+    	return mMessageType;
+    }
+    
+    public boolean isValid()
+    {
+    	return mCRC != CRC.FAILED_CRC && mCRC != CRC.FAILED_PARITY;
+    }
+    
+	/**
+	 * Appends spaces to the end of the stringbuilder to make it length long
+	 */
+	protected void pad( StringBuilder sb, int length )
+	{
+		while( sb.length() < length )
+		{
+			sb.append( " " );
+		}
+	}
+
+	@Override
+    public String getBinaryMessage()
+    {
+		return mMessage.toString();
+    }
+
+	/**
+	 * Returns a value formatted in hex notation.
+	 * 
+	 * @param value - integer value
+	 * @return - hex digits returned
+	 */
+	protected static String getHex( int value, int digits )
+	{
+		return String.format( "%0" + digits + "X", value );
+	}
+	
+    protected int getInt( int[] bits )
+    {
+    	int retVal = 0;
+    	
+    	for( int x = 0; x < bits.length; x++ )
+    	{
+    		if( mMessage.get( bits[ x ] ) )
+    		{
+    			retVal += 1<<x;
+    		}
+    	}
+    	
+    	return retVal;
+    }
+    
+    /**
+     * Pads an integer value with additional zeroes to make it decimalPlaces long
+     */
+    public String format( int number, int decimalPlaces )
+    {
+    	StringBuilder sb = new StringBuilder();
+
+    	int paddingRequired = decimalPlaces - ( String.valueOf( number ).length() );
+
+    	for( int x = 0; x < paddingRequired; x++)
+    	{
+    		sb.append( "0" );
+    	}
+    	
+    	sb.append( number );
+    	
+    	return sb.toString();
+    }
+    
+    public String format( String val, int places )
+    {
+    	StringBuilder sb = new StringBuilder();
+    	
+    	sb.append( val );
+
+    	while( sb.length() < places )
+    	{
+    		sb.append( " " );
+    	}
+    	
+    	return sb.toString();
+    }
+
+    public CRC getCRC()
+    {
+    	return mCRC;
+    }
+    
+	public int getArea()
+	{
+		return getInt( sAREA );
+	}
+
+	public int getChannel()
+	{
+		return getInt( sCHANNEL );
+	}
+	
+	public int getHomeRepeater()
+	{
+		return getInt( sHOME_REPEATER );
+	}
+	
+	public int getGroup()
+	{
+		return getInt( sGROUP );
+	}
+
+	public String getTalkgroupID()
+	{
+		return getTalkgroupID( true );
+	}
+	
+	public String getTalkgroupID( boolean format )
+	{
+		StringBuilder sb = new StringBuilder();
+		
+		sb.append( getArea() );
+		
+		if( format )
+		{
+			sb.append( "-" );
+		}
+
+		sb.append( format( getHomeRepeater(), 2 ) );
+		
+		if( format )
+		{
+			sb.append( "-" );
+		}
+
+		sb.append( format( getGroup(), 3 ) );
+		
+		return sb.toString();
+	}
+	
+	public Alias getTalkgroupIDAlias()
+	{
+		return mAliasList.getTalkgroupAlias( getTalkgroupID() );
+	}
+	
+	public int getFree()
+	{
+		return getInt( sFREE );
+	}
+	
+	public int getCRCChecksum()
+	{
+		return getInt( sCRC );
+	}
+	
+	@Override
+    public String getProtocol()
+    {
+	    return DecoderType.LTR_STANDARD.getDisplayString();
+    }
+
+	@Override
+    public String getEventType()
+    {
+		if( mMessageType != null )
+		{
+		    return mMessageType.getDisplayText();
+		}
+		else
+		{
+			return MessageType.UN_KNWN.getDisplayText();
+		}
+    }
+
+	@Override
+    public String getToID()
+    {
+	    return null;
+    }
+
+	@Override
+    public Alias getToIDAlias()
+    {
+	    return null;
+    }
+
+	@Override
+    public String getErrorStatus()
+    {
+	    return mCRC.getDisplayText();
+    }
+}

src/module/decode/ltrstandard/LTRStandardMessageFilter.java

@@ -0,0 +1,56 @@
+package module.decode.ltrstandard;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+import message.Message;
+import message.MessageType;
+import filter.Filter;
+import filter.FilterElement;
+
+public class LTRStandardMessageFilter extends Filter<Message>
+{
+	private HashMap<MessageType, FilterElement<MessageType>> mElements = 
+			new HashMap<MessageType, FilterElement<MessageType>>();
+	
+	public LTRStandardMessageFilter()
+	{
+		super( "LTR Message Filter" );
+
+		mElements.put( MessageType.CA_STRT, 
+				new FilterElement<MessageType>( MessageType.CA_STRT ) );
+		mElements.put( MessageType.CA_ENDD, 
+				new FilterElement<MessageType>( MessageType.CA_ENDD ) );
+		mElements.put( MessageType.SY_IDLE, 
+				new FilterElement<MessageType>( MessageType.SY_IDLE ) );
+	}
+	
+	@Override
+    public boolean passes( Message message )
+    {
+		if( mEnabled && canProcess( message ) )
+		{
+			LTRStandardMessage ltr = (LTRStandardMessage)message;
+			
+			if( mElements.containsKey( ltr.getMessageType() ) )
+			{
+				return mElements.get( ltr.getMessageType() ).isEnabled();
+			}
+		}
+		
+	    return false;
+    }
+
+	@Override
+    public boolean canProcess( Message message )
+    {
+	    return message instanceof LTRStandardMessage;
+    }
+
+	@Override
+    public List<FilterElement<?>> getFilterElements()
+    {
+	    return new ArrayList<FilterElement<?>>( mElements.values() );
+    }
+}

src/module/decode/ltrstandard/LTRStandardMessageProcessor.java

@@ -0,0 +1,69 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014,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 module.decode.ltrstandard;
+
+import message.Message;
+import message.MessageDirection;
+import sample.Listener;
+import alias.AliasList;
+import bits.BinaryMessage;
+
+public class LTRStandardMessageProcessor implements Listener<BinaryMessage>
+{
+	private MessageDirection mDirection;
+	private AliasList mAliasList;
+	private Listener<Message> mMessageListener;
+	
+	public LTRStandardMessageProcessor( MessageDirection direction, AliasList list )
+	{
+		mDirection = direction;
+		mAliasList = list;
+	}
+	
+	@Override
+    public void receive( BinaryMessage buffer )
+    {
+		if( mMessageListener != null )
+		{
+			LTRStandardMessage message;
+			
+			if( mDirection == MessageDirection.OSW )
+			{
+				message = new LTRStandardOSWMessage( buffer, mAliasList );
+			}
+			else
+			{
+				buffer.flip( 0, 40 );
+
+				message = new LTRStandardISWMessage( buffer, mAliasList );
+			}
+			
+			mMessageListener.receive( message );
+		}
+    }
+	
+    public void setMessageListener( Listener<Message> listener )
+    {
+		mMessageListener = listener;
+    }
+
+    public void removeMessageListener()
+    {
+		mMessageListener = null;
+    }
+}

src/module/decode/ltrstandard/LTRStandardOSWMessage.java

@@ -0,0 +1,248 @@
+/*******************************************************************************
+ *     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 module.decode.ltrstandard;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+import map.Plottable;
+import message.MessageDirection;
+import message.MessageType;
+import alias.Alias;
+import alias.AliasList;
+import bits.BinaryMessage;
+
+public class LTRStandardOSWMessage extends LTRStandardMessage
+{
+	private static final int sCALL_END = 31;
+	private static final int sIDLE = 255;
+
+	public LTRStandardOSWMessage( BinaryMessage message, AliasList list )
+    {
+    	super( message, MessageDirection.OSW, list );
+        mMessageType = getType();
+    }
+
+	@Override
+    public String toString()
+    {
+		StringBuilder sb = new StringBuilder();
+    	sb.append( mDatestampFormatter.format( 
+    			new Date( System.currentTimeMillis() ) ) );
+		sb.append( " LTR OSW [" );
+		sb.append( mCRC.getAbbreviation() );
+		sb.append( "] " );
+		sb.append( getMessage() );
+		pad(  sb, 100 );
+		sb.append( mMessage.toString() );
+		
+	    return sb.toString();
+    }
+
+	@Override
+    public String getMessage()
+    {
+		StringBuilder sb = new StringBuilder();
+
+		switch( mMessageType )
+		{
+			case SY_IDLE:
+				sb.append( "IDLE AREA:" );
+				sb.append( getArea() );
+				sb.append( " LCN:" );
+				sb.append( format( getChannel(), 2 ) );
+				sb.append( " HOME:" );
+				sb.append( format( getHomeRepeater(), 2 ) );
+				sb.append( " GRP:" );
+				sb.append( format( getGroup(), 3 ) );
+				sb.append( " FREE:" );
+				sb.append( format( getFree(), 2 ) );
+				break;
+			case CA_STRT:
+				sb.append( "CALL LCN:" );
+				sb.append( format( getChannel(), 2 ) );
+				sb.append( " TG [ " );
+				sb.append( getTalkgroupID() );
+				sb.append( "/" );
+				Alias alias = getTalkgroupIDAlias();
+				if( alias != null )
+				{
+					sb.append( getTalkgroupIDAlias().getName() );
+				}
+				else
+				{
+					sb.append( "UNKNOWN" );
+				}
+				sb.append( " ] FREE:" );
+				sb.append( format( getFree(), 2 ) );
+				break;
+			case CA_ENDD:
+				sb.append( "END* AREA:" );
+				sb.append( getArea() );
+				sb.append( " LCN:" );
+				sb.append( format( getChannel(), 2 ) );
+				sb.append( " TG [" );
+				sb.append( getTalkgroupID() );
+				sb.append( "/" );
+				Alias endAlias = getTalkgroupIDAlias();
+				if( endAlias != null )
+				{
+					sb.append( getTalkgroupIDAlias().getName() );
+				}
+				else
+				{
+					sb.append( "UNKNOWN" );
+				}
+				sb.append( "] FREE:" );
+				sb.append( format( getFree(), 2 ) );
+				break;
+			default:
+				sb.append( "UNKNOWN A:" );
+				sb.append( getArea() );
+				sb.append( " C:" );
+				sb.append( format( getChannel(), 2 ) );
+				sb.append( " H:" );
+				sb.append( format( getHomeRepeater(), 2 ) );
+				sb.append( " G:" );
+				sb.append( format( getGroup(), 3 ) );
+				sb.append( " F:" );
+				sb.append( format( getFree(), 2 ) );
+		}
+
+	    return sb.toString();
+    }
+	
+	public String getTalkgroupID()
+	{
+		return getTalkgroupID( true );
+	}
+	
+	public String getTalkgroupID( boolean format )
+	{
+		StringBuilder sb = new StringBuilder();
+		
+		sb.append( getArea() );
+		
+		if( format )
+		{
+			sb.append( "-" );
+		}
+
+		sb.append( format( getHomeRepeater(), 2 ) );
+		
+		if( format )
+		{
+			sb.append( "-" );
+		}
+
+		sb.append( format( getGroup(), 3 ) );
+		
+		return sb.toString();
+	}
+	
+	public Alias getTalkgroupIDAlias()
+	{
+		return mAliasList.getTalkgroupAlias( getTalkgroupID() );
+	}
+	
+	public MessageType getType()
+	{
+		MessageType retVal = MessageType.UN_KNWN; 
+		
+		/* Group 255 when the channel equals the free is the IDLE message */
+		if( getGroup() == sIDLE && getChannel() == getFree() )
+		{
+			retVal = MessageType.SY_IDLE;
+		}
+		else
+		{
+			int channel = getChannel();
+
+			if( channel == sCALL_END )
+			{
+				retVal = MessageType.CA_ENDD;
+			}
+			else
+			{
+				retVal = MessageType.CA_STRT;
+			}
+		}
+		
+		return retVal;
+	}
+	
+	@Override
+    public String getFromID()
+    {
+		if( mMessageType == MessageType.CA_STRT || 
+			mMessageType == MessageType.CA_ENDD )
+		{
+		    return getTalkgroupID();
+		}
+		else
+		{
+			return null;
+		}
+    }
+
+	@Override
+    public Alias getFromIDAlias()
+    {
+		if( mMessageType == MessageType.CA_STRT || 
+				mMessageType == MessageType.CA_ENDD )
+		{
+		    return getTalkgroupIDAlias();
+		}
+		else
+		{
+			return null;
+		}
+    }
+
+	@Override
+    public Plottable getPlottable()
+    {
+	    // TODO Auto-generated method stub
+	    return null;
+    }
+	
+	/**
+	 * Provides a listing of aliases contained in the message.  
+	 */
+	public List<Alias> getAliases()
+	{
+		List<Alias> aliases = new ArrayList<Alias>();
+		
+		Alias from = getFromIDAlias();
+		
+		if( from != null )
+		{
+			aliases.add( from );
+		}
+
+		Alias to = getToIDAlias();
+		
+		if( to != null )
+		{
+			aliases.add( to );
+		}
+		
+		return aliases;
+	}
+}