xmrs 0.12.2

A library to edit SoundTracker data with pleasure
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

//! Fast Tracker II XI instrument file.
//!
//! Header layout (66 bytes):
//! ```text
//! [u8;21]  id_text ("Extended Instrument: ")
//! [u8;22]  name
//! u8       0x1A (CP/M EOF marker)
//! [u8;20]  tracker_name
//! u16      version_number
//! ```
//! followed by an [`XmInstrDefault`] (215 bytes), 15 reserved bytes,
//! `num_samples:u16`, then `num_samples × XmSampleHeader` + bodies.

use alloc::boxed::Box;
use alloc::string::String;
use alloc::string::ToString;
use alloc::vec;

use crate::import::bin_reader::{bytes_to_trimmed_string, BinReader, ImportError};

use super::xminstrument::{
    XmInstrDefault, XmInstrument, XmInstrumentHeader, XmInstrumentType, XMINSTRUMENT_HEADER_SIZE,
};
use super::xmsample::{XmSample, XMSAMPLE_HEADER_SIZE};

#[derive(Debug)]
pub struct XiInstrumentHeader {
    id_text: String, // "Extended Instrument: "
    name: String,
    right_arrow: u8, // 0x1A CP/M EOF marker
    tracker_name: String,
    version_number: u16,
}

impl Default for XiInstrumentHeader {
    fn default() -> Self {
        Self {
            id_text: "Extended Instrument: ".to_string(),
            name: "".to_string(),
            right_arrow: 0x1A,
            tracker_name: "XMrs".to_string(),
            version_number: 0x0104,
        }
    }
}

#[derive(Debug)]
pub struct XiInstrument {
    header: XiInstrumentHeader,
    instr: XmInstrDefault,
    reserved: [u8; 15],
    num_samples: u16,
}

impl XiInstrument {
    pub fn load(data: &[u8]) -> Result<XmInstrument, ImportError> {
        let mut r = BinReader::new(data);

        // XiInstrumentHeader (66 bytes).
        let id_bytes: [u8; 21] = r.read_array()?;
        let name_bytes: [u8; 22] = r.read_array()?;
        let right_arrow = r.read_u8()?;
        let tracker_bytes: [u8; 20] = r.read_array()?;
        let version_number = r.read_u16_le()?;

        let header = XiInstrumentHeader {
            id_text: bytes_to_trimmed_string(&id_bytes),
            name: bytes_to_trimmed_string(&name_bytes),
            right_arrow,
            tracker_name: bytes_to_trimmed_string(&tracker_bytes),
            version_number,
        };
        if header.id_text != "Extended Instrument:" {
            return Err(ImportError::InvalidMagic("Not an Extended Instrument?"));
        }

        let instr = XmInstrDefault::read(&mut r)?;
        let _reserved: [u8; 15] = r.read_array()?;
        let num_samples = r.read_u16_le()?;
        let data_after_header = r.tail();

        let xm_header = XmInstrumentHeader {
            name: header.name,
            instr_type: 0,
            num_samples,
        };

        if num_samples == 0 {
            return Ok(XmInstrument {
                instrument_header_len: 4 + XMINSTRUMENT_HEADER_SIZE as u32,
                header: xm_header,
                sample_header_size: XMSAMPLE_HEADER_SIZE as u32,
                instr: XmInstrumentType::Default(Box::new(instr)),
                sample: vec![],
            });
        }

        // all sample headers, then bodies
        let mut sample = vec![];
        let mut d3 = data_after_header;
        for _ in 0..num_samples {
            let (d, s) = XmSample::load(d3)?;
            sample.push(s);
            d3 = d;
        }
        for s in &mut sample {
            let d = s.add_sample(d3)?;
            d3 = d;
        }

        Ok(XmInstrument {
            instrument_header_len: 4 + XMINSTRUMENT_HEADER_SIZE as u32,
            header: xm_header,
            sample_header_size: XMSAMPLE_HEADER_SIZE as u32,
            instr: XmInstrumentType::Default(Box::new(instr)),
            sample,
        })
    }
}