diff --git a/src/audio/AudioInverter.java b/src/audio/AudioInverter.java index a483df07..70898f73 100644 --- a/src/audio/AudioInverter.java +++ b/src/audio/AudioInverter.java @@ -17,7 +17,7 @@ ******************************************************************************/ package audio; -import sample.simplex.SimplexSampleListener; +import sample.real.RealSampleListener; import util.Oscillator; import dsp.filter.Filters; import dsp.filter.FloatFIRFilter; @@ -26,11 +26,11 @@ import dsp.filter.FloatFIRFilter; * Applies audio inversion (or un-inversion) to a stream of float audio samples * by multiplying each successive sample by either a 1 or a -1 value. */ -public class AudioInverter implements SimplexSampleListener +public class AudioInverter implements RealSampleListener { private Oscillator mSineWaveGenerator; private FloatFIRFilter mPostInversionLowPassFilter; - private SimplexSampleListener mListener; + private RealSampleListener mListener; public AudioInverter( int inversionFrequency, int sampleRate ) { @@ -47,7 +47,7 @@ public class AudioInverter implements SimplexSampleListener this( frequency.getFrequency(), sampleRate ); } - public void setListener( SimplexSampleListener listener ) + public void setListener( RealSampleListener listener ) { mListener = listener; } @@ -68,7 +68,7 @@ public class AudioInverter implements SimplexSampleListener * Simple class to receive the output of the FIR low pass filter and then * send it to the registered listener(s) */ - class FilteredSampleProcessor implements SimplexSampleListener + class FilteredSampleProcessor implements RealSampleListener { @Override public void receive( float sample ) diff --git a/src/audio/AudioOutput.java b/src/audio/AudioOutput.java index 8a50b3f1..da0dacfd 100644 --- a/src/audio/AudioOutput.java +++ b/src/audio/AudioOutput.java @@ -27,10 +27,10 @@ import javax.sound.sampled.SourceDataLine; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import sample.simplex.SimplexSampleListener; +import sample.real.RealSampleListener; import buffer.FloatSampleBufferAssembler; -public class AudioOutput implements SimplexSampleListener, +public class AudioOutput implements RealSampleListener, SquelchListener, AudioTypeListener { diff --git a/src/buffer/DoubleCircularBuffer.java b/src/buffer/DoubleCircularBuffer.java new file mode 100644 index 00000000..5759279c --- /dev/null +++ b/src/buffer/DoubleCircularBuffer.java @@ -0,0 +1,80 @@ +/******************************************************************************* + * SDR Trunk + * Copyright (C) 2014 Dennis Sheirer + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see + ******************************************************************************/ +package buffer; + +import java.util.Arrays; + +/** + * Circular sample buffer - allocates a buffer and stores samples in a circular + * fashion, overwriting older samples with newly arrived samples. Initially + * fills buffer with 0-valued samples + * + * Can be used as a delay-type buffer, to delay samples by the 'size' amount + */ +public class DoubleCircularBuffer +{ + double[] mBuffer; + int mBufferPointer = 0; + + public DoubleCircularBuffer( int size ) + { + mBuffer = new double[ size ]; + + Arrays.fill( mBuffer, 0.0 ); + } + + /** + * Puts the new value into the buffer and returns the oldest buffer value + * that it replaced + * @param newValue + * @return + */ + public double get( double newValue ) + { + double oldestSample = mBuffer[ mBufferPointer ]; + + mBuffer[ mBufferPointer ] = newValue; + + mBufferPointer++; + + if( mBufferPointer >= mBuffer.length ) + { + mBufferPointer = 0; + } + + return oldestSample; + } + + /** + * Returns the maximum from the values currently in the buffer + */ + public double max() + { + double max = 0.0d; + + for( int x = 0; x < mBuffer.length; x++ ) + { + if( mBuffer[ x ] > max ) + { + max = mBuffer[ x ]; + } + } + + return max; + } +} diff --git a/src/controller/channel/ProcessingChain.java b/src/controller/channel/ProcessingChain.java index c2241957..2a7c7b93 100644 --- a/src/controller/channel/ProcessingChain.java +++ b/src/controller/channel/ProcessingChain.java @@ -39,10 +39,10 @@ import record.wave.FloatWaveRecorder; import sample.Broadcaster; import sample.Listener; import sample.complex.ComplexSample; -import sample.simplex.SimplexBuffer; -import sample.simplex.SimplexSampleListener; +import sample.real.RealBuffer; +import sample.real.RealSampleListener; import source.ComplexSource; -import source.SimplexSource; +import source.RealSource; import source.Source; import source.SourceException; import source.config.SourceConfigMixer; @@ -89,9 +89,9 @@ public class ProcessingChain implements Listener private LinkedTransferQueue> mComplexQueue = new LinkedTransferQueue>(); - private SimplexSampleReceiver mSimplexReceiver = new SimplexSampleReceiver(); - private LinkedTransferQueue mSimplexQueue = - new LinkedTransferQueue(); + private RealSampleReceiver mRealReceiver = new RealSampleReceiver(); + private LinkedTransferQueue mRealQueue = + new LinkedTransferQueue(); protected Broadcaster mBroadcaster = new Broadcaster(); @@ -121,9 +121,9 @@ public class ProcessingChain implements Listener return mComplexReceiver; } - public Listener getSimplexReceiver() + public Listener getRealReceiver() { - return (Listener)mSimplexReceiver; + return (Listener)mRealReceiver; } public String toString() @@ -243,10 +243,10 @@ public class ProcessingChain implements Listener { ((ComplexSource)mSource).removeListener( this.getComplexReceiver() ); } - else if( mSource instanceof SimplexSource ) + else if( mSource instanceof RealSource ) { - ((SimplexSource)mSource) - .removeListener( this.getSimplexReceiver() ); + ((RealSource)mSource) + .removeListener( this.getRealReceiver() ); } if( mProcessorTask != null ) @@ -299,18 +299,18 @@ public class ProcessingChain implements Listener mSource.dispose(); } } - else if( mSource instanceof SimplexSource ) + else if( mSource instanceof RealSource ) { try { mProcessorTask = mResourceManager.getThreadPoolManager() .schedule( ThreadType.DECODER, - new SimplexProcessor(), + new RealProcessor(), 50, TimeUnit.MILLISECONDS ); - ((SimplexSource)mSource) - .setListener( this.getSimplexReceiver() ); + ((RealSource)mSource) + .setListener( this.getRealReceiver() ); } catch( RejectedExecutionException ree ) { @@ -361,7 +361,7 @@ public class ProcessingChain implements Listener "-" + mChannel.getName(); mAudioOutput = new AudioOutput( threadName ); - addSimplexListener( mAudioOutput ); + addRealListener( mAudioOutput ); /* Automatic frequency control */ if( mAFC != null ) @@ -386,7 +386,7 @@ public class ProcessingChain implements Listener tcs.addListener( mAFC ); /* Add AFC as listener to the decoder */ - mDecoder.addUnfilteredSimplexSampleListener( mAFC ); + mDecoder.addUnfilteredRealSampleListener( mAFC ); } } } @@ -496,7 +496,7 @@ public class ProcessingChain implements Listener mLog.info( getLogPrefix() + "- started audio recording [" + recorder.getFileName() + "]" ); - mDecoder.addSimplexSampleListener( (FloatWaveRecorder)recorder ); + mDecoder.addRealSampleListener( (FloatWaveRecorder)recorder ); } else if( recorder instanceof ComplexWaveRecorder ) { @@ -594,22 +594,22 @@ public class ProcessingChain implements Listener /** * Adds the listener to receive demodulated samples from the decoder */ - public void addSimplexListener( SimplexSampleListener listener ) + public void addRealListener( RealSampleListener listener ) { if( mDecoder != null ) { - mDecoder.addSimplexSampleListener( listener ); + mDecoder.addRealSampleListener( listener ); } } /** * Removes the listener from receiving demodulated samples from the decoder */ - public void removeSimplexListener( SimplexSampleListener listener ) + public void removeRealListener( RealSampleListener listener ) { if( mDecoder != null ) { - mDecoder.removeSimplexListener( listener ); + mDecoder.removeRealListener( listener ); } } @@ -675,18 +675,18 @@ public class ProcessingChain implements Listener } /** - * Manages the simplex sample queue and distributes samples to the decoder. + * Manages the real sample queue and distributes samples to the decoder. */ - private class SimplexProcessor implements Runnable + private class RealProcessor implements Runnable { @Override public void run() { - List sampleBuffers = new ArrayList(); + List sampleBuffers = new ArrayList(); - mSimplexQueue.drainTo( sampleBuffers, 4 ); + mRealQueue.drainTo( sampleBuffers, 4 ); - for( SimplexBuffer sampleBuffer: sampleBuffers ) + for( RealBuffer sampleBuffer: sampleBuffers ) { if( mDecoder != null ) { @@ -694,7 +694,7 @@ public class ProcessingChain implements Listener for( float sample: samples ) { - mDecoder.getSimplexReceiver().receive( sample ); + mDecoder.getRealReceiver().receive( sample ); } } @@ -749,15 +749,15 @@ public class ProcessingChain implements Listener } /** - * Internal listener to receive simplex (ie demodulated) samples. Places - * received samples into the queue managed by the SimplexProcessor + * Internal listener to receive real(ie demodulated) samples. Places + * received samples into the queue managed by the RealProcessor */ - public class SimplexSampleReceiver implements Listener + public class RealSampleReceiver implements Listener { @Override - public void receive( SimplexBuffer samples ) + public void receive( RealBuffer samples ) { - mSimplexQueue.add( samples ); + mRealQueue.add( samples ); } } } diff --git a/src/decode/Decoder.java b/src/decode/Decoder.java index 752c38e1..89737600 100644 --- a/src/decode/Decoder.java +++ b/src/decode/Decoder.java @@ -24,8 +24,8 @@ import message.Message; import sample.Broadcaster; import sample.Listener; import sample.complex.ComplexSample; -import sample.simplex.SimplexSampleBroadcaster; -import sample.simplex.SimplexSampleListener; +import sample.real.RealSampleBroadcaster; +import sample.real.RealSampleListener; import source.Source.SampleType; import eventlog.MessageEventLogger; @@ -33,7 +33,7 @@ public abstract class Decoder implements Listener { private MessageEventLogger mEventLogger; private Broadcaster mMessageBroadcaster = new Broadcaster(); - private SimplexSampleBroadcaster mSimplexBroadcaster = new SimplexSampleBroadcaster(); + private RealSampleBroadcaster mRealBroadcaster = new RealSampleBroadcaster(); private Broadcaster mComplexBroadcaster = new Broadcaster(); @@ -43,11 +43,11 @@ public abstract class Decoder implements Listener /** * Abstract decoder class. * - * @param sampleType - complex (I/Q) or simplex (demodulated) sample type. + * @param sampleType - complex (I/Q) or real (demodulated) sample type. * Each decoder instance will be configured to receive either complex or - * simplex samples. When configured to receive complex samples, the + * real samples. When configured to receive complex samples, the * decoder will implement a demodulator component and feed the output from - * that demodulator back onto itself via the simplex sample interface, so + * that demodulator back onto itself via the real sample interface, so * that any added auxiliary decoders will then receive the demodulated * output stream. */ @@ -57,12 +57,12 @@ public abstract class Decoder implements Listener } /** - * Returns a simplex (ie demodulated) sample listener interface for - * connecting this decoder to a simplex sample stream provider + * Returns a real (ie demodulated) sample listener interface for + * connecting this decoder to a real sample stream provider */ - public SimplexSampleListener getSimplexReceiver() + public RealSampleListener getRealReceiver() { - return mSimplexBroadcaster; + return mRealBroadcaster; } /** @@ -93,7 +93,7 @@ public abstract class Decoder implements Listener mMessageBroadcaster.clear(); mComplexBroadcaster.clear(); - mSimplexBroadcaster.clear(); + mRealBroadcaster.clear(); } /** @@ -111,7 +111,7 @@ public abstract class Decoder implements Listener public void addAuxiliaryDecoder( Decoder decoder ) { mAuxiliaryDecoders.add( decoder ); - mSimplexBroadcaster.addListener( decoder.getSimplexReceiver() ); + mRealBroadcaster.addListener( decoder.getRealReceiver() ); decoder.addMessageListener( this ); } @@ -179,24 +179,24 @@ public abstract class Decoder implements Listener } /** - * Adds a simplex sample listener to receive unfiltered demodulated samples + * Adds a real sample listener to receive unfiltered demodulated samples */ - public abstract void addUnfilteredSimplexSampleListener( SimplexSampleListener listener ); + public abstract void addUnfilteredRealSampleListener( RealSampleListener listener ); /** - * Adds a simplex sample listener to receive demodulated samples + * Adds a real sample listener to receive demodulated samples */ - public void addSimplexSampleListener( SimplexSampleListener listener ) + public void addRealSampleListener( RealSampleListener listener ) { - mSimplexBroadcaster.addListener( listener ); + mRealBroadcaster.addListener( listener ); } /** - * Remove the simplex sample listener from receiving demodulated samples + * Remove the real sample listener from receiving demodulated samples */ - public void removeSimplexListener( SimplexSampleListener listener ) + public void removeRealListener( RealSampleListener listener ) { - mSimplexBroadcaster.removeListener( listener ); + mRealBroadcaster.removeListener( listener ); } /** diff --git a/src/decode/fleetsync2/Fleetsync2Decoder.java b/src/decode/fleetsync2/Fleetsync2Decoder.java index 3391292a..f586958e 100644 --- a/src/decode/fleetsync2/Fleetsync2Decoder.java +++ b/src/decode/fleetsync2/Fleetsync2Decoder.java @@ -26,7 +26,7 @@ import java.util.ArrayList; import java.util.List; import sample.Listener; -import sample.simplex.SimplexSampleListener; +import sample.real.RealSampleListener; import source.Source.SampleType; import alias.AliasList; import bits.MessageFramer; @@ -72,11 +72,11 @@ public class Fleetsync2Decoder extends Decoder implements Instrumentable public Fleetsync2Decoder( AliasList aliasList ) { - super( SampleType.FLOAT ); + super( SampleType.REAL ); mDecimationFilter = new FloatHalfBandFilter( Filters.FIR_HALF_BAND_31T_ONE_EIGHTH_FCO, 1.0002 ); - addSimplexSampleListener( mDecimationFilter ); + addRealSampleListener( mDecimationFilter ); mBandPassFilter = new FloatFIRFilter( Filters.FIRBP_1200FSK_24000FS.getCoefficients(), 1.02 ); @@ -116,9 +116,9 @@ public class Fleetsync2Decoder extends Decoder implements Instrumentable * Returns a float listener interface for connecting this decoder to a * float stream provider */ - public SimplexSampleListener getSimplexReceiver() + public RealSampleListener getRealReceiver() { - return (SimplexSampleListener)mDecimationFilter; + return (RealSampleListener)mDecimationFilter; } @Override @@ -148,7 +148,7 @@ public class Fleetsync2Decoder extends Decoder implements Instrumentable { case INSTRUMENT_INPUT: FloatTap inputTap = (FloatTap)tap; - addSimplexSampleListener( inputTap ); + addRealSampleListener( inputTap ); break; case INSTRUMENT_BANDPASS_FILTER_TO_FSK2_DEMOD: FloatTap bpTap = (FloatTap)tap; @@ -172,7 +172,7 @@ public class Fleetsync2Decoder extends Decoder implements Instrumentable { case INSTRUMENT_INPUT: FloatTap inputTap = (FloatTap)tap; - removeSimplexListener( inputTap ); + removeRealListener( inputTap ); break; case INSTRUMENT_BANDPASS_FILTER_TO_FSK2_DEMOD: mBandPassFilter.setListener( mFSKDecoder ); @@ -184,7 +184,7 @@ public class Fleetsync2Decoder extends Decoder implements Instrumentable } @Override - public void addUnfilteredSimplexSampleListener( SimplexSampleListener listener ) + public void addUnfilteredRealSampleListener( RealSampleListener listener ) { //Not implemented } diff --git a/src/decode/ltrnet/LTRNetDecoder.java b/src/decode/ltrnet/LTRNetDecoder.java index 5dede991..850ac4db 100644 --- a/src/decode/ltrnet/LTRNetDecoder.java +++ b/src/decode/ltrnet/LTRNetDecoder.java @@ -24,7 +24,7 @@ import java.util.ArrayList; import java.util.List; import message.MessageDirection; -import sample.simplex.SimplexSampleListener; +import sample.real.RealSampleListener; import source.Source.SampleType; import alias.AliasList; import bits.MessageFramer; @@ -81,7 +81,7 @@ public class LTRNetDecoder extends Decoder implements Instrumentable mDCRemovalFilter = new DCRemovalFilter2( sDC_REMOVAL_RATIO ); mDemodulator.addListener( mDCRemovalFilter ); - mDCRemovalFilter.setListener( this.getSimplexReceiver() ); + mDCRemovalFilter.setListener( this.getRealReceiver() ); } mLTRFSKDecoder = new LTRFSKDecoder(); @@ -96,7 +96,7 @@ public class LTRNetDecoder extends Decoder implements Instrumentable } else { - this.addSimplexSampleListener( mLTRFSKDecoder ); + this.addRealSampleListener( mLTRFSKDecoder ); } if( direction == MessageDirection.OSW ) @@ -151,7 +151,7 @@ public class LTRNetDecoder extends Decoder implements Instrumentable } @Override - public void addUnfilteredSimplexSampleListener( SimplexSampleListener listener ) + public void addUnfilteredRealSampleListener( RealSampleListener listener ) { if( mDemodulator != null ) { diff --git a/src/decode/ltrstandard/LTRStandardDecoder.java b/src/decode/ltrstandard/LTRStandardDecoder.java index bc1a3eb4..9594f547 100644 --- a/src/decode/ltrstandard/LTRStandardDecoder.java +++ b/src/decode/ltrstandard/LTRStandardDecoder.java @@ -18,7 +18,7 @@ package decode.ltrstandard; import message.MessageDirection; -import sample.simplex.SimplexSampleListener; +import sample.real.RealSampleListener; import source.Source.SampleType; import alias.AliasList; import bits.MessageFramer; @@ -73,7 +73,7 @@ public class LTRStandardDecoder extends Decoder mDCRemovalFilter = new DCRemovalFilter2( sDC_REMOVAL_RATIO ); mDemodulator.addListener( mDCRemovalFilter ); - mDCRemovalFilter.setListener( this.getSimplexReceiver() ); + mDCRemovalFilter.setListener( this.getRealReceiver() ); } mLTRFSKDecoder = new LTRFSKDecoder(); @@ -88,7 +88,7 @@ public class LTRStandardDecoder extends Decoder } else { - this.addSimplexSampleListener( mLTRFSKDecoder ); + this.addRealSampleListener( mLTRFSKDecoder ); } if( direction == MessageDirection.OSW ) @@ -118,7 +118,7 @@ public class LTRStandardDecoder extends Decoder } @Override - public void addUnfilteredSimplexSampleListener( SimplexSampleListener listener ) + public void addUnfilteredRealSampleListener( RealSampleListener listener ) { if( mDemodulator != null ) { diff --git a/src/decode/mdc1200/MDCDecoder.java b/src/decode/mdc1200/MDCDecoder.java index a5c993a6..f6a48916 100644 --- a/src/decode/mdc1200/MDCDecoder.java +++ b/src/decode/mdc1200/MDCDecoder.java @@ -25,7 +25,7 @@ import instrument.tap.stream.FloatTap; import java.util.ArrayList; import java.util.List; -import sample.simplex.SimplexSampleListener; +import sample.real.RealSampleListener; import source.Source.SampleType; import alias.AliasList; import bits.MessageFramer; @@ -74,12 +74,12 @@ public class MDCDecoder extends Decoder implements Instrumentable public MDCDecoder( AliasList aliasList ) { - super( SampleType.FLOAT ); + super( SampleType.REAL ); /* Decimation filter: 48000 / 2 = 24000 */ mDecimationFilter = new FloatHalfBandFilter( Filters.FIR_HALF_BAND_31T_ONE_EIGHTH_FCO, 1.0002 ); - addSimplexSampleListener( mDecimationFilter ); + addRealSampleListener( mDecimationFilter ); /* Bandpass filter - predefined */ mBandPassFilter = new FloatFIRFilter( @@ -154,7 +154,7 @@ public class MDCDecoder extends Decoder implements Instrumentable switch( tap.getName() ) { case INSTRUMENT_INPUT: - addSimplexSampleListener( (FloatTap)tap ); + addRealSampleListener( (FloatTap)tap ); break; case INSTRUMENT_BANDPASS_FILTER_TO_FSK2_DEMOD: /* wire the tap between the bandpass filter and the demod */ @@ -186,7 +186,7 @@ public class MDCDecoder extends Decoder implements Instrumentable switch( tap.getName() ) { case INSTRUMENT_INPUT: - removeSimplexListener( (FloatTap)tap ); + removeRealListener( (FloatTap)tap ); break; case INSTRUMENT_BANDPASS_FILTER_TO_FSK2_DEMOD: mBandPassFilter.setListener( mFSKDecoder ); @@ -202,7 +202,7 @@ public class MDCDecoder extends Decoder implements Instrumentable } @Override - public void addUnfilteredSimplexSampleListener( SimplexSampleListener listener ) + public void addUnfilteredRealSampleListener( RealSampleListener listener ) { //Not implemented } diff --git a/src/decode/mpt1327/MPT1327Decoder.java b/src/decode/mpt1327/MPT1327Decoder.java index e32c5f22..ba487a56 100644 --- a/src/decode/mpt1327/MPT1327Decoder.java +++ b/src/decode/mpt1327/MPT1327Decoder.java @@ -26,7 +26,7 @@ import java.util.ArrayList; import java.util.List; import sample.Broadcaster; -import sample.simplex.SimplexSampleListener; +import sample.real.RealSampleListener; import source.Source.SampleType; import alias.AliasList; import bits.MessageFramer; @@ -106,7 +106,7 @@ public class MPT1327Decoder extends Decoder implements Instrumentable if( mNBFMDemodulator != null ) { mNBFMDemodulator.addListener( mDCRemovalFilter ); - mDCRemovalFilter.setListener( this.getSimplexReceiver() ); + mDCRemovalFilter.setListener( this.getRealReceiver() ); } } @@ -115,7 +115,7 @@ public class MPT1327Decoder extends Decoder implements Instrumentable /* Decimation filter - 48000 / 2 = 24000 output */ mDecimationFilter = new FloatHalfBandFilter( Filters.FIR_HALF_BAND_31T_ONE_EIGHTH_FCO, 1.0002 ); - addSimplexSampleListener( mDecimationFilter ); + addRealSampleListener( mDecimationFilter ); /* Low pass filter: 2kHz to pass the 1200 & 1800 Hz FSK */ mLowPassFilter = new FloatFIRFilter( @@ -169,7 +169,7 @@ public class MPT1327Decoder extends Decoder implements Instrumentable } @Override - public void addUnfilteredSimplexSampleListener( SimplexSampleListener listener ) + public void addUnfilteredRealSampleListener( RealSampleListener listener ) { if( mNBFMDemodulator != null ) { @@ -256,7 +256,7 @@ public class MPT1327Decoder extends Decoder implements Instrumentable } else { - addSimplexSampleListener( inputTap ); + addRealSampleListener( inputTap ); } break; case INSTRUMENT_HB1_FILTER_TO_LOW_PASS: @@ -292,7 +292,7 @@ public class MPT1327Decoder extends Decoder implements Instrumentable } else { - removeSimplexListener( inputTap ); + removeRealListener( inputTap ); } break; case INSTRUMENT_HB1_FILTER_TO_LOW_PASS: diff --git a/src/decode/nbfm/NBFMConventionalDecoder.java b/src/decode/nbfm/NBFMConventionalDecoder.java index f6790e19..745e5858 100644 --- a/src/decode/nbfm/NBFMConventionalDecoder.java +++ b/src/decode/nbfm/NBFMConventionalDecoder.java @@ -17,7 +17,7 @@ ******************************************************************************/ package decode.nbfm; -import sample.simplex.SimplexSampleListener; +import sample.real.RealSampleListener; import source.Source.SampleType; import decode.Decoder; import decode.DecoderType; @@ -66,7 +66,7 @@ public class NBFMConventionalDecoder extends Decoder * Route the demodulated, filtered samples back to this class to send * to all registered listeners */ - mDCRemovalFilter.setListener( this.getSimplexReceiver() ); + mDCRemovalFilter.setListener( this.getRealReceiver() ); } } @@ -77,7 +77,7 @@ public class NBFMConventionalDecoder extends Decoder } @Override - public void addUnfilteredSimplexSampleListener( SimplexSampleListener listener ) + public void addUnfilteredRealSampleListener( RealSampleListener listener ) { if( mDemodulator != null ) { diff --git a/src/decode/p25/P25Decoder.java b/src/decode/p25/P25Decoder.java index 30131be4..4563a3c3 100644 --- a/src/decode/p25/P25Decoder.java +++ b/src/decode/p25/P25Decoder.java @@ -24,7 +24,7 @@ import instrument.tap.stream.FloatTap; import java.util.ArrayList; import java.util.List; -import sample.simplex.SimplexSampleListener; +import sample.real.RealSampleListener; import source.Source.SampleType; import alias.AliasList; import decode.Decoder; @@ -83,12 +83,12 @@ public class P25Decoder extends Decoder implements Instrumentable * Route the demodulated, filtered samples back to this class to send * to all registered listeners */ - mDCRemovalFilter.setListener( this.getSimplexReceiver() ); + mDCRemovalFilter.setListener( this.getRealReceiver() ); } mC4FMDecoder = new C4FMDecoder(); - addSimplexSampleListener( mC4FMDecoder ); + addRealSampleListener( mC4FMDecoder ); } @Override @@ -120,8 +120,8 @@ public class P25Decoder extends Decoder implements Instrumentable { case TAP_DEMOD_TO_DECODER: FloatTap demodTap = (FloatTap)tap; - removeSimplexListener( mC4FMDecoder ); - addSimplexSampleListener( demodTap ); + removeRealListener( mC4FMDecoder ); + addRealSampleListener( demodTap ); demodTap.setListener( mC4FMDecoder ); break; } @@ -136,15 +136,15 @@ public class P25Decoder extends Decoder implements Instrumentable { case TAP_DEMOD_TO_DECODER: FloatTap demodTap = (FloatTap)tap; - removeSimplexListener( demodTap ); + removeRealListener( demodTap ); demodTap.removeListener( mC4FMDecoder ); - addSimplexSampleListener( mC4FMDecoder ); + addRealSampleListener( mC4FMDecoder ); break; } } @Override - public void addUnfilteredSimplexSampleListener( SimplexSampleListener listener ) + public void addUnfilteredRealSampleListener( RealSampleListener listener ) { // TODO Auto-generated method stub } diff --git a/src/decode/passport/PassportDecoder.java b/src/decode/passport/PassportDecoder.java index 2e05ee62..fefe7ee2 100644 --- a/src/decode/passport/PassportDecoder.java +++ b/src/decode/passport/PassportDecoder.java @@ -23,7 +23,7 @@ import instrument.tap.Tap; import java.util.ArrayList; import java.util.List; -import sample.simplex.SimplexSampleListener; +import sample.real.RealSampleListener; import source.Source.SampleType; import alias.AliasList; import bits.MessageFramer; @@ -78,7 +78,7 @@ public class PassportDecoder extends Decoder implements Instrumentable */ mDCRemovalFilter = new DCRemovalFilter2( sDC_REMOVAL_RATIO ); mNBFMDemodulator.addListener( mDCRemovalFilter ); - mDCRemovalFilter.setListener( this.getSimplexReceiver() ); + mDCRemovalFilter.setListener( this.getRealReceiver() ); } mPassportFSKDecoder = @@ -94,7 +94,7 @@ public class PassportDecoder extends Decoder implements Instrumentable } else { - addSimplexSampleListener( mPassportFSKDecoder ); + addRealSampleListener( mPassportFSKDecoder ); } @@ -141,7 +141,7 @@ public class PassportDecoder extends Decoder implements Instrumentable } @Override - public void addUnfilteredSimplexSampleListener( SimplexSampleListener listener ) + public void addUnfilteredRealSampleListener( RealSampleListener listener ) { if( mNBFMDemodulator != null ) { diff --git a/src/dsp/afc/AutomaticFrequencyControl.java b/src/dsp/afc/AutomaticFrequencyControl.java index 6bc8b5f0..491616b0 100644 --- a/src/dsp/afc/AutomaticFrequencyControl.java +++ b/src/dsp/afc/AutomaticFrequencyControl.java @@ -1,12 +1,12 @@ package dsp.afc; -import sample.simplex.SimplexSampleListener; +import sample.real.RealSampleListener; import source.tuner.FrequencyChangeEvent; import source.tuner.FrequencyChangeEvent.Attribute; import source.tuner.FrequencyChangeListener; import buffer.FloatAveragingBuffer; -public class AutomaticFrequencyControl implements SimplexSampleListener, +public class AutomaticFrequencyControl implements RealSampleListener, FrequencyChangeListener { private static float LARGE_ERROR = 10000.0f; diff --git a/src/dsp/agc/ComplexAutomaticGainControl.java b/src/dsp/agc/ComplexAutomaticGainControl.java new file mode 100644 index 00000000..4e037f11 --- /dev/null +++ b/src/dsp/agc/ComplexAutomaticGainControl.java @@ -0,0 +1,198 @@ +package dsp.agc; + +import java.util.concurrent.atomic.AtomicBoolean; + +import sample.Listener; +import sample.Provider; +import sample.complex.ComplexSample; +import buffer.ComplexCircularBuffer; +import buffer.DoubleCircularBuffer; + +/** + * Automatic Gain Control (AGC) for complex samples at 48000 sample rate. + */ +public class ComplexAutomaticGainControl implements Listener, + Provider +{ + private static final double SAMPLE_RATE = 48000; + + /* Signal delay line - time delay in seconds */ + private static final double DELAY_TIME_CONSTANT = 0.015; + + /* Peak detector window - time delay in seconds */ + private static final double WINDOW_TIME_CONSTANT = 0.018; + + /* Attack time constants in seconds */ + private static final double ATTACK_RISE_TIME_CONSTANT = 0.002; + private static final double ATTACK_FALL_TIME_CONSTANT = 0.005; + + private static final double ATTACK_RISE_ALPHA = 1.0 - + Math.exp( -1.0 / SAMPLE_RATE * ATTACK_RISE_TIME_CONSTANT ); + + private static final double ATTACK_FALL_ALPHA = 1.0 - + Math.exp( -1.0 / SAMPLE_RATE * ATTACK_FALL_TIME_CONSTANT ); + + /* AGC decay value in milliseconds (20 to 5000) */ + private static final double DECAY = 200; + + /* Ratio between rise and fall times of decay time constants - adjust for + * best action with SSB */ + private static final double DECAY_RISEFALL_RATIO = 0.3; + + private static final double DECAY_RISE_ALPHA = 1.0 - + Math.exp( -1.0 / ( SAMPLE_RATE * DECAY * .001 * DECAY_RISEFALL_RATIO ) ); + + private static final double DECAY_FALL_ALPHA = 1.0 - + Math.exp( -1.0 / ( SAMPLE_RATE * DECAY * .001 ) ); + + /* Hang timer release decay time constant in seconds */ + private static final double RELEASE_TIME_CONSTANT = 0.05; + + /* Specifies the AGC Knee in dB if AGC is active (nominal range -160 to 0 dB) */ + private static final double THRESHOLD = -100; + + /* Limit output to about 3db of maximum */ + private static final double AGC_OUT_SCALE = 0.7; + + /* Keep max input and output the same */ + private static final double MAX_AMPLITUDE = 32767.0; //1.0; + private static final double MAX_MANUAL_AMPLITUDE = 32767.0; //1.0; + + /* Specifies AGC manual gain in dB if AGC is not active ( 0 to 100 dB) */ + private static final double MANUAL_GAIN = 0.0; + + private static final double MANUAL_AGC_GAIN = MAX_MANUAL_AMPLITUDE * + Math.pow( 10.0, MANUAL_GAIN / 20.0 ); + + /* Specifies dB reduction in output at knee from max output level (0 - 10dB) */ + private static final double SLOPE_FACTOR = 2.0; + + private static final double KNEE = THRESHOLD / 20.0; + + private static final double GAIN_SLOPE = SLOPE_FACTOR / 100.0; + + private static final double FIXED_GAIN = AGC_OUT_SCALE * + Math.pow( 10.0, KNEE * ( GAIN_SLOPE - 1.0 ) ); + + /* Constant for calc log() so that a value of 0 magnitude = -8 */ + private static final double MIN_CONSTANT = 3.2767E-4; + + private AtomicBoolean mAGCEnabled = new AtomicBoolean( true ); + + private double mPeakMagnitude = 0.0; + private double mAttackAverage = 0.0; + private double mDecayAverage = 0.0; + + private ComplexCircularBuffer mDelayBuffer = + new ComplexCircularBuffer( (int)( SAMPLE_RATE * DELAY_TIME_CONSTANT ) ); + private DoubleCircularBuffer mMagnitudeBuffer = + new DoubleCircularBuffer( (int)( SAMPLE_RATE * WINDOW_TIME_CONSTANT ) ); + + private Listener mListener; + + public ComplexAutomaticGainControl() + { + } + + @Override + public void receive( ComplexSample currentSample ) + { + ComplexSample delayedSample = mDelayBuffer.get( currentSample ); + + double gain = MANUAL_AGC_GAIN; + + if( mAGCEnabled.get() ) + { + float max = currentSample.maximumAbsolute(); + + double currentMagnitude = Math.log10( max + MIN_CONSTANT ) - + Math.log10( MAX_AMPLITUDE ); + + double delayedMagnitude = mMagnitudeBuffer.get( currentMagnitude ); + + if( currentMagnitude > mPeakMagnitude ) + { + /* Use current magnitude as peak if it's larger */ + mPeakMagnitude = currentMagnitude; + } + else if( delayedMagnitude == mPeakMagnitude ) + { + /* If delayed magnitude is the current peak, then find a new peak */ + mPeakMagnitude = mMagnitudeBuffer.max(); + } + + /* Exponential decay mode */ + if( mPeakMagnitude > mAttackAverage ) + { + mAttackAverage = ( ( 1.0 - ATTACK_RISE_ALPHA ) * mAttackAverage ) + + ( ATTACK_RISE_ALPHA * mPeakMagnitude ); + } + else + { + mAttackAverage = ( ( 1.0 - ATTACK_FALL_ALPHA ) * mAttackAverage ) + + ( ATTACK_FALL_ALPHA * mPeakMagnitude ); + } + + if( mPeakMagnitude > mDecayAverage ) + { + mDecayAverage = ( ( 1.0 - DECAY_RISE_ALPHA ) * mDecayAverage ) + + ( DECAY_RISE_ALPHA * mPeakMagnitude ); + } + else + { + mDecayAverage = ( ( 1.0 - DECAY_FALL_ALPHA ) * mDecayAverage ) + + ( DECAY_RISE_ALPHA * mPeakMagnitude ); + } + + double magnitude = ( mAttackAverage > mDecayAverage ) ? + mAttackAverage : mDecayAverage; + + if( magnitude < KNEE ) + { + gain = FIXED_GAIN; + } + else + { + gain = AGC_OUT_SCALE * Math.pow( 10.0, + magnitude * ( GAIN_SLOPE - 1.0 ) ); + } + + } + + delayedSample.multiply( (float)gain ); + + if( mListener != null ) + { + mListener.receive( delayedSample ); + } + } + + /** + * Enables or disables Automatic Gain Control (AGC). + */ + public void setAGCEnabled( boolean enabled ) + { + mAGCEnabled.set( enabled ); + } + + /** + * Indicates if AGC is enabled + * @return true=AGC, false=MANUAL GAIN + */ + public boolean isAGCEnabled() + { + return mAGCEnabled.get(); + } + + @Override + public void setListener( Listener listener ) + { + mListener = listener; + } + + @Override + public void removeListener( Listener listener ) + { + mListener = null; + } +} diff --git a/src/dsp/filter/DCRemovalFilter.java b/src/dsp/filter/DCRemovalFilter.java index 2ea181b0..4806ccaa 100644 --- a/src/dsp/filter/DCRemovalFilter.java +++ b/src/dsp/filter/DCRemovalFilter.java @@ -18,17 +18,17 @@ package dsp.filter; import sample.Listener; -import sample.simplex.SimplexSampleListener; +import sample.real.RealSampleListener; /** * Implements the real-time general DC removal algorithm described on page * 762, figure 13-62d, in Understanding Digital Signal Processing 3e, Lyons. */ -public class DCRemovalFilter implements SimplexSampleListener +public class DCRemovalFilter implements RealSampleListener { private double mAlpha; private float mPrevious; - private SimplexSampleListener mListener; + private RealSampleListener mListener; public DCRemovalFilter( double alpha ) { @@ -59,7 +59,7 @@ public class DCRemovalFilter implements SimplexSampleListener } } - public void setListener( SimplexSampleListener listener ) + public void setListener( RealSampleListener listener ) { mListener = listener; } diff --git a/src/dsp/filter/DCRemovalFilter2.java b/src/dsp/filter/DCRemovalFilter2.java index fa1fe6a5..36827935 100644 --- a/src/dsp/filter/DCRemovalFilter2.java +++ b/src/dsp/filter/DCRemovalFilter2.java @@ -18,13 +18,13 @@ package dsp.filter; import sample.Listener; -import sample.simplex.SimplexSampleListener; +import sample.real.RealSampleListener; -public class DCRemovalFilter2 implements SimplexSampleListener +public class DCRemovalFilter2 implements RealSampleListener { private double mAverage; private double mRatio; - private SimplexSampleListener mListener; + private RealSampleListener mListener; public DCRemovalFilter2( double ratio ) { @@ -50,7 +50,7 @@ public class DCRemovalFilter2 implements SimplexSampleListener } } - public void setListener( SimplexSampleListener listener ) + public void setListener( RealSampleListener listener ) { mListener = listener; } diff --git a/src/dsp/filter/DCRemovalFilter3.java b/src/dsp/filter/DCRemovalFilter3.java index af119490..43d331c6 100644 --- a/src/dsp/filter/DCRemovalFilter3.java +++ b/src/dsp/filter/DCRemovalFilter3.java @@ -1,14 +1,14 @@ package dsp.filter; -import sample.simplex.SimplexSampleListener; +import sample.real.RealSampleListener; -public class DCRemovalFilter3 implements SimplexSampleListener +public class DCRemovalFilter3 implements RealSampleListener { private float mAlpha; private float mPreviousInput = 0.0f; private float mPreviousOutput = 0.0f; - private SimplexSampleListener mListener; + private RealSampleListener mListener; /** * IIR single-pole DC removal filter, as described by J M de Freitas in @@ -38,7 +38,7 @@ public class DCRemovalFilter3 implements SimplexSampleListener mPreviousOutput = currentOutput; } - public void setListener( SimplexSampleListener listener ) + public void setListener( RealSampleListener listener ) { mListener = listener; } diff --git a/src/dsp/filter/FloatFIRFilter.java b/src/dsp/filter/FloatFIRFilter.java index edaa4711..c2c8d69e 100644 --- a/src/dsp/filter/FloatFIRFilter.java +++ b/src/dsp/filter/FloatFIRFilter.java @@ -19,11 +19,11 @@ package dsp.filter; import java.util.ArrayList; -import sample.simplex.SimplexSampleListener; +import sample.real.RealSampleListener; -public class FloatFIRFilter implements SimplexSampleListener +public class FloatFIRFilter implements RealSampleListener { - private SimplexSampleListener mListener; + private RealSampleListener mListener; private ArrayList mBuffer; private int mBufferSize = 1; //Temporary initial value private int mBufferPointer = 0; @@ -61,7 +61,7 @@ public class FloatFIRFilter implements SimplexSampleListener return mCoefficients.length; } - public void setListener( SimplexSampleListener listener ) + public void setListener( RealSampleListener listener ) { mListener = listener; } diff --git a/src/dsp/filter/FloatHalfBandFilter.java b/src/dsp/filter/FloatHalfBandFilter.java index e0816ba8..e1a47392 100644 --- a/src/dsp/filter/FloatHalfBandFilter.java +++ b/src/dsp/filter/FloatHalfBandFilter.java @@ -19,11 +19,11 @@ package dsp.filter; import java.util.ArrayList; -import sample.simplex.SimplexSampleListener; +import sample.real.RealSampleListener; -public class FloatHalfBandFilter implements SimplexSampleListener +public class FloatHalfBandFilter implements RealSampleListener { - private SimplexSampleListener mListener; + private RealSampleListener mListener; private ArrayList mBuffer; private int mBufferSize = 1; //Temporary initial value private int mBufferPointer = 0; @@ -188,7 +188,7 @@ public class FloatHalfBandFilter implements SimplexSampleListener /** * Registers a listener for filtered samples */ - public void setListener( SimplexSampleListener listener ) + public void setListener( RealSampleListener listener ) { mListener = listener; } diff --git a/src/dsp/filter/FloatHalfBandNoDecimateFilter.java b/src/dsp/filter/FloatHalfBandNoDecimateFilter.java index aa180c2e..57937df1 100644 --- a/src/dsp/filter/FloatHalfBandNoDecimateFilter.java +++ b/src/dsp/filter/FloatHalfBandNoDecimateFilter.java @@ -19,11 +19,11 @@ package dsp.filter; import java.util.ArrayList; -import sample.simplex.SimplexSampleListener; +import sample.real.RealSampleListener; -public class FloatHalfBandNoDecimateFilter implements SimplexSampleListener +public class FloatHalfBandNoDecimateFilter implements RealSampleListener { - private SimplexSampleListener mListener; + private RealSampleListener mListener; private ArrayList mBuffer; private int mBufferSize = 1; //Temporary initial value private int mBufferPointer = 0; @@ -178,7 +178,7 @@ public class FloatHalfBandNoDecimateFilter implements SimplexSampleListener /** * Registers a listener for filtered samples */ - public void setListener( SimplexSampleListener listener ) + public void setListener( RealSampleListener listener ) { mListener = listener; } diff --git a/src/dsp/filter/SquaringFilter.java b/src/dsp/filter/SquaringFilter.java index 0d79615c..3857e8a0 100644 --- a/src/dsp/filter/SquaringFilter.java +++ b/src/dsp/filter/SquaringFilter.java @@ -18,9 +18,9 @@ package dsp.filter; import sample.Listener; -import sample.simplex.SimplexSampleListener; +import sample.real.RealSampleListener; -public class SquaringFilter implements SimplexSampleListener +public class SquaringFilter implements RealSampleListener { private Listener mListener; diff --git a/src/dsp/fsk/C4FMDecoder.java b/src/dsp/fsk/C4FMDecoder.java index ca21f638..5184422e 100644 --- a/src/dsp/fsk/C4FMDecoder.java +++ b/src/dsp/fsk/C4FMDecoder.java @@ -7,9 +7,9 @@ import instrument.tap.stream.FloatTap; import java.util.ArrayList; import java.util.List; -import sample.simplex.SimplexSampleListener; +import sample.real.RealSampleListener; -public class C4FMDecoder implements SimplexSampleListener, Instrumentable +public class C4FMDecoder implements RealSampleListener, Instrumentable { private final String TAP_C4FM_INPUT = "C4FM Input"; private ArrayList mTaps; diff --git a/src/dsp/fsk/FSK2Decoder.java b/src/dsp/fsk/FSK2Decoder.java index c8e66cfa..a9c06789 100644 --- a/src/dsp/fsk/FSK2Decoder.java +++ b/src/dsp/fsk/FSK2Decoder.java @@ -26,7 +26,7 @@ import java.util.BitSet; import java.util.List; import sample.Listener; -import sample.simplex.SimplexSampleListener; +import sample.real.RealSampleListener; import buffer.BooleanAveragingBuffer; import dsp.fsk.SymbolEvent.Shift; @@ -50,7 +50,7 @@ import dsp.fsk.SymbolEvent.Shift; * Implements instrumentable interface, so that slice events can be received * externally to analyze decoder performance. */ -public class FSK2Decoder implements Instrumentable, SimplexSampleListener +public class FSK2Decoder implements Instrumentable, RealSampleListener { public enum Output{ NORMAL, INVERTED }; diff --git a/src/dsp/fsk/LTRFSKDecoder.java b/src/dsp/fsk/LTRFSKDecoder.java index 21ef2b16..89a06f54 100644 --- a/src/dsp/fsk/LTRFSKDecoder.java +++ b/src/dsp/fsk/LTRFSKDecoder.java @@ -27,7 +27,7 @@ import java.util.ArrayList; import java.util.List; import sample.Listener; -import sample.simplex.SimplexSampleListener; +import sample.real.RealSampleListener; import dsp.Slicer; import dsp.Slicer.Output; import dsp.filter.DCRemovalFilter3; @@ -37,7 +37,7 @@ import dsp.filter.FloatHalfBandNoDecimateFilter; import dsp.filter.LTRPulseShapingFilter; import dsp.filter.SquaringFilter; -public class LTRFSKDecoder implements SimplexSampleListener, Instrumentable +public class LTRFSKDecoder implements RealSampleListener, Instrumentable { private FloatHalfBandFilter mHBFilter1; private FloatHalfBandFilter mHBFilter2; diff --git a/src/dsp/nbfm/FMDiscriminator.java b/src/dsp/nbfm/FMDiscriminator.java index 3c8b9a9d..0f57b2b3 100644 --- a/src/dsp/nbfm/FMDiscriminator.java +++ b/src/dsp/nbfm/FMDiscriminator.java @@ -19,11 +19,11 @@ package dsp.nbfm; import sample.Listener; import sample.complex.ComplexSample; -import sample.simplex.SimplexSampleListener; +import sample.real.RealSampleListener; public class FMDiscriminator implements Listener { - private SimplexSampleListener mListener; + private RealSampleListener mListener; private ComplexSample mPreviousSample = new ComplexSample( 0.0f, 0.0f ); private double mGain; @@ -94,7 +94,7 @@ public class FMDiscriminator implements Listener mPreviousSample = currentSample; } - public void setListener( SimplexSampleListener listener ) + public void setListener( RealSampleListener listener ) { mListener = listener; } diff --git a/src/dsp/nbfm/FilteringNBFMDemodulator.java b/src/dsp/nbfm/FilteringNBFMDemodulator.java index f9815c08..4d74f08d 100644 --- a/src/dsp/nbfm/FilteringNBFMDemodulator.java +++ b/src/dsp/nbfm/FilteringNBFMDemodulator.java @@ -19,8 +19,8 @@ package dsp.nbfm; import sample.Listener; import sample.complex.ComplexSample; -import sample.simplex.SimplexSampleBroadcaster; -import sample.simplex.SimplexSampleListener; +import sample.real.RealSampleBroadcaster; +import sample.real.RealSampleListener; import dsp.filter.ComplexFIRFilter; import dsp.filter.FilterFactory; import dsp.filter.FloatFIRFilter; @@ -28,7 +28,7 @@ import dsp.filter.Window.WindowType; public class FilteringNBFMDemodulator implements Listener { - private SimplexSampleBroadcaster mBroadcaster = new SimplexSampleBroadcaster(); + private RealSampleBroadcaster mBroadcaster = new RealSampleBroadcaster(); private ComplexFIRFilter mIQFilter; private FloatFIRFilter mAudioFilter; private FMDiscriminator mDiscriminator; @@ -78,7 +78,7 @@ public class FilteringNBFMDemodulator implements Listener /** * Adds a listener to receive demodulated samples */ - public void addListener( SimplexSampleListener listener ) + public void addListener( RealSampleListener listener ) { mBroadcaster.addListener( listener ); } @@ -86,7 +86,7 @@ public class FilteringNBFMDemodulator implements Listener /** * Removes a listener from receiving demodulated samples */ - public void removeListener( SimplexSampleListener listener ) + public void removeListener( RealSampleListener listener ) { mBroadcaster.removeListener( listener ); } diff --git a/src/dsp/nbfm/NBFMDemodulator.java b/src/dsp/nbfm/NBFMDemodulator.java index c763e620..1545c752 100644 --- a/src/dsp/nbfm/NBFMDemodulator.java +++ b/src/dsp/nbfm/NBFMDemodulator.java @@ -19,15 +19,15 @@ package dsp.nbfm; import sample.Listener; import sample.complex.ComplexSample; -import sample.simplex.SimplexSampleBroadcaster; -import sample.simplex.SimplexSampleListener; +import sample.real.RealSampleBroadcaster; +import sample.real.RealSampleListener; import dsp.filter.ComplexFIRFilter; import dsp.filter.FilterFactory; import dsp.filter.Window.WindowType; public class NBFMDemodulator implements Listener { - private SimplexSampleBroadcaster mBroadcaster = new SimplexSampleBroadcaster(); + private RealSampleBroadcaster mBroadcaster = new RealSampleBroadcaster(); private ComplexFIRFilter mIQFilter; private FMDiscriminator mDiscriminator; @@ -78,7 +78,7 @@ public class NBFMDemodulator implements Listener /** * Adds a listener to receive demodulated samples */ - public void addListener( SimplexSampleListener listener ) + public void addListener( RealSampleListener listener ) { mBroadcaster.addListener( listener ); } @@ -86,7 +86,7 @@ public class NBFMDemodulator implements Listener /** * Removes a listener from receiving demodulated samples */ - public void removeListener( SimplexSampleListener listener ) + public void removeListener( RealSampleListener listener ) { mBroadcaster.removeListener( listener ); } diff --git a/src/instrument/gui/DecoderViewFrame.java b/src/instrument/gui/DecoderViewFrame.java index 98cd1575..5311c161 100644 --- a/src/instrument/gui/DecoderViewFrame.java +++ b/src/instrument/gui/DecoderViewFrame.java @@ -77,10 +77,10 @@ public class DecoderViewFrame extends JInternalFrame { mLog.error( "Hey, we're not wired up yet for complex" ); } - else if( source.getSampleType() == SampleType.FLOAT ) + else if( source.getSampleType() == SampleType.REAL ) { FloatWaveSource fws = (FloatWaveSource)mWaveSource; - fws.setListener( mDecoder.getSimplexReceiver() ); + fws.setListener( mDecoder.getRealReceiver() ); } mDecoder.addMessageListener( this ); diff --git a/src/instrument/gui/WaveSourceFrame.java b/src/instrument/gui/WaveSourceFrame.java index 03d9fcfa..61d5c648 100644 --- a/src/instrument/gui/WaveSourceFrame.java +++ b/src/instrument/gui/WaveSourceFrame.java @@ -145,19 +145,19 @@ public class WaveSourceFrame extends JInternalFrame implements PositionListener decoder = new Fleetsync2Decoder( null ); break; case LTR_NET: - decoder = new LTRNetDecoder( SampleType.FLOAT, null, MessageDirection.OSW ); + decoder = new LTRNetDecoder( SampleType.REAL, null, MessageDirection.OSW ); break; case MDC1200: decoder = new MDCDecoder( null ); break; case MPT1327: - decoder = new MPT1327Decoder( SampleType.FLOAT, null, Sync.NORMAL ); + decoder = new MPT1327Decoder( SampleType.REAL, null, Sync.NORMAL ); break; case PASSPORT: - decoder = new PassportDecoder( SampleType.FLOAT, null ); + decoder = new PassportDecoder( SampleType.REAL, null ); break; case P25: - decoder = new P25Decoder( SampleType.FLOAT, null ); + decoder = new P25Decoder( SampleType.REAL, null ); break; } diff --git a/src/instrument/tap/stream/FloatTap.java b/src/instrument/tap/stream/FloatTap.java index 4253c09c..1beebfa5 100644 --- a/src/instrument/tap/stream/FloatTap.java +++ b/src/instrument/tap/stream/FloatTap.java @@ -19,11 +19,11 @@ package instrument.tap.stream; import instrument.tap.TapListener; import instrument.tap.TapType; -import sample.simplex.SimplexSampleListener; +import sample.real.RealSampleListener; -public class FloatTap extends StreamTap implements SimplexSampleListener +public class FloatTap extends StreamTap implements RealSampleListener { - private SimplexSampleListener mListener; + private RealSampleListener mListener; public FloatTap( String name, int delay, @@ -46,12 +46,12 @@ public class FloatTap extends StreamTap implements SimplexSampleListener } } - public void setListener( SimplexSampleListener listener ) + public void setListener( RealSampleListener listener ) { mListener = listener; } - public void removeListener( SimplexSampleListener listener ) + public void removeListener( RealSampleListener listener ) { mListener = null; } diff --git a/src/record/wave/FloatWaveRecorder.java b/src/record/wave/FloatWaveRecorder.java index 1a789f13..67ce74a5 100644 --- a/src/record/wave/FloatWaveRecorder.java +++ b/src/record/wave/FloatWaveRecorder.java @@ -28,14 +28,14 @@ import org.slf4j.LoggerFactory; import record.Recorder; import record.RecorderType; -import sample.simplex.SimplexSampleListener; +import sample.real.RealSampleListener; import util.waveaudio.WaveWriter; import buffer.FloatSampleBufferAssembler; /** * Threaded WAVE audio recorder for recording mono float samples to a wave file */ -public class FloatWaveRecorder extends Recorder implements SimplexSampleListener +public class FloatWaveRecorder extends Recorder implements RealSampleListener { private final static Logger mLog = LoggerFactory.getLogger( FloatWaveRecorder.class ); diff --git a/src/sample/complex/ComplexSample.java b/src/sample/complex/ComplexSample.java index 33e1849e..63898c4f 100644 --- a/src/sample/complex/ComplexSample.java +++ b/src/sample/complex/ComplexSample.java @@ -182,6 +182,21 @@ public class ComplexSample implements Serializable return mRight; } + /** + * Returns the greater absolute value between left and right values + */ + public float maximumAbsolute() + { + if( Math.abs( mLeft ) > Math.abs( mRight ) ) + { + return Math.abs( mLeft ); + } + else + { + return Math.abs( mRight ); + } + } + /** * Creates a new complex sample representing the angle with unit circle * magnitude diff --git a/src/sample/decimator/SimplexDecimator.java b/src/sample/decimator/RealDecimator.java similarity index 90% rename from src/sample/decimator/SimplexDecimator.java rename to src/sample/decimator/RealDecimator.java index 315942dd..3a01249f 100644 --- a/src/sample/decimator/SimplexDecimator.java +++ b/src/sample/decimator/RealDecimator.java @@ -3,7 +3,7 @@ package sample.decimator; import sample.complex.ComplexSampleListener; -public class SimplexDecimator implements ComplexSampleListener +public class RealDecimator implements ComplexSampleListener { private ComplexSampleListener mListener; private int mCounter = 0; @@ -12,7 +12,7 @@ public class SimplexDecimator implements ComplexSampleListener /** * Constructs a new Decimator object with the specified decimation rate. */ - public SimplexDecimator( int rate ) + public RealDecimator( int rate ) { mDecimationRate = rate; } diff --git a/src/sample/simplex/SimplexBuffer.java b/src/sample/real/RealBuffer.java similarity index 74% rename from src/sample/simplex/SimplexBuffer.java rename to src/sample/real/RealBuffer.java index f627b5d6..b4ed8ffb 100644 --- a/src/sample/simplex/SimplexBuffer.java +++ b/src/sample/real/RealBuffer.java @@ -1,15 +1,15 @@ -package sample.simplex; +package sample.real; import java.util.Arrays; -public class SimplexBuffer +public class RealBuffer { private float[] mSamples; /** * Wrapper around float array containing float samples */ - public SimplexBuffer( float[] samples ) + public RealBuffer( float[] samples ) { mSamples = samples; } @@ -17,11 +17,11 @@ public class SimplexBuffer /** * Creates a deep copy of the buffer */ - public SimplexBuffer copyOf() + public RealBuffer copyOf() { float[] copy = Arrays.copyOf( mSamples, mSamples.length ); - return new SimplexBuffer( copy ); + return new RealBuffer( copy ); } /** diff --git a/src/sample/simplex/SimplexSampleBroadcaster.java b/src/sample/real/RealSampleBroadcaster.java similarity index 80% rename from src/sample/simplex/SimplexSampleBroadcaster.java rename to src/sample/real/RealSampleBroadcaster.java index f5734894..5dbbb04e 100644 --- a/src/sample/simplex/SimplexSampleBroadcaster.java +++ b/src/sample/real/RealSampleBroadcaster.java @@ -15,17 +15,17 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see ******************************************************************************/ -package sample.simplex; +package sample.real; import java.util.concurrent.CopyOnWriteArrayList; /** * Broadcasts a received float sample to multiple listeners */ -public class SimplexSampleBroadcaster implements SimplexSampleListener +public class RealSampleBroadcaster implements RealSampleListener { - private CopyOnWriteArrayList mListeners = - new CopyOnWriteArrayList(); + private CopyOnWriteArrayList mListeners = + new CopyOnWriteArrayList(); @Override public void receive( float sample ) @@ -51,12 +51,12 @@ public class SimplexSampleBroadcaster implements SimplexSampleListener return mListeners.size(); } - public void addListener( SimplexSampleListener listener ) + public void addListener( RealSampleListener listener ) { mListeners.add( listener ); } - public void removeListener( SimplexSampleListener listener ) + public void removeListener( RealSampleListener listener ) { mListeners.remove( listener ); } @@ -68,7 +68,7 @@ public class SimplexSampleBroadcaster implements SimplexSampleListener public void broadcast( float sample ) { - for( SimplexSampleListener listener: mListeners ) + for( RealSampleListener listener: mListeners ) { listener.receive( sample ); } diff --git a/src/sample/real/RealSampleListener.java b/src/sample/real/RealSampleListener.java new file mode 100644 index 00000000..de32950d --- /dev/null +++ b/src/sample/real/RealSampleListener.java @@ -0,0 +1,6 @@ +package sample.real; + +public interface RealSampleListener +{ + public void receive( float sample ); +} diff --git a/src/sample/real/RealSampleProvider.java b/src/sample/real/RealSampleProvider.java new file mode 100644 index 00000000..3adcface --- /dev/null +++ b/src/sample/real/RealSampleProvider.java @@ -0,0 +1,8 @@ +package sample.real; + +public interface RealSampleProvider +{ + public void setListener( RealSampleListener listener ); + + public void removeListener( RealSampleListener listener ); +} diff --git a/src/sample/simplex/SimplexSampleListener.java b/src/sample/simplex/SimplexSampleListener.java deleted file mode 100644 index bd63cf26..00000000 --- a/src/sample/simplex/SimplexSampleListener.java +++ /dev/null @@ -1,6 +0,0 @@ -package sample.simplex; - -public interface SimplexSampleListener -{ - public void receive( float sample ); -} diff --git a/src/sample/simplex/SimplexSampleProvider.java b/src/sample/simplex/SimplexSampleProvider.java deleted file mode 100644 index 73c29710..00000000 --- a/src/sample/simplex/SimplexSampleProvider.java +++ /dev/null @@ -1,8 +0,0 @@ -package sample.simplex; - -public interface SimplexSampleProvider -{ - public void setListener( SimplexSampleListener listener ); - - public void removeListener( SimplexSampleListener listener ); -} diff --git a/src/source/FloatSource.java b/src/source/FloatSource.java index 6e7d849b..a4d297a9 100644 --- a/src/source/FloatSource.java +++ b/src/source/FloatSource.java @@ -6,6 +6,6 @@ public abstract class FloatSource extends Source implements Provider { public FloatSource( String name ) { - super( name, SampleType.FLOAT ); + super( name, SampleType.REAL ); } } diff --git a/src/source/RealSource.java b/src/source/RealSource.java new file mode 100644 index 00000000..352ff26f --- /dev/null +++ b/src/source/RealSource.java @@ -0,0 +1,13 @@ +package source; + +import sample.Provider; +import sample.real.RealBuffer; + + +public abstract class RealSource extends Source implements Provider +{ + public RealSource( String name ) + { + super( name, SampleType.REAL ); + } +} diff --git a/src/source/SimplexSource.java b/src/source/SimplexSource.java deleted file mode 100644 index 2c5ce78c..00000000 --- a/src/source/SimplexSource.java +++ /dev/null @@ -1,13 +0,0 @@ -package source; - -import sample.Provider; -import sample.simplex.SimplexBuffer; - - -public abstract class SimplexSource extends Source implements Provider -{ - public SimplexSource( String name ) - { - super( name, SampleType.FLOAT ); - } -} diff --git a/src/source/Source.java b/src/source/Source.java index 8f53a979..506955d0 100644 --- a/src/source/Source.java +++ b/src/source/Source.java @@ -25,7 +25,7 @@ public abstract class Source protected String mName; protected SampleType mSampleType; - public enum SampleType { COMPLEX, FLOAT } + public enum SampleType { COMPLEX, REAL } public Source( String name, SampleType sampleType ) { diff --git a/src/source/mixer/MixerManager.java b/src/source/mixer/MixerManager.java index cc44fe61..d233776d 100644 --- a/src/source/mixer/MixerManager.java +++ b/src/source/mixer/MixerManager.java @@ -82,9 +82,9 @@ public class MixerManager return sInstance; } - public SimplexMixerSource getSource( ProcessingChain processingChain ) + public RealMixerSource getSource( ProcessingChain processingChain ) { - SimplexMixerSource retVal = null; + RealMixerSource retVal = null; SourceConfiguration config = processingChain.getChannel().getSourceConfiguration(); @@ -120,7 +120,7 @@ public class MixerManager if( dataLine != null ) { - return new SimplexMixerSource( dataLine, + return new RealMixerSource( dataLine, MONO, mixerName, new ShortAdapter() ); @@ -148,7 +148,7 @@ public class MixerManager if( dataLine != null ) { - return new SimplexMixerSource( dataLine, STEREO, + return new RealMixerSource( dataLine, STEREO, mixerName, new ChannelShortAdapter( mixerConfig.getChannel() ) ); } diff --git a/src/source/mixer/SimplexMixerSource.java b/src/source/mixer/RealMixerSource.java similarity index 89% rename from src/source/mixer/SimplexMixerSource.java rename to src/source/mixer/RealMixerSource.java index ae2ca924..a560108d 100644 --- a/src/source/mixer/SimplexMixerSource.java +++ b/src/source/mixer/RealMixerSource.java @@ -31,14 +31,14 @@ import org.slf4j.LoggerFactory; import sample.Listener; import sample.adapter.SampleAdapter; -import sample.simplex.SimplexBuffer; -import source.SimplexSource; +import sample.real.RealBuffer; +import source.RealSource; import source.SourceException; -public class SimplexMixerSource extends SimplexSource +public class RealMixerSource extends RealSource { private final static Logger mLog = - LoggerFactory.getLogger( SimplexMixerSource.class ); + LoggerFactory.getLogger( RealMixerSource.class ); private long mFrequency = 0; private int mBufferSize = 16384; @@ -50,13 +50,13 @@ public class SimplexMixerSource extends SimplexSource private int mBytesPerFrame = 0; private SampleAdapter mSampleAdapter; - CopyOnWriteArrayList> mSampleListeners = - new CopyOnWriteArrayList>(); + CopyOnWriteArrayList> mSampleListeners = + new CopyOnWriteArrayList>(); /** - * Simplex 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 ) - * and broadcasts simplex 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. * * @param targetDataLine - mixer or sound card to be used @@ -69,7 +69,7 @@ public class SimplexMixerSource extends SimplexSource * mixer into float array data. Can optionally invert the channel data if * the left/right stereo channels are inverted. */ - public SimplexMixerSource( TargetDataLine targetDataLine, + public RealMixerSource( TargetDataLine targetDataLine, AudioFormat format, String name, SampleAdapter sampleAdapter ) @@ -81,7 +81,7 @@ public class SimplexMixerSource extends SimplexSource mSampleAdapter = sampleAdapter; } - public void setListener( Listener listener ) + public void setListener( Listener listener ) { mSampleListeners.add( listener ); @@ -95,7 +95,7 @@ public class SimplexMixerSource extends SimplexSource } } - public void removeListener( Listener listener ) + public void removeListener( Listener listener ) { mSampleListeners.remove( listener ); @@ -106,13 +106,13 @@ public class SimplexMixerSource extends SimplexSource } } - public void broadcast( SimplexBuffer samples ) + public void broadcast( RealBuffer samples ) { - Iterator> it = mSampleListeners.iterator(); + Iterator> it = mSampleListeners.iterator(); while( it.hasNext() ) { - Listener next = it.next(); + Listener next = it.next(); /* if this is the last (or only) listener, send him the original * buffer, otherwise send him a copy of the buffer */ @@ -226,7 +226,7 @@ public class SimplexMixerSource extends SimplexSource mSampleAdapter.convert( buffer ); /* Dispatch samples to registered listeners */ - broadcast( new SimplexBuffer( samples ) ); + broadcast( new RealBuffer( samples ) ); } catch ( Exception e ) { diff --git a/src/source/tuner/hackrf/HackRFTunerController.java b/src/source/tuner/hackrf/HackRFTunerController.java index f38051a8..045f7d65 100644 --- a/src/source/tuner/hackrf/HackRFTunerController.java +++ b/src/source/tuner/hackrf/HackRFTunerController.java @@ -491,8 +491,6 @@ public class HackRFTunerController extends TunerController */ public void setSampleRate( HackRFSampleRate rate ) throws UsbException { - mLog.debug( "Setting sample rate to:" + rate.name() ); - setSampleRateManual( rate.getRate(), 1 ); mFrequencyController.setSampleRate( rate.getRate() ); diff --git a/src/source/wave/FloatWaveSource.java b/src/source/wave/FloatWaveSource.java index 471f8e2d..8174d122 100644 --- a/src/source/wave/FloatWaveSource.java +++ b/src/source/wave/FloatWaveSource.java @@ -29,7 +29,7 @@ import javax.sound.sampled.AudioInputStream; import javax.sound.sampled.AudioSystem; import javax.sound.sampled.UnsupportedAudioFileException; -import sample.simplex.SimplexSampleListener; +import sample.real.RealSampleListener; public class FloatWaveSource extends WaveSource { @@ -44,7 +44,7 @@ public class FloatWaveSource extends WaveSource private int mBufferPointer = 0; private int mBufferLength; private ShortBuffer mBufferWrapper; - private SimplexSampleListener mListener; + private RealSampleListener mListener; private static int BUFFER_SAMPLE_SIZE = 2000; @@ -70,7 +70,7 @@ public class FloatWaveSource extends WaveSource */ public FloatWaveSource( File file, boolean loop ) throws IOException { - super( file, SampleType.FLOAT ); + super( file, SampleType.REAL ); mLoop = loop; } @@ -272,12 +272,12 @@ public class FloatWaveSource extends WaveSource /** * Adds a new listener to receive samples as they are read from the wave file */ - public void setListener( SimplexSampleListener listener ) + public void setListener( RealSampleListener listener ) { mListener = listener; } - public void removeListener( SimplexSampleListener listener ) + public void removeListener( RealSampleListener listener ) { mListener = null; } diff --git a/src/spectrum/ChannelSpectrumPanel.java b/src/spectrum/ChannelSpectrumPanel.java index cca89602..7fd4837b 100644 --- a/src/spectrum/ChannelSpectrumPanel.java +++ b/src/spectrum/ChannelSpectrumPanel.java @@ -18,7 +18,7 @@ import javax.swing.SwingUtilities; import net.miginfocom.swing.MigLayout; import sample.Listener; import sample.complex.ComplexBuffer; -import sample.simplex.SimplexSampleListener; +import sample.real.RealSampleListener; import settings.ColorSetting.ColorSettingName; import settings.ColorSettingMenuItem; import settings.Setting; @@ -45,7 +45,7 @@ import dsp.filter.Window.WindowType; public class ChannelSpectrumPanel extends JPanel implements ChannelEventListener, - SimplexSampleListener, + RealSampleListener, SettingChangeListener, SpectralDisplayAdjuster { @@ -54,7 +54,7 @@ public class ChannelSpectrumPanel extends JPanel "channel_spectrum_averaging_size"; private ResourceManager mResourceManager; - private DFTProcessor mDFTProcessor = new DFTProcessor( SampleType.FLOAT ); + private DFTProcessor mDFTProcessor = new DFTProcessor( SampleType.REAL ); private DFTResultsConverter mDFTConverter = new RealDecibelConverter(); private JLayeredPane mLayeredPane; private SpectrumPanel mSpectrumPanel; @@ -206,7 +206,7 @@ public class ChannelSpectrumPanel extends JPanel { if( mEnabled.get() && mCurrentChannel != null && mCurrentChannel.isProcessing() ) { - mCurrentChannel.getProcessingChain().addSimplexListener( (SimplexSampleListener)this ); + mCurrentChannel.getProcessingChain().addRealListener( (RealSampleListener)this ); mDFTProcessor.start(); } } @@ -216,7 +216,7 @@ public class ChannelSpectrumPanel extends JPanel if( mCurrentChannel != null && mCurrentChannel.isProcessing() ) { - mCurrentChannel.getProcessingChain().removeSimplexListener( (SimplexSampleListener)this ); + mCurrentChannel.getProcessingChain().removeRealListener( (RealSampleListener)this ); } mDFTProcessor.stop(); @@ -491,7 +491,7 @@ public class ChannelSpectrumPanel extends JPanel } } - public class SampleAssembler implements SimplexSampleListener + public class SampleAssembler implements RealSampleListener { private Listener mListener; diff --git a/src/spectrum/DFTProcessor.java b/src/spectrum/DFTProcessor.java index 58d32f52..98a9bd55 100644 --- a/src/spectrum/DFTProcessor.java +++ b/src/spectrum/DFTProcessor.java @@ -327,7 +327,7 @@ public class DFTProcessor implements Listener, Window.apply( mWindow, samples ); - if( mSampleType == SampleType.FLOAT ) + if( mSampleType == SampleType.REAL ) { mFFT.realForward( samples ); }