use std::collections::VecDeque;
use std::f64::consts::TAU;
use super::dsp::{Complex, ComplexFir, Nco, blackman_taps, design_lowpass};
use super::ita2::{self, Decoded, Shift};
use super::profile::{CharacterSet, RttyProfile, RttyTones, validate_sample_rate};
use crate::{Error, Result};
const MATCHED_CUTOFF_BAUD: f64 = 0.6;
const MATCHED_SPAN_BITS: f64 = 2.0;
const MIN_BASEBAND_RATE: f64 = 1_500.0;
const LLR_SCALE: f64 = 0.35;
const LEVEL_BITS: f64 = 16.0;
const SIGNAL_LEVEL_BITS: f64 = 2.0;
const MAX_CANDIDATES: usize = 16;
const FRAME_OVERLAP_BITS: f64 = 6.5;
const MAX_BIT_LLR: f64 = 6.0;
const QUALITY_ALPHA: f64 = 0.35;
const QUALITY_GATE: f64 = 0.12;
const STRONG_CHARACTER: f64 = 0.7;
const WARMUP_BITS: f64 = 24.0;
const SILENCE_POWER: f64 = 1e-14;
const SNR_DECAY: f64 = 0.85;
const SNR_WINDOW: (f64, f64) = (0.3, 0.7);
const SNR_HISTORY_BITS: f64 = 32.0;
const SNR_FLOOR_DB: f64 = -30.0;
const SNR_CEILING_DB: f64 = 60.0;
const SNR_REFERENCE_HZ: f64 = 3_000.0;
const LOCK_SCORE: f64 = 0.35;
const TICK_SECONDS: f64 = 0.1;
const BLANKER_THRESHOLD: f64 = 6.0;
const BLANKER_AVERAGE_SECONDS: f64 = 0.2;
const BLANKER_HOLD_SECONDS: f64 = 0.000_5;
const BLANKER_MAX_IMPULSE_SECONDS: f64 = 0.003;
const BLANKER_POWER_FLOOR: f64 = 1e-9;
const CHAIN_PRIOR: f64 = 0.8;
const STREAM_HYSTERESIS: f64 = 0.1;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum RttyLane {
Atc,
Kahn,
MarkOnly,
SpaceOnly,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct RttyLaneSet {
pub atc: bool,
pub kahn: bool,
pub mark_only: bool,
pub space_only: bool,
}
impl Default for RttyLaneSet {
fn default() -> Self {
Self::ATC_KAHN
}
}
impl RttyLaneSet {
pub const ATC_KAHN: Self = Self {
atc: true,
kahn: true,
mark_only: false,
space_only: false,
};
pub const ATC: Self = Self {
atc: true,
kahn: false,
mark_only: false,
space_only: false,
};
pub const ALL: Self = Self {
atc: true,
kahn: true,
mark_only: true,
space_only: true,
};
fn lanes(self) -> Vec<RttyLane> {
let mut lanes = Vec::with_capacity(4);
if self.atc {
lanes.push(RttyLane::Atc);
}
if self.kahn {
lanes.push(RttyLane::Kahn);
}
if self.mark_only {
lanes.push(RttyLane::MarkOnly);
}
if self.space_only {
lanes.push(RttyLane::SpaceOnly);
}
lanes
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct RttyDecoderConfig {
pub profile: RttyProfile,
pub tones: RttyTones,
pub character_set: CharacterSet,
pub usos: bool,
pub afc: bool,
pub afc_range_hz: f64,
pub squelch: f32,
pub lanes: RttyLaneSet,
pub auto_reverse: bool,
pub signal_report_seconds: f64,
pub noise_blanker: bool,
}
impl Default for RttyDecoderConfig {
fn default() -> Self {
Self {
profile: RttyProfile::default(),
tones: RttyTones::default(),
character_set: CharacterSet::default(),
usos: true,
afc: true,
afc_range_hz: 50.0,
squelch: 0.25,
lanes: RttyLaneSet::default(),
auto_reverse: true,
signal_report_seconds: 0.1,
noise_blanker: true,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
#[non_exhaustive]
pub struct RttyCharacter {
pub ch: char,
pub code: u8,
pub confidence: f32,
pub start_sample: u64,
pub lane: RttyLane,
pub reversed: bool,
}
#[derive(Clone, Copy, Debug, PartialEq)]
#[non_exhaustive]
pub struct RttySignal {
pub sample: u64,
pub locked: bool,
pub snr_db: f32,
pub mark_db: f32,
pub space_db: f32,
pub frequency_offset_hz: f32,
pub reversed: bool,
}
#[derive(Clone, Copy, Debug, PartialEq)]
#[non_exhaustive]
pub enum RttyDecodeEvent {
Character(RttyCharacter),
Signal(RttySignal),
}
pub trait RttySink {
fn on_event(&mut self, event: RttyDecodeEvent);
}
impl<F: FnMut(RttyDecodeEvent)> RttySink for F {
fn on_event(&mut self, event: RttyDecodeEvent) {
self(event);
}
}
impl RttySink for Vec<RttyDecodeEvent> {
fn on_event(&mut self, event: RttyDecodeEvent) {
self.push(event);
}
}
#[derive(Clone, Copy, Debug)]
struct FrameResult {
t0: f64,
code: u8,
confidence: f64,
lane: RttyLane,
reversed: bool,
}
#[derive(Clone, Copy, Debug)]
struct Candidate {
t0: f64,
sums: [f64; 7],
counts: [u32; 7],
}
#[derive(Debug)]
struct Framer {
lane: RttyLane,
reversed: bool,
frame_bits: f64,
previous: f64,
recent: VecDeque<f64>,
recent_len: usize,
candidates: Vec<Candidate>,
last_valid_start: f64,
}
impl Framer {
fn new(lane: RttyLane, reversed: bool, samples_per_bit: f64, frame_bits: f64) -> Self {
let recent_len = (samples_per_bit / 2.0).round().max(1.0) as usize;
Self {
lane,
reversed,
frame_bits,
previous: 0.0,
recent: VecDeque::with_capacity(recent_len + 1),
recent_len,
candidates: Vec::with_capacity(MAX_CANDIDATES),
last_valid_start: f64::NEG_INFINITY,
}
}
fn reset(&mut self) {
self.previous = 0.0;
self.recent.clear();
self.candidates.clear();
self.last_valid_start = f64::NEG_INFINITY;
}
fn push(&mut self, index: f64, llr: f64, bit: f64, out: &mut Vec<FrameResult>) {
let llr = if self.reversed { -llr } else { llr };
if self.previous >= 0.0
&& llr < 0.0
&& self.candidates.len() < MAX_CANDIDATES
&& self.recent.len() == self.recent_len
&& self.recent.iter().sum::<f64>() > 0.0
{
let fraction = self.previous / (self.previous - llr);
let t0 = index - 1.0 + fraction;
if t0 >= self.last_valid_start + FRAME_OVERLAP_BITS * bit {
self.candidates.push(Candidate {
t0,
sums: [0.0; 7],
counts: [0; 7],
});
}
}
self.previous = llr;
self.recent.push_back(llr);
if self.recent.len() > self.recent_len {
self.recent.pop_front();
}
let mut position = 0;
while position < self.candidates.len() {
let candidate = &mut self.candidates[position];
let offset = (index - candidate.t0) / bit;
if offset >= 6.75 {
let finished = self.candidates.swap_remove(position);
if let Some(result) = self.finish(finished) {
out.push(result);
let predicted = result.t0 + self.frame_bits * bit;
let duplicate = self
.candidates
.iter()
.any(|other| (other.t0 - predicted).abs() < 0.1 * bit);
if !duplicate && self.candidates.len() < MAX_CANDIDATES {
self.candidates.push(Candidate {
t0: predicted,
sums: [0.0; 7],
counts: [0; 7],
});
}
}
continue;
}
if offset >= 0.0 {
let slot = offset.floor();
let fraction = offset - slot;
if (0.25..=0.75).contains(&fraction) {
let slot = slot as usize;
candidate.sums[slot] += llr;
candidate.counts[slot] += 1;
}
}
position += 1;
}
}
fn finish(&self, candidate: Candidate) -> Option<FrameResult> {
let mut averages = [0.0; 7];
for ((average, sum), count) in averages
.iter_mut()
.zip(candidate.sums)
.zip(candidate.counts)
{
if count == 0 {
return None;
}
*average = sum / f64::from(count);
}
if averages[0] >= 0.0 || averages[6] <= 0.0 {
return None;
}
let clip = |value: f64| value.clamp(-MAX_BIT_LLR, MAX_BIT_LLR);
let mut confidence = sigmoid(-clip(averages[0])) * sigmoid(clip(averages[6]));
let mut code = 0u8;
for bit in 0..5 {
let value = averages[bit + 1];
confidence *= sigmoid(clip(value).abs());
if value > 0.0 {
code |= 1 << bit;
}
}
Some(FrameResult {
t0: candidate.t0,
code,
confidence,
lane: self.lane,
reversed: self.reversed,
})
}
fn mark_accepted(&mut self, t0: f64, bit: f64) {
self.last_valid_start = self.last_valid_start.max(t0);
self.candidates
.retain(|candidate| candidate.t0 >= t0 + FRAME_OVERLAP_BITS * bit);
}
}
#[inline]
fn sigmoid(x: f64) -> f64 {
1.0 / (1.0 + (-x).exp())
}
#[derive(Debug)]
struct Combiner {
pending: Vec<FrameResult>,
last_t0: f64,
chain: f64,
score: f64,
last_winner: Option<FrameResult>,
}
impl Combiner {
fn new() -> Self {
Self {
pending: Vec::new(),
last_t0: f64::NEG_INFINITY,
chain: 0.0,
score: 0.0,
last_winner: None,
}
}
fn clear(&mut self) {
self.pending.clear();
self.last_t0 = f64::NEG_INFINITY;
self.last_winner = None;
}
fn ready_at(&self, now: f64, bit: f64) -> Option<f64> {
let earliest = self
.pending
.iter()
.map(|result| result.t0)
.min_by(f64::total_cmp)?;
(!now.is_finite() || now >= earliest + (FRAME_OVERLAP_BITS + 7.25) * bit)
.then_some(earliest)
}
fn next(&mut self, now: f64, bit: f64) -> Option<FrameResult> {
let earliest = self.ready_at(now, bit)?;
let window_end = earliest + FRAME_OVERLAP_BITS * bit;
let penalty = 1.0 - CHAIN_PRIOR * self.chain;
let weight = |result: &FrameResult| {
let distance = (result.t0 - self.last_t0) / bit;
if (6.8..=8.3).contains(&distance) {
result.confidence
} else {
result.confidence * penalty
}
};
let mut winner: Option<(FrameResult, f64)> = None;
for result in &self.pending {
if result.t0 >= window_end {
continue;
}
let weighted = weight(result);
if winner.is_none_or(|(_, best)| weighted > best) {
winner = Some((*result, weighted));
}
}
let (winner, _) = winner?;
let keep_from = window_end.max(winner.t0 + FRAME_OVERLAP_BITS * bit);
self.pending.retain(|result| result.t0 >= keep_from);
let distance = (winner.t0 - self.last_t0) / bit;
if distance < 6.8 {
self.chain += QUALITY_ALPHA * (0.0 - self.chain);
} else if distance <= 8.3 {
self.chain += QUALITY_ALPHA * (1.0 - self.chain);
}
self.score += QUALITY_ALPHA * (confidence_score(winner.confidence) - self.score);
self.last_t0 = winner.t0;
self.last_winner = Some(winner);
Some(winner)
}
}
fn stream_quality(combiner: &Combiner) -> f64 {
0.5 * combiner.chain + 0.5 * combiner.score
}
fn confidence_score(probability: f64) -> f64 {
(1.0 + probability.max(1e-12).log2() / 7.0).clamp(0.0, 1.0)
}
#[derive(Clone, Copy, Debug, Default)]
struct Level {
value: f64,
count: f64,
}
impl Level {
#[inline]
fn update(&mut self, input: f64, tau: f64) {
self.count += 1.0;
self.value += (input - self.value) / self.count.min(tau.max(1.0));
}
}
#[derive(Debug)]
struct ToneTrack {
nco: Nco,
filter: ComplexFir,
previous: Complex,
envelope: Level,
noise: Level,
}
impl ToneTrack {
fn new(offset_hz: f64, baseband_rate: f64, taps: Vec<f64>) -> Self {
Self {
nco: Nco::new(offset_hz, baseband_rate),
filter: ComplexFir::new(taps),
previous: Complex::ZERO,
envelope: Level::default(),
noise: Level::default(),
}
}
}
#[derive(Debug)]
pub struct RttyDecoder {
config: RttyDecoderConfig,
sample_rate: u32,
decimation: usize,
baseband_rate: f64,
samples_per_bit: f64,
blanker: NoiseBlanker,
decimator: ComplexFir,
center_nco: Nco,
mark: ToneTrack,
space: ToneTrack,
framers: Vec<Framer>,
results: Vec<FrameResult>,
combiners: Vec<Combiner>,
active_stream: usize,
last_emitted_t0: f64,
shift: Shift,
input_index: u64,
base_input_offset: u64,
phase: usize,
baseband_index: u64,
afc_offset_hz: f64,
afc_error: f64,
afc_weight: f64,
lock_score: f64,
last_character_index: f64,
next_tick: u64,
tick_interval: u64,
next_report: u64,
report_interval: u64,
matched_delay: f64,
decimator_delay: f64,
levels: [f64; 4],
warmup: u64,
warmup_length: u64,
active_run: u64,
matched_len: u64,
power_history: Vec<(u64, f64, f64)>,
snr_sums: [f64; 3],
noise_bandwidth_hz: f64,
finished: bool,
}
impl RttyDecoder {
pub fn new(sample_rate: u32, config: RttyDecoderConfig) -> Result<Self> {
validate_sample_rate(sample_rate)?;
validate_config(&config, sample_rate)?;
let rate = f64::from(sample_rate);
let half_band = config.tones.shift_hz() / 2.0 + 2.0 * config.profile.baud + 30.0;
let target = (3.0 * half_band).max(MIN_BASEBAND_RATE);
let decimation = ((rate / target).floor() as usize).max(1);
let baseband_rate = rate / decimation as f64;
let transition = (baseband_rate - 2.0 * half_band).max(100.0);
let decimator_taps = if decimation == 1 {
vec![1.0]
} else {
design_lowpass(half_band, rate, blackman_taps(transition, rate, 2_047))
};
let samples_per_bit = baseband_rate / config.profile.baud;
let matched_taps = design_lowpass(
MATCHED_CUTOFF_BAUD * config.profile.baud,
baseband_rate,
(MATCHED_SPAN_BITS * samples_per_bit).round() as usize,
);
let matched_delay = (matched_taps.len() - 1) as f64 / 2.0;
let matched_len = matched_taps.len() as u64;
let noise_bandwidth_hz = equivalent_noise_bandwidth(&matched_taps, baseband_rate);
let history_len = (SNR_HISTORY_BITS * samples_per_bit).ceil() as usize;
let decimator_delay = (decimator_taps.len() - 1) as f64 / 2.0;
let center = config.tones.center_hz();
let mark = ToneTrack::new(
config.tones.mark_hz - center,
baseband_rate,
matched_taps.clone(),
);
let space = ToneTrack::new(config.tones.space_hz - center, baseband_rate, matched_taps);
let framers = build_framers(&config, samples_per_bit);
let framers_len = framers.len();
let report_interval =
((config.signal_report_seconds * baseband_rate).round() as u64).max(1);
let tick_interval = ((TICK_SECONDS * baseband_rate).round() as u64).max(1);
let warmup_length = (WARMUP_BITS * samples_per_bit).ceil() as u64;
Ok(Self {
config,
sample_rate,
decimation,
baseband_rate,
samples_per_bit,
blanker: NoiseBlanker::new(rate),
decimator: ComplexFir::new(decimator_taps),
center_nco: Nco::new(center, rate),
mark,
space,
framers,
results: Vec::new(),
combiners: (0..framers_len).map(|_| Combiner::new()).collect(),
active_stream: 0,
last_emitted_t0: f64::NEG_INFINITY,
shift: Shift::Letters,
input_index: 0,
base_input_offset: 0,
phase: 0,
baseband_index: 0,
afc_offset_hz: 0.0,
afc_error: 0.0,
afc_weight: 0.0,
lock_score: 0.0,
last_character_index: f64::NEG_INFINITY,
next_tick: tick_interval,
tick_interval,
next_report: report_interval,
report_interval,
matched_delay,
decimator_delay,
levels: [0.0; 4],
warmup: warmup_length,
warmup_length,
active_run: 0,
matched_len,
power_history: vec![(u64::MAX, 0.0, 0.0); history_len.max(1)],
snr_sums: [0.0; 3],
noise_bandwidth_hz,
finished: false,
})
}
#[must_use]
pub fn config(&self) -> &RttyDecoderConfig {
&self.config
}
#[must_use]
pub fn sample_rate(&self) -> u32 {
self.sample_rate
}
#[must_use]
pub fn samples_consumed(&self) -> u64 {
self.input_index
}
#[must_use]
pub fn shift(&self) -> Shift {
self.shift
}
#[must_use]
pub fn frequency_offset_hz(&self) -> f64 {
self.afc_offset_hz
}
pub fn set_squelch(&mut self, squelch: f32) -> Result<()> {
if !squelch.is_finite() || !(0.0..=1.0).contains(&squelch) {
return Err(Error::InvalidConfiguration(
"RTTY squelch must be between 0 and 1",
));
}
self.config.squelch = squelch;
Ok(())
}
pub fn set_afc(&mut self, enabled: bool) {
self.config.afc = enabled;
if !enabled {
self.afc_offset_hz = 0.0;
self.apply_center();
}
}
pub fn set_usos(&mut self, enabled: bool) {
self.config.usos = enabled;
}
pub fn set_character_set(&mut self, character_set: CharacterSet) {
self.config.character_set = character_set;
}
pub fn set_lanes(
&mut self,
lanes: RttyLaneSet,
auto_reverse: bool,
sink: &mut impl RttySink,
) -> Result<()> {
if lanes == self.config.lanes && auto_reverse == self.config.auto_reverse {
return Ok(());
}
let config = RttyDecoderConfig {
lanes,
auto_reverse,
..self.config
};
validate_config(&config, self.sample_rate)?;
self.flush(f64::INFINITY, sink);
let active_key = {
let framer = &self.framers[self.active_stream];
(framer.lane, framer.reversed)
};
let mut old: Vec<(Framer, Combiner)> = self
.framers
.drain(..)
.zip(self.combiners.drain(..))
.collect();
self.config = config;
for fresh in build_framers(&self.config, self.samples_per_bit) {
let kept = old
.iter()
.position(|(framer, _)| {
framer.lane == fresh.lane && framer.reversed == fresh.reversed
})
.map(|index| old.swap_remove(index));
let (framer, combiner) = kept.unwrap_or_else(|| (fresh, Combiner::new()));
self.framers.push(framer);
self.combiners.push(combiner);
}
self.active_stream = self
.framers
.iter()
.position(|framer| (framer.lane, framer.reversed) == active_key)
.unwrap_or(0);
Ok(())
}
pub fn retune(&mut self, tones: RttyTones, sink: &mut impl RttySink) -> Result<()> {
tones.validate(self.sample_rate)?;
if (tones.shift_hz() - self.config.tones.shift_hz()).abs() > 0.5 {
let config = RttyDecoderConfig {
tones,
profile: RttyProfile {
shift_hz: tones.shift_hz(),
..self.config.profile
},
..self.config
};
validate_config(&config, self.sample_rate)?;
self.flush(f64::INFINITY, sink);
let mut fresh = Self::new(self.sample_rate, config)?;
fresh.input_index = self.input_index;
fresh.base_input_offset = self.input_index;
fresh.shift = self.shift;
fresh.finished = self.finished;
*self = fresh;
return Ok(());
}
self.config.tones = tones;
self.afc_offset_hz = 0.0;
let center = tones.center_hz();
self.apply_center();
self.mark
.nco
.set_frequency(tones.mark_hz - center, self.baseband_rate);
self.space
.nco
.set_frequency(tones.space_hz - center, self.baseband_rate);
Ok(())
}
pub fn push_f32(&mut self, samples: &[f32], sink: &mut impl RttySink) -> Result<()> {
if self.finished {
return Err(Error::DecoderFinished);
}
if samples.iter().any(|sample| !sample.is_finite()) {
return Err(Error::NonFiniteSample);
}
for &sample in samples {
self.process_sample(f64::from(sample), sink);
}
Ok(())
}
pub fn push_i16(&mut self, samples: &[i16], sink: &mut impl RttySink) -> Result<()> {
if self.finished {
return Err(Error::DecoderFinished);
}
for &sample in samples {
self.process_sample(f64::from(sample) / 32_768.0, sink);
}
Ok(())
}
pub fn process_into(
&mut self,
samples: &[f32],
events: &mut Vec<RttyDecodeEvent>,
) -> Result<()> {
self.push_f32(samples, events)
}
pub fn finish(&mut self, sink: &mut impl RttySink) {
if self.finished {
return;
}
let tail = self.decimator_delay
+ (self.matched_delay + 8.0 * self.samples_per_bit) * self.decimation as f64;
for _ in 0..tail.ceil() as usize {
self.process_sample(0.0, sink);
}
self.flush(f64::INFINITY, sink);
self.finished = true;
}
pub fn mark_discontinuity(&mut self, dropped_samples: u64, sink: &mut impl RttySink) {
self.flush(f64::INFINITY, sink);
self.input_index += dropped_samples;
self.base_input_offset = self.input_index;
self.baseband_index = 0;
self.phase = 0;
self.decimator.reset();
self.mark.filter.reset();
self.space.filter.reset();
self.mark.previous = Complex::ZERO;
self.space.previous = Complex::ZERO;
for framer in &mut self.framers {
framer.reset();
}
for combiner in &mut self.combiners {
combiner.clear();
}
self.warmup = self.warmup_length;
self.active_run = 0;
self.last_character_index = f64::NEG_INFINITY;
self.last_emitted_t0 = f64::NEG_INFINITY;
self.next_tick = self.tick_interval;
self.next_report = self.report_interval;
}
pub fn reset(&mut self) {
if let Ok(fresh) = Self::new(self.sample_rate, self.config) {
*self = fresh;
}
}
fn apply_center(&mut self) {
self.center_nco.set_frequency(
self.config.tones.center_hz() + self.afc_offset_hz,
f64::from(self.sample_rate),
);
}
fn process_sample(&mut self, sample: f64, sink: &mut impl RttySink) {
let sample = if self.config.noise_blanker {
self.blanker.process(sample)
} else {
sample
};
let mixed = self.center_nco.next().scale(sample);
self.input_index += 1;
self.decimator.push(mixed);
self.phase += 1;
if self.phase < self.decimation {
return;
}
self.phase = 0;
let baseband = self.decimator.output();
self.process_baseband(baseband, sink);
}
fn process_baseband(&mut self, baseband: Complex, sink: &mut impl RttySink) {
let bit = self.samples_per_bit;
let mark_out = self.mark.filter.filter(baseband * self.mark.nco.next());
let space_out = self.space.filter.filter(baseband * self.space.nco.next());
let m = mark_out.norm();
let s = space_out.norm();
let slot = (self.baseband_index % self.power_history.len() as u64) as usize;
self.power_history[slot] = (self.baseband_index, m * m, s * s);
let power = baseband.norm_sqr();
if power < SILENCE_POWER {
self.warmup = self.warmup_length;
self.active_run = 0;
} else {
self.warmup = self.warmup.saturating_sub(1);
self.active_run = self.active_run.saturating_add(1);
}
if self.active_run > self.matched_len {
let signal_tau = SIGNAL_LEVEL_BITS * bit;
let noise_tau = LEVEL_BITS * bit;
if m > s {
self.mark.envelope.update(m, signal_tau);
self.space.noise.update(s, noise_tau);
} else {
self.space.envelope.update(s, signal_tau);
self.mark.noise.update(m, noise_tau);
}
}
let me = self.mark.envelope.value;
let se = self.space.envelope.value;
let mn = self.mark.noise.value;
let sn = self.space.noise.value;
self.levels = [me, se, mn, sn];
if self.config.afc && self.locked() {
let (current, previous, weight) = if m > s {
(mark_out, self.mark.previous, m * m)
} else {
(space_out, self.space.previous, s * s)
};
self.afc_error += (current * previous.conj()).arg() * weight;
self.afc_weight += weight;
}
self.mark.previous = mark_out;
self.space.previous = space_out;
let noise = [self.mark.noise, self.space.noise]
.iter()
.filter(|level| level.count >= bit)
.map(|level| level.value)
.reduce(f64::min);
let norm = noise.map_or(0.0, |noise| 1.0 / (noise * noise).max(1e-18));
let mark_amp = (me - mn).max(0.0);
let space_amp = (se - sn).max(0.0);
let mc = (m.clamp(mn.min(me), me.max(mn)) - mn).max(0.0);
let sc = (s.clamp(sn.min(se), se.max(sn)) - sn).max(0.0);
let index = self.baseband_index as f64;
for (stream, framer) in self.framers.iter_mut().enumerate() {
let raw = match framer.lane {
RttyLane::Atc => {
mc * mark_amp
- sc * space_amp
- 0.5 * (mark_amp * mark_amp - space_amp * space_amp)
}
RttyLane::Kahn => mc * mc - sc * sc,
RttyLane::MarkOnly => 2.0 * mc * mark_amp - mark_amp * mark_amp,
RttyLane::SpaceOnly => space_amp * space_amp - 2.0 * sc * space_amp,
};
framer.push(index, LLR_SCALE * raw * norm, bit, &mut self.results);
self.combiners[stream].pending.append(&mut self.results);
}
self.flush(index, sink);
self.baseband_index += 1;
if self.baseband_index >= self.next_tick {
self.next_tick += self.tick_interval;
self.tick(index);
}
if self.baseband_index >= self.next_report {
self.next_report += self.report_interval;
self.report(sink);
}
}
fn locked(&self) -> bool {
self.lock_score > LOCK_SCORE
}
fn flush(&mut self, now: f64, sink: &mut impl RttySink) {
let bit = self.samples_per_bit;
loop {
let Some((stream, _)) = self
.combiners
.iter()
.enumerate()
.filter_map(|(stream, combiner)| combiner.ready_at(now, bit).map(|t0| (stream, t0)))
.min_by(|a, b| a.1.total_cmp(&b.1))
else {
return;
};
let Some(winner) = self.combiners[stream].next(now, bit) else {
return;
};
self.framers[stream].mark_accepted(winner.t0, bit);
let previous = self.active_stream;
self.select_stream();
if self.active_stream != previous && self.active_stream != stream {
if let Some(replay) = self.combiners[self.active_stream].last_winner {
self.emit_if_new(self.active_stream, replay, sink);
}
}
if stream == self.active_stream {
self.emit_if_new(stream, winner, sink);
}
}
}
fn emit_if_new(&mut self, stream: usize, frame: FrameResult, sink: &mut impl RttySink) {
if frame.t0 < self.last_emitted_t0 + FRAME_OVERLAP_BITS * self.samples_per_bit {
return;
}
self.last_emitted_t0 = frame.t0;
let combiner = &self.combiners[stream];
let evidence = combiner.chain * combiner.score;
self.accept(frame, evidence, sink);
}
fn select_stream(&mut self) {
let quality = stream_quality;
let current = quality(&self.combiners[self.active_stream]);
let mut best = (self.active_stream, current);
for (stream, combiner) in self.combiners.iter().enumerate() {
let candidate = quality(combiner);
if candidate > best.1 {
best = (stream, candidate);
}
}
if best.0 != self.active_stream && best.1 > current + STREAM_HYSTERESIS {
self.active_stream = best.0;
}
}
fn accept(&mut self, frame: FrameResult, quality: f64, sink: &mut impl RttySink) {
self.last_character_index = frame.t0;
self.measure_frame(&frame);
let confidence = confidence_score(frame.confidence);
self.lock_score += QUALITY_ALPHA * (confidence - self.lock_score);
let mut squelch = f64::from(self.config.squelch);
if squelch > 0.0 && (quality < QUALITY_GATE || self.warmup > 0) {
squelch = squelch.max(STRONG_CHARACTER);
}
match ita2::decode(frame.code, self.shift, self.config.character_set) {
Decoded::ShiftTo(shift) if confidence >= squelch * 0.5 => self.shift = shift,
Decoded::ShiftTo(_) | Decoded::Nothing => {}
Decoded::Char(ch) if confidence >= squelch => {
if ch == ' ' && self.config.usos {
self.shift = Shift::Letters;
}
let decimation = self.decimation as f64;
let start =
(frame.t0 - self.matched_delay + 1.0) * decimation - 1.0 - self.decimator_delay;
sink.on_event(RttyDecodeEvent::Character(RttyCharacter {
ch,
code: frame.code,
confidence: confidence as f32,
start_sample: self.base_input_offset + start.max(0.0).round() as u64,
lane: frame.lane,
reversed: frame.reversed,
}));
}
Decoded::Char(_) => {}
}
}
fn measure_frame(&mut self, frame: &FrameResult) {
let bit = self.samples_per_bit;
let mut bits = [true; 7];
bits[0] = false;
for (index, value) in bits[1..6].iter_mut().enumerate() {
*value = (frame.code >> index) & 1 == 1;
}
let mut sums = [0.0; 3];
for k in 1..6 {
if bits[k - 1] != bits[k] || bits[k + 1] != bits[k] {
continue;
}
let mark_keyed = bits[k] != frame.reversed;
let first = (frame.t0 + (k as f64 + SNR_WINDOW.0) * bit).ceil();
let last = (frame.t0 + (k as f64 + SNR_WINDOW.1) * bit).floor();
if first < 0.0 || last < first {
continue;
}
for index in first as u64..=last as u64 {
let slot = (index % self.power_history.len() as u64) as usize;
let (stored, mark, space) = self.power_history[slot];
if stored != index {
continue;
}
let (keyed, other) = if mark_keyed {
(mark, space)
} else {
(space, mark)
};
sums[0] += keyed;
sums[1] += other;
sums[2] += 1.0;
}
}
if sums[2] > 0.0 {
for (total, value) in self.snr_sums.iter_mut().zip(sums) {
*total = *total * SNR_DECAY + value;
}
}
}
fn snr_db(&self) -> f64 {
let [keyed, other, count] = self.snr_sums;
if count <= 0.0 || other <= 0.0 {
return SNR_FLOOR_DB;
}
let noise = other / count;
let signal = keyed / count - noise;
if signal <= 0.0 {
return SNR_FLOOR_DB;
}
let ratio = signal / noise * self.noise_bandwidth_hz / SNR_REFERENCE_HZ;
(10.0 * ratio.log10()).clamp(SNR_FLOOR_DB, SNR_CEILING_DB)
}
fn tick(&mut self, index: f64) {
let frame_bits = 6.0 + self.config.profile.stop_bits.bits();
if index - self.last_character_index > 3.0 * frame_bits * self.samples_per_bit {
self.lock_score *= 0.85;
}
if self.config.afc && self.locked() && self.afc_weight > 0.0 {
let error_hz = self.afc_error / self.afc_weight * self.baseband_rate / TAU;
let range = self.config.afc_range_hz;
self.afc_offset_hz = (self.afc_offset_hz + 0.5 * error_hz).clamp(-range, range);
self.apply_center();
} else if !self.locked() && self.afc_offset_hz != 0.0 {
self.afc_offset_hz *= 0.9;
if self.afc_offset_hz.abs() < 0.05 {
self.afc_offset_hz = 0.0;
}
self.apply_center();
}
self.afc_error = 0.0;
self.afc_weight = 0.0;
}
fn report(&mut self, sink: &mut impl RttySink) {
let [me, se, mn, sn] = self.levels;
let ratio_db = |envelope: f64, noise: f64| {
if noise <= 1e-12 {
0.0
} else {
(20.0 * ((envelope - noise).max(1e-12) / noise).log10()).max(-30.0)
}
};
let mark_db = ratio_db(me, mn);
let space_db = ratio_db(se, sn);
let snr_db = self.snr_db();
sink.on_event(RttyDecodeEvent::Signal(RttySignal {
sample: self.input_index,
locked: self.locked(),
snr_db: snr_db as f32,
mark_db: mark_db as f32,
space_db: space_db as f32,
frequency_offset_hz: self.afc_offset_hz as f32,
reversed: self.framers[self.active_stream].reversed,
}));
}
}
#[derive(Debug)]
struct NoiseBlanker {
power: f64,
alpha: f64,
hold: usize,
hold_samples: usize,
episode: usize,
episode_energy: f64,
max_impulse_samples: usize,
}
impl NoiseBlanker {
fn new(sample_rate: f64) -> Self {
Self {
power: 0.0,
alpha: 1.0 / (BLANKER_AVERAGE_SECONDS * sample_rate).max(1.0),
hold: 0,
hold_samples: (BLANKER_HOLD_SECONDS * sample_rate).ceil() as usize,
episode: 0,
episode_energy: 0.0,
max_impulse_samples: (BLANKER_MAX_IMPULSE_SECONDS * sample_rate).ceil() as usize,
}
}
#[inline]
fn process(&mut self, sample: f64) -> f64 {
let energy = sample * sample;
if self.power > BLANKER_POWER_FLOOR
&& energy > BLANKER_THRESHOLD * BLANKER_THRESHOLD * self.power
{
if self.hold == 0 {
self.episode = 0;
self.episode_energy = 0.0;
}
self.hold = self.hold_samples;
}
if self.hold > 0 {
self.hold -= 1;
self.episode += 1;
self.episode_energy += energy;
if self.episode <= self.max_impulse_samples {
return 0.0;
}
self.power = self.episode_energy / self.episode as f64;
self.hold = 0;
}
self.power += (energy - self.power) * self.alpha;
sample
}
}
fn equivalent_noise_bandwidth(taps: &[f64], sample_rate: f64) -> f64 {
let sum: f64 = taps.iter().sum();
let energy: f64 = taps.iter().map(|tap| tap * tap).sum();
sample_rate * energy / (sum * sum).max(f64::MIN_POSITIVE)
}
fn build_framers(config: &RttyDecoderConfig, samples_per_bit: f64) -> Vec<Framer> {
let mut framers = Vec::new();
let frame_bits = 6.0 + config.profile.stop_bits.bits();
for lane in config.lanes.lanes() {
framers.push(Framer::new(lane, false, samples_per_bit, frame_bits));
if config.auto_reverse {
framers.push(Framer::new(lane, true, samples_per_bit, frame_bits));
}
}
framers
}
fn validate_config(config: &RttyDecoderConfig, sample_rate: u32) -> Result<()> {
config.profile.validate()?;
config.tones.validate(sample_rate)?;
config.profile.check_tones(&config.tones)?;
if config.lanes.lanes().is_empty() {
return Err(Error::InvalidConfiguration(
"at least one RTTY decision lane must be enabled",
));
}
if !config.squelch.is_finite() || !(0.0..=1.0).contains(&config.squelch) {
return Err(Error::InvalidConfiguration(
"RTTY squelch must be between 0 and 1",
));
}
if !config.afc_range_hz.is_finite() || !(0.0..=500.0).contains(&config.afc_range_hz) {
return Err(Error::InvalidConfiguration(
"RTTY AFC range must be between 0 and 500 Hz",
));
}
if !config.signal_report_seconds.is_finite()
|| !(0.01..=10.0).contains(&config.signal_report_seconds)
{
return Err(Error::InvalidConfiguration(
"RTTY signal report interval must be between 0.01 and 10 seconds",
));
}
Ok(())
}