roxify 1.13.1 → 1.13.3

package/native/lib.rs

@@ -6,8 +6,6 @@ use napi_derive::napi;
 static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
 
 mod core;
-#[cfg(feature = "gpu")]
-mod gpu;
 mod rans;
 mod rans_byte;
 mod bwt;
@@ -27,15 +25,6 @@ mod archive;
 mod streaming;
 
 pub use core::*;
-#[cfg(feature = "gpu")]
-pub use gpu::*;
-#[cfg(not(feature = "gpu"))]
-mod gpu {
-        pub fn gpu_available() -> bool {
-        false
-    }
-}
-
 pub use rans::*;
 pub use bwt::*;
 pub use context_mixing::*;
@@ -57,12 +46,6 @@ pub struct CompressionReport {
     pub blocks_count: u32,
 }
 
-#[napi(object)]
-pub struct GpuStatus {
-    pub available: bool,
-    pub adapter_info: Option<String>,
-}
-
 #[cfg(not(test))]
 #[napi]
 pub fn scan_pixels(buffer: Buffer, channels: u32, marker_bytes: Option<Buffer>) -> Result<ScanResult> {
@@ -86,60 +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))
-}
-
-#[cfg(not(test))]
-#[napi]
-pub fn check_gpu_status() -> GpuStatus {
-    GpuStatus {
-        available: gpu::gpu_available(),
-        adapter_info: None,
-    }
+    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())),
     }
@@ -217,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()))
 }
 
@@ -236,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()))
 }
 
@@ -255,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,
@@ -264,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))]
@@ -281,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))
 }
 
@@ -335,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,
 }
@@ -360,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))]
@@ -373,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))
 }
 
@@ -383,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))
 }
 
@@ -418,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()))
 }
 
@@ -430,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()))
 }
 
@@ -449,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,
@@ -458,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

@@ -17,6 +17,7 @@ mod archive;
 mod streaming;
 mod streaming_decode;
 mod streaming_encode;
+mod progress;
 
 use crate::encoder::ImageFormat;
 use std::path::PathBuf;
@@ -157,13 +158,16 @@ fn main() -> anyhow::Result<()> {
                 .or_else(|| input.file_name().and_then(|n| n.to_str()));
 
             if is_dir && dict.is_none() {
-                streaming_encode::encode_dir_to_png_encrypted(
+                streaming_encode::encode_dir_to_png_encrypted_with_progress(
                     &input,
                     &output,
                     level,
                     file_name,
                     passphrase.as_deref(),
                     Some(&encrypt),
+                    Some(Box::new(|current, total, step| {
+                        eprintln!("PROGRESS:{}:{}:{}", current, total, step);
+                    })),
                 )?;
                 println!("(TAR archive, rXFL chunk embedded)");
                 return Ok(());
@@ -187,6 +191,7 @@ fn main() -> anyhow::Result<()> {
             };
 
             let use_streaming = payload.len() > 64 * 1024 * 1024;
+            eprintln!("PROGRESS:50:100:encoding");
 
             if use_streaming {
                 streaming::encode_to_png_file(
@@ -227,6 +232,7 @@ fn main() -> anyhow::Result<()> {
             }
 
             if file_list_json.is_some() {
+                eprintln!("PROGRESS:100:100:done");
                 if is_dir {
                     println!("(TAR archive, rXFL chunk embedded)");
                 } else {
@@ -337,10 +343,18 @@ 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"));
-                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());
                         return Ok(());
                     }
@@ -351,6 +365,7 @@ fn main() -> anyhow::Result<()> {
             }
 
             let buf = read_all(&input)?;
+            eprintln!("PROGRESS:20:100:decompressing");
             let dict_bytes: Option<Vec<u8>> = match dict {
                 Some(path) => Some(read_all(&path)?),
                 None => None,
@@ -413,6 +428,7 @@ fn main() -> anyhow::Result<()> {
                 let files_slice = file_list.as_ref().map(|v| v.as_slice());
 
                                 let written = packer::unpack_stream_to_dir(&mut reader, &out_dir, files_slice).map_err(|e| anyhow::anyhow!(e))?;
+                eprintln!("PROGRESS:100:100:done");
                 println!("Unpacked {} files", written.len());
             } else {
                                                 let is_png = buf.len() >= 8 && &buf[0..8] == &[137, 80, 78, 71, 13, 10, 26, 10];
@@ -511,6 +527,7 @@ fn main() -> anyhow::Result<()> {
                 } else {
                     write_all(&dest, &out_bytes)?;
                 }
+                eprintln!("PROGRESS:100:100:done");
             }
         }
         Commands::Crc32 { input } => {

package/native/progress.rs

@@ -1,43 +1,142 @@
 use parking_lot::Mutex;
 use std::sync::Arc;
+use std::time::Instant;
 
-pub struct ProgressBar {
+#[derive(Clone, Debug)]
+pub struct ProgressSnapshot {
+    pub current: u64,
+    pub total: u64,
+    pub percentage: f64,
+    pub elapsed_ms: u64,
+    pub eta_ms: Option<u64>,
+    pub speed_bytes_per_sec: f64,
+    pub step: String,
+}
+
+struct ProgressInner {
     total: u64,
-    current: Arc<Mutex<u64>>,
-    message: Arc<Mutex<String>>,
+    current: u64,
+    step: String,
+    start: Instant,
+}
+
+pub struct ProgressBar {
+    inner: Arc<Mutex<ProgressInner>>,
+    callback: Arc<Mutex<Option<Box<dyn Fn(ProgressSnapshot) + Send>>>>,
 }
 
 impl ProgressBar {
     pub fn new(total: u64) -> Self {
         Self {
-            total,
-            current: Arc::new(Mutex::new(0)),
-            message: Arc::new(Mutex::new(String::new())),
+            inner: Arc::new(Mutex::new(ProgressInner {
+                total,
+                current: 0,
+                step: String::new(),
+                start: Instant::now(),
+            })),
+            callback: Arc::new(Mutex::new(None)),
+        }
+    }
+
+    pub fn with_callback<F: Fn(ProgressSnapshot) + Send + 'static>(total: u64, cb: F) -> Self {
+        Self {
+            inner: Arc::new(Mutex::new(ProgressInner {
+                total,
+                current: 0,
+                step: String::new(),
+                start: Instant::now(),
+            })),
+            callback: Arc::new(Mutex::new(Some(Box::new(cb)))),
         }
     }
 
     pub fn inc(&self, delta: u64) {
-        let mut current = self.current.lock();
-        *current += delta;
+        let snapshot = {
+            let mut inner = self.inner.lock();
+            inner.current += delta;
+            self.snapshot_inner(&inner)
+        };
+        self.emit(snapshot);
     }
 
     pub fn set(&self, value: u64) {
-        let mut current = self.current.lock();
-        *current = value;
+        let snapshot = {
+            let mut inner = self.inner.lock();
+            inner.current = value;
+            self.snapshot_inner(&inner)
+        };
+        self.emit(snapshot);
     }
 
-    pub fn set_message(&self, msg: String) {
-        let mut message = self.message.lock();
-        *message = msg;
+    pub fn set_step(&self, step: &str) {
+        let snapshot = {
+            let mut inner = self.inner.lock();
+            inner.step = step.to_string();
+            self.snapshot_inner(&inner)
+        };
+        self.emit(snapshot);
     }
 
-    pub fn get_progress(&self) -> (u64, u64) {
-        let current = *self.current.lock();
-        (current, self.total)
+    pub fn snapshot(&self) -> ProgressSnapshot {
+        let inner = self.inner.lock();
+        self.snapshot_inner(&inner)
+    }
+
+    fn snapshot_inner(&self, inner: &ProgressInner) -> ProgressSnapshot {
+        let elapsed = inner.start.elapsed();
+        let elapsed_ms = elapsed.as_millis() as u64;
+        let percentage = if inner.total > 0 {
+            (inner.current as f64 / inner.total as f64) * 100.0
+        } else {
+            0.0
+        };
+
+        let elapsed_secs = elapsed.as_secs_f64();
+        let speed = if elapsed_secs > 0.01 {
+            inner.current as f64 / elapsed_secs
+        } else {
+            0.0
+        };
+
+        let eta_ms = if speed > 0.0 && inner.current > 0 && inner.current < inner.total {
+            let remaining = inner.total - inner.current;
+            Some((remaining as f64 / speed * 1000.0) as u64)
+        } else {
+            None
+        };
+
+        ProgressSnapshot {
+            current: inner.current,
+            total: inner.total,
+            percentage,
+            elapsed_ms,
+            eta_ms,
+            speed_bytes_per_sec: speed,
+            step: inner.step.clone(),
+        }
+    }
+
+    fn emit(&self, snapshot: ProgressSnapshot) {
+        if let Some(ref cb) = *self.callback.lock() {
+            cb(snapshot);
+        }
     }
 
     pub fn finish(&self) {
-        let mut current = self.current.lock();
-        *current = self.total;
+        let snapshot = {
+            let mut inner = self.inner.lock();
+            inner.current = inner.total;
+            self.snapshot_inner(&inner)
+        };
+        self.emit(snapshot);
+    }
+
+    pub fn get_progress(&self) -> (u64, u64) {
+        let inner = self.inner.lock();
+        (inner.current, inner.total)
+    }
+
+    pub fn set_message(&self, msg: String) {
+        self.set_step(&msg);
     }
 }