cridecoder 0.3.1__tar.gz → 0.3.2__tar.gz

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

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

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

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

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

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

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

@@ -10,7 +10,9 @@ from typing import Optional
 __all__ = [
     "extract_acb",
     "extract_acb_tracks",
+    "extract_acb_bytes",
     "decode_acb_to_wav",
+    "decode_acb_to_wav_bytes",
     "build_acb",
     "build_acb_bytes",
     "build_music_acb_bytes",
@@ -19,6 +21,7 @@ __all__ = [
     "encode_hca",
     "encode_hca_bytes",
     "extract_usm",
+    "extract_usm_bytes",
     "build_usm",
     "build_usm_bytes",
     "read_usm_metadata",
@@ -45,6 +48,16 @@ def extract_acb_tracks(
     """
     ...
 
+def extract_acb_bytes(acb_data: bytes) -> list[dict[str, object]]:
+    """In-memory counterpart of :func:`extract_acb_tracks` (no disk I/O).
+
+    Takes the ACB bytes directly and returns the waveform bytes per track as a
+    list of dicts ``{"name", "cue_id", "extension", "subkey", "data"}`` (``data``
+    is ``bytes``). Only the embedded AWB is read — external streaming ``.awb``
+    archives need a path, so use :func:`extract_acb` for those.
+    """
+    ...
+
 def decode_acb_to_wav(
     acb_path: str, output_dir: str, key: Optional[int] = ...
 ) -> list[str]:
@@ -57,6 +70,17 @@ def decode_acb_to_wav(
     """
     ...
 
+def decode_acb_to_wav_bytes(
+    acb_data: bytes, key: Optional[int] = ...
+) -> list[dict[str, object]]:
+    """In-memory counterpart of :func:`decode_acb_to_wav` (no disk I/O).
+
+    Returns a list of dicts ``{"name", "cue_id", "extension", "data"}`` where
+    ``data`` is WAV ``bytes`` for HCA tracks (``extension == "wav"``); non-HCA
+    tracks are returned verbatim. Encrypted ACBs only need the global ``key``.
+    """
+    ...
+
 def build_acb(tracks: list[tuple[str, int, bytes]], output_path: str) -> None:
     """Build an ACB file from ``(name, cue_id, hca_data)`` tuples, writing to disk."""
     ...
@@ -154,6 +178,19 @@ def extract_usm(
     """
     ...
 
+def extract_usm_bytes(
+    usm_data: bytes,
+    key: Optional[int] = ...,
+    export_audio: bool = ...,
+) -> list[dict[str, object]]:
+    """In-memory counterpart of :func:`extract_usm` (no disk I/O).
+
+    Takes the USM bytes and returns each stream as a dict
+    ``{"name", "extension", "data"}`` (``data`` is ``bytes``) — video, plus
+    audio when ``export_audio`` is set.
+    """
+    ...
+
 def build_usm(
     name: str,
     video_data: bytes,

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

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

cridecoder-0.3.2/src/acb/decode.rs

@@ -0,0 +1,107 @@
+//! High-level ACB → WAV decoding.
+//!
+//! Composes ACB extraction with the HCA decoder so callers can go straight from
+//! 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::io::{Cursor, Read, Seek};
+use std::path::Path;
+
+use thiserror::Error;
+
+use crate::acb::extractor::{extract_acb_to_memory, ExtractError};
+use crate::hca::{HcaDecoder, HcaDecoderError};
+
+/// A decoded ACB track held in memory.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct DecodedAcbTrack {
+    /// Cue name of the track (also the output file stem).
+    pub name: String,
+    /// Cue id of the track (cue-table index).
+    pub cue_id: i32,
+    /// Output extension: `"wav"` for a decoded HCA track, otherwise the
+    /// original waveform extension (non-HCA tracks are passed through raw).
+    pub extension: String,
+    /// Decoded WAV bytes (HCA), or the raw waveform bytes (non-HCA).
+    pub data: Vec<u8>,
+}
+
+#[derive(Error, Debug)]
+pub enum DecodeAcbError {
+    #[error("ACB extraction failed: {0}")]
+    Extract(#[from] ExtractError),
+    #[error("HCA decode failed: {0}")]
+    Hca(#[from] HcaDecoderError),
+    #[error("IO error: {0}")]
+    Io(#[from] std::io::Error),
+}
+
+/// Extract an ACB and decode its HCA tracks to WAV, returning everything in
+/// memory. The per-AWB AFS2 subkey is applied automatically, so encrypted
+/// (type-56) ACBs only need the global `key`. Non-HCA tracks are returned
+/// verbatim with their original extension.
+pub fn decode_acb_to_wav_to_memory<R: Read + Seek>(
+    acb_file: R,
+    acb_file_path: Option<&Path>,
+    key: Option<u64>,
+) -> Result<Vec<DecodedAcbTrack>, DecodeAcbError> {
+    let tracks = extract_acb_to_memory(acb_file, acb_file_path)?;
+
+    let mut outputs = Vec::with_capacity(tracks.len());
+    for track in tracks {
+        if track.extension == "hca" {
+            let mut decoder = HcaDecoder::from_reader(Cursor::new(track.data))?;
+            if let Some(k) = key {
+                decoder.set_encryption_key(k, track.subkey as u64);
+            }
+            let mut wav = Vec::new();
+            decoder.decode_to_wav(&mut wav)?;
+            outputs.push(DecodedAcbTrack {
+                name: track.name,
+                cue_id: track.cue_id,
+                extension: "wav".to_string(),
+                data: wav,
+            });
+        } else {
+            outputs.push(DecodedAcbTrack {
+                name: track.name,
+                cue_id: track.cue_id,
+                extension: track.extension,
+                data: track.data,
+            });
+        }
+    }
+    Ok(outputs)
+}
+
+/// Like [`decode_acb_to_wav_to_memory`], but writes each decoded track to
+/// `target_dir` and returns the written paths.
+pub fn decode_acb_to_wav<R: Read + Seek>(
+    acb_file: R,
+    target_dir: &Path,
+    acb_file_path: Option<&Path>,
+    key: Option<u64>,
+) -> Result<Vec<String>, DecodeAcbError> {
+    let tracks = decode_acb_to_wav_to_memory(acb_file, acb_file_path, key)?;
+
+    fs::create_dir_all(target_dir)?;
+    let mut outputs = Vec::with_capacity(tracks.len());
+    for track in tracks {
+        let path = target_dir.join(format!("{}.{}", track.name, track.extension));
+        fs::write(&path, &track.data)?;
+        outputs.push(path.to_string_lossy().into_owned());
+    }
+    Ok(outputs)
+}
+
+/// Convenience wrapper over [`decode_acb_to_wav`] that reads from a file path
+/// (also used to resolve sibling external streaming `.awb` archives).
+pub fn decode_acb_to_wav_from_file(
+    acb_path: &Path,
+    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)
+}

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

@@ -12,6 +12,8 @@ use thiserror::Error;
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ExtractedAcbTrack {
     pub name: String,
+    /// Cue id of the track (cue-table index).
+    pub cue_id: i32,
     pub extension: String,
     pub data: Vec<u8>,
     /// AFS2 subkey of the AWB this waveform came from. Required (together with the
@@ -79,6 +81,7 @@ pub fn extract_acb_to_memory<R: Read + Seek>(
         };
         outputs.push(ExtractedAcbTrack {
             name: track.name.clone(),
+            cue_id: track.cue_id,
             extension,
             data,
             subkey,

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

@@ -3,6 +3,7 @@
 mod afs;
 mod builder;
 mod consts;
+mod decode;
 mod extractor;
 mod track;
 mod utf;
@@ -12,6 +13,10 @@ pub use builder::{
     AcbBuilder, AfsArchiveBuilder, BuilderError, ColumnDef, TrackInput, UtfTableBuilder,
 };
 pub use consts::*;
+pub use decode::{
+    decode_acb_to_wav, decode_acb_to_wav_from_file, decode_acb_to_wav_to_memory, DecodeAcbError,
+    DecodedAcbTrack,
+};
 pub use extractor::{
     extract_acb, extract_acb_from_file, extract_acb_to_memory, extract_acb_tracks,
     extract_acb_tracks_from_file, ExtractedAcbTrack, ExtractedTrackFile,

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

@@ -14,6 +14,10 @@ pub mod usm;
 mod python;
 
 // ACB/AWB exports
+pub use acb::{
+    decode_acb_to_wav, decode_acb_to_wav_from_file, decode_acb_to_wav_to_memory, DecodeAcbError,
+    DecodedAcbTrack,
+};
 pub use acb::{
     extract_acb, extract_acb_from_file, extract_acb_to_memory, extract_acb_tracks,
     extract_acb_tracks_from_file, ExtractedAcbTrack, ExtractedTrackFile,

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

@@ -101,35 +101,76 @@ fn decode_acb_to_wav(acb_path: &str, output_dir: &str, key: Option<u64>) -> PyRe
     fs::create_dir_all(out_dir)
         .map_err(|e| PyRuntimeError::new_err(format!("Failed to create output dir: {}", e)))?;
 
-    let file = fs::File::open(acb_path)
-        .map_err(|e| PyRuntimeError::new_err(format!("Failed to open ACB: {}", e)))?;
+    acb::decode_acb_to_wav_from_file(Path::new(acb_path), out_dir, key)
+        .map_err(|e| PyRuntimeError::new_err(format!("ACB decode failed: {}", e)))
+}
 
-    let tracks = acb::extract_acb_to_memory(file, Some(Path::new(acb_path)))
+/// Extract audio tracks from in-memory ACB bytes (no disk I/O).
+///
+/// The in-memory counterpart of :func:`extract_acb_tracks`: takes the ACB
+/// bytes directly and returns the waveform bytes per track instead of writing
+/// files. Only the embedded AWB is read — external streaming ``.awb`` archives
+/// can't be resolved without a path, so use :func:`extract_acb` for those.
+///
+/// Args:
+///     acb_data: Raw ACB file bytes
+///
+/// Returns:
+///     List of dicts ``{"name", "cue_id", "extension", "subkey", "data"}``.
+#[pyfunction]
+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)
         .map_err(|e| PyRuntimeError::new_err(format!("ACB extraction failed: {}", e)))?;
 
-    let mut outputs = Vec::with_capacity(tracks.len());
+    let mut out = Vec::with_capacity(tracks.len());
     for track in tracks {
-        if track.extension == "hca" {
-            let mut decoder = HcaDecoder::from_reader(Cursor::new(track.data))
-                .map_err(|e| PyRuntimeError::new_err(format!("Failed to parse HCA: {}", e)))?;
-            if let Some(k) = key {
-                decoder.set_encryption_key(k, track.subkey as u64);
-            }
-            let wav_path = out_dir.join(format!("{}.wav", track.name));
-            let mut wav = fs::File::create(&wav_path)
-                .map_err(|e| PyRuntimeError::new_err(format!("Failed to create WAV: {}", e)))?;
-            decoder
-                .decode_to_wav(&mut wav)
-                .map_err(|e| PyRuntimeError::new_err(format!("HCA decode failed: {}", e)))?;
-            outputs.push(wav_path.to_string_lossy().into_owned());
-        } else {
-            let raw_path = out_dir.join(format!("{}.{}", track.name, track.extension));
-            fs::write(&raw_path, &track.data)
-                .map_err(|e| PyRuntimeError::new_err(format!("Failed to write track: {}", e)))?;
-            outputs.push(raw_path.to_string_lossy().into_owned());
-        }
+        let dict = pyo3::types::PyDict::new(py);
+        dict.set_item("name", track.name)?;
+        dict.set_item("cue_id", track.cue_id)?;
+        dict.set_item("extension", track.extension)?;
+        dict.set_item("subkey", track.subkey)?;
+        dict.set_item("data", pyo3::types::PyBytes::new(py, &track.data))?;
+        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
+/// applied automatically, so encrypted ACBs only need the global ``key``.
+/// Non-HCA tracks are returned verbatim (``extension`` reflects this).
+///
+/// Args:
+///     acb_data: Raw ACB file bytes
+///     key: Global HCA keycode (omit/None for unencrypted ACBs)
+///
+/// Returns:
+///     List of dicts ``{"name", "cue_id", "extension", "data"}`` where ``data``
+///     is WAV bytes for HCA tracks (``extension == "wav"``).
+#[pyfunction]
+#[pyo3(signature = (acb_data, key=None))]
+fn decode_acb_to_wav_bytes<'py>(
+    py: Python<'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)
+        .map_err(|e| PyRuntimeError::new_err(format!("ACB decode failed: {}", e)))?;
+
+    let mut out = Vec::with_capacity(tracks.len());
+    for track in tracks {
+        let dict = pyo3::types::PyDict::new(py);
+        dict.set_item("name", track.name)?;
+        dict.set_item("cue_id", track.cue_id)?;
+        dict.set_item("extension", track.extension)?;
+        dict.set_item("data", pyo3::types::PyBytes::new(py, &track.data))?;
+        out.push(dict);
     }
-    Ok(outputs)
+    Ok(out)
 }
 
 /// Build an ACB file from track data.
@@ -525,6 +566,42 @@ fn extract_usm(
         .collect())
 }
 
+/// Extract USM streams from in-memory bytes (no disk I/O).
+///
+/// The in-memory counterpart of :func:`extract_usm`: takes the USM bytes and
+/// returns each stream's bytes instead of writing files.
+///
+/// Args:
+///     usm_data: Raw USM file bytes
+///     key: Optional decryption key (u64)
+///     export_audio: Whether to include audio streams (default: false)
+///
+/// Returns:
+///     List of dicts ``{"name", "extension", "data"}`` (video, and audio when
+///     ``export_audio`` is set).
+#[pyfunction]
+#[pyo3(signature = (usm_data, key=None, export_audio=false))]
+fn extract_usm_bytes<'py>(
+    py: Python<'py>,
+    usm_data: &[u8],
+    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 mut out = Vec::with_capacity(streams.len());
+    for stream in streams {
+        let dict = pyo3::types::PyDict::new(py);
+        dict.set_item("name", stream.name)?;
+        dict.set_item("extension", stream.extension)?;
+        dict.set_item("data", pyo3::types::PyBytes::new(py, &stream.data))?;
+        out.push(dict);
+    }
+    Ok(out)
+}
+
 /// Build a USM file from video data.
 ///
 /// Args:
@@ -611,7 +688,9 @@ pub fn register(m: &Bound<'_, PyModule>) -> PyResult<()> {
     // ACB functions
     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!(decode_acb_to_wav, m)?)?;
+    m.add_function(wrap_pyfunction!(decode_acb_to_wav_bytes, m)?)?;
     m.add_function(wrap_pyfunction!(build_acb, m)?)?;
     m.add_function(wrap_pyfunction!(build_acb_bytes, m)?)?;
     m.add_function(wrap_pyfunction!(build_music_acb_bytes, m)?)?;
@@ -624,6 +703,7 @@ pub fn register(m: &Bound<'_, PyModule>) -> PyResult<()> {
 
     // USM functions
     m.add_function(wrap_pyfunction!(extract_usm, m)?)?;
+    m.add_function(wrap_pyfunction!(extract_usm_bytes, m)?)?;
     m.add_function(wrap_pyfunction!(build_usm, m)?)?;
     m.add_function(wrap_pyfunction!(build_usm_bytes, m)?)?;
     m.add_function(wrap_pyfunction!(read_usm_metadata, m)?)?;

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

@@ -596,6 +596,36 @@ fn test_acb_extract_tracks_metadata() {
     assert_eq!(&data[0..4], b"HCA\x00");
 }
 
+/// Test extract_acb_to_memory returns track bytes with cue id and subkey
+#[test]
+fn test_acb_extract_to_memory() {
+    use cridecoder::{extract_acb_to_memory, AcbBuilder, TrackInput};
+    use std::io::Cursor;
+
+    let mut builder = AcbBuilder::new();
+    builder.add_track(TrackInput::new("mem_a", 0, create_minimal_hca_header()));
+    builder.add_track(TrackInput::new("mem_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 tracks =
+        extract_acb_to_memory(Cursor::new(output), None).expect("in-memory extract should succeed");
+
+    assert_eq!(tracks.len(), 2);
+    assert_eq!(tracks[0].name, "mem_a");
+    assert_eq!(tracks[0].cue_id, 0);
+    assert_eq!(tracks[1].name, "mem_b");
+    assert_eq!(tracks[1].cue_id, 1);
+    for track in &tracks {
+        assert_eq!(track.extension, "hca");
+        assert_eq!(track.subkey, 0); // builder produces unencrypted AWBs
+        assert_eq!(&track.data[0..4], b"HCA\x00");
+    }
+}
+
 /// Test ACB builder keeps Waveform AWB ids aligned with non-zero cue ids
 #[test]
 fn test_acb_builder_nonzero_cue_id() {