Releasing Version 0.3.0 (final).

269 Viterbi decoder for DMR 3/4-rate packet messages

LICENSE

@@ -631,8 +631,8 @@ to attach them to the start of each source file to most effectively
 state the exclusion of warranty; and each file should have at least
 the "copyright" line and a pointer to where the full notice is found.
 
-    <one line to give the program's name and a brief idea of what it does.>
+    {one line to give the program's name and a brief idea of what it does.}
-    Copyright (C) <year>  <name of author>
+    Copyright (C) {year}  {name of author}
 
     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
@@ -652,7 +652,7 @@ Also add information on how to contact you by electronic and paper mail.
   If the program does terminal interaction, make it output a short
 notice like this when it starts in an interactive mode:
 
-    <program>  Copyright (C) <year>  <name of author>
+    {project}  Copyright (C) {year}  {fullname}
     This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
     This is free software, and you are welcome to redistribute it
     under certain conditions; type `show c' for details.

build/build.xml

@@ -7,7 +7,7 @@
   <property name="major" value="0"/>
   <property name="minor" value="3"/>
   <property name="patch" value="0"/>
-  <property name="release" value="-beta12"/>
+  <property name="release" value=""/>
   <property name="filename" value="sdrtrunk_${major}.${minor}.${patch}${release}"/>
     
   <!-- Build properties -->
@@ -16,7 +16,6 @@
   <property name="source.configs"  location="${repo}/config"/>
   <property name="source.images"  location="${repo}/images"/>
   <property name="source.libs"  location="${repo}/imports"/>
-  <property name="source.license"  location="${repo}/license"/>
   <property name="source.scripts"  location="${repo}/scripts"/>
 
   <property name="output"  location="${repo}/product"/>
@@ -57,8 +56,8 @@
         <exclude name="*.rules"/>
       </fileset>
       
-      <fileset dir="${source.license}">
+      <fileset dir="${repo}">
-        <include name="license.txt"/>
+        <include name="LICENSE"/>
       </fileset>
     </jar>
     
@@ -85,8 +84,8 @@
     
     <!-- Copy license file -->
     <copy todir="${output.folder}">
-      <fileset dir="${source.license}">
+      <fileset dir="${repo}">
-        <include name="license.txt"/>
+        <include name="LICENSE"/>
       </fileset>
     </copy>
     

src/audio/broadcast/icecast/IcecastTCPAudioBroadcaster.java

@@ -36,6 +36,7 @@ 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;
 
@@ -44,7 +45,8 @@ 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 = 30000; //30 seconds
+    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;
@@ -99,10 +101,11 @@ public class IcecastTCPAudioBroadcaster extends IcecastAudioBroadcaster
             if(mSocketConnector == null)
             {
                 mSocketConnector = new NioSocketConnector();
-                mSocketConnector.setConnectTimeoutCheckInterval(10000);
+                mSocketConnector.setConnectTimeoutCheckInterval(CONNECTION_ATTEMPT_TIMEOUT);
 
-//                mSocketConnector.getFilterChain().addLast("logger",
+//                LoggingFilter loggingFilter = new LoggingFilter(IcecastTCPAudioBroadcaster.class);
-//                    new LoggingFilter(IcecastTCPAudioBroadcaster.class));
+//                loggingFilter.setMessageSentLogLevel(LogLevel.NONE);
+//                mSocketConnector.getFilterChain().addLast("logger", loggingFilter);
 
                 mSocketConnector.getFilterChain().addLast("codec",
                     new ProtocolCodecFilter(new IcecastCodecFactory()));
@@ -123,9 +126,20 @@ public class IcecastTCPAudioBroadcaster extends IcecastAudioBroadcaster
                         ConnectFuture future = mSocketConnector
                             .connect(new InetSocketAddress(getBroadcastConfiguration().getHost(),
                                 getBroadcastConfiguration().getPort()));
-                        future.awaitUninterruptibly();
+
+                        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();
@@ -137,16 +151,20 @@ public class IcecastTCPAudioBroadcaster extends IcecastAudioBroadcaster
                         else if(throwableCause != null)
                         {
                             setBroadcastState(BroadcastState.ERROR);
-                            mLog.debug("Failed to connect", rie);
+                            mLog.debug("[" + getStreamName() + "] failed to connect", rie);
                         }
                         else
                         {
                             setBroadcastState(BroadcastState.ERROR);
-                            mLog.debug("Failed to connect - no exception is available");
+                            mLog.debug("[" + getStreamName() + "] failed to connect - no exception is available");
                         }
 
                         disconnect();
                     }
+                    catch(Throwable t)
+                    {
+                        disconnect();
+                    }
 
                     mConnecting.set(false);
                 }
@@ -164,12 +182,13 @@ public class IcecastTCPAudioBroadcaster extends IcecastAudioBroadcaster
      */
     public void disconnect()
     {
-        if(connected())
+        if(connected() && mStreamingSession != null)
         {
-            if(mStreamingSession != null)
+            mStreamingSession.closeNow();
-            {
+        }
-                mStreamingSession.closeNow();
+        else
-            }
+        {
+            mLastConnectionAttempt = System.currentTimeMillis();
         }
     }
 
@@ -226,17 +245,18 @@ public class IcecastTCPAudioBroadcaster extends IcecastAudioBroadcaster
         @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);
             }
 
-            mSocketConnector.dispose();
             mStreamingSession = null;
-            mSocketConnector = null;
 
             mConnecting.set(false);
+
             super.sessionClosed(session);
         }
 
@@ -253,45 +273,36 @@ public class IcecastTCPAudioBroadcaster extends IcecastAudioBroadcaster
 
                     if(connected())
                     {
-                        mLog.info("Streaming connection error detected - resetting connection - " + reason);
                         disconnect();
-                        connect();
                     }
                     else if(reason.startsWith("Connection reset"))
                     {
-                        mLog.info("Streaming connection reset by remote server - reestablishing connection");
                         disconnect();
-                        connect();
                     }
                     else if(reason.startsWith("Operation timed out"))
                     {
-                        mLog.info("Streaming connection timed out - resetting connection");
                         disconnect();
-                        connect();
                     }
                     else
                     {
                         setBroadcastState(BroadcastState.ERROR);
                         disconnect();
-                        mLog.error("Unrecognized IO error: " + reason + ". Streaming halted.", cause);
                     }
                 }
                 else if(ioe instanceof WriteTimeoutException)
                 {
-                    mLog.info("Network write timeout error - resetting connection");
                     disconnect();
-                    connect();
                 }
                 else
                 {
                     setBroadcastState(BroadcastState.ERROR);
                     disconnect();
-                    mLog.error("Unspecified IO error - streaming halted.", cause);
+                    mLog.error("[" + getStreamName() + "] Unspecified IO error - streaming halted.", cause);
                 }
             }
             else
             {
-                mLog.error("Broadcast error", cause);
+                mLog.error("[" + getStreamName() + "] Broadcast error", cause);
                 setBroadcastState(BroadcastState.ERROR);
                 disconnect();
             }
@@ -319,6 +330,10 @@ public class IcecastTCPAudioBroadcaster extends IcecastAudioBroadcaster
                     {
                         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);
@@ -328,7 +343,7 @@ public class IcecastTCPAudioBroadcaster extends IcecastAudioBroadcaster
             }
             else
             {
-                mLog.error("Icecast TCP broadcaster - unrecognized message [ " + object.getClass() +
+                mLog.error("[" + getStreamName() + "]Icecast TCP broadcaster - unrecognized message [ " + object.getClass() +
                     "] received:" + object.toString());
             }
         }

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

@@ -168,6 +168,10 @@ public class ShoutcastV1AudioBroadcaster extends AudioBroadcaster
 
                         disconnect();
                     }
+                    catch(Throwable t)
+                    {
+                        disconnect();
+                    }
 
                     mConnecting.set(false);
                 }
@@ -185,12 +189,13 @@ public class ShoutcastV1AudioBroadcaster extends AudioBroadcaster
      */
     public void disconnect()
     {
-        if(connected())
+        if(connected() && mStreamingSession != null)
         {
-            if(mStreamingSession != null)
+            mStreamingSession.closeNow();
-            {
+        }
-                mStreamingSession.closeNow();
+        else
-            }
+        {
+            mLastConnectionAttempt = System.currentTimeMillis();
         }
     }
 
@@ -226,15 +231,15 @@ public class ShoutcastV1AudioBroadcaster extends AudioBroadcaster
         @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);
             }
 
-            mSocketConnector.dispose();
             mStreamingSession = null;
-            mSocketConnector = null;
 
             mConnecting.set(false);
             super.sessionClosed(session);
@@ -255,13 +260,11 @@ public class ShoutcastV1AudioBroadcaster extends AudioBroadcaster
                     {
                         mLog.info("Streaming connection reset by remote server - reestablishing connection");
                         disconnect();
-                        connect();
                     }
                     else if(reason.startsWith("Operation timed out"))
                     {
                         mLog.info("Streaming connection timed out - resetting connection");
                         disconnect();
-                        connect();
                     }
                     else
                     {

src/audio/broadcast/shoutcast/v2/ShoutcastV2AudioBroadcaster.java

@@ -204,6 +204,10 @@ public class ShoutcastV2AudioBroadcaster extends AudioBroadcaster implements IBr
 
                         disconnect();
                     }
+                    catch(Throwable t)
+                    {
+                        disconnect();
+                    }
 
                     mConnecting.set(false);
                 }
@@ -221,13 +225,13 @@ public class ShoutcastV2AudioBroadcaster extends AudioBroadcaster implements IBr
      */
     public void disconnect()
     {
-        if(connected())
+        if(connected() && mStreamingSession != null)
         {
-            if(mStreamingSession != null)
+            mStreamingSession.closeNow();
-            {
+        }
-                mStreamingSession.write(new TerminateBroadcast());
+        else
-                mStreamingSession.closeNow();
+        {
-            }
+            mLastConnectionAttempt = System.currentTimeMillis();
         }
     }
 
@@ -349,15 +353,15 @@ public class ShoutcastV2AudioBroadcaster extends AudioBroadcaster implements IBr
         @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);
             }
 
-            mSocketConnector.dispose();
             mStreamingSession = null;
-            mSocketConnector = null;
 
             mConnecting.set(false);
             super.sessionClosed(session);
@@ -378,13 +382,11 @@ public class ShoutcastV2AudioBroadcaster extends AudioBroadcaster implements IBr
                     {
                         mLog.info("Streaming connection reset by remote server - reestablishing connection");
                         disconnect();
-                        connect();
                     }
                     else if(reason.startsWith("Operation timed out"))
                     {
                         mLog.info("Streaming connection timed out - resetting connection");
                         disconnect();
-                        connect();
                     }
                     else
                     {

src/bits/BinaryMessage.java

@@ -137,6 +137,17 @@ public class BinaryMessage extends BitSet
     	mCRC = crc;
     }
 
+    /**
+     * Indicates the number of bit errors that were corrected in this message.
+     *
+     * @see CorrectedBinaryMessage subclass that supports setting this value
+     * @return number of corrected bits in this message
+     */
+    public int getCorrectedBitCount()
+    {
+        return 0;
+    }
+    
     /**
      * Current pointer index
      */

src/bits/CorrectedBinaryMessage.java

@@ -0,0 +1,65 @@
+/*******************************************************************************
+ * 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 bits;
+
+import java.util.BitSet;
+
+public class CorrectedBinaryMessage extends BinaryMessage
+{
+    private int mCorrectedBitCount;
+
+    /**
+     * Subclass of binary message class to allow capturing a corrected bits metric.
+     * @param size of message to create.
+     */
+    public CorrectedBinaryMessage(int size)
+    {
+        super(size);
+    }
+
+    public CorrectedBinaryMessage(int size, boolean[] bitsToPreload)
+    {
+        super(size, bitsToPreload);
+    }
+
+    public CorrectedBinaryMessage(BitSet bitset, int size)
+    {
+        super(bitset, size);
+    }
+
+    public CorrectedBinaryMessage(byte[] data)
+    {
+        super(data);
+    }
+
+    @Override
+    public int getCorrectedBitCount()
+    {
+        return mCorrectedBitCount;
+    }
+
+    /**
+     * Sets the number of bits that were corrected in this message
+     * @param count of corrected bits
+     */
+    public void setCorrectedBitCount(int count)
+    {
+        mCorrectedBitCount = count;
+    }
+}

src/channel/heartbeat/Heartbeat.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 channel.heartbeat;
+
+public class Heartbeat
+{
+    /**
+     * Periodic pulse that is broadcast to subscribing modules within the demodulating chain so that
+     * monitoring of state and other attributes can occur on the primary demodulation and decoding
+     * thread.
+     */
+    public Heartbeat()
+    {
+    }
+}

src/channel/heartbeat/IHeartbeatListener.java

@@ -0,0 +1,26 @@
+/*******************************************************************************
+ * 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 channel.heartbeat;
+
+import sample.Listener;
+
+public interface IHeartbeatListener
+{
+    public Listener<Heartbeat> getHeartbeatListener();
+}

src/channel/heartbeat/IHeartbeatProvider.java

@@ -0,0 +1,28 @@
+/*******************************************************************************
+ * 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 channel.heartbeat;
+
+import sample.Listener;
+
+public interface IHeartbeatProvider
+{
+    public void setHeartbeatListener(Listener<Heartbeat> listener);
+
+    public void removeHeartbeatListener();
+}

src/channel/state/ChannelState.java

@@ -20,6 +20,8 @@ package channel.state;
 
 import audio.squelch.ISquelchStateProvider;
 import audio.squelch.SquelchState;
+import channel.heartbeat.Heartbeat;
+import channel.heartbeat.IHeartbeatListener;
 import channel.metadata.Attribute;
 import channel.metadata.AttributeChangeRequest;
 import channel.metadata.IAttributeChangeRequestListener;
@@ -39,16 +41,13 @@ import sample.real.IOverflowListener;
 import source.tuner.frequency.FrequencyChangeEvent;
 import source.tuner.frequency.IFrequencyChangeListener;
 
-import java.util.concurrent.RejectedExecutionException;
 import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.TimeUnit;
 
 import static source.tuner.frequency.FrequencyChangeEvent.Event.NOTIFICATION_FREQUENCY_CHANGE;
 
 public class ChannelState extends Module implements ICallEventProvider, IDecoderStateEventListener,
-    IDecoderStateEventProvider, IFrequencyChangeListener, ISquelchStateProvider, IAttributeChangeRequestListener,
+    IDecoderStateEventProvider, IFrequencyChangeListener, IHeartbeatListener, ISquelchStateProvider,
-    IOverflowListener
+    IAttributeChangeRequestListener, IOverflowListener
 {
     private final static Logger mLog = LoggerFactory.getLogger(ChannelState.class);
 
@@ -61,8 +60,7 @@ public class ChannelState extends Module implements ICallEventProvider, IDecoder
     private Listener<DecoderStateEvent> mDecoderStateListener;
     private Listener<SquelchState> mSquelchStateListener;
     private DecoderStateEventReceiver mDecoderStateEventReceiver = new DecoderStateEventReceiver();
-    private StateMonitor mStateMonitor = new StateMonitor();
+    private HeartbeatReceiver mHeartbeatReceiver = new HeartbeatReceiver();
-    private ScheduledFuture<?> mStateMonitorFuture;
     private ChannelType mChannelType;
     private TrafficChannelManager mTrafficChannelEndListener;
     private CallEvent mTrafficChannelCallEvent;
@@ -79,30 +77,21 @@ public class ChannelState extends Module implements ICallEventProvider, IDecoder
 
 
     /**
-     * Channel state tracks the overall state of all processing modules and decoders
+     * Channel state tracks the overall state of all processing modules and decoders configured for the channel and
-     * configured for the channel and provides squelch control and decoder state
+     * provides squelch control and decoder state reset events.
-     * reset events.
      *
-     * Uses a state enumeration that defines allowable channel state transitions in
+     * Uses a state enumeration that defines allowable channel state transitions in order to track a call or data decode
-     * order to track a call or data decode event from start to finish.  Uses a
+     * event from start to finish.  Uses a timer to monitor for inactivity and to provide a FADE period that indicates
-     * timer to monitor for inactivity and to provide a FADE period that indicates
+     * to the user that the activity has stopped while continuing to provide details about the call, before the state is
-     * to the user that the activity has stopped while continuing to provide details
+     * reset to IDLE.
-     * about the call, before the state is reset to IDLE.
-     *
-     * Since this class is multi-threaded between decoder events and the internal
-     * timer that monitors for inactivity, this class uses the mState object for
-     * thread synchronization.
      *
      * State Descriptions:
-     * IDLE		Normal state. No voice or data call activity
+     * IDLE:  Normal state. No voice or data call activity
-     * CALL/DATA/ENCRYPTED/CONTROL
+     * CALL/DATA/ENCRYPTED/CONTROL:  Decoding states.
-     * Decoding states.
+     * FADE:  The phase after a voice or data call when either an explicit call end has been received, or when no new
-     * FADE		The phase after a voice or data call when either an explicit
+     *     signalling updates have been received, and the fade timer has expired.  This phase allows for gui updates to
-     * call end has been received, or when no new signalling updates
+     *     signal to the user that the call is ended, while continuing to display the call details for the user
-     * have been received, and the fade timer has expired.  This phase
+     * TEARDOWN:  Indicates a traffic channel that will be torn down for reuse.
-     * allows for gui updates to signal to the user that the call is
-     * ended, while continuing to display the call details for the user
-     * TEARDOWN	Indicates a traffic channel that will be torn down for reuse.
      */
     public ChannelState(ChannelType channelType)
     {
@@ -137,23 +126,11 @@ public class ChannelState extends Module implements ICallEventProvider, IDecoder
     @Override
     public void start(ScheduledExecutorService executor)
     {
-        if(mStateMonitorFuture == null && mStateMonitor != null)
+        mMutableMetadata.receive(new AttributeChangeRequest<State>(Attribute.CHANNEL_STATE, mState));
+
+        if(mTrafficChannelEndListener != null)
         {
-            mMutableMetadata.receive(new AttributeChangeRequest<State>(Attribute.CHANNEL_STATE, mState));
+            setState(State.CALL);
-
-            if(mTrafficChannelEndListener != null)
-            {
-                setState(State.CALL);
-            }
-
-            try
-            {
-                mStateMonitorFuture = executor.scheduleAtFixedRate(mStateMonitor, 0, 20, TimeUnit.MILLISECONDS);
-            }
-            catch(RejectedExecutionException ree)
-            {
-                mLog.error("state monitor scheduled task rejected", ree);
-            }
         }
     }
 
@@ -162,16 +139,6 @@ public class ChannelState extends Module implements ICallEventProvider, IDecoder
     {
         mMutableMetadata.resetAllAttributes();
 
-        if(mStateMonitorFuture != null)
-        {
-            boolean success = mStateMonitorFuture.cancel(true);
-
-            if(!success)
-            {
-                mLog.error("Couldn't stop monitoring scheduled future");
-            }
-        }
-
         mTrafficChannelEndListener = null;
 
         if(mTrafficChannelCallEvent != null)
@@ -182,8 +149,6 @@ public class ChannelState extends Module implements ICallEventProvider, IDecoder
 
         mTrafficChannelCallEvent = null;
 
-        mStateMonitorFuture = null;
-
         mSquelchLocked = false;
     }
 
@@ -192,7 +157,6 @@ public class ChannelState extends Module implements ICallEventProvider, IDecoder
         mCallEventListener = null;
         mDecoderStateListener = null;
         mSquelchStateListener = null;
-        mStateMonitor = null;
     }
 
     @Override
@@ -312,70 +276,74 @@ public class ChannelState extends Module implements ICallEventProvider, IDecoder
     }
 
     /**
-     * Sets the channel state to the specified state, or updates the timeout
+     * Sets the channel state to the specified state, or updates the timeout values so that the state monitor will not
-     * values so that the state monitor will not change state.  Broadcasts a
+     * change state.  Broadcasts a squelch event when the state changes and the audio squelch state should change.  Also
-     * squelch event when the state changes and the audio squelch state should
+     * broadcasts changed attribute and decoder state events so that external processes can maintain sync with this
-     * change.  Also broadcasts changed attribute and decoder state events so
+     * channel state.
-     * that external processes can maintain sync with this channel state.
      */
     protected void setState(State state)
     {
-        synchronized(mState)
+        if(state == mState)
         {
-            if(state == mState)
+            if(State.CALL_STATES.contains(state))
             {
-                if(State.CALL_STATES.contains(state))
+                updateFadeTimeout();
-                {
-                    updateFadeTimeout();
-                }
             }
-            else if(state != mState && mState.canChangeTo(state))
+        }
+        else if(mState.canChangeTo(state))
+        {
+            switch(state)
             {
-                switch(state)
+                case CONTROL:
-                {
+                    //Don't allow traffic channels to be control channels, otherwise they can't transition to teardown
-                    case CONTROL:
+                    if(isStandardChannel())
-                        //Don't allow traffic channels to be control channels,
+                    {
-                        //otherwise they can't transition to call tear down
-                        if(isStandardChannel())
-                        {
-                            broadcast(SquelchState.SQUELCH);
-                            updateFadeTimeout();
-                            mState = state;
-                        }
-                        break;
-                    case DATA:
-                    case ENCRYPTED:
                         broadcast(SquelchState.SQUELCH);
                         updateFadeTimeout();
                         mState = state;
-                        break;
+                    }
-                    case CALL:
+                    break;
-                        broadcast(SquelchState.UNSQUELCH);
+                case DATA:
-                        updateFadeTimeout();
+                case ENCRYPTED:
-                        mState = state;
+                    broadcast(SquelchState.SQUELCH);
-                        break;
+                    updateFadeTimeout();
-                    case FADE:
+                    mState = state;
-                        processFadeState();
+                    break;
-                        break;
+                case CALL:
-                    case IDLE:
+                    broadcast(SquelchState.UNSQUELCH);
-                        processIdleState();
+                    updateFadeTimeout();
-                        break;
+                    mState = state;
-                    case TEARDOWN:
+                    break;
-                        processTeardownState();
+                case FADE:
-                        break;
+                    processFadeState();
-                    case RESET:
+                    break;
-                        mState = State.IDLE;
+                case IDLE:
-                        break;
+                    processIdleState();
-                    default:
+                    break;
-                        break;
+                case TEARDOWN:
-                }
+                    processTeardownState();
-
+                    break;
-                mMutableMetadata.receive(new AttributeChangeRequest<State>(Attribute.CHANNEL_STATE,
+                case RESET:
-                    mSourceOverflow ? State.OVERFLOW : mState));
+                    mState = State.IDLE;
+                    break;
+                default:
+                    break;
             }
+
+            mMutableMetadata.receive(new AttributeChangeRequest<State>(Attribute.CHANNEL_STATE,
+                mSourceOverflow ? State.OVERFLOW : mState));
         }
     }
 
+    /**
+     * Receiver inner class that implements the IHeartbeatListener interface to receive heartbeat messages.
+     */
+    @Override
+    public Listener<Heartbeat> getHeartbeatListener()
+    {
+        return mHeartbeatReceiver;
+    }
+
     /**
      * This method is invoked if the source buffer provider goes into overflow state.  Since this is an external state,
      * we use the mSourceOverflow variable to override the internal state reported to external listeners.
@@ -625,45 +593,41 @@ public class ChannelState extends Module implements ICallEventProvider, IDecoder
     }
 
     /**
-     * Monitors decoder state events to automatically transition the channel
+     * Processes periodic heartbeats received from the processing chain to perform state monitoring and cleanup
-     * state to IDLE (standard channel) or to TEARDOWN (traffic channel) when
+     * functions.
-     * decoding stops or the monitored channel returns to a no signal state.
      *
-     * Provides a FADE transition state to allow for momentary decoding dropouts
+     * Monitors decoder state events to automatically transition the channel state to IDLE (standard channel) or to
-     * and to allow the user access to call details for a fade period upon
+     * TEARDOWN (traffic channel) when decoding stops or the monitored channel returns to a no signal state.
-     * call end.
+     *
+     * Provides a FADE transition state to allow for momentary decoding dropouts and to allow the user access to call
+     * details for a fade period upon call end.
      */
-    public class StateMonitor implements Runnable
+    public class HeartbeatReceiver implements Listener<Heartbeat>
     {
         @Override
-        public void run()
+        public void receive(Heartbeat heartbeat)
         {
             try
             {
-                synchronized(mState)
+                if(State.CALL_STATES.contains(mState) && mFadeTimeout <= System.currentTimeMillis())
                 {
-                    if(State.CALL_STATES.contains(mState) &&
+                    processFadeState();
-                        mFadeTimeout <= System.currentTimeMillis())
+                }
+                else if(mState == State.FADE && mEndTimeout <= System.currentTimeMillis())
+                {
+                    if(isTrafficChannel())
                     {
-                        processFadeState();
+                        processTeardownState();
                     }
-                    else if(mState == State.FADE &&
+                    else
-                        mEndTimeout <= System.currentTimeMillis())
                     {
-                        if(isTrafficChannel())
+                        processIdleState();
-                        {
-                            processTeardownState();
-                        }
-                        else
-                        {
-                            processIdleState();
-                        }
                     }
                 }
             }
-            catch(Exception e)
+            catch(Throwable e)
             {
-                mLog.error("Exception thrown while state monitor is running " +
+                mLog.error("An error occurred while state monitor was running " +
                     "- state [" + getState() +
                     "] current [" + System.currentTimeMillis() +
                     "] mResetTimeout [" + mEndTimeout +

src/edac/trellis/DMRNode.java

@@ -0,0 +1,86 @@
+/*******************************************************************************
+ * 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 edac.trellis;
+
+public class DMRNode extends Node
+{
+    //Hamming error values indicating the number of bits set in each indexed value, 0-15
+    public static final int[] HAMMING_ERROR_COUNT = new int[]{0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4};
+
+    /**
+     * Transmitted quad-bit value, derived from ETSI TS 102-361-1, Table B.7 Trellis encoder state transition table
+     *
+     * Note: the B.7 table contains constellation point ID numbers that have to be converted into actual bit values
+     * where the bits represent the dibit pair for the constellation point.
+     */
+    public static final int[][] DMR_TRANSITION_MATRIX = new int[][]
+    {
+        {2,13,14,1,7,8,11,4},
+        {14,1,7,8,11,4,2,13},
+        {10,5,6,9,15,0,3,12},
+        {6,9,15,0,3,12,10,5},
+        {15,0,3,12,10,5,6,9},
+        {3,12,10,5,6,9,15,0},
+        {7,8,11,4,2,13,14,1},
+        {11,4,2,13,14,1,7,8}
+    };
+
+    /**
+     * Trellis Coded Modulation (TCM) 3/4-rate trellis node for decoding DMR
+     *
+     * @param inputValue for the trellis time instant
+     * @param transmittedOutputValue the actual four-bit output value that was transmitted.
+     */
+    public DMRNode(int inputValue, int transmittedOutputValue)
+    {
+        super(inputValue, transmittedOutputValue);
+    }
+
+    /**
+     * Calculates the error between the preceeding node and this node as the Hamming distance between the expected
+     * four-bit output value versus the actual transmitted output value.
+     *
+     * @param precedingNode that precedes this node
+     * @return error value for this node relative to the preceeding node argument
+     */
+    @Override
+    public int getError(Node precedingNode)
+    {
+        if(precedingNode != null)
+        {
+            int expectedOutputValue = getOutputValue(precedingNode);
+            int errorMask = expectedOutputValue ^ getTransmittedOutputValue();
+            return HAMMING_ERROR_COUNT[errorMask];
+        }
+
+        return 0;
+    }
+
+    /**
+     * Expected output four-bit value when this node is preceeded by the argument node.
+     *
+     * @param precedingNode that precedes this node
+     * @return expected output value
+     */
+    @Override
+    public int getOutputValue(Node precedingNode)
+    {
+        return DMR_TRANSITION_MATRIX[precedingNode.getInputValue()][getInputValue()];
+    }
+}

src/edac/trellis/Node.java

@@ -0,0 +1,77 @@
+/*******************************************************************************
+ * 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 edac.trellis;
+
+public abstract class Node
+{
+    private int mInputValue;
+    private int mTransmittedOutputValue;
+
+    /**
+     * Trellis Coded Modulation (TCM) node.  A node represents a time instant on the trellis and contains an input
+     * value and the corresponding transmitted output value for the time instant.  A node does not maintain the
+     * state at the time instant -- the state is determined by the input value of a preceeding node.
+     *
+     * @param inputValue for this node
+     * @param transmittedOutputValue for this node
+     */
+    public Node(int inputValue, int transmittedOutputValue)
+    {
+        mInputValue = inputValue;
+        mTransmittedOutputValue = transmittedOutputValue;
+    }
+
+    /**
+     * Input value for this node.
+     *
+     * @return input value
+     */
+    public int getInputValue()
+    {
+        return mInputValue;
+    }
+
+    /**
+     * Transmitted output value for this node
+     * @return transmitted output value
+     */
+    public int getTransmittedOutputValue()
+    {
+        return mTransmittedOutputValue;
+    }
+
+    /**
+     * Calculates the error value for this node (time instant) by determining the expected output value that would have
+     * been transmitted using the state from the preceding node argument and this node's input value and comparing that
+     * expected value to the actual transmitted output value.  This error is normally represented as the Hamming
+     * distance between the two values.
+     *
+     * @param precedingNode that precedes this node
+     * @return error value for this node relative to the preceeding node
+     */
+    public abstract int getError(Node precedingNode);
+
+    /**
+     * Expected output value when this node is preceeded by the node specified in the argument.
+     *
+     * @param precedingNode that precedes this node
+     * @return expected output value
+     */
+    public abstract int getOutputValue(Node precedingNode);
+}

src/edac/trellis/Path.java

@@ -0,0 +1,131 @@
+/*******************************************************************************
+ * 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 edac.trellis;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Path
+{
+    private List<Node> mNodes = new ArrayList<>();
+    private int mError = 0;
+
+    /**
+     * Trellis Coded Modulation (TCM) path.  Represents a sequence of nodes that traverse various time instants and
+     * states across a trellis.
+     *
+     * Note: each node can be shared across multiple paths.  This class does not assume that any nodes are unique.
+     * @param startingNode to start the path.  This node normally contains an input value of zero, but is implementation
+     * specific.
+     */
+    public Path(Node startingNode)
+    {
+        add(startingNode);
+    }
+
+    /**
+     * Trellis Coded Modulation (TCM) path.  Represents a sequence of nodes that traverse various time instants and
+     * states across a trellis.
+     *
+     * Note: each node can be shared across multiple paths.  This class does not assume that any nodes are unique.
+     *
+     * @param original path to create a copy from.  Each of the nodes in the original will be added to this path and
+     * after construction both this path and the original will contain the exact same set of nodes.
+     */
+    private Path(Path original)
+    {
+        for(Node node: original.getNodes())
+        {
+            add(node);
+        }
+    }
+
+    /**
+     * Cumulative error across all nodes contained within this path.  Error value is updated as each new node is added
+     * to this path.
+     *
+     * @return cumulative error value
+     */
+    public int getError()
+    {
+        return mError;
+    }
+
+    /**
+     * Length or number of nodes contained within this path.  Note: this value includes the starting node and may
+     * also include a flushing node.  The values contained in the starting and flushing nodes are normally not used
+     * when decoding a path.
+     *
+     * @return number of nodes in this path
+     */
+    public int getLength()
+    {
+        return mNodes.size() - 1;
+    }
+
+    /**
+     * The set of nodes contained in this path.
+     * @return nodes
+     */
+    public List<Node> getNodes()
+    {
+        return mNodes;
+    }
+
+    /**
+     * Adds the node to this path and updates the cumulative error value for this path by adding the node's error
+     * value to the running error total.
+     *
+     * @param node to add to this path
+     */
+    public void add(Node node)
+    {
+        if(!mNodes.isEmpty())
+        {
+            mError += node.getError(getLastNode());
+        }
+
+        mNodes.add(node);
+    }
+
+    /**
+     * Last node in this path.
+     *
+     * @return last node
+     */
+    public Node getLastNode()
+    {
+        if(!mNodes.isEmpty())
+        {
+            return mNodes.get(mNodes.size() - 1);
+        }
+
+        return null;
+    }
+
+    /**
+     * Utility method to create an exact copy of this path.
+     *
+     * @return a new copy of this path.
+     */
+    public Path copyOf()
+    {
+        return new Path(this);
+    }
+}

src/edac/trellis/ViterbiDecoder.java

@@ -0,0 +1,226 @@
+/*******************************************************************************
+ * 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 edac.trellis;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+public abstract class ViterbiDecoder
+{
+    private int mInputBitLength;
+    private int mInputValueCount;
+    private int mOutputBitLength;
+    private int mOutputValueCount;
+
+    /**
+     * Viterbi decoder for trellis coded modulation (TCM) encoded binary sequences.
+     *
+     * @param inputBitLength for coding (e.g. 3/4 rate input bit length is 3)
+     * @param outputBitLength for coding (e.g. 3/4 rate output bit length is 4)
+     */
+    public ViterbiDecoder(int inputBitLength, int outputBitLength)
+    {
+        mInputBitLength = inputBitLength;
+        mOutputBitLength = outputBitLength;
+
+        mInputValueCount = (int)Math.pow(2.0, mInputBitLength);
+        mOutputValueCount = (int)Math.pow(2.0, mOutputBitLength);
+    }
+
+    /**
+     * Creates a node that represents an input value and the actual/transmitted output value.
+     *
+     * Note: this method must be implemented by a sub-class since the node requires a specific state transition
+     * table/matrix implementation.
+     *
+     * @param inputValue for the specific trellis node
+     * @param transmittedOutputValue the actual transmitted output value
+     * @return node for decoding
+     */
+    protected abstract Node createNode(int inputValue, int transmittedOutputValue);
+
+    /**
+     * Creates a flushing or final node that represents an actual/transmitted output value and a flushing input value.
+     *
+     * The final flushing input value is implementation-specific, therefore this will be implemented in any subclass
+     * of this decoder.  A normal flushing input value is zero.
+     *
+     * @param transmittedOutputValue the actual transmitted output value
+     * @return flushing node
+     */
+    protected abstract Node createFlushingNode(int transmittedOutputValue);
+
+    /**
+     * Creates a starting node that represents a starting state and notional transmitted output value.
+     *
+     * The starting input value is implementation-specific, therefore this will be implemented in any subclass
+     * of this decoder.  A normal starting input value is zero.
+     *
+     * @return starting node
+     */
+    protected abstract Node createStartingNode();
+
+    /**
+     * Size in bits of the input and state values (e.g. 3/4 rate input size is 3)
+     *
+     * @return input bit size
+     */
+    public int getInputBitLength()
+    {
+        return mInputBitLength;
+    }
+
+    /**
+     * Count of input or state values where the set of values is in the range of 0 <> count - 1
+     *
+     * @return input or state values count
+     */
+    public int getInputValueCount()
+    {
+        return mInputValueCount;
+    }
+
+    /**
+     * Size in bits of the output constellation or transmitted symbol value (e.g. 3/4 rate output size is 4)
+     *
+     * @return output size in bits
+     */
+    public int getOutputBitLength()
+    {
+        return mOutputBitLength;
+    }
+
+    /**
+     * Count of input or state values where the set of values is in the range of 0 <> count - 1
+     *
+     * @return input or state values count
+     */
+    public int getOutputValueCount()
+    {
+        return mOutputValueCount;
+    }
+
+    /**
+     * Decodes the TCM encoded transmitted output values and returns a path the represents the most likely transmitted
+     * sequence of nodes.
+     *
+     * @param transmittedOutputValues from the encoded message
+     * @return most likely path representing the transmitted values
+     */
+    public Path decode(int[] transmittedOutputValues)
+    {
+        Collection<Path> survivingPaths = new ArrayList<>();
+
+        survivingPaths.add(new Path(createStartingNode()));
+
+        //Add all but the last transmitted value to the starting path, creating a set of survivors at each iteration.
+        for(int x = 0; x < transmittedOutputValues.length - 1; x++)
+        {
+            survivingPaths = add(survivingPaths, transmittedOutputValues[x]);
+        }
+
+        //Flush the survivors with the final transmitted value and return the lone surviving path
+        return flush(survivingPaths, transmittedOutputValues[transmittedOutputValues.length - 1]);
+    }
+
+    /**
+     * Creates a set of new nodes representing all possible input values and the transmitted output value argument
+     * and iteratively adds the set of nodes to a copy of each of the surviving paths.  A set of surviving paths is
+     * returned that represents each path that terminates at a distinct input/state value that has the least error
+     * value.
+     *
+     * @param survivingPaths from the previous time instant to evaluate for the next time instant in the trellis
+     * using the transmitted output value.
+     *
+     * @param transmittedOutputValue that will be decoded for this time instant.
+     *
+     * @return paths that have survived (ie have the lowest error value) after adding nodes for the transmitted
+     * output value
+     *
+     */
+    public Collection<Path> add(Collection<Path> survivingPaths, int transmittedOutputValue)
+    {
+        Map<Integer,Path> survivingPathMap = new HashMap<>();
+
+        for(int x = 0; x < getInputValueCount(); x++)
+        {
+            //Create a single/unique node for each possible input value combined with the transmitted output value
+            Node node = createNode(x, transmittedOutputValue);
+
+            //Evaluate each surviving path by creating a copy and adding the node to it and see if it survives
+            for(Path path: survivingPaths)
+            {
+                Path pathToEvaluate = path.copyOf();
+
+                pathToEvaluate.add(node);
+
+                if(survivingPathMap.containsKey(node.getInputValue()))
+                {
+                    Path survivingPath = survivingPathMap.get(node.getInputValue());
+
+                    //Replace the current survivor path if this evaluate path has a lower error value
+                    if(pathToEvaluate.getError() < survivingPath.getError())
+                    {
+                        survivingPathMap.put(node.getInputValue(), pathToEvaluate);
+                    }
+                }
+                else
+                {
+                    //No survivor yet -- set this evaluate path as the first survivor
+                    survivingPathMap.put(node.getInputValue(), pathToEvaluate);
+                }
+            }
+        }
+
+        return survivingPathMap.values();
+    }
+
+    /**
+     * Flushes each of the surviving paths with a final/flushing node using the transmitted symbol.  A final flushing
+     * input value or state is implementation-specific, but normally uses a value of zero.  Since all paths will be
+     * evaluated against each other as terminating at the same state, only the path with the lowest error value will
+     * be returned from this method.
+     *
+     * @param survivingPaths to flush with the final flushing node
+     * @param transmittedOutputValue to use for the final flushing node
+     *
+     * @return the single survivor path that remains after adding the flushing node to each of the candidate argument
+     * survivor paths.
+     */
+    public Path flush(Collection<Path> survivingPaths, int transmittedOutputValue)
+    {
+        Node flushingNode = createFlushingNode(transmittedOutputValue);
+
+        Path bestPath = null;
+
+        for(Path survivingPath: survivingPaths)
+        {
+            survivingPath.add(flushingNode);
+
+            if(bestPath == null || (survivingPath.getError() < bestPath.getError()))
+            {
+                bestPath = survivingPath;
+            }
+        }
+
+        return bestPath;
+    }
+}

src/edac/trellis/ViterbiDecoder_3_4_DMR.java

@@ -0,0 +1,159 @@
+/*******************************************************************************
+ * 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 edac.trellis;
+
+import bits.BinaryMessage;
+import bits.CorrectedBinaryMessage;
+
+import java.util.List;
+
+public class ViterbiDecoder_3_4_DMR extends ViterbiDecoder
+{
+    /**
+     * Viterbi decoder for Digital Mobile Radio (DMR) 3/4 rate Trellis Coded Modulation (TCM) encoded messages.
+     */
+    public ViterbiDecoder_3_4_DMR()
+    {
+        super(3,4);
+    }
+
+    /**
+     * Decodes a 3/4 rate trellis coded modulation (TCM) encoded DMR binary message containing 196 bits that have
+     * already been deinterleaved.
+     *
+     * @param encodedMessage to decode that has already been deinterleaved.
+     * @return decoded message
+     */
+    public BinaryMessage decode(BinaryMessage encodedMessage)
+    {
+        int[] symbols = getSymbols(encodedMessage);
+
+        Path mostLikelyPath = decode(symbols);
+
+        return getMessage(mostLikelyPath);
+    }
+
+    /**
+     * Extracts the decoded/corrected message from the surviving path argument.
+     *
+     * @param path to extract a message from
+     * @return corrected binary message.
+     */
+    private static CorrectedBinaryMessage getMessage(Path path)
+    {
+        List<Node> mNodes = path.getNodes();
+
+        //Each node contains an input value excluding the starting(0) and final flushing(0) nodes.
+        CorrectedBinaryMessage message = new CorrectedBinaryMessage((mNodes.size() - 2) * 3);
+
+        if(mNodes.size() > 2)
+        {
+            for(int x = 1; x < mNodes.size() - 1; x++)
+            {
+                int inputValue = mNodes.get(x).getInputValue();
+
+                int messageOffset = 3 * (x - 1);
+
+                if((inputValue & 4) == 4)
+                {
+                    message.set(messageOffset);
+                }
+
+                if((inputValue & 2) == 2)
+                {
+                    message.set(messageOffset + 1);
+                }
+
+                if((inputValue & 1) == 1)
+                {
+                    message.set(messageOffset + 2);
+                }
+            }
+        }
+
+        //Transfer the corrected error count to the message
+        message.setCorrectedBitCount(path.getError());
+
+        return message;
+    }
+
+    /**
+     * Extracts (49) four-bit symbols (196 bits / 4) from the deinterleaved DMR binary message
+     *
+     * @param encodedMessage that deinterleaved and contains 196-bits of 3/4 TCM encoding
+     * @return symbols
+     */
+    public int[] getSymbols(BinaryMessage encodedMessage)
+    {
+        //Ensure we have an integral number of transmitted symbols (nibbles) in the message
+        if(encodedMessage.size() % getOutputBitLength() != 0)
+        {
+            throw new  IllegalArgumentException("Encoded message must contain an integral number of 4-bit symbols -" +
+                " message size: " + encodedMessage.size());
+        }
+
+        int[] symbols = new int[encodedMessage.size() / getOutputBitLength()];
+
+        int index = 0;
+        int pointer = 0;
+
+        while(index < encodedMessage.size())
+        {
+            int symbol = encodedMessage.getInt(index, index + (getOutputBitLength() - 1));
+            symbols[pointer++] = symbol;
+            index += getOutputBitLength();
+        }
+
+        return symbols;
+    }
+
+    /**
+     * Creates a DMR node
+     * @param inputValue for the specific trellis node
+     * @param transmittedOutputValue the actual transmitted output value
+     * @return created node
+     */
+    @Override
+    protected Node createNode(int inputValue, int transmittedOutputValue)
+    {
+        return new DMRNode(inputValue, transmittedOutputValue);
+    }
+
+    /**
+     * Creates a DMR flushing node.  DMR uses an input value of zero to flush the final output value out of the
+     * encoder.
+     *
+     * @param transmittedOutputValue the actual transmitted output value
+     * @return
+     */
+    @Override
+    protected Node createFlushingNode(int transmittedOutputValue)
+    {
+        return new DMRNode(0, transmittedOutputValue);
+    }
+
+    /**
+     * Creates a DMR starting node.  DMR uses a starting input value of zero for the initial node.
+     */
+    @Override
+    protected Node createStartingNode()
+    {
+        return new DMRNode(0,0);
+    }
+}

src/external/radioreference/RadioReferenceService.java

@@ -151,41 +151,4 @@ public class RadioReferenceService
 
         return mClient.getUserFeedBroadcasts(mUserAuthorization);
     }
-
-
-    public static void main(String[] args)
-    {
-        try
-        {
-            RadioReferenceService service = new RadioReferenceService("dsheirer", "1dodgeram");
-
-            Long expiration = service.getAccountExpirationDate();
-
-            mLog.debug("Expiration Date:" + (expiration != null ? new Date(expiration).toString() : "unknown"));
-
-            mLog.debug("Is Active: " + service.isAccountActive());
-
-            UserFeedBroadcast[] feeds = service.getUserFeedBroadcasts();
-
-            for(UserFeedBroadcast feed: feeds)
-            {
-                mLog.debug("Feed ID: " + feed.getFeedId() + " Desc:" + feed.getDescr());
-            }
-        }
-        catch(AxisFault af)
-        {
-            mLog.debug("Hey, I caught an axis fault!");
-            mLog.debug("Reason:" + af.getFaultReason());
-        }
-        catch(RemoteException re)
-        {
-            re.printStackTrace();
-        }
-        catch(Exception e)
-        {
-            e.printStackTrace();
-        }
-
-        mLog.debug("Finished!");
-    }
 }

src/module/ProcessingChain.java

@@ -24,16 +24,17 @@ import audio.IAudioPacketProvider;
 import audio.squelch.ISquelchStateListener;
 import audio.squelch.ISquelchStateProvider;
 import audio.squelch.SquelchState;
+import channel.heartbeat.Heartbeat;
+import channel.heartbeat.IHeartbeatListener;
+import channel.heartbeat.IHeartbeatProvider;
 import channel.metadata.AttributeChangeRequest;
 import channel.metadata.IAttributeChangeRequestListener;
 import channel.metadata.IAttributeChangeRequestProvider;
 import channel.state.ChannelState;
 import channel.state.DecoderState;
 import channel.state.DecoderStateEvent;
-import channel.state.DecoderStateEvent.Event;
 import channel.state.IDecoderStateEventListener;
 import channel.state.IDecoderStateEventProvider;
-import channel.state.State;
 import controller.channel.Channel.ChannelType;
 import controller.channel.ChannelEvent;
 import controller.channel.IChannelEventListener;
@@ -63,8 +64,6 @@ import sample.real.RealBuffer;
 import source.ComplexSource;
 import source.RealSource;
 import source.Source;
-import source.SourceException;
-import source.tuner.TunerChannelSource;
 import source.tuner.frequency.FrequencyChangeEvent;
 import source.tuner.frequency.IFrequencyChangeListener;
 import source.tuner.frequency.IFrequencyChangeProvider;
@@ -103,6 +102,7 @@ public class ProcessingChain implements IChannelEventListener
     private Broadcaster<ComplexBuffer> mComplexBufferBroadcaster = new Broadcaster<>();
     private Broadcaster<DecoderStateEvent> mDecoderStateEventBroadcaster = new Broadcaster<>();
     private Broadcaster<FrequencyChangeEvent> mFrequencyChangeEventBroadcaster = new Broadcaster<>();
+    private Broadcaster<Heartbeat> mHeartbeatBroadcaster = new Broadcaster<>();
     private Broadcaster<Message> mMessageBroadcaster = new Broadcaster<>();
     private Broadcaster<RealBuffer> mFilteredRealBufferBroadcaster = new Broadcaster<>();
     private Broadcaster<RealBuffer> mUnFilteredRealBufferBroadcaster = new Broadcaster<>();
@@ -329,6 +329,11 @@ public class ProcessingChain implements IChannelEventListener
             }
         }
 
+        if(module instanceof IHeartbeatListener)
+        {
+            mHeartbeatBroadcaster.addListener(((IHeartbeatListener)module).getHeartbeatListener());
+        }
+
         if(module instanceof IMessageListener)
         {
             mMessageBroadcaster.addListener(((IMessageListener) module).getMessageListener());
@@ -391,6 +396,11 @@ public class ProcessingChain implements IChannelEventListener
             mFrequencyChangeEventBroadcaster.removeListener(((IFrequencyChangeListener) module).getFrequencyChangeListener());
         }
 
+        if(module instanceof IHeartbeatListener)
+        {
+            mHeartbeatBroadcaster.removeListener(((IHeartbeatListener)module).getHeartbeatListener());
+        }
+
         if(module instanceof IMessageListener)
         {
             mMessageBroadcaster.removeListener(((IMessageListener) module).getMessageListener());
@@ -448,6 +458,11 @@ public class ProcessingChain implements IChannelEventListener
             ((IFrequencyChangeProvider) module).setFrequencyChangeListener(mFrequencyChangeEventBroadcaster);
         }
 
+        if(module instanceof IHeartbeatProvider)
+        {
+            ((IHeartbeatProvider)module).setHeartbeatListener(mHeartbeatBroadcaster);
+        }
+
         if(module instanceof IMessageProvider)
         {
             ((IMessageProvider) module).setMessageListener(mMessageBroadcaster);
@@ -505,6 +520,11 @@ public class ProcessingChain implements IChannelEventListener
             ((IFrequencyChangeProvider) module).setFrequencyChangeListener(null);
         }
 
+        if(module instanceof IHeartbeatProvider)
+        {
+            ((IHeartbeatProvider)module).removeHeartbeatListener();
+        }
+
         if(module instanceof IMessageProvider)
         {
             ((IMessageProvider) module).setMessageListener(null);

src/module/decode/p25/P25DecoderState.java

@@ -1713,33 +1713,41 @@ public class P25DecoderState extends DecoderState
                         .build());
                     break;
                 case SNDCP_RF_CONFIRMED_DATA:
-                    SNDCPUserData sud = (SNDCPUserData)pduc;
+                    if(pduc instanceof SNDCPUserData)
-
-                    StringBuilder sbFrom = new StringBuilder();
-                    StringBuilder sbTo = new StringBuilder();
-
-                    sbFrom.append(sud.getSourceIPAddress());
-                    sbTo.append(sud.getDestinationIPAddress());
-
-                    if(sud.getIPProtocol() == IPProtocol.UDP)
                     {
-                        sbFrom.append(":");
+                        SNDCPUserData sud = (SNDCPUserData)pduc;
-                        sbFrom.append(sud.getUDPSourcePort());
+
-                        sbTo.append(":");
+                        StringBuilder sbFrom = new StringBuilder();
-                        sbTo.append(sud.getUDPDestinationPort());
+                        StringBuilder sbTo = new StringBuilder();
+
+                        sbFrom.append(sud.getSourceIPAddress());
+                        sbTo.append(sud.getDestinationIPAddress());
+
+                        if(sud.getIPProtocol() == IPProtocol.UDP)
+                        {
+                            sbFrom.append(":");
+                            sbFrom.append(sud.getUDPSourcePort());
+                            sbTo.append(":");
+                            sbTo.append(sud.getUDPDestinationPort());
+                        }
+
+                        broadcast(new DecoderStateEvent(this, Event.START, State.DATA));
+
+                        broadcast(new P25CallEvent.Builder(CallEventType.DATA_CALL)
+                            .aliasList(getAliasList())
+                            .channel(mCurrentChannel)
+                            .details("DATA: " + sud.getPayload() +
+                                " RADIO IP:" + sbTo.toString())
+                            .frequency(mCurrentChannelFrequency)
+                            .from(sbFrom.toString())
+                            .to(pduc.getLogicalLinkID())
+                            .build());
+                    }
+                    else
+                    {
+                        mLog.error("Error - expected SNDCPUserData instance but class was: " + pduc.getClass() +
+                        " and PDU Type:" + pduc.getPDUType().name());
                     }
-
-                    broadcast(new DecoderStateEvent(this, Event.START, State.DATA));
-
-                    broadcast(new P25CallEvent.Builder(CallEventType.DATA_CALL)
-                        .aliasList(getAliasList())
-                        .channel(mCurrentChannel)
-                        .details("DATA: " + sud.getPayload() +
-                            " RADIO IP:" + sbTo.toString())
-                        .frequency(mCurrentChannelFrequency)
-                        .from(sbFrom.toString())
-                        .to(pduc.getLogicalLinkID())
-                        .build());
                     break;
                 case SNDCP_RF_UNCONFIRMED_DATA:
                     break;

src/sample/OverflowableTransferQueue.java

@@ -124,10 +124,6 @@ public class OverflowableTransferQueue<E>
             mQueue.clear();
             mCounter.set(0);
             mOverflow.set(false);
-            if(mOverflowListener != null)
-            {
-                mOverflowListener.sourceOverflow(false);
-            }
         }
     }
 }

src/source/Source.java

@@ -17,6 +17,7 @@
  ******************************************************************************/
 package source;
 
+import channel.heartbeat.IHeartbeatProvider;
 import module.Module;
 import sample.SampleType;
 import sample.real.IOverflowListener;
@@ -26,7 +27,8 @@ import source.tuner.frequency.IFrequencyChangeProvider;
 /**
  * Abstract class to define the minimum functionality of a sample data provider.
  */
-public abstract class Source extends Module implements IFrequencyChangeListener, IFrequencyChangeProvider
+public abstract class Source extends Module implements IFrequencyChangeListener, IFrequencyChangeProvider,
+    IHeartbeatProvider
 {
     protected SampleType mSampleType;
     protected IOverflowListener mOverflowListener;

src/source/mixer/RealMixerSource.java

@@ -17,158 +17,175 @@
  ******************************************************************************/
 package source.mixer;
 
-import java.util.Iterator;
+import channel.heartbeat.Heartbeat;
-import java.util.concurrent.CopyOnWriteArrayList;
+import dsp.gain.AutomaticGainControl;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-import javax.sound.sampled.AudioFormat;
-import javax.sound.sampled.AudioSystem;
-import javax.sound.sampled.LineUnavailableException;
-import javax.sound.sampled.TargetDataLine;
-
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-
 import sample.Listener;
 import sample.adapter.ISampleAdapter;
 import sample.real.RealBuffer;
 import source.RealSource;
 import source.SourceException;
-import dsp.gain.AutomaticGainControl;
 import source.tuner.frequency.FrequencyChangeEvent;
 
+import javax.sound.sampled.AudioFormat;
+import javax.sound.sampled.AudioSystem;
+import javax.sound.sampled.LineUnavailableException;
+import javax.sound.sampled.TargetDataLine;
+import java.util.Iterator;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.atomic.AtomicBoolean;
+
 public class RealMixerSource extends RealSource
 {
-	private final static Logger mLog = LoggerFactory.getLogger( RealMixerSource.class );
+    private final static Logger mLog = LoggerFactory.getLogger(RealMixerSource.class);
 
-	private long mFrequency = 0;
+    private long mFrequency = 0;
-	private int mBufferSize = 16384;
+    private int mBufferSize = 16384;
 
-	private BufferReader mBufferReader = new BufferReader();
+    private BufferReader mBufferReader = new BufferReader();
-	private TargetDataLine mTargetDataLine;
+    private TargetDataLine mTargetDataLine;
-	private AudioFormat mAudioFormat;
+    private AudioFormat mAudioFormat;
-	private int mBytesPerFrame = 0;
+    private int mBytesPerFrame = 0;
-	private ISampleAdapter mSampleAdapter;
+    private ISampleAdapter mSampleAdapter;
-	private AutomaticGainControl mAGC = new AutomaticGainControl();
+    private AutomaticGainControl mAGC = new AutomaticGainControl();
+    private Listener<Heartbeat> mHeartbeatListener;
+    private static final Heartbeat HEARTBEAT = new Heartbeat();
 
-	CopyOnWriteArrayList<Listener<RealBuffer>> mSampleListeners = new CopyOnWriteArrayList<Listener<RealBuffer>>();
+    private CopyOnWriteArrayList<Listener<RealBuffer>> mSampleListeners = new CopyOnWriteArrayList<Listener<RealBuffer>>();
 
-	/**
+    /**
-	 * Real Mixer Source - constructs a reader on the mixer/sound card target 
+     * Real Mixer Source - constructs a reader on the mixer/sound card target
-	 * data line using the specified audio format (sample size, sample rate ) 
+     * data line using the specified audio format (sample size, sample rate )
-	 * and broadcasts real buffers (float arrays) to all registered listeners.  
+     * and broadcasts real buffers (float arrays) to all registered listeners.
-	 * Reads buffers sized to 10% of the sample rate specified in audio format.
+     * Reads buffers sized to 10% of the sample rate specified in audio format.
-	 * 
+     *
-	 * @param targetDataLine - mixer or sound card to be used
+     * @param targetDataLine - mixer or sound card to be used
-	 * 
+     * @param format - audio format
-	 * @param format - audio format
+     * @param sampleAdapter - adapter to convert byte array data read from the
-	 * 
+     * mixer into float array data.  Can optionally invert the channel data if
-	 * @param name - token name to use for this source
+     * the left/right stereo channels are inverted.
-	 * 
+     */
-	 * @param sampleAdapter - adapter to convert byte array data read from the
+    public RealMixerSource(TargetDataLine targetDataLine,
-	 * mixer into float array data.  Can optionally invert the channel data if
+                           AudioFormat format,
-	 * the left/right stereo channels are inverted.
+                           ISampleAdapter sampleAdapter)
-	 */
-    public RealMixerSource( TargetDataLine targetDataLine, 
-    						AudioFormat format,
-    						ISampleAdapter sampleAdapter )
     {
-    	mTargetDataLine = targetDataLine;
+        mTargetDataLine = targetDataLine;
         mAudioFormat = format;
         mSampleAdapter = sampleAdapter;
     }
 
-	@Override
+    @Override
-	public void setFrequencyChangeListener(Listener<FrequencyChangeEvent> listener)
+    public void setFrequencyChangeListener(Listener<FrequencyChangeEvent> listener)
-	{
-		//Not implemented
-	}
-
-	@Override
-	public void removeFrequencyChangeListener()
-	{
-		//Not implemented
-	}
-
-	@Override
-	public Listener<FrequencyChangeEvent> getFrequencyChangeListener()
-	{
-		//Not implemented
-		return null;
-	}
-
-	@Override
-	public void reset()
-	{
-	}
-
-	@Override
-	public void start( ScheduledExecutorService executor )
-	{
-	}
-
-	@Override
-	public void stop()
-	{
-	}
-
-	public void setListener( Listener<RealBuffer> listener )
     {
-		mSampleListeners.add( listener );
+        //Not implemented
+    }
+
+    @Override
+    public void removeFrequencyChangeListener()
+    {
+        //Not implemented
+    }
+
+    @Override
+    public Listener<FrequencyChangeEvent> getFrequencyChangeListener()
+    {
+        //Not implemented
+        return null;
+    }
+
+    /**
+     * Registers the listener to receive heartbeats from this source.
+     *
+     * @param listener to receive heartbeats
+     */
+    @Override
+    public void setHeartbeatListener(Listener<Heartbeat> listener)
+    {
+        mHeartbeatListener = listener;
+    }
+
+    /**
+     * Removes the currently registered heartbeat listener
+     */
+    @Override
+    public void removeHeartbeatListener()
+    {
+        mHeartbeatListener = null;
+    }
+
+    @Override
+    public void reset()
+    {
+    }
+
+    @Override
+    public void start(ScheduledExecutorService executor)
+    {
+    }
+
+    @Override
+    public void stop()
+    {
+    }
+
+    public void setListener(Listener<RealBuffer> listener)
+    {
+        mSampleListeners.add(listener);
 
 		/* If this is the first listener, start the reader thread */
-		if( !mBufferReader.isRunning() )
+        if(!mBufferReader.isRunning())
-		{
+        {
-			Thread thread = new Thread( mBufferReader );
+            Thread thread = new Thread(mBufferReader);
-			thread.setDaemon( true );
+            thread.setDaemon(true);
-			thread.setName( "Sample Reader" );
+            thread.setName("Sample Reader");
-			thread.start();
+            thread.start();
-		}
+        }
     }
 
-    public void removeListener( Listener<RealBuffer> listener )
+    public void removeListener(Listener<RealBuffer> listener)
     {
-		mSampleListeners.remove( listener );
+        mSampleListeners.remove(listener);
 
 		/* If this is the laster listener, stop the reader thread */
-		if( mSampleListeners.isEmpty() )
+        if(mSampleListeners.isEmpty())
-		{
+        {
-			mBufferReader.stop();
+            mBufferReader.stop();
-		}
+        }
     }
 
-    public void broadcast( RealBuffer samples )
+    public void broadcast(RealBuffer samples)
     {
-		Iterator<Listener<RealBuffer>> it = mSampleListeners.iterator();
+        Iterator<Listener<RealBuffer>> it = mSampleListeners.iterator();
 
-		while( it.hasNext() )
+        while(it.hasNext())
-		{
+        {
-			Listener<RealBuffer> next = it.next();
+            Listener<RealBuffer> next = it.next();
 			
 			/* if this is the last (or only) listener, send him the original 
 			 * buffer, otherwise send him a copy of the buffer */
-			if( it.hasNext() )
+            if(it.hasNext())
-			{
+            {
-				next.receive( samples.copyOf() );
+                next.receive(samples.copyOf());
-			}
+            }
-			else
+            else
-			{
+            {
-				next.receive( samples );
+                next.receive(samples);
-			}
+            }
-		}
+        }
     }
 
     public int getSampleRate()
     {
-		if( mTargetDataLine != null )
+        if(mTargetDataLine != null)
-		{
+        {
-		    return (int)mTargetDataLine.getFormat().getSampleRate();
+            return (int)mTargetDataLine.getFormat().getSampleRate();
-		}
+        }
-		else
+        else
-		{
+        {
-			return 0;
+            return 0;
-		}
+        }
     }
 
     /**
@@ -176,7 +193,7 @@ public class RealMixerSource extends RealSource
      */
     public long getFrequency() throws SourceException
     {
-	    return mFrequency;
+        return mFrequency;
     }
 
     /**
@@ -184,122 +201,128 @@ public class RealMixerSource extends RealSource
      * be useful if you are streaming an external audio source in through the
      * sound card and you want to specify a frequency for that source
      */
-    public void setFrequency( long frequency )
+    public void setFrequency(long frequency)
     {
-    	mFrequency = frequency;
+        mFrequency = frequency;
     }
 
-	/**
+    /**
-	 * Reader thread.  Performs blocking read against the mixer target data 
+     * Reader thread.  Performs blocking read against the mixer target data
-	 * line, converts the samples to an array of floats using the specified 
+     * line, converts the samples to an array of floats using the specified
-	 * adapter.  Dispatches float arrays to all registered listeners.
+     * adapter.  Dispatches float arrays to all registered listeners.
-	 */
+     */
-	public class BufferReader implements Runnable
+    public class BufferReader implements Runnable
-	{
+    {
-		private AtomicBoolean mRunning = new AtomicBoolean();
+        private AtomicBoolean mRunning = new AtomicBoolean();
 
-		@Override
+        @Override
         public void run()
         {
-			if( mRunning.compareAndSet( false, true ) )
+            if(mRunning.compareAndSet(false, true))
-			{
+            {
-        		if( mTargetDataLine == null )
+                //Send a heartbeat every time we run
-        		{
+                if(mHeartbeatListener != null)
-        			mRunning.set( false );
+                {
+                    mHeartbeatListener.receive(HEARTBEAT);
+                }
 
-        			mLog.error( "ComplexMixerSource - mixer target data line"
+                if(mTargetDataLine == null)
-                			+ " is null" );
+                {
-        		}
+                    mRunning.set(false);
-        		else
-        		{
-        			mBytesPerFrame = mAudioFormat.getSampleSizeInBits() / 8;
 
-    	    		if( mBytesPerFrame == AudioSystem.NOT_SPECIFIED )
+                    mLog.error("ComplexMixerSource - mixer target data line"
-    	            {
+                        + " is null");
-    	                mBytesPerFrame = 2;
+                }
-    	            }
+                else
+                {
+                    mBytesPerFrame = mAudioFormat.getSampleSizeInBits() / 8;
+
+                    if(mBytesPerFrame == AudioSystem.NOT_SPECIFIED)
+                    {
+                        mBytesPerFrame = 2;
+                    }
     	    		
     	    		/* Set buffer size to 1/10 second of samples */
-    	    		mBufferSize = (int)( mAudioFormat.getSampleRate() 
+                    mBufferSize = (int)(mAudioFormat.getSampleRate()
-    	    				* 0.05 ) * mBytesPerFrame;
+                        * 0.05) * mBytesPerFrame;
 
             		/* We'll reuse the same buffer for each read */
-            		byte[] buffer = new byte[ mBufferSize ];
+                    byte[] buffer = new byte[mBufferSize];
 
-            		try
+                    try
                     {
-	                    mTargetDataLine.open( mAudioFormat );
+                        mTargetDataLine.open(mAudioFormat);
 
-	                    mTargetDataLine.start();
+                        mTargetDataLine.start();
                     }
-                    catch ( LineUnavailableException e )
+                    catch(LineUnavailableException e)
                     {
-                    	mLog.error( "ComplexMixerSource - mixer target data line"
+                        mLog.error("ComplexMixerSource - mixer target data line"
-                    			+ "not available to read data from", e );
+                            + "not available to read data from", e);
 
-                    	mRunning.set( false );
+                        mRunning.set(false);
                     }
 
-            		while( mRunning.get() )
+                    while(mRunning.get())
-    				{
+                    {
-        				try
+                        try
                         {
             				/* Blocking read - waits until the buffer fills */
-        					mTargetDataLine.read( buffer, 0, buffer.length );
+                            mTargetDataLine.read(buffer, 0, buffer.length);
 
 	                        /* Convert samples to float array */
-	            			float[] samples =  
+                            float[] samples =
-	            					mSampleAdapter.convert( buffer );
+                                mSampleAdapter.convert(buffer);
 	            			
 	            			/* Dispatch samples to registered listeners */
-	            			broadcast( new RealBuffer( samples ) );
+                            broadcast(new RealBuffer(samples));
                         }
-                        catch ( Exception e )
+                        catch(Exception e)
                         {
-                        	mLog.error( "ComplexMixerSource - error while reading"
+                            mLog.error("ComplexMixerSource - error while reading"
-                        			+ "from the mixer target data line", e );
+                                + "from the mixer target data line", e);
 
-                        	mRunning.set( false );
+                            mRunning.set(false);
                         }
-    				}
+                    }
-        		}
+                }
         		
         		/* Close the data line if it is still open */
-        		if( mTargetDataLine != null && mTargetDataLine.isOpen() )
+                if(mTargetDataLine != null && mTargetDataLine.isOpen())
-        		{
+                {
-        			mTargetDataLine.close();
+                    mTargetDataLine.close();
-        		}
+                }
-			}
+            }
         }
 
-		/**
+        /**
-		 * Stops the reader thread
+         * Stops the reader thread
-		 */
+         */
-		public void stop()
+        public void stop()
-		{
+        {
-			if( mRunning.compareAndSet( true, false ) )
+            if(mRunning.compareAndSet(true, false))
-			{
+            {
-				mTargetDataLine.stop();
+                mTargetDataLine.stop();
-				mTargetDataLine.close();
+                mTargetDataLine.close();
-			}
+            }
-		}
+        }
 
-		/**
+        /**
-		 * Indicates if the reader thread is running
+         * Indicates if the reader thread is running
-		 */
+         */
-		public boolean isRunning()
+        public boolean isRunning()
-		{
+        {
-			return mRunning.get();
+            return mRunning.get();
-		}
+        }
-	}
+    }
 
-	@Override
+    @Override
     public void dispose()
     {
-		if( mBufferReader != null )
+        if(mBufferReader != null)
-		{
+        {
-			mBufferReader.stop();
+            mBufferReader.stop();
-			mSampleListeners.clear();			
+            mSampleListeners.clear();
-		}
+        }
     }
 }

src/source/tuner/TunerChannelSource.java

@@ -18,6 +18,8 @@
  ******************************************************************************/
 package source.tuner;
 
+import channel.heartbeat.Heartbeat;
+import channel.heartbeat.IHeartbeatProvider;
 import dsp.filter.FilterFactory;
 import dsp.filter.Window.WindowType;
 import dsp.filter.cic.ComplexPrimeCICDecimate;
@@ -58,6 +60,7 @@ public class TunerChannelSource extends ComplexSource implements IFrequencyChang
 
     private static int CHANNEL_RATE = 48000;
     private static int CHANNEL_PASS_FREQUENCY = 12000;
+    private static final Heartbeat HEARTBEAT = new Heartbeat();
 
     private OverflowableTransferQueue<ComplexBuffer> mBuffer;
 
@@ -66,6 +69,7 @@ public class TunerChannelSource extends ComplexSource implements IFrequencyChang
     private Oscillator mMixer;
     private ComplexPrimeCICDecimate mDecimationFilter;
     private Listener<ComplexBuffer> mListener;
+    private Listener<Heartbeat> mHeartbeatListener;
     private IFrequencyChangeProcessor mFrequencyChangeProcessor;
     private DownstreamProcessor mDownstreamFrequencyEventProcessor = new DownstreamProcessor();
     private ScheduledFuture<?> mTaskHandle;
@@ -352,6 +356,25 @@ public class TunerChannelSource extends ComplexSource implements IFrequencyChang
         return mDownstreamFrequencyEventProcessor.getFrequencyChangeListener();
     }
 
+    /**
+     * Registers the listener to receive heartbeats from this source.
+     * @param listener to receive heartbeats
+     */
+    @Override
+    public void setHeartbeatListener(Listener<Heartbeat> listener)
+    {
+        mHeartbeatListener = listener;
+    }
+
+    /**
+     * Removes the currently registered heartbeat listener
+     */
+    @Override
+    public void removeHeartbeatListener()
+    {
+        mHeartbeatListener = null;
+    }
+
     /**
      * Managers frequency change requests and notifications from/to any downstream component.  Downstream
      * components are those that receive samples from this tuner channel source.  These downstream components will be
@@ -477,6 +500,13 @@ public class TunerChannelSource extends ComplexSource implements IFrequencyChang
             {
                 if(mProcessing)
                 {
+                    //Send a heartbeat every time this runs to allow downstream components to perform periodic
+                    //state monitoring functions on this thread
+                    if(mHeartbeatListener != null)
+                    {
+                        mHeartbeatListener.receive(HEARTBEAT);
+                    }
+
                     mBuffer.drainTo(mSampleBuffers, 20);
 
                     for(Buffer buffer : mSampleBuffers)

src/source/tuner/usb/USBTransferProcessor.java

@@ -54,7 +54,7 @@ public class USBTransferProcessor implements TransferCallback
     private static final int TRANSFER_BUFFER_POOL_SIZE = 16;
 
     //Maximum number of filled buffers for the blocking queue
-    private static final int FILLED_BUFFER_MAX_CAPACITY = 300;
+    private static final int FILLED_BUFFER_MAX_CAPACITY = 500;
 
     //Threshold for resetting buffer overflow condition
     private static final int FILLED_BUFFER_OVERFLOW_RESET_THRESHOLD = 100;
@@ -200,7 +200,7 @@ public class USBTransferProcessor implements TransferCallback
 
 
             //Unregister from LibUSB processor so that it auto-stops LibUSB processing
-            TunerManager.LIBUSB_TRANSFER_PROCESSOR.registerTransferProcessor(this);
+            TunerManager.LIBUSB_TRANSFER_PROCESSOR.unregisterTransferProcessor(this);
 
             //Directly invoke the timeout handler to ensure that our cancelled transfer buffers are flushed.
             int result = LibUsb.handleEventsTimeoutCompleted(null, USB_TIMEOUT_MS,
@@ -415,23 +415,27 @@ public class USBTransferProcessor implements TransferCallback
         @Override
         public void run()
         {
-            try
+            mFilledBuffers.drainTo(mBuffersToDispatch, 50);
-            {
-                mFilledBuffers.drainTo(mBuffersToDispatch, 15);
 
-                for(byte[] buffer : mBuffersToDispatch)
+            while(!mBuffersToDispatch.isEmpty())
+            {
+                try
                 {
-                    float[] complexSamples = mSampleAdapter.convert(buffer);
+                    for(byte[] buffer : mBuffersToDispatch)
+                    {
+                        float[] complexSamples = mSampleAdapter.convert(buffer);
 
-                    mComplexBufferBroadcaster.broadcast(new ComplexBuffer(complexSamples));
+                        mComplexBufferBroadcaster.broadcast(new ComplexBuffer(complexSamples));
+                    }
+                }
+                catch(Exception e)
+                {
+                    mLog.error(mDeviceName + " - error while dispatching complex IQ buffer samples", e);
                 }
-            }
-            catch(Exception e)
-            {
-                mLog.error(mDeviceName + " - error while dispatching complex IQ buffer samples", e);
-            }
 
-            mBuffersToDispatch.clear();
+                mBuffersToDispatch.clear();
+                mFilledBuffers.drainTo(mBuffersToDispatch, 50);
+            }
         }
     }
 }

src/source/wave/ComplexWaveSource.java

@@ -18,19 +18,9 @@
  ******************************************************************************/
 package source.wave;
 
-import java.io.File;
+import channel.heartbeat.Heartbeat;
-import java.io.IOException;
-import java.util.Arrays;
-import java.util.concurrent.ScheduledExecutorService;
-
-import javax.sound.sampled.AudioFormat;
-import javax.sound.sampled.AudioInputStream;
-import javax.sound.sampled.AudioSystem;
-import javax.sound.sampled.UnsupportedAudioFileException;
-
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-
 import sample.ConversionUtils;
 import sample.Listener;
 import sample.complex.ComplexBuffer;
@@ -39,22 +29,31 @@ import source.IControllableFileSource;
 import source.IFrameLocationListener;
 import source.tuner.frequency.FrequencyChangeEvent;
 
+import javax.sound.sampled.AudioFormat;
+import javax.sound.sampled.AudioInputStream;
+import javax.sound.sampled.AudioSystem;
+import javax.sound.sampled.UnsupportedAudioFileException;
+import java.io.File;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.concurrent.ScheduledExecutorService;
+
 public class ComplexWaveSource extends ComplexSource implements IControllableFileSource
 {
-	private final static Logger mLog = 
+    private final static Logger mLog =
-			LoggerFactory.getLogger( ComplexWaveSource.class );
+        LoggerFactory.getLogger(ComplexWaveSource.class);
 
-	private IFrameLocationListener mFrameLocationListener;
+    private IFrameLocationListener mFrameLocationListener;
-	private int mBytesPerFrame;
+    private int mBytesPerFrame;
-	private int mFrameCounter = 0;
+    private int mFrameCounter = 0;
     private long mFrequency = 0;
     private Listener<ComplexBuffer> mListener;
     private AudioInputStream mInputStream;
     private File mFile;
 
-    public ComplexWaveSource( File file ) throws IOException 
+    public ComplexWaveSource(File file) throws IOException
     {
-    	mFile = file;
+        mFile = file;
     }
 
     @Override
@@ -76,72 +75,88 @@ public class ComplexWaveSource extends ComplexSource implements IControllableFil
         return null;
     }
 
+    /**
+     * Not implemented
+     */
     @Override
-	public void reset()
+    public void setHeartbeatListener(Listener<Heartbeat> listener)
-	{
-		stop();
-		start( null );
-	}
-
-	@Override
-	public void start( ScheduledExecutorService executor )
-	{
-		try
-		{
-			open();
-		} 
-		catch ( IOException | UnsupportedAudioFileException e )
-		{
-			mLog.error( "Error starting complex wave source" );
-		}
-	}
-
-	@Override
-	public void stop()
-	{
-		try
-		{
-			close();
-		} 
-		catch ( IOException e )
-		{
-			mLog.error( "Error stopping complex wave source" );
-		}
-	}
-
-	@Override
-	public long getFrameCount() throws IOException
-	{
-		// TODO Auto-generated method stub
-		return 0;
-	}
-
-	@Override
-    public int getSampleRate()
     {
-		if( mInputStream != null )
-		{
-			return (int)mInputStream.getFormat().getSampleRate();
-		}
-		
-		return 0;
     }
 
-	/**
+    /**
-	 * Returns the frequency set for this file.  Normally returns zero, but
+     * Not implemented
-	 * the value can be set with setFrequency() method.
+     */
-	 */
+    @Override
+    public void removeHeartbeatListener()
+    {
+    }
+
+    @Override
+    public void reset()
+    {
+        stop();
+        start(null);
+    }
+
+    @Override
+    public void start(ScheduledExecutorService executor)
+    {
+        try
+        {
+            open();
+        }
+        catch(IOException | UnsupportedAudioFileException e)
+        {
+            mLog.error("Error starting complex wave source");
+        }
+    }
+
+    @Override
+    public void stop()
+    {
+        try
+        {
+            close();
+        }
+        catch(IOException e)
+        {
+            mLog.error("Error stopping complex wave source");
+        }
+    }
+
+    @Override
+    public long getFrameCount() throws IOException
+    {
+        // TODO Auto-generated method stub
+        return 0;
+    }
+
+    @Override
+    public int getSampleRate()
+    {
+        if(mInputStream != null)
+        {
+            return (int)mInputStream.getFormat().getSampleRate();
+        }
+
+        return 0;
+    }
+
+    /**
+     * Returns the frequency set for this file.  Normally returns zero, but
+     * the value can be set with setFrequency() method.
+     */
     public long getFrequency()
     {
-	    return mFrequency;
+        return mFrequency;
     }
 
     /**
      * Changes the value returned from getFrequency() for this source.
      */
-    public void setFrequency( long frequency )
+    public void setFrequency(long frequency)
     {
-    	mFrequency = frequency;
+        mFrequency = frequency;
     }
 
     /**
@@ -149,16 +164,16 @@ public class ComplexWaveSource extends ComplexSource implements IControllableFil
      */
     public void close() throws IOException
     {
-    	if( mInputStream != null )
+        if(mInputStream != null)
-    	{
+        {
-        	mInputStream.close();
+            mInputStream.close();
-    	}
+        }
-    	else
+        else
-    	{
+        {
-    		throw new IOException( "Can't close wave source - was not opened" );
+            throw new IOException("Can't close wave source - was not opened");
-    	}
+        }
 
-    	mInputStream = null;
+        mInputStream = null;
     }
 
     /**
@@ -166,69 +181,69 @@ public class ComplexWaveSource extends ComplexSource implements IControllableFil
      */
     public void open() throws IOException, UnsupportedAudioFileException
     {
-    	if( mInputStream == null )
+        if(mInputStream == null)
-    	{
+        {
-        	mInputStream = AudioSystem.getAudioInputStream( mFile );
+            mInputStream = AudioSystem.getAudioInputStream(mFile);
-    	}
+        }
-    	else
+        else
-    	{
+        {
-    		throw new IOException( "Can't open wave source - is already opened" );
+            throw new IOException("Can't open wave source - is already opened");
-    	}
+        }
 
 
         AudioFormat format = mInputStream.getFormat();
 
         mBytesPerFrame = format.getFrameSize();
 
-        if( format.getChannels() != 2 || format.getSampleSizeInBits() != 16 )
+        if(format.getChannels() != 2 || format.getSampleSizeInBits() != 16)
         {
-        	throw new IOException( "Unsupported Wave Format - EXPECTED: 2 " +
+            throw new IOException("Unsupported Wave Format - EXPECTED: 2 " +
-        		"channels 16-bit samples FOUND: " + 
+                "channels 16-bit samples FOUND: " +
-    			mInputStream.getFormat().getChannels() + " channels " + 
+                mInputStream.getFormat().getChannels() + " channels " +
-        		mInputStream.getFormat().getSampleSizeInBits() + "-bit samples" );
+                mInputStream.getFormat().getSampleSizeInBits() + "-bit samples");
         }
 
         /* Broadcast that we're at frame location 0 */
-        broadcast( 0 );
+        broadcast(0);
     }
 
     /**
      * Reads the number of frames and sends a buffer to the listener
      */
-	@Override
+    @Override
-	public void next( int frames ) throws IOException
+    public void next(int frames) throws IOException
-	{
-		next( frames, true );
-	}
-
-	/**
-	 * Reads the number of frames and optionally sends the buffer to the listener
-	 */
-    public void next( int frames, boolean broadcast ) throws IOException
     {
-        if( mInputStream != null )
+        next(frames, true);
+    }
+
+    /**
+     * Reads the number of frames and optionally sends the buffer to the listener
+     */
+    public void next(int frames, boolean broadcast) throws IOException
+    {
+        if(mInputStream != null)
         {
-        	byte[] buffer = new byte[ mBytesPerFrame * frames ];
+            byte[] buffer = new byte[mBytesPerFrame * frames];
 
         	/* Fill the buffer with samples from the file */
-        	int samplesRead = mInputStream.read( buffer );
+            int samplesRead = mInputStream.read(buffer);
 
-        	mFrameCounter += samplesRead;
+            mFrameCounter += samplesRead;
 
-        	broadcast( mFrameCounter );
+            broadcast(mFrameCounter);
 
-        	if( broadcast && mListener != null )
+            if(broadcast && mListener != null)
-        	{
+            {
-            	if( samplesRead < buffer.length )
+                if(samplesRead < buffer.length)
-            	{
+                {
-            		buffer = Arrays.copyOf( buffer, samplesRead );
+                    buffer = Arrays.copyOf(buffer, samplesRead);
-            	}
+                }
 
-            	float[] samples = ConversionUtils
+                float[] samples = ConversionUtils
-            			.convertFromSigned16BitSamples( buffer );
+                    .convertFromSigned16BitSamples(buffer);
 
-            	mListener.receive( new ComplexBuffer( samples ) );
+                mListener.receive(new ComplexBuffer(samples));
-        	}
+            }
         }
     }
 
@@ -236,51 +251,51 @@ public class ComplexWaveSource extends ComplexSource implements IControllableFil
      * Registers the listener to receive sample buffers as they are read from
      * the wave file
      */
-	@Override
+    @Override
-	public void setListener( Listener<ComplexBuffer> listener )
+    public void setListener(Listener<ComplexBuffer> listener)
-	{
-        mListener = listener;
-	}
-
-	/**
-	 * Unregisters the listener from receiving sample buffers
-	 */
-    public void removeListener( Listener<ComplexBuffer> listener )
     {
-    	mListener = null;
+        mListener = listener;
     }
 
-	@Override
+    /**
+     * Unregisters the listener from receiving sample buffers
+     */
+    public void removeListener(Listener<ComplexBuffer> listener)
+    {
+        mListener = null;
+    }
+
+    @Override
     public void dispose()
     {
-		mListener = null;
+        mListener = null;
     }
 
-	@Override
+    @Override
-	public File getFile()
+    public File getFile()
-	{
+    {
-		return mFile;
+        return mFile;
-	}
+    }
 
-	private void broadcast( int byteLocation )
+    private void broadcast(int byteLocation)
-	{
+    {
-		int frameLocation = (int)( byteLocation / mBytesPerFrame );
+        int frameLocation = (int)(byteLocation / mBytesPerFrame);
 
-		if( mFrameLocationListener != null )
+        if(mFrameLocationListener != null)
-		{
+        {
-			mFrameLocationListener.frameLocationUpdated( frameLocation );
+            mFrameLocationListener.frameLocationUpdated(frameLocation);
-		}
+        }
-	}
+    }
 
-	@Override
+    @Override
-	public void setListener( IFrameLocationListener listener )
+    public void setListener(IFrameLocationListener listener)
-	{
+    {
-		mFrameLocationListener = listener;
+        mFrameLocationListener = listener;
-	}
+    }
 
-	@Override
+    @Override
-	public void removeListener( IFrameLocationListener listener )
+    public void removeListener(IFrameLocationListener listener)
-	{
+    {
-		mFrameLocationListener = null;
+        mFrameLocationListener = null;
-	}
+    }
 }

src/source/wave/RealWaveSource.java

@@ -17,19 +17,9 @@
  ******************************************************************************/
 package source.wave;
 
-import java.io.File;
+import channel.heartbeat.Heartbeat;
-import java.io.IOException;
-import java.util.Arrays;
-import java.util.concurrent.ScheduledExecutorService;
-
-import javax.sound.sampled.AudioFormat;
-import javax.sound.sampled.AudioInputStream;
-import javax.sound.sampled.AudioSystem;
-import javax.sound.sampled.UnsupportedAudioFileException;
-
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-
 import sample.ConversionUtils;
 import sample.Listener;
 import sample.real.RealBuffer;
@@ -38,114 +28,137 @@ import source.IFrameLocationListener;
 import source.RealSource;
 import source.tuner.frequency.FrequencyChangeEvent;
 
-public class RealWaveSource extends RealSource 
+import javax.sound.sampled.AudioFormat;
-	implements IControllableFileSource, AutoCloseable
+import javax.sound.sampled.AudioInputStream;
-{
+import javax.sound.sampled.AudioSystem;
-	private final static Logger mLog = 
+import javax.sound.sampled.UnsupportedAudioFileException;
-			LoggerFactory.getLogger( RealWaveSource.class );
+import java.io.File;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.concurrent.ScheduledExecutorService;
 
-	private IFrameLocationListener mFrameLocationListener;
+public class RealWaveSource extends RealSource implements IControllableFileSource, AutoCloseable
-	private int mBytesPerFrame;
+{
-	private int mFrameCounter = 0;
+    private final static Logger mLog = LoggerFactory.getLogger(RealWaveSource.class);
+
+    private IFrameLocationListener mFrameLocationListener;
+    private int mBytesPerFrame;
+    private int mFrameCounter = 0;
     private long mFrequency = 0;
     private Listener<RealBuffer> mListener;
     private AudioInputStream mInputStream;
     private File mFile;
 
-    public RealWaveSource( File file ) throws IOException 
+    public RealWaveSource(File file) throws IOException
     {
-    	mFile = file;
+        mFile = file;
     }
 
-	@Override
+    @Override
-	public void setFrequencyChangeListener(Listener<FrequencyChangeEvent> listener)
+    public void setFrequencyChangeListener(Listener<FrequencyChangeEvent> listener)
-	{
+    {
-		//Not implemented
+        //Not implemented
-	}
+    }
 
-	@Override
+    @Override
-	public void removeFrequencyChangeListener()
+    public void removeFrequencyChangeListener()
-	{
+    {
-		//Not implemented
+        //Not implemented
-	}
+    }
 
-	@Override
+    @Override
-	public Listener<FrequencyChangeEvent> getFrequencyChangeListener()
+    public Listener<FrequencyChangeEvent> getFrequencyChangeListener()
-	{
+    {
-		//Not implemented
+        //Not implemented
-		return null;
+        return null;
-	}
+    }
+
+    /**
+     * Not implemented
+     */
+    @Override
+    public void setHeartbeatListener(Listener<Heartbeat> listener)
+    {
+    }
+
+    /**
+     * Not implemented
+     */
+    @Override
+    public void removeHeartbeatListener()
+    {
+    }
 
 
-	@Override
+    @Override
-	public void reset()
+    public void reset()
-	{
+    {
-		stop();
+        stop();
-		start( null );
+        start(null);
-	}
+    }
 
 
-	@Override
+    @Override
-	public void start( ScheduledExecutorService executor )
+    public void start(ScheduledExecutorService executor)
-	{
+    {
-		try
+        try
-		{
+        {
-			open();
+            open();
-		} 
+        }
-		catch ( IOException | UnsupportedAudioFileException e )
+        catch(IOException | UnsupportedAudioFileException e)
-		{
+        {
-			mLog.error( "Error starting real wave source", e );
+            mLog.error("Error starting real wave source", e);
-		}
+        }
-	}
+    }
 
 
-	@Override
+    @Override
-	public void stop()
+    public void stop()
-	{
+    {
-		try
+        try
-		{
+        {
-			close();
+            close();
-		} 
+        }
-		catch ( IOException e )
+        catch(IOException e)
-		{
+        {
-			mLog.error( "Error stopping real wave source", e );
+            mLog.error("Error stopping real wave source", e);
-		}
+        }
-	}
+    }
 
 
-	@Override
+    @Override
-	public long getFrameCount() throws IOException
+    public long getFrameCount() throws IOException
-	{
+    {
-		// TODO Auto-generated method stub
+        // TODO Auto-generated method stub
-		return 0;
+        return 0;
-	}
+    }
 
-	@Override
+    @Override
     public int getSampleRate()
     {
-		if( mInputStream != null )
+        if(mInputStream != null)
-		{
+        {
-			return (int)mInputStream.getFormat().getSampleRate();
+            return (int)mInputStream.getFormat().getSampleRate();
-		}
+        }
 
-		return 0;
+        return 0;
     }
 
-	/**
+    /**
-	 * Returns the frequency set for this file.  Normally returns zero, but
+     * Returns the frequency set for this file.  Normally returns zero, but
-	 * the value can be set with setFrequency() method.
+     * the value can be set with setFrequency() method.
-	 */
+     */
     public long getFrequency()
     {
-	    return mFrequency;
+        return mFrequency;
     }
 
     /**
      * Changes the value returned from getFrequency() for this source.
      */
-    public void setFrequency( long frequency )
+    public void setFrequency(long frequency)
     {
-    	mFrequency = frequency;
+        mFrequency = frequency;
     }
 
     /**
@@ -153,16 +166,16 @@ public class RealWaveSource extends RealSource
      */
     public void close() throws IOException
     {
-    	if( mInputStream != null )
+        if(mInputStream != null)
-    	{
+        {
-        	mInputStream.close();
+            mInputStream.close();
-    	}
+        }
-    	else
+        else
-    	{
+        {
-    		throw new IOException( "Can't close wave source - was not opened" );
+            throw new IOException("Can't close wave source - was not opened");
-    	}
+        }
 
-    	mInputStream = null;
+        mInputStream = null;
     }
 
     /**
@@ -170,74 +183,74 @@ public class RealWaveSource extends RealSource
      */
     public void open() throws IOException, UnsupportedAudioFileException
     {
-    	if( mInputStream == null )
+        if(mInputStream == null)
-    	{
+        {
-        	mInputStream = AudioSystem.getAudioInputStream( mFile );
+            mInputStream = AudioSystem.getAudioInputStream(mFile);
-    	}
+        }
-    	else
+        else
-    	{
+        {
-    		throw new IOException( "Can't open wave source - is already opened" );
+            throw new IOException("Can't open wave source - is already opened");
-    	}
+        }
 
 
         AudioFormat format = mInputStream.getFormat();
 
         mBytesPerFrame = format.getFrameSize();
 
-        if( format.getChannels() != 1 || format.getSampleSizeInBits() != 16 )
+        if(format.getChannels() != 1 || format.getSampleSizeInBits() != 16)
         {
-        	throw new IOException( "Unsupported Wave Format - EXPECTED: 1 " +
+            throw new IOException("Unsupported Wave Format - EXPECTED: 1 " +
-        		"channel 16-bit samples FOUND: " + 
+                "channel 16-bit samples FOUND: " +
-    			mInputStream.getFormat().getChannels() + " channels " + 
+                mInputStream.getFormat().getChannels() + " channels " +
-        		mInputStream.getFormat().getSampleSizeInBits() + "-bit samples" );
+                mInputStream.getFormat().getSampleSizeInBits() + "-bit samples");
         }
         
         /* Broadcast that we're at frame location 0 */
-        broadcast( 0 );
+        broadcast(0);
     }
 
     /**
      * Reads the number of frames and sends a buffer to the listener
      */
-	@Override
+    @Override
-	public void next( int frames ) throws IOException
+    public void next(int frames) throws IOException
-	{
-		next( frames, true );
-	}
-
-	/**
-	 * Reads the number of frames and optionally sends the buffer to the listener
-	 */
-    public void next( int frames, boolean broadcast ) throws IOException
     {
-        if( mInputStream != null )
+        next(frames, true);
+    }
+
+    /**
+     * Reads the number of frames and optionally sends the buffer to the listener
+     */
+    public void next(int frames, boolean broadcast) throws IOException
+    {
+        if(mInputStream != null)
         {
-        	byte[] buffer = new byte[ mBytesPerFrame * frames ];
+            byte[] buffer = new byte[mBytesPerFrame * frames];
 
         	/* Fill the buffer with samples from the file */
-        	int samplesRead = mInputStream.read( buffer );
+            int samplesRead = mInputStream.read(buffer);
 
-        	mFrameCounter += samplesRead;
+            mFrameCounter += samplesRead;
 
-        	broadcast( mFrameCounter );
+            broadcast(mFrameCounter);
 
-        	if( broadcast && mListener != null )
+            if(broadcast && mListener != null)
-        	{
+            {
-            	if( samplesRead < buffer.length )
+                if(samplesRead < buffer.length)
-            	{
+                {
-            		if( samplesRead == -1 )
+                    if(samplesRead == -1)
-            		{
+                    {
-            			throw new IOException( "End of recording" );
+                        throw new IOException("End of recording");
-            		}
+                    }
 
-            		buffer = Arrays.copyOf( buffer, samplesRead );
+                    buffer = Arrays.copyOf(buffer, samplesRead);
-            	}
+                }
 
-            	float[] samples = ConversionUtils
+                float[] samples = ConversionUtils
-            			.convertFromSigned16BitSamples( buffer );
+                    .convertFromSigned16BitSamples(buffer);
 
-            	mListener.receive( new RealBuffer( samples ) );
+                mListener.receive(new RealBuffer(samples));
-        	}
+            }
         }
     }
 
@@ -245,51 +258,51 @@ public class RealWaveSource extends RealSource
      * Registers the listener to receive sample buffers as they are read from
      * the wave file
      */
-	@Override
+    @Override
-	public void setListener( Listener<RealBuffer> listener )
+    public void setListener(Listener<RealBuffer> listener)
-	{
-        mListener = listener;
-	}
-
-	/**
-	 * Unregisters the listener from receiving sample buffers
-	 */
-    public void removeListener( Listener<RealBuffer> listener )
     {
-    	mListener = null;
+        mListener = listener;
     }
 
-	@Override
+    /**
+     * Unregisters the listener from receiving sample buffers
+     */
+    public void removeListener(Listener<RealBuffer> listener)
+    {
+        mListener = null;
+    }
+
+    @Override
     public void dispose()
     {
-		mListener = null;
+        mListener = null;
     }
 
-	@Override
+    @Override
-	public File getFile()
+    public File getFile()
-	{
+    {
-		return mFile;
+        return mFile;
-	}
+    }
 
-	private void broadcast( int byteLocation )
+    private void broadcast(int byteLocation)
-	{
+    {
-		int frameLocation = (int)( byteLocation / mBytesPerFrame );
+        int frameLocation = (int)(byteLocation / mBytesPerFrame);
 
-		if( mFrameLocationListener != null )
+        if(mFrameLocationListener != null)
-		{
+        {
-			mFrameLocationListener.frameLocationUpdated( frameLocation );
+            mFrameLocationListener.frameLocationUpdated(frameLocation);
-		}
+        }
-	}
+    }
 
-	@Override
+    @Override
-	public void setListener( IFrameLocationListener listener )
+    public void setListener(IFrameLocationListener listener)
-	{
+    {
-		mFrameLocationListener = listener;
+        mFrameLocationListener = listener;
-	}
+    }
 
-	@Override
+    @Override
-	public void removeListener( IFrameLocationListener listener )
+    public void removeListener(IFrameLocationListener listener)
-	{
+    {
-		mFrameLocationListener = null;
+        mFrameLocationListener = null;
-	}
+    }
 }