ifstools 2.0__tar.gz → 2.1__tar.gz

{ifstools-2.0 → ifstools-2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ifstools
-Version: 2.0
+Version: 2.1
 Requires-Dist: kbinxml>=1.5
 Requires-Dist: lxml
 Requires-Dist: pillow

{ifstools-2.0 → ifstools-2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "ifstools"
-version = "2.0"
+version = "2.1"
 description = "Extractor/repacker for Konmai IFS files"
 readme = "README.md"
 authors = [

{ifstools-2.0 → ifstools-2.1}/rust/dxt.rs

@@ -9,11 +9,6 @@ use texpresso::Format;
 #[derive(Debug)]
 pub enum DxtError {
     UnknownFormat(String),
-    SizeMismatch {
-        expected: usize,
-        got: usize,
-        format: &'static str,
-    },
     OddByteCount(usize),
 }
 
@@ -21,11 +16,6 @@ impl std::fmt::Display for DxtError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             DxtError::UnknownFormat(s) => write!(f, "unknown DXT format: {}", s),
-            DxtError::SizeMismatch { expected, got, format } => write!(
-                f,
-                "{}: expected {} compressed bytes, got {}",
-                format, expected, got
-            ),
             DxtError::OddByteCount(n) => write!(f, "input length {} is not a multiple of 2", n),
         }
     }
@@ -60,16 +50,12 @@ pub fn decode(
     let expected = fmt.compressed_size(width, height);
 
     // Konami's per-WORD byte swap, with zero padding if the source is short.
+    // n is always even: data.len() is checked above, expected is a DXT block size.
     let mut swapped = vec![0u8; expected];
     let n = data.len().min(expected);
-    let pairs = n / 2;
-    for i in 0..pairs {
-        swapped[i * 2] = data[i * 2 + 1];
-        swapped[i * 2 + 1] = data[i * 2];
-    }
-    if n % 2 != 0 {
-        // Trailing odd byte (only possible when source is shorter than expected).
-        swapped[n - 1] = data[n - 1];
+    swapped[..n].copy_from_slice(&data[..n]);
+    for chunk in swapped[..n].chunks_exact_mut(2) {
+        chunk.swap(0, 1);
     }
     let _ = fmt_name; // currently only used for error formatting
 
@@ -78,6 +64,27 @@ pub fn decode(
     Ok(rgba)
 }
 
+/// Encode raw RGBA8 pixels (`width * height * 4` bytes) into Konami-format DXT
+/// data. Inverse of `decode`: compress to canonical DXT, then apply the
+/// per-WORD byte swap Konami's textures use.
+pub fn encode(
+    rgba: &[u8],
+    width: usize,
+    height: usize,
+    format: &str,
+) -> Result<Vec<u8>, DxtError> {
+    let (fmt, _) = parse_format(format)?;
+
+    let mut out = vec![0u8; fmt.compressed_size(width, height)];
+    fmt.compress(rgba, width, height, texpresso::Params::default(), &mut out);
+
+    // compressed_size is always a multiple of the (even) block size.
+    for chunk in out.chunks_exact_mut(2) {
+        chunk.swap(0, 1);
+    }
+    Ok(out)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -106,6 +113,19 @@ mod tests {
         }
     }
 
+    #[test]
+    fn dxt5_roundtrip() {
+        // Encode a solid opaque red 4x4, decode it, expect it back (DXT is
+        // lossy but a single flat color survives exactly).
+        let mut rgba = Vec::new();
+        for _ in 0..16 {
+            rgba.extend_from_slice(&[0xFF, 0x00, 0x00, 0xFF]);
+        }
+        let konami = encode(&rgba, 4, 4, "dxt5").unwrap();
+        let decoded = decode(&konami, 4, 4, "dxt5").unwrap();
+        assert_eq!(decoded, rgba);
+    }
+
     #[test]
     fn unknown_format_errors() {
         assert!(decode(&[0; 16], 4, 4, "garbage").is_err());

{ifstools-2.0 → ifstools-2.1}/rust/lib.rs

@@ -57,6 +57,21 @@ fn py_decode_dxt<'py>(
     Ok(PyBytes::new(py, &out))
 }
 
+#[pyfunction]
+#[pyo3(name = "encode_dxt")]
+fn py_encode_dxt<'py>(
+    py: Python<'py>,
+    rgba: Vec<u8>,
+    width: usize,
+    height: usize,
+    format: &str,
+) -> PyResult<Bound<'py, PyBytes>> {
+    let out = py
+        .detach(|| dxt::encode(&rgba, width, height, format))
+        .map_err(|e| PyValueError::new_err(e.to_string()))?;
+    Ok(PyBytes::new(py, &out))
+}
+
 #[pymodule]
 #[pyo3(name = "_native")]
 fn _native(m: &Bound<'_, PyModule>) -> PyResult<()> {
@@ -64,5 +79,6 @@ fn _native(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(py_compress, m)?)?;
     m.add_function(wrap_pyfunction!(py_encode_png, m)?)?;
     m.add_function(wrap_pyfunction!(py_decode_dxt, m)?)?;
+    m.add_function(wrap_pyfunction!(py_encode_dxt, m)?)?;
     Ok(())
 }

{ifstools-2.0 → ifstools-2.1}/rust/lz77.rs

@@ -15,6 +15,10 @@ const HASH_SIZE: usize = 1 << HASH_BITS;
 const HASH_MASK: u32 = HASH_SIZE as u32 - 1;
 const NIL: u32 = u32::MAX;
 
+// Greedy match-search depth. 128 hits a good speed/ratio knee on real-world
+// texture data: ~1.5× faster than an unbounded chain at <0.5% size cost.
+const MAX_CHAIN: u32 = 128;
+
 #[derive(Debug)]
 pub enum DecompressError {
     Truncated,
@@ -33,9 +37,10 @@ impl std::error::Error for DecompressError {}
 pub fn decompress(input: &[u8]) -> Result<Vec<u8>, DecompressError> {
     let mut out: Vec<u8> = Vec::with_capacity(input.len() * 2);
     let mut i = 0usize;
+    let n = input.len();
 
     loop {
-        if i >= input.len() {
+        if i >= n {
             return Err(DecompressError::Truncated);
         }
         let flag = input[i];
@@ -43,13 +48,13 @@ pub fn decompress(input: &[u8]) -> Result<Vec<u8>, DecompressError> {
 
         for bit in 0..8 {
             if (flag >> bit) & 1 == 1 {
-                if i >= input.len() {
+                if i >= n {
                     return Err(DecompressError::Truncated);
                 }
                 out.push(input[i]);
                 i += 1;
             } else {
-                if i + 1 >= input.len() {
+                if i + 1 >= n {
                     return Err(DecompressError::Truncated);
                 }
                 let w = u16::from_be_bytes([input[i], input[i + 1]]);
@@ -65,22 +70,31 @@ pub fn decompress(input: &[u8]) -> Result<Vec<u8>, DecompressError> {
                 // References into the virtual zero-prefilled window before stream start.
                 if pos > out.len() {
                     let diff = (pos - out.len()).min(len);
-                    out.extend(std::iter::repeat(0u8).take(diff));
+                    let new_len = out.len() + diff;
+                    out.resize(new_len, 0);
                     len -= diff;
                 }
 
-                // Self-overlapping copy: each output byte may feed the next.
+                if len == 0 {
+                    continue;
+                }
+
                 let start = out.len() - pos;
-                for k in 0..len {
-                    let b = out[start + k];
-                    out.push(b);
+                if pos >= len {
+                    // Non-overlapping run: single memcpy.
+                    out.extend_from_within(start..start + len);
+                } else {
+                    // Self-overlapping copy: each output byte may feed the next.
+                    for k in 0..len {
+                        let b = out[start + k];
+                        out.push(b);
+                    }
                 }
             }
         }
     }
 }
 
-/// Hash a 3-byte prefix into the chain table.
 #[inline(always)]
 fn hash3(a: u8, b: u8, c: u8) -> usize {
     let h = ((a as u32) << 16) | ((b as u32) << 8) | (c as u32);
@@ -88,9 +102,7 @@ fn hash3(a: u8, b: u8, c: u8) -> usize {
     ((h >> (32 - HASH_BITS)) & HASH_MASK) as usize
 }
 
-/// Compress a buffer. Output is byte-identical to the reference Python encoder
-/// when the matcher decisions agree (greedy longest-match here vs. greedy
-/// longest-match there).
+/// Compress a buffer. Greedy longest-match with a bounded hash chain.
 pub fn compress(input: &[u8]) -> Vec<u8> {
     // Pre-pend a 4 KB zero window so matches at the start can legitimately
     // reference into the zero-prefilled history that the decoder synthesises.
@@ -115,15 +127,17 @@ pub fn compress(input: &[u8]) -> Vec<u8> {
     let mut pos = WINDOW;
 
     while pos < buf_len {
+        // Reserve a flag byte we'll patch in once the group is done. Avoids the
+        // per-group scratch Vec the older impl allocated.
+        let flag_idx = out.len();
+        out.push(0);
         let mut flag_byte: u8 = 0;
-        let mut group: Vec<u8> = Vec::with_capacity(8 * 2);
 
         for bit in 0..8 {
             if pos >= buf_len {
                 // Out of input mid-group: leave the bit as match (0). The
-                // decoder will read into our trailing 0x00 0x00 0x00 sentinel
-                // and exit on the position == 0 check before reaching this
-                // phantom slot.
+                // decoder reads our trailing 0x00 0x00 0x00 sentinel and
+                // exits on the position == 0 check before reaching this slot.
                 continue;
             }
 
@@ -132,10 +146,9 @@ pub fn compress(input: &[u8]) -> Vec<u8> {
             if best_len >= THRESHOLD {
                 let dist = best_dist as u16;
                 let info: u16 = (dist << 4) | ((best_len - THRESHOLD) as u16);
-                group.extend_from_slice(&info.to_be_bytes());
+                out.extend_from_slice(&info.to_be_bytes());
 
-                // Insert hash entries for every position covered by the match,
-                // including the start (which we are about to skip past).
+                // Insert hash entries for every position covered by the match.
                 for k in 0..best_len {
                     let p = pos + k;
                     if p + 2 < buf_len {
@@ -146,7 +159,7 @@ pub fn compress(input: &[u8]) -> Vec<u8> {
                 }
                 pos += best_len;
             } else {
-                group.push(buf[pos]);
+                out.push(buf[pos]);
                 flag_byte |= 1 << bit;
 
                 if pos + 2 < buf_len {
@@ -158,8 +171,7 @@ pub fn compress(input: &[u8]) -> Vec<u8> {
             }
         }
 
-        out.push(flag_byte);
-        out.extend_from_slice(&group);
+        out[flag_idx] = flag_byte;
     }
 
     // EOS sentinel: flag byte saying "next code is a match", then a 0x0000
@@ -188,28 +200,24 @@ fn find_match(buf: &[u8], pos: usize, head: &[u32], prev: &[u32]) -> (usize, usi
 
     let mut best_len = 0usize;
     let mut best_dist = 0usize;
-
-    // Bound on chain depth — at N=4096 chains are short anyway, but cap to keep
-    // worst-case behaviour bounded on highly repetitive input.
-    let mut chain_remaining: u32 = 4096;
+    let mut chain_remaining = MAX_CHAIN;
 
     while candidate != NIL {
         let cand = candidate as usize;
         if cand < limit {
             break;
         }
+        if chain_remaining == 0 {
+            break;
+        }
         chain_remaining -= 1;
 
         // Quick reject: if the byte at best_len doesn't match, skip.
-        if best_len > 0 && buf[cand + best_len] != buf[pos + best_len] {
-            // fall through to chain step
-        } else {
-            // Compare bytes up to max_len.
+        if best_len == 0 || buf[cand + best_len] == buf[pos + best_len] {
             let mut len = 0usize;
             while len < max_len && buf[cand + len] == buf[pos + len] {
                 len += 1;
             }
-
             if len > best_len {
                 best_len = len;
                 best_dist = pos - cand;
@@ -219,9 +227,6 @@ fn find_match(buf: &[u8], pos: usize, head: &[u32], prev: &[u32]) -> (usize, usi
             }
         }
 
-        if chain_remaining == 0 {
-            break;
-        }
         candidate = prev[cand & (WINDOW - 1)];
     }
 

{ifstools-2.0 → ifstools-2.1}/src/ifstools/handlers/image_decoders.py

@@ -53,12 +53,15 @@ def decode_dxt5(ifs_img, data):
 def decode_dxt1(ifs_img, data):
     return decode_dxt(ifs_img, data, 'dxt1')
 
+def encode_dxt5(ifs_img, image):
+    return _native.encode_dxt(image.tobytes('raw', 'RGBA'), image.width, image.height, 'dxt5')
+
 
 image_formats = {
     'argb8888rev' : {'decoder': decode_argb8888rev, 'encoder': encode_argb8888rev},
     'argb4444'    : {'decoder': decode_argb4444, 'encoder': None},
     'dxt1'        : {'decoder': decode_dxt1, 'encoder': None},
-    'dxt5'        : {'decoder': decode_dxt5, 'encoder': None},
+    'dxt5'        : {'decoder': decode_dxt5, 'encoder': encode_dxt5 if _native else None},
 }
 
 cachable_formats = [key for key, val in image_formats.items() if val['encoder'] is not None]