misc: refactors

algorithmiker · algorithmiker · commit 4c3b21136701 · 2025-03-27T18:47:01.000+01:00
diff --git a/src/backend/midi/mod.rs b/src/backend/midi/mod.rs
@@ -7,8 +7,8 @@ use midly::{
 
 use super::{Backend, BackendResult};
 use crate::parser::parser::{parse, ParseResult};
-use crate::parser::tab_element::TabElement3;
-use crate::parser::tab_element::TabElement3::Fret;
+use crate::parser::tab_element::TabElement;
+use crate::parser::tab_element::TabElement::Fret;
 use crate::{debugln, time};
 
 const BPM: u32 = 80;
@@ -94,14 +94,14 @@ fn convert_to_midi(parsed: &ParseResult) -> Vec<Vec<TrackEvent<'static>>> {
                 tracks[track].push(note_on);
                 tracks[track].push(note_off);
             }
-            TabElement3::Rest => delta_carry_on[track] += LENGTH_OF_EIGHTH.into(),
-            TabElement3::Bend
-            | TabElement3::HammerOn
-            | TabElement3::Pull
-            | TabElement3::Release
-            | TabElement3::Slide
-            | TabElement3::DeadNote
-            | TabElement3::Vibrato => (),
+            TabElement::Rest => delta_carry_on[track] += LENGTH_OF_EIGHTH.into(),
+            TabElement::Bend
+            | TabElement::HammerOn
+            | TabElement::Pull
+            | TabElement::Release
+            | TabElement::Slide
+            | TabElement::DeadNote
+            | TabElement::Vibrato => (),
         }
     }
     tracks.iter_mut().for_each(|x| {
diff --git a/src/backend/muxml/mod.rs b/src/backend/muxml/mod.rs
@@ -6,7 +6,7 @@ pub mod settings;
 use crate::backend::errors::backend_error::BackendError;
 use crate::parser::parser;
 use crate::parser::parser::{source_location_from_stream, ParseResult};
-use crate::parser::tab_element::TabElement3;
+use crate::parser::tab_element::TabElement;
 use crate::{
     backend::{Backend, BackendResult},
     debugln, rlen, time, traceln,
@@ -53,37 +53,32 @@ pub enum Muxml2TabElement {
     Invalid,
 }
 
+#[inline(always)]
+fn write_rest(buf: &mut impl std::fmt::Write, mut x: u32) -> std::fmt::Result {
+    while x != 0 {
+        for bound in [(8, "whole"), (4, "half"), (2, "quarter"), (1, "eighth")] {
+            if x >= bound.0 {
+                write_muxml2_rest(buf, bound.1, bound.0 as u8)?;
+                x -= bound.0;
+            }
+        }
+    }
+    Ok(())
+}
+
 impl Muxml2TabElement {
     fn write_muxml<A: std::fmt::Write>(
         &self, parsed: &ParseResult, buf: &mut A,
         note_properties: &HashMap<u32, NoteProperties, impl std::hash::BuildHasher>,
     ) -> std::fmt::Result {
         match self {
-            Muxml2TabElement::Rest(mut x) => {
-                while x != 0 {
-                    if x >= 8 {
-                        write_muxml2_rest(buf, "whole", 8)?;
-                        x -= 8;
-                    } else if x >= 4 {
-                        write_muxml2_rest(buf, "half", 4)?;
-                        x -= 4;
-                    } else if x >= 2 {
-                        write_muxml2_rest(buf, "quarter", 2)?;
-                        x -= 2;
-                    } else {
-                        debug_assert_eq!(x, 1);
-                        write_muxml2_rest(buf, "eighth", 1)?;
-                        x -= 1;
-                    }
-                }
-                Ok(())
-            }
+            Muxml2TabElement::Rest(x) => write_rest(buf, *x),
             Muxml2TabElement::CopyTick(tick_idx) => {
                 let note_range = *tick_idx as usize..=(*tick_idx as usize + 5);
                 let notes_iter = parsed.tick_stream[note_range]
                     .iter()
                     .enumerate()
-                    .filter(|x| !matches!(x.1, TabElement3::Rest))
+                    .filter(|x| !matches!(x.1, TabElement::Rest))
                     .map(|(x, y)| (x + *tick_idx as usize, y));
                 // at least two notes here
                 let tick_chord = notes_iter.clone().take(2).count() == 2;
@@ -95,37 +90,19 @@ impl Muxml2TabElement {
                 let mut chord_first_written = false;
                 for (elem_idx, elem) in notes_iter {
                     let need_chord = tick_chord && chord_first_written;
-                    traceln!(depth = 1, "elem={elem:?}@{elem_idx} chord flag: {need_chord}");
+                    chord_first_written = true;
 
-                    match elem {
-                        TabElement3::Fret(x) => {
-                            chord_first_written = true;
-                            let note =
-                                get_fretboard_note2(parsed.base_notes[elem_idx % 6], *x).unwrap();
-                            let (step, octave, sharp) = note.step_octave_sharp();
-                            let properties = note_properties.get(&(elem_idx as u32));
-                            write_muxml2_note(
-                                buf, step, octave, sharp, need_chord, false, properties,
-                            )?;
-                        }
-                        TabElement3::DeadNote => {
-                            chord_first_written = true;
-                            let note =
-                                get_fretboard_note2(parsed.base_notes[elem_idx % 6], 0).unwrap();
-                            let (step, octave, sharp) = note.step_octave_sharp();
-                            let properties = note_properties.get(&(elem_idx as u32));
-                            write_muxml2_note(
-                                buf, step, octave, sharp, need_chord, true, properties,
-                            )?;
-                        }
-                        TabElement3::Rest => unreachable!(),
-                        TabElement3::Bend
-                        | TabElement3::HammerOn
-                        | TabElement3::Pull
-                        | TabElement3::Release
-                        | TabElement3::Slide
-                        | TabElement3::Vibrato => {}
-                    }
+                    let Some((dead, fret)) = (match elem {
+                        TabElement::DeadNote => Some((true, 0)),
+                        TabElement::Fret(x) => Some((false, *x)),
+                        _ => None,
+                    }) else {
+                        continue;
+                    };
+                    let note = get_fretboard_note2(parsed.base_notes[elem_idx % 6], fret).unwrap();
+                    let (step, octave, sharp) = note.step_octave_sharp();
+                    let properties = note_properties.get(&(elem_idx as u32));
+                    write_muxml2_note(buf, step, octave, sharp, need_chord, dead, properties)?;
                 }
 
                 Ok(())
@@ -174,16 +151,11 @@ pub enum Vibrato {
     Start,
     Stop,
 }
+
 fn gen_muxml2(
     parse_time: Duration, mut parsed: ParseResult,
     settings: <MuxmlBackend as Backend>::BackendSettings,
 ) -> (Option<String>, BackendResult) {
-    // status of the project:
-    // parser3 is mostly done and works well and fast,
-    // but the codegen backends need to be adapted
-    // muxml2 especially, as it can be made much faster
-    // since, especially with std::simd, comparing the next 6 ticks against a TabElem3::Rest should be trivial
-    //     (with a splat-compare)
     let mut r = BackendResult::new(vec![], None, Some(parse_time), None);
     let number_of_measures = parsed.measures.len();
     let mut document = String::from(MUXML_INCOMPLETE_DOC_PRELUDE);
@@ -197,7 +169,7 @@ fn gen_muxml2(
     let mut note_properties: HashMap<u32, NoteProperties, FxBuildHasher> = HashMap::default();
     for measure_idx in 0..number_of_measures {
         traceln!("Muxml2: processing measure {}", measure_idx);
-        let ticks_in_measure = rlen(&parsed.measures[measure_idx].data_range) / 6; // see assumption 2
+        let ticks_in_measure = rlen(&parsed.measures[measure_idx].data_range) / 6;
         debug_assert!(rlen(&parsed.measures[measure_idx].data_range) % 6 == 0);
         // Length of actual content in measure. `remove_space_between_notes` will reduce this for
         // example
@@ -215,25 +187,22 @@ fn gen_muxml2(
             //    "current elem: {elem:?}, note_count: {note_count}, proc_cnt = {stream_proc_cnt}"
             //);
             match elem {
-                TabElement3::Fret(..) | TabElement3::DeadNote => {
-                    note_count += 1;
-                }
-                TabElement3::Rest => {}
-                TabElement3::Vibrato => {
-                    let last_idx = stream_idx.saturating_sub(6);
-                    note_properties.entry(last_idx as u32).or_default().vibrato =
-                        Some(Vibrato::Start);
+                TabElement::Fret(..) | TabElement::DeadNote => note_count += 1,
+                TabElement::Rest => {}
+                TabElement::Vibrato => {
+                    let last_idx = stream_idx.saturating_sub(6) as u32;
+                    note_properties.entry(last_idx).or_default().vibrato = Some(Vibrato::Start);
                     let next_idx = stream_idx + 6;
                     if next_idx >= parsed.tick_stream.len() {
-                        parsed.tick_stream.extend([const { TabElement3::Rest }; 6]);
+                        parsed.tick_stream.extend([const { TabElement::Rest }; 6]);
                     }
                     note_properties.entry(next_idx as u32).or_default().vibrato =
                         Some(Vibrato::Stop);
                 }
-                TabElement3::Bend
-                | TabElement3::HammerOn
-                | TabElement3::Pull
-                | TabElement3::Release => {
+                TabElement::Bend
+                | TabElement::HammerOn
+                | TabElement::Pull
+                | TabElement::Release => {
                     // TODO: eventually mark hammerOns and pulls
                     let last_idx = stream_idx.saturating_sub(6);
                     traceln!(
@@ -248,27 +217,27 @@ fn gen_muxml2(
                     match &parsed.tick_stream.get(next_idx) {
                         None => {
                             traceln!("hanging bend on {stream_idx} at stream end");
-                            let TabElement3::Fret(x) = parsed.tick_stream[last_idx] else {
+                            let TabElement::Fret(x) = parsed.tick_stream[last_idx] else {
                                 let (line, char) =
                                     source_location_from_stream(&parsed, stream_idx as u32);
                                 r.err = Some(BackendError::bend_on_invalid(line, char));
                                 return (None, r);
                             };
 
-                            parsed.tick_stream.extend([const { TabElement3::Rest }; 6]);
-                            parsed.tick_stream[next_idx] = TabElement3::Fret(x + 1);
+                            parsed.tick_stream.extend([const { TabElement::Rest }; 6]);
+                            parsed.tick_stream[next_idx] = TabElement::Fret(x + 1);
                             let entry = note_properties.entry(next_idx as u32).or_default();
                             entry.slurs.push(Slur::stop(slur_cnt));
                         }
                         // since we know that with a "hanging bend" the next element in this track is going to be a rest, we can just silently replace it and add the correct note
-                        Some(TabElement3::Rest) => {
-                            let TabElement3::Fret(x) = parsed.tick_stream[last_idx] else {
+                        Some(TabElement::Rest) => {
+                            let TabElement::Fret(x) = parsed.tick_stream[last_idx] else {
                                 let (line, char) =
                                     source_location_from_stream(&parsed, stream_idx as u32);
                                 r.err = Some(BackendError::bend_on_invalid(line, char));
                                 return (None, r);
                             };
-                            parsed.tick_stream[next_idx] = TabElement3::Fret(x + 1);
+                            parsed.tick_stream[next_idx] = TabElement::Fret(x + 1);
                             traceln!(
                                 "hanging bend on {stream_idx}, replacing {next_idx} with a Fret"
                             );
@@ -283,7 +252,7 @@ fn gen_muxml2(
 
                     traceln!("added bend with start idx {last_idx} and end idx {next_idx}")
                 }
-                TabElement3::Slide => {
+                TabElement::Slide => {
                     let last_idx = stream_idx.saturating_sub(6);
                     traceln!(
                         depth = 1,
@@ -307,7 +276,6 @@ fn gen_muxml2(
             stream_idx += 1;
 
             if stream_proc_cnt == 5 {
-                stream_proc_cnt = 0;
                 if note_count > 0 {
                     measure_processed.push(Muxml2TabElement::CopyTick(stream_idx as u32 - 6));
                 // TODO: maybe pass the non-rest tick ids here instead?
@@ -316,6 +284,7 @@ fn gen_muxml2(
                 }
                 traceln!(depth = 1, "Parsed a tick, a {:?} ", measure_processed.last().unwrap());
                 note_count = 0;
+                stream_proc_cnt = 0;
             } else {
                 stream_proc_cnt += 1;
             }
diff --git a/src/parser/parser.rs b/src/parser/parser.rs
@@ -1,6 +1,6 @@
 use super::{
     string_name,
-    tab_element::{self, tab_element3, TabElement3},
+    tab_element::{self, tab_element3, TabElement},
 };
 use crate::{
     backend::errors::backend_error::BackendError, debugln, parser::tab_element::TabElementError,
@@ -32,7 +32,7 @@ impl Measure {
 pub struct ParseResult {
     /// This is not a [Result] because we want to preserve the partial parse state, eg. for fixup or recovery
     pub error: Option<BackendError>,
-    pub tick_stream: Vec<TabElement3>,
+    pub tick_stream: Vec<TabElement>,
     pub measures: Vec<Measure>,
     pub base_notes: Vec<char>,
     /// The line on which the n-th section begins and the index of the first tick in that section.
@@ -53,7 +53,7 @@ impl ParseResult {
             let max_width =
                 (0..6).map(|x| self.tick_stream[tick * 6 + x].repr_len()).max().unwrap() as usize;
             for (s, buf) in bufs.iter_mut().enumerate() {
-                use tab_element::TabElement3::*;
+                use tab_element::TabElement::*;
                 let to_padded = |c: char| format!("{1:<0$}", max_width, c);
                 match self.tick_stream[tick * 6 + s] {
                     Fret(x) => buf.push_str(&format!("{x:<0$}", max_width)),
@@ -173,7 +173,7 @@ pub fn parse(lines: &[String]) -> ParseResult {
                     let elem_idx = r.tick_stream.len() - (6 - s);
                     let elem = &r.tick_stream[elem_idx];
                     traceln!(depth = 1, "on string {s} we have {:?}", elem);
-                    if let TabElement3::Rest = elem {
+                    if let TabElement::Rest = elem {
                         traceln!(depth = 2, "this is a rest so we try to parse the next element");
                         let len_before = part[s].len();
                         let next = tab_element3(part[s]).unwrap();
diff --git a/src/parser/tab_element.rs b/src/parser/tab_element.rs
@@ -1,8 +1,8 @@
-use crate::{backend::errors::backend_error::BackendError, parser::numeric, traceln};
+use crate::parser::numeric;
 use std::cmp::max;
 
 #[derive(Debug, PartialEq, Clone)]
-pub enum TabElement3 {
+pub enum TabElement {
     Fret(u8),
     Rest,
     DeadNote,
@@ -19,27 +19,27 @@ pub enum TabElementError {
     FretTooLarge,
 }
 #[inline(always)]
-pub fn tab_element3(s: &str) -> Result<(&str, TabElement3), (&str, Option<TabElementError>)> {
+pub fn tab_element3(s: &str) -> Result<(&str, TabElement), (&str, Option<TabElementError>)> {
     let bytes = s.as_bytes();
     match bytes.first() {
-        Some(b'-') => Ok((&s[1..], TabElement3::Rest)),
-        Some(b'x') => Ok((&s[1..], TabElement3::DeadNote)),
+        Some(b'-') => Ok((&s[1..], TabElement::Rest)),
+        Some(b'x') => Ok((&s[1..], TabElement::DeadNote)),
         Some(48..=58) => {
             let (res, num) = numeric(s).map_err(|s| (s, Some(TabElementError::FretTooLarge)))?;
-            Ok((res, TabElement3::Fret(num)))
+            Ok((res, TabElement::Fret(num)))
         }
-        Some(b'b') => Ok((&s[1..], TabElement3::Bend)),
-        Some(b'h') => Ok((&s[1..], TabElement3::HammerOn)),
-        Some(b'p') => Ok((&s[1..], TabElement3::Pull)),
-        Some(b'r') => Ok((&s[1..], TabElement3::Release)),
-        Some(b'/') | Some(b'\\') => Ok((&s[1..], TabElement3::Slide)),
-        Some(b'~') => Ok((&s[1..], TabElement3::Vibrato)),
+        Some(b'b') => Ok((&s[1..], TabElement::Bend)),
+        Some(b'h') => Ok((&s[1..], TabElement::HammerOn)),
+        Some(b'p') => Ok((&s[1..], TabElement::Pull)),
+        Some(b'r') => Ok((&s[1..], TabElement::Release)),
+        Some(b'/') | Some(b'\\') => Ok((&s[1..], TabElement::Slide)),
+        Some(b'~') => Ok((&s[1..], TabElement::Vibrato)),
         Some(_) | None => Err((s, None)),
     }
 }
-impl TabElement3 {
+impl TabElement {
     pub fn repr_len(&self) -> u32 {
-        use TabElement3::*;
+        use TabElement::*;
         match self {
             Fret(x) => max(x, &1).ilog10() + 1,
             Bend | HammerOn | DeadNote | Pull | Slide | Rest | Release | Vibrato => 1,
