Convert CV2 <-> CV1

[BenLeadbetter]

The MIDI 2.0 spec describes how channel voice 1 messages can be converted into channel voice 2. Currently there is no support for this.

Acceptance Criteria

• Conversions should use standard rust conversion traits where possible
• Any narrowing or widening should strictly comply with what is specified in the MIDI 2.0 specs.

[Rahzael]

I do think I might be up to the task of implementing the default translation as specified in Appendix D of the UMP and MIDI 2.0 Protocol specification.

However, as someone also working on a voice allocator for Appendix C, per-note controllers, I do believe that there will be a lot of cases where this translation doesn't make sense, especially for the MIDI 2.0 -> MIDI 1.0 translation.

[Rahzael]

@BenLeadbetter I have a work in progress PR up here where I've implemented the conversion from CV2 note_on to CV1 note_on: #85.

I would appreciate any feedback you have on the general approach before continuing to implement conversions for different message types.

[BenLeadbetter]

Thanks taking this work on!

The most interesting part of this issue is in the implementation of the this upscaling "Min-Center-Max" algorithm when converting between 7-bit integers to 16-bit integers, for example. The good news is that this should be very unit testable - we can be pretty shure when we've got the correect implementation by just locking down all the key cases.

[Rahzael]

@BenLeadbetter

It obviously doesn't give the correct conversion yet, but does this seem like an acceptable route for generically implementing scaling for ux types?

pub(crate) trait Center {
    fn min_value() -> Self;
    fn max_value() -> Self;

    fn center_value() -> Self
    where
        Self: Sized + core::ops::Sub + From<ux::u2>,
        <Self as core::ops::Sub>::Output: core::ops::Div<Self>,
        Self: From<<<Self as core::ops::Sub>::Output as core::ops::Div<Self>>::Output>
    {
        ((Self::max_value() - Self::min_value()) / Self::from(ux::u2::new(2))).into()
    }
}

impl Center for ux::u7 {
    fn min_value() -> Self {
        Self::min_value()
    }
    fn max_value() -> Self {
        Self::max_value()
    }
}

impl Center for u16 {
    fn min_value() -> Self {
        Self::min_value()
    }
    fn max_value() -> Self {
        Self::max_value()
    }
}

pub(crate) trait MinCenterMax {
    fn min_value() -> Self;
    fn center_value() -> Self;
    fn max_value() -> Self;

    fn scale<U: MinCenterMax>(self) -> U where Self: Sized + Into<U> {self.into()}
}

impl<U> MinCenterMax for U
where
    U: Center,
    U: core::ops::Sub,
    U: core::convert::From<ux::u2>,
    U: From<<<U as core::ops::Sub>::Output as core::ops::Div<U>>::Output>,
    <U as core::ops::Sub>::Output: core::ops::Div<U>,
{
    fn min_value() -> Self {
        Self::min_value()
    }
    fn max_value() -> Self {
        Self::max_value()
    }
    fn center_value() -> Self {
        Self::center_value()
    }
}

I couldn't find a convenient way to implement Center (and thus MinCenterMax) for all of ux, but perhaps I can write a Macro to do so?

[Rahzael]

And then the min-center-max algorithm would go under the branch arm in MinCenterMax::scale() when other.max_value() is greater than self.max_value().

With the other branch arm doing a bitshift by the proper amount.

[Rahzael]

Alternatively to doing a macro to implement Center for all of ux, we can just do the common midi sizes for now:

impl Center for ux::u7 {
    fn min_value() -> Self {
        Self::min_value()
    }
    fn max_value() -> Self {
        Self::max_value()
    }
}

impl Center for ux::u9 {
    fn min_value() -> Self {
        Self::min_value()
    }
    fn max_value() -> Self {
        Self::max_value()
    }
}

impl Center for ux::u14 {
    fn min_value() -> Self {
        Self::min_value()
    }
    fn max_value() -> Self {
        Self::max_value()
    }
}

impl Center for u16 {
    fn min_value() -> Self {
        Self::min_value()
    }
    fn max_value() -> Self {
        Self::max_value()
    }
}

impl Center for u32 {
    fn min_value() -> Self {
        Self::min_value()
    }
    fn max_value() -> Self {
        Self::max_value()
    }
}

[Rahzael]

And then the min-center-max algorithm would go under the branch arm in MinCenterMax::scale() when other.max_value() is greater than self.max_value().

With the other branch arm doing a bitshift by the proper amount.

An update on this. Due to conflicting traitbound requirements for upscaling and downscaling, I was not able to keep the generic scale function and had to split it up into seperate upscaling and downscaling functions.

I've almost finished the MinCenterMax implementation, I just need to cover the (perhaps most complicated) case of upscaling the upper range.

[Rahzael]

@BenLeadbetter I think I got MinCenterMax down. It could probably use a bit more test coverage for downscaling, but all the current tests are now passing, including test cases I pulled directly from MIDI 2.0 Bit Scaling and Resolution.