device 0.0.4

A generative engine
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

use super::*;

#[derive(Debug, Snafu)]
#[snafu(context(suffix(Error)))]
pub(crate) enum MessageParseError {
  Parse {
    source: midly::Error,
  },
  Unrecognized {
    event: midly::live::LiveEvent<'static>,
  },
}

#[derive(Clone, Copy, Debug)]
pub(crate) struct Message {
  pub(crate) control: u8,
  pub(crate) controller: Controller,
  pub(crate) event: Event,
}

impl Message {
  pub(crate) fn parse(event: &[u8]) -> Result<Self, MessageParseError> {
    let event = midly::live::LiveEvent::parse(event).context(ParseError)?;
    let (channel, key, value, press): (u8, u8, u7, Press) = match event {
      midly::live::LiveEvent::Midi { channel, message } => match message {
        midly::MidiMessage::NoteOn { key, vel } => (channel.into(), key.into(), vel, Press::Press),
        midly::MidiMessage::NoteOff { key, vel } => {
          (channel.into(), key.into(), vel, Press::Release)
        }
        _ => {
          return Err(MessageParseError::Unrecognized {
            event: event.to_static(),
          });
        }
      },
      _ => {
        return Err(MessageParseError::Unrecognized {
          event: event.to_static(),
        });
      }
    };

    let (controller, control, event) = match (channel, key) {
      (0, 0..=15) => (Controller::Twister, key, Event::Encoder(value)),
      (1, 0..=15) => (Controller::Twister, key, Event::Button(press)),
      (2, 36..=51) => (
        Controller::Spectra,
        match key {
          48 => 0,
          49 => 1,
          50 => 2,
          51 => 3,
          44 => 4,
          45 => 5,
          46 => 6,
          47 => 7,
          40 => 8,
          41 => 9,
          42 => 10,
          43 => 11,
          36 => 12,
          37 => 13,
          38 => 14,
          39 => 15,
          _ => unreachable!(),
        },
        Event::Button(press),
      ),
      (3, 20..=25) => (
        Controller::Spectra,
        match key {
          22 => 16,
          21 => 17,
          20 => 18,
          25 => 19,
          24 => 20,
          23 => 21,
          _ => unreachable!(),
        },
        Event::Button(press),
      ),
      (3, 8..=13) => (Controller::Twister, key - 8 + 16, Event::Button(press)),
      _ => {
        return Err(MessageParseError::Unrecognized {
          event: event.to_static(),
        });
      }
    };

    Ok(Self {
      control,
      controller,
      event,
    })
  }
}