roxify 1.13.2 → 1.13.4

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

@@ -144,6 +144,19 @@ fn parse_markers(v: &[String]) -> Option<Vec<u8>> {
 
 fn main() -> anyhow::Result<()> {
     let cli = Cli::parse();
+
+fn parse_requested_files(files: &str) -> anyhow::Result<Vec<String>> {
+    if files.trim_start().starts_with('[') {
+        serde_json::from_str::<Vec<String>>(files)
+            .map_err(|e| anyhow::anyhow!("Invalid JSON for --files: {}", e))
+    } else {
+        Ok(files
+            .split(',')
+            .map(|file| file.trim().to_string())
+            .filter(|file| !file.is_empty())
+            .collect())
+    }
+}
     match cli.command {
         Commands::TrainDict { samples, size, output } => {
             let dict = core::train_zstd_dictionary(&samples, size)?;
@@ -169,7 +182,7 @@ fn main() -> anyhow::Result<()> {
                         eprintln!("PROGRESS:{}:{}:{}", current, total, step);
                     })),
                 )?;
-                println!("(TAR archive, rXFL chunk embedded)");
+                println!("(directory payload, rXFL chunk embedded)");
                 return Ok(());
             }
 
@@ -234,7 +247,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)");
+                    println!("(directory payload, rXFL chunk embedded)");
                 } else {
                     println!("(rXFL chunk embedded)");
                 }
@@ -343,13 +356,24 @@ 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 {
+            let requested_files = match files.as_deref() {
+                Some(files_str) => Some(parse_requested_files(files_str)?),
+                None => None,
+            };
+
+            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());
+                        println!("Unpacked {} files", written.len());
                         return Ok(());
                     }
                     Err(e) => {
@@ -358,25 +382,31 @@ fn main() -> anyhow::Result<()> {
                 }
             }
 
+            if is_png_file && requested_files.is_some() && dict.is_none() {
+                let out_dir = output.clone().unwrap_or_else(|| PathBuf::from("."));
+                std::fs::create_dir_all(&out_dir).map_err(|e| anyhow::anyhow!("Cannot create output directory {:?}: {}", out_dir, e))?;
+                let written = streaming_decode::streaming_decode_selected_to_dir_encrypted_with_progress(
+                    &input,
+                    &out_dir,
+                    requested_files.as_deref(),
+                    passphrase.as_deref(),
+                    Some(Box::new(|current, total, step| {
+                        eprintln!("PROGRESS:{}:{}:{}", current, total, step);
+                    })),
+                ).map_err(|e| anyhow::anyhow!(e))?;
+                eprintln!("PROGRESS:100:100:done");
+                println!("Unpacked {} files", written.len());
+                return Ok(());
+            }
+
             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,
             };
-                        if let Some(files_str) = files {
-                                let file_list: Option<Vec<String>> = if files_str.trim_start().starts_with('[') {
-                    match serde_json::from_str::<Vec<String>>(&files_str) {
-                        Ok(v) => Some(v),
-                        Err(e) => {
-                            eprintln!("Invalid JSON for --files: {}", e);
-                            std::process::exit(1);
-                        }
-                    }
-                } else {
-                    let list = files_str.split(',').map(|s| s.trim().to_string()).filter(|s| !s.is_empty()).collect::<Vec<_>>();
-                    Some(list)
-                };
+                        if requested_files.is_some() {
+                                let file_list = requested_files;
 
                                 let is_png = buf.len() >= 8 && &buf[0..8] == &[137, 80, 78, 71, 13, 10, 26, 10];
 
@@ -421,7 +451,9 @@ fn main() -> anyhow::Result<()> {
                 std::fs::create_dir_all(&out_dir).map_err(|e| anyhow::anyhow!("Cannot create output directory {:?}: {}", out_dir, e))?;
                 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))?;
+                                let written = packer::unpack_stream_to_dir(&mut reader, &out_dir, files_slice, Some(&|current, total, step| {
+                                    eprintln!("PROGRESS:{}:{}:{}", current, total, step);
+                                }), 0).map_err(|e| anyhow::anyhow!(e))?;
                 eprintln!("PROGRESS:100:100:done");
                 println!("Unpacked {} files", written.len());
             } else {
@@ -492,7 +524,7 @@ fn main() -> anyhow::Result<()> {
                         .map_err(|e| anyhow::anyhow!("mkdir {:?}: {}", out_dir, e))?;
                     let written = archive::tar_unpack(&out_bytes, &out_dir)
                         .map_err(|e| anyhow::anyhow!(e))?;
-                    println!("Unpacked {} files (TAR) to {:?}", written.len(), out_dir);
+                    println!("Unpacked {} files to {:?}", written.len(), out_dir);
                 } else if out_bytes.len() >= 4
                     && (u32::from_be_bytes(out_bytes[0..4].try_into().unwrap()) == 0x524f5850u32
                         || u32::from_be_bytes(out_bytes[0..4].try_into().unwrap()) == 0x524f5849u32)

package/native/packer.rs

@@ -255,13 +255,50 @@ fn unpack_entries_sequential(buf: &[u8], start: usize, out_dir: &Path, files_opt
     Ok(written)
 }
 
-pub fn unpack_stream_to_dir<R: std::io::Read>(reader: &mut R, out_dir: &Path, files_opt: Option<&[String]>) -> Result<Vec<String>> {
+fn unpack_progress_percent(total_expected: u64, bytes_processed: u64, file_count: usize, processed_files: usize) -> u64 {
+    if total_expected > 0 {
+        return 10 + (bytes_processed.saturating_mul(89) / total_expected).min(89);
+    }
+    if file_count > 0 {
+        return 10 + ((processed_files as u64).saturating_mul(89) / file_count as u64).min(89);
+    }
+    10
+}
+
+fn report_unpack_progress(
+    progress: Option<&(dyn Fn(u64, u64, &str) + Send)>,
+    total_expected: u64,
+    bytes_processed: u64,
+    file_count: usize,
+    processed_files: usize,
+    last_pct: &mut u64,
+) {
+    if let Some(cb) = progress {
+        let pct = unpack_progress_percent(total_expected, bytes_processed, file_count, processed_files);
+        if pct > *last_pct {
+            *last_pct = pct;
+            cb(pct, 100, "extracting");
+        }
+    }
+}
+
+pub fn unpack_stream_to_dir<R: std::io::Read>(
+    reader: &mut R,
+    out_dir: &Path,
+    files_opt: Option<&[String]>,
+    progress: Option<&(dyn Fn(u64, u64, &str) + Send)>,
+    total_expected: u64,
+) -> Result<Vec<String>> {
     let mut written = Vec::new();
     let mut buf: Vec<u8> = Vec::new();
     let mut pos: usize = 0;
     let mut temp = [0u8; 64 * 1024];
     let files_filter: Option<std::collections::HashSet<String>> = files_opt.map(|l| l.iter().map(|s| s.clone()).collect());
     let mut requested = files_filter.as_ref().map(|s| s.len()).unwrap_or(usize::MAX);
+    let mut file_count = 0usize;
+    let mut processed_files = 0usize;
+    let mut bytes_processed = 0u64;
+    let mut last_pct = 10u64;
 
         let mut header_parsed = false;
     let debug = std::env::var("ROX_DEBUG").is_ok();
@@ -280,10 +317,10 @@ pub fn unpack_stream_to_dir<R: std::io::Read>(reader: &mut R, out_dir: &Path, fi
                 if debug { eprintln!("[rox debug] magic_header=0x{:08x}", magic_header); }
                 if magic_header == 0x524f5850u32 {
                                         pos += 4;
-                                        let _file_count = u32::from_be_bytes(buf[pos..pos+4].try_into().unwrap()) as usize;
+                                        file_count = u32::from_be_bytes(buf[pos..pos+4].try_into().unwrap()) as usize;
                     pos += 4;
                     header_parsed = true;
-                    if debug { eprintln!("[rox debug] header parsed, file_count={}", _file_count); }
+                    if debug { eprintln!("[rox debug] header parsed, file_count={}", file_count); }
                 } else if magic_header == 0x524f5831u32 {
                                         if debug { eprintln!("[rox debug] found ROX1 outer magic, skipping 4 bytes"); }
                     pos += 4;
@@ -310,6 +347,8 @@ pub fn unpack_stream_to_dir<R: std::io::Read>(reader: &mut R, out_dir: &Path, fi
             let content_start = pos + 2 + name_len + 8;
             let content_end = content_start + size;
             let content = &buf[content_start..content_end];
+            processed_files = processed_files.saturating_add(1);
+            bytes_processed = bytes_processed.saturating_add(size as u64);
 
                         let p = Path::new(&name);
             let mut safe = std::path::PathBuf::new();
@@ -328,10 +367,18 @@ pub fn unpack_stream_to_dir<R: std::io::Read>(reader: &mut R, out_dir: &Path, fi
                 written.push(safe.to_string_lossy().to_string());
                 if let Some(_set) = files_filter.as_ref() {
                     requested = requested.saturating_sub(1);
-                    if requested == 0 { return Ok(written); }
+                    report_unpack_progress(progress, total_expected, bytes_processed, file_count, processed_files, &mut last_pct);
+                    if requested == 0 {
+                        if let Some(cb) = progress {
+                            cb(99, 100, "finishing");
+                        }
+                        return Ok(written);
+                    }
                 }
             }
 
+            report_unpack_progress(progress, total_expected, bytes_processed, file_count, processed_files, &mut last_pct);
+
             pos = content_end;                         if pos > 0 {
                 buf.drain(0..pos);
                 pos = 0;
@@ -344,6 +391,10 @@ pub fn unpack_stream_to_dir<R: std::io::Read>(reader: &mut R, out_dir: &Path, fi
         }
     }
 
+    if let Some(cb) = progress {
+        cb(99, 100, "finishing");
+    }
+
     Ok(written)
 }
 
@@ -390,7 +441,7 @@ mod stream_tests {
         let tmpdir = std::env::temp_dir().join(format!("rox_unpack_test_{}", ms));
         let _ = std::fs::create_dir_all(&tmpdir);
 
-        let out = unpack_stream_to_dir(&mut dec2, &tmpdir, None)?;
+        let out = unpack_stream_to_dir(&mut dec2, &tmpdir, None, None, 0)?;
 
                 assert_eq!(out.len(), 2);
         assert!(tmpdir.join("file1.txt").exists());
@@ -432,7 +483,7 @@ mod stream_tests {
         let tmpdir = std::env::temp_dir().join(format!("rox_unpack_png_test_{}", ms));
         let _ = std::fs::create_dir_all(&tmpdir);
 
-        let out = unpack_stream_to_dir(&mut dec, &tmpdir, None)?;
+        let out = unpack_stream_to_dir(&mut dec, &tmpdir, None, None, 0)?;
 
         assert_eq!(out.len(), 2);
         assert!(tmpdir.join("file1.txt").exists());