Compare commits

..

1 Commits

13 changed files with 224 additions and 349 deletions

View File

@@ -79,11 +79,9 @@ public class ComplexPolyphaseChannelizerM2 extends AbstractComplexPolyphaseChann
private static final int MAXIMUM_QUEUED_BATCHES = 50;
/**
* Maximum batch sample arrays held for reuse: the queued IFFT batches plus the batch being filled and the batch
* being transformed. Channel output processors copy their channels from a batch instead of retaining it, so no
* other batches are held.
* Maximum batch sample arrays held for reuse: the queued IFFT batches plus the batches queued for channel output.
*/
private static final int MAXIMUM_POOLED_BATCHES = MAXIMUM_QUEUED_BATCHES + 2;
private static final int MAXIMUM_POOLED_BATCHES = 2 * MAXIMUM_QUEUED_BATCHES;
//Sized to process 40 times per second
private IFFTProcessorDispatcher mIFFTProcessorDispatcher = new IFFTProcessorDispatcher(25);

View File

@@ -68,12 +68,7 @@ public class PolyphaseChannelManager implements ISourceEventProcessor
private final static Logger mLog = LoggerFactory.getLogger(PolyphaseChannelManager.class);
private static final double CHANNEL_OVERSAMPLING = 2.0;
private static final int POLYPHASE_CHANNELIZER_TAPS_PER_CHANNEL = 9;
/**
* Maximum duration of queued native buffers awaiting the channelizer. The queue is bounded by sample count instead
* of buffer count because tuner buffer sizes vary widely, for example about 1,000 samples per RSP buffer and 32,768
* samples per RTL-SDR buffer, so that each tuner can absorb a processing delay of the same duration.
*/
private static final double MAXIMUM_QUEUED_SECONDS = 1.0;
private static final int MAXIMUM_QUEUED_NATIVE_BUFFERS = 500;
private Broadcaster<SourceEvent> mSourceEventBroadcaster = new Broadcaster<>();
private TunerController mTunerController;
@@ -83,7 +78,7 @@ public class PolyphaseChannelManager implements ISourceEventProcessor
private ComplexPolyphaseChannelizerM2 mPolyphaseChannelizer;
private ChannelSourceEventListener mChannelSourceEventListener = new ChannelSourceEventListener();
private NativeBufferReceiver mNativeBufferReceiver = new NativeBufferReceiver();
private Dispatcher<INativeBuffer> mBufferDispatcher;
private Dispatcher mBufferDispatcher;
private boolean mRunning = true;
/**
@@ -104,21 +99,10 @@ public class PolyphaseChannelManager implements ISourceEventProcessor
mChannelCalculator = new ChannelCalculator(tunerController.getSampleRate(), channelCount,
tunerController.getFrequency(), CHANNEL_OVERSAMPLING);
mBufferDispatcher = new Dispatcher<>("sdrtrunk polyphase buffer processor", 10, INativeBuffer::sampleCount,
getMaximumQueuedSamples(tunerController.getSampleRate()));
mBufferDispatcher = new Dispatcher("sdrtrunk polyphase buffer processor", 10, MAXIMUM_QUEUED_NATIVE_BUFFERS);
mBufferDispatcher.setListener(mNativeBufferReceiver);
}
/**
* Calculates the maximum number of queued samples for the buffer dispatcher.
* @param sampleRate of the tuner
* @return maximum queued samples, at least one
*/
private static long getMaximumQueuedSamples(double sampleRate)
{
return Math.max(1, (long)(sampleRate * MAXIMUM_QUEUED_SECONDS));
}
/**
* Provides a description of the state of this manager.
*/
@@ -294,7 +278,6 @@ public class PolyphaseChannelManager implements ISourceEventProcessor
double sampleRate = sourceEvent.getValue().doubleValue();
int channelCount = ComplexPolyphaseChannelizerM2.getChannelCount(sampleRate);
mChannelCalculator.setRates(sampleRate, channelCount);
mBufferDispatcher.setMaximumQueuedWeight(getMaximumQueuedSamples(sampleRate));
break;
case NOTIFICATION_FREQUENCY_AND_SAMPLE_RATE_LOCKED:
case NOTIFICATION_FREQUENCY_AND_SAMPLE_RATE_UNLOCKED:

View File

@@ -180,8 +180,7 @@ public class PolyphaseChannelSource extends TunerChannelSource implements Listen
/**
* Performs the output processor update. This method must be invoked on the channel results calling thread so that
* replacing the output processor doesn't overlap with delivery of channel results to it. The output processor
* applies channel index changes as it copies the next batch, and applies mixer and filter changes on its own
* dispatcher thread at that same batch.
* applies the configuration changes on its own dispatcher thread.
* @param channelCalculator for updates
* @param filterManager for updates
* @throws IllegalArgumentException if there's an issue.

View File

@@ -1,6 +1,6 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 Dennis Sheirer
* Copyright (C) 2014-2024 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
@@ -24,7 +24,6 @@ import io.github.dsheirer.sample.complex.ComplexSamples;
import io.github.dsheirer.source.heartbeat.HeartbeatManager;
import io.github.dsheirer.util.Dispatcher;
import java.util.Queue;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.atomic.AtomicLong;
import org.slf4j.Logger;
@@ -35,20 +34,12 @@ public abstract class ChannelOutputProcessor implements IPolyphaseChannelOutputP
private final static Logger mLog = LoggerFactory.getLogger(ChannelOutputProcessor.class);
/**
* Maximum queued channel sample batches, about one second of samples. A full batch is dropped when this channel
* Maximum queued channel results batches, about one second of samples. A full batch is dropped when this channel
* falls behind, which preserves the even-sized batch block parity that two-channel synthesis relies on.
*/
private static final int MAXIMUM_QUEUED_BATCHES = 50;
/**
* Maximum channel sample arrays held for reuse: the queued batches plus the batch being processed and the batch
* being copied.
*/
private static final int MAXIMUM_POOLED_ARRAYS = MAXIMUM_QUEUED_BATCHES + 2;
private Dispatcher<QueuedChannelSamples> mChannelSamplesDispatcher;
private final Queue<float[]> mSamplePool = new ArrayBlockingQueue<>(MAXIMUM_POOLED_ARRAYS);
private volatile int[] mChannelOffsets = new int[0];
private Dispatcher<QueuedChannelResults> mChannelResultsDispatcher;
private final Queue<PendingUpdate> mPendingUpdates = new ConcurrentLinkedQueue<>();
private final AtomicLong mBatchSequence = new AtomicLong();
private HeartbeatManager mHeartbeatManager;
@@ -69,45 +60,25 @@ public abstract class ChannelOutputProcessor implements IPolyphaseChannelOutputP
mInputChannelCount = inputChannelCount;
//Process 1/10th of the sample rate per second at a rate of 20 times a second (200% of anticipated rate)
mHeartbeatManager = heartbeatManager;
mChannelSamplesDispatcher = new Dispatcher<>(threadName,50, mHeartbeatManager, MAXIMUM_QUEUED_BATCHES);
mChannelSamplesDispatcher.setListener(queued -> {
mChannelResultsDispatcher = new Dispatcher(threadName,50, mHeartbeatManager, MAXIMUM_QUEUED_BATCHES);
mChannelResultsDispatcher.setListener(queued -> {
try
{
applyPendingUpdates(queued.sequence());
mCurrentSampleTimestamp = queued.timestamp();
process(queued.samples(), queued.blockCount());
mCurrentSampleTimestamp = queued.channelResults().getTimestamp();
process(queued.channelResults());
}
catch(Throwable t)
{
mLog.error("Error processing channel samples", t);
mLog.error("Error processing channel results", t);
}
finally
{
mSamplePool.offer(queued.samples());
queued.channelResults().release();
}
});
}
/**
* Sets the I/Q offsets within each channel results block for the polyphase channel(s) that this processor copies.
* The offsets take effect at the first channel results batch received after this method is invoked, the same as a
* change queued with enqueueUpdate(), so a change of offsets and of the mixer frequency apply to the same batch.
* This should only be invoked on the thread that delivers channel results, or before results are delivered.
* @param offsets for each polyphase channel, which is twice the channel index.
*/
protected void setChannelOffsets(int... offsets)
{
mChannelOffsets = offsets.clone();
}
/**
* Current I/Q offsets within each channel results block for the polyphase channel(s) that this processor copies.
*/
protected int[] getChannelOffsets()
{
return mChannelOffsets.clone();
}
/**
* Queues a configuration change to apply on the dispatcher thread, so that configuration changes don't overlap with
* sample processing. The change takes effect at the first channel results batch received after this method is
@@ -148,13 +119,13 @@ public abstract class ChannelOutputProcessor implements IPolyphaseChannelOutputP
@Override
public void start()
{
mChannelSamplesDispatcher.start();
mChannelResultsDispatcher.start();
}
@Override
public void stop()
{
mChannelSamplesDispatcher.stop();
mChannelResultsDispatcher.stop();
}
/**
@@ -176,66 +147,22 @@ public abstract class ChannelOutputProcessor implements IPolyphaseChannelOutputP
{
}
/**
* Copies this processor's polyphase channel(s) from the channel results batch and queues the copy for processing on
* the dispatcher thread. The copy is small (about 8 kB per polyphase channel for a 1024 block batch), so the batch
* isn't retained beyond this method and its large shared sample array returns to the channelizer's pool as soon as
* the channelizer has dispatched it to every channel. A slow channel then queues only its own samples.
*
* @param channelResults batch to copy from
*/
@Override
public void receiveChannelResults(ChannelResultsBatch channelResults)
{
long sequence = mBatchSequence.incrementAndGet();
channelResults.retain();
if(!mChannelSamplesDispatcher.isRunning())
if(!mChannelResultsDispatcher.offer(new QueuedChannelResults(channelResults, mBatchSequence.incrementAndGet())))
{
return;
}
int[] offsets = mChannelOffsets;
float[] source = channelResults.getSamples();
int blockLength = channelResults.getBlockLength();
int blockCount = channelResults.getBlockCount();
float[] samples = getPooledArray(blockCount * offsets.length * 2);
int pointer = 0;
for(int block = 0; block < blockCount; block++)
{
int blockOffset = block * blockLength;
for(int offset : offsets)
{
samples[pointer++] = source[blockOffset + offset];
samples[pointer++] = source[blockOffset + offset + 1];
}
}
if(!mChannelSamplesDispatcher.offer(new QueuedChannelSamples(samples, blockCount, channelResults.getTimestamp(),
sequence)))
{
mSamplePool.offer(samples);
channelResults.release();
}
}
/**
* Provides a reused sample array of the requested length when one is available, or a new array.
* Sub-class implementation to process one polyphase channelizer results batch.
* @param channelResults to process
*/
private float[] getPooledArray(int length)
{
float[] samples = mSamplePool.poll();
return samples != null && samples.length == length ? samples : new float[length];
}
/**
* Sub-class implementation to process one batch of copied channel samples.
* @param samples for each block in order, with the I/Q pair of each polyphase channel in the order of the channel
* offsets, for example I1,Q1,I2,Q2 per block for two channels.
* @param blockCount number of blocks. Batches start on an even block index, so the index of a block within this
* batch has the same parity as its absolute block index.
*/
public abstract void process(float[] samples, int blockCount);
public abstract void process(ChannelResultsBatch channelResults);
@Override
public int getInputChannelCount()
@@ -244,10 +171,9 @@ public abstract class ChannelOutputProcessor implements IPolyphaseChannelOutputP
}
/**
* Copied channel samples with the timestamp of the batch they were copied from and the batch's position in the
* sequence of received batches.
* Channel results batch and its position in the sequence of received batches.
*/
private record QueuedChannelSamples(float[] samples, int blockCount, long timestamp, long sequence) {}
private record QueuedChannelResults(ChannelResultsBatch channelResults, long sequence) {}
/**
* Configuration change and the sequence number of the last batch received before the change was requested.

View File

@@ -1,6 +1,6 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 Dennis Sheirer
* Copyright (C) 2014-2024 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
@@ -18,9 +18,9 @@
*/
package io.github.dsheirer.dsp.filter.channelizer.output;
import io.github.dsheirer.dsp.filter.channelizer.ChannelResultsBatch;
import io.github.dsheirer.sample.complex.ComplexSamples;
import io.github.dsheirer.source.heartbeat.HeartbeatManager;
import java.util.Arrays;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -29,6 +29,7 @@ public class OneChannelOutputProcessor extends ChannelOutputProcessor
{
private final static Logger mLog = LoggerFactory.getLogger(OneChannelOutputProcessor.class);
private final OneChannelMixerAssembler mMixerAssembler;
private int mChannelOffset;
/**
* Processor to extract a single channel from a polyphase channelizer and produce an output I/Q complex sample
@@ -54,7 +55,7 @@ public class OneChannelOutputProcessor extends ChannelOutputProcessor
{
StringBuilder sb = new StringBuilder();
sb.append("One Channel Output Processor");
sb.append("\n\tIndex (doubled) ").append(Arrays.toString(getChannelOffsets()));
sb.append("\n\tIndex (doubled) [").append(mChannelOffset).append("]");
sb.append("\n\tMixer Assembler: none");
return sb.toString();
}
@@ -80,7 +81,8 @@ public class OneChannelOutputProcessor extends ChannelOutputProcessor
//Set the channelized output results offset to twice the channel index to account for each channel having
//an I/Q pair
setChannelOffsets(indexes.get(0) * 2);
int channelOffset = indexes.get(0) * 2;
enqueueUpdate(() -> mChannelOffset = channelOffset);
}
@Override
@@ -90,18 +92,19 @@ public class OneChannelOutputProcessor extends ChannelOutputProcessor
}
/**
* Passes the copied channel samples to the assembler. The assembler will apply frequency translation and gain and
* indicate when a buffer is fully assembled.
* Extract the channel from the channel results array and pass to the assembler. The assembler will
* apply frequency translation and gain and indicate when a buffer is fully assembled.
*
* @param samples containing an I/Q pair for each block (I0,Q0,I1,Q1...In,Qn)
* @param blockCount number of blocks
* @param channelResults to process containing blocks of channel I/Q sample pairs (I0,Q0,I1,Q1...In,Qn)
*/
@Override
public void process(float[] samples, int blockCount)
public void process(ChannelResultsBatch channelResults)
{
int length = blockCount * 2;
float[] samples = channelResults.getSamples();
int blockLength = channelResults.getBlockLength();
int channelOffset = mChannelOffset;
for(int index = 0; index < length; index += 2)
for(int index = channelOffset; index < samples.length; index += blockLength)
{
mMixerAssembler.receive(samples[index], samples[index + 1]);

View File

@@ -1,6 +1,6 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 Dennis Sheirer
* Copyright (C) 2014-2024 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
@@ -18,9 +18,9 @@
*/
package io.github.dsheirer.dsp.filter.channelizer.output;
import io.github.dsheirer.dsp.filter.channelizer.ChannelResultsBatch;
import io.github.dsheirer.sample.complex.ComplexSamples;
import io.github.dsheirer.source.heartbeat.HeartbeatManager;
import java.util.Arrays;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -29,6 +29,8 @@ public class TwoChannelOutputProcessor extends ChannelOutputProcessor
{
private final static Logger mLog = LoggerFactory.getLogger(TwoChannelOutputProcessor.class);
private TwoChannelMixerAssembler mMixerAssembler;
private int mChannelOffset1;
private int mChannelOffset2;
/**
* Processor to extract two channels from a polyphase channelizer, synthesize/recombine the channels, apply
@@ -58,7 +60,7 @@ public class TwoChannelOutputProcessor extends ChannelOutputProcessor
{
StringBuilder sb = new StringBuilder();
sb.append("Two Channel Output Processor");
sb.append("\n\tIndices (doubled) ").append(Arrays.toString(getChannelOffsets()));
sb.append("\n\tIndices (doubled) 1 [").append(mChannelOffset1).append("] 2 [").append(mChannelOffset2).append("]");
sb.append("\n\tMixer Assembler: ").append(mMixerAssembler.getStateDescription());
return sb.toString();
}
@@ -96,32 +98,45 @@ public class TwoChannelOutputProcessor extends ChannelOutputProcessor
//Set the channelized output results offsets to twice the channel index to account for each channel having
//an I/Q pair
setChannelOffsets(indexes.get(0) * 2, indexes.get(1) * 2);
int channelOffset1 = indexes.get(0) * 2;
int channelOffset2 = indexes.get(1) * 2;
enqueueUpdate(() -> {
mChannelOffset1 = channelOffset1;
mChannelOffset2 = channelOffset2;
});
}
/**
* Synthesizes the two copied channels, applies frequency translation, and delivers the frequency-corrected channel
* I/Q sample set to the complex sample listener.
* Extract the channel from the channel results array, apply frequency translation, and deliver the
* extracted frequency-corrected channel I/Q sample set to the complex sample listener.
*
* @param samples containing an I/Q pair for each of the two channels per block (I1,Q1,I2,Q2 ...)
* @param blockCount number of blocks
* @param channelResults to process containing blocks of channel I/Q sample pairs (I0,Q0,I1,Q1...In,Qn)
*/
@Override
public void process(float[] samples, int blockCount)
public void process(ChannelResultsBatch channelResults)
{
float[] samples = channelResults.getSamples();
int blockLength = channelResults.getBlockLength();
int blockCount = channelResults.getBlockCount();
int channelOffset1 = mChannelOffset1;
int channelOffset2 = mChannelOffset2;
//Translate channel 2 up by FS/2 (multiply by (-1)^n) so that it sits adjacent to channel 1 for synthesis. The
//channelizer dispatches even-sized batches, so the index within the batch carries the absolute block parity.
for(int x = 0; x < blockCount; x++)
{
int block = x * 4;
int block = x * blockLength;
if((x & 1) == 0)
{
mMixerAssembler.receive(samples[block], samples[block + 1], samples[block + 2], samples[block + 3]);
mMixerAssembler.receive(samples[block + channelOffset1], samples[block + channelOffset1 + 1],
samples[block + channelOffset2], samples[block + channelOffset2 + 1]);
}
else
{
mMixerAssembler.receive(samples[block], samples[block + 1], -samples[block + 2], -samples[block + 3]);
mMixerAssembler.receive(samples[block + channelOffset1], samples[block + channelOffset1 + 1],
-samples[block + channelOffset2], -samples[block + channelOffset2 + 1]);
}
if(mMixerAssembler.hasBuffer())

View File

@@ -75,6 +75,9 @@ import io.github.dsheirer.module.decode.nxdn.layer3.mobility.RegistrationCommand
import io.github.dsheirer.module.decode.nxdn.layer3.mobility.RegistrationResponse;
import io.github.dsheirer.module.decode.nxdn.layer3.mobility.RegistrationResponseTypeD;
import io.github.dsheirer.module.decode.nxdn.layer3.proprietary.TalkerAliasComplete;
import io.github.dsheirer.module.decode.nxdn.layer3.scch.Information1;
import io.github.dsheirer.module.decode.nxdn.layer3.scch.InitializationVectorPart1;
import io.github.dsheirer.module.decode.nxdn.layer3.type.CipherType;
import io.github.dsheirer.protocol.Protocol;
import java.util.Collections;
import java.util.List;
@@ -288,8 +291,9 @@ public class NXDNDecoderState extends DecoderState
{
//Controller responds to a voice call request with either a channel grant, or this message if
//it can't support the call or the called party is not available
//Type-D call response doesn't carry a cause.
broadcastEvent(vcr.getIdentifiers(), vcr.getTimestamp(), DecodeEventType.RESPONSE,
"VOICE CALL REQUEST - RESPONSE:" + vcr.getCause().toString());
vcr.isTypeD() ? "CALL RESPONSE" : "VOICE CALL REQUEST - RESPONSE:" + vcr.getCause());
}
break;
case TRAFFIC_OUT_01_CC_VOICE_CALL:
@@ -726,6 +730,24 @@ public class NXDNDecoderState extends DecoderState
break;
}
//Messages that don't otherwise change the state (e.g. Type-D SCCH) but are carried in a frame that also carries
//voice are a continuation of the call. Otherwise, the ACTIVE state toggles the channel out of CALL state on
//every voice frame, squelching the audio module which then discards the call audio.
if(state == State.ACTIVE && event == DecoderStateEvent.Event.DECODE && layer3.getLICH().hasAudio())
{
//Type-D only sends the VOICE CALL at the start of a call. When we join late, or miss it, use the SCCH call
//info or initialization vector to determine the encryption state.
if(!mEncryptedCallStateDetermined && layer3 instanceof Information1 info1)
{
mEncryptedCallStateDetermined = true;
mEncryptedCall = info1 instanceof InitializationVectorPart1 ||
info1.getCipherType() != CipherType.UNENCRYPTED;
}
state = (mEncryptedCallStateDetermined && mEncryptedCall) ? State.ENCRYPTED : State.CALL;
event = DecoderStateEvent.Event.CONTINUATION;
}
broadcast(new DecoderStateEvent(this, event, state));
}

View File

@@ -27,8 +27,10 @@ import io.github.dsheirer.module.decode.nxdn.layer3.call.Audio;
import io.github.dsheirer.module.decode.nxdn.layer3.call.Disconnect;
import io.github.dsheirer.module.decode.nxdn.layer3.call.TransmissionRelease;
import io.github.dsheirer.module.decode.nxdn.layer3.call.VoiceCall;
import io.github.dsheirer.module.decode.nxdn.layer3.call.VoiceCallWithOptionalLocation;
import io.github.dsheirer.module.decode.nxdn.layer3.scch.Information1;
import io.github.dsheirer.module.decode.nxdn.layer3.scch.InitializationVectorPart1;
import io.github.dsheirer.module.decode.nxdn.layer3.type.AudioCodec;
import io.github.dsheirer.module.decode.nxdn.layer3.type.CipherType;
import io.github.dsheirer.preference.UserPreferences;
import io.github.dsheirer.sample.Listener;
import java.util.ArrayList;
@@ -100,11 +102,18 @@ public class NXDNAudioModule extends AmbeAudioModule
mAudioCodec = voiceCall.getCallOption().getCodec();
processCachedAudio();
}
else if(message instanceof VoiceCallWithOptionalLocation voiceCall)
//Note: VoiceCallWithOptionalLocation subclasses (request, response, assignment, etc.) don't carry the
//cipher type and key ID, so they can't be used to establish the encryption state.
else if(!mEncryptedCallStateEstablished && message instanceof Information1 info1 &&
info1.getLICH().hasAudio())
{
mEncryptedCall = voiceCall.getEncryptionKeyIdentifier().isEncrypted();
//Type-D only sends the VOICE CALL message at the start of the call. Use the SCCH call info or
//initialization vector from a voice frame to establish the encryption state when we join a call
//late, or when the VOICE CALL message was missed. Type-D only supports AMBE+ half-rate.
mEncryptedCall = info1 instanceof InitializationVectorPart1 ||
info1.getCipherType() != CipherType.UNENCRYPTED;
mEncryptedCallStateEstablished = true;
mAudioCodec = voiceCall.getCallOption().getCodec();
mAudioCodec = AudioCodec.HALF_RATE;
processCachedAudio();
}
else if(message instanceof Disconnect || message instanceof TransmissionRelease)

View File

@@ -25,15 +25,25 @@ import io.github.dsheirer.identifier.Identifier;
import io.github.dsheirer.module.decode.nxdn.layer2.LICH;
import io.github.dsheirer.module.decode.nxdn.layer3.NXDNMessageType;
import io.github.dsheirer.module.decode.nxdn.layer3.type.CauseVD;
import io.github.dsheirer.module.decode.nxdn.layer3.type.SystemID;
import java.util.List;
/**
* Voice call response
* Voice call response (VCALL_RESP) or Type-D call response (CALL_RESP).
*
* Note: the Type-D call response (NXDN TS 1-E, Figure 6.4-21) has no cause or cipher fields. Instead, octets 7-9
* optionally carry a System ID Option and System ID when the CC Option indicates a multi trunked system.
*/
public class VoiceCallResponse extends VoiceCallWithOptionalLocation
{
private static final IntField CAUSE_VD = IntField.length8(OCTET_7);
private static final int LOCATION_ID_OFFSET = OCTET_8;
private static final int TYPE_D_MASK_MULTI_TRUNKED_SYSTEM = 0x10; //CC Option T-Type flag
private static final IntField TYPE_D_SYSTEM_ID_RELATED_UNIT = IntField.length2(OCTET_7);
private static final int TYPE_D_SYSTEM_ID_OFFSET = OCTET_7 + 5;
private static final int TYPE_D_RELATED_UNIT_SOURCE = 2;
private static final int TYPE_D_RELATED_UNIT_DESTINATION = 1;
private SystemID mTypeDSystemID;
/**
* Constructs an instance
@@ -58,6 +68,11 @@ public class VoiceCallResponse extends VoiceCallWithOptionalLocation
@Override
public String toString()
{
if(isTypeD())
{
return toStringTypeD();
}
StringBuilder sb = getMessageBuilder();
if(getCallControlOption().isEmergency())
@@ -88,28 +103,124 @@ public class VoiceCallResponse extends VoiceCallWithOptionalLocation
sb.append(" FROM:").append(getSource());
sb.append(" TO:").append(getDestination());
sb.append(" ").append(getEncryptionKeyIdentifier());
if(isTypeD())
{
sb.append(" FREE REPEATER:").append(getMessage().getInt(CALL_OPTION));
}
sb.append(" ").append(getCallOption());
return sb.toString();
}
/**
* Type-D call response formatted as a string.
*/
private String toStringTypeD()
{
StringBuilder sb = getMessageBuilder();
if(getCallControlOption().isEmergency())
{
sb.append("EMERGENCY ");
}
if(getCallControlOption().isPriorityPaging())
{
sb.append("PRIORITY ");
}
sb.append("TYPE-D ").append(getCallType()).append(" CALL RESPONSE");
sb.append(" FROM:").append(getSource());
sb.append(" TO:").append(getDestination());
if(hasTypeDSystemID())
{
sb.append(" MULTI-SYSTEM ").append(getTypeDSystemID());
if(isTypeDSystemIDForSource())
{
sb.append(" (SOURCE)");
}
else if(isTypeDSystemIDForDestination())
{
sb.append(" (DESTINATION)");
}
}
sb.append(" FREE REPEATER:").append(getFreeRepeater());
sb.append(" ").append(getCallOption());
return sb.toString();
}
/**
* Type-D free repeater number.
*/
public int getFreeRepeater()
{
return getMessage().getInt(CALL_OPTION);
}
/**
* Indicates if this Type-D call response carries the optional System ID, which is present for a multi trunked
* system.
*/
public boolean hasTypeDSystemID()
{
return isTypeD() && (getCallControlOption().value() & TYPE_D_MASK_MULTI_TRUNKED_SYSTEM) ==
TYPE_D_MASK_MULTI_TRUNKED_SYSTEM;
}
/**
* Optional Type-D System ID.
* @return system ID or null if the message doesn't carry a system ID.
*/
public SystemID getTypeDSystemID()
{
if(mTypeDSystemID == null && hasTypeDSystemID())
{
mTypeDSystemID = new SystemID(getMessage(), TYPE_D_SYSTEM_ID_OFFSET);
}
return mTypeDSystemID;
}
/**
* Indicates if the Type-D System ID relates to the source unit.
*/
public boolean isTypeDSystemIDForSource()
{
return hasTypeDSystemID() && getMessage().getInt(TYPE_D_SYSTEM_ID_RELATED_UNIT) == TYPE_D_RELATED_UNIT_SOURCE;
}
/**
* Indicates if the Type-D System ID relates to the destination unit.
*/
public boolean isTypeDSystemIDForDestination()
{
return hasTypeDSystemID() &&
getMessage().getInt(TYPE_D_SYSTEM_ID_RELATED_UNIT) == TYPE_D_RELATED_UNIT_DESTINATION;
}
/**
* Amplifying cause for the response.
* @return cause, or UNKNOWN for a Type-D call response which doesn't carry a cause.
*/
public CauseVD getCause()
{
if(isTypeD())
{
return CauseVD.UNKNOWN;
}
return CauseVD.fromValue(getMessage().getInt(CAUSE_VD));
}
@Override
public List<Identifier> getIdentifiers()
{
if(isTypeD())
{
//Type-D call response doesn't carry an encryption key
return List.of(getSource(), getDestination());
}
return List.of(getSource(), getDestination(), getEncryptionKeyIdentifier());
}
}

View File

@@ -1,6 +1,6 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 Dennis Sheirer
* Copyright (C) 2014-2023 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
@@ -70,7 +70,7 @@ public class RspNativeBuffer extends AbstractNativeBuffer
@Override
public int sampleCount()
{
return mISamples.length;
return mISamples.length * 2;
}
/**

View File

@@ -1,6 +1,6 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 Dennis Sheirer
* Copyright (C) 2014-2025 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
@@ -31,8 +31,6 @@ import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.ToLongFunction;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -56,9 +54,6 @@ public class Dispatcher<E> implements Listener<E>
private HeartbeatManager mHeartbeatManager;
private long mDroppedCount = 0;
private long mLastOverflowLogTimestamp = 0;
private final ToLongFunction<E> mWeigher;
private volatile long mMaximumQueuedWeight = Long.MAX_VALUE;
private final AtomicLong mQueuedWeight = new AtomicLong();
/**
* Constructs an instance of a Dispatcher with integrated heartbeat support.
@@ -95,7 +90,6 @@ public class Dispatcher<E> implements Listener<E>
mThreadName = threadName;
mInterval = interval;
mQueue = new LinkedTransferQueue<>();
mWeigher = null;
}
/**
@@ -109,46 +103,6 @@ public class Dispatcher<E> implements Listener<E>
mThreadName = threadName;
mInterval = interval;
mQueue = new LinkedBlockingQueue<>(maximumQueueSize);
mWeigher = null;
}
/**
* Constructs an instance that is bounded by the total weight of the queued elements instead of the element count,
* for when element sizes vary widely, for example sample buffers from different tuners. An element is dropped
* when adding it would exceed the maximum weight, except when nothing is queued, so that an element heavier than
* the maximum is still delivered. Elements count toward the weight until the listener has processed them.
*
* @param threadName to name the dispatcher thread
* @param interval for processing each batch in milliseconds.
* @param weigher to calculate the weight of each element, for example a sample count.
* @param maximumQueuedWeight for the queued elements.
*/
public Dispatcher(String threadName, long interval, ToLongFunction<E> weigher, long maximumQueuedWeight)
{
if(weigher == null)
{
throw new IllegalArgumentException("Weigher cannot be null");
}
mThreadName = threadName;
mInterval = interval;
mQueue = new LinkedTransferQueue<>();
mWeigher = weigher;
setMaximumQueuedWeight(maximumQueuedWeight);
}
/**
* Sets the maximum total weight of the queued elements, for a dispatcher that was constructed with a weigher.
* @param maximumQueuedWeight for the queued elements.
*/
public void setMaximumQueuedWeight(long maximumQueuedWeight)
{
if(maximumQueuedWeight <= 0)
{
throw new IllegalArgumentException("Maximum queued weight must be positive: " + maximumQueuedWeight);
}
mMaximumQueuedWeight = maximumQueuedWeight;
}
/**
@@ -195,27 +149,7 @@ public class Dispatcher<E> implements Listener<E>
return false;
}
boolean queued;
if(mWeigher != null)
{
long weight = mWeigher.applyAsLong(e);
long queuedWeight = mQueuedWeight.addAndGet(weight);
if(queuedWeight > mMaximumQueuedWeight && queuedWeight > weight)
{
mQueuedWeight.addAndGet(-weight);
queued = false;
}
else
{
queued = mQueue.offer(e);
}
}
else
{
queued = mQueue.offer(e);
}
boolean queued = mQueue.offer(e);
if(!queued)
{
@@ -255,7 +189,6 @@ public class Dispatcher<E> implements Listener<E>
}
mQueue.clear();
mQueuedWeight.set(0);
mExecutorService = Executors.newSingleThreadScheduledExecutor(new NamingThreadFactory(mThreadName));
Runnable r = (mHeartbeatManager != null ? new ProcessorWithHeartbeat() : new Processor());
@@ -277,7 +210,6 @@ public class Dispatcher<E> implements Listener<E>
mScheduledFuture.cancel(false);
mScheduledFuture = null;
mQueue.clear();
mQueuedWeight.set(0);
}
if(mExecutorService != null)
@@ -327,8 +259,6 @@ public class Dispatcher<E> implements Listener<E>
mListener.getClass() + "]", t);
}
}
release(element);
}
}
}
@@ -364,19 +294,6 @@ public class Dispatcher<E> implements Listener<E>
mListener.getClass() + "]", t);
}
}
release(element);
}
}
/**
* Removes the weight of a dequeued element from the queued weight, once the element is processed.
*/
private void release(E element)
{
if(mWeigher != null)
{
mQueuedWeight.addAndGet(-mWeigher.applyAsLong(element));
}
}

View File

@@ -19,16 +19,11 @@
package io.github.dsheirer.dsp.filter.channelizer;
import io.github.dsheirer.dsp.filter.channelizer.output.OneChannelOutputProcessor;
import io.github.dsheirer.dsp.filter.channelizer.output.TwoChannelOutputProcessor;
import io.github.dsheirer.sample.complex.ComplexSamples;
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.CopyOnWriteArrayList;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -82,51 +77,4 @@ public class ChannelResultsBatchTest
assertEquals(1, pool.size());
}
/**
* Test: a running output processor copies its channels instead of retaining the batch, so the batch returns to the
* pool as soon as the channelizer releases it, even when the channel hasn't processed it yet. The copy holds the
* two channels' samples for each block in order.
*/
@Test
void runningOutputProcessorCopiesChannelsWithoutRetainingBatch() throws Exception
{
int blockLength = 8; //4 polyphase channels, I/Q interleaved
int blockCount = 2;
float[] samples = new float[blockLength * blockCount];
for(int x = 0; x < samples.length; x++)
{
samples[x] = x;
}
Queue<float[]> pool = new ArrayDeque<>();
ChannelResultsBatch batch = new ChannelResultsBatch(samples, blockLength, 0, pool);
List<float[]> copied = new CopyOnWriteArrayList<>();
TwoChannelOutputProcessor processor = new TwoChannelOutputProcessor(50000.0, List.of(1, 3), new float[]{1.0f},
1.0f, null, "test")
{
@Override
public void process(float[] channelSamples, int count)
{
copied.add(Arrays.copyOf(channelSamples, count * 4));
}
};
processor.setListener((ComplexSamples complexSamples) -> {});
processor.start();
processor.receiveChannelResults(batch);
batch.release();
assertSame(samples, pool.poll(), "Batch was retained by the output processor");
for(int wait = 0; wait < 100 && copied.isEmpty(); wait++)
{
Thread.sleep(20);
}
processor.stop();
//Channel 1 is at offset 2 and channel 3 at offset 6 within each 8 element block
assertArrayEquals(new float[]{2, 3, 6, 7, 10, 11, 14, 15}, copied.get(0));
}
}

View File

@@ -125,60 +125,4 @@ public class DispatcherTest
assertEquals(101, received.size());
}
/**
* Test: a weight-bounded queue drops elements that would exceed the maximum weight and keeps lighter ones.
*/
@Test
void weightBoundedQueueDropsElementsOverMaximumWeight() throws Exception
{
//Each element weighs its own value: 1 + 2 + 3 = 6 is queued, then 4 would exceed 6 and is dropped, then 0 fits
Dispatcher<Integer> dispatcher = new Dispatcher<>("test", 1, Integer::longValue, 6);
List<Integer> received = dispatchWhileBlocked(dispatcher, 4);
dispatcher.receive(0);
awaitSize(received, 5);
Thread.sleep(50);
dispatcher.stop();
assertEquals(List.of(0, 1, 2, 3, 0), received);
}
/**
* Test: an element heavier than the maximum weight is delivered when nothing else is queued.
*/
@Test
void weightBoundedQueueAcceptsHeavyElementWhenEmpty() throws Exception
{
Dispatcher<Integer> dispatcher = new Dispatcher<>("test", 1, Integer::longValue, 6);
List<Integer> received = dispatchWhileBlocked(dispatcher, 0);
dispatcher.receive(100);
dispatcher.receive(1);
awaitSize(received, 2);
Thread.sleep(50);
dispatcher.stop();
assertEquals(List.of(0, 100), received);
}
/**
* Test: processed elements release their weight so that the queue accepts new elements after an overflow.
*/
@Test
void weightBoundedQueueRecoversAfterOverflow() throws Exception
{
Dispatcher<Integer> dispatcher = new Dispatcher<>("test", 1, Integer::longValue, 6);
List<Integer> received = dispatchWhileBlocked(dispatcher, 10);
awaitSize(received, 4);
Thread.sleep(50);
for(int x = 0; x < 3; x++)
{
dispatcher.receive(5);
awaitSize(received, 5 + x);
}
dispatcher.stop();
assertEquals(List.of(0, 1, 2, 3, 5, 5, 5), received);
}
}