Skip to main content

unityrs_testkit/
fsb5.rs

1//! Synthetic FSB5 banks and hostile inputs, shared by fuzz seeds and tests.
2//! Format facts only: 60/64-byte headers, 32-byte data offsets, packed records.
3use 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
16/// Build a bank, with optional names and extra metadata chunks.
17pub 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
96/// Visit PCM/ADPCM banks of both versions, passthroughs and hostile inputs.
97pub 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                // Coefficient and shift nibbles span all sixteen classes.
220                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}