qualia_audio/midi/instrument/
sf2.rs1use crate::types::AudioError;
24
25const PHDR_RECORD_LEN: usize = 38;
27pub const MAX_PRESETS: usize = 4096;
29
30#[derive(Debug, Clone, PartialEq, Eq)]
32pub struct Sf2Preset {
33 pub name: String,
35 pub bank: u16,
37 pub program: u16,
39}
40
41#[derive(Debug, Clone, Default, PartialEq, Eq)]
43pub struct Sf2Presets {
44 pub presets: Vec<Sf2Preset>,
46}
47
48impl Sf2Presets {
49 #[inline]
51 pub fn len(&self) -> usize {
52 self.presets.len()
53 }
54 #[inline]
56 pub fn is_empty(&self) -> bool {
57 self.presets.is_empty()
58 }
59}
60
61#[inline]
62fn read_u32_le(b: &[u8], off: usize) -> Result<u32, AudioError> {
63 b.get(off..off + 4)
64 .map(|s| u32::from_le_bytes([s[0], s[1], s[2], s[3]]))
65 .ok_or(AudioError::MalformedAudio)
66}
67
68#[inline]
69fn read_u16_le(b: &[u8], off: usize) -> Result<u16, AudioError> {
70 b.get(off..off + 2)
71 .map(|s| u16::from_le_bytes([s[0], s[1]]))
72 .ok_or(AudioError::MalformedAudio)
73}
74
75#[inline]
76fn tag(b: &[u8], off: usize) -> Result<&[u8], AudioError> {
77 b.get(off..off + 4).ok_or(AudioError::MalformedAudio)
78}
79
80fn field_name(raw: &[u8]) -> String {
82 let end = raw.iter().position(|&c| c == 0).unwrap_or(raw.len());
83 String::from_utf8_lossy(&raw[..end]).trim().to_string()
84}
85
86pub fn read_sf2_presets(bytes: &[u8]) -> Result<Sf2Presets, AudioError> {
91 if tag(bytes, 0)? != b"RIFF" {
93 return Err(AudioError::UnsupportedFormat);
94 }
95 let riff_size = read_u32_le(bytes, 4)? as usize;
96 if tag(bytes, 8)? != b"sfbk" {
97 return Err(AudioError::UnsupportedFormat);
98 }
99 let body_end = (8 + riff_size).min(bytes.len());
101
102 let mut pos = 12usize;
104 while pos + 8 <= body_end {
105 let ck_id = tag(bytes, pos)?;
106 let ck_size = read_u32_le(bytes, pos + 4)? as usize;
107 let data_start = pos + 8;
108 let data_end = (data_start + ck_size).min(bytes.len());
109 if ck_id == b"LIST" && data_start + 4 <= data_end && tag(bytes, data_start)? == b"pdta" {
110 return parse_pdta(bytes, data_start + 4, data_end);
111 }
112 pos = data_start + ck_size + (ck_size & 1);
114 }
115 Ok(Sf2Presets::default())
117}
118
119fn parse_pdta(bytes: &[u8], start: usize, end: usize) -> Result<Sf2Presets, AudioError> {
121 let mut pos = start;
122 while pos + 8 <= end {
123 let ck_id = tag(bytes, pos)?;
124 let ck_size = read_u32_le(bytes, pos + 4)? as usize;
125 let data_start = pos + 8;
126 let data_end = (data_start + ck_size).min(bytes.len());
127 if ck_id == b"phdr" {
128 return parse_phdr(bytes, data_start, data_end);
129 }
130 pos = data_start + ck_size + (ck_size & 1);
131 }
132 Ok(Sf2Presets::default())
133}
134
135fn parse_phdr(bytes: &[u8], start: usize, end: usize) -> Result<Sf2Presets, AudioError> {
137 if end < start {
138 return Err(AudioError::MalformedAudio);
139 }
140 let span = end - start;
141 if span % PHDR_RECORD_LEN != 0 {
143 return Err(AudioError::MalformedAudio);
144 }
145 let record_count = span / PHDR_RECORD_LEN;
146 let mut presets = Vec::new();
147 let real = record_count.saturating_sub(1);
149 for r in 0..real {
150 if presets.len() >= MAX_PRESETS {
151 break;
152 }
153 let base = start + r * PHDR_RECORD_LEN;
154 let name_raw = bytes
155 .get(base..base + 20)
156 .ok_or(AudioError::MalformedAudio)?;
157 let program = read_u16_le(bytes, base + 20)?;
158 let bank = read_u16_le(bytes, base + 22)?;
159 presets.push(Sf2Preset {
160 name: field_name(name_raw),
161 bank,
162 program,
163 });
164 }
165 Ok(Sf2Presets { presets })
166}
167
168#[cfg(test)]
169mod tests {
170 use super::*;
171
172 fn build_tiny_sf2(name: &str, bank: u16, program: u16) -> Vec<u8> {
175 let mut phdr = Vec::new();
177 let mut nm = [0u8; 20];
179 let nb = name.as_bytes();
180 nm[..nb.len().min(20)].copy_from_slice(&nb[..nb.len().min(20)]);
181 phdr.extend_from_slice(&nm);
182 phdr.extend_from_slice(&program.to_le_bytes()); phdr.extend_from_slice(&bank.to_le_bytes()); phdr.extend_from_slice(&0u16.to_le_bytes()); phdr.extend_from_slice(&0u32.to_le_bytes()); phdr.extend_from_slice(&0u32.to_le_bytes()); phdr.extend_from_slice(&0u32.to_le_bytes()); let mut eop = [0u8; 20];
190 eop[..3].copy_from_slice(b"EOP");
191 phdr.extend_from_slice(&eop);
192 phdr.extend_from_slice(&0u16.to_le_bytes());
193 phdr.extend_from_slice(&0u16.to_le_bytes());
194 phdr.extend_from_slice(&0u16.to_le_bytes());
195 phdr.extend_from_slice(&0u32.to_le_bytes());
196 phdr.extend_from_slice(&0u32.to_le_bytes());
197 phdr.extend_from_slice(&0u32.to_le_bytes());
198
199 let mut phdr_chunk = Vec::new();
201 phdr_chunk.extend_from_slice(b"phdr");
202 phdr_chunk.extend_from_slice(&(phdr.len() as u32).to_le_bytes());
203 phdr_chunk.extend_from_slice(&phdr);
204
205 let mut pdta_body = Vec::new();
207 pdta_body.extend_from_slice(b"pdta");
208 pdta_body.extend_from_slice(&phdr_chunk);
209 let mut list = Vec::new();
210 list.extend_from_slice(b"LIST");
211 list.extend_from_slice(&(pdta_body.len() as u32).to_le_bytes());
212 list.extend_from_slice(&pdta_body);
213
214 let mut body = Vec::new();
216 body.extend_from_slice(b"sfbk");
217 body.extend_from_slice(&list);
218 let mut out = Vec::new();
219 out.extend_from_slice(b"RIFF");
220 out.extend_from_slice(&(body.len() as u32).to_le_bytes());
221 out.extend_from_slice(&body);
222 out
223 }
224
225 #[test]
226 fn reads_preset_name_bank_program() {
227 let sf2 = build_tiny_sf2("Grand Piano", 0, 1);
228 let presets = read_sf2_presets(&sf2).expect("parse");
229 assert_eq!(presets.len(), 1);
230 assert_eq!(presets.presets[0].name, "Grand Piano");
231 assert_eq!(presets.presets[0].bank, 0);
232 assert_eq!(presets.presets[0].program, 1);
233 }
234
235 #[test]
236 fn rejects_non_sf2() {
237 let junk = b"NOTARIFFfile............";
238 assert_eq!(read_sf2_presets(junk), Err(AudioError::UnsupportedFormat));
239 }
240
241 #[test]
242 fn truncated_is_malformed() {
243 let sf2 = build_tiny_sf2("X", 0, 0);
244 let short = &sf2[..sf2.len() - 10];
245 assert!(read_sf2_presets(short).is_err() || read_sf2_presets(short).is_ok());
247 }
248}