xmrs 0.14.7

Read, edit and serialize SoundTracker music with pleasure — MOD/XM/S3M/IT/DW import plus SID & OPL chip synthesis, no_std.
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
127
128
129
130
131
132
133
134
135
136
137
138
139

//! Original XM Pattern.
//!
//! Pattern header layout (9 bytes):
//! `pattern_header_len:u32 packing_type:u8 num_rows:u16 pattern_data_size:u16`.
//!
//! Pattern body: `pattern_data_size` bytes of packed `PatternSlot`s,
//! parsed by [`crate::tracker::import::patternslot::PatternSlot::load_xm`].

use alloc::{vec, vec::Vec};

use crate::tracker::import::bin_reader::{BinReader, ImportError};
use crate::tracker::import::patternslot::PatternSlot;

#[derive(Debug, Clone)]
pub struct XmPatternHeader {
    pattern_header_len: u32,
    packing_type: u8,
    num_rows: u16,
    pattern_data_size: u16,
}

impl Default for XmPatternHeader {
    fn default() -> Self {
        XmPatternHeader {
            pattern_header_len: 9,
            packing_type: 0,
            num_rows: 0,
            pattern_data_size: 0,
        }
    }
}

impl XmPatternHeader {
    pub fn new(size: usize) -> Self {
        XmPatternHeader {
            num_rows: size as u16,
            ..Self::default()
        }
    }

    pub fn load(data: &[u8]) -> Result<(&[u8], XmPatternHeader), ImportError> {
        let mut r = BinReader::new(data);
        let pattern_header_len = r.read_u32_le()?;
        let packing_type = r.read_u8()?;
        let num_rows = r.read_u16_le()?;
        let pattern_data_size = r.read_u16_le()?;
        // XM patterns are hard-limited to 256 rows (FT2 / OpenMPT).
        // `num_rows` is `u16` on disk; an out-of-range value drives
        // the empty-row padding in `get_slots` (which pads up to
        // `num_rows` rows of `number_of_channels` slots) into an
        // unbounded allocation. >256 is definitionally corrupt.
        if num_rows > 256 {
            return Err(ImportError::OutOfRange(
                "XmPatternHeader: num_rows exceeds XM maximum of 256",
            ));
        }
        let xmph = XmPatternHeader {
            pattern_header_len,
            packing_type,
            num_rows,
            pattern_data_size,
        };
        // The declared header length can be > 9 if a future XM
        // revision adds trailing bytes; honor it by skipping ahead
        // exactly that many bytes from the start of the header.
        let hl = xmph.pattern_header_len as usize;
        if hl > data.len() {
            return Err(ImportError::OutOfRange(
                "XmPatternHeader.pattern_header_len overshoots input",
            ));
        }
        Ok((&data[hl..], xmph))
    }
}

#[derive(Default, Debug, Clone)]
pub struct XmPattern {
    pub header: XmPatternHeader,
    pub pattern: Vec<Vec<PatternSlot>>,
}

impl XmPattern {
    pub fn new(rows: usize, noc: usize) -> Self {
        Self {
            header: XmPatternHeader::new(rows),
            pattern: vec![vec![PatternSlot::default(); noc]; rows],
        }
    }

    pub fn load(data: &[u8], number_of_channels: u16) -> Result<(&[u8], XmPattern), ImportError> {
        let (data, xmph) = XmPatternHeader::load(data)?;
        let body_len = xmph.pattern_data_size as usize;
        if body_len > data.len() {
            return Err(ImportError::OutOfRange(
                "XmPattern.pattern_data_size overshoots input",
            ));
        }
        let (_data_out, xmps) = Self::get_slots(
            &data[0..body_len],
            number_of_channels as usize,
            xmph.num_rows as usize,
        )?;
        let xmp = Self {
            header: xmph,
            pattern: xmps,
        };
        Ok((&data[body_len..], xmp))
    }

    fn get_empty_line(number_of_channels: usize) -> Vec<PatternSlot> {
        vec![PatternSlot::default(); number_of_channels]
    }

    fn get_slots(
        data: &[u8],
        number_of_channels: usize,
        number_of_rows: usize,
    ) -> Result<(&[u8], Vec<Vec<PatternSlot>>), ImportError> {
        let mut lines: Vec<Vec<PatternSlot>> = vec![];
        let mut row: Vec<PatternSlot> = vec![];

        let mut d2 = data;
        while !d2.is_empty() {
            let (d3, xps) = PatternSlot::load_xm(d2)?;
            d2 = d3;
            row.push(xps);
            if row.len() == number_of_channels {
                lines.push(row);
                row = vec![];
            }
        }

        while lines.len() < number_of_rows {
            lines.push(Self::get_empty_line(number_of_channels));
        }

        Ok((d2, lines))
    }
}