refs #114, bugfix with click channel not always inited, and wasm compatibility

Author: yjpark

crates/notation_midi/src/midi_message.rs

@@ -4,38 +4,42 @@ use notation_model::prelude::*;
 #[derive(Clone, Debug)]
 pub struct MidiMessage {
     pub pass_mode: EntryPassMode,
-    pos: BarPosition,
-    delay: Option<Units>,
+    pub pos: BarPosition,
+    pub duration: Units,
+    pub delay: bool,
     pub midi: StructuredShortMessage,
 }
 impl MidiMessage {
-    pub fn new(pass_mode: EntryPassMode, pos: BarPosition, delay: Option<Units>, midi: StructuredShortMessage) -> Self {
+    pub fn new(pass_mode: EntryPassMode, pos: BarPosition, duration: Units, delay: bool, midi: StructuredShortMessage) -> Self {
         Self {
             pass_mode,
             pos,
+            duration,
             delay,
             midi,
         }
     }
-    pub fn of_entry(entry: &LaneEntry, delay: Option<Units>, midi: StructuredShortMessage) -> Self {
+    pub fn of_entry(entry: &LaneEntry, delay: bool, midi: StructuredShortMessage) -> Self {
         Self {
             pass_mode: entry.pass_mode(),
             pos: entry.bar_position(),
+            duration: entry.tied_units(),
             delay,
             midi,
         }
     }
     pub fn bar_ordinal(&self) -> usize {
         self.pos.bar_ordinal
     }
-    pub fn bar_position(&self) -> BarPosition {
-        match self.delay {
-            Some(delay) => self.pos.with_delay(delay),
-            None => self.pos,
+    pub fn effect_position(&self) -> BarPosition {
+        if self.delay {
+            self.pos.with_delay(self.duration)
+        } else {
+            self.pos
         }
     }
-    pub fn units_position(&self) -> Units {
-        self.bar_position().into()
+    pub fn effect_units(&self) -> Units {
+        self.effect_position().into()
     }
     pub fn to_midi(&self) -> [u8; 3] {
         [

crates/notation_midi/src/midi_state.rs

@@ -49,8 +49,8 @@ impl MidiChannel {
     fn ensure_sorted(&mut self) -> bool {
         if self.need_sort {
             dmsort::sort_by(&mut self.messages, |a, b| {
-                let units_a = a.units_position().0;
-                let units_b = b.units_position().0;
+                let units_a = a.effect_units().0;
+                let units_b = b.effect_units().0;
                 if units_a == units_b {
                     Ordering::Equal
                 } else if units_a < units_b {
@@ -68,7 +68,7 @@ impl MidiChannel {
     pub fn calc_next_index(&mut self, position: &BarPosition) {
         let pos_units = Units::from(*position);
         for (index, value) in self.messages.iter().enumerate() {
-            if Units::from(value.bar_position()) >= pos_units {
+            if Units::from(value.effect_position()) >= pos_units {
                 self.next_index = index;
                 return;
             }
@@ -134,15 +134,15 @@ impl MidiChannel {
                 if play_control.is_bar_in_range(next.bar_ordinal())
                     && play_control
                         .position
-                        .is_passed(next.pass_mode, &next.bar_position())
+                        .is_passed(next.pass_mode, &next.effect_position())
                 {
                     self.next_index += 1;
                     count += 1;
                     if !bypass {
                         hub.send(settings, speed, next, velocity);
                     }
                 } else {
-                    if next.bar_position().bar_ordinal < play_control.begin_bar_ordinal {
+                    if next.effect_position().bar_ordinal < play_control.begin_bar_ordinal {
                         self.next_index += 1;
                     } else {
                         break;
@@ -163,7 +163,7 @@ impl MidiChannel {
             hub.send(
                 settings,
                 speed,
-                &MidiMessage::new(first_msg.pass_mode, first_msg.bar_position(), None, msg),
+                &MidiMessage::new(first_msg.pass_mode, first_msg.pos, first_msg.duration, false, msg),
                 self.velocity.into(),
             );
             let msg = StructuredShortMessage::ControlChange {
@@ -174,7 +174,7 @@ impl MidiChannel {
             hub.send(
                 settings,
                 speed,
-                &MidiMessage::new(first_msg.pass_mode, first_msg.bar_position(), None, msg),
+                &MidiMessage::new(first_msg.pass_mode, first_msg.pos, first_msg.duration, false, msg),
                 self.velocity.into(),
             );
         }
@@ -267,18 +267,18 @@ impl MidiState {
             let scale_root = tab.meta.scale.calc_root_syllable();
             let signature = tab.signature();
             let bar_units = tab.bar_units();
-            let beat_delay = Some(Units::from(signature.beat_unit) - Units::MIN_ACCURACY);
+            let beat_duration = Units::from(signature.beat_unit);
             for bar in tab.bars.iter() {
                 for beat in 0..signature.bar_beats {
                     let in_bar_pos = Units(beat as f32 * Units::from(signature.beat_unit).0);
                     let root = bar.get_chord(Some(in_bar_pos)).map(|x| x.root).unwrap_or(scale_root);
                     let note = tab.meta.scale.calc_click_note(&tab.meta.key, &settings.click_octave, &root);
                     let pos = BarPosition::new(bar_units, bar.props.bar_ordinal, in_bar_pos);
                     if let Some(midi_msg) = MidiUtil::note_midi_on_msg(&note, channel.channel, channel.velocity) {
-                        channel.add_message(MidiMessage::new(EntryPassMode::Immediate, pos, None, midi_msg));
+                        channel.add_message(MidiMessage::new(EntryPassMode::Immediate, pos, beat_duration, false, midi_msg));
                     }
                     if let Some(midi_msg) = MidiUtil::note_midi_off_msg(&note, channel.channel, channel.velocity) {
-                        channel.add_message(MidiMessage::new(EntryPassMode::Immediate, pos, beat_delay, midi_msg));
+                        channel.add_message(MidiMessage::new(EntryPassMode::Immediate, pos, beat_duration, true, midi_msg));
                     }
                 }
             }
@@ -378,7 +378,7 @@ impl MidiState {
     }
     pub fn init_channels(&mut self, settings: &MidiSettings, hub: &mut MidiHub) {
         for channel in self.channels.iter_mut() {
-            if channel.track.is_some() {
+            if channel.messages.len() > 0 {
                 channel.init_channel(settings, hub, &self.play_control.play_speed);
                 channel.calc_next_index(&self.play_control.position.bar);
             }

crates/notation_midi/src/midi_util.rs

@@ -3,7 +3,6 @@ use std::convert::TryFrom;
 use helgoboss_midi::{Channel, KeyNumber, StructuredShortMessage, U7};
 use notation_model::prelude::{
     CoreEntry, Entry, FrettedEntry4, FrettedEntry6, LaneEntry, Note, Pick, Semitones, TabBar, Tone,
-    Units,
 };
 
 use crate::prelude::MidiChannel;
@@ -47,22 +46,21 @@ impl MidiUtil {
         _bar: &TabBar,
         entry: &LaneEntry,
         tone: &Tone,
-    ) -> Option<Vec<(Option<Units>, StructuredShortMessage)>> {
+    ) -> Option<Vec<(bool, StructuredShortMessage)>> {
         if tone.is_none() || entry.prev_is_tie() {
             return None;
         }
-        let mut play_msgs: Vec<(Option<Units>, StructuredShortMessage)> = tone
+        let mut play_msgs: Vec<(bool, StructuredShortMessage)> = tone
             .get_notes()
             .iter()
             .flat_map(|x| MidiUtil::note_midi_on_msg(x, channel.channel, channel.velocity))
-            .map(|x| (None, x))
+            .map(|x| (false, x))
             .collect();
-        let delay = entry.tied_units();
-        let mut stop_msgs: Vec<(Option<Units>, StructuredShortMessage)> = tone
+        let mut stop_msgs: Vec<(bool, StructuredShortMessage)> = tone
             .get_notes()
             .iter()
             .flat_map(|x| MidiUtil::note_midi_off_msg(x, channel.channel, channel.velocity))
-            .map(|x| (Some(delay), x))
+            .map(|x| (true, x))
             .collect();
         play_msgs.append(&mut stop_msgs);
         if play_msgs.len() > 0 {
@@ -76,7 +74,7 @@ impl MidiUtil {
         bar: &TabBar,
         entry: &LaneEntry,
         core_entry: &CoreEntry,
-    ) -> Option<Vec<(Option<Units>, StructuredShortMessage)>> {
+    ) -> Option<Vec<(bool, StructuredShortMessage)>> {
         match core_entry {
             CoreEntry::Tone(tone, _) => Self::get_tone_midi_msgs(channel, bar, entry, tone),
             _ => None,
@@ -86,7 +84,7 @@ impl MidiUtil {
         channel: &MidiChannel,
         bar: &TabBar,
         entry: &LaneEntry,
-    ) -> Option<Vec<(Option<Units>, StructuredShortMessage)>> {
+    ) -> Option<Vec<(bool, StructuredShortMessage)>> {
         match entry.proto() {
             notation_model::prelude::ProtoEntry::Core(core_entry) => {
                 Self::get_core_midi_msgs(channel, bar, entry, core_entry)
@@ -110,7 +108,7 @@ macro_rules! impl_get_pick_midi_msgs {
                 bar: &TabBar,
                 entry: &LaneEntry,
                 pick: &Pick,
-            ) -> Option<Vec<(Option<Units>, StructuredShortMessage)>> {
+            ) -> Option<Vec<(bool, StructuredShortMessage)>> {
                 if let Some((fretboard, shape)) = bar.$get_fretted_shape(entry) {
                     let tone = fretboard.pick_tone(&shape, pick);
                     Self::get_tone_midi_msgs(channel, bar, entry, &tone)
@@ -130,7 +128,7 @@ macro_rules! impl_get_fretted_midi_msgs {
                 bar: &TabBar,
                 entry: &LaneEntry,
                 fretted_entry: &$fretted_entry,
-            ) -> Option<Vec<(Option<Units>, StructuredShortMessage)>> {
+            ) -> Option<Vec<(bool, StructuredShortMessage)>> {
                 match fretted_entry {
                     $fretted_entry::Pick(pick, _) => {
                         Self::$get_pick_midi_msgs(channel, bar, entry, pick)

crates/notation_midi/src/wasm/midi_synth.rs

@@ -26,7 +26,9 @@ impl MidiSynth {
                 channel: _,
                 key_number: _,
                 velocity: _,
-            } => Ok(()),
+            } => {
+                Ok(())
+            },
             StructuredShortMessage::NoteOn {
                 channel,
                 key_number,
@@ -40,7 +42,7 @@ impl MidiSynth {
                     Ok(play_note(
                         channel.into(),
                         key_number.into(),
-                        speed.calc_seconds(msg.entry.tied_units()),
+                        speed.calc_seconds(msg.duration),
                         volume * Self::VOLUME_FACTOR,
                     ))
                 } else {