WIP - correctly implements the 2x oversampled polyphase channelizer.

This commit is contained in:
Denny
2017-04-14 06:41:43 -04:00
parent f7cd798f07
commit ac686f5f64
9 changed files with 360 additions and 489 deletions

View File

@@ -1,19 +1,20 @@
/******************************************************************************* /*******************************************************************************
* SDR Trunk * sdrtrunk
* Copyright (C) 2014 Dennis Sheirer * Copyright (C) 2014-2017 Dennis Sheirer
* *
* This program is free software: you can redistribute it and/or modify * 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 * it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or * the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * 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/>
* *
* 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 buffer; package buffer;
@@ -21,98 +22,105 @@ import java.util.Arrays;
/** /**
* Circular sample buffer - allocates a buffer and stores samples in a circular * Circular sample buffer - allocates a buffer and stores samples in a circular
* fashion, overwriting older samples with newly arrived samples. Initially * fashion, overwriting older samples with newly arrived samples.
* fills buffer with 0-valued samples
* *
* Can be used as a delay-type buffer, to delay samples by the 'size' amount * Can be used as a delay-type buffer, to delay samples by the 'size' amount
* @author denny
*
*/ */
public class FloatCircularBuffer public class FloatCircularBuffer
{ {
float[] mBuffer; float[] mBuffer;
int mBufferPointer = 0; int mBufferPointer = 0;
public FloatCircularBuffer( int size ) public FloatCircularBuffer(int size)
{ {
mBuffer = new float[ size ]; mBuffer = new float[size];
}
Arrays.fill( mBuffer, (float)0.0 ); public int getSize()
} {
return mBuffer.length;
}
public int getSize() public float[] getBuffer()
{ {
return mBuffer.length; return mBuffer;
} }
public float[] getBuffer() /**
{ * Puts the new value into the buffer and returns the oldest buffer value
return mBuffer; * that it replaced
} *
* @param newValue
* @return
*/
public float putAndGet(float newValue)
{
float oldestSample = mBuffer[mBufferPointer];
/** put(newValue);
* Puts the new value into the buffer and returns the oldest buffer value
* that it replaced
* @param newValue
* @return
*/
public float get( float newValue )
{
float oldestSample = mBuffer[ mBufferPointer ];
mBuffer[ mBufferPointer ] = newValue; return oldestSample;
}
mBufferPointer++; /**
* Adds the new value to this buffer.
*/
public void put(float newValue)
{
mBuffer[mBufferPointer] = newValue;
if( mBufferPointer >= mBuffer.length ) mBufferPointer++;
{
mBufferPointer = 0;
}
return oldestSample; if(mBufferPointer >= mBuffer.length)
} {
mBufferPointer = 0;
}
}
/** /**
* Convenience method to put a new value in the buffer, while discarding * Returns the sample at the specified index, where index 0 is the oldest sample and index (length - 1) is the
* the old value * newest sample.
*/ * @param index in range of 0 to length-1
public void put( float newValue ) * @return value at indexed position
{ */
get( newValue );
}
/** public float get(int index)
* Returns an array of arraySize, loaded with sampleCount of the {
* oldest samples, loaded into the array starting at index 0. if(index < mBuffer.length)
* {
* This is useful for fetching an array filled half way with samples to int pointer = mBufferPointer + index;
* use in FFT processing.
* @param arraySize - size of the array (must be larger than sampleCount)
* @param sampleCount - number of the oldest samples in the buffer to load
* @return
*/
public float[] get( int arraySize, int sampleCount )
{
float[] samples = new float[ arraySize ];
if( arraySize > sampleCount ) if(pointer >= mBuffer.length)
{ {
int tempCounter = mBufferPointer; pointer -= mBuffer.length;
}
for( int x = 0; x < sampleCount; x++ ) return mBuffer[pointer];
{ }
samples[ x ] = mBuffer[ tempCounter ]; else
{
throw new ArrayIndexOutOfBoundsException("Index [" + index + "] is not valid for the buffer size of [" +
mBuffer.length + "]");
}
}
tempCounter++; /**
* Returns the contents of the circular buffer unwrapped where index 0 is the oldest sample and index length-1
* is the newest sample.
*
* @return array of samples
*/
public float[] get()
{
float[] samples = new float[mBuffer.length];
if( tempCounter > mBuffer.length ) System.arraycopy(mBuffer, mBufferPointer, samples, 0, mBuffer.length - mBufferPointer);
{
tempCounter = 0;
}
}
}
return samples; if(mBufferPointer != 0)
} {
System.arraycopy(mBuffer, 0, samples, mBuffer.length - mBufferPointer, mBufferPointer);
}
return samples;
}
} }

View File

@@ -0,0 +1,89 @@
/*******************************************************************************
* 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 buffer;
/**
* Circular sample buffer - allocates a buffer and stores samples in a circular
* fashion, overwriting older samples with newly arrived samples.
*/
public class ReverseFloatCircularBuffer
{
private float[] mBuffer;
private int mBufferPointer = 0;
public ReverseFloatCircularBuffer(int size)
{
mBuffer = new float[size];
mBufferPointer = mBuffer.length - 1;
}
/**
* Size of the buffer
* @return
*/
public int getSize()
{
return mBuffer.length;
}
public float[] getBuffer()
{
return mBuffer;
}
/**
* Adds the new value to this buffer.
*/
public void put(float newValue)
{
mBuffer[mBufferPointer--] = newValue;
if(mBufferPointer < 0)
{
mBufferPointer = mBuffer.length - 1;
}
}
/**
* Returns the sample at the specified index, where index 0 is the newest sample and index (length - 1) is the
* oldest sample.
* @param index in range of 0 to length-1
* @return value at indexed position
*/
public float get(int index)
{
if(index < mBuffer.length)
{
int pointer = mBufferPointer + 1 + index;
if(pointer >= mBuffer.length)
{
pointer -= mBuffer.length;
}
return mBuffer[pointer];
}
else
{
throw new ArrayIndexOutOfBoundsException("Index [" + index + "] is not valid for the buffer size of [" +
mBuffer.length + "]");
}
}
}

View File

@@ -20,6 +20,7 @@ package dsp.filter.channelizer;
import dsp.filter.FilterFactory; import dsp.filter.FilterFactory;
import dsp.filter.Window; import dsp.filter.Window;
import dsp.filter.correction.IQCorrectionFilter;
import dsp.filter.design.FilterDesignException; import dsp.filter.design.FilterDesignException;
import dsp.mixer.LowPhaseNoiseOscillator; import dsp.mixer.LowPhaseNoiseOscillator;
import net.miginfocom.swing.MigLayout; import net.miginfocom.swing.MigLayout;
@@ -59,6 +60,7 @@ public class ChannelizerViewer extends JFrame
private LowPhaseNoiseOscillator mOscillator; private LowPhaseNoiseOscillator mOscillator;
private int mChannelCount; private int mChannelCount;
private int mChannelsPerRow; private int mChannelsPerRow;
private int mFilterTapsPerChannel;
private int mSampleRate; private int mSampleRate;
private int mToneFrequency; private int mToneFrequency;
private DFTSize mMainPanelDFTSize = DFTSize.FFT32768; private DFTSize mMainPanelDFTSize = DFTSize.FFT32768;
@@ -70,10 +72,12 @@ public class ChannelizerViewer extends JFrame
* @param channelCount * @param channelCount
* @param channelsPerRow * @param channelsPerRow
*/ */
public ChannelizerViewer(int channelCount, int channelsPerRow) public ChannelizerViewer(int channelCount, int channelsPerRow, int tapsPerChannel)
{ {
mChannelCount = channelCount; mChannelCount = channelCount;
mChannelsPerRow = channelsPerRow; mChannelsPerRow = channelsPerRow;
mFilterTapsPerChannel = tapsPerChannel;
mSampleRate = mChannelCount * CHANNEL_BANDWIDTH; mSampleRate = mChannelCount * CHANNEL_BANDWIDTH;
mToneFrequency = (int)(CHANNEL_BANDWIDTH * 1); //Set to channel 1 as default mToneFrequency = (int)(CHANNEL_BANDWIDTH * 1); //Set to channel 1 as default
@@ -202,13 +206,13 @@ public class ChannelizerViewer extends JFrame
private float[] getFilter() throws FilterDesignException private float[] getFilter() throws FilterDesignException
{ {
return FilterFactory.getSincChannelizer(CHANNEL_BANDWIDTH, mChannelCount, 19, return FilterFactory.getSincChannelizer(CHANNEL_BANDWIDTH, mChannelCount, mFilterTapsPerChannel,
Window.WindowType.BLACKMAN_HARRIS_7, true); Window.WindowType.BLACKMAN_HARRIS_7, true);
} }
public class ChannelArrayPanel extends JPanel implements Listener<ComplexBuffer> public class ChannelArrayPanel extends JPanel implements Listener<ComplexBuffer>
{ {
private ComplexPolyphaseChannelizer3 mPolyphaseChannelizer; private ComplexPolyphaseChannelizerM2 mPolyphaseChannelizer;
private ChannelDistributor mChannelDistributor; private ChannelDistributor mChannelDistributor;
public ChannelArrayPanel(float[] taps) public ChannelArrayPanel(float[] taps)
@@ -219,7 +223,7 @@ public class ChannelizerViewer extends JFrame
bufferSize++; bufferSize++;
} }
mPolyphaseChannelizer = new ComplexPolyphaseChannelizer3(taps, mChannelCount); mPolyphaseChannelizer = new ComplexPolyphaseChannelizerM2(taps, mChannelCount);
mChannelDistributor = new ChannelDistributor(bufferSize, mChannelCount); mChannelDistributor = new ChannelDistributor(bufferSize, mChannelCount);
mPolyphaseChannelizer.setChannelDistributor(mChannelDistributor); mPolyphaseChannelizer.setChannelDistributor(mChannelDistributor);
@@ -298,8 +302,9 @@ public class ChannelizerViewer extends JFrame
{ {
int channelCount = 4; int channelCount = 4;
int channelsPerRow = 4; int channelsPerRow = 4;
int tapsPerChannel = 17;
final ChannelizerViewer frame = new ChannelizerViewer(channelCount, channelsPerRow); final ChannelizerViewer frame = new ChannelizerViewer(channelCount, channelsPerRow, tapsPerChannel);
EventQueue.invokeLater(new Runnable() EventQueue.invokeLater(new Runnable()
{ {

View File

@@ -38,32 +38,23 @@ public class ComplexPolyphaseChannelizer implements Listener<ComplexBuffer>
private RealFIRFilter[] mQuadratureFilters; private RealFIRFilter[] mQuadratureFilters;
private int mFilterPointer = 0; private int mFilterPointer = 0;
private int mChannelCount; private int mChannelCount;
private int mBlockSize;
private float[] mFilteredSamples; private float[] mFilteredSamples;
private FloatFFT_1D mFFT; private FloatFFT_1D mFFT;
private ChannelDistributor mChannelDistributor; private ChannelDistributor mChannelDistributor;
private DecimalFormat DECIMAL_FORMAT = new DecimalFormat("0.0000");
/** /**
* Creates a polyphase filter bank that divides the input frequency band into evenly spaced channels that * Maximally Decimated Polyphase Filter Bank (MDPFB) channelizer that divides the input frequency band into
* are oversampled by 2x for output. * equal bandwidth channels.
* *
* @param taps of a low-pass filter designed for the inbound sample rate with a cutoff frequency * @param taps of a low-pass filter designed for the inbound sample rate with a cutoff frequency
* equal to the channel bandwidth (sample rate / filters). If you need to synthesize (combine two or more * equal to the channel bandwidth (sample rate / filters). If you need to synthesize (combine two or more
* filte outputs) a new bandwidth signal from the outputs of this filter, then the filter should be designed * filte outputs) a new bandwidth signal from the outputs of this filter, then the filter should be designed
* as a nyquist filter with -6 dB attenuation at the channel bandwidth cutoff frequency * as a nyquist filter with -6 dB attenuation at the channel bandwidth cutoff frequency
* *
* @param channels - number of filters/channels to output. Since this filter bank oversamples each filter * @param channels - number of channels to output.
* output, this number must be even (divisible by the oversample rate).
*/ */
public ComplexPolyphaseChannelizer(float[] taps, int channels, int oversample) public ComplexPolyphaseChannelizer(float[] taps, int channels)
{ {
if(oversample > 1 && channels % 2 != 0)
{
throw new IllegalArgumentException("Channel count must be a multiple of 2 when oversampling");
}
mChannelCount = channels; mChannelCount = channels;
initFilters(taps); initFilters(taps);
@@ -187,7 +178,7 @@ public class ComplexPolyphaseChannelizer implements Listener<ComplexBuffer>
mLog.debug(sb.toString()); mLog.debug(sb.toString());
ComplexPolyphaseChannelizer channelizer = new ComplexPolyphaseChannelizer(taps, 8, 1); ComplexPolyphaseChannelizer channelizer = new ComplexPolyphaseChannelizer(taps, 8);
Oscillator oscillator = new Oscillator(channelCenter, 2 * sampleRate); Oscillator oscillator = new Oscillator(channelCenter, 2 * sampleRate);

View File

@@ -1,306 +0,0 @@
/*******************************************************************************
* 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 dsp.filter.channelizer;
import dsp.filter.FilterFactory;
import dsp.filter.Window;
import dsp.filter.design.FilterDesignException;
import dsp.mixer.Oscillator;
import org.jtransforms.fft.FloatFFT_1D;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import sample.Listener;
import sample.complex.ComplexBuffer;
import java.text.DecimalFormat;
import java.util.Arrays;
public class ComplexPolyphaseChannelizer2 implements Listener<ComplexBuffer>
{
private final static Logger mLog = LoggerFactory.getLogger(ComplexPolyphaseChannelizer2.class);
private float[][] mFilterCoefficients;
private float[][] mIBuffer;
private float[][] mQBuffer;
private int mBufferRowPointer = 0;
private int mBufferColumnPointer = 0;
private int[][] mIndexMap;
private int mStrideLength;
private int mStrideCount;
private int mChannelCount;
private float[] mFilteredSamples;
private FloatFFT_1D mFFT;
private ChannelDistributor mChannelDistributor;
private DecimalFormat DECIMAL_FORMAT = new DecimalFormat("0.0000");
/**
* Creates a polyphase filter bank that divides the input frequency band into evenly spaced channels that
* are oversampled by 2x for output.
*
* @param taps of a low-pass filter designed for the inbound sample rate with a cutoff frequency
* equal to the channel bandwidth (sample rate / filters). If you need to synthesize (combine two or more
* filte outputs) a new bandwidth signal from the outputs of this filter, then the filter should be designed
* as a nyquist filter with -6 dB attenuation at the channel bandwidth cutoff frequency
*
* @param channels - number of filters/channels to output. Since this filter bank oversamples each filter
* output, this number must be even (divisible by the oversample rate).
*/
public ComplexPolyphaseChannelizer2(float[] taps, int channels)
{
if(channels % 2 != 0)
{
throw new IllegalArgumentException("Channel count must be a multiple of 2");
}
mChannelCount = channels;
initFilters(taps);
}
public void filter(float inphase, float quadrature)
{
mIBuffer[mBufferRowPointer][mBufferColumnPointer] = inphase;
mQBuffer[mBufferRowPointer][mBufferColumnPointer] = quadrature;
mBufferRowPointer--;
mStrideCount++;
if(mStrideCount >= mStrideLength)
{
dispatch();
mStrideCount = 0;
}
//Adjust the circular buffer pointers, wrapping as necessary
if(mBufferRowPointer < 0)
{
mBufferRowPointer += mChannelCount;
mBufferColumnPointer--;
if(mBufferColumnPointer < 0)
{
mBufferColumnPointer += mIBuffer[mBufferRowPointer].length;
}
}
}
@Override
public void receive(ComplexBuffer complexBuffer)
{
float[] samples = complexBuffer.getSamples();
for(int x = 0; x < samples.length; x += 2)
{
filter(samples[x], samples[x + 1]);
}
}
private void dispatch()
{
float[] samples = calculate();
//FFT is executed in-place where the output overwrites the input
mFFT.complexForward(samples);
dispatch(samples);
}
/**
* Calculates the value of the current data row and the current filter coefficient set and assigns the value to the
* current filtered samples array
*/
private float[] calculate()
{
float[] samples = new float[mChannelCount * 2];
try
{
for(int x = 0; x < mChannelCount; x++)
{
float iAccumulator = 0.0f;
float qAccumulator = 0.0f;
int coefficientIndex;
if(mBufferRowPointer <= 0)
{
coefficientIndex = x;
}
else if(x < mChannelCount / 2)
{
coefficientIndex = x + mChannelCount / 2;
}
else
{
coefficientIndex = x - mChannelCount / 2;
}
float[] coefficients = mFilterCoefficients[coefficientIndex];
float[] iSamples = mIBuffer[x];
float[] qSamples = mQBuffer[x];
for( int y = 0; y < coefficients.length; y++ )
{
int column = mIndexMap[mBufferColumnPointer][y];
iAccumulator += coefficients[y] * iSamples[column];
qAccumulator += coefficients[y] * qSamples[column];
}
samples[coefficientIndex * 2] = iAccumulator;
samples[coefficientIndex * 2 + 1] = qAccumulator;
}
}
catch(Exception e)
{
mLog.error("Error", e);
}
return samples;
}
/**
* Dispatches the filtered, de-spun samples as an array of channel I/Q sample pairs
* @param channels arranged as: channel0i, channel0q, channel1i, channel1q ... channelN-1i, channelN-1q
*/
private void dispatch(float[] channels)
{
if(mChannelDistributor != null)
{
mChannelDistributor.receive(channels);
}
}
public void setChannelDistributor(ChannelDistributor channelDistributor)
{
mChannelDistributor = channelDistributor;
}
private double magnitude(float real, float imaginary, int fftSize)
{
return Math.sqrt(Math.pow(real, 2.0) + Math.pow(imaginary, 2.0));
}
/**
* Distributes the filter taps to each of the polyphase filters
*
* @param taps
*/
private void initFilters(float[] taps)
{
int tapCount = (int)Math.ceil((double)taps.length / (double)mChannelCount);
mIBuffer = new float[mChannelCount][tapCount];
mQBuffer = new float[mChannelCount][tapCount];
mFilterCoefficients = new float[mChannelCount][tapCount];
for(int tap = 0; tap < tapCount; tap++)
{
for(int filter = 0; filter < mChannelCount; filter++)
{
int index = tap * mChannelCount + filter;
if(index < taps.length)
{
mFilterCoefficients[filter][tap] = taps[index];
}
}
}
generateIndexMap(tapCount);
mFilteredSamples = new float[mChannelCount * 2];
mFFT = new FloatFFT_1D(mChannelCount);
mStrideLength = mChannelCount / 2; //channel count * 2 / 2
mStrideCount = 0;
mBufferRowPointer = mChannelCount / 2 - 1; //Start filling data half way into buffer
mBufferColumnPointer = tapCount - 1;
}
/**
* Generates a circular buffer index map to support lookup of the translated
* index based on the current buffer pointer and the desired sample index.
*/
private void generateIndexMap( int size )
{
mIndexMap = new int[ size ][ size ];
for( int x = 0; x < size; x++ )
{
for( int y = 0; y < size; y++ )
{
int z = x + y;
mIndexMap[ x ][ y ] = z < size ? z : z - size;
}
}
}
public static void main(String[] args)
{
mLog.debug("Starting ...");
int channelBandwidth = 12500;
int channels = 4;
int tapsPerChannel = 15;
float[] taps = null;
try
{
taps = FilterFactory.getSincChannelizer( channelBandwidth, channels, tapsPerChannel,
Window.WindowType.BLACKMAN_HARRIS_7, true);
}
catch(FilterDesignException fde)
{
mLog.error("Error in filter design", fde);
}
int channelCenter = (int)(channelBandwidth * 1.5);
StringBuilder sb = new StringBuilder();
sb.append("\nPolyphase Channelizer\n");
sb.append("Sample Rate:" + (channelBandwidth * channels) + "\n");
sb.append("Channels:" + channels + "\n");
sb.append("Channel Rate:" + channelBandwidth + "\n");
sb.append("Tap Count:" + taps.length + "\n");
sb.append("Channel:" + channelCenter + "\n");
mLog.debug(sb.toString());
ComplexPolyphaseChannelizer2 channelizer = new ComplexPolyphaseChannelizer2(taps, channels);
Oscillator oscillator = new Oscillator(channelCenter, 2 * (channelBandwidth * channels));
for(int x = 0; x < 2000; x++)
{
channelizer.filter(oscillator.getComplex().inphase(), oscillator.getComplex().quadrature());
oscillator.rotate();
}
mLog.debug("Finished!");
}
}

View File

@@ -18,9 +18,9 @@
******************************************************************************/ ******************************************************************************/
package dsp.filter.channelizer; package dsp.filter.channelizer;
import buffer.ReverseFloatCircularBuffer;
import dsp.filter.FilterFactory; import dsp.filter.FilterFactory;
import dsp.filter.Window; import dsp.filter.Window;
import dsp.filter.fir.real.RealFIRFilter;
import dsp.mixer.Oscillator; import dsp.mixer.Oscillator;
import org.jtransforms.fft.FloatFFT_1D; import org.jtransforms.fft.FloatFFT_1D;
import org.slf4j.Logger; import org.slf4j.Logger;
@@ -30,27 +30,22 @@ import sample.complex.ComplexBuffer;
import java.text.DecimalFormat; import java.text.DecimalFormat;
public class ComplexPolyphaseChannelizer3 implements Listener<ComplexBuffer> public class ComplexPolyphaseChannelizerM2 implements Listener<ComplexBuffer>
{ {
private final static Logger mLog = LoggerFactory.getLogger(ComplexPolyphaseChannelizer3.class); private final static Logger mLog = LoggerFactory.getLogger(ComplexPolyphaseChannelizerM2.class);
private RealFIRFilter[] mInphaseFilters; private ReverseFloatCircularBuffer[] mDataBuffers;
private RealFIRFilter[] mQuadratureFilters; private float[][] mFilterCoefficients;
private int mInputPointer = 0; private int mFilterPointer = 0;
private int mChannelCount; private int mChannelCount;
private int mBlockSize;
private float[] mInputISamples;
private float[] mInputQSamples;
private float[] mOutputSamples;
private FloatFFT_1D mFFT; private FloatFFT_1D mFFT;
private ChannelDistributor mChannelDistributor; private ChannelDistributor mChannelDistributor;
private boolean mFlipFlop = false;
private DecimalFormat DECIMAL_FORMAT = new DecimalFormat("0.0000"); private DecimalFormat DECIMAL_FORMAT = new DecimalFormat("0.0000");
/** /**
* Creates a polyphase filter bank that divides the input frequency band into evenly spaced channels that * Non-Maximally Decimated Polyphase Filter Bank (NMDPFB) channelizer that divides the input frequency band into
* are oversampled by 2x for output. * equal bandwidth channels that are each oversampled by 2x for output.
* *
* @param taps of a low-pass filter designed for the inbound sample rate with a cutoff frequency * @param taps of a low-pass filter designed for the inbound sample rate with a cutoff frequency
* equal to the channel bandwidth (sample rate / filters). If you need to synthesize (combine two or more * equal to the channel bandwidth (sample rate / filters). If you need to synthesize (combine two or more
@@ -60,7 +55,7 @@ public class ComplexPolyphaseChannelizer3 implements Listener<ComplexBuffer>
* @param channels - number of filters/channels to output. Since this filter bank oversamples each filter * @param channels - number of filters/channels to output. Since this filter bank oversamples each filter
* output, this number must be even (divisible by the oversample rate). * output, this number must be even (divisible by the oversample rate).
*/ */
public ComplexPolyphaseChannelizer3(float[] taps, int channels) public ComplexPolyphaseChannelizerM2(float[] taps, int channels)
{ {
if(channels % 2 != 0) if(channels % 2 != 0)
{ {
@@ -74,17 +69,26 @@ public class ComplexPolyphaseChannelizer3 implements Listener<ComplexBuffer>
public void filter(float inphase, float quadrature) public void filter(float inphase, float quadrature)
{ {
mInputISamples[mInputPointer] = inphase; try
mInputQSamples[mInputPointer] = quadrature; {
mDataBuffers[mFilterPointer--].put(quadrature);
mDataBuffers[mFilterPointer].put(inphase);
if(mInputPointer == 0) if(mFilterPointer == 0)
{ {
calculate(); calculate();
mInputPointer = mChannelCount / 2 - 1; mFilterPointer = mChannelCount * 2;
}
else if(mFilterPointer == mChannelCount)
{
calculate();
}
mFilterPointer--;
} }
else catch(Exception e)
{ {
mInputPointer--; mLog.error("Error!", e);
} }
} }
@@ -101,39 +105,73 @@ public class ComplexPolyphaseChannelizer3 implements Listener<ComplexBuffer>
private void calculate() private void calculate()
{ {
float[] filteredSamples = new float[mChannelCount * 2]; float[] samples = new float[mChannelCount * 2];
for(int x = 0; x < mChannelCount; x++) if(mFilterPointer == 0)
{ {
int index = x * 2; for(int x = 0; x < mFilterCoefficients.length; x++)
{
int index = x * 2;
filteredSamples[index] = mInphaseFilters[x].filter(mInputISamples[x]); //Inphase sample
filteredSamples[index + 1] = mQuadratureFilters[x].filter(mInputQSamples[x]); samples[index] = convolve(mFilterCoefficients[x], mDataBuffers[index]);
//Quadrature sample
samples[index + 1] = convolve(mFilterCoefficients[x], mDataBuffers[index + 1]);
}
}
else
{
int half = mFilterCoefficients.length / 2;
for(int x = 0; x < half; x++)
{
int index = x * 2;
int filterIndex = x + half;
//Inphase sample
samples[index] = convolve(mFilterCoefficients[filterIndex], mDataBuffers[index]);
//Quadrature sample
samples[index + 1] = convolve(mFilterCoefficients[filterIndex], mDataBuffers[index + 1]);
}
for(int x = half; x < mFilterCoefficients.length; x++)
{
int index = x * 2;
int filterIndex = x - half;
//Inphase sample
samples[index] = convolve(mFilterCoefficients[filterIndex], mDataBuffers[index]);
//Quadrature sample
samples[index + 1] = convolve(mFilterCoefficients[filterIndex], mDataBuffers[index + 1]);
}
} }
//Toggled flip-flop here //IFFT is executed in-place with the output overwriting the input
if(mFlipFlop) mFFT.complexInverse(samples, true);
dispatch(samples);
}
/**
* Filters the samples contained in the buffer against the filter coefficients
* @param coefficients of the sub filter
* @param buffer containing data samples
* @return
*/
private float convolve(float[] coefficients, ReverseFloatCircularBuffer buffer)
{
float accumulator = 0.0f;
for( int x = 0; x < coefficients.length; x++ )
{ {
float[] flippedSamples = new float[mChannelCount * 2]; accumulator += coefficients[ x ] * buffer.get(x);
System.arraycopy(filteredSamples, 0, flippedSamples, mChannelCount, mChannelCount);
System.arraycopy(filteredSamples, mChannelCount, flippedSamples, 0, mChannelCount);
filteredSamples = flippedSamples;
} }
mFlipFlop = !mFlipFlop; return accumulator;
//FFT is executed in-place where the output overwrites the input
mFFT.complexForward(filteredSamples);
dispatch(filteredSamples);
int half = mChannelCount / 2;
//Serpentine shift the 0 to m/2 samples to bottom of the input arrays
System.arraycopy(mInputISamples, half, mInputISamples, 0, half);
System.arraycopy(mInputQSamples, half, mInputQSamples, 0, half);
} }
private void dispatch(float[] channels) private void dispatch(float[] channels)
@@ -163,7 +201,14 @@ public class ComplexPolyphaseChannelizer3 implements Listener<ComplexBuffer>
{ {
int tapCount = (int)Math.ceil((double)taps.length / (double)mChannelCount); int tapCount = (int)Math.ceil((double)taps.length / (double)mChannelCount);
float[][] coefficients = new float[mChannelCount][tapCount]; mDataBuffers = new ReverseFloatCircularBuffer[mChannelCount * 2];
for(int x = 0; x < mChannelCount * 2; x++)
{
mDataBuffers[x] = new ReverseFloatCircularBuffer(tapCount);
}
mFilterCoefficients = new float[mChannelCount][tapCount];
for(int tap = 0; tap < tapCount; tap++) for(int tap = 0; tap < tapCount; tap++)
{ {
@@ -173,25 +218,13 @@ public class ComplexPolyphaseChannelizer3 implements Listener<ComplexBuffer>
if(index < taps.length) if(index < taps.length)
{ {
coefficients[filter][tap] = taps[index]; mFilterCoefficients[filter][tap] = taps[index];
} }
} }
} }
mInphaseFilters = new RealFIRFilter[mChannelCount];
mQuadratureFilters = new RealFIRFilter[mChannelCount];
for(int filter = 0; filter < mChannelCount; filter++)
{
mInphaseFilters[filter] = new RealFIRFilter(coefficients[filter], 1.0f);
mQuadratureFilters[filter] = new RealFIRFilter(coefficients[filter], 1.0f);
}
mInputISamples = new float[mChannelCount];
mInputQSamples = new float[mChannelCount];
mOutputSamples = new float[mChannelCount * 2];
mFFT = new FloatFFT_1D(mChannelCount); mFFT = new FloatFFT_1D(mChannelCount);
mInputPointer = mChannelCount -1; mFilterPointer = mChannelCount - 1; //Start at M/2
} }
public static void main(String[] args) public static void main(String[] args)
@@ -216,7 +249,7 @@ public class ComplexPolyphaseChannelizer3 implements Listener<ComplexBuffer>
mLog.debug(sb.toString()); mLog.debug(sb.toString());
ComplexPolyphaseChannelizer3 channelizer = new ComplexPolyphaseChannelizer3(taps, 8); ComplexPolyphaseChannelizerM2 channelizer = new ComplexPolyphaseChannelizerM2(taps, 8);
Oscillator oscillator = new Oscillator(channelCenter, 2 * sampleRate); Oscillator oscillator = new Oscillator(channelCenter, 2 * sampleRate);

View File

@@ -0,0 +1,51 @@
/*******************************************************************************
* 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 dsp.filter.correction;
import sample.complex.ComplexBuffer;
public class IQCorrectionFilter
{
private float mRatio = 0.00001f;
private float mAverageInphase = 0.0f;
private float mAverageQuadrature = 0.0f;
public IQCorrectionFilter(float ratio)
{
mRatio = ratio;
}
public IQCorrectionFilter()
{
}
public void filter(ComplexBuffer buffer)
{
float[] samples = buffer.getSamples();
for(int x = 0; x < samples.length; x += 2)
{
mAverageInphase = mAverageInphase + (mRatio * (samples[x] - mAverageInphase));
samples[x] -= mAverageInphase;
mAverageQuadrature = mAverageQuadrature + (mRatio * (samples[x + 1] - mAverageQuadrature));
samples[x + 1] -= mAverageQuadrature;
}
}
}

View File

@@ -142,7 +142,7 @@ public class AutomaticGainControl
public float process( float currentSample ) public float process( float currentSample )
{ {
float delayedSample = mDelayBuffer.get( currentSample ); float delayedSample = mDelayBuffer.putAndGet( currentSample );
double gain = MANUAL_AGC_GAIN; double gain = MANUAL_AGC_GAIN;

View File

@@ -74,7 +74,7 @@ public class ComplexFeedForwardGainControl implements ComplexSampleListener
} }
/* Replace oldest envelope value with current envelope value */ /* Replace oldest envelope value with current envelope value */
float oldestEnvelope = mEnvelopeHistory.get( envelope ); float oldestEnvelope = mEnvelopeHistory.putAndGet( envelope );
/* If the oldest envelope value was the max envelope value, then we /* If the oldest envelope value was the max envelope value, then we
* have to rediscover the max value from the envelope history */ * have to rediscover the max value from the envelope history */