m8-files 0.3.1

Parse the Dirtywave M8's file formats
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

use num_enum::{IntoPrimitive, TryFromPrimitive};

use crate::{writer::Writer, Version};

use super::{M8Result, Mod, ParseError, Reader};

#[repr(u8)]
#[allow(non_camel_case_types)]
#[derive(IntoPrimitive, TryFromPrimitive, PartialEq, Copy, Clone, Default, Debug)]
pub enum LfoShape {
    #[default]
    TRI,
    SIN,
    RAMP_DOWN,
    RAMP_UP,
    EXP_DN,
    EXP_UP,
    SQR_DN,
    SQR_UP,
    RANDOM,
    DRUNK,
    TRI_T,
    SIN_T,
    RAMPD_T,
    RAMPU_T,
    EXPD_T,
    EXPU_T,
    SQ_D_T,
    SQ_U_T,
    RAND_T,
    DRNK_T,
}

#[repr(u8)]
#[allow(non_camel_case_types)]
#[derive(IntoPrimitive, TryFromPrimitive, PartialEq, Copy, Clone, Default, Debug)]
pub enum LfoTriggerMode {
    #[default]
    FREE,
    RETRIG,
    HOLD,
    ONCE,
}

#[derive(PartialEq, Debug, Clone)]
pub struct LFO {
    pub shape: LfoShape,
    pub dest: u8,
    pub trigger_mode: LfoTriggerMode,
    pub freq: u8,
    pub amount: u8,
    pub retrigger: u8,
}

const LFO_COMMAND_NAMES: [[&'static str; 5]; 4] = [
    ["LA1", "LO1", "LS1", "LF1", "LT1"],
    ["LA2", "LO2", "LS2", "LF2", "LT2"],
    ["LA3", "LO3", "LS3", "LF3", "LT3"],
    ["LA4", "LO4", "LS4", "LF4", "LT4"],
];

impl LFO {
    pub fn command_name(_ver: Version, mod_id: usize) -> &'static [&'static str] {
        &LFO_COMMAND_NAMES[mod_id]
    }

    pub fn from_reader2(reader: &mut Reader) -> M8Result<Self> {
        let shape = reader.read();
        let dest = reader.read();
        let trigger = reader.read();
        let r = Self {
            shape: shape
                .try_into()
                .map_err(|_| ParseError(format!("Invalid LFO shape {}", shape)))?,
            dest,
            trigger_mode: trigger
                .try_into()
                .map_err(|_| ParseError(format!("Invalid lfo trigger mode {}", trigger)))?,
            freq: reader.read(),
            amount: reader.read(),
            retrigger: reader.read(),
        };

        Ok(r)
    }

    pub fn write(&self, w: &mut Writer) {
        w.write(self.amount);
        w.write(self.shape.into());
        w.write(self.trigger_mode.into());
        w.write(self.freq);
        w.write(self.retrigger);
    }

    pub fn from_reader3(reader: &mut Reader, dest: u8) -> M8Result<Self> {
        let amount = reader.read();
        let shape = reader.read();
        let trigger_mode = reader.read();
        let freq = reader.read();
        let retrigger = reader.read();

        Ok(Self {
            dest,
            amount,
            shape: shape
                .try_into()
                .map_err(|_| ParseError(format!("Invalid LFO shape {}", shape)))?,
            trigger_mode: trigger_mode
                .try_into()
                .map_err(|_| ParseError(format!("Invalid lfo trigger mode {}", trigger_mode)))?,
            freq,
            retrigger,
        })
    }

    pub fn to_mod(self) -> Mod {
        Mod::LFO(self)
    }
}