cridecoder 0.3.2__tar.gz → 0.3.3__tar.gz

{cridecoder-0.3.2 → cridecoder-0.3.3}/Cargo.lock

@@ -28,7 +28,7 @@ checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
 name = "cridecoder"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "byteorder",
  "encoding_rs",

{cridecoder-0.3.2 → cridecoder-0.3.3}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cridecoder"
-version = "0.3.2"
+version = "0.3.3"
 edition = "2021"
 description = "CRI codec library for ACB/AWB, HCA audio, and USM video extraction"
 license = "MIT"

{cridecoder-0.3.2 → cridecoder-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cridecoder
-Version: 0.3.2
+Version: 0.3.3
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{cridecoder-0.3.2 → cridecoder-0.3.3}/cridecoder.pyi

@@ -11,6 +11,7 @@ __all__ = [
     "extract_acb",
     "extract_acb_tracks",
     "extract_acb_bytes",
+    "extract_acb_unique_bytes",
     "decode_acb_to_wav",
     "decode_acb_to_wav_bytes",
     "build_acb",
@@ -58,6 +59,17 @@ def extract_acb_bytes(acb_data: bytes) -> list[dict[str, object]]:
     """
     ...
 
+def extract_acb_unique_bytes(acb_data: bytes) -> list[dict[str, object]]:
+    """Extract each distinct waveform from in-memory ACB bytes exactly once.
+
+    ACBs often point several cues at one physical waveform; unlike
+    :func:`extract_acb_bytes` (which copies it once per cue), this copies each
+    waveform a single time. Returns a list of dicts
+    ``{"extension", "subkey", "data", "cues"}`` where ``data`` is ``bytes`` and
+    ``cues`` is a list of ``{"name", "cue_id"}`` (at least one entry).
+    """
+    ...
+
 def decode_acb_to_wav(
     acb_path: str, output_dir: str, key: Optional[int] = ...
 ) -> list[str]:

cridecoder-0.3.3/examples/profile_acb.rs

@@ -0,0 +1,55 @@
+//! Micro-profile of ACB extraction stages on a real ACB.
+//! Usage: cargo run --release --example profile_acb -- <path-to.acb>
+
+use std::io::Cursor;
+use std::time::Instant;
+
+use cridecoder::acb::{AfsArchive, TrackList, UtfTable};
+
+fn time<T>(label: &str, rounds: u32, mut f: impl FnMut() -> T) -> T {
+    for _ in 0..3 {
+        std::hint::black_box(f());
+    }
+    let mut best = f64::INFINITY;
+    let mut last = None;
+    for _ in 0..rounds {
+        let t0 = Instant::now();
+        let r = std::hint::black_box(f());
+        best = best.min(t0.elapsed().as_secs_f64());
+        last = Some(r);
+    }
+    println!("  {label:40} best={:8.4} ms", best * 1000.0);
+    last.unwrap()
+}
+
+fn main() {
+    let path = std::env::args().nth(1).expect("usage: profile_acb <acb>");
+    let data = std::fs::read(&path).unwrap();
+    println!("ACB: {} ({} bytes)\n", path, data.len());
+    let rounds = 300;
+
+    time("UtfTable::new (outer)", rounds, || {
+        UtfTable::new(Cursor::new(&data)).unwrap()
+    });
+
+    time("UtfTable::new + TrackList::new", rounds, || {
+        let utf = UtfTable::new(Cursor::new(&data)).unwrap();
+        TrackList::new(&utf).unwrap()
+    });
+
+    time("+ build embedded AFS2", rounds, || {
+        let utf = UtfTable::new(Cursor::new(&data)).unwrap();
+        let _tl = TrackList::new(&utf).unwrap();
+        let awb = utf.rows[0]
+            .get("AwbFile")
+            .unwrap()
+            .as_bytes()
+            .unwrap()
+            .to_vec();
+        AfsArchive::new(Cursor::new(awb)).unwrap()
+    });
+
+    time("extract_acb_to_memory (full)", rounds, || {
+        cridecoder::extract_acb_to_memory(Cursor::new(&data), None).unwrap()
+    });
+}

{cridecoder-0.3.2 → cridecoder-0.3.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "cridecoder"
-version = "0.3.2"
+version = "0.3.3"
 description = "CRI codec library for ACB/AWB, HCA audio, and USM video extraction"
 readme = "README.md"
 license = { text = "MIT" }

{cridecoder-0.3.2 → cridecoder-0.3.3}/src/acb/decode.rs

@@ -4,13 +4,13 @@
 //! an ACB to decoded audio without managing the intermediate HCA bytes
 //! themselves. The per-AWB AFS2 subkey is applied automatically.
 
-use std::fs::{self, File};
+use std::fs;
 use std::io::{Cursor, Read, Seek};
 use std::path::Path;
 
 use thiserror::Error;
 
-use crate::acb::extractor::{extract_acb_to_memory, ExtractError};
+use crate::acb::extractor::{extract_acb_to_memory, read_validated_acb, ExtractError};
 use crate::hca::{HcaDecoder, HcaDecoderError};
 
 /// A decoded ACB track held in memory.
@@ -102,6 +102,11 @@ pub fn decode_acb_to_wav_from_file(
     target_dir: &Path,
     key: Option<u64>,
 ) -> Result<Vec<String>, DecodeAcbError> {
-    let file = File::open(acb_path)?;
-    decode_acb_to_wav(file, target_dir, Some(acb_path), key)
+    // Slurp once so the parser reads from memory instead of issuing many small
+    // syscalls against the file handle.
+    let data = match read_validated_acb(acb_path)? {
+        Some(d) => d,
+        None => return Ok(Vec::new()),
+    };
+    decode_acb_to_wav(Cursor::new(data), target_dir, Some(acb_path), key)
 }

{cridecoder-0.3.2 → cridecoder-0.3.3}/src/acb/extractor.rs

@@ -3,8 +3,9 @@
 use crate::acb::afs::AfsArchive;
 use crate::acb::consts::wave_type_extension;
 use crate::acb::track::{Track, TrackList};
-use crate::acb::utf::{get_bytes_field, get_string_field, UtfTable};
-use std::fs::{self, File};
+use crate::acb::utf::{get_bytes_field, get_string_field, take_bytes_field, UtfTable};
+use std::collections::HashMap;
+use std::fs;
 use std::io::{Cursor, Read, Seek};
 use std::path::Path;
 use thiserror::Error;
@@ -42,11 +43,11 @@ pub fn extract_acb<R: Read + Seek>(
     target_dir: &Path,
     acb_file_path: Option<&Path>,
 ) -> Result<Vec<String>, ExtractError> {
-    let utf = UtfTable::new(acb_file)?;
+    let mut utf = UtfTable::new(acb_file)?;
 
     let track_list = TrackList::new(&utf)?;
 
-    let mut embedded_awb = load_embedded_awb(&utf.rows[0]);
+    let mut embedded_awb = load_embedded_awb(&mut utf.rows[0]);
     let mut external_awbs = load_external_awbs(&utf.rows[0], acb_file_path);
 
     extract_all_tracks(
@@ -62,9 +63,9 @@ pub fn extract_acb_to_memory<R: Read + Seek>(
     acb_file: R,
     acb_file_path: Option<&Path>,
 ) -> Result<Vec<ExtractedAcbTrack>, ExtractError> {
-    let utf = UtfTable::new(acb_file)?;
+    let mut utf = UtfTable::new(acb_file)?;
     let track_list = TrackList::new(&utf)?;
-    let mut embedded_awb = load_embedded_awb(&utf.rows[0]);
+    let mut embedded_awb = load_embedded_awb(&mut utf.rows[0]);
     let mut external_awbs = load_external_awbs(&utf.rows[0], acb_file_path);
 
     let mut outputs = Vec::new();
@@ -73,16 +74,10 @@ pub fn extract_acb_to_memory<R: Read + Seek>(
             Some(data) => data,
             None => continue,
         };
-        let extension = wave_type_extension(track.enc_type);
-        let extension = if extension.is_empty() {
-            track.enc_type.to_string()
-        } else {
-            extension.trim_start_matches('.').to_string()
-        };
         outputs.push(ExtractedAcbTrack {
             name: track.name.clone(),
             cue_id: track.cue_id,
-            extension,
+            extension: track_extension(track),
             data,
             subkey,
         });
@@ -91,12 +86,86 @@ pub fn extract_acb_to_memory<R: Read + Seek>(
     Ok(outputs)
 }
 
-fn load_embedded_awb(row: &crate::acb::utf::ValueMap) -> Option<AfsArchive<Cursor<Vec<u8>>>> {
-    let awb_data = get_bytes_field(row, "AwbFile")?;
+/// A cue that references a waveform.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct AcbCueRef {
+    pub name: String,
+    pub cue_id: i32,
+}
+
+/// A distinct (de-duplicated) waveform from an ACB, with every cue that maps to
+/// it. ACBs frequently point multiple cues at one physical waveform.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct UniqueWaveform {
+    pub extension: String,
+    /// AFS2 subkey of the originating AWB (0 if unencrypted).
+    pub subkey: u16,
+    pub data: Vec<u8>,
+    /// All cues that reference this waveform (always at least one).
+    pub cues: Vec<AcbCueRef>,
+}
+
+/// Extract each distinct waveform from an ACB exactly once, together with the
+/// cues that reference it. The per-cue extractors read and copy a shared
+/// waveform once per cue; this reads and copies each waveform a single time.
+pub fn extract_acb_unique_to_memory<R: Read + Seek>(
+    acb_file: R,
+    acb_file_path: Option<&Path>,
+) -> Result<Vec<UniqueWaveform>, ExtractError> {
+    let mut utf = UtfTable::new(acb_file)?;
+    let track_list = TrackList::new(&utf)?;
+    let mut embedded_awb = load_embedded_awb(&mut utf.rows[0]);
+    let mut external_awbs = load_external_awbs(&utf.rows[0], acb_file_path);
+
+    // A physical waveform is identified by which AWB it lives in plus its id.
+    let mut seen: HashMap<(bool, i32, i32), usize> = HashMap::new();
+    let mut out: Vec<UniqueWaveform> = Vec::new();
+
+    for track in &track_list.tracks {
+        let key = (track.is_stream, track.stream_awb_id, track.wav_id);
+        let cue = AcbCueRef {
+            name: track.name.clone(),
+            cue_id: track.cue_id,
+        };
+        if let Some(&idx) = seen.get(&key) {
+            out[idx].cues.push(cue);
+            continue;
+        }
+        let (data, subkey) = match get_track_data(track, &mut embedded_awb, &mut external_awbs)? {
+            Some(d) => d,
+            None => continue,
+        };
+        seen.insert(key, out.len());
+        out.push(UniqueWaveform {
+            extension: track_extension(track),
+            subkey,
+            data,
+            cues: vec![cue],
+        });
+    }
+
+    Ok(out)
+}
+
+/// Output extension for a track's waveform (no leading dot; falls back to the
+/// numeric encode type for unknown formats).
+fn track_extension(track: &Track) -> String {
+    let ext = wave_type_extension(track.enc_type);
+    if ext.is_empty() {
+        track.enc_type.to_string()
+    } else {
+        ext.trim_start_matches('.').to_string()
+    }
+}
+
+fn load_embedded_awb(row: &mut crate::acb::utf::ValueMap) -> Option<AfsArchive<Cursor<Vec<u8>>>> {
+    // Move the embedded AWB bytes out of the UTF cell rather than cloning them
+    // (the embedded AWB is often several MB).
+    let awb_data = take_bytes_field(row, "AwbFile")?;
     if awb_data.is_empty() {
         return None;
     }
-    AfsArchive::new(Cursor::new(awb_data.to_vec())).ok()
+    AfsArchive::new(Cursor::new(awb_data)).ok()
 }
 
 fn load_external_awbs(
@@ -233,9 +302,9 @@ pub fn extract_acb_tracks<R: Read + Seek>(
     target_dir: &Path,
     acb_file_path: Option<&Path>,
 ) -> Result<Vec<ExtractedTrackFile>, ExtractError> {
-    let utf = UtfTable::new(acb_file)?;
+    let mut utf = UtfTable::new(acb_file)?;
     let track_list = TrackList::new(&utf)?;
-    let mut embedded_awb = load_embedded_awb(&utf.rows[0]);
+    let mut embedded_awb = load_embedded_awb(&mut utf.rows[0]);
     let mut external_awbs = load_external_awbs(&utf.rows[0], acb_file_path);
 
     fs::create_dir_all(target_dir)?;
@@ -281,30 +350,25 @@ fn extract_single_track_file(
     }))
 }
 
-/// Open and validate an ACB file, returning the seekable handle positioned at
-/// the start, or `None` if the path is missing or is not a valid ACB.
-fn open_validated_acb(acb_path: &Path) -> Result<Option<File>, ExtractError> {
-    let info = match fs::metadata(acb_path) {
-        Ok(i) => i,
+/// Read and validate an ACB file into memory, returning its bytes or `None` if
+/// the path is missing or is not a valid ACB.
+///
+/// Slurping the whole file once (instead of parsing straight from the `File`)
+/// turns the parser's many small `seek`/`read` calls into in-memory pointer
+/// math rather than syscalls — a large win on the file-based entry points.
+pub fn read_validated_acb(acb_path: &Path) -> Result<Option<Vec<u8>>, ExtractError> {
+    let data = match fs::read(acb_path) {
+        Ok(d) => d,
         Err(_) => return Ok(None),
     };
 
-    // A valid ACB file must have at least @UTF magic (4 bytes) + header (28 bytes) = 32 bytes
-    if info.len() < 32 {
+    // A valid ACB file must have at least @UTF magic (4 bytes) + header (28 bytes) = 32 bytes,
+    // and start with the @UTF magic (0x40 0x55 0x54 0x46).
+    if data.len() < 32 || data[0..4] != [0x40, 0x55, 0x54, 0x46] {
         return Ok(None);
     }
 
-    let mut file = File::open(acb_path)?;
-
-    // Read and validate the @UTF magic (0x40 0x55 0x54 0x46)
-    let mut header = [0u8; 4];
-    file.read_exact(&mut header)?;
-    if header != [0x40, 0x55, 0x54, 0x46] {
-        return Ok(None); // Not a valid ACB file
-    }
-
-    file.seek(std::io::SeekFrom::Start(0))?;
-    Ok(Some(file))
+    Ok(Some(data))
 }
 
 /// Convenience function to extract from a file path
@@ -312,11 +376,11 @@ pub fn extract_acb_from_file(
     acb_path: &Path,
     target_dir: &Path,
 ) -> Result<Option<Vec<String>>, ExtractError> {
-    let file = match open_validated_acb(acb_path)? {
-        Some(f) => f,
+    let data = match read_validated_acb(acb_path)? {
+        Some(d) => d,
         None => return Ok(None),
     };
-    let outputs = extract_acb(file, target_dir, Some(acb_path))?;
+    let outputs = extract_acb(Cursor::new(data), target_dir, Some(acb_path))?;
     Ok(Some(outputs))
 }
 
@@ -326,10 +390,10 @@ pub fn extract_acb_tracks_from_file(
     acb_path: &Path,
     target_dir: &Path,
 ) -> Result<Option<Vec<ExtractedTrackFile>>, ExtractError> {
-    let file = match open_validated_acb(acb_path)? {
-        Some(f) => f,
+    let data = match read_validated_acb(acb_path)? {
+        Some(d) => d,
         None => return Ok(None),
     };
-    let outputs = extract_acb_tracks(file, target_dir, Some(acb_path))?;
+    let outputs = extract_acb_tracks(Cursor::new(data), target_dir, Some(acb_path))?;
     Ok(Some(outputs))
 }

{cridecoder-0.3.2 → cridecoder-0.3.3}/src/acb/utf.rs

@@ -408,6 +408,15 @@ pub fn get_bytes_field<'a>(row: &'a ValueMap, key: &str) -> Option<&'a [u8]> {
     row.get(key).and_then(|v| v.as_bytes())
 }
 
+/// Move (take ownership of) a bytes field out of a row, leaving an empty
+/// placeholder. Avoids cloning large embedded blobs such as the embedded AWB.
+pub fn take_bytes_field(row: &mut ValueMap, key: &str) -> Option<Vec<u8>> {
+    match row.get_mut(key) {
+        Some(Value::Data(d)) => Some(std::mem::take(d)),
+        _ => None,
+    }
+}
+
 /// Helper to get string field from a row
 pub fn get_string_field<'a>(row: &'a ValueMap, key: &str) -> Option<&'a str> {
     row.get(key).and_then(|v| v.as_string())

{cridecoder-0.3.2 → cridecoder-0.3.3}/src/acb.rs

@@ -19,7 +19,8 @@ pub use decode::{
 };
 pub use extractor::{
     extract_acb, extract_acb_from_file, extract_acb_to_memory, extract_acb_tracks,
-    extract_acb_tracks_from_file, ExtractedAcbTrack, ExtractedTrackFile,
+    extract_acb_tracks_from_file, extract_acb_unique_to_memory, AcbCueRef, ExtractedAcbTrack,
+    ExtractedTrackFile, UniqueWaveform,
 };
 pub use track::{Track, TrackList};
 pub use utf::{UtfHeader, UtfTable, Value};

{cridecoder-0.3.2 → cridecoder-0.3.3}/src/lib.rs

@@ -20,7 +20,8 @@ pub use acb::{
 };
 pub use acb::{
     extract_acb, extract_acb_from_file, extract_acb_to_memory, extract_acb_tracks,
-    extract_acb_tracks_from_file, ExtractedAcbTrack, ExtractedTrackFile,
+    extract_acb_tracks_from_file, extract_acb_unique_to_memory, AcbCueRef, ExtractedAcbTrack,
+    ExtractedTrackFile, UniqueWaveform,
 };
 pub use acb::{AcbBuilder, AfsArchiveBuilder, BuilderError, TrackInput, UtfTableBuilder};
 

{cridecoder-0.3.2 → cridecoder-0.3.3}/src/python.rs

@@ -122,7 +122,7 @@ fn extract_acb_bytes<'py>(
     py: Python<'py>,
     acb_data: &[u8],
 ) -> PyResult<Vec<Bound<'py, pyo3::types::PyDict>>> {
-    let tracks = acb::extract_acb_to_memory(Cursor::new(acb_data.to_vec()), None)
+    let tracks = acb::extract_acb_to_memory(Cursor::new(acb_data), None)
         .map_err(|e| PyRuntimeError::new_err(format!("ACB extraction failed: {}", e)))?;
 
     let mut out = Vec::with_capacity(tracks.len());
@@ -138,6 +138,45 @@ fn extract_acb_bytes<'py>(
     Ok(out)
 }
 
+/// Extract each distinct waveform from in-memory ACB bytes exactly once.
+///
+/// ACBs often point several cues at the same physical waveform; unlike
+/// :func:`extract_acb_bytes` (which copies it once per cue), this reads and
+/// copies each waveform a single time and lists the cues that reference it.
+///
+/// Args:
+///     acb_data: Raw ACB file bytes
+///
+/// Returns:
+///     List of dicts ``{"extension", "subkey", "data", "cues"}`` where ``cues``
+///     is a list of ``{"name", "cue_id"}`` (at least one).
+#[pyfunction]
+fn extract_acb_unique_bytes<'py>(
+    py: Python<'py>,
+    acb_data: &[u8],
+) -> PyResult<Vec<Bound<'py, pyo3::types::PyDict>>> {
+    let waveforms = acb::extract_acb_unique_to_memory(Cursor::new(acb_data), None)
+        .map_err(|e| PyRuntimeError::new_err(format!("ACB extraction failed: {}", e)))?;
+
+    let mut out = Vec::with_capacity(waveforms.len());
+    for wf in waveforms {
+        let dict = pyo3::types::PyDict::new(py);
+        dict.set_item("extension", wf.extension)?;
+        dict.set_item("subkey", wf.subkey)?;
+        dict.set_item("data", pyo3::types::PyBytes::new(py, &wf.data))?;
+        let mut cues = Vec::with_capacity(wf.cues.len());
+        for cue in wf.cues {
+            let c = pyo3::types::PyDict::new(py);
+            c.set_item("name", cue.name)?;
+            c.set_item("cue_id", cue.cue_id)?;
+            cues.push(c);
+        }
+        dict.set_item("cues", cues)?;
+        out.push(dict);
+    }
+    Ok(out)
+}
+
 /// Decode an in-memory ACB straight to WAV bytes (no disk I/O).
 ///
 /// The in-memory counterpart of :func:`decode_acb_to_wav`: each AWB's subkey is
@@ -158,7 +197,7 @@ fn decode_acb_to_wav_bytes<'py>(
     acb_data: &[u8],
     key: Option<u64>,
 ) -> PyResult<Vec<Bound<'py, pyo3::types::PyDict>>> {
-    let tracks = acb::decode_acb_to_wav_to_memory(Cursor::new(acb_data.to_vec()), None, key)
+    let tracks = acb::decode_acb_to_wav_to_memory(Cursor::new(acb_data), None, key)
         .map_err(|e| PyRuntimeError::new_err(format!("ACB decode failed: {}", e)))?;
 
     let mut out = Vec::with_capacity(tracks.len());
@@ -349,7 +388,7 @@ fn decode_hca<'py>(
 #[pyfunction]
 #[pyo3(signature = (hca_data, key=None, subkey=None))]
 fn decode_hca_bytes(hca_data: &[u8], key: Option<u64>, subkey: Option<u64>) -> PyResult<Vec<u8>> {
-    let mut decoder = HcaDecoder::from_reader(Cursor::new(hca_data.to_vec()))
+    let mut decoder = HcaDecoder::from_reader(Cursor::new(hca_data))
         .map_err(|e| PyRuntimeError::new_err(format!("Failed to parse HCA: {}", e)))?;
     if let Some(k) = key {
         decoder.set_encryption_key(k, subkey.unwrap_or(0));
@@ -587,9 +626,8 @@ fn extract_usm_bytes<'py>(
     key: Option<u64>,
     export_audio: bool,
 ) -> PyResult<Vec<Bound<'py, pyo3::types::PyDict>>> {
-    let streams =
-        usm::extract_usm_to_memory(Cursor::new(usm_data.to_vec()), b"", key, export_audio)
-            .map_err(|e| PyRuntimeError::new_err(format!("USM extraction failed: {}", e)))?;
+    let streams = usm::extract_usm_to_memory(Cursor::new(usm_data), b"", key, export_audio)
+        .map_err(|e| PyRuntimeError::new_err(format!("USM extraction failed: {}", e)))?;
 
     let mut out = Vec::with_capacity(streams.len());
     for stream in streams {
@@ -689,6 +727,7 @@ pub fn register(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(extract_acb, m)?)?;
     m.add_function(wrap_pyfunction!(extract_acb_tracks, m)?)?;
     m.add_function(wrap_pyfunction!(extract_acb_bytes, m)?)?;
+    m.add_function(wrap_pyfunction!(extract_acb_unique_bytes, m)?)?;
     m.add_function(wrap_pyfunction!(decode_acb_to_wav, m)?)?;
     m.add_function(wrap_pyfunction!(decode_acb_to_wav_bytes, m)?)?;
     m.add_function(wrap_pyfunction!(build_acb, m)?)?;

{cridecoder-0.3.2 → cridecoder-0.3.3}/tests/integration_tests.rs

@@ -626,6 +626,36 @@ fn test_acb_extract_to_memory() {
     }
 }
 
+/// Test extract_acb_unique_to_memory de-duplicates waveforms and lists cues
+#[test]
+fn test_acb_extract_unique() {
+    use cridecoder::{extract_acb_unique_to_memory, AcbBuilder, TrackInput};
+    use std::io::Cursor;
+
+    let mut builder = AcbBuilder::new();
+    builder.add_track(TrackInput::new("uniq_a", 0, create_minimal_hca_header()));
+    builder.add_track(TrackInput::new("uniq_b", 1, create_minimal_hca_header()));
+
+    let mut output = Vec::new();
+    builder
+        .build(&mut Cursor::new(&mut output), None)
+        .expect("ACB build should succeed");
+
+    let waves = extract_acb_unique_to_memory(Cursor::new(output), None)
+        .expect("unique extract should work");
+
+    // The builder lays down two distinct waveforms, one cue each.
+    assert_eq!(waves.len(), 2);
+    for wf in &waves {
+        assert_eq!(wf.extension, "hca");
+        assert_eq!(wf.subkey, 0);
+        assert_eq!(wf.cues.len(), 1);
+        assert_eq!(&wf.data[0..4], b"HCA\x00");
+    }
+    assert_eq!(waves[0].cues[0].name, "uniq_a");
+    assert_eq!(waves[1].cues[0].name, "uniq_b");
+}
+
 /// Test ACB builder keeps Waveform AWB ids aligned with non-zero cue ids
 #[test]
 fn test_acb_builder_nonzero_cue_id() {