bel/composer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

seq maintains state, pop returns changed, none is stop singing

Browse Source
This commit is contained in:
breel
2026-03-11 13:33:56 -06:00
parent f50a435200
commit acdac24d1a
2 changed files with 110 additions and 101 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
src/seq.rs
View File

@@ -4,14 +4,12 @@ use crate::syn;
pub struct SynSeq { pub struct SynSeq {
seq: Seq, seq: Seq,
syn: syn::Syn, syn: syn::Syn,
state: Option<tone::Tone>,
} }
pub fn new_syn(syn: syn::Syn) -> SynSeq { pub fn new_syn(syn: syn::Syn) -> SynSeq {
SynSeq{ SynSeq{
seq: new(), seq: new(),
syn: syn, syn: syn,
state: None,
} }
} }
@@ -21,13 +19,13 @@ impl SynSeq {
} }
pub fn render(&mut self, left: &mut [f32], right: &mut [f32]) { pub fn render(&mut self, left: &mut [f32], right: &mut [f32]) {
let state = self.state.clone();
match self.seq.pop() { match self.seq.pop() {
Some(tone) if (state.is_none() || tone != state.unwrap()) => { (Some(tone), changed) if changed => {
self.syn.set(tone.clone()); self.syn.set(0, Some(tone.clone()));
self.state = Some(tone); },
(None, changed) if changed => {
self.syn.set(0, None);
}, },
None => { self.state = None; },
_ => {}, _ => {},
}; };
self.syn.render(left, right); self.syn.render(left, right);
@@ -41,6 +39,7 @@ impl SynSeq {
#[derive(PartialEq)] #[derive(PartialEq)]
pub struct Seq { pub struct Seq {
beats: Vec<(i32, tone::Tone)>, beats: Vec<(i32, tone::Tone)>,
state: Option<tone::Tone>,
} }
fn new() -> Seq { fn new() -> Seq {
@@ -51,10 +50,20 @@ impl Seq {
fn new() -> Seq { fn new() -> Seq {
Seq{ Seq{
beats: vec![], beats: vec![],
state: None,
} }
} }
fn pop(&mut self) -> Option<tone::Tone> { fn pop(&mut self) -> (Option<tone::Tone>, bool) {
let state_before = self.state.clone();
let tone_after = self._pop();
if state_before != tone_after {
self.state = tone_after.clone();
}
(tone_after, self.state != state_before)
}
fn _pop(&mut self) -> Option<tone::Tone> {
match self.beats.len() { match self.beats.len() {
0 => None, 0 => None,
_ => match self.beats[0].0 { _ => match self.beats[0].0 {
@@ -105,14 +114,15 @@ mod test {
assert_eq!(seq.beats[2], (1 as i32, tone::new("g"))); assert_eq!(seq.beats[2], (1 as i32, tone::new("g")));
assert_eq!(seq.beats[3], (2 as i32, tone::new("e"))); assert_eq!(seq.beats[3], (2 as i32, tone::new("e")));
assert_eq!(seq.pop(), Some(tone::new("c"))); assert_eq!(seq.pop(), (Some(tone::new("c")), true));
for _ in 0..4 { assert_eq!(seq.pop(), (Some(tone::new("d")), true));
assert_eq!(seq.pop(), Some(tone::new("d"))); for _ in 1..4 {
assert_eq!(seq.pop(), (Some(tone::new("d")), false));
} }
assert_eq!(seq.pop(), Some(tone::new("g"))); assert_eq!(seq.pop(), (Some(tone::new("g")), true));
for _ in 0..2 { assert_eq!(seq.pop(), (Some(tone::new("e")), true));
assert_eq!(seq.pop(), Some(tone::new("e"))); assert_eq!(seq.pop(), (Some(tone::new("e")), false));
} assert_eq!(seq.pop(), (None, true));
assert_eq!(seq.pop(), None); assert_eq!(seq.pop(), (None, false));
} }
} }

169
src/syn.rs
View File

@@ -6,88 +6,87 @@ use std::sync::Arc;
use crate::tone; use crate::tone;
pub enum Syn { pub enum Syn {
Real(Synthesizer), Real(Synthesizer),
Text{ Text{
m: std::collections::HashMap<i32, std::collections::HashMap<i32, i32>>, m: std::collections::HashMap<i32, std::collections::HashMap<i32, i32>>,
i: u32, i: u32,
}, },
} }
impl Syn { impl Syn {
pub fn new(debug: bool, sound_font: String, sample_rate: usize) -> Syn { pub fn new(debug: bool, sound_font: String, sample_rate: usize) -> Syn {
match debug { match debug {
false => Syn::new_real(sound_font, sample_rate), false => Syn::new_real(sound_font, sample_rate),
true => Syn::Text{m: std::collections::HashMap::new(), i: 0}, true => Syn::Text{m: std::collections::HashMap::new(), i: 0},
} }
} }
fn new_real(sound_font: String, sample_rate: usize) -> Syn { fn new_real(sound_font: String, sample_rate: usize) -> Syn {
let mut sf2 = std::fs::File::open(sound_font).unwrap(); let mut sf2 = std::fs::File::open(sound_font).unwrap();
let sound_font = Arc::new(SoundFont::new(&mut sf2).unwrap()); let sound_font = Arc::new(SoundFont::new(&mut sf2).unwrap());
let settings = SynthesizerSettings::new(sample_rate as i32); let settings = SynthesizerSettings::new(sample_rate as i32);
let synthesizer = Synthesizer::new(&sound_font, &settings).unwrap(); let synthesizer = Synthesizer::new(&sound_font, &settings).unwrap();
Syn::Real(synthesizer) Syn::Real(synthesizer)
} }
pub fn set(&mut self, b: tone::Tone) { pub fn set(&mut self, ch: i32, b: Option<tone::Tone>) {
let a = 0 as i32; match self {
match self { // channel=[0..16)
// channel=[0..16) // velocity=[0..128)
// velocity=[0..128) Syn::Real(syn) => {
Syn::Real(syn) => { syn.note_off_all_channel(ch, false);
syn.note_off_all_channel(a, false); },
}, Syn::Text{m, ..} => {
Syn::Text{m, ..} => { m.remove(&ch);
m.clear(); },
}, };
}; if let Some(tone) = b {
self.tone_on(b); self.tone_on(ch, tone);
} };
}
fn tone_on(&mut self, b: tone::Tone) { fn tone_on(&mut self, ch: i32, b: tone::Tone) {
let a = 0 as i32; match self {
match self { // channel=[0..16)
// channel=[0..16) // velocity=[0..128)
// velocity=[0..128) Syn::Real(syn) => syn.note_on(ch, b.i32(), 127),
Syn::Real(syn) => syn.note_on(a, b.i32(), 127), Syn::Text{m, ..} => {
Syn::Text{m, ..} => { match m.get_mut(&ch) {
match m.get_mut(&a) { Some(m2) => { m2.insert(b.i32(), 127); },
Some(m2) => { m2.insert(b.i32(), 127); }, None => {
None => { let mut m2 = std::collections::HashMap::new();
let mut m2 = std::collections::HashMap::new(); m2.insert(b.i32(), 127);
m2.insert(b.i32(), 127); m.insert(ch, m2);
m.insert(a, m2); },
}, };
}; },
}, };
}; }
}
fn tone_off(&mut self, b: tone::Tone) { fn tone_off(&mut self, ch: i32, b: tone::Tone) {
let a = 0 as i32; match self {
match self { Syn::Real(syn) => syn.note_off(ch, b.i32()),
Syn::Real(syn) => syn.note_off(a, b.i32()), Syn::Text{m, ..} => {
Syn::Text{m, ..} => { match m.get_mut(&ch) {
match m.get_mut(&a) { Some(m) => { m.remove(&b.i32()); },
Some(m) => { m.remove(&b.i32()); }, None => {},
None => {}, };
};
}, },
}; };
} }
pub fn render(&mut self, a: &mut [f32], b: &mut [f32]) { pub fn render(&mut self, a: &mut [f32], b: &mut [f32]) {
match self { match self {
Syn::Real(syn) => syn.render(a, b), Syn::Real(syn) => syn.render(a, b),
Syn::Text{m, i} => { Syn::Text{m, i} => {
eprintln!("{} | render[{}]({:?})", chrono::prelude::Utc::now(), i, m); eprintln!("{} | render[{}]({:?})", chrono::prelude::Utc::now(), i, m);
*i += 1; *i += 1;
}, },
}; };
} }
} }
#[cfg(test)] #[cfg(test)]
@@ -96,29 +95,29 @@ mod test {
#[test] #[test]
fn test_new_real() { fn test_new_real() {
let mut syn = Syn::new(false, "super_small_font.sf2".to_string(), 44100); let mut syn = Syn::new(false, "super_small_font.sf2".to_string(), 44100);
syn.tone_on(tone::new("c")); syn.tone_on(0, tone::new("c"));
syn.tone_on(tone::new("d")); syn.tone_on(0, tone::new("d"));
syn.tone_off(tone::new("d")); syn.tone_off(0, tone::new("d"));
let mut buffer1 = Vec::<f32>::new(); let mut buffer1 = Vec::<f32>::new();
let mut buffer2 = Vec::<f32>::new(); let mut buffer2 = Vec::<f32>::new();
syn.render(&mut buffer1, &mut buffer2); syn.render(&mut buffer1, &mut buffer2);
} }
#[test] #[test]
fn test_text() { fn test_text() {
let mut syn = Syn::new(true, ".sf2".to_string(), 1); let mut syn = Syn::new(true, ".sf2".to_string(), 1);
syn.tone_on(tone::new("c")); syn.tone_on(0, tone::new("c"));
syn.tone_on(tone::new("d")); syn.tone_on(0, tone::new("d"));
syn.tone_off(tone::new("d")); syn.tone_off(0, tone::new("d"));
let mut buffer1 = Vec::<f32>::new(); let mut buffer1 = Vec::<f32>::new();
let mut buffer2 = Vec::<f32>::new(); let mut buffer2 = Vec::<f32>::new();
syn.render(&mut buffer1, &mut buffer2); syn.render(&mut buffer1, &mut buffer2);
} }
} }