boring

Cargo.lock

@@ -242,6 +242,7 @@ dependencies = [
  "chrono",
  "clap",
  "env_logger",
+ "io-prompt-prototype",
  "itertools 0.14.0",
  "midir",
  "regex",
@@ -412,6 +413,12 @@ dependencies = [
  "hashbrown",
 ]
 
+[[package]]
+name = "io-prompt-prototype"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca9d71ad6b790f2522eeb0a4f207fa7ef21826777d4714c7ff09483bf17b0ab8"
+
 [[package]]
 name = "is_terminal_polyfill"
 version = "1.70.2"

Cargo.toml

@@ -7,6 +7,7 @@ edition = "2024"
 chrono = "0.4.44"
 clap = { version = "4.5.60", features = ["derive"] }
 env_logger = "0.11.9"
+io-prompt-prototype = "1.0.0"
 itertools = "0.14.0"
 midir = "0.10.3"
 regex = "1.12.3"

src/flags.rs

@@ -5,6 +5,9 @@ pub struct Flags {
     #[arg(short, long, default_value_t = false)]
     pub debug: bool,
 
+    #[arg(short, long, default_value_t = false)]
+    pub interactive: bool,
+
     #[arg(long, default_value_t = 120)]
     pub bpm: usize,
 
@@ -14,8 +17,8 @@ pub struct Flags {
     #[arg(long, default_value = "super_small_font.sf2")]
     pub sound_font: String,
 
-    #[arg(short, long, default_value = "c 2e+")]
+    #[arg(short, long, default_value = "c 2*e+")]
-    pub play: Option<String>,
+    pub play: Vec<String>,
 }
 
 impl Flags {

src/main.rs

@@ -1,49 +1,78 @@
+use io_prompt_prototype::prompt;
 use itertools::Itertools;
 
 mod flags;
+mod parse;
+mod player;
+mod seq;
 mod syn;
 mod tone;
-mod seq;
 
 fn main() {
-    let flags = flags::Flags::new();
+    let mut flags = flags::Flags::new();
-
+    if flags.debug {
-    let mut syn_seq = seq::new_syn(syn::Syn::new(
+        eprintln!("{:?}", flags);
-        flags.debug,
+    }
-        flags.sound_font,
+    if flags.interactive {
-        flags.sample_rate,
+        flags.play = vec![];
-    ));
-    if let Some(play) = flags.play {
-      syn_seq.append(play);
     }
 
-    play(syn_seq, flags.sample_rate, flags.bpm);
+    let once = flags.play.iter().filter(|x| x.len() > 0).count() > 0;
-}
+    let mut player = player::new(flags.sample_rate.clone(), flags.bpm.clone());
-
+    loop {
-fn play(mut s: seq::SynSeq, sample_rate: usize, bpm: usize) {
+        play_with_flags(&flags, &mut player);
-    let samples_per_beat = sample_rate / bpm * 60;
+        if once {
-    let params = tinyaudio::prelude::OutputDeviceParameters {
+            break;
-        channels_count: 2,
-        sample_rate: sample_rate,
-        channel_sample_count: samples_per_beat,
-    };
-    let beats = s.beats();
-    let duration = 1 + 60 * beats / bpm;
-
-    let sample_count = (params.channel_sample_count) as usize;
-    let mut left: Vec<f32> = vec![0_f32; sample_count];
-    let mut right: Vec<f32> = vec![0_f32; sample_count];
-
-    let _device = tinyaudio::prelude::run_output_device(params, {
-        move |data| {
-            s.render(&mut left[..], &mut right[..]); // put in a state of rendering the next loop of these notes
-            for (i, value) in left.iter().interleave(right.iter()).enumerate() {
-                data[i] = *value;
-            }
         }
-    })
+    }
-    .unwrap();
+}
-
+
-    // Wait it out
+fn play_with_flags(flags: &flags::Flags, player: &mut player::Player) {
-    std::thread::sleep(std::time::Duration::from_secs(duration as u64));
+    let mut syn_seq = seq::new_syn(syn::Syn::new(
+        flags.debug.clone(),
+        flags.sound_font.clone(),
+        flags.sample_rate.clone(),
+    ));
+
+    let mut i = 0;
+    for p in flags.play.iter() {
+        for p in parse::new(p.clone()) {
+            syn_seq.append(i as i32, p);
+            i += 1;
+        }
+    }
+
+    let sync = i > 0;
+    if !sync {
+        let mut to_break = false;
+        let mut payload = vec![];
+        loop {
+            let mut s: String = prompt!("> ").parse().expect("failed to readline");
+            s = s.split_whitespace().join(" ");
+            payload.push(s.clone());
+            match s.as_ref() {
+                "" => match to_break {
+                    false => {
+                        to_break = true;
+                    }
+                    true => {
+                        break;
+                    }
+                },
+                _ => {
+                    to_break = false;
+                }
+            };
+        }
+
+        for p in parse::new(payload.join("\n")) {
+            syn_seq.append(i as i32, p);
+            i += 1;
+        }
+    }
+
+    match sync {
+        true => player.play(syn_seq),
+        false => player.play_async(syn_seq),
+    };
 }

src/parse.rs

@@ -0,0 +1,119 @@
+use std::io::Read;
+
+pub fn new<S: ToString>(s: S) -> Vec<String> {
+    parse(from_string(s.to_string()))
+}
+
+fn from_string(s: String) -> String {
+    match std::fs::File::open(s.clone()) {
+        Ok(mut reader) => {
+            let mut content = String::new();
+            reader
+                .read_to_string(&mut content)
+                .expect(format!("failed to read {}", s).as_ref());
+            content
+        }
+        Err(_) => s,
+    }
+}
+
+fn parse(s: String) -> Vec<String> {
+    let s = s
+        .split("\n")
+        .filter(|x: &&str| {
+            !x // doesnt start with #
+                .split_whitespace()
+                .collect::<Vec<_>>()
+                .join("")
+                .starts_with("#")
+        })
+        .map(|x| {
+            x.split("#")
+                .take(1) // drop after #
+                .collect::<Vec<_>>()
+                .join("")
+                .split_whitespace()
+                .collect::<Vec<_>>()
+                .join(" ")
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+    let mut channels = vec![];
+    let lines = s.split("\n").collect::<Vec<_>>();
+    let mut j = 0;
+    for i in 0..lines.len() {
+        match lines[i] {
+            "" => {
+                j = 0;
+            }
+            _ => {
+                while channels.len() <= j {
+                    channels.push("".to_string());
+                }
+                channels[{
+                    let tmp = j;
+                    j += 1;
+                    tmp
+                }] += &(" ".to_string() + lines[i]);
+            }
+        };
+    }
+    channels
+        .iter()
+        .map(|x| x.split_whitespace().collect::<Vec<_>>().join(" "))
+        .collect()
+}
+
+#[cfg(test)]
+mod test {
+    #[test]
+    fn test_string() {
+        assert_eq!(super::new("a b c")[0], "a b c".to_string());
+        assert_eq!(super::new("a b c".to_string())[0], "a b c".to_string());
+    }
+
+    #[test]
+    fn test_single_line_file() {
+        assert_eq!(
+            super::new("src/testdata/single_line_file.txt")[0],
+            "a b c".to_string()
+        );
+    }
+
+    #[test]
+    fn test_two_channels_one_bar() {
+        assert_eq!(
+            super::new("src/testdata/two_channels_one_bar.txt")[0],
+            "2*a 2*b 2*c".to_string()
+        );
+        assert_eq!(
+            super::new("src/testdata/two_channels_one_bar.txt")[1],
+            ". a5 . b5 . c5".to_string()
+        );
+    }
+
+    #[test]
+    fn test_two_channels_two_bars() {
+        assert_eq!(
+            super::new("src/testdata/two_channels_two_bars.txt")[0],
+            "a b c d e f".to_string()
+        );
+        assert_eq!(
+            super::new("src/testdata/two_channels_two_bars.txt")[1],
+            "2*a 2*b 2*c 2*d 2*e 2*f".to_string()
+        );
+    }
+
+    #[test]
+    fn drop_comment_lines() {
+        assert_eq!(
+            super::new("# hello\n # world\na b c")[0],
+            "a b c".to_string()
+        );
+    }
+
+    #[test]
+    fn drop_comment_trailer() {
+        assert_eq!(super::new("a b c # hello world")[0], "a b c".to_string());
+    }
+}

src/player.rs

@@ -0,0 +1,61 @@
+use itertools::Itertools;
+
+use crate::seq;
+
+pub struct Player {
+    bpm: usize,
+    params: tinyaudio::OutputDeviceParameters,
+    device: Option<tinyaudio::OutputDevice>,
+}
+
+pub fn new(sample_rate: usize, bpm: usize) -> Player {
+    let samples_per_beat = sample_rate / bpm * 60;
+    Player {
+        bpm: bpm,
+        params: tinyaudio::prelude::OutputDeviceParameters {
+            channels_count: 2,
+            sample_rate: sample_rate,
+            channel_sample_count: samples_per_beat,
+        },
+        device: None,
+    }
+}
+
+impl Player {
+    pub fn play(&mut self, s: seq::SynSeq) {
+        self.play_with_sync(s, true);
+    }
+
+    pub fn play_async(&mut self, s: seq::SynSeq) {
+        self.play_with_sync(s, false);
+    }
+
+    fn play_with_sync(&mut self, mut s: seq::SynSeq, sync: bool) {
+        let sample_count = (self.params.channel_sample_count) as usize;
+        let mut left: Vec<f32> = vec![0_f32; sample_count];
+        let mut right: Vec<f32> = vec![0_f32; sample_count];
+
+        let beats = s.beats() + 3;
+        let duration = 60 * beats / self.bpm;
+
+        if self.device.is_some() {
+            self.device.as_mut().expect("lost device").close();
+        }
+        self.device = Some(
+            tinyaudio::prelude::run_output_device(self.params, {
+                move |data| {
+                    s.render(&mut left[..], &mut right[..]); // put in a state of rendering the next loop of these notes
+                    for (i, value) in left.iter().interleave(right.iter()).enumerate() {
+                        data[i] = *value;
+                    }
+                }
+            })
+            .unwrap(),
+        );
+
+        if sync {
+            // Wait it out
+            std::thread::sleep(std::time::Duration::from_secs(duration as u64));
+        }
+    }
+}

src/seq.rs

@@ -1,128 +1,171 @@
-use crate::tone;
 use crate::syn;
+use crate::tone;
 
 pub struct SynSeq {
-   seq: Seq,
+    seqs: std::collections::HashMap<i32, Seq>,
-   syn: syn::Syn,
+    syn: syn::Syn,
 }
 
 pub fn new_syn(syn: syn::Syn) -> SynSeq {
-   SynSeq{
+    SynSeq {
-      seq: new(),
+        seqs: std::collections::HashMap::new(),
-      syn: syn,
+        syn: syn,
-   }
+    }
 }
 
 impl SynSeq {
-   pub fn append<S: ToString>(&mut self, s: S) {
+    pub fn append<S: ToString>(&mut self, ch: i32, s: S) {
-      self.seq.append(s);
+        match self.seqs.get_mut(&ch) {
-   }
+            Some(seq) => seq.append(s),
+            None => {
+                let mut seq = new();
+                seq.append(s);
+                self.seqs.insert(ch, seq);
+            }
+        };
+    }
 
-   pub fn render(&mut self, left: &mut [f32], right: &mut [f32]) {
+    pub fn render(&mut self, left: &mut [f32], right: &mut [f32]) {
-      match self.seq.pop() {
+        for (ch, seq) in self.seqs.iter_mut() {
-         (Some(tone), changed) if changed => {
+            let ch = ch.clone();
-            self.syn.set(0, Some(tone.clone()));
+            match seq.pop() {
-         },
+                (Some(tone), changed) if changed => self.syn.set(ch, Some(tone.clone())),
-         (None, changed) if changed => {
+                (None, changed) if changed => {
-            self.syn.set(0, None);
+                    self.syn.set(ch, None);
-         },
+                }
-         _ => {},
+                _ => {}
-      };
+            };
-      self.syn.render(left, right);
+        }
-   }
+        self.syn.render(left, right);
+    }
 
-   pub fn beats(&self) -> usize {
+    pub fn beats(&self) -> usize {
-      self.seq.beats.len()
+        let mut longest = 0 as usize;
-   }
+        for (_, seq) in self.seqs.iter() {
+            longest = if seq.len() > longest {
+                seq.len()
+            } else {
+                longest
+            };
+        }
+        longest
+    }
 }
 
 #[derive(PartialEq)]
 pub struct Seq {
-   beats: Vec<(i32, tone::Tone)>,
+    beats: Vec<(usize, tone::Tone)>,
-   state: Option<tone::Tone>,
+    had_more: bool,
+    eof: bool,
 }
 
 fn new() -> Seq {
-   Seq::new()
+    Seq::new()
 }
 
 impl Seq {
-   fn new() -> Seq {
+    fn new() -> Seq {
-      Seq{
+        Seq {
-         beats: vec![],
+            beats: vec![],
-         state: None,
+            had_more: false,
-      }
+            eof: false,
-   }
+        }
+    }
 
-   fn pop(&mut self) -> (Option<tone::Tone>, bool) {
+    fn len(&self) -> usize {
-      let state_before = self.state.clone();
+        let mut sum = 0 as usize;
-      let tone_after = self._pop();
+        for beat in self.beats.iter() {
-      if state_before != tone_after {
+            sum += beat.0 as usize;
-         self.state = tone_after.clone();
+        }
-      }
+        sum
-      (tone_after, self.state != state_before)
+    }
-   }
 
-   fn _pop(&mut self) -> Option<tone::Tone> {
+    fn pop(&mut self) -> (Option<tone::Tone>, bool) {
-      match self.beats.len() {
+        let mut changed = !self.had_more && self.beats.len() > 0;
-         0 => None,
+        self.had_more = match self.beats.len() {
-         _ => match self.beats[0].0 {
+            0 => false,
-            1 => Some(self.beats.remove(0).1),
+            _ => self.beats[0].0 > 1,
-            _ => {
+        };
-               self.beats[0].0 -= 1;
+        let eof_before = self.eof;
-               Some(self.beats[0].1.clone())
+        self.eof = self.beats.len() == 0;
+        if !eof_before && self.eof {
+            changed = true;
+        }
+        let tone = self._pop();
+        (tone, changed)
+    }
+
+    fn _pop(&mut self) -> Option<tone::Tone> {
+        match self.beats.len() {
+            0 => None,
+            _ => match self.beats[0].0 {
+                1 => Some(self.beats.remove(0).1),
+                _ => {
+                    self.beats[0].0 -= 1;
+                    Some(self.beats[0].1.clone())
+                }
             },
-         },
+        }
-      }
+    }
-   }
 
-   fn append<S: ToString>(&mut self, s: S) {
+    fn append<S: ToString>(&mut self, s: S) {
-      let s: String = s.to_string();
+        let s: String = s.to_string();
-      let s: &str = s.as_ref();
+        let s: &str = s.as_ref();
-      for split in s.split_whitespace() {
+        for split in s.split_whitespace() {
-         self.append_one(split.to_string());
+            self.append_one(split.to_string());
-      }
+        }
-   }
+    }
 
-   fn append_one(&mut self, s: String) {
+    fn append_one(&mut self, s: String) {
-      let re = regex::Regex::new(r"^(?<count>[0-9]*)(?<tone>[a-z].*)$").unwrap();
+        let re = regex::Regex::new(r"^((?<count>[0-9]+)\*)?(?<tone>.*)$").unwrap();
-      let captures = re.captures(&s).unwrap();
+        let captures = re.captures(&s).unwrap();
 
-      let n = match captures.name("count") {
+        let n = match captures.name("count") {
-         Some(number) if number.as_str().len() > 0 => number.as_str().parse::<usize>().unwrap(),
+            Some(number) if number.as_str().len() > 0 => number.as_str().parse::<usize>().unwrap(),
-         _ => 1,
+            _ => 1,
-      } as i32;
+        } as usize;
 
-      let tone = tone::new(captures.name("tone").unwrap().as_str());
+        let tone_s = captures.name("tone").unwrap().as_str();
-      self.beats.push((n, tone));
+        let tone = tone::new(tone_s);
-   }
+        self.beats.push((n, tone));
+    }
 }
 
 #[cfg(test)]
 mod test {
-   use super::*;
+    use super::*;
 
-   #[test]
+    #[test]
-   fn test_seq() {
+    fn test_seq() {
-      let mut seq = new();
+        let mut seq = new();
-      seq.append("c");
-      seq.append("4d");
-      seq.append("g 2e");
-      assert_eq!(seq.beats.len(), 4);
-      assert_eq!(seq.beats[0], (1 as i32, tone::new("c")));
-      assert_eq!(seq.beats[1], (4 as i32, tone::new("d")));
-      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.pop(), (Some(tone::new("c")), true));
+        seq.append("c c");
-      assert_eq!(seq.pop(), (Some(tone::new("d")), true));
+        seq.append("4*d");
-      for _ in 1..4 {
+        seq.append("2*-");
-         assert_eq!(seq.pop(), (Some(tone::new("d")), false));
+        seq.append("g 2*e");
-      }
+
-      assert_eq!(seq.pop(), (Some(tone::new("g")), true));
+        assert_eq!(seq.beats.len(), 6);
-      assert_eq!(seq.pop(), (Some(tone::new("e")), true));
+        assert_eq!(seq.len(), 11);
-      assert_eq!(seq.pop(), (Some(tone::new("e")), false));
+
-      assert_eq!(seq.pop(), (None, true));
+        assert_eq!(seq.beats[0], (1 as usize, tone::new("c")));
-      assert_eq!(seq.pop(), (None, false));
+        assert_eq!(seq.beats[1], (1 as usize, tone::new("c")));
-   }
+        assert_eq!(seq.beats[2], (4 as usize, tone::new("d")));
+        assert_eq!(seq.beats[3], (2 as usize, tone::new("!")));
+        assert_eq!(seq.beats[4], (1 as usize, tone::new("g")));
+        assert_eq!(seq.beats[5], (2 as usize, tone::new("e")));
+
+        assert_eq!(seq.pop(), (Some(tone::new("c")), true));
+        assert_eq!(seq.pop(), (Some(tone::new("c")), true));
+        assert_eq!(seq.pop(), (Some(tone::new("d")), true));
+        for _ in 1..4 {
+            assert_eq!(seq.pop(), (Some(tone::new("d")), false));
+        }
+        assert_eq!(seq.pop(), (Some(tone::new(".")), true));
+        assert_eq!(seq.pop(), (Some(tone::new("?")), false));
+        assert_eq!(seq.pop(), (Some(tone::new("g")), true));
+        assert_eq!(seq.pop(), (Some(tone::new("e")), true));
+        assert_eq!(seq.pop(), (Some(tone::new("e")), false));
+        assert_eq!(seq.pop(), (None, true), "shouldve newly had no more");
+        assert_eq!(seq.pop(), (None, false), "shouldve still had no more");
+    }
 }

src/syn.rs

@@ -1,123 +1,125 @@
-use rustysynth::Synthesizer;
 use rustysynth::SoundFont;
+use rustysynth::Synthesizer;
 use rustysynth::SynthesizerSettings;
 use std::sync::Arc;
 
 use crate::tone;
 
 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 {
-   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, ch: i32, b: Option<tone::Tone>) {
+    pub fn set(&mut self, ch: i32, b: Option<tone::Tone>) {
-      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(ch, false);
-         },
+            }
-         Syn::Text{m, ..} => {
+            Syn::Text { m, .. } => {
-            m.remove(&ch);
+                m.remove(&ch);
-         },
+            }
-      };
+        };
-      if let Some(tone) = b {
+        if let Some(tone) = b {
-         self.tone_on(ch, tone);
+            self.tone_on(ch, tone);
-      };
+        };
-   }
+    }
 
-   fn tone_on(&mut self, ch: i32, b: tone::Tone) {
+    fn tone_on(&mut self, ch: i32, b: tone::Tone) {
-      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(ch, b.i32(), 127),
-         Syn::Text{m, ..} => {
+            Syn::Text { m, .. } => {
-            match m.get_mut(&ch) {
+                match m.get_mut(&ch) {
-               Some(m2) => { m2.insert(b.i32(), 127); },
+                    Some(m2) => {
-               None => {
+                        m2.insert(b.i32(), 127);
-                  let mut m2 = std::collections::HashMap::new();
+                    }
-                  m2.insert(b.i32(), 127);
+                    None => {
-                  m.insert(ch, m2);
+                        let mut m2 = std::collections::HashMap::new();
-               },
+                        m2.insert(b.i32(), 127);
-            };
+                        m.insert(ch, m2);
-         },
+                    }
-      };
+                };
-   }
+            }
+        };
+    }
 
-   fn tone_off(&mut self, ch: i32, b: tone::Tone) {
+    pub fn render(&mut self, a: &mut [f32], b: &mut [f32]) {
-      match self {
+        match self {
-         Syn::Real(syn) => syn.note_off(ch, b.i32()),
+            Syn::Real(syn) => syn.render(a, b),
-         Syn::Text{m, ..} => {
+            Syn::Text { m, i } => {
-            match m.get_mut(&ch) {
+                eprintln!(
-               Some(m) => { m.remove(&b.i32()); },
+                    "{} | render[{}]({:?})",
-               None => {},
+                    chrono::prelude::Utc::now(),
-            };
+                    i,
-
+                    m.iter()
-         },
+                        .map(|tuple| (
-      };
+                            tuple.0,
-   }
+                            tuple
-
+                                .1
-   pub fn render(&mut self, a: &mut [f32], b: &mut [f32]) {
+                                .iter()
-      match self {
+                                .map(|v| tone::new(v.0.to_string()).string())
-         Syn::Real(syn) => syn.render(a, b),
+                                .collect::<Vec<_>>()
-         Syn::Text{m, i} => {
+                        ))
-            eprintln!("{} | render[{}]({:?})", chrono::prelude::Utc::now(), i, m);
+                        .collect::<Vec<_>>(),
-            *i += 1;
+                );
-         },
+                *i += 1;
-      };
+            }
-   }
+        };
+    }
 }
 
 #[cfg(test)]
 mod test {
-   use super::*;
+    use super::*;
 
-   #[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(0, tone::new("c"));
+        syn.tone_on(0, tone::new("c"));
-     syn.tone_on(0, tone::new("d"));
+        syn.tone_on(0, tone::new("d"));
 
-     syn.tone_off(0, tone::new("d"));
+        let mut buffer1 = Vec::<f32>::new();
+        let mut buffer2 = Vec::<f32>::new();
+        syn.render(&mut buffer1, &mut buffer2);
+    }
 
-     let mut buffer1 = Vec::<f32>::new();
+    #[test]
-     let mut buffer2 = Vec::<f32>::new();
+    fn test_text() {
-     syn.render(&mut buffer1, &mut buffer2);
+        let mut syn = Syn::new(true, ".sf2".to_string(), 1);
-   }
 
-   #[test]
+        syn.tone_on(0, tone::new("c"));
-   fn test_text() {
+        syn.tone_on(0, tone::new("d"));
-     let mut syn = Syn::new(true, ".sf2".to_string(), 1);
 
-     syn.tone_on(0, tone::new("c"));
+        let mut buffer1 = Vec::<f32>::new();
-     syn.tone_on(0, tone::new("d"));
+        let mut buffer2 = Vec::<f32>::new();
-
+        syn.render(&mut buffer1, &mut buffer2);
-     syn.tone_off(0, tone::new("d"));
+    }
-
-     let mut buffer1 = Vec::<f32>::new();
-     let mut buffer2 = Vec::<f32>::new();
-     syn.render(&mut buffer1, &mut buffer2);
-   }
 }

src/testdata/battle_against_a_true_hero.txt

@@ -0,0 +1,9 @@
+# https://www.musicnotes.com/sheetmusic/chrissy-ricker/battle-against-a-true-hero-easy/MN0235808
+# c major
+
+CM4 CM5 CM5 CM1 CM1 CM2 . .
+
+CM3 CM0 CM0 CM4 CM4 .   . .
+
+CM4 CM5 CM5 CM1 CM1 CM2 . .
+

src/testdata/chord_progressions.txt

@@ -0,0 +1,12 @@
+# x+0 x+5 x+7 x+0
+CM0 CM3 CM4 CM0
+
+.
+
+# x+2 x+7 x+0
+CM1 CM4 CM0
+
+.
+
+# x+0 x+7 x+9 x+5
+CM0 CM4 CM5 CM3

src/testdata/fifth_wheel.txt

@@ -0,0 +1,5 @@
+# fifth wheel = +7 semitones
+# f -> c -> g -> d -> a -> e -> b
+
+f  c  g  d  a  e  b
+ff cf gf df af ef bf

src/testdata/major_chord_progressions.txt

@@ -0,0 +1,19 @@
+CM0  CM3  CM4  CM0
+CM0T CM3T CM4T CM0T
+CM0f CM3f CM4f CM0f
+
+.
+.
+.
+
+CM1  CM4  CM0
+CM1T CM4T CM0T
+CM1f CM4f CM0f
+
+.
+.
+.
+
+CM0  CM4  CM5  CM3
+CM0T CM4T CM5T CM3T
+CM0f CM4f CM5f CM3f

src/testdata/major_chords.txt

@@ -0,0 +1,27 @@
+# major CHORD = root + major_third + perfect_fifth
+# c = c,e,g
+
+f
+a
+c
+
+c
+e
+g
+
+g
+b
+d
+
+d
+f+
+a
+
+a
+c+
+e
+
+e
+g+
+b
+

src/testdata/major_third.txt

@@ -0,0 +1,18 @@
+# major third
+# +2 letters (the third letter) with exactly 2 sharps between
+
+# c,e c+,f d,f+
+c   c+   d
+cT  c+T  dT
+
+# d+,g e,g+ f,a
+d+  e  f
+d+T eT fT
+
+# f+,a+ g,b g+,c
+f+  g  g+
+f+T gT g+T
+
+# a,c+ a+,d b,d+
+a     a+    b
+aT    a+T   bT

src/testdata/minor_chords.txt

@@ -0,0 +1,27 @@
+# minor CHORD = root + minor_third + perfect_fifth
+# c = c,e-,g
+
+f
+g+
+c
+
+c
+e-
+g
+
+g
+a+
+d
+
+d
+f
+a
+
+a
+c
+e
+
+e
+g
+b
+

src/testdata/minor_third.txt

@@ -0,0 +1,18 @@
+# minor third
+# +2 letters (the third letter) with exactly 1 half step between
+
+# c,e- c+,e d,f
+c  c+  d
+ct c+t dt
+
+# d+,f+ e,g f,g+
+d+  e  f
+d+t et ft
+
+# f+,a g,a+ g+,b
+f+  g  g+
+f+t gt g+t
+
+# a,c a+,c+ b,d
+a  a+  b
+at a+t bt

src/testdata/plus_three_sounds_nice.txt

@@ -0,0 +1,12 @@
+#CM0 CM3 CM4 CM0
+#CM1 CM4 CM0
+#CM0 CM4 CM5 CM3
+
+# 1 4 6 4 # pop101
+#GM0 GM3 GM5 GM3
+
+60
+63
+66
+69
+72

src/testdata/sandbox.txt

@@ -0,0 +1,12 @@
+#CM0 CM3 CM4 CM0
+#CM1 CM4 CM0
+#CM0 CM4 CM5 CM3
+
+# 1 4 6 4 # pop101
+#GM0 GM3 GM5 GM3
+
+60
+63
+66
+69
+72

src/testdata/single_line_file.txt

@@ -0,0 +1 @@
+a b c

src/testdata/two_channels_one_bar.txt

@@ -0,0 +1,2 @@
+2*a 2*b 2*c
+. a5 . b5 . c5

src/testdata/two_channels_two_bars.txt

@@ -0,0 +1,5 @@
+a b c
+2*a 2*b 2*c
+
+d e f
+2*d 2*e 2*f

src/tone.rs

@@ -3,69 +3,239 @@ pub struct Tone(i32);
 
 // new parses [a-g][+-]?[1-5]? to tone, sharp or flat, down 2 octave..up 1 octave
 pub fn new<S: ToString>(s: S) -> Tone {
-   Tone::new(s.to_string())
+    Tone::new(s.to_string())
 }
 
 impl Tone {
-   fn new(s: String) -> Tone {
+    fn new(s: String) -> Tone {
-      let re = regex::Regex::new(r"^((?<letter>^[a-g])(?<sharpness>[+-]?)(?<octave>[1-5]?)|(?<numeric>[0-9]+))$").unwrap();
+        let re = regex::Regex::new(r"^(((?<letter>^[a-g])(?<sharpness>[+-]?)|(?<major>[A-G]M[0-6])|(?<minor>[A-G]m[0-6]))(?<octave>[1-5]?)((?<major_third>T)|(?<minor_third>t)|(?<fifth>f))?|(?<numeric>[0-9]+)|(?<rest>[^a-gA-G0-9]))$").unwrap();
-      let captures = re.captures(s.as_ref()).unwrap();
+        let captures = re
-      Tone (match captures.name("numeric") {
+            .captures(&s)
-         Some(number) => number.as_str().parse::<i32>().unwrap(),
+            .expect(format!("tone '{}' does not match regex", s).as_ref());
-         None => {
+        Tone(match captures.name("numeric") {
-            let mut result = match captures.name("letter").unwrap().as_str() {
+            Some(number) => number.as_str().parse::<i32>().unwrap(),
-               "a" => 57,
+            None => match captures.name("rest") {
-               "b" => 59,
+                Some(_) => 0,
-               "c" => 60,
+                _ => {
-               "d" => 62,
+                    let mut result = match captures.name("letter") {
-               "e" => 64,
+                        Some(letter) => Tone::char_to_middle_i32(letter.as_str()),
-               "f" => 65,
+                        None => match captures.name("major") {
-               _ => 67,
+                            Some(major) => {
-            } as i32;
+                                Tone::char_to_middle_i32(&major.as_str()[..1])
+                                    + match &major.as_str()[2..] {
+                                        "0" => 0,
+                                        "1" => 2,
+                                        "2" => 4,
+                                        "3" => 5,
+                                        "4" => 7,
+                                        "5" => 9,
+                                        _ => 11,
+                                    }
+                            }
+                            None => {
+                                let minor = captures.name("minor").unwrap();
+                                Tone::char_to_middle_i32(&minor.as_str()[..1])
+                                    + match &minor.as_str()[2..] {
+                                        "0" => 0,
+                                        "1" => 2,
+                                        "2" => 3,
+                                        "3" => 5,
+                                        "4" => 7,
+                                        "5" => 8,
+                                        _ => 10,
+                                    }
+                            }
+                        },
+                    } as i32;
 
-            result += match captures.name("sharpness") {
+                    result += match captures.name("sharpness") {
-               Some(sharpness) => match sharpness.as_str() {
+                        Some(sharpness) => match sharpness.as_str() {
-                  "+" => 1,
+                            "+" => 1,
-                  "-" => -1,
+                            "-" => -1,
-                  _ => 0,
+                            _ => 0,
-               },
+                        },
-               None => 0,
+                        None => 0,
-            } as i32;
+                    } as i32;
 
-            result += match captures.name("octave") {
+                    result += match captures.name("octave") {
-               Some(octave) => match octave.as_str() {
+                        Some(octave) => match octave.as_str() {
-                  "" => 0,
+                            "" => 0,
-                  _ => (octave.as_str().parse::<i32>().unwrap() - 3) * 12,
+                            _ => (octave.as_str().parse::<i32>().unwrap() - 3) * 12,
-               },
+                        },
-               None => 0,
+                        None => 0,
-            } as i32;
+                    } as i32;
 
-            result
+                    result += match captures.name("major_third") {
-         },
+                        Some(_) => 4, // TODO not all are good
-      })
+                        None => 0,
-   }
+                    } as i32;
 
-   pub fn i32(&self) -> i32 {
+                    result += match captures.name("minor_third") {
-      self.0
+                        Some(_) => 3, // TODO not all are good
-   }
+                        None => 0,
+                    } as i32;
+
+                    result += match captures.name("fifth") {
+                        Some(_) => 7,
+                        None => 0,
+                    } as i32;
+
+                    result
+                }
+            },
+        })
+    }
+
+    fn char_to_middle_i32(c: &str) -> i32 {
+        match c.to_lowercase().as_str() {
+            "a" => 57,
+            "b" => 59,
+            "c" => 60,
+            "d" => 62,
+            "e" => 64,
+            "f" => 65,
+            _ => 67,
+        }
+    }
+
+    pub fn i32(&self) -> i32 {
+        self.0
+    }
+
+    pub fn string(&self) -> String {
+        let v = self.i32();
+        let modifier = if v > 0 && v < 57 {
+            "-"
+        } else if v >= 69 {
+            "+"
+        } else {
+            ""
+        };
+        modifier.to_string()
+            + match v {
+                45 | 57 | 69 => "a",
+                46 | 58 | 70 => "a+",
+                47 | 59 | 71 => "b",
+                48 | 60 | 72 => "c",
+                49 | 61 | 73 => "c+",
+                50 | 62 | 74 => "d",
+                51 | 63 | 75 => "d+",
+                52 | 64 | 76 => "e",
+                53 | 65 | 77 => "f",
+                54 | 66 | 78 => "f+",
+                55 | 67 | 79 => "g",
+                56 | 68 | 80 => "g+",
+                0 => " ",
+                _ => "?",
+            }
+    }
 }
 
 #[cfg(test)]
 mod test {
-   #[test]
+    #[test]
-   fn test_tone_new() {
+    fn test_tone_new() {
-      assert_eq!(super::new("60").i32(), 60);
+        eprintln!("numeric");
+        assert_eq!(super::new("60").i32(), 60);
 
-      assert_eq!(super::new("c").i32(), 60);
+        eprintln!("rests");
-      assert_eq!(super::new("e").i32(), 64);
+        assert_eq!(super::new("-").i32(), 0);
-      assert_eq!(super::new("g").i32(), 67);
+        assert_eq!(super::new(".").i32(), 0);
 
-      assert_eq!(super::new("c+").i32(), 60+1);
+        eprintln!("alpha");
-      assert_eq!(super::new("c-").i32(), 60-1);
+        assert_eq!(super::new("c").i32(), 60);
+        assert_eq!(super::new("e").i32(), 64);
+        assert_eq!(super::new("g").i32(), 67);
 
-      assert_eq!(super::new("c3").i32(), 60);
+        eprintln!("alpha mod");
-      assert_eq!(super::new("c4").i32(), 60+12);
+        assert_eq!(super::new("c+").i32(), 60 + 1);
+        assert_eq!(super::new("c-").i32(), 60 - 1);
 
-      assert_eq!(super::new("c+4").i32(), 60+12+1);
+        eprintln!("alpha octave");
-   }
+        assert_eq!(super::new("c3").i32(), 60);
+        assert_eq!(super::new("c4").i32(), 60 + 12);
+
+        eprintln!("alpha mod octave");
+        assert_eq!(super::new("c+4").i32(), 60 + 12 + 1);
+    }
+
+    #[test]
+    fn test_tone_new_major_third() {
+        assert_eq!(super::new("cT").i32(), 60 + 4);
+        assert_eq!(super::new("c1T").i32(), 60 + 4 - 24);
+
+        assert_eq!(super::new("c+T").i32(), 60 + 1 + 4);
+        assert_eq!(super::new("c+1T").i32(), 60 + 1 + 4 - 24);
+
+        assert_eq!(super::new("CM0T").i32(), 60 + 4);
+        assert_eq!(super::new("CM01T").i32(), 60 + 4 - 24);
+    }
+
+    #[test]
+    fn test_tone_new_minor_third() {
+        assert_eq!(super::new("ct").i32(), 60 + 3);
+        assert_eq!(super::new("c1t").i32(), 60 + 3 - 24);
+
+        assert_eq!(super::new("c+t").i32(), 60 + 1 + 3);
+        assert_eq!(super::new("c+1t").i32(), 60 + 1 + 3 - 24);
+
+        assert_eq!(super::new("CM0t").i32(), 60 + 3);
+        assert_eq!(super::new("CM01t").i32(), 60 + 3 - 24);
+    }
+
+    #[test]
+    fn test_tone_new_fifth() {
+        assert_eq!(super::new("cf").i32(), 60 + 7);
+        assert_eq!(super::new("c1f").i32(), 60 + 7 - 24);
+
+        assert_eq!(super::new("c+f").i32(), 60 + 1 + 7);
+        assert_eq!(super::new("c+1f").i32(), 60 + 1 + 7 - 24);
+
+        assert_eq!(super::new("CM0f").i32(), 60 + 7);
+        assert_eq!(super::new("CM01f").i32(), 60 + 7 - 24);
+    }
+
+    #[test]
+    fn test_tone_c_major() {
+        assert_eq!(super::new("CM0"), super::new("c"));
+        assert_eq!(super::new("CM1"), super::new("d"));
+        assert_eq!(super::new("CM2"), super::new("e"));
+        assert_eq!(super::new("CM3"), super::new("f"));
+        assert_eq!(super::new("CM4"), super::new("g"));
+        assert_eq!(super::new("CM5"), super::new("a4"));
+        assert_eq!(super::new("CM6"), super::new("b4"));
+    }
+
+    #[test]
+    fn test_tone_c_minor() {
+        assert_eq!(super::new("Cm0"), super::new("c"));
+        assert_eq!(super::new("Cm1"), super::new("d"));
+        assert_eq!(super::new("Cm2"), super::new("e-"));
+        assert_eq!(super::new("Cm3"), super::new("f"));
+        assert_eq!(super::new("Cm4"), super::new("g"));
+        assert_eq!(super::new("Cm5"), super::new("a-4"));
+        assert_eq!(super::new("Cm6"), super::new("b-4"));
+    }
+
+    #[test]
+    fn test_tone_a_major() {
+        assert_eq!(super::new("AM0"), super::new("a"));
+        assert_eq!(super::new("AM1"), super::new("b"));
+        assert_eq!(super::new("AM2"), super::new("c+"));
+        assert_eq!(super::new("AM3"), super::new("d"));
+        assert_eq!(super::new("AM4"), super::new("e"));
+        assert_eq!(super::new("AM5"), super::new("f+"));
+        assert_eq!(super::new("AM6"), super::new("g+"));
+    }
+
+    #[test]
+    fn test_tone_a_minor() {
+        assert_eq!(super::new("Am0"), super::new("a"));
+        assert_eq!(super::new("Am1"), super::new("b"));
+        assert_eq!(super::new("Am2"), super::new("c"));
+        assert_eq!(super::new("Am3"), super::new("d"));
+        assert_eq!(super::new("Am4"), super::new("e"));
+        assert_eq!(super::new("Am5"), super::new("f"));
+        assert_eq!(super::new("Am6"), super::new("g"));
+    }
 }

todo.yaml

@@ -0,0 +1,9 @@
+todo:
+- can output .wav
+- can output .midi
+scheduled: []
+done: 
+- change define offset instead of only c==60
+- change change offset instead of only c==60 in file
+- can choose minor/major/other scale
+- can change minor/major/other scale in file