124 lines
4.0 KiB
Rust
124 lines
4.0 KiB
Rust
const SYNC_LENGHT : usize = 40;
|
|
const SYNCA_SEQ : [bool; 40] = [false, false, false, false,
|
|
true, true, false, false, // Pulse 1
|
|
true, true, false, false, // Pulse 2
|
|
true, true, false, false, // Pulse 3
|
|
true, true, false, false, // Pulse 4
|
|
true, true, false, false, // Pulse 5
|
|
true, true, false, false, // Pulse 6
|
|
true, true, false, false, // Pulse 7
|
|
false, false, false, false,
|
|
false, false, false, false,];
|
|
|
|
const SYNCB_SEQ : [bool; 40] = [false, false, false, false,
|
|
true, true, true, false, false,
|
|
true, true, true, false, false,
|
|
true, true, true, false, false,
|
|
true, true, true, false, false,
|
|
true, true, true, false, false,
|
|
true, true, true, false, false,
|
|
true, true, true, false, false,
|
|
false];
|
|
|
|
|
|
pub enum SyncedSample {
|
|
Sample(f32),
|
|
SyncA(f32),
|
|
SyncB(f32)
|
|
}
|
|
|
|
pub struct APTSyncer<'a> {
|
|
state: [f32; SYNC_LENGHT],
|
|
pos : usize,
|
|
nones_read: usize,
|
|
max_level : f32,
|
|
min_level: f32,
|
|
iterator: Box<Iterator<Item=f32> + 'a>
|
|
}
|
|
|
|
impl<'a> APTSyncer<'a> {
|
|
pub fn from<I>(mut iterator: I) -> APTSyncer<'a> where I: Iterator<Item=f32> + 'a {
|
|
let mut state = [0.0; SYNC_LENGHT];
|
|
let mut max_level = 0.0;
|
|
let mut min_level = 1.0;
|
|
for i in 0..SYNC_LENGHT {
|
|
match iterator.next() {
|
|
Some(x) => {
|
|
state[i] = x;
|
|
max_level = 0.25 * x + max_level * 0.75;
|
|
min_level = 0.25 * x + min_level * 0.75;
|
|
},
|
|
None => panic!("Could not retrieve enough samples to prime syncer")
|
|
}
|
|
}
|
|
|
|
APTSyncer {
|
|
state: state,
|
|
pos: 0,
|
|
nones_read: 0,
|
|
max_level: max_level,
|
|
min_level: min_level,
|
|
iterator: Box::new(iterator)
|
|
}
|
|
}
|
|
|
|
fn is_marker(&mut self) -> (bool, bool) {
|
|
let mut count_a = 0;
|
|
let mut count_b = 0;
|
|
|
|
for i in 0..SYNC_LENGHT {
|
|
let sync_pos = (self.pos + i) % SYNC_LENGHT;
|
|
let sample = (self.state[sync_pos] - self.min_level) / (self.max_level - self.min_level);
|
|
if (sample > 0.5 && SYNCA_SEQ[i]) || (sample <= 0.5 && !SYNCA_SEQ[i]) {
|
|
count_a += 1;
|
|
}
|
|
if (sample > 0.5 && SYNCB_SEQ[i]) || (sample <= 0.5 && !SYNCB_SEQ[i]) {
|
|
count_b += 1;
|
|
}
|
|
|
|
/*
|
|
if !count_a && !count_b {
|
|
break;
|
|
}
|
|
*/
|
|
}
|
|
|
|
return (count_a > 35, count_b > 35);
|
|
}
|
|
}
|
|
|
|
impl<'a> Iterator for APTSyncer<'a> {
|
|
type Item = SyncedSample;
|
|
|
|
fn next(&mut self) -> Option<Self::Item> {
|
|
|
|
let (is_a, is_b) = self.is_marker();
|
|
|
|
let sample = self.state[self.pos];
|
|
match self.iterator.next() {
|
|
Some(x) => {
|
|
self.state[self.pos] = x;
|
|
self.max_level = 0.25 * x + self.max_level * 0.75;
|
|
self.min_level = 0.25 * x + self.min_level * 0.75;
|
|
},
|
|
None => self.nones_read += 1
|
|
};
|
|
|
|
if self.nones_read >= SYNC_LENGHT {
|
|
return None;
|
|
}
|
|
|
|
self.pos = (self.pos + 1) % SYNC_LENGHT;
|
|
|
|
if is_a {
|
|
return Some(SyncedSample::SyncA(sample));
|
|
}
|
|
else if is_b {
|
|
return Some(SyncedSample::SyncB(sample));
|
|
}
|
|
else {
|
|
return Some(SyncedSample::Sample(sample));
|
|
}
|
|
}
|
|
}
|