WIP: Convert CV2 <-> CV1

midi2/src/channel_voice1/note_off.rs

@@ -37,11 +37,72 @@ struct NoteOff {
     velocity: crate::ux::u7,
 }
 
+/// Converts a CV2 Note Off message to CV1 Note Off message,
+/// storing the result in a pre-allocated CV1 Note Off.
+#[cfg(feature = "channel-voice2")]
+impl<
+        A: crate::buffer::Buffer<Unit = u32>,
+        B: crate::buffer::Buffer<Unit = u32> + crate::buffer::BufferMut,
+    > From<(crate::channel_voice2::NoteOff<A>, NoteOff<B>)> for NoteOff<B>
+{
+    fn from(val: (crate::channel_voice2::NoteOff<A>, NoteOff<B>)) -> Self {
+        use crate::conversion::MinCenterMax;
+        use crate::traits::{Channeled, Grouped};
+
+        let (src, mut dest) = val;
+        dest.set_group(src.group());
+        dest.set_channel(src.channel());
+        dest.set_note_number(src.note_number());
+        dest.set_velocity(src.velocity().mcm_downscale::<ux::u7>());
+        dest
+    }
+}
+
+/// Converts a CV2 Note Off message to a CV1 Note Off message.
+/// This is only infallible for resizable buffers.
+/// For fixed size buffers, see TryFromCv2.
+///
+/// Note: Due to 0 velocity Note Off messages being considered
+/// a Note Off in CV1 but not in CV2, a 0 velocity CV2 message
+/// will be converted to a 1 velocity CV1 message.
+#[cfg(feature = "channel-voice2")]
+impl<
+        A: crate::buffer::Buffer<Unit = u32>,
+        B: crate::buffer::Buffer<Unit = u32>
+            + crate::buffer::BufferMut
+            + crate::buffer::BufferDefault
+            + crate::buffer::BufferResize,
+    > crate::FromCv2<crate::channel_voice2::NoteOff<A>> for NoteOff<B>
+{
+    fn from_cv2(val: crate::channel_voice2::NoteOff<A>) -> Self {
+        let dest = NoteOff::<B>::new();
+        (val, dest).into()
+    }
+}
+
+/// Tries to Convert a CV2 Note Off message to a CV1 Note Off message.
+/// Fails if the underlying buffer doesn't have enough room for a new Note Off message.
+#[cfg(feature = "channel-voice2")]
+impl<
+        A: crate::buffer::Buffer<Unit = u32>,
+        B: crate::buffer::Buffer<Unit = u32>
+            + crate::buffer::BufferMut
+            + crate::buffer::BufferDefault
+            + crate::buffer::BufferTryResize,
+    > crate::TryFromCv2<crate::channel_voice2::NoteOff<A>> for NoteOff<B>
+{
+    type Error = crate::error::BufferOverflow;
+    fn try_from_cv2(val: crate::channel_voice2::NoteOff<A>) -> Result<Self, Self::Error> {
+        let dest = NoteOff::<B>::try_new()?;
+        Ok((val, dest).into())
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::{
-        traits::{Channeled, Grouped},
+        traits::{Channeled, Grouped, IntoCv1, TryIntoCv1},
         ux::*,
     };
     use pretty_assertions::assert_eq;
@@ -91,4 +152,71 @@ mod tests {
             u7::new(0x1B),
         );
     }
+
+    #[test]
+    fn from_midi_2_with_dest() {
+        use crate::traits::{Channeled, Grouped};
+
+        let mut message2 = crate::channel_voice2::NoteOff::<[u32; 4]>::new();
+        message2.set_group(u4::new(0x8));
+        message2.set_channel(u4::new(0x8));
+        message2.set_note_number(u7::new(0x5E));
+        message2.set_velocity(0x8000);
+
+        let mut message1 = NoteOff::<[u32; 4]>::new();
+        message1.set_group(u4::new(0x8));
+        message1.set_channel(u4::new(0x8));
+        message1.set_note_number(u7::new(0x5E));
+        message1.set_velocity(u7::new(0x40));
+
+        let message21 = NoteOff::<[u32; 4]>::new();
+        let message21: NoteOff<[u32; 4]> = (message2, message21).into();
+
+        assert_eq!(message21, message1);
+    }
+
+    #[test]
+    fn from_midi_2() {
+        use crate::traits::{Channeled, Grouped};
+        use std::vec::Vec;
+
+        let mut message2 = crate::channel_voice2::NoteOff::<[u32; 4]>::new();
+        message2.set_group(u4::new(0x8));
+        message2.set_channel(u4::new(0x8));
+        message2.set_note_number(u7::new(0x5E));
+        message2.set_velocity(0x8000);
+
+        let mut message1 = NoteOff::<Vec<u32>>::new();
+        message1.set_group(u4::new(0x8));
+        message1.set_channel(u4::new(0x8));
+        message1.set_note_number(u7::new(0x5E));
+        message1.set_velocity(u7::new(0x40));
+
+        let message21: NoteOff<Vec<u32>> = message2.into_cv1();
+
+        assert_eq!(message21, message1);
+    }
+
+    #[test]
+    fn try_from_midi_2() {
+        use crate::traits::{Channeled, Grouped};
+
+        let mut message2 = crate::channel_voice2::NoteOff::<[u32; 4]>::new();
+        message2.set_group(u4::new(0x8));
+        message2.set_channel(u4::new(0x8));
+        message2.set_note_number(u7::new(0x5E));
+        message2.set_velocity(0x8000);
+
+        let mut message1 = NoteOff::<[u32; 4]>::new();
+        message1.set_group(u4::new(0x8));
+        message1.set_channel(u4::new(0x8));
+        message1.set_note_number(u7::new(0x5E));
+        message1.set_velocity(u7::new(0x40));
+
+        let message21: NoteOff<[u32; 4]> = message2
+            .try_into_cv1()
+            .expect("Conversion should not fail.");
+
+        assert_eq!(message21, message1);
+    }
 }

midi2/src/channel_voice1/note_on.rs

@@ -37,11 +37,86 @@ struct NoteOn {
     velocity: crate::ux::u7,
 }
 
+/// Converts a CV2 Note On message to CV1 Note On message,
+/// storing the result in a pre-allocated CV1 Note On.
+///
+/// Note: Due to 0 velocity Note On messages being considered
+/// a Note Off in CV1 but not in CV2, a 0 velocity CV2 message
+/// will be converted to a 1 velocity CV1 message.
+#[cfg(feature = "channel-voice2")]
+impl<
+        A: crate::buffer::Buffer<Unit = u32>,
+        B: crate::buffer::Buffer<Unit = u32> + crate::buffer::BufferMut,
+    > From<(crate::channel_voice2::NoteOn<A>, NoteOn<B>)> for NoteOn<B>
+{
+    fn from(val: (crate::channel_voice2::NoteOn<A>, NoteOn<B>)) -> Self {
+        use crate::conversion::MinCenterMax;
+        use crate::traits::{Channeled, Grouped};
+
+        let (src, mut dest) = val;
+        dest.set_group(src.group());
+        dest.set_channel(src.channel());
+        dest.set_note_number(src.note_number());
+        match src.velocity() {
+            // Since 0 velocity doesn't trigger a note off in CV2 like in CV1,
+            // we need to convert 0 velocity in CV2 to 1 velocity in CV1.
+            // See MIDI 2.0 spec 7.4.2: MIDI 2.0 Note On Message -> Velocity
+            // for details.
+            0 => dest.set_velocity(ux::u7::new(0x01)),
+            _ => dest.set_velocity(src.velocity().mcm_downscale::<ux::u7>()),
+        }
+        dest
+    }
+}
+
+/// Tries to Convert a CV2 Note On message to a CV1 Note On message.
+///
+/// Note: Due to 0 velocity Note On messages being considered
+/// a Note Off in CV1 but not in CV2, a 0 velocity CV2 message
+/// will be converted to a 1 velocity CV1 message.
+#[cfg(feature = "channel-voice2")]
+impl<
+        A: crate::buffer::Buffer<Unit = u32>,
+        B: crate::buffer::Buffer<Unit = u32>
+            + crate::buffer::BufferMut
+            + crate::buffer::BufferDefault
+            + crate::buffer::BufferTryResize,
+    > crate::TryFromCv2<crate::channel_voice2::NoteOn<A>> for NoteOn<B>
+{
+    type Error = crate::error::BufferOverflow;
+    fn try_from_cv2(val: crate::channel_voice2::NoteOn<A>) -> Result<Self, Self::Error> {
+        let dest = NoteOn::<B>::try_new()?;
+        Ok((val, dest).into())
+    }
+}
+
+/// Converts a CV2 Note On message to a CV1 Note On message.
+/// This is only infallible for resizable buffers.
+/// For fixed size buffers, see the Into impl for (CV2, CV1).
+///
+/// Note: Due to 0 velocity Note On messages being considered
+/// a Note Off in CV1 but not in CV2, a 0 velocity CV2 message
+/// will be converted to a 1 velocity CV1 message.
+#[cfg(feature = "channel-voice2")]
+impl<
+        A: crate::buffer::Buffer<Unit = u32>,
+        B: crate::buffer::Buffer<Unit = u32>
+            + crate::buffer::BufferMut
+            + crate::buffer::BufferDefault
+            + crate::buffer::BufferResize,
+    > crate::FromCv2<crate::channel_voice2::NoteOn<A>> for NoteOn<B>
+{
+    fn from_cv2(val: crate::channel_voice2::NoteOn<A>) -> Self {
+        let dest = NoteOn::<B>::new();
+        (val, dest).into()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::{
-        traits::{Channeled, Grouped},
+        traits::{Channeled, Grouped, IntoCv1, TryIntoCv1},
         ux::*,
     };
     use pretty_assertions::assert_eq;
@@ -103,4 +178,115 @@ mod tests {
             u7::new(0x3D),
         );
     }
+
+    #[test]
+    fn from_midi_2() {
+        use crate::traits::{Channeled, Grouped};
+        use std::vec::Vec;
+
+        let mut message2 = crate::channel_voice2::NoteOn::<[u32; 4]>::new();
+        message2.set_group(u4::new(0x8));
+        message2.set_channel(u4::new(0x8));
+        message2.set_note_number(u7::new(0x5E));
+        message2.set_velocity(0x8000);
+
+        let mut message1 = NoteOn::<Vec<u32>>::new();
+        message1.set_group(u4::new(0x8));
+        message1.set_channel(u4::new(0x8));
+        message1.set_note_number(u7::new(0x5E));
+        message1.set_velocity(u7::new(0x40));
+
+        let message21: NoteOn<Vec<u32>> = message2.into_cv1();
+
+        assert_eq!(message21, message1);
+    }
+
+    #[test]
+    fn try_from_midi_2() {
+        use crate::traits::{Channeled, Grouped};
+
+        let mut message2 = crate::channel_voice2::NoteOn::<[u32; 4]>::new();
+        message2.set_group(u4::new(0x8));
+        message2.set_channel(u4::new(0x8));
+        message2.set_note_number(u7::new(0x5E));
+        message2.set_velocity(0x8000);
+
+        let mut message1 = NoteOn::<[u32; 4]>::new();
+        message1.set_group(u4::new(0x8));
+        message1.set_channel(u4::new(0x8));
+        message1.set_note_number(u7::new(0x5E));
+        message1.set_velocity(u7::new(0x40));
+
+        let message21: NoteOn<[u32; 4]> = message2
+            .try_into_cv1()
+            .expect("Conversion should not fail.");
+
+        assert_eq!(message21, message1);
+    }
+
+    #[test]
+    fn from_midi_2_zero_velocity() {
+        use crate::traits::{Channeled, Grouped};
+        use std::vec::Vec;
+
+        let mut message2 = crate::channel_voice2::NoteOn::<[u32; 4]>::new();
+        message2.set_group(u4::new(0x8));
+        message2.set_channel(u4::new(0x8));
+        message2.set_note_number(u7::new(0x5E));
+        message2.set_velocity(0x0000);
+
+        let mut message1 = NoteOn::<Vec<u32>>::new();
+        message1.set_group(u4::new(0x8));
+        message1.set_channel(u4::new(0x8));
+        message1.set_note_number(u7::new(0x5E));
+        message1.set_velocity(u7::new(0x01));
+
+        let message21: NoteOn<Vec<u32>> = message2.into_cv1();
+
+        assert_eq!(message21, message1);
+    }
+
+    #[test]
+    fn from_midi_2_with_dest() {
+        use crate::traits::{Channeled, Grouped};
+
+        let mut message2 = crate::channel_voice2::NoteOn::<[u32; 4]>::new();
+        message2.set_group(u4::new(0x8));
+        message2.set_channel(u4::new(0x8));
+        message2.set_note_number(u7::new(0x5E));
+        message2.set_velocity(0x8000);
+
+        let mut message1 = NoteOn::<[u32; 4]>::new();
+        message1.set_group(u4::new(0x8));
+        message1.set_channel(u4::new(0x8));
+        message1.set_note_number(u7::new(0x5E));
+        message1.set_velocity(u7::new(0x40));
+
+        let message21 = NoteOn::<[u32; 4]>::new();
+        let message21: NoteOn<[u32; 4]> = (message2, message21).into();
+
+        assert_eq!(message21, message1);
+    }
+
+    #[test]
+    fn from_midi_2_zero_velocity_with_dest() {
+        use crate::traits::{Channeled, Grouped};
+
+        let mut message2 = crate::channel_voice2::NoteOn::<[u32; 4]>::new();
+        message2.set_group(u4::new(0x8));
+        message2.set_channel(u4::new(0x8));
+        message2.set_note_number(u7::new(0x5E));
+        message2.set_velocity(0x0000);
+
+        let mut message1 = NoteOn::<[u32; 4]>::new();
+        message1.set_group(u4::new(0x8));
+        message1.set_channel(u4::new(0x8));
+        message1.set_note_number(u7::new(0x5E));
+        message1.set_velocity(u7::new(0x01));
+
+        let message21 = NoteOn::<[u32; 4]>::new();
+        let message21: NoteOn<[u32; 4]> = (message2, message21).into();
+
+        assert_eq!(message21, message1);
+    }
 }