no_std support

Author: kornelski

Cargo.toml

@@ -15,11 +15,18 @@ edition = "2021"
 rust-version = "1.65"
 
 [features]
-default = ["threads"]
-threads = ["dep:rayon", "dep:thread_local"]
+default = ["threads", "std"]
+
+# libimagequant makes good use of multi-threading, so disabling threads has a significant performance peanalty
+threads = ["dep:rayon", "dep:thread_local", "std"]
+
 # supports up to 2048 colors for palettes, but NOT FOR REMAPPING
 large_palettes = []
 
+# To opt-in you must disable the default features to disable `std` and `threads`, and also enable `no_std`
+std = []
+no_std = ["dep:hashbrown"]
+
 # this is private and unstable for imagequant-sys only, do not use
 _internal_c_ffi = []
 
@@ -35,6 +42,8 @@ arrayvec = { version = "0.7.4", default-features = false }
 rgb = { version = "0.8.47", default-features = false, features = ["bytemuck"] }
 rayon = { version = "1.10.0", optional = true }
 thread_local = { version = "1.1.8", optional = true }
+# Used only in no_std
+hashbrown = { version = "0.15.4", optional = true, default-features = false, features = ["alloc"] }
 
 [dev-dependencies]
 lodepng = "3.10"

imagequant-sys/Cargo.toml

@@ -22,6 +22,12 @@ default = ["imagequant/default"]
 # libimagequant makes good use of multi-threading, so disabling threads has a significant performance peanalty
 threads = ["imagequant/threads"]
 
+# To opt-in you must disable the default features to disable `std` and `threads`, and also enable `no_std`
+std = ["imagequant/std"]
+no_std = ["imagequant/no_std"]
+
+# Enable if you get errors like "no global memory allocator found" or "`#[panic_handler]` function required, but not found"
+no_std_global_handlers = ["no_std"]
 
 # internal for cargo-c only <http://lib.rs/cargo-c>
 capi = []

imagequant-sys/build.rs

@@ -1,3 +1,6 @@
 fn main() {
+    if cfg!(all(feature = "std", feature = "no_std")) {
+        println!("cargo::warning=both std and no_std features are enabled in imagequant-sys");
+    }
     println!("cargo:include={}", std::env::var("CARGO_MANIFEST_DIR").unwrap());
 }

imagequant-sys/src/ffi.rs

@@ -1,20 +1,26 @@
 //! Exports API for C programs and C-FFI-compatible languages. See `libimagequant.h` or <https://pngquant.org/lib/> for C docs.
 //!
 //! This crate is not supposed to be used in Rust directly. For Rust, see the parent [imagequant](https://lib.rs/imagequant) crate.
+#![cfg_attr(all(not(feature = "std"), feature = "no_std"), no_std)]
+
 #![allow(non_camel_case_types)]
 #![allow(clippy::missing_safety_doc)]
 #![allow(clippy::wildcard_imports)]
 #![allow(clippy::items_after_statements)]
 #![allow(clippy::cast_possible_truncation)]
 #![allow(clippy::cast_possible_wrap)]
 
+#[cfg(all(not(feature = "std"), feature = "no_std"))]
+extern crate alloc as std;
+
 use core::ffi::{c_char, c_int, c_uint, c_void};
 use core::mem::{ManuallyDrop, MaybeUninit};
 use core::{mem, ptr, slice};
 use imagequant::capi::*;
 use imagequant::Error::LIQ_OK;
 use imagequant::*;
 use std::ffi::CString;
+use std::boxed::Box;
 
 pub use imagequant::Error as liq_error;
 
@@ -437,6 +443,7 @@ pub extern "C" fn liq_attr_create_with_allocator(_unused: *mut c_void, free: uns
 #[no_mangle]
 #[inline(never)]
 #[allow(deprecated)]
+#[cfg_attr(all(feature = "std", feature = "no_std"), deprecated(note = "Cargo features configuration issue: both std and no_std features are enabled in imagequant-sys\nYou must disable default features to use no_std."))]
 pub extern "C" fn liq_attr_create() -> Option<Box<liq_attr>> {
     liq_attr_create_with_allocator(ptr::null_mut(), libc::free)
 }
@@ -780,3 +787,33 @@ fn c_callback_test_c() {
 fn ownership_bitflags() {
     assert_eq!(4 + 16, (liq_ownership::LIQ_OWN_ROWS | liq_ownership::LIQ_COPY_PIXELS).bits());
 }
+
+#[cfg(all(feature = "no_std_global_handlers", not(feature = "std"), feature = "no_std"))]
+#[cfg(not(test))]
+mod no_std_global_handlers {
+    use std::alloc::{GlobalAlloc, Layout};
+
+    #[cfg(panic = "unwind")]
+    compile_error!("no_std imagequant-sys must be compiled with panic=abort\n\nset env var CARGO_PROFILE_DEV_PANIC=abort and CARGO_PROFILE_RELEASE_PANIC=abort\nor modify your Cargo.toml to add `panic=\"abort\"` to `[profile.release]` and `[profile.dev]`");
+
+    #[panic_handler]
+    fn panic(_info: &core::panic::PanicInfo) -> ! {
+        unsafe { libc::abort(); }
+    }
+
+    #[global_allocator]
+    static GLOBAL_ALLOCATOR: Mallocator = Mallocator;
+
+    #[derive(Default)]
+    pub struct Mallocator;
+
+    unsafe impl GlobalAlloc for Mallocator {
+         unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+             libc::malloc(layout.size() as _).cast()
+         }
+
+         unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
+             libc::free(ptr.cast());
+         }
+    }
+}

src/attr.rs

@@ -6,8 +6,12 @@ use crate::quant::{mse_to_quality, quality_to_mse, QuantizationResult};
 use crate::remap::DitherMapMode;
 use std::sync::Arc;
 
+#[cfg(all(not(feature = "std"), feature = "no_std"))]
+use crate::no_std_compat::*;
+
 /// Starting point and settings for the quantization process
 #[derive(Clone)]
+#[cfg_attr(all(feature = "std", feature = "no_std"), deprecated(note = "Cargo features configuration issue: both std and no_std features are enabled in imagequant\nYou must disable default features to use no_std."))]
 pub struct Attributes {
     pub(crate) max_colors: PalLen,
     target_mse: f64,

src/capi.rs

@@ -3,6 +3,9 @@
 #![allow(missing_docs)]
 #![allow(clippy::missing_safety_doc)]
 
+#[cfg(all(not(feature = "std"), feature = "no_std"))]
+use crate::no_std_compat::*;
+
 use crate::pal::Palette;
 use crate::rows::RowCallback;
 use crate::seacow::{Pointer, RowBitmapMut, SeaCow};

src/hist.rs

@@ -4,10 +4,19 @@ use crate::pal::{f_pixel, gamma_lut, PalIndex, ARGBF, MAX_COLORS, RGBA};
 use crate::quant::QuantizationResult;
 use crate::rows::{temp_buf, DynamicRows};
 use crate::Attributes;
-use std::collections::{HashMap, HashSet};
 use core::{fmt, hash, mem};
 use core::hash::Hash;
 
+#[cfg(all(not(feature = "std"), feature = "no_std"))]
+use std::{format, boxed::Box, vec::Vec};
+
+#[cfg(all(not(feature = "std"), feature = "no_std"))]
+use hashbrown::{HashMap, HashSet};
+
+#[cfg(not(all(not(feature = "std"), feature = "no_std")))]
+use std::collections::{HashMap, HashSet};
+
+
 /// Number of pixels in a given color for [`Histogram::add_colors()`]
 ///
 /// Used for building a histogram manually. Otherwise see [`Histogram::add_image()`]

src/image.rs

@@ -9,6 +9,9 @@ use crate::{PushInCapacity, LIQ_HIGH_MEMORY_LIMIT};
 use rgb::prelude::*;
 use core::mem::{self, MaybeUninit};
 
+#[cfg(all(not(feature = "std"), feature = "no_std"))]
+use crate::no_std_compat::*;
+
 /// Describes image dimensions and pixels for the library
 ///
 /// Create one using [`Attributes::new_image()`].

src/kmeans.rs

@@ -7,6 +7,9 @@ use core::cell::RefCell;
 use rgb::prelude::*;
 use rgb::Argb;
 
+#[cfg(all(not(feature = "std"), feature = "no_std"))]
+use crate::no_std_compat::*;
+
 /// K-Means iteration: new palette color is computed from weighted average of colors that map best to that palette entry.
 // avoid false sharing
 pub(crate) struct Kmeans {

src/lib.rs

@@ -3,6 +3,8 @@
 //! Converts RGBA images to 8-bit with alpha channel.
 //!
 //! See `examples/` directory for example code.
+#![cfg_attr(all(not(feature = "std"), feature = "no_std"), no_std)]
+
 #![doc(html_logo_url = "https://pngquant.org/pngquant-logo.png")]
 #![deny(missing_docs)]
 #![allow(clippy::bool_to_int_with_if)]
@@ -19,6 +21,12 @@
 #![allow(clippy::wildcard_imports)]
 #![deny(clippy::semicolon_if_nothing_returned)]
 
+#[cfg(all(not(feature = "std"), feature = "no_std"))]
+extern crate alloc as std;
+
+#[cfg(all(not(feature = "std"), feature = "no_std"))]
+use std::vec::Vec;
+
 mod attr;
 mod blur;
 mod error;
@@ -138,8 +146,8 @@ fn poke_it() {
     assert_eq!(1, liq.min_posterization());
     liq.set_min_posterization(0).unwrap();
 
-    use std::sync::atomic::AtomicBool;
-    use std::sync::atomic::Ordering::SeqCst;
+    use core::sync::atomic::AtomicBool;
+    use core::sync::atomic::Ordering::SeqCst;
     use std::sync::Arc;
 
     let log_called = Arc::new(AtomicBool::new(false));
@@ -204,8 +212,8 @@ fn thread() {
 #[test]
 fn r_callback_test() {
     use core::mem::MaybeUninit;
-    use std::sync::atomic::AtomicU16;
-    use std::sync::atomic::Ordering::SeqCst;
+    use core::sync::atomic::AtomicU16;
+    use core::sync::atomic::Ordering::SeqCst;
     use std::sync::Arc;
 
     let called = Arc::new(AtomicU16::new(0));
@@ -349,3 +357,56 @@ fn test_fixed_colors() {
         assert!(pal[55..].iter().any(|&p| p == RGBA::new(c, c, c, 255)));
     }
 }
+
+#[cfg(all(not(feature = "std"), feature = "no_std"))]
+pub(crate) mod no_std_compat {
+    pub use std::boxed::Box;
+    pub use std::vec::Vec;
+    pub use std::format;
+
+    extern "C" {
+        fn pow(_: f64, _: f64) -> f64;
+        fn powf(_: f32, _: f32) -> f32;
+        fn sqrt(_: f64) -> f64;
+        fn sqrtf(_: f32) -> f32;
+    }
+
+    pub(crate) trait NoMath: Sized {
+        fn mul_add(self, mul: Self, add: Self) -> Self;
+        fn powi(self, n: u32) -> Self;
+        fn powf(self, e: Self) -> Self;
+        fn sqrt(self) -> Self;
+    }
+
+    impl NoMath for f32 {
+        fn mul_add(self, mul: Self, add: Self) -> Self {
+            self * mul + add
+        }
+        fn powi(self, n: u32) -> Self {
+            assert_eq!(n, 2);
+            self * self
+        }
+        fn powf(self, e: Self) -> Self {
+            unsafe { powf(self, e) }
+        }
+        fn sqrt(self) -> Self {
+            unsafe { sqrtf(self) }
+        }
+    }
+
+    impl NoMath for f64 {
+        fn mul_add(self, mul: Self, add: Self) -> Self {
+            self * mul + add
+        }
+        fn powi(self, n: u32) -> Self {
+            assert_eq!(n, 2);
+            self * self
+        }
+        fn powf(self, e: Self) -> Self {
+            unsafe { pow(self, e) }
+        }
+        fn sqrt(self) -> Self {
+            unsafe { sqrt(self) }
+        }
+    }
+}