1use std::io;
4
5type Entry<'a> = (&'a [u8], u32, u8, u8, &'a [(u32, &'a [u8])]);
6
7fn append(out: &mut Vec<u8>, bytes: &[u8]) -> io::Result<()> {
8 out.try_reserve(bytes.len()).map_err(io::Error::other)?;
9 out.extend_from_slice(bytes);
10 Ok(())
11}
12fn word(n: usize) -> io::Result<[u8; 4]> {
13 Ok(u32::try_from(n).map_err(io::Error::other)?.to_le_bytes())
14}
15
16pub fn bank(
18 mode: u32,
19 entries: &[Entry<'_>],
20 version: u32,
21 names: Option<&[&[u8]]>,
22) -> io::Result<Vec<u8>> {
23 let (mut headers, mut data, mut table) = (Vec::new(), Vec::new(), Vec::new());
24 for &(payload, frames, channels, rate, chunks) in entries {
25 let padding = (32 - data.len() % 32) % 32;
26 append(&mut data, &[0; 32][..padding])?;
27 let channels = match channels {
28 1 => 0u64,
29 2 => 1,
30 6 => 2,
31 8 => 3,
32 _ => return Err(io::Error::other("FSB5 builder channels")),
33 };
34 let offset = u64::try_from(data.len() / 32).map_err(io::Error::other)?;
35 if offset > 0x07ff_ffff || rate > 15 || frames > 0x3fff_ffff {
36 return Err(io::Error::other("FSB5 builder record overflow"));
37 }
38 let raw = u64::from(!chunks.is_empty())
39 | u64::from(rate) << 1
40 | channels << 5
41 | offset << 7
42 | u64::from(frames) << 34;
43 append(&mut headers, &raw.to_le_bytes())?;
44 for (i, &(kind, value)) in chunks.iter().enumerate() {
45 let size = u32::try_from(value.len()).map_err(io::Error::other)?;
46 if kind > 127 || size > 0x00ff_ffff {
47 return Err(io::Error::other("FSB5 builder chunk overflow"));
48 }
49 let raw = kind << 25 | size << 1 | u32::from(i + 1 < chunks.len());
50 append(&mut headers, &raw.to_le_bytes())?;
51 append(&mut headers, value)?;
52 }
53 append(&mut data, payload)?;
54 }
55 if let Some(names) = names {
56 let mut strings = Vec::new();
57 let offsets = names
58 .len()
59 .checked_mul(4)
60 .ok_or_else(|| io::Error::other("name offsets overflow"))?;
61 for name in names {
62 let at = offsets
63 .checked_add(strings.len())
64 .ok_or_else(|| io::Error::other("name offset overflow"))?;
65 append(&mut table, &word(at)?)?;
66 append(&mut strings, name)?;
67 append(&mut strings, &[0])?;
68 }
69 append(&mut table, &strings)?;
70 }
71 let header_size = match version {
72 0 => 64,
73 1 => 60,
74 _ => return Err(io::Error::other("FSB5 builder version")),
75 };
76 let mut out = Vec::new();
77 append(&mut out, b"FSB5")?;
78 for n in [
79 version.to_le_bytes(),
80 word(entries.len())?,
81 word(headers.len())?,
82 word(table.len())?,
83 word(data.len())?,
84 mode.to_le_bytes(),
85 ] {
86 append(&mut out, &n)?;
87 }
88 let padding = header_size - out.len();
89 append(&mut out, &[0; 64][..padding])?;
90 append(&mut out, &headers)?;
91 append(&mut out, &table)?;
92 append(&mut out, &data)?;
93 Ok(out)
94}
95
96pub fn seeds(mut add: impl FnMut(&str, &[u8]) -> io::Result<()>) -> io::Result<()> {
98 for (name, data) in [
99 ("ogg", b"OggSsynthetic".as_slice()),
100 ("riff", b"RIFFsynthetic"),
101 ("m4a", b"\0\0\0\x10ftypM4A synthetic"),
102 ("riff_before_m4a", b"RIFFftyp"),
103 ("legacy_ogg", b"OggSlegacy"),
104 ("legacy_non_passthrough", b"FORMsynthetic"),
105 ] {
106 add(name, data)?;
107 }
108 let pcm = [
109 0, 128, 0, 192, 255, 255, 0, 0, 1, 0, 210, 4, 0, 64, 255, 127,
110 ];
111 pcm_rates(&mut add, &pcm)?;
112 add("version0", &bank(2, &[(&pcm, 8, 1, 8, &[])], 0, None)?)?;
113 add(
114 "named_multi",
115 &bank(
116 2,
117 &[(&pcm, 8, 1, 8, &[]), (&pcm[..8], 2, 2, 9, &[])],
118 1,
119 Some(&[b"first", b"second"]),
120 )?,
121 )?;
122 add(
123 "overrides",
124 &bank(
125 2,
126 &[(&pcm, 8, 1, 0, &[(1, &[1]), (2, &12345u32.to_le_bytes())])],
127 1,
128 None,
129 )?,
130 )?;
131 add(
132 "short_mono",
133 &bank(2, &[(&pcm[..2], 1, 1, 8, &[])], 1, None)?,
134 )?;
135 add(
136 "later_empty",
137 &bank(2, &[(&pcm, 8, 1, 8, &[]), (&[], 0, 1, 8, &[])], 1, None)?,
138 )?;
139 add(
140 "empty_first",
141 &bank(2, &[(&[], 0, 1, 8, &[]), (&pcm, 8, 1, 8, &[])], 1, None)?,
142 )?;
143 for (mode, width, name, v0) in [
144 (1, 1, "refused_pcm1", "pcm1_v0"),
145 (3, 3, "refused_pcm3", "pcm3_v0"),
146 (4, 4, "refused_pcm4", "pcm4_v0"),
147 (5, 4, "refused_pcm5", "pcm5_v0"),
148 ] {
149 let entry = (&[0; 24][..], 24 / width, 1, 8, &[][..]);
150 add(name, &bank(mode, &[entry], 1, None)?)?;
151 add(v0, &bank(mode, &[entry], 0, None)?)?;
152 }
153 for (mode, name) in [
154 (11, "deferred_codec11"),
155 (15, "deferred_codec15"),
156 (17, "deferred_codec17"),
157 ] {
158 add(name, &bank(mode, &[(&[0; 64], 32, 1, 8, &[])], 1, None)?)?;
159 }
160 adpcm_seeds(&mut add)?;
161 let good = bank(2, &[(&pcm, 8, 1, 8, &[])], 1, None)?;
162 for (name, at, value) in [
163 ("hostile_count", 8, u32::MAX),
164 ("hostile_headers", 12, u32::MAX),
165 ("hostile_names", 16, u32::MAX),
166 ("hostile_data", 20, u32::MAX),
167 ("hostile_version", 4, 9),
168 ] {
169 let mut hostile = Vec::new();
170 append(&mut hostile, &good)?;
171 hostile[at..at + 4].copy_from_slice(&value.to_le_bytes());
172 add(name, &hostile)?;
173 }
174 add("truncated", &good[..good.len() - 1])?;
175 let bad_name = bank(2, &[(&pcm, 8, 1, 8, &[])], 1, Some(&[b"broken"]))?;
176 add("bad_name", &bad_name[..bad_name.len() - 17])
177}
178
179fn adpcm_seeds(add: &mut impl FnMut(&str, &[u8]) -> io::Result<()>) -> io::Result<()> {
180 for (mode, size, samples, labels) in [
181 (
182 7,
183 0x24,
184 64,
185 [
186 "ima_mono",
187 "ima_stereo",
188 "ima_6ch",
189 "ima_8ch",
190 "ima_3ch",
191 "ima_short_last",
192 "ima_short_first",
193 "ima_trailing",
194 "ima_next",
195 "ima_large",
196 ],
197 ),
198 (
199 16,
200 0x8c,
201 256,
202 [
203 "fadpcm_mono",
204 "fadpcm_stereo",
205 "fadpcm_6ch",
206 "fadpcm_8ch",
207 "fadpcm_3ch",
208 "fadpcm_short_last",
209 "fadpcm_short_first",
210 "fadpcm_trailing",
211 "fadpcm_next",
212 "fadpcm_large",
213 ],
214 ),
215 ] {
216 let mut payload = [0x12; 0x8c * 8 * 3];
217 if mode == 16 {
218 for (i, frame) in payload.as_chunks_mut::<0x8c>().0.iter_mut().enumerate() {
219 let patterns = [
221 [0x10, 0x32, 0x54, 0x76, 0x98, 0xba, 0xdc, 0xfe],
222 [0x98, 0xba, 0xdc, 0xfe, 0x10, 0x32, 0x54, 0x76],
223 ];
224 frame[..8].copy_from_slice(&patterns[i % 2]);
225 }
226 }
227 for (channel, label, old_label) in [
228 (
229 1,
230 labels[0],
231 if mode == 7 {
232 "ima_mono_v0"
233 } else {
234 "fadpcm_mono_v0"
235 },
236 ),
237 (
238 2,
239 labels[1],
240 if mode == 7 {
241 "ima_stereo_v0"
242 } else {
243 "fadpcm_stereo_v0"
244 },
245 ),
246 (
247 6,
248 labels[2],
249 if mode == 7 {
250 "ima_6ch_v0"
251 } else {
252 "fadpcm_6ch_v0"
253 },
254 ),
255 (
256 8,
257 labels[3],
258 if mode == 7 {
259 "ima_8ch_v0"
260 } else {
261 "fadpcm_8ch_v0"
262 },
263 ),
264 ] {
265 let entry = (
266 &payload[..size * usize::from(channel) * 3],
267 samples * 3,
268 channel,
269 8,
270 &[][..],
271 );
272 add(label, &bank(mode, &[entry], 1, None)?)?;
273 add(old_label, &bank(mode, &[entry], 0, None)?)?;
274 }
275 adpcm_edges(add, mode, size, samples, labels, &payload)?;
276 }
277 ima_bad_steps(add)
278}
279
280fn ima_bad_steps(add: &mut impl FnMut(&str, &[u8]) -> io::Result<()>) -> io::Result<()> {
281 for (channels, step_offset, label) in [
282 (1, 2, "ima_bad_mono"),
283 (2, 6, "ima_bad_stereo"),
284 (6, 18, "ima_bad_6ch"),
285 ] {
286 let mut payload = [0x12; 0x24 * 6 * 3];
287 payload[0x24 * usize::from(channels) + step_offset] = 255;
288 add(
289 label,
290 &bank(
291 7,
292 &[(
293 &payload[..0x24 * usize::from(channels) * 3],
294 192,
295 channels,
296 8,
297 &[],
298 )],
299 1,
300 None,
301 )?,
302 )?;
303 }
304 Ok(())
305}
306
307fn adpcm_edges(
308 add: &mut impl FnMut(&str, &[u8]) -> io::Result<()>,
309 mode: u32,
310 size: usize,
311 samples: u32,
312 labels: [&str; 10],
313 payload: &[u8],
314) -> io::Result<()> {
315 add(
316 labels[4],
317 &bank(
318 mode,
319 &[(&payload[..size * 9], samples * 3, 1, 8, &[(1, &[3])])],
320 1,
321 None,
322 )?,
323 )?;
324 add(
325 labels[5],
326 &bank(
327 mode,
328 &[(&payload[..size * 4 - 1], samples * 2, 2, 8, &[])],
329 1,
330 None,
331 )?,
332 )?;
333 add(
334 labels[6],
335 &bank(
336 mode,
337 &[(&payload[..size * 2 - 1], samples, 2, 8, &[])],
338 1,
339 None,
340 )?,
341 )?;
342 let mut trailing = bank(mode, &[(&payload[..size], samples * 3, 1, 8, &[])], 1, None)?;
343 append(&mut trailing, &payload[..size])?;
344 add(labels[7], &trailing)?;
345 add(
346 labels[8],
347 &bank(
348 mode,
349 &[
350 (&payload[..16], samples * 4, 1, 8, &[]),
351 (&payload[..size * 2], samples * 2, 1, 8, &[]),
352 ],
353 1,
354 None,
355 )?,
356 )?;
357 add(
358 labels[9],
359 &bank(mode, &[(&payload[..size], 1 << 20, 1, 8, &[])], 1, None)?,
360 )?;
361 Ok(())
362}
363
364fn pcm_rates(add: &mut impl FnMut(&str, &[u8]) -> io::Result<()>, pcm: &[u8]) -> io::Result<()> {
365 let labels = [
366 [
367 "pcm16_c1_r0",
368 "pcm16_c1_r1",
369 "pcm16_c1_r2",
370 "pcm16_c1_r3",
371 "pcm16_c1_r4",
372 "pcm16_c1_r5",
373 "pcm16_c1_r6",
374 "pcm16_c1_r7",
375 "pcm16_c1_r8",
376 "pcm16_c1_r9",
377 "pcm16_c1_r10",
378 ],
379 [
380 "pcm16_c2_r0",
381 "pcm16_c2_r1",
382 "pcm16_c2_r2",
383 "pcm16_c2_r3",
384 "pcm16_c2_r4",
385 "pcm16_c2_r5",
386 "pcm16_c2_r6",
387 "pcm16_c2_r7",
388 "pcm16_c2_r8",
389 "pcm16_c2_r9",
390 "pcm16_c2_r10",
391 ],
392 ];
393 for (channels, labels) in (1..=2).zip(labels) {
394 for (rate, name) in (0..=10).zip(labels) {
395 add(
396 name,
397 &bank(
398 2,
399 &[(pcm, 8 / u32::from(channels), channels, rate, &[])],
400 1,
401 None,
402 )?,
403 )?;
404 }
405 }
406 Ok(())
407}