mirror of
https://github.com/DSheirer/sdrtrunk.git
synced 2026-11-18 03:27:26 -05:00
Compare commits
1 Commits
master
...
2688-nxdn-
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
886ac2a070 |
@@ -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);
|
||||
|
||||
@@ -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:
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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]);
|
||||
|
||||
|
||||
@@ -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())
|
||||
|
||||
@@ -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));
|
||||
}
|
||||
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -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));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user