midistream 0.1.0

Midi encode/decode
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

use std::convert::From;
use std::ops::Deref;

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
pub struct U5(u8);

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
pub struct U7(u8);

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
pub struct U14(u16);

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
pub struct Channel(u8);

impl From<u8> for U7 {
    fn from(i: u8) -> U7 {
        debug_assert!(i & 0x80 == 0);
        U7(i & 0x7f)
    }
}

impl Deref for U7 {
    type Target = u8;

    #[inline]
    fn deref(&self) -> &u8 { &self.0 }
}

impl From<u8> for U5 {
    fn from(i: u8) -> U5 {
        debug_assert!(i & 0xe0 == 0);
        U5(i & 0x1f)
    }
}

impl Deref for U5 {
    type Target = u8;

    #[inline]
    fn deref(&self) -> &u8 { &self.0 }
}

impl From<u16> for U14 {
    fn from(i: u16) -> U14 {
        debug_assert!(i & 0xc000 == 0);
        U14(i & 0x3fff)
    }
}

impl From<(U7, U7)> for U14 {
    fn from(i: (U7, U7)) -> U14 {
        U14(*i.0 as u16 + ((*i.1 as u16) << 7))
    }
}

impl From<U14> for (U7, U7) {
    fn from(i: U14) -> (U7, U7) {
        (i.lsb(), i.msb())
    }
}

impl U14 {
    #[inline]
    pub fn lsb(&self) -> U7 { U7((self.0 & 0x7f) as u8) }
    #[inline]
    pub fn msb(&self) -> U7 { U7((self.0 >> 7) as u8) }
}

impl Deref for U14 {
    type Target = u16;

    #[inline]
    fn deref(&self) -> &u16 { &self.0 }
}

impl From<u8> for Channel {
    fn from(i: u8) -> Channel {
        debug_assert!(i & 0xf0 == 0);
        Channel(i & 0x0f)
    }
}

impl Deref for Channel {
    type Target = u8;

    #[inline]
    fn deref(&self) -> &u8 { &self.0 }
}

#[test]
#[should_panic]
fn out_of_range() {
    let _: U7 = 129.into();
}

#[test]
fn test_u14() {
    let a = U7(0x40);
    let b = U7(0x30);
    let c: U14 = (b, a).into();
    assert_eq!(c.msb(), a);
    assert_eq!(c.lsb(), b);
    assert_eq!(*c, 0x2030);
}