roxify 1.13.2 → 1.13.3

package/native/lib.rs

@@ -69,51 +69,51 @@ pub fn native_adler32(buffer: Buffer) -> u32 {
 
 #[cfg(not(test))]
 #[napi]
-pub fn native_delta_encode(buffer: Buffer) -> Vec<u8> {
-    core::delta_encode_bytes(&buffer)
+pub fn native_delta_encode(buffer: Buffer) -> Buffer {
+    core::delta_encode_bytes(&buffer).into()
 }
 
 #[cfg(not(test))]
 #[napi]
-pub fn native_delta_decode(buffer: Buffer) -> Vec<u8> {
-    core::delta_decode_bytes(&buffer)
+pub fn native_delta_decode(buffer: Buffer) -> Buffer {
+    core::delta_decode_bytes(&buffer).into()
 }
 
 #[cfg(not(test))]
 #[napi]
-pub fn native_zstd_compress(buffer: Buffer, level: i32) -> Result<Vec<u8>> {
-    core::zstd_compress_bytes(&buffer, level, None).map_err(|e| Error::from_reason(e))
+pub fn native_zstd_compress(buffer: Buffer, level: i32) -> Result<Buffer> {
+    core::zstd_compress_bytes(&buffer, level, None).map(Buffer::from).map_err(|e| Error::from_reason(e))
 }
 
 #[cfg(not(test))]
 #[napi]
-pub fn native_zstd_compress_with_dict(buffer: Buffer, level: i32, dict: Buffer) -> Result<Vec<u8>> {
+pub fn native_zstd_compress_with_dict(buffer: Buffer, level: i32, dict: Buffer) -> Result<Buffer> {
     let dict_slice: &[u8] = &dict;
-    core::zstd_compress_bytes(&buffer, level, Some(dict_slice)).map_err(|e| Error::from_reason(e))
+    core::zstd_compress_bytes(&buffer, level, Some(dict_slice)).map(Buffer::from).map_err(|e| Error::from_reason(e))
 }
 
 #[cfg(not(test))]
 #[napi]
-pub fn native_zstd_decompress(buffer: Buffer) -> Result<Vec<u8>> {
-    core::zstd_decompress_bytes(&buffer, None).map_err(|e| Error::from_reason(e))
+pub fn native_zstd_decompress(buffer: Buffer) -> Result<Buffer> {
+    core::zstd_decompress_bytes(&buffer, None).map(Buffer::from).map_err(|e| Error::from_reason(e))
 }
 
 #[cfg(not(test))]
 #[napi]
-pub fn native_zstd_decompress_with_dict(buffer: Buffer, dict: Buffer) -> Result<Vec<u8>> {
+pub fn native_zstd_decompress_with_dict(buffer: Buffer, dict: Buffer) -> Result<Buffer> {
     let dict_slice: &[u8] = &dict;
-    core::zstd_decompress_bytes(&buffer, Some(dict_slice)).map_err(|e| Error::from_reason(e))
+    core::zstd_decompress_bytes(&buffer, Some(dict_slice)).map(Buffer::from).map_err(|e| Error::from_reason(e))
 }
 
 #[cfg(not(test))]
 #[napi]
-pub fn bwt_transform(buffer: Buffer) -> Result<Vec<u8>> {
+pub fn bwt_transform(buffer: Buffer) -> Result<Buffer> {
     match bwt::bwt_encode(&buffer) {
         Ok(result) => {
             let mut output = Vec::with_capacity(4 + result.transformed.len());
             output.extend_from_slice(&result.primary_index.to_le_bytes());
             output.extend_from_slice(&result.transformed);
-            Ok(output)
+            Ok(output.into())
         }
         Err(e) => Err(Error::from_reason(e.to_string())),
     }
@@ -191,15 +191,17 @@ mod tests {
 
 #[cfg(not(test))]
 #[napi]
-pub fn native_encode_png(buffer: Buffer, compression_level: i32) -> Result<Vec<u8>> {
+pub fn native_encode_png(buffer: Buffer, compression_level: i32) -> Result<Buffer> {
     encoder::encode_to_png(&buffer, compression_level)
+        .map(Buffer::from)
         .map_err(|e| Error::from_reason(e.to_string()))
 }
 
 #[cfg(not(test))]
 #[napi]
-pub fn native_encode_png_raw(buffer: Buffer, compression_level: i32) -> Result<Vec<u8>> {
+pub fn native_encode_png_raw(buffer: Buffer, compression_level: i32) -> Result<Buffer> {
     encoder::encode_to_png_raw(&buffer, compression_level)
+        .map(Buffer::from)
         .map_err(|e| Error::from_reason(e.to_string()))
 }
 
@@ -210,13 +212,14 @@ pub fn native_encode_png_with_name_and_filelist(
     compression_level: i32,
     name: Option<String>,
     file_list_json: Option<String>,
-) -> Result<Vec<u8>> {
+) -> Result<Buffer> {
     encoder::encode_to_png_with_name_and_filelist(
         &buffer,
         compression_level,
         name.as_deref(),
         file_list_json.as_deref(),
     )
+    .map(Buffer::from)
     .map_err(|e| Error::from_reason(e.to_string()))
 }
 
@@ -229,7 +232,7 @@ pub fn native_encode_png_with_encryption_name_and_filelist(
     encrypt_type: Option<String>,
     name: Option<String>,
     file_list_json: Option<String>,
-) -> Result<Vec<u8>> {
+) -> Result<Buffer> {
     encoder::encode_to_png_with_encryption_name_and_filelist(
         &buffer,
         compression_level,
@@ -238,13 +241,14 @@ pub fn native_encode_png_with_encryption_name_and_filelist(
         name.as_deref(),
         file_list_json.as_deref(),
     )
+    .map(Buffer::from)
     .map_err(|e| Error::from_reason(e.to_string()))
 }
 
 #[napi(object)]
 pub struct PngChunkData {
     pub name: String,
-    pub data: Vec<u8>,
+    pub data: Buffer,
 }
 
 #[cfg(not(test))]
@@ -255,21 +259,22 @@ pub fn extract_png_chunks(png_buffer: Buffer) -> Result<Vec<PngChunkData>> {
 
     Ok(chunks.into_iter().map(|c| PngChunkData {
         name: c.name,
-        data: c.data,
+        data: c.data.into(),
     }).collect())
 }
 
 #[cfg(not(test))]
 #[napi]
-pub fn encode_png_chunks(chunks: Vec<PngChunkData>) -> Result<Vec<u8>> {
+pub fn encode_png_chunks(chunks: Vec<PngChunkData>) -> Result<Buffer> {
     let native_chunks: Vec<png_utils::PngChunk> = chunks.into_iter()
         .map(|c| png_utils::PngChunk {
             name: c.name,
-            data: c.data,
+            data: c.data.to_vec(),
         })
         .collect();
 
     png_utils::encode_png_chunks(&native_chunks)
+        .map(Buffer::from)
         .map_err(|e| Error::from_reason(e))
 }
 
@@ -309,22 +314,23 @@ pub fn sharp_resize_image(
     width: u32,
     height: u32,
     kernel: String,
-) -> Result<Vec<u8>> {
+) -> Result<Buffer> {
     image_utils::sharp_resize(&input_buffer, width, height, &kernel)
+        .map(Buffer::from)
         .map_err(|e| Error::from_reason(e))
 }
 
 #[cfg(not(test))]
 #[napi]
-pub fn sharp_raw_pixels(input_buffer: Buffer) -> Result<Vec<u8>> {
+pub fn sharp_raw_pixels(input_buffer: Buffer) -> Result<Buffer> {
     let (pixels, _w, _h) = image_utils::sharp_raw_pixels(&input_buffer)
         .map_err(|e| Error::from_reason(e))?;
-    Ok(pixels)
+    Ok(pixels.into())
 }
 
 #[napi(object)]
 pub struct RawPixelsWithDimensions {
-    pub pixels: Vec<u8>,
+    pub pixels: Buffer,
     pub width: u32,
     pub height: u32,
 }
@@ -334,7 +340,7 @@ pub struct RawPixelsWithDimensions {
 pub fn sharp_to_raw(input_buffer: Buffer) -> Result<RawPixelsWithDimensions> {
     let (pixels, width, height) = image_utils::sharp_raw_pixels(&input_buffer)
         .map_err(|e| Error::from_reason(e))?;
-    Ok(RawPixelsWithDimensions { pixels, width, height })
+    Ok(RawPixelsWithDimensions { pixels: pixels.into(), width, height })
 }
 
 #[cfg(not(test))]
@@ -347,8 +353,9 @@ pub fn sharp_metadata(input_buffer: Buffer) -> Result<SharpMetadata> {
 
 #[cfg(not(test))]
 #[napi]
-pub fn rgb_to_png(rgb_buffer: Buffer, width: u32, height: u32) -> Result<Vec<u8>> {
+pub fn rgb_to_png(rgb_buffer: Buffer, width: u32, height: u32) -> Result<Buffer> {
     image_utils::rgb_to_png(&rgb_buffer, width, height)
+        .map(Buffer::from)
         .map_err(|e| Error::from_reason(e))
 }
 
@@ -357,27 +364,30 @@ pub fn rgb_to_png(rgb_buffer: Buffer, width: u32, height: u32) -> Result<Vec<u8>
 pub fn png_to_rgb(png_buffer: Buffer) -> Result<RawPixelsWithDimensions> {
     let (pixels, width, height) = image_utils::png_to_rgb(&png_buffer)
         .map_err(|e| Error::from_reason(e))?;
-    Ok(RawPixelsWithDimensions { pixels, width, height })
+    Ok(RawPixelsWithDimensions { pixels: pixels.into(), width, height })
 }
 
 #[cfg(not(test))]
 #[napi]
-pub fn crop_and_reconstitute(png_buffer: Buffer) -> Result<Vec<u8>> {
+pub fn crop_and_reconstitute(png_buffer: Buffer) -> Result<Buffer> {
     reconstitution::crop_and_reconstitute(&png_buffer)
+        .map(Buffer::from)
         .map_err(|e| Error::from_reason(e))
 }
 
 #[cfg(not(test))]
 #[napi]
-pub fn unstretch_nn(png_buffer: Buffer) -> Result<Vec<u8>> {
+pub fn unstretch_nn(png_buffer: Buffer) -> Result<Buffer> {
     reconstitution::unstretch_nn(&png_buffer)
+        .map(Buffer::from)
         .map_err(|e| Error::from_reason(e))
 }
 
 #[cfg(not(test))]
 #[napi]
-pub fn extract_payload_from_png(png_buffer: Buffer) -> Result<Vec<u8>> {
+pub fn extract_payload_from_png(png_buffer: Buffer) -> Result<Buffer> {
     png_utils::extract_payload_from_png(&png_buffer)
+        .map(Buffer::from)
         .map_err(|e| Error::from_reason(e))
 }
 
@@ -392,8 +402,9 @@ pub fn extract_file_list_from_pixels(png_buffer: Buffer) -> Result<String> {
 
 #[cfg(not(test))]
 #[napi]
-pub fn native_encode_wav(buffer: Buffer, compression_level: i32) -> Result<Vec<u8>> {
+pub fn native_encode_wav(buffer: Buffer, compression_level: i32) -> Result<Buffer> {
     encoder::encode_to_wav(&buffer, compression_level)
+        .map(Buffer::from)
         .map_err(|e| Error::from_reason(e.to_string()))
 }
 
@@ -404,13 +415,14 @@ pub fn native_encode_wav_with_name_and_filelist(
     compression_level: i32,
     name: Option<String>,
     file_list_json: Option<String>,
-) -> Result<Vec<u8>> {
+) -> Result<Buffer> {
     encoder::encode_to_wav_with_name_and_filelist(
         &buffer,
         compression_level,
         name.as_deref(),
         file_list_json.as_deref(),
     )
+    .map(Buffer::from)
     .map_err(|e| Error::from_reason(e.to_string()))
 }
 
@@ -423,7 +435,7 @@ pub fn native_encode_wav_with_encryption_name_and_filelist(
     encrypt_type: Option<String>,
     name: Option<String>,
     file_list_json: Option<String>,
-) -> Result<Vec<u8>> {
+) -> Result<Buffer> {
     encoder::encode_to_wav_with_encryption_name_and_filelist(
         &buffer,
         compression_level,
@@ -432,26 +444,29 @@ pub fn native_encode_wav_with_encryption_name_and_filelist(
         name.as_deref(),
         file_list_json.as_deref(),
     )
+    .map(Buffer::from)
     .map_err(|e| Error::from_reason(e.to_string()))
 }
 
 #[cfg(not(test))]
 #[napi]
-pub fn native_decode_wav_payload(wav_buffer: Buffer) -> Result<Vec<u8>> {
+pub fn native_decode_wav_payload(wav_buffer: Buffer) -> Result<Buffer> {
     encoder::decode_wav_payload(&wav_buffer)
+        .map(Buffer::from)
         .map_err(|e| Error::from_reason(e.to_string()))
 }
 
 #[cfg(not(test))]
 #[napi]
-pub fn native_bytes_to_wav(buffer: Buffer) -> Vec<u8> {
-    audio::bytes_to_wav(&buffer)
+pub fn native_bytes_to_wav(buffer: Buffer) -> Buffer {
+    audio::bytes_to_wav(&buffer).into()
 }
 
 #[cfg(not(test))]
 #[napi]
-pub fn native_wav_to_bytes(wav_buffer: Buffer) -> Result<Vec<u8>> {
+pub fn native_wav_to_bytes(wav_buffer: Buffer) -> Result<Buffer> {
     audio::wav_to_bytes(&wav_buffer)
+        .map(Buffer::from)
         .map_err(|e| Error::from_reason(e))
 }
 

package/native/main.rs

@@ -343,10 +343,16 @@ fn main() -> anyhow::Result<()> {
                         && sig == [137, 80, 78, 71, 13, 10, 26, 10]
                 });
 
-            if is_png_file && files.is_none() && dict.is_none() && file_size > 100_000_000 {
+            if is_png_file && files.is_none() && dict.is_none() {
                 let out_dir = output.clone().unwrap_or_else(|| PathBuf::from("out.raw"));
-                eprintln!("PROGRESS:5:100:decoding");
-                match streaming_decode::streaming_decode_to_dir_encrypted(&input, &out_dir, passphrase.as_deref()) {
+                match streaming_decode::streaming_decode_to_dir_encrypted_with_progress(
+                    &input,
+                    &out_dir,
+                    passphrase.as_deref(),
+                    Some(Box::new(|current, total, step| {
+                        eprintln!("PROGRESS:{}:{}:{}", current, total, step);
+                    })),
+                ) {
                     Ok(written) => {
                         eprintln!("PROGRESS:100:100:done");
                         println!("Unpacked {} files (TAR)", written.len());

package/native/streaming_decode.rs

@@ -7,14 +7,25 @@ const MARKER_BYTES: usize = 12;
 
 type Aes256Ctr = ctr::Ctr64BE<aes::Aes256>;
 
+pub type DecodeProgressCallback = Box<dyn Fn(u64, u64, &str) + Send>;
+
 pub fn streaming_decode_to_dir(png_path: &Path, out_dir: &Path) -> Result<Vec<String>, String> {
-    streaming_decode_to_dir_encrypted(png_path, out_dir, None)
+    streaming_decode_to_dir_encrypted_with_progress(png_path, out_dir, None, None)
 }
 
 pub fn streaming_decode_to_dir_encrypted(
     png_path: &Path,
     out_dir: &Path,
     passphrase: Option<&str>,
+) -> Result<Vec<String>, String> {
+    streaming_decode_to_dir_encrypted_with_progress(png_path, out_dir, passphrase, None)
+}
+
+pub fn streaming_decode_to_dir_encrypted_with_progress(
+    png_path: &Path,
+    out_dir: &Path,
+    passphrase: Option<&str>,
+    progress: Option<DecodeProgressCallback>,
 ) -> Result<Vec<String>, String> {
     let file = std::fs::File::open(png_path).map_err(|e| format!("open: {}", e))?;
     let mmap = unsafe { memmap2::Mmap::map(&file).map_err(|e| format!("mmap: {}", e))? };
@@ -24,7 +35,16 @@ pub fn streaming_decode_to_dir_encrypted(
         return Err("Not a PNG file".into());
     }
 
+    if let Some(ref cb) = progress {
+        cb(2, 100, "parsing_png");
+    }
+
     let (width, height, idat_data_start, idat_data_end) = parse_png_header(data)?;
+    let total_expected = parse_rxfl_total_bytes(data).unwrap_or(0);
+
+    if let Some(ref cb) = progress {
+        cb(5, 100, "reading_header");
+    }
 
     let mut reader = DeflatePixelReader::new(data, width, height, idat_data_start, idat_data_end);
 
@@ -51,6 +71,10 @@ pub fn streaming_decode_to_dir_encrypted(
     reader.read_exact(&mut plen_buf).map_err(|e| format!("read payload_len: {}", e))?;
     let payload_len = u32::from_be_bytes(plen_buf) as u64;
 
+    if let Some(ref cb) = progress {
+        cb(8, 100, "decrypting");
+    }
+
     let payload_reader = reader.take(payload_len);
 
     let first_byte_reader = FirstByteReader::new(payload_reader);
@@ -58,10 +82,13 @@ pub fn streaming_decode_to_dir_encrypted(
 
     match enc_byte {
         0x00 => {
+            if let Some(ref cb) = progress {
+                cb(10, 100, "decompressing");
+            }
             let mut decoder = zstd::stream::Decoder::new(remaining_reader)
                 .map_err(|e| format!("zstd decoder: {}", e))?;
             decoder.window_log_max(31).map_err(|e| format!("zstd window_log_max: {}", e))?;
-            read_rox1_and_untar(decoder, out_dir)
+            read_rox1_and_untar_with_progress(decoder, out_dir, progress, total_expected)
         }
         0x03 => {
             let pass = passphrase.ok_or("Passphrase required for AES-CTR decryption")?;
@@ -79,23 +106,31 @@ pub fn streaming_decode_to_dir_encrypted(
             let encrypted_data_len = payload_len - 1 - 16 - 16 - hmac_size;
             let ctr_reader = CtrDecryptReader::new(r.take(encrypted_data_len), cipher);
 
+            if let Some(ref cb) = progress {
+                cb(10, 100, "decompressing");
+            }
             let mut decoder = zstd::stream::Decoder::new(ctr_reader)
                 .map_err(|e| format!("zstd decoder: {}", e))?;
             decoder.window_log_max(31).map_err(|e| format!("zstd window_log_max: {}", e))?;
-            read_rox1_and_untar(decoder, out_dir)
+            read_rox1_and_untar_with_progress(decoder, out_dir, progress, total_expected)
         }
         _ => Err(format!("Unsupported encryption (enc=0x{:02x}) in streaming decode", enc_byte)),
     }
 }
 
-fn read_rox1_and_untar<R: Read>(mut decoder: R, out_dir: &Path) -> Result<Vec<String>, String> {
+fn read_rox1_and_untar_with_progress<R: Read>(
+    mut decoder: R,
+    out_dir: &Path,
+    progress: Option<DecodeProgressCallback>,
+    total_expected: u64,
+) -> Result<Vec<String>, String> {
     let mut magic = [0u8; 4];
     decoder.read_exact(&mut magic).map_err(|e| format!("read ROX1: {}", e))?;
     if &magic != b"ROX1" {
         return Err(format!("Expected ROX1, got {:?}", magic));
     }
     std::fs::create_dir_all(out_dir).map_err(|e| format!("mkdir: {}", e))?;
-    tar_unpack_from_reader(decoder, out_dir)
+    tar_unpack_from_reader_with_progress(decoder, out_dir, progress, total_expected)
 }
 
 fn parse_png_header(data: &[u8]) -> Result<(usize, usize, usize, usize), String> {
@@ -147,6 +182,30 @@ fn parse_png_header(data: &[u8]) -> Result<(usize, usize, usize, usize), String>
     Ok((width, height, idat_start, idat_end))
 }
 
+fn parse_rxfl_total_bytes(data: &[u8]) -> Option<u64> {
+    let mut pos = 8;
+    while pos + 12 <= data.len() {
+        let chunk_len = u32::from_be_bytes([data[pos], data[pos + 1], data[pos + 2], data[pos + 3]]) as usize;
+        let chunk_type = &data[pos + 4..pos + 8];
+        let chunk_data_start = pos + 8;
+
+        if chunk_type == b"rXFL" && chunk_data_start + chunk_len <= data.len() {
+            let json_bytes = &data[chunk_data_start..chunk_data_start + chunk_len];
+            if let Ok(entries) = serde_json::from_slice::<Vec<serde_json::Value>>(json_bytes) {
+                let total: u64 = entries.iter()
+                    .filter_map(|e| e.get("size").and_then(|s| s.as_u64()))
+                    .sum();
+                return Some(total);
+            }
+        } else if chunk_type == b"IEND" {
+            break;
+        }
+
+        pos = chunk_data_start + chunk_len + 4;
+    }
+    None
+}
+
 struct DeflatePixelReader<'a> {
     data: &'a [u8],
     height: usize,
@@ -298,15 +357,23 @@ impl<R: Read> Read for CtrDecryptReader<R> {
     }
 }
 
-fn tar_unpack_from_reader<R: Read>(reader: R, output_dir: &Path) -> Result<Vec<String>, String> {
+fn tar_unpack_from_reader_with_progress<R: Read>(
+    reader: R,
+    output_dir: &Path,
+    progress: Option<DecodeProgressCallback>,
+    total_expected: u64,
+) -> Result<Vec<String>, String> {
     let buf_reader = std::io::BufReader::with_capacity(8 * 1024 * 1024, reader);
     let mut archive = tar::Archive::new(buf_reader);
     let mut written = Vec::new();
     let mut created_dirs = std::collections::HashSet::new();
+    let mut bytes_extracted: u64 = 0;
+    let mut last_pct: u64 = 10;
 
     let entries = archive.entries().map_err(|e| format!("tar entries: {}", e))?;
     for entry in entries {
         let mut entry = entry.map_err(|e| format!("tar entry: {}", e))?;
+        let entry_size = entry.size();
         let path = entry.path().map_err(|e| format!("tar path: {}", e))?.to_path_buf();
 
         let mut safe = std::path::PathBuf::new();
@@ -327,11 +394,28 @@ fn tar_unpack_from_reader<R: Read>(reader: R, output_dir: &Path) -> Result<Vec<S
         }
 
         let mut f = std::io::BufWriter::with_capacity(
-            (entry.size() as usize).min(4 * 1024 * 1024).max(8192),
+            (entry_size as usize).min(4 * 1024 * 1024).max(8192),
             std::fs::File::create(&dest).map_err(|e| format!("create {:?}: {}", dest, e))?,
         );
         std::io::copy(&mut entry, &mut f).map_err(|e| format!("write {:?}: {}", dest, e))?;
         written.push(safe.to_string_lossy().to_string());
+
+        bytes_extracted += entry_size;
+        if let Some(ref cb) = progress {
+            let pct = if total_expected > 0 {
+                10 + (bytes_extracted * 89 / total_expected).min(89)
+            } else {
+                (10 + (bytes_extracted / (1024 * 1024))).min(99)
+            };
+            if pct > last_pct {
+                last_pct = pct;
+                cb(pct, 100, "extracting");
+            }
+        }
+    }
+
+    if let Some(ref cb) = progress {
+        cb(99, 100, "finishing");
     }
 
     Ok(written)