rtpmidi 0.4.4

A library for RTP-MIDI / AppleMIDI
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use zerocopy::{
    FromBytes, Immutable, IntoBytes, KnownLayout,
    network_endian::{U16, U32},
};

#[derive(IntoBytes, FromBytes, KnownLayout, Immutable)]
#[repr(C, packed)]
pub(super) struct MidiPacketHeader {
    pub flags: MidiPacketHeaderFlags, // 2 bits for version, 1 bit for p_flag, 1 bit for x_flag, 4 bits for cc, 1 bit for m_flag, 7 bits for pt
    pub sequence_number: U16,         // Sequence number
    pub timestamp: U32,               // Lower 32 bits of the timestamp in 100-microsecond units
    pub ssrc: U32,                    // Sender SSRC
}

#[repr(u16)]
pub enum FlagMasks {
    Version = 0b1100_0000_0000_0000,
    P = 0b0010_0000_0000_0000,
    X = 0b0001_0000_0000_0000,
    CC = 0b0000_1111_0000_0000,
    M = 0b0000_0000_1000_0000,
    PT = 0b0000_0000_0111_1111,
}

#[derive(IntoBytes, FromBytes, KnownLayout, Immutable)]
#[repr(C, packed)]
pub struct MidiPacketHeaderFlags {
    flags: U16,
}

impl MidiPacketHeaderFlags {
    pub fn new(version: u8, p: bool, x: bool, cc: u8, m: bool, pt: u8) -> Self {
        let mut flags = MidiPacketHeaderFlags { flags: U16::new(0) };
        flags.set_version(version);
        flags.set_flag(FlagMasks::P, p);
        flags.set_flag(FlagMasks::X, x);
        flags.set_cc(cc);
        flags.set_flag(FlagMasks::M, m);
        flags.set_pt(pt);
        flags
    }

    fn get_flag(&self, flag: FlagMasks) -> bool {
        self.flags & flag as u16 != 0
    }

    fn set_flag(&mut self, flag: FlagMasks, value: bool) {
        if value {
            self.flags |= flag as u16;
        } else {
            self.flags &= !(flag as u16);
        }
    }

    fn get_version(&self) -> u8 {
        ((self.flags.get() & FlagMasks::Version as u16) >> 14) as u8
    }

    fn set_version(&mut self, version: u8) {
        self.flags.set((self.flags.get() & !(FlagMasks::Version as u16)) | ((version as u16) << 14));
    }

    fn cc(&self) -> u8 {
        ((self.flags.get() & FlagMasks::CC as u16) >> 8) as u8
    }

    fn set_cc(&mut self, cc: u8) {
        self.flags.set((self.flags.get() & !(FlagMasks::CC as u16)) | ((cc as u16) << 8));
    }

    fn pt(&self) -> u8 {
        (self.flags.get() & FlagMasks::PT as u16) as u8
    }

    fn set_pt(&mut self, pt: u8) {
        self.flags.set((self.flags.get() & !(FlagMasks::PT as u16)) | (pt as u16));
    }
}

impl From<u16> for MidiPacketHeaderFlags {
    fn from(flags: u16) -> Self {
        MidiPacketHeaderFlags { flags: U16::new(flags) }
    }
}

impl From<MidiPacketHeaderFlags> for u16 {
    fn from(flags: MidiPacketHeaderFlags) -> u16 {
        flags.flags.get()
    }
}

impl MidiPacketHeader {
    pub fn new(sequence_number: U16, timestamp: U32, ssrc: U32) -> Self {
        //let flags: u8 = 0b10
        let flags = MidiPacketHeaderFlags::new(2, false, false, 0, false, 97);

        MidiPacketHeader {
            flags,
            sequence_number,
            timestamp,
            ssrc,
        }
    }
}

impl std::fmt::Debug for MidiPacketHeader {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("MidiPacketHeader")
            .field(
                "flags",
                &format_args!(
                    "version: {}, p: {}, x: {}, cc: {}, m: {}, pt: {}",
                    self.flags.get_version(),
                    self.flags.get_flag(FlagMasks::P),
                    self.flags.get_flag(FlagMasks::X),
                    self.flags.cc(),
                    self.flags.get_flag(FlagMasks::M),
                    self.flags.pt()
                ),
            )
            .field("sequence_number", &self.sequence_number)
            .field("timestamp", &self.timestamp)
            .field("ssrc", &self.ssrc)
            .finish()
    }
}