cridecoder 0.2.2__tar.gz → 0.2.3__tar.gz

{cridecoder-0.2.2 → cridecoder-0.2.3}/Cargo.lock

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

{cridecoder-0.2.2 → cridecoder-0.2.3}/Cargo.toml

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

{cridecoder-0.2.2 → cridecoder-0.2.3}/PKG-INFO

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

{cridecoder-0.2.2 → cridecoder-0.2.3}/pyproject.toml

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

{cridecoder-0.2.2 → cridecoder-0.2.3}/src/acb/extractor.rs

@@ -9,6 +9,13 @@ use std::io::{Cursor, Read, Seek};
 use std::path::Path;
 use thiserror::Error;
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ExtractedAcbTrack {
+    pub name: String,
+    pub extension: String,
+    pub data: Vec<u8>,
+}
+
 #[derive(Error, Debug)]
 pub enum ExtractError {
     #[error("IO error: {0}")]
@@ -44,6 +51,38 @@ 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);
+
+    let mut outputs = Vec::new();
+    for track in &track_list.tracks {
+        let data = match get_track_data(track, &mut embedded_awb, &mut external_awbs)? {
+            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(),
+            extension,
+            data,
+        });
+    }
+
+    Ok(outputs)
+}
+
 fn load_embedded_awb(
     row: &std::collections::HashMap<String, crate::acb::utf::Value>,
 ) -> Option<AfsArchive<Cursor<Vec<u8>>>> {

{cridecoder-0.2.2 → cridecoder-0.2.3}/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.2 → cridecoder-0.2.3}/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.2 → cridecoder-0.2.3}/src/usm/extractor.rs

@@ -70,6 +70,13 @@ pub type UtfRow = std::collections::HashMap<String, UtfValue>;
 /// A UTF table
 pub type UtfTable = Vec<UtfRow>;
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ExtractedUsmStream {
+    pub name: 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>,
@@ -356,6 +363,32 @@ pub fn extract_usm<R: Read + Seek>(
     Ok(output_files)
 }
 
+/// Extract USM video/audio streams from a reader 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();
+
+    extract_usm_chunks_to_memory(
+        &mut reader,
+        base_name,
+        has_audio && export_audio,
+        vmask.as_ref(),
+        amask.as_ref(),
+    )
+}
+
 /// Parse USM header
 fn parse_usm_header<R: Read + Seek>(
     reader: &mut Reader<R>,
@@ -560,6 +593,86 @@ fn extract_usm_chunks<R: Read + Seek>(
     Ok(())
 }
 
+fn extract_usm_chunks_to_memory<R: Read + Seek>(
+    reader: &mut Reader<R>,
+    base_name: String,
+    export_audio: bool,
+    vmask: Option<&VideoMask>,
+    amask: Option<&AudioMask>,
+) -> Result<Vec<ExtractedUsmStream>, UsmError> {
+    let mut video = Vec::new();
+    let mut audio = if export_audio { Some(Vec::new()) } else { None };
+
+    while let Ok(next_sig) = reader.read_bytes(4) {
+        let block_size = reader.read_u32()?;
+        let current_pos = reader.stream_position()?;
+        let next_offset = current_pos + block_size as u64;
+
+        let chunk_header_size = reader.read_u16()?;
+        let chunk_footer_size = reader.read_u16()?;
+        let _ = reader.read_bytes(3)?;
+        let data_type_byte = reader.read_i8()?;
+        let data_type = (data_type_byte & 0b11) as u8;
+        reader.seek(SeekFrom::Current(16))?;
+
+        let contents_end = reader.read_bytes(13)?;
+        if &contents_end == b"#CONTENTS END" {
+            break;
+        }
+
+        reader.seek(SeekFrom::Current(-13))?;
+        let read_data_len =
+            block_size as usize - chunk_header_size as usize - chunk_footer_size as usize;
+
+        if next_sig == b"@SFV" {
+            let content = read_usm_chunk_to_vec(reader, read_data_len, data_type, vmask, None)?;
+            video.extend_from_slice(&content);
+        } else if next_sig == b"@SFA" {
+            if let Some(audio) = audio.as_mut() {
+                let content = read_usm_chunk_to_vec(reader, read_data_len, data_type, None, amask)?;
+                audio.extend_from_slice(&content);
+            }
+        }
+
+        reader.seek(SeekFrom::Start(next_offset))?;
+    }
+
+    let mut streams = vec![ExtractedUsmStream {
+        name: base_name.clone(),
+        extension: "m2v".to_string(),
+        data: video,
+    }];
+    if let Some(audio) = audio {
+        streams.push(ExtractedUsmStream {
+            name: base_name,
+            extension: "adx".to_string(),
+            data: audio,
+        });
+    }
+
+    Ok(streams)
+}
+
+fn read_usm_chunk_to_vec<R: Read + Seek>(
+    reader: &mut Reader<R>,
+    read_data_len: usize,
+    data_type: u8,
+    vmask: Option<&VideoMask>,
+    amask: Option<&AudioMask>,
+) -> Result<Vec<u8>, UsmError> {
+    let content = reader.read_bytes(read_data_len)?;
+    if data_type != 0 {
+        return Ok(content);
+    }
+    if let Some(vmask) = vmask {
+        return Ok(mask_video(&content, vmask));
+    }
+    if let Some(amask) = amask {
+        return Ok(mask_audio(&content, amask));
+    }
+    Ok(content)
+}
+
 /// Process a chunk
 #[allow(clippy::too_many_arguments)]
 fn process_chunk<R: Read + Seek>(

{cridecoder-0.2.2 → cridecoder-0.2.3}/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,
 };