Deploying to gh-pages from @ 49db36a 🚀

Author: HHMagnus

Cargo.toml

@@ -7,6 +7,6 @@ edition = "2024"
 crate-type = ["cdylib", "rlib"]
 
 [dependencies]
-image = "0.25.8"
+image = { version = "0.25.8", features = ["default-formats"] }
 js-sys = "0.3.78"
 wasm-bindgen = "0.2.101"

index.html

@@ -138,6 +138,38 @@ <h1>Offline Image Converter</h1>
       </select>
     </div>
 
+    <details id="advancedInput">
+      <summary>
+        Advanced options (click to expand)
+      </summary>
+      <div>
+        <label for="quality">Quality (0-100, where 100 is best quality):</label>
+        <input type="number" id="quality" name="quality" min="0" max="100" />
+      </div>
+
+      <div>
+        <label for="compression">Compression method:</label>
+        <select id="compression" name="compression">
+          <option value="fast">Fast</option>
+          <option value="best">Best</option>
+          <option value="default">Default</option>
+        </select>
+      </div>
+
+      <div>
+        <label for="filter">Filter type:</label>
+        <select id="filter" name="filter">
+          <option value="adaptive">Adaptive</option>
+          <option value="no_filter">No filter</option>
+          <option value="sub">Sub</option>
+          <option value="up">Up</option>
+          <option value="avg">Avg</option>
+          <option value="paeth">Paeth</option>
+        </select>
+      </div>
+
+    </details>
+
     <button id="convertBtn" onclick="convert()">Convert</button>
 
     <div id="loader" style="display: none;">

pkg/image_convert.d.ts

@@ -1,12 +1,17 @@
 /* tslint:disable */
 /* eslint-disable */
-export function convert_exposed(image_data: Uint8Array, input: string, output: string): Uint8Array;
+export function convert_exposed(image_data: Uint8Array, input: string, output: string, options: EncoderInput): Uint8Array;
+export class EncoderInput {
+  private constructor();
+  free(): void;
+}
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
-  readonly convert_exposed: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number, number];
+  readonly __wbg_encoderinput_free: (a: number, b: number) => void;
+  readonly convert_exposed: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number, number];
   readonly __wbindgen_exn_store: (a: number) => void;
   readonly __externref_table_alloc: () => number;
   readonly __wbindgen_export_2: WebAssembly.Table;

pkg/image_convert.js

@@ -186,6 +186,12 @@ function passArray8ToWasm0(arg, malloc) {
     return ptr;
 }
 
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
 function takeFromExternrefTable0(idx) {
     const value = wasm.__wbindgen_export_2.get(idx);
     wasm.__externref_table_dealloc(idx);
@@ -200,22 +206,44 @@ function getArrayU8FromWasm0(ptr, len) {
  * @param {Uint8Array} image_data
  * @param {string} input
  * @param {string} output
+ * @param {EncoderInput} options
  * @returns {Uint8Array}
  */
-export function convert_exposed(image_data, input, output) {
+export function convert_exposed(image_data, input, output, options) {
     const ptr0 = passArray8ToWasm0(image_data, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     const ptr1 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
     const ptr2 = passStringToWasm0(output, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len2 = WASM_VECTOR_LEN;
-    const ret = wasm.convert_exposed(ptr0, len0, ptr1, len1, ptr2, len2);
+    _assertClass(options, EncoderInput);
+    var ptr3 = options.__destroy_into_raw();
+    const ret = wasm.convert_exposed(ptr0, len0, ptr1, len1, ptr2, len2, ptr3);
     if (ret[3]) {
         throw takeFromExternrefTable0(ret[2]);
     }
-    var v4 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    var v5 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
     wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v4;
+    return v5;
+}
+
+const EncoderInputFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_encoderinput_free(ptr >>> 0, 1));
+
+export class EncoderInput {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        EncoderInputFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_encoderinput_free(ptr, 0);
+    }
 }
 
 const EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);

pkg/image_convert_bg.wasm

@@ -1,7 +1,8 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
-export const convert_exposed: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number, number];
+export const __wbg_encoderinput_free: (a: number, b: number) => void;
+export const convert_exposed: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number, number];
 export const __wbindgen_exn_store: (a: number) => void;
 export const __externref_table_alloc: () => number;
 export const __wbindgen_export_2: WebAssembly.Table;

pkg/image_convert_bg.wasm.d.ts

@@ -1,19 +1,72 @@
 use std::io::Cursor;
 
-use image::{ImageError, ImageFormat};
+use image::{codecs::{jpeg::JpegEncoder, png::{CompressionType, FilterType, PngEncoder}}, ImageEncoder, ImageError, ImageFormat};
 use js_sys::Reflect;
 use wasm_bindgen::{prelude::wasm_bindgen, JsCast, JsValue};
 
+enum EncoderOptions {
+	Jpeg { quality: u8 },
+	Png { compression: CompressionType, filter: FilterType },
+	None,
+}
+
+#[wasm_bindgen]
+pub struct EncoderInput {
+	quality: Option<u8>,
+	compression: Option<String>,
+	filter: Option<String>,
+}
+
+impl EncoderInput {
+	fn to_options(&self, format: ImageFormat) -> EncoderOptions {
+		match format {
+			ImageFormat::Jpeg => self.quality.map(|v| EncoderOptions::Jpeg { quality: v }).unwrap_or(EncoderOptions::None),
+			ImageFormat::Png => {
+				let compression = match self.compression.as_deref() {
+					Some("fast") => Some(CompressionType::Fast),
+					Some("best") => Some(CompressionType::Best),
+					Some("default") => Some(CompressionType::Default),
+					_ => None,
+				};
+				let filter = match self.filter.as_deref() {
+					Some("no_filter") => Some(FilterType::NoFilter),
+					Some("sub") => Some(FilterType::Sub),
+					Some("up") => Some(FilterType::Up),
+					Some("avg") => Some(FilterType::Avg),
+					Some("paeth") => Some(FilterType::Paeth),
+					Some("adaptive") => Some(FilterType::Adaptive),
+					_ => None
+				};
+				match (compression, filter) {
+					(Some(c), Some(f)) => EncoderOptions::Png { compression: c, filter: f },
+					(_, _) => EncoderOptions::None,
+				}
+			}
+			_ => EncoderOptions::None,
+		}
+	}
+}
+
 fn map_image_err(err: ImageError) -> String {
-    format!("Image processing error: {}", err)
+	format!("Image processing error: {}", err)
 }
 
-fn convert(image_data: Vec<u8>, input: ImageFormat, output: ImageFormat) -> Result<Vec<u8>, String> {
+fn convert(image_data: Vec<u8>, input: ImageFormat, output: ImageFormat, options: EncoderOptions) -> Result<Vec<u8>, String> {
 	report_progress("Loading image...");
     let img = image::load_from_memory_with_format(&image_data, input).map_err(map_image_err)?;
     let mut output_data: Vec<u8> = Vec::new();
 	report_progress("Converting to new format...");
-    img.write_to(&mut Cursor::new(&mut output_data), output).map_err(map_image_err)?;
+	match options {
+		EncoderOptions::Jpeg { quality } => {
+			let mut encoder = JpegEncoder::new_with_quality(&mut output_data, quality);
+			encoder.encode_image(&img).map_err(map_image_err)?;
+		},
+		EncoderOptions::Png { compression, filter } => {
+			let encoder = PngEncoder::new_with_quality(&mut output_data, compression, filter);
+			encoder.write_image(&img.as_bytes(), img.width(), img.height(), img.color().into()).map_err(map_image_err)?;
+		},
+		EncoderOptions::None => img.write_to(&mut Cursor::new(&mut output_data), output).map_err(map_image_err)?,
+	};
 	report_progress("Completed conversion.");
     Ok(output_data)
 }
@@ -40,10 +93,11 @@ fn str_to_type(s: &str) -> Option<ImageFormat> {
 }
 
 #[wasm_bindgen]
-pub fn convert_exposed(image_data: Vec<u8>, input: String, output: String) -> Result<Vec<u8>, String> {
+pub fn convert_exposed(image_data: Vec<u8>, input: String, output: String, options: EncoderInput) -> Result<Vec<u8>, String> {
     let input = str_to_type(&input).ok_or_else(|| format!("Unsupported input format: {}", input))?;
     let output = str_to_type(&output).ok_or_else(|| format!("Unsupported output format: {}", output))?;
-    convert(image_data, input, output)
+	let options = options.to_options(output);
+    convert(image_data, input, output, options)
 }
 
 fn report_progress(message: &str) {