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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

// SPDX-License-Identifier: LGPL-3.0-or-later
// Copyright (c) 2020 Takashi Sakamoto

#![doc = include_str!("../README.md")]

pub mod alesis;
pub mod avid;
pub mod focusrite;
pub mod lexicon;
pub mod loud;
pub mod maudio;
pub mod presonus;
pub mod tcat;
pub mod tcelectronic;

use {
    glib::{Error, FileError},
    hinawa::{FwNode, FwReq},
};

const QUADLET_SIZE: usize = 4;

/// For conversion between quadlet-aligned byte array and computed value.
trait QuadletConvert<T>: From<T> {
    fn build_quadlet(&self, raw: &mut [u8]);
    fn parse_quadlet(&mut self, raw: &[u8]);
}

/// For primitive u32 type and enumeration which has implementation to convert between u32.
impl<O> QuadletConvert<u32> for O
where
    u32: From<O>,
    O: From<u32> + Copy,
{
    fn build_quadlet(&self, raw: &mut [u8]) {
        assert_eq!(
            raw.len(),
            QUADLET_SIZE,
            "Programming error for length of quadlet data"
        );
        raw[..4].copy_from_slice(&u32::from(*self).to_be_bytes());
    }

    fn parse_quadlet(&mut self, raw: &[u8]) {
        assert_eq!(
            raw.len(),
            QUADLET_SIZE,
            "Programming error for length of quadlet data"
        );
        let mut quadlet = [0; 4];
        quadlet.copy_from_slice(&raw[..4]);
        *self = Self::from(u32::from_be_bytes(quadlet))
    }
}

/// For primitive i32 type.
impl QuadletConvert<i32> for i32 {
    fn build_quadlet(&self, raw: &mut [u8]) {
        assert_eq!(
            raw.len(),
            QUADLET_SIZE,
            "Programming error for length of quadlet data"
        );
        raw[..4].copy_from_slice(&i32::from(*self).to_be_bytes());
    }

    fn parse_quadlet(&mut self, raw: &[u8]) {
        assert_eq!(
            raw.len(),
            QUADLET_SIZE,
            "Programming error for length of quadlet data"
        );
        let mut quadlet = [0; 4];
        quadlet.copy_from_slice(&raw[..4]);
        *self = Self::from(i32::from_be_bytes(quadlet))
    }
}

/// For primitive bool type.
impl QuadletConvert<bool> for bool {
    fn build_quadlet(&self, raw: &mut [u8]) {
        assert_eq!(
            raw.len(),
            QUADLET_SIZE,
            "Programming error for length of quadlet data"
        );
        raw[..4].copy_from_slice(&u32::from(*self).to_be_bytes());
    }

    fn parse_quadlet(&mut self, raw: &[u8]) {
        assert_eq!(
            raw.len(),
            QUADLET_SIZE,
            "Programming error for length of quadlet data"
        );
        let mut quadlet = [0; 4];
        quadlet.copy_from_slice(&raw[..4]);
        *self = u32::from_be_bytes(quadlet) > 0;
    }
}

/// For primitive u8 type.
impl QuadletConvert<u8> for u8 {
    fn build_quadlet(&self, raw: &mut [u8]) {
        assert_eq!(
            raw.len(),
            QUADLET_SIZE,
            "Programming error for length of quadlet data"
        );
        raw[..4].copy_from_slice(&u32::from(*self).to_be_bytes());
    }

    fn parse_quadlet(&mut self, raw: &[u8]) {
        assert_eq!(
            raw.len(),
            QUADLET_SIZE,
            "Programming error for length of quadlet data"
        );
        let mut quadlet = [0; 4];
        quadlet.copy_from_slice(&raw[..4]);
        *self = u32::from_be_bytes(quadlet) as u8;
    }
}

/// For conversion between quadlet-aligned byte array and array of computed value.
trait QuadletBlockConvert<T> {
    fn build_quadlet_block(&self, raw: &mut [u8]);
    fn parse_quadlet_block(&mut self, raw: &[u8]);
}

impl<T, U> QuadletBlockConvert<T> for [U]
where
    U: QuadletConvert<T>,
{
    fn build_quadlet_block(&self, raw: &mut [u8]) {
        assert_eq!(
            raw.len(),
            self.len() * QUADLET_SIZE,
            "Programming error for length of block data."
        );

        self.iter().enumerate().for_each(|(i, v)| {
            let pos = i * 4;
            v.build_quadlet(&mut raw[pos..(pos + 4)]);
        });
    }

    fn parse_quadlet_block(&mut self, raw: &[u8]) {
        assert_eq!(
            raw.len(),
            self.len() * QUADLET_SIZE,
            "Programming error for length of block data."
        );

        self.iter_mut().enumerate().for_each(|(i, v)| {
            let pos = i * 4;
            v.parse_quadlet(&raw[pos..(pos + 4)]);
        });
    }
}