paa: add generate to wasm (#1199)

* paa: add generate to wasm

* remove commented line

Author: BrettMayson

Cargo.lock

@@ -1,12 +1,12 @@
-import init, { ImageResult } from './hemtt_paa.js';
+import init, { FromPaaResult } from './hemtt_paa.js';
 
 async function run() {
     // Firefox linter has trouble with 'import', so import directly here
     let app = await init();
     chrome.runtime.onMessage.addListener(function(request, sender, sendResponse) {
         if (request.contentScriptQuery == "fetch_blob") {
             let b = new Uint8Array(request.ab);
-            let result = new ImageResult(b);
+            let result = new FromPaaResult(b);
             let arr = new Uint8Array(app.memory.buffer, result.data_ptr(), result.data_len());
             let blob = new Blob([arr], { type: 'image/png' });
             let reader = new FileReader();

browser/background.js

@@ -9,7 +9,6 @@ license = "GPL-2.0"
 workspace = true
 
 [dependencies]
-libc = "0.2.177"
 thiserror = { workspace = true }
 
 [dev-dependencies]

libs/lzo/Cargo.toml

@@ -1,8 +1,10 @@
-mod compress;
-mod decompress;
+use std::alloc::{Layout, alloc, dealloc};
 use std::mem;
 use std::slice;
 
+mod compress;
+mod decompress;
+
 use thiserror::Error;
 
 #[must_use]
@@ -49,9 +51,16 @@ pub enum LzoError {
 ///
 /// # Errors
 /// [`LzoError`] if an error occurs
+///
+/// # Panics
+/// If the layout creation fails
 pub fn compress(input: &[u8], output: &mut Vec<u8>) -> Result<(), LzoError> {
     unsafe {
-        let wrkmem = libc::malloc(LZO1X_MEM_COMPRESS);
+        use std::ffi::c_void;
+
+        let layout = Layout::from_size_align(LZO1X_MEM_COMPRESS, std::mem::align_of::<u8>())
+            .expect("Failed to create layout");
+        let wrkmem = alloc(layout).cast::<c_void>();
         let mut out_len = output.capacity();
         let err = compress::lzo1x_1_compress(
             input.as_ptr(),
@@ -62,7 +71,7 @@ pub fn compress(input: &[u8], output: &mut Vec<u8>) -> Result<(), LzoError> {
         );
 
         output.set_len(out_len);
-        libc::free(wrkmem);
+        dealloc(wrkmem.cast::<u8>(), layout);
         let res = mem::transmute::<i32, LzoError>(err);
         if res == LzoError::Ok {
             Ok(())
@@ -77,9 +86,14 @@ pub fn compress(input: &[u8], output: &mut Vec<u8>) -> Result<(), LzoError> {
 ///
 /// # Errors
 /// [`LzoError`] if an error occurs
+///
+/// # Panics
+/// If the layout creation fails
 pub fn compress_to_slice<'a>(in_: &[u8], out: &'a mut [u8]) -> Result<&'a mut [u8], LzoError> {
     unsafe {
-        let wrkmem = libc::malloc(LZO1X_MEM_COMPRESS);
+        let layout = Layout::from_size_align(LZO1X_MEM_COMPRESS, std::mem::align_of::<u8>())
+            .expect("Failed to create layout");
+        let wrkmem = alloc(layout).cast::<std::ffi::c_void>();
         let mut out_len = out.len();
         let err = compress::lzo1x_1_compress(
             in_.as_ptr(),
@@ -88,7 +102,7 @@ pub fn compress_to_slice<'a>(in_: &[u8], out: &'a mut [u8]) -> Result<&'a mut [u
             &raw mut out_len,
             wrkmem,
         );
-        libc::free(wrkmem);
+        dealloc(wrkmem.cast::<u8>(), layout);
         let res = mem::transmute::<i32, LzoError>(err);
         if res == LzoError::Ok {
             Ok(slice::from_raw_parts_mut(out.as_mut_ptr(), out_len))
@@ -143,12 +157,12 @@ fn compress_and_back() {
             let size = mem::size_of_val(&data[0]) * data.len();
             let dst_len: usize = worst_compress(size);
             let mut v = Vec::with_capacity(dst_len);
-            let dst = libc::malloc(dst_len);
+            let dst = alloc(Layout::from_size_align(dst_len, mem::align_of::<u8>()).unwrap());
             let dst = slice::from_raw_parts_mut(dst.cast::<u8>(), dst_len);
             let dst = compress_to_slice(&data, dst).unwrap();
             compress(&data, &mut v).unwrap();
 
-            let dec_dst = libc::malloc(size);
+            let dec_dst = alloc(Layout::from_size_align(size, mem::align_of::<u8>()).unwrap());
             let dec_dst = slice::from_raw_parts_mut(dec_dst.cast::<u8>(), size);
             let result = decompress_to_slice(dst, dec_dst).unwrap();
             assert!(result.len() == size);

libs/lzo/src/lzss/mod.rs

@@ -2,7 +2,7 @@
 name = "hemtt-paa"
 version = "1.0.1"
 edition = "2024"
-description = "An PAA library for hemtt"
+description = "A PAA library for hemtt"
 license = "GPL-2.0"
 
 [lints]

libs/paa/Cargo.toml

@@ -4,30 +4,12 @@ use js_sys::Uint8Array;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen]
-extern "C" {
-    // Use `js_namespace` here to bind `console.log(..)` instead of just
-    // `log(..)`
-    #[wasm_bindgen(js_namespace = console)]
-    fn log(s: &str);
-
-    // The `console.log` is quite polymorphic, so we can bind it with multiple
-    // signatures. Note that we need to use `js_name` to ensure we always call
-    // `log` in JS.
-    #[wasm_bindgen(js_namespace = console, js_name = log)]
-    fn log_u32(a: u32);
-
-    // Multiple arguments too!
-    #[wasm_bindgen(js_namespace = console, js_name = log)]
-    fn log_many(a: &str, b: &str);
-}
-
-#[wasm_bindgen]
-pub struct ImageResult {
+pub struct FromPaaResult {
     data: std::rc::Rc<std::cell::RefCell<Vec<u8>>>,
 }
 
 #[wasm_bindgen]
-impl ImageResult {
+impl FromPaaResult {
     #[wasm_bindgen(constructor)]
     pub fn new(s: &Uint8Array) -> Self {
         let bytes = s.to_vec();
@@ -53,3 +35,54 @@ impl ImageResult {
         self.data.clone().borrow().len() as u32
     }
 }
+
+#[cfg(feature = "generate")]
+use image::GenericImageView;
+
+#[cfg(feature = "generate")]
+#[wasm_bindgen]
+pub struct ToPaaResult {
+    data: std::rc::Rc<std::cell::RefCell<Vec<u8>>>,
+    format: String,
+}
+
+#[cfg(feature = "generate")]
+#[wasm_bindgen]
+impl ToPaaResult {
+    #[wasm_bindgen(constructor)]
+    pub fn new(s: &Uint8Array) -> Self {
+        let bytes = s.to_vec();
+        let img = image::load_from_memory(&bytes).expect("Failed to load image from memory");
+        let (width, height) = img.dimensions();
+        let format = if !height.is_power_of_two() || !width.is_power_of_two() {
+            crate::PaXType::ARGB8
+        } else {
+            let has_transparency = img.pixels().any(|p| p.2[3] < 255);
+            if has_transparency {
+                crate::PaXType::DXT5
+            } else {
+                crate::PaXType::DXT1
+            }
+        };
+        let paa = crate::Paa::from_dynamic(&img, format).expect("Failed to create PAA from image");
+        let mut buffer = Cursor::new(Vec::new());
+        paa.write(&mut buffer).expect("Failed to write PAA");
+        Self {
+            data: std::rc::Rc::new(std::cell::RefCell::from(buffer.into_inner())),
+            format: format.to_string(),
+        }
+    }
+
+    pub fn data_ptr(&self) -> *const u8 {
+        self.data.clone().borrow().as_ptr()
+    }
+
+    #[allow(clippy::cast_possible_truncation)]
+    pub fn data_len(&self) -> u32 {
+        self.data.clone().borrow().len() as u32
+    }
+
+    pub fn format(&self) -> String {
+        self.format.clone()
+    }
+}