Merge pull request #23 from soulsmods/feat/better-dcx

DCX parser rework

cli/Cargo.toml

@@ -11,3 +11,8 @@ indicatif = { version = "0.17", features = ["rayon"] }
 rayon = "1"
 souls_vfs = { path = "../vfs" }
 util = { path = "../util" }
+
+[dependencies.memmap2]
+version = "0.7"
+
+

cli/src/bin/dcx-extract.rs

@@ -1,7 +1,8 @@
-use std::io::Write;
+use std::io::{Read, Write};
 
 use clap::Parser;
-use format::{bnd4::BND4, dcx::DCX};
+use format::{bnd4::BND4, dcx::Dcx};
+use memmap2::MmapOptions;
 
 #[derive(Parser, Debug)]
 #[command(version, about, long_about = None)]
@@ -14,10 +15,21 @@ fn main() -> Result<(), std::io::Error> {
     let args = Args::parse();
     let path = std::path::PathBuf::from(args.file);
 
-    let mut dcx_file = std::fs::File::open(&path)?;
-    let dcx = DCX::from_reader(&mut dcx_file).expect("Could not parse DCX");
+    let dcx_file = std::fs::File::open(&path)?;
+    let data = unsafe {
+        MmapOptions::new()
+            .populate()
+            .map_copy_read_only(&dcx_file)?
+    };
 
-    let mut cursor = std::io::Cursor::new(dcx.decompressed);
+    let dcx = Dcx::parse(&data).unwrap();
+
+    let mut decoder = dcx.create_decoder().expect("Could not create decoder");
+
+    let mut decompressed = Vec::with_capacity(decoder.hint_size());
+    decoder.read_to_end(&mut decompressed)?;
+
+    let mut cursor = std::io::Cursor::new(decompressed);
     let bnd4 = BND4::from_reader(&mut cursor)?;
 
     let folder = format!(

format/Cargo.toml

@@ -13,11 +13,14 @@ strict-padding = []
 bytemuck = "1"
 byteorder = "1"
 aes = "0.8"
-oodle-safe = "0.1.0"
 rayon = "1"
 rug = "1.24"
 rsa = "0.9"
 zerocopy = { version = "0.7.32", features = ["derive"] }
+flate2 = "1.0"
 
 [dependencies.thiserror]
 workspace = true
+
+[dependencies.oodle-sys]
+version = "0.1"

format/src/dcx/deflate.rs

@@ -0,0 +1,17 @@
+use std::io::{self, Read};
+
+use flate2::read::ZlibDecoder;
+
+pub struct DcxDecoderDeflate<'a>(ZlibDecoder<&'a [u8]>);
+
+impl<'a> DcxDecoderDeflate<'a> {
+    pub fn from_buffer(buf: &'a [u8]) -> Self {
+        Self(ZlibDecoder::new(buf))
+    }
+}
+
+impl<'a> Read for DcxDecoderDeflate<'a> {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        self.0.read(buf)
+    }
+}

format/src/dcx/kraken.rs

@@ -0,0 +1,65 @@
+use std::io::{Cursor, Error, ErrorKind, Read, Result};
+
+use byteorder::BE;
+use oodle_sys::{
+    OodleLZ_Decode_ThreadPhase_OodleLZ_Decode_ThreadPhaseAll, OodleLZ_Decompress, OODLELZ_FAILED,
+};
+use zerocopy::U32;
+
+pub struct DcxDecoderKraken<'a> {
+    compressed: &'a [u8],
+    uncompressed_size: U32<BE>,
+    inner_cursor: Option<Cursor<Vec<u8>>>,
+}
+
+impl<'a> DcxDecoderKraken<'a> {
+    pub fn from_buffer(buf: &'a [u8], uncompressed_size: U32<BE>) -> Self {
+        Self {
+            compressed: buf,
+            uncompressed_size,
+            inner_cursor: None,
+        }
+    }
+}
+impl<'a> Read for DcxDecoderKraken<'a> {
+    // TODO: implement somewhat incremental reading by working with oodle's
+    // blocks per example in docs.
+    // It currently just decompresses the entire input one go and then
+    // operates a Cursor wrapping the decompressed bytes.
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
+        if self.inner_cursor.is_none() {
+            let mut inner_buffer = vec![0u8; self.uncompressed_size.get() as usize];
+            let compressed_len =
+                isize::try_from(inner_buffer.len()).map_err(|e| Error::new(ErrorKind::Other, e))?;
+            let inner_buffer_len =
+                isize::try_from(inner_buffer.len()).map_err(|e| Error::new(ErrorKind::Other, e))?;
+
+            let result = unsafe {
+                OodleLZ_Decompress(
+                    self.compressed.as_ptr() as *const _,
+                    compressed_len,
+                    inner_buffer.as_mut_ptr() as *mut _,
+                    inner_buffer_len,
+                    oodle_sys::OodleLZ_FuzzSafe_OodleLZ_FuzzSafe_Yes,
+                    0,
+                    0,
+                    std::ptr::null_mut(),
+                    0,
+                    None,
+                    std::ptr::null_mut(),
+                    std::ptr::null_mut(),
+                    0,
+                    OodleLZ_Decode_ThreadPhase_OodleLZ_Decode_ThreadPhaseAll,
+                ) as usize
+            };
+
+            if result == OODLELZ_FAILED as usize {
+                return Err(Error::from(ErrorKind::Other));
+            }
+
+            self.inner_cursor = Some(Cursor::new(inner_buffer));
+        }
+
+        self.inner_cursor.as_mut().unwrap().read(buf)
+    }
+}