cridecoder 0.2.0__tar.gz → 0.2.1__tar.gz

{cridecoder-0.2.0 → cridecoder-0.2.1}/Cargo.lock

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

{cridecoder-0.2.0 → cridecoder-0.2.1}/Cargo.toml

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

{cridecoder-0.2.0 → cridecoder-0.2.1}/PKG-INFO

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

cridecoder-0.2.1/cridecoder.pyi

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from typing import Optional, TypedDict
+
+
+class ExtractedTrack(TypedDict):
+    name: str
+    extension: str
+    filename: str
+    data: bytes
+
+
+class HcaInfo(TypedDict):
+    sample_rate: int
+    channels: int
+    block_count: int
+    block_size: int
+    encoder_delay: int
+    samples_per_block: int
+
+
+class EncodeInfo(TypedDict):
+    size: int
+    bitrate: int
+
+
+def extract_acb(acb_path: str, output_dir: str) -> Optional[list[str]]: ...
+
+
+def extract_acb_bytes(acb_data: bytes, acb_path: Optional[str] = None) -> list[ExtractedTrack]: ...
+
+
+def build_acb(tracks: list[tuple[str, int, bytes]], output_path: str) -> None: ...
+
+
+def build_acb_bytes(tracks: list[tuple[str, int, bytes]]) -> bytes: ...
+
+
+def build_music_acb_bytes(
+    name: str,
+    hca_data: bytes,
+    cue_id: int,
+    virtual_cue_suffix: Optional[str],
+    memory_awb_id: int,
+    reference_num_samples: int,
+    reference_length_ms: int,
+    acb_version: int,
+    acf_md5_hash: bytes,
+    acb_guid: bytes,
+    version_string: str,
+    acb_volume: float,
+    category_extension: int,
+    cue_priority_type: int,
+    acf_category_name: str,
+    acf_category_id: int,
+    acf_bus_names: list[str],
+) -> bytes: ...
+
+
+def decode_hca(hca_path: str, wav_path: str) -> HcaInfo: ...
+
+
+def decode_hca_bytes(hca_data: bytes) -> bytes: ...
+
+
+def encode_hca(
+    wav_path: str,
+    hca_path: str,
+    bitrate: int = 256000,
+    encryption_key: Optional[int] = None,
+) -> EncodeInfo: ...
+
+
+def encode_hca_bytes(
+    wav_data: bytes,
+    sample_rate: Optional[int] = None,
+    channels: Optional[int] = None,
+    bitrate: int = 256000,
+    encryption_key: Optional[int] = None,
+) -> bytes: ...
+
+
+def extract_usm(
+    usm_path: str,
+    output_dir: str,
+    key: Optional[int] = None,
+    export_audio: bool = False,
+) -> list[str]: ...
+
+
+def extract_usm_bytes(
+    usm_data: bytes,
+    fallback_name: str = "input.usm",
+    key: Optional[int] = None,
+    export_audio: bool = False,
+) -> list[ExtractedTrack]: ...
+
+
+def build_usm(
+    name: str,
+    video_data: bytes,
+    output_path: str,
+    encryption_key: Optional[int] = None,
+) -> None: ...
+
+
+def build_usm_bytes(
+    name: str,
+    video_data: bytes,
+    encryption_key: Optional[int] = None,
+) -> bytes: ...
+
+
+def read_usm_metadata(usm_path: str) -> str: ...

{cridecoder-0.2.0 → cridecoder-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "cridecoder"
-version = "0.2.0"
+version = "0.2.1"
 description = "CRI codec library for ACB/AWB, HCA audio, and USM video extraction"
 readme = "README.md"
 license = { text = "MIT" }
@@ -23,3 +23,4 @@ free-threaded = true
 
 [tool.maturin]
 features = ["python"]
+include = [{ path = "cridecoder.pyi", format = "wheel" }]

{cridecoder-0.2.0 → cridecoder-0.2.1}/src/acb/extractor.rs

@@ -23,6 +23,14 @@ pub enum ExtractError {
     InvalidAcb,
 }
 
+/// Audio track data extracted from an ACB/AWB container.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ExtractedAcbTrack {
+    pub name: String,
+    pub extension: String,
+    pub data: Vec<u8>,
+}
+
 /// Extract all audio files from an ACB file
 pub fn extract_acb<R: Read + Seek>(
     acb_file: R,
@@ -44,6 +52,21 @@ pub fn extract_acb<R: Read + Seek>(
     )
 }
 
+/// Extract all audio tracks from an ACB reader into memory.
+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 track_list = TrackList::new(&utf)?;
+
+    let mut embedded_awb = load_embedded_awb(&utf.rows[0]);
+    let mut external_awbs = load_external_awbs(&utf.rows[0], acb_file_path);
+
+    extract_all_tracks_to_memory(&track_list, &mut embedded_awb, &mut external_awbs)
+}
+
 fn load_embedded_awb(
     row: &std::collections::HashMap<String, crate::acb::utf::Value>,
 ) -> Option<AfsArchive<Cursor<Vec<u8>>>> {
@@ -120,6 +143,22 @@ fn extract_all_tracks(
     Ok(outputs)
 }
 
+fn extract_all_tracks_to_memory(
+    track_list: &TrackList,
+    embedded_awb: &mut Option<AfsArchive<Cursor<Vec<u8>>>>,
+    external_awbs: &mut [AfsArchive<Cursor<Vec<u8>>>],
+) -> Result<Vec<ExtractedAcbTrack>, ExtractError> {
+    let mut outputs = Vec::new();
+
+    for track in &track_list.tracks {
+        if let Some(output) = extract_single_track_to_memory(track, embedded_awb, external_awbs)? {
+            outputs.push(output);
+        }
+    }
+
+    Ok(outputs)
+}
+
 fn extract_single_track(
     track: &Track,
     target_dir: &Path,
@@ -146,6 +185,31 @@ fn extract_single_track(
     Ok(Some(output_path.to_string_lossy().into_owned()))
 }
 
+fn extract_single_track_to_memory(
+    track: &Track,
+    embedded_awb: &mut Option<AfsArchive<Cursor<Vec<u8>>>>,
+    external_awbs: &mut [AfsArchive<Cursor<Vec<u8>>>],
+) -> Result<Option<ExtractedAcbTrack>, ExtractError> {
+    let ext = wave_type_extension(track.enc_type);
+    let extension = if ext.is_empty() {
+        track.enc_type.to_string()
+    } else {
+        ext.trim_start_matches('.').to_string()
+    };
+
+    let data = get_track_data(track, embedded_awb, external_awbs)?;
+    let data = match data {
+        Some(d) => d,
+        None => return Ok(None),
+    };
+
+    Ok(Some(ExtractedAcbTrack {
+        name: track.name.clone(),
+        extension,
+        data,
+    }))
+}
+
 fn get_track_data(
     track: &Track,
     embedded_awb: &mut Option<AfsArchive<Cursor<Vec<u8>>>>,

{cridecoder-0.2.0 → cridecoder-0.2.1}/src/acb.rs

@@ -12,6 +12,6 @@ pub use builder::{
     AcbBuilder, AfsArchiveBuilder, BuilderError, ColumnDef, TrackInput, UtfTableBuilder,
 };
 pub use consts::*;
-pub use extractor::{extract_acb, extract_acb_from_file};
+pub use extractor::{extract_acb, extract_acb_from_file, extract_acb_to_memory, ExtractedAcbTrack};
 pub use track::{Track, TrackList};
 pub use utf::{UtfHeader, UtfTable, Value};

{cridecoder-0.2.0 → cridecoder-0.2.1}/src/lib.rs

@@ -14,7 +14,7 @@ pub mod usm;
 mod python;
 
 // ACB/AWB exports
-pub use acb::{extract_acb, extract_acb_from_file};
+pub use acb::{extract_acb, extract_acb_from_file, extract_acb_to_memory, ExtractedAcbTrack};
 pub use acb::{AcbBuilder, AfsArchiveBuilder, BuilderError, TrackInput, UtfTableBuilder};
 
 // HCA exports
@@ -22,7 +22,9 @@ pub use hca::{encode_wav_to_hca, HcaEncoder, HcaEncoderConfig, HcaEncoderError};
 pub use hca::{HcaDecoder, HcaDecoderError, HcaInfo};
 
 // USM exports
-pub use usm::{extract_usm, extract_usm_file, Metadata, UsmError};
+pub use usm::{
+    extract_usm, extract_usm_file, extract_usm_to_memory, ExtractedUsmStream, Metadata, UsmError,
+};
 pub use usm::{UsmBuilder, UsmBuilderError};
 
 #[cfg(feature = "python")]

{cridecoder-0.2.0 → cridecoder-0.2.1}/src/python.rs

@@ -7,6 +7,7 @@
 
 use pyo3::exceptions::PyRuntimeError;
 use pyo3::prelude::*;
+use pyo3::types::{PyBytes, PyDict, PyList};
 
 use std::fs;
 use std::io::Cursor;
@@ -37,6 +38,38 @@ fn extract_acb(acb_path: &str, output_dir: &str) -> PyResult<Option<Vec<String>>
         .map_err(|e| PyRuntimeError::new_err(format!("ACB extraction failed: {}", e)))
 }
 
+/// Extract audio tracks from ACB data into memory.
+///
+/// Args:
+///     acb_data: Raw ACB file data as bytes
+///     acb_path: Optional ACB path, used to resolve external AWB files
+///
+/// Returns:
+///     List of dicts with name, extension, filename, and data bytes
+#[pyfunction]
+#[pyo3(signature = (acb_data, acb_path=None))]
+fn extract_acb_bytes<'py>(
+    py: Python<'py>,
+    acb_data: &[u8],
+    acb_path: Option<String>,
+) -> PyResult<Bound<'py, PyList>> {
+    let acb_path = acb_path.as_deref().map(Path::new);
+    let tracks = acb::extract_acb_to_memory(Cursor::new(acb_data.to_vec()), acb_path)
+        .map_err(|e| PyRuntimeError::new_err(format!("ACB extraction failed: {}", e)))?;
+
+    let list = PyList::empty(py);
+    for track in tracks {
+        let dict = PyDict::new(py);
+        let filename = format!("{}.{}", track.name, track.extension);
+        dict.set_item("name", track.name)?;
+        dict.set_item("extension", track.extension)?;
+        dict.set_item("filename", filename)?;
+        dict.set_item("data", PyBytes::new(py, &track.data))?;
+        list.append(dict)?;
+    }
+    Ok(list)
+}
+
 /// Build an ACB file from track data.
 ///
 /// Args:
@@ -419,6 +452,50 @@ fn extract_usm(
         .collect())
 }
 
+/// Extract video/audio streams from USM data into memory.
+///
+/// Args:
+///     usm_data: Raw USM file data as bytes
+///     fallback_name: Name used when the USM metadata has no filename
+///     key: Optional decryption key (u64)
+///     export_audio: Whether to export audio streams (default: false)
+///
+/// Returns:
+///     List of dicts with name, extension, filename, and data bytes
+#[pyfunction]
+#[pyo3(signature = (usm_data, fallback_name="input.usm", key=None, export_audio=false))]
+fn extract_usm_bytes<'py>(
+    py: Python<'py>,
+    usm_data: &[u8],
+    fallback_name: &str,
+    key: Option<u64>,
+    export_audio: bool,
+) -> PyResult<Bound<'py, PyList>> {
+    let streams = usm::extract_usm_to_memory(
+        Cursor::new(usm_data.to_vec()),
+        fallback_name.as_bytes(),
+        key,
+        export_audio,
+    )
+    .map_err(|e| PyRuntimeError::new_err(format!("USM extraction failed: {}", e)))?;
+
+    let list = PyList::empty(py);
+    for stream in streams {
+        let dict = PyDict::new(py);
+        let name = Path::new(&stream.filename)
+            .file_stem()
+            .and_then(|stem| stem.to_str())
+            .unwrap_or(&stream.filename)
+            .to_string();
+        dict.set_item("name", name)?;
+        dict.set_item("extension", stream.extension)?;
+        dict.set_item("filename", stream.filename)?;
+        dict.set_item("data", PyBytes::new(py, &stream.data))?;
+        list.append(dict)?;
+    }
+    Ok(list)
+}
+
 /// Build a USM file from video data.
 ///
 /// Args:
@@ -504,6 +581,7 @@ fn read_usm_metadata(usm_path: &str) -> PyResult<String> {
 pub fn register(m: &Bound<'_, PyModule>) -> PyResult<()> {
     // ACB functions
     m.add_function(wrap_pyfunction!(extract_acb, m)?)?;
+    m.add_function(wrap_pyfunction!(extract_acb_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)?)?;
@@ -516,6 +594,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.2.0 → cridecoder-0.2.1}/src/usm/extractor.rs

@@ -66,6 +66,14 @@ pub type UtfRow = std::collections::HashMap<String, UtfValue>;
 /// A UTF table
 pub type UtfTable = Vec<UtfRow>;
 
+/// A stream extracted from a USM container.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ExtractedUsmStream {
+    pub filename: String,
+    pub extension: String,
+    pub data: Vec<u8>,
+}
+
 /// Read column data from a UTF table
 fn read_column_data<R: Read + Seek>(
     reader: &mut Reader<R>,
@@ -352,6 +360,57 @@ pub fn extract_usm<R: Read + Seek>(
     Ok(output_files)
 }
 
+/// Extract USM video/audio streams into memory.
+pub fn extract_usm_to_memory<R: Read + Seek>(
+    usm: R,
+    fallback_name: &[u8],
+    key: Option<u64>,
+    export_audio: bool,
+) -> Result<Vec<ExtractedUsmStream>, UsmError> {
+    let mut reader = Reader::new(usm);
+
+    let (vmask, amask) = key.map(get_mask).unzip();
+
+    let (filename, has_audio) = parse_usm_header(&mut reader, fallback_name)?;
+    let decoded_filename = decode_shift_jis(&filename);
+
+    let base_name = Path::new(&decoded_filename)
+        .file_stem()
+        .and_then(|s| s.to_str())
+        .unwrap_or(&decoded_filename)
+        .to_string();
+
+    let mut video = Vec::new();
+    let mut audio = if has_audio && export_audio {
+        Some(Vec::new())
+    } else {
+        None
+    };
+
+    extract_usm_chunks(
+        &mut reader,
+        &mut video,
+        audio.as_mut(),
+        vmask.as_ref(),
+        amask.as_ref(),
+    )?;
+
+    let mut streams = vec![ExtractedUsmStream {
+        filename: format!("{base_name}.m2v"),
+        extension: "m2v".to_string(),
+        data: video,
+    }];
+    if let Some(audio) = audio {
+        streams.push(ExtractedUsmStream {
+            filename: format!("{base_name}.adx"),
+            extension: "adx".to_string(),
+            data: audio,
+        });
+    }
+
+    Ok(streams)
+}
+
 /// Parse USM header
 fn parse_usm_header<R: Read + Seek>(
     reader: &mut Reader<R>,
@@ -511,10 +570,10 @@ fn create_output_files(
 }
 
 /// Extract USM chunks
-fn extract_usm_chunks<R: Read + Seek>(
+fn extract_usm_chunks<R: Read + Seek, V: Write, A: Write>(
     reader: &mut Reader<R>,
-    video_file: &mut File,
-    mut audio_file: Option<&mut File>,
+    video_file: &mut V,
+    mut audio_file: Option<&mut A>,
     vmask: Option<&Vec<Vec<u8>>>,
     amask: Option<&Vec<u8>>,
 ) -> Result<(), UsmError> {
@@ -558,13 +617,13 @@ fn extract_usm_chunks<R: Read + Seek>(
 
 /// Process a chunk
 #[allow(clippy::too_many_arguments)]
-fn process_chunk<R: Read + Seek>(
+fn process_chunk<R: Read + Seek, V: Write, A: Write>(
     reader: &mut Reader<R>,
     sig: &[u8],
     read_data_len: usize,
     data_type: u8,
-    video_file: &mut File,
-    audio_file: &mut Option<&mut File>,
+    video_file: &mut V,
+    audio_file: &mut Option<&mut A>,
     vmask: Option<&Vec<Vec<u8>>>,
     amask: Option<&Vec<u8>>,
 ) -> Result<(), UsmError> {

{cridecoder-0.2.0 → cridecoder-0.2.1}/src/usm.rs

@@ -8,7 +8,9 @@ mod extractor;
 mod metadata;
 
 pub use builder::{StreamInput, StreamType, UsmBuilder, UsmBuilderError};
-pub use extractor::{extract_usm, extract_usm_file, UsmError};
+pub use extractor::{
+    extract_usm, extract_usm_file, extract_usm_to_memory, ExtractedUsmStream, UsmError,
+};
 pub use metadata::{
     export_metadata_file, read_metadata, read_metadata_file, Metadata, MetadataSection,
 };

{cridecoder-0.2.0 → cridecoder-0.2.1}/tests/integration_tests.rs

@@ -387,6 +387,23 @@ fn test_acb_from_memory() {
     assert_eq!(tracks.len(), 4, "Should extract 4 tracks from memory");
 }
 
+/// Test extract_acb_to_memory returns track bytes without writing files
+#[test]
+fn test_acb_to_memory() {
+    let acb_path = Path::new("se_0126_01.acb");
+    if !acb_path.exists() {
+        eprintln!("Skipping test: se_0126_01.acb not found");
+        return;
+    }
+
+    let data = fs::read(acb_path).unwrap();
+    let tracks = cridecoder::extract_acb_to_memory(Cursor::new(data), None)
+        .expect("Should extract ACB tracks into memory");
+    assert_eq!(tracks.len(), 4, "Should extract 4 tracks into memory");
+    assert!(tracks.iter().all(|track| track.extension == "hca"));
+    assert!(tracks.iter().all(|track| !track.data.is_empty()));
+}
+
 /// Test extract_usm with in-memory data
 #[test]
 fn test_usm_from_memory() {
@@ -404,6 +421,25 @@ fn test_usm_from_memory() {
     assert!(!files.is_empty(), "Should extract at least one file");
 }
 
+/// Test extract_usm_to_memory returns stream bytes without writing files
+#[test]
+fn test_usm_to_memory() {
+    let usm_path = Path::new("0703.usm");
+    if !usm_path.exists() {
+        eprintln!("Skipping test: 0703.usm not found");
+        return;
+    }
+
+    let data = fs::read(usm_path).unwrap();
+    let streams =
+        cridecoder::usm::extract_usm_to_memory(Cursor::new(data), b"0703.usm", None, false)
+            .expect("Should extract USM streams into memory");
+    assert_eq!(streams.len(), 1);
+    assert_eq!(streams[0].filename, "0703.m2v");
+    assert_eq!(streams[0].extension, "m2v");
+    assert!(!streams[0].data.is_empty());
+}
+
 // =============================================================================
 // Encoder Tests
 // =============================================================================

cridecoder-0.2.1/tests/test_python.py

@@ -0,0 +1,332 @@
+"""
+Python integration tests for cridecoder.
+
+Tests encoding and decoding functionality:
+- HCA encoding/decoding round-trip
+- ACB/USM container building (structure verification)
+- Real file extraction and HCA encoding
+"""
+
+import os
+import tempfile
+import pytest
+
+# Skip if cridecoder not available
+pytest.importorskip("cridecoder")
+
+import cridecoder
+
+
+class TestHcaRoundtrip:
+    """Test HCA encoding and decoding round-trip."""
+
+    def test_encode_decode_roundtrip(self):
+        """Test encoding WAV to HCA and decoding back."""
+        # Create a simple sine wave WAV
+        wav_data = create_test_wav(sample_rate=44100, channels=2, duration_sec=0.5)
+        
+        # Encode to HCA
+        hca_data = cridecoder.encode_hca_bytes(wav_data, bitrate=256000)
+        
+        # Verify HCA magic
+        assert hca_data[:4] == b"HCA\x00", "Should have HCA magic"
+        
+        # Decode back to WAV
+        decoded_wav = cridecoder.decode_hca_bytes(hca_data)
+        
+        # Verify WAV magic
+        assert decoded_wav[:4] == b"RIFF", "Should have RIFF magic"
+        assert decoded_wav[8:12] == b"WAVE", "Should have WAVE format"
+
+    def test_encode_with_encryption(self):
+        """Test HCA encoding with encryption key."""
+        wav_data = create_test_wav(sample_rate=44100, channels=1, duration_sec=0.2)
+        
+        # Encode with encryption
+        hca_data = cridecoder.encode_hca_bytes(
+            wav_data, 
+            bitrate=128000, 
+            encryption_key=0x1234567890ABCDEF
+        )
+        
+        # Verify it's encrypted (header will be masked)
+        # Encrypted HCA has masked magic: 0xC8C3C100 instead of 0x48434100
+        assert hca_data[0] == 0xC8, "Should have masked HCA magic"
+
+    def test_encode_mono(self):
+        """Test encoding mono audio."""
+        wav_data = create_test_wav(sample_rate=22050, channels=1, duration_sec=0.3)
+        hca_data = cridecoder.encode_hca_bytes(wav_data, bitrate=128000)
+        assert hca_data[:4] == b"HCA\x00"
+        
+        # Verify can decode
+        decoded = cridecoder.decode_hca_bytes(hca_data)
+        assert decoded[:4] == b"RIFF"
+
+    def test_encode_stereo(self):
+        """Test encoding stereo audio."""
+        wav_data = create_test_wav(sample_rate=48000, channels=2, duration_sec=0.3)
+        hca_data = cridecoder.encode_hca_bytes(wav_data, bitrate=320000)
+        assert hca_data[:4] == b"HCA\x00"
+        
+        decoded = cridecoder.decode_hca_bytes(hca_data)
+        assert decoded[:4] == b"RIFF"
+
+
+class TestContainerBuilding:
+    """Test container building (structure verification only)."""
+
+    def test_build_acb_structure(self):
+        """Test ACB building produces valid UTF structure."""
+        wav_data = create_test_wav(sample_rate=44100, channels=2, duration_sec=0.1)
+        hca_data = cridecoder.encode_hca_bytes(wav_data, bitrate=256000)
+        
+        tracks = [("test_track", 0, hca_data)]
+        acb_data = cridecoder.build_acb_bytes(tracks)
+        
+        # Verify ACB magic (@UTF)
+        assert acb_data[:4] == b"@UTF", "Should have UTF magic"
+        assert len(acb_data) > 100, "Should have substantial content"
+
+    def test_extract_acb_bytes(self):
+        """Test extracting ACB tracks without writing files."""
+        wav_data = create_test_wav(sample_rate=44100, channels=1, duration_sec=0.1)
+        hca_data = cridecoder.encode_hca_bytes(wav_data, bitrate=128000)
+        acb_data = cridecoder.build_acb_bytes([("memory_track", 0, hca_data)])
+
+        tracks = cridecoder.extract_acb_bytes(acb_data)
+
+        assert len(tracks) == 1
+        assert tracks[0]["name"] == "memory_track"
+        assert tracks[0]["extension"] == "hca"
+        assert tracks[0]["filename"] == "memory_track.hca"
+        assert tracks[0]["data"][:4] == b"HCA\x00"
+
+    def test_build_acb_multiple_tracks(self):
+        """Test ACB building with multiple tracks."""
+        tracks = []
+        for i in range(3):
+            wav_data = create_test_wav(sample_rate=44100, channels=1, duration_sec=0.1)
+            hca_data = cridecoder.encode_hca_bytes(wav_data, bitrate=128000)
+            tracks.append((f"track_{i}", i, hca_data))
+        
+        acb_data = cridecoder.build_acb_bytes(tracks)
+        assert acb_data[:4] == b"@UTF"
+
+    def test_build_usm_structure(self):
+        """Test USM building produces valid CRID structure."""
+        # Create minimal M2V header
+        video_data = bytes([
+            0x00, 0x00, 0x01, 0xB3,  # sequence_header_code
+            0x14, 0x00, 0xF0, 0x24,  # picture size
+            0xFF, 0xFF, 0xE0, 0x00,  # bit rate
+        ])
+        
+        usm_data = cridecoder.build_usm_bytes("test_video", video_data)
+        
+        # Verify CRID magic
+        assert usm_data[:4] == b"CRID", "Should have CRID magic"
+        assert len(usm_data) > 100, "Should have substantial content"
+
+
+class TestRealFileOperations:
+    """Test operations with real fixture files."""
+
+    @pytest.fixture
+    def acb_path(self):
+        """Path to test ACB file."""
+        path = "se_0126_01.acb"
+        if not os.path.exists(path):
+            pytest.skip("Test fixture se_0126_01.acb not found")
+        return path
+
+    @pytest.fixture
+    def usm_path(self):
+        """Path to test USM file."""
+        path = "0703.usm"
+        if not os.path.exists(path):
+            pytest.skip("Test fixture 0703.usm not found")
+        return path
+
+    def test_extract_acb(self, acb_path):
+        """Test extracting real ACB file."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            extracted = cridecoder.extract_acb(acb_path, tmpdir)
+            assert extracted is not None
+            assert len(extracted) > 0, "Should extract tracks"
+            
+            # Verify extracted files exist
+            for path in extracted:
+                assert os.path.exists(path), f"Extracted file should exist: {path}"
+
+    def test_extract_usm(self, usm_path):
+        """Test extracting real USM file."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            extracted = cridecoder.extract_usm(usm_path, tmpdir)
+            assert len(extracted) > 0, "Should extract files"
+            
+            # Verify M2V extracted
+            m2v_files = [p for p in extracted if p.endswith(".m2v")]
+            assert len(m2v_files) > 0, "Should extract M2V video"
+
+    def test_extract_usm_bytes(self, usm_path):
+        """Test extracting real USM streams without writing files."""
+        with open(usm_path, "rb") as f:
+            usm_data = f.read()
+
+        streams = cridecoder.extract_usm_bytes(usm_data, fallback_name=os.path.basename(usm_path))
+
+        assert len(streams) > 0
+        m2v_streams = [stream for stream in streams if stream["extension"] == "m2v"]
+        assert len(m2v_streams) > 0, "Should extract M2V video"
+        assert m2v_streams[0]["data"].startswith(b"\x00\x00\x01")
+
+    def test_hca_decode_and_reencode(self, acb_path):
+        """Extract HCA, decode to WAV, and re-encode to HCA."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Extract ACB
+            extracted = cridecoder.extract_acb(acb_path, tmpdir)
+            assert extracted is not None and len(extracted) > 0
+            
+            # Decode first HCA to WAV
+            hca_path = extracted[0]
+            wav_path = os.path.join(tmpdir, "decoded.wav")
+            info = cridecoder.decode_hca(hca_path, wav_path)
+            
+            assert info["sample_rate"] > 0
+            assert info["channels"] > 0
+            
+            # Read WAV and re-encode
+            with open(wav_path, "rb") as f:
+                wav_data = f.read()
+            
+            new_hca_data = cridecoder.encode_hca_bytes(
+                wav_data,
+                sample_rate=info["sample_rate"],
+                channels=info["channels"],
+                bitrate=256000
+            )
+            
+            assert new_hca_data[:4] == b"HCA\x00", "Should produce valid HCA"
+            
+            # Verify the new HCA can be decoded
+            decoded_again = cridecoder.decode_hca_bytes(new_hca_data)
+            assert decoded_again[:4] == b"RIFF", "Re-encoded HCA should decode"
+
+    def test_usm_extract_and_rebuild_video(self, usm_path):
+        """Extract M2V from USM and build new USM with it."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Extract
+            extracted = cridecoder.extract_usm(usm_path, tmpdir)
+            
+            # Find M2V
+            m2v_path = None
+            for path in extracted:
+                if path.endswith(".m2v"):
+                    m2v_path = path
+                    break
+            
+            assert m2v_path is not None, "Should have M2V"
+            
+            # Read M2V and build new USM
+            with open(m2v_path, "rb") as f:
+                m2v_data = f.read()
+            
+            rebuilt_path = os.path.join(tmpdir, "rebuilt.usm")
+            cridecoder.build_usm("rebuilt", m2v_data, rebuilt_path)
+            
+            # Verify file created and has CRID header
+            assert os.path.exists(rebuilt_path)
+            with open(rebuilt_path, "rb") as f:
+                header = f.read(4)
+            assert header == b"CRID", "Rebuilt USM should have CRID magic"
+
+    def test_full_acb_pipeline(self, acb_path):
+        """Full pipeline: extract ACB -> decode HCA -> encode HCA -> build ACB."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # 1. Extract original ACB
+            extract_dir = os.path.join(tmpdir, "extract")
+            os.makedirs(extract_dir)
+            extracted = cridecoder.extract_acb(acb_path, extract_dir)
+            assert extracted and len(extracted) > 0
+            
+            # 2. Process each track: decode and re-encode
+            new_tracks = []
+            for i, hca_path in enumerate(extracted[:2]):  # First 2 tracks
+                # Decode
+                wav_path = os.path.join(tmpdir, f"track{i}.wav")
+                info = cridecoder.decode_hca(hca_path, wav_path)
+                
+                # Re-encode
+                with open(wav_path, "rb") as f:
+                    wav_data = f.read()
+                
+                new_hca = cridecoder.encode_hca_bytes(
+                    wav_data,
+                    sample_rate=info["sample_rate"],
+                    channels=info["channels"],
+                    bitrate=256000
+                )
+                
+                new_tracks.append((f"track_{i}", i, new_hca))
+            
+            # 3. Build new ACB
+            rebuilt_path = os.path.join(tmpdir, "rebuilt.acb")
+            cridecoder.build_acb(new_tracks, rebuilt_path)
+            
+            # Verify ACB created
+            assert os.path.exists(rebuilt_path)
+            with open(rebuilt_path, "rb") as f:
+                header = f.read(4)
+            assert header == b"@UTF", "Rebuilt ACB should have UTF magic"
+            
+            # Verify substantial size
+            size = os.path.getsize(rebuilt_path)
+            assert size > 1000, f"ACB should have substantial size, got {size}"
+
+
+def create_test_wav(sample_rate: int, channels: int, duration_sec: float) -> bytes:
+    """Create a simple test WAV file with a sine wave."""
+    import struct
+    import math
+    
+    num_samples = int(sample_rate * duration_sec)
+    bits_per_sample = 16
+    byte_rate = sample_rate * channels * bits_per_sample // 8
+    block_align = channels * bits_per_sample // 8
+    data_size = num_samples * channels * bits_per_sample // 8
+    
+    # Generate sine wave samples
+    frequency = 440.0  # A4 note
+    samples = []
+    for i in range(num_samples):
+        t = i / sample_rate
+        value = int(32767 * 0.5 * math.sin(2 * math.pi * frequency * t))
+        for _ in range(channels):
+            samples.append(value)
+    
+    # Build WAV header
+    wav = bytearray()
+    wav.extend(b"RIFF")
+    wav.extend(struct.pack("<I", 36 + data_size))
+    wav.extend(b"WAVE")
+    wav.extend(b"fmt ")
+    wav.extend(struct.pack("<I", 16))  # fmt chunk size
+    wav.extend(struct.pack("<H", 1))   # PCM format
+    wav.extend(struct.pack("<H", channels))
+    wav.extend(struct.pack("<I", sample_rate))
+    wav.extend(struct.pack("<I", byte_rate))
+    wav.extend(struct.pack("<H", block_align))
+    wav.extend(struct.pack("<H", bits_per_sample))
+    wav.extend(b"data")
+    wav.extend(struct.pack("<I", data_size))
+    
+    # Add sample data
+    for sample in samples:
+        wav.extend(struct.pack("<h", sample))
+    
+    return bytes(wav)
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])