use rasterwave::rtty::{
RttyDecodeEvent, RttyDecoder, RttyDecoderConfig, RttyEncoder, RttyEncoderConfig, RttyIdle,
RttyLaneSet, RttyProfile, RttyTones, StopBits, decode_rtty, encode_rtty,
};
const TEXT: &str = "CQ CQ CQ DE BG5DRB BG5DRB PSE K\nRYRYRYRY THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG 0123456789 -/? 599 TU 73\n";
struct Noise(u64, Option<f64>);
impl Noise {
fn new(seed: u64) -> Self {
Self(seed | 1, None)
}
fn uniform(&mut self) -> f64 {
self.0 ^= self.0 << 13;
self.0 ^= self.0 >> 7;
self.0 ^= self.0 << 17;
(self.0 >> 11) as f64 / (1u64 << 53) as f64
}
fn gaussian(&mut self) -> f64 {
if let Some(value) = self.1.take() {
return value;
}
let u1 = self.uniform().max(1e-300);
let u2 = self.uniform();
let radius = (-2.0 * u1.ln()).sqrt();
let angle = std::f64::consts::TAU * u2;
self.1 = Some(radius * angle.sin());
radius * angle.cos()
}
}
fn add_noise(pcm: &[f32], sample_rate: u32, snr_db: f64, seed: u64) -> Vec<f32> {
let active: Vec<f32> = pcm.iter().copied().filter(|s| s.abs() > 1e-6).collect();
let signal_power =
active.iter().map(|s| f64::from(*s).powi(2)).sum::<f64>() / active.len().max(1) as f64;
let noise_in_band = signal_power / 10f64.powf(snr_db / 10.0);
let sigma = (noise_in_band * f64::from(sample_rate) / 2.0 / 3_000.0).sqrt();
let mut noise = Noise::new(seed);
pcm.iter()
.map(|s| (f64::from(*s) + sigma * noise.gaussian()) as f32)
.collect()
}
fn decoded_text(events: &[RttyDecodeEvent]) -> String {
events
.iter()
.filter_map(|event| match event {
RttyDecodeEvent::Character(c) => Some(c.ch),
_ => None,
})
.collect::<String>()
.replace('\r', "")
}
fn edit_distance(a: &str, b: &str) -> usize {
let a: Vec<char> = a.chars().collect();
let b: Vec<char> = b.chars().collect();
let mut row: Vec<usize> = (0..=b.len()).collect();
for i in 1..=a.len() {
let mut previous = row[0];
row[0] = i;
for j in 1..=b.len() {
let current = row[j];
row[j] = if a[i - 1] == b[j - 1] {
previous
} else {
1 + previous.min(row[j]).min(row[j - 1])
};
previous = current;
}
}
row[b.len()]
}
fn cer(expected: &str, actual: &str) -> f64 {
edit_distance(expected, actual) as f64 / expected.chars().count() as f64
}
fn silence(seconds: f64, rate: u32) -> Vec<f32> {
vec![0.0; (seconds * f64::from(rate)) as usize]
}
fn padded(mut pcm: Vec<f32>, rate: u32) -> Vec<f32> {
let mut out = silence(0.5, rate);
out.append(&mut pcm);
out.extend(silence(0.5, rate));
out
}
fn clean_round_trip(rate: u32, profile: RttyProfile, tones: RttyTones) -> String {
let pcm = encode_rtty(
TEXT,
rate,
RttyEncoderConfig {
profile,
tones,
..RttyEncoderConfig::default()
},
)
.unwrap();
let events = decode_rtty(
&padded(pcm, rate),
rate,
RttyDecoderConfig {
profile,
tones,
..RttyDecoderConfig::default()
},
)
.unwrap();
decoded_text(&events)
}
#[test]
fn clean_round_trip_at_common_sample_rates() {
for rate in [8_000, 12_000, 44_100, 48_000] {
let text = clean_round_trip(rate, RttyProfile::RTTY_45_170, RttyTones::default());
assert_eq!(text.trim_start(), TEXT, "rate {rate}");
}
}
#[test]
fn clean_round_trip_for_every_catalog_profile() {
for profile in [
RttyProfile::RTTY_45_170,
RttyProfile::RTTY_50_170,
RttyProfile::RTTY_75_170,
RttyProfile::RTTY_50_425,
RttyProfile::RTTY_50_850,
] {
let tones = RttyTones::from_center(1_700.0, profile.shift_hz, false);
let text = clean_round_trip(12_000, profile, tones);
assert_eq!(text.trim_start(), TEXT, "{profile:?}");
}
}
#[test]
fn decoding_is_chunk_size_invariant() {
let pcm = padded(
encode_rtty(TEXT, 12_000, RttyEncoderConfig::default()).unwrap(),
12_000,
);
let decode = |chunk: usize| {
let mut decoder = RttyDecoder::new(12_000, RttyDecoderConfig::default()).unwrap();
let mut events = Vec::new();
for part in pcm.chunks(chunk) {
decoder.push_f32(part, &mut events).unwrap();
}
decoder.finish(&mut events);
events
};
let reference = decode(4_096);
for chunk in [1, 7, 31, 127, 509, 1_024] {
assert_eq!(decode(chunk), reference, "chunk {chunk}");
}
}
#[test]
fn reversed_signal_is_decoded_by_auto_reverse() {
let tones = RttyTones::default();
let pcm = encode_rtty(
TEXT,
12_000,
RttyEncoderConfig {
tones: tones.reversed(),
..RttyEncoderConfig::default()
},
)
.unwrap();
let events = decode_rtty(&padded(pcm, 12_000), 12_000, RttyDecoderConfig::default()).unwrap();
assert!(cer(TEXT, decoded_text(&events).trim_start()) < 0.02);
let reversed = events
.iter()
.filter_map(|event| match event {
RttyDecodeEvent::Character(c) => Some(c.reversed),
_ => None,
})
.filter(|reversed| *reversed)
.count();
assert!(reversed > TEXT.len() / 2);
}
#[test]
fn frequency_offset_is_tolerated_and_tracked_by_afc() {
for offset in [-40.0, -20.0, 20.0, 40.0] {
let sent = RttyTones::new(2_125.0 + offset, 2_295.0 + offset);
let long_text = TEXT.repeat(2);
let pcm = encode_rtty(
&long_text,
12_000,
RttyEncoderConfig {
tones: sent,
..RttyEncoderConfig::default()
},
)
.unwrap();
let events =
decode_rtty(&padded(pcm, 12_000), 12_000, RttyDecoderConfig::default()).unwrap();
let text = decoded_text(&events);
assert!(
cer(&long_text, text.trim_start()) < 0.03,
"offset {offset}: {text}"
);
let last_offset = events
.iter()
.rev()
.find_map(|event| match event {
RttyDecodeEvent::Signal(signal) if signal.locked => {
Some(f64::from(signal.frequency_offset_hz))
}
_ => None,
})
.expect("decoder should lock");
assert!(
(last_offset - offset).abs() < 8.0,
"offset {offset} tracked {last_offset}"
);
}
}
#[test]
fn baud_rate_drift_is_tolerated() {
for baud in [45.0, 45.9] {
let profile = RttyProfile {
baud,
..RttyProfile::RTTY_45_170
};
let pcm = encode_rtty(
TEXT,
12_000,
RttyEncoderConfig {
profile,
..RttyEncoderConfig::default()
},
)
.unwrap();
let events =
decode_rtty(&padded(pcm, 12_000), 12_000, RttyDecoderConfig::default()).unwrap();
assert!(
cer(TEXT, decoded_text(&events).trim_start()) < 0.02,
"baud {baud}"
);
}
}
fn typed(text: &str, gap_bits: f64, config: RttyEncoderConfig, rate: u32) -> Vec<f32> {
let mut encoder = RttyEncoder::new(rate, config).unwrap();
let gap = (gap_bits * f64::from(rate) / config.profile.baud).round() as usize;
let char_samples = (config.profile.character_seconds() * f64::from(rate)).ceil() as usize;
let mut pcm = Vec::new();
let mut buffer = vec![0.0; char_samples * 2 + gap];
for ch in text.chars() {
encoder.push_text(&ch.to_string()).unwrap();
let n = encoder.read_samples(&mut buffer[..char_samples * 2 + gap]);
pcm.extend_from_slice(&buffer[..n]);
}
encoder.finish();
while !encoder.is_finished() {
let n = encoder.read_samples(&mut buffer);
pcm.extend_from_slice(&buffer[..n]);
}
pcm
}
#[test]
fn mark_idle_keyboard_sending_is_decoded() {
let text = "HELLO WORLD DE N0CALL 599 0123";
for stop_bits in [StopBits::One, StopBits::OnePointFive] {
for gap in [1.0, 2.0, 5.0, 12.0, 40.0] {
let config = RttyEncoderConfig {
profile: RttyProfile {
stop_bits,
..RttyProfile::RTTY_45_170
},
idle: RttyIdle::Mark,
..RttyEncoderConfig::default()
};
let pcm = padded(typed(text, gap, config, 12_000), 12_000);
let events = decode_rtty(&pcm, 12_000, RttyDecoderConfig::default()).unwrap();
assert_eq!(
decoded_text(&events).trim(),
text,
"gap {gap} stop {stop_bits:?}"
);
}
}
}
#[test]
fn diddle_idle_keyboard_sending_is_decoded() {
let text = "CQ TEST 5NN 001 TU";
for gap in [1.0, 10.0, 30.0] {
let pcm = padded(
typed(text, gap, RttyEncoderConfig::default(), 12_000),
12_000,
);
let events = decode_rtty(&pcm, 12_000, RttyDecoderConfig::default()).unwrap();
assert_eq!(decoded_text(&events).trim(), text, "gap {gap}");
}
}
#[test]
fn first_character_after_a_pause_is_kept() {
let rate = 12_000;
let mut pcm = encode_rtty("DE N0CALL K", rate, RttyEncoderConfig::default()).unwrap();
pcm.extend(silence(8.0, rate));
pcm.extend(encode_rtty("DE N0CALL K", rate, RttyEncoderConfig::default()).unwrap());
let events = decode_rtty(&padded(pcm, rate), rate, RttyDecoderConfig::default()).unwrap();
assert_eq!(decoded_text(&events).trim(), "DE N0CALL KDE N0CALL K");
}
#[test]
fn figures_survive_both_usos_settings() {
let text = "RST 599 599 NR 012 345";
let pcm = padded(
encode_rtty(text, 12_000, RttyEncoderConfig::default()).unwrap(),
12_000,
);
for usos in [true, false] {
let events = decode_rtty(
&pcm,
12_000,
RttyDecoderConfig {
usos,
..RttyDecoderConfig::default()
},
)
.unwrap();
assert_eq!(decoded_text(&events).trim(), text, "usos {usos}");
}
}
#[test]
fn finish_drains_filter_delay_and_rejects_more_input() {
let config = RttyEncoderConfig {
tail_ltrs: 0,
tail_mark_seconds: 0.0,
..RttyEncoderConfig::default()
};
let pcm = encode_rtty("CQ TEST", 12_000, config).unwrap();
let mut decoder = RttyDecoder::new(12_000, RttyDecoderConfig::default()).unwrap();
let mut events = Vec::new();
decoder.push_f32(&pcm, &mut events).unwrap();
decoder.finish(&mut events);
assert_eq!(decoded_text(&events), "CQ TEST");
assert!(decoder.push_f32(&[0.0], &mut events).is_err());
decoder.reset();
assert!(decoder.push_f32(&[0.0], &mut events).is_ok());
}
fn start_samples(events: &[RttyDecodeEvent]) -> Vec<u64> {
events
.iter()
.filter_map(|event| match event {
RttyDecodeEvent::Character(c) => Some(c.start_sample),
_ => None,
})
.collect()
}
#[test]
fn start_samples_follow_the_input_timeline() {
let rate = 12_000;
let config = RttyEncoderConfig {
preamble_mark_seconds: 0.2,
preamble_ltrs: 2,
..RttyEncoderConfig::default()
};
let mut encoder = RttyEncoder::new(rate, config).unwrap();
encoder.push_text("RYRY").unwrap();
encoder.finish();
let mut pcm = Vec::new();
let mut buffer = vec![0.0; 1000];
while !encoder.is_finished() {
let n = encoder.read_samples(&mut buffer);
pcm.extend_from_slice(&buffer[..n]);
}
let mut rendered = Vec::new();
encoder.drain_rendered(&mut rendered);
let lead = 10 * rate as usize;
let mut input = silence(10.0, rate);
input.extend_from_slice(&pcm);
input.extend(silence(0.5, rate));
let reference =
start_samples(&decode_rtty(&input, rate, RttyDecoderConfig::default()).unwrap());
let mut decoder = RttyDecoder::new(
rate,
RttyDecoderConfig {
tones: RttyTones::new(2_125.0, 2_325.0),
profile: RttyProfile {
shift_hz: 200.0,
..RttyProfile::RTTY_45_170
},
..RttyDecoderConfig::default()
},
)
.unwrap();
let mut events = Vec::new();
decoder.push_f32(&input[..lead / 2], &mut events).unwrap();
decoder.retune(RttyTones::default(), &mut events).unwrap();
decoder.push_f32(&input[lead / 2..], &mut events).unwrap();
decoder.finish(&mut events);
let retuned = start_samples(&events);
assert_eq!(reference.len(), 4);
assert_eq!(retuned.len(), 4);
for ((expected, a), b) in rendered.iter().zip(&reference).zip(&retuned) {
let truth = expected.start_sample + lead as u64;
assert!(truth.abs_diff(*a) < 40, "{truth} vs {a}");
assert!(truth.abs_diff(*b) < 40, "{truth} vs {b}");
}
}
#[test]
fn discontinuity_keeps_finished_characters_and_the_timeline() {
let rate = 12_000;
let pcm = padded(
encode_rtty("DE N0CALL", rate, RttyEncoderConfig::default()).unwrap(),
rate,
);
let mut decoder = RttyDecoder::new(rate, RttyDecoderConfig::default()).unwrap();
let mut events = Vec::new();
decoder.push_f32(&pcm, &mut events).unwrap();
decoder.mark_discontinuity(rate as u64, &mut events);
assert_eq!(decoded_text(&events).trim(), "DE N0CALL");
assert_eq!(
decoder.samples_consumed(),
pcm.len() as u64 + u64::from(rate)
);
let second = encode_rtty("K", rate, RttyEncoderConfig::default()).unwrap();
let before = events.len();
decoder.push_f32(&second, &mut events).unwrap();
decoder.finish(&mut events);
let starts = start_samples(&events[before..]);
assert_eq!(starts.len(), 1);
assert!(starts[0] > pcm.len() as u64 + u64::from(rate));
}
#[test]
fn noise_does_not_report_lock_or_drag_afc() {
let rate = 12_000;
let mut noise = Noise::new(11);
let pcm: Vec<f32> = (0..rate * 120)
.map(|_| (0.1 * noise.gaussian()) as f32)
.collect();
let events = decode_rtty(&pcm, rate, RttyDecoderConfig::default()).unwrap();
let signals: Vec<_> = events
.iter()
.filter_map(|event| match event {
RttyDecodeEvent::Signal(signal) => Some(*signal),
_ => None,
})
.collect();
let locked = signals.iter().filter(|signal| signal.locked).count();
assert!(
locked * 100 <= signals.len(),
"{locked} of {} locked",
signals.len()
);
let worst = signals
.iter()
.map(|signal| signal.frequency_offset_hz.abs())
.fold(0.0_f32, f32::max);
assert!(worst < 15.0, "AFC wandered {worst} Hz");
}
#[test]
#[ignore = "manual tuning report"]
fn report_squelch() {
for squelch in [0.15_f32, 0.2, 0.25, 0.3, 0.4] {
let rate = 12_000;
let mut noise = Noise::new(7);
let pcm: Vec<f32> = (0..rate * 60)
.map(|_| (0.1 * noise.gaussian()) as f32)
.collect();
let config = RttyDecoderConfig {
squelch,
..RttyDecoderConfig::default()
};
let garbage = decoded_text(&decode_rtty(&pcm, rate, config).unwrap())
.chars()
.count();
let weak: Vec<String> = [-6.0, -8.0, -10.0]
.iter()
.map(|snr| {
format!(
"{snr} dB {:.1}%",
100.0 * (1..=3).map(|seed| cer_at(*snr, config, seed)).sum::<f64>() / 3.0
)
})
.collect();
println!(
"squelch {squelch}: noise chars/min {garbage} | {}",
weak.join(" | ")
);
}
}
#[test]
fn noise_alone_is_squelched() {
let rate = 12_000;
let mut noise = Noise::new(7);
let pcm: Vec<f32> = (0..rate * 30)
.map(|_| (0.1 * noise.gaussian()) as f32)
.collect();
let events = decode_rtty(&pcm, rate, RttyDecoderConfig::default()).unwrap();
let garbage = decoded_text(&events);
assert!(
garbage.chars().count() < 15,
"{} chars: {garbage}",
garbage.len()
);
}
fn cer_at(snr_db: f64, config: RttyDecoderConfig, seed: u64) -> f64 {
let rate = 12_000;
let text = TEXT.repeat(3);
let pcm = padded(
encode_rtty(&text, rate, RttyEncoderConfig::default()).unwrap(),
rate,
);
let noisy = add_noise(&pcm, rate, snr_db, seed);
let events = decode_rtty(&noisy, rate, config).unwrap();
cer(&text, decoded_text(&events).trim())
}
#[test]
fn weak_signal_character_error_rate_thresholds() {
let config = RttyDecoderConfig::default();
for (snr, limit) in [(0.0, 0.02), (-6.0, 0.03), (-8.0, 0.1)] {
let value = (1..=3).map(|seed| cer_at(snr, config, seed)).sum::<f64>() / 3.0;
assert!(value <= limit, "CER {value:.4} at {snr} dB exceeds {limit}");
}
}
#[test]
#[ignore = "manual tuning report: cargo test --release --test rtty -- --ignored --nocapture"]
fn report_character_error_rate_curve() {
let variants = [
("all lanes", RttyLaneSet::ALL),
(
"atc only",
RttyLaneSet {
atc: true,
kahn: false,
mark_only: false,
space_only: false,
},
),
(
"atc+kahn",
RttyLaneSet {
atc: true,
kahn: true,
mark_only: false,
space_only: false,
},
),
(
"kahn only",
RttyLaneSet {
atc: false,
kahn: true,
mark_only: false,
space_only: false,
},
),
];
for (name, lanes) in variants {
let config = RttyDecoderConfig {
lanes,
squelch: 0.0,
..RttyDecoderConfig::default()
};
let row: Vec<String> = [0.0, -3.0, -6.0, -8.0, -10.0, -12.0]
.iter()
.map(|snr| {
let mean = (1..=6).map(|seed| cer_at(*snr, config, seed)).sum::<f64>() / 6.0;
format!("{snr:>5} dB {:>6.2}%", mean * 100.0)
})
.collect();
println!("{name:>10}: {}", row.join(" | "));
}
}
#[test]
fn interactive_encoder_feeds_decoder_while_streaming() {
let rate = 12_000;
let mut encoder = RttyEncoder::new(rate, RttyEncoderConfig::default()).unwrap();
let mut decoder = RttyDecoder::new(rate, RttyDecoderConfig::default()).unwrap();
let mut events = Vec::new();
let mut buffer = vec![0.0; 600];
let words = ["CQ ", "CQ ", "DE ", "BG5DRB ", "K"];
for word in words {
encoder.push_text(word).unwrap();
for _ in 0..8 {
let n = encoder.read_samples(&mut buffer);
decoder.push_f32(&buffer[..n], &mut events).unwrap();
}
}
encoder.finish();
while !encoder.is_finished() {
let n = encoder.read_samples(&mut buffer);
decoder.push_f32(&buffer[..n], &mut events).unwrap();
}
decoder.push_f32(&silence(0.5, rate), &mut events).unwrap();
decoder.finish(&mut events);
assert_eq!(decoded_text(&events).trim(), "CQ CQ DE BG5DRB K");
}
#[test]
#[ignore = "manual tuning report"]
fn report_confidence_distribution() {
let rate = 12_000;
let quantiles = |events: Vec<RttyDecodeEvent>| {
let mut values: Vec<f32> = events
.iter()
.filter_map(|e| match e {
RttyDecodeEvent::Character(c) => Some(c.confidence),
_ => None,
})
.collect();
values.sort_by(f32::total_cmp);
let q = |p: f64| {
values
.get(((values.len() as f64 - 1.0) * p) as usize)
.copied()
.unwrap_or(f32::NAN)
};
format!(
"n={} p10={:.4} p50={:.4} p90={:.4}",
values.len(),
q(0.1),
q(0.5),
q(0.9)
)
};
let config = RttyDecoderConfig {
squelch: 0.0,
..RttyDecoderConfig::default()
};
let mut noise = Noise::new(7);
let pcm: Vec<f32> = (0..rate * 60)
.map(|_| (0.1 * noise.gaussian()) as f32)
.collect();
println!(
"noise: {}",
quantiles(decode_rtty(&pcm, rate, config).unwrap())
);
for snr in [0.0, -6.0, -8.0, -10.0] {
let text = TEXT.repeat(3);
let pcm = padded(
encode_rtty(&text, rate, RttyEncoderConfig::default()).unwrap(),
rate,
);
let noisy = add_noise(&pcm, rate, snr, 1);
println!(
"{snr} dB: {}",
quantiles(decode_rtty(&noisy, rate, config).unwrap())
);
}
}
#[test]
fn silence_then_noise_does_not_print_garbage() {
let rate = 12_000;
let mut total = 0;
for seed in 1..=10 {
let mut noise = Noise::new(seed);
let mut pcm: Vec<f32> = (0..rate * 10)
.map(|_| (0.1 * noise.gaussian()) as f32)
.collect();
pcm.extend(silence(3.0, rate));
pcm.extend((0..rate * 3).map(|_| (0.1 * noise.gaussian()) as f32));
let events = decode_rtty(&pcm, rate, RttyDecoderConfig::default()).unwrap();
total += decoded_text(&events).chars().count();
}
assert!(total <= 5, "{total} garbage characters in 10 runs");
}
#[test]
fn changing_lanes_mid_stream_keeps_the_text() {
let rate = 12_000;
let pcm = padded(
encode_rtty(TEXT, rate, RttyEncoderConfig::default()).unwrap(),
rate,
);
let mut decoder = RttyDecoder::new(rate, RttyDecoderConfig::default()).unwrap();
let mut events = Vec::new();
for (index, chunk) in pcm.chunks(1_200).enumerate() {
decoder.push_f32(chunk, &mut events).unwrap();
let lanes = if index % 10 < 5 {
RttyLaneSet::default()
} else {
RttyLaneSet::ATC
};
decoder.set_lanes(lanes, true, &mut events).unwrap();
}
decoder.finish(&mut events);
assert!(
cer(TEXT, decoded_text(&events).trim_start()) < 0.03,
"{}",
decoded_text(&events)
);
}
#[test]
fn retune_to_a_new_shift_emits_finished_characters_first() {
let rate = 12_000;
let pcm = encode_rtty("DE N0CALL", rate, RttyEncoderConfig::default()).unwrap();
let mut decoder = RttyDecoder::new(rate, RttyDecoderConfig::default()).unwrap();
let mut events = Vec::new();
decoder.push_f32(&pcm, &mut events).unwrap();
decoder.push_f32(&silence(0.2, rate), &mut events).unwrap();
decoder
.retune(RttyTones::new(2_125.0, 2_550.0), &mut events)
.unwrap();
assert_eq!(decoded_text(&events).trim(), "DE N0CALL");
assert_eq!(decoder.config().profile.shift_hz, 425.0);
}
#[test]
fn tones_must_match_the_profile_shift() {
let config = RttyEncoderConfig {
profile: RttyProfile::RTTY_50_850,
..RttyEncoderConfig::default()
};
assert!(RttyEncoder::new(12_000, config).is_err());
let config = RttyDecoderConfig {
profile: RttyProfile::RTTY_50_850,
..RttyDecoderConfig::default()
};
assert!(RttyDecoder::new(12_000, config).is_err());
}
fn white_noise(seconds: f64, rate: u32, sigma: f64, noise: &mut Noise) -> Vec<f32> {
(0..(seconds * f64::from(rate)) as usize)
.map(|_| (sigma * noise.gaussian()) as f32)
.collect()
}
fn characters_after(pcm: &[f32], rate: u32, from: usize) -> usize {
decode_rtty(pcm, rate, RttyDecoderConfig::default())
.unwrap()
.iter()
.filter(|event| {
matches!(event, RttyDecodeEvent::Character(c) if c.start_sample as usize + 600 >= from)
})
.count()
}
#[test]
fn muted_gap_does_not_make_noise_look_like_a_signal() {
let rate = 12_000;
let sigma = 0.1;
let message = encode_rtty(
"RYRYRYRY CQ DE BG5DRB 599 TU QRZ",
rate,
RttyEncoderConfig::default(),
)
.unwrap();
let trials = 40;
let (mut continuous, mut after_noise, mut after_signal) = (0, 0, 0);
for seed in 0..trials {
let mut noise = Noise::new(1_000 + 2 * seed);
let pcm = white_noise(6.2, rate, sigma, &mut noise);
continuous += characters_after(&pcm, rate, rate as usize * 3 + 2_400);
let mut pcm = white_noise(3.0, rate, sigma, &mut noise);
pcm.extend(silence(0.2, rate));
let gap_end = pcm.len();
pcm.extend(white_noise(3.0, rate, sigma, &mut noise));
after_noise += characters_after(&pcm, rate, gap_end);
let mut pcm = add_noise(&message, rate, 6.0, 2 * seed + 1);
pcm.extend(silence(1.0, rate));
let gap_end = pcm.len();
pcm.extend(white_noise(3.0, rate, sigma, &mut noise));
after_signal += characters_after(&pcm, rate, gap_end);
}
println!(
"continuous {continuous}, noise-gap-noise {after_noise}, signal-gap-noise {after_signal}"
);
let limit = continuous + 4;
assert!(
after_noise <= limit && after_signal <= limit,
"garbage after a muted gap: noise {after_noise}, signal {after_signal}; continuous noise {continuous}"
);
}
fn signal_reports(events: &[RttyDecodeEvent]) -> Vec<rasterwave::rtty::RttySignal> {
events
.iter()
.filter_map(|event| match event {
RttyDecodeEvent::Signal(signal) => Some(*signal),
_ => None,
})
.collect()
}
#[test]
fn reported_snr_tracks_the_true_snr() {
let rate = 12_000;
let pcm = encode_rtty(&TEXT.repeat(2), rate, RttyEncoderConfig::default()).unwrap();
let mut previous = f64::NEG_INFINITY;
for snr in [-5.0, 0.0, 5.0, 10.0, 20.0, 30.0] {
let noisy = add_noise(&pcm, rate, snr, 3);
let reports =
signal_reports(&decode_rtty(&noisy, rate, RttyDecoderConfig::default()).unwrap());
let middle = &reports[reports.len() / 4..reports.len() * 3 / 4];
let mean = middle.iter().map(|s| f64::from(s.snr_db)).sum::<f64>() / middle.len() as f64;
println!("true {snr} dB -> reported {mean:.1} dB");
assert!(
(mean - snr).abs() <= 3.0,
"true {snr} dB reported as {mean:.1} dB"
);
assert!(mean > previous + 2.0, "not monotonic at {snr} dB");
previous = mean;
}
let mut noise = Noise::new(5);
let reports = signal_reports(
&decode_rtty(
&white_noise(20.0, rate, 0.1, &mut noise),
rate,
RttyDecoderConfig::default(),
)
.unwrap(),
);
let tail = &reports[reports.len() / 2..];
let mean = tail.iter().map(|s| f64::from(s.snr_db)).sum::<f64>() / tail.len() as f64;
assert!(mean < -10.0, "noise alone reads {mean:.1} dB");
let reports = signal_reports(
&decode_rtty(&silence(1.0, rate), rate, RttyDecoderConfig::default()).unwrap(),
);
assert!(reports.iter().all(|s| s.snr_db == -30.0));
}