Try using no-std types

(cherry picked from commit c35147c0477b727221ed237368a0dea75e47fad5)

Author: kornelski

benches/bench.rs

@@ -1,6 +1,7 @@
 #![feature(test)]
 
 extern crate test;
+use core::mem::MaybeUninit;
 use test::Bencher;
 
 use imagequant::*;
@@ -19,7 +20,7 @@ fn histogram(b: &mut Bencher) {
 #[bench]
 fn remap_ord(b: &mut Bencher) {
     let img = lodepng::decode32_file("/Users/kornel/Desktop/canvas.png").unwrap();
-    let mut buf = vec![std::mem::MaybeUninit::uninit(); img.width * img.height];
+    let mut buf = vec![MaybeUninit::uninit(); img.width * img.height];
     let mut liq = Attributes::new();
     liq.set_speed(10).unwrap();
     let mut img = liq.new_image(img.buffer, img.width, img.height, 0.).unwrap();
@@ -40,7 +41,7 @@ fn kmeans(b: &mut Bencher) {
 #[bench]
 fn remap_floyd(b: &mut Bencher) {
     let img = lodepng::decode32_file("/Users/kornel/Desktop/canvas.png").unwrap();
-    let mut buf = vec![std::mem::MaybeUninit::uninit(); img.width * img.height];
+    let mut buf = vec![MaybeUninit::uninit(); img.width * img.height];
     let mut liq = Attributes::new();
     liq.set_speed(10).unwrap();
     let mut img = liq.new_image(img.buffer, img.width, img.height, 0.).unwrap();

imagequant-sys/src/ffi.rs

@@ -8,13 +8,13 @@
 #![allow(clippy::cast_possible_truncation)]
 #![allow(clippy::cast_possible_wrap)]
 
+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::mem::{ManuallyDrop, MaybeUninit};
-use std::os::raw::{c_char, c_int, c_uint, c_void};
-use std::ptr;
 
 pub use imagequant::Error as liq_error;
 
@@ -191,9 +191,9 @@ pub unsafe extern "C" fn liq_result_set_progress_callback(result: &mut liq_resul
 
 #[allow(clippy::cast_ptr_alignment)]
 unsafe fn attr_to_liq_attr_ptr(ptr: &Attributes) -> &liq_attr {
-    let liq_attr = std::ptr::NonNull::<liq_attr>::dangling();
-    let outer_addr = std::ptr::addr_of!(*liq_attr.as_ptr()) as isize;
-    let inner_addr = std::ptr::addr_of!((*liq_attr.as_ptr()).inner) as isize;
+    let liq_attr = ptr::NonNull::<liq_attr>::dangling();
+    let outer_addr = ptr::addr_of!(*liq_attr.as_ptr()) as isize;
+    let inner_addr = ptr::addr_of!((*liq_attr.as_ptr()).inner) as isize;
 
     &*(ptr as *const Attributes).cast::<u8>().offset(outer_addr - inner_addr).cast::<liq_attr>()
 }
@@ -304,7 +304,7 @@ pub unsafe extern "C" fn liq_write_remapped_image(result: &mut liq_result, input
 
     let required_size = (input_image.width()) * (input_image.height());
     if buffer_size < required_size { return Error::BufferTooSmall; }
-    let buffer_bytes = std::slice::from_raw_parts_mut(buffer_bytes, required_size);
+    let buffer_bytes = slice::from_raw_parts_mut(buffer_bytes, required_size);
     liq_write_remapped_image_impl(result, input_image, buffer_bytes).err().unwrap_or(LIQ_OK)
 }
 
@@ -317,7 +317,7 @@ pub unsafe extern "C" fn liq_write_remapped_image_rows(result: &mut liq_result,
     let result = &mut result.inner;
 
     if liq_received_invalid_pointer(row_pointers.cast()) { return Error::InvalidPointer; }
-    let rows = std::slice::from_raw_parts_mut(row_pointers, input_image.height());
+    let rows = slice::from_raw_parts_mut(row_pointers, input_image.height());
 
     liq_write_remapped_image_rows_impl(result, input_image, rows).err().unwrap_or(LIQ_OK)
 }
@@ -378,7 +378,7 @@ pub unsafe extern "C" fn liq_image_set_importance_map(img: &mut liq_image, impor
         return Error::BufferTooSmall;
     }
 
-    let importance_map_slice = std::slice::from_raw_parts(importance_map, required_size);
+    let importance_map_slice = slice::from_raw_parts(importance_map, required_size);
     if ownership == liq_ownership::LIQ_COPY_PIXELS {
         img.set_importance_map(importance_map_slice).err().unwrap_or(LIQ_OK)
     } else if ownership == liq_ownership::LIQ_OWN_PIXELS {
@@ -430,7 +430,7 @@ pub extern "C" fn liq_attr_create_with_allocator(_unused: *mut c_void, free: uns
         inner: Attributes::new(),
         c_api_free: free,
     });
-    debug_assert_eq!(std::ptr::addr_of!(*attr), unsafe { attr_to_liq_attr_ptr(&attr.inner) } as *const liq_attr);
+    debug_assert_eq!(ptr::addr_of!(*attr), unsafe { attr_to_liq_attr_ptr(&attr.inner) } as *const liq_attr);
     Some(attr)
 }
 
@@ -561,7 +561,7 @@ pub unsafe extern "C" fn liq_result_from_palette(
     }
 
     let attr = &attr.inner;
-    let palette = std::slice::from_raw_parts(palette, palette_size);
+    let palette = slice::from_raw_parts(palette, palette_size);
 
     let res = QuantizationResult::from_palette(attr, palette, gamma).map(|inner| liq_result {
         magic_header: LIQ_RESULT_MAGIC,
@@ -585,9 +585,9 @@ pub(crate) fn check_image_size(attr: &liq_attr, width: u32, height: u32) -> bool
         return false;
     }
 
-    if width as usize > c_int::MAX as usize / std::mem::size_of::<liq_color>() / height as usize ||
-       width as usize > c_int::MAX as usize / 16 / std::mem::size_of::<f32>() ||
-       height as usize > c_int::MAX as usize / std::mem::size_of::<usize>()
+    if width as usize > c_int::MAX as usize / mem::size_of::<liq_color>() / height as usize ||
+       width as usize > c_int::MAX as usize / 16 / mem::size_of::<f32>() ||
+       height as usize > c_int::MAX as usize / mem::size_of::<usize>()
     {
         return false;
     }
@@ -612,7 +612,7 @@ pub unsafe extern "C" fn liq_image_create_custom(attr: &liq_attr, row_callback:
 pub unsafe extern "C" fn liq_image_create_rgba_rows<'rows>(attr: &liq_attr, rows: *const *const RGBA, width: c_uint, height: c_uint, gamma: f64) -> Option<Box<liq_image<'rows>>> {
     if !check_image_size(attr, width, height) { return None; }
     if rows.is_null() { return None; }
-    let rows = std::slice::from_raw_parts(rows, height as _);
+    let rows = slice::from_raw_parts(rows, height as _);
     liq_image_create_rgba_rows_impl(&attr.inner, rows, width as _,  height as _, gamma)
         .map(move |inner| Box::new(liq_image {
             magic_header: LIQ_IMAGE_MAGIC,
@@ -651,7 +651,7 @@ pub unsafe extern "C" fn liq_histogram_add_colors(input_hist: &mut liq_histogram
 
     if liq_received_invalid_pointer(entries.cast()) { return Error::InvalidPointer; }
 
-    let entries = std::slice::from_raw_parts(entries, num_entries);
+    let entries = slice::from_raw_parts(entries, num_entries);
 
     input_hist.add_colors(entries, gamma).err().unwrap_or(LIQ_OK)
 }
@@ -678,7 +678,6 @@ pub unsafe extern "Rust" fn liq_executing_user_callback(callback: liq_image_get_
 
 #[test]
 fn links_and_runs() {
-    use std::ptr;
     unsafe {
         assert!(liq_version() >= 40000);
         let attr = liq_attr_create().unwrap();
@@ -701,7 +700,6 @@ fn links_and_runs() {
 #[test]
 #[allow(deprecated)]
 fn link_every_symbol() {
-    use std::os::raw::c_void;
 
     let x = liq_attr_create as *const c_void as usize
         + liq_attr_create_with_allocator as *const c_void as usize
@@ -757,8 +755,6 @@ fn link_every_symbol() {
 
 #[test]
 fn c_callback_test_c() {
-    use std::mem::MaybeUninit;
-
     let mut called = 0;
     let mut res = unsafe {
         let mut a = liq_attr_create().unwrap();
@@ -772,17 +768,15 @@ fn c_callback_test_c() {
             let user_data = user_data.0.cast::<i32>();
             *user_data += 1;
         }
-        let mut img = liq_image_create_custom(&a, get_row, AnySyncSendPtr(std::ptr::addr_of_mut!(called).cast::<c_void>()), 123, 5, 0.).unwrap();
+        let mut img = liq_image_create_custom(&a, get_row, AnySyncSendPtr(ptr::addr_of_mut!(called).cast::<c_void>()), 123, 5, 0.).unwrap();
         liq_quantize_image(&mut a, &mut img).unwrap()
     };
     assert!(called > 5 && called < 50);
     let pal = liq_get_palette(&mut res).unwrap();
     assert_eq!(123, pal.count);
 }
 
-
-
 #[test]
 fn ownership_bitflags() {
-    assert_eq!(4+16, (liq_ownership::LIQ_OWN_ROWS | liq_ownership::LIQ_COPY_PIXELS).bits());
+    assert_eq!(4 + 16, (liq_ownership::LIQ_OWN_ROWS | liq_ownership::LIQ_COPY_PIXELS).bits());
 }

src/capi.rs

@@ -7,7 +7,8 @@ use crate::pal::Palette;
 use crate::rows::RowCallback;
 use crate::seacow::{Pointer, RowBitmapMut, SeaCow};
 use crate::{Attributes, Error, Image, QuantizationResult, RGBA};
-use std::mem::MaybeUninit;
+use core::ffi::c_void;
+use core::mem::{self, MaybeUninit};
 
 pub const LIQ_VERSION: u32 = 40202;
 
@@ -28,7 +29,7 @@ pub unsafe fn liq_image_create_rgba_rows_impl<'rows>(attr: &Attributes, rows: &'
 
 #[must_use]
 pub unsafe fn liq_image_create_rgba_bitmap_impl<'rows>(attr: &Attributes, rows: Box<[*const RGBA]>, width: u32, height: u32, gamma: f64) -> Option<crate::image::Image<'rows>> {
-    let rows = SeaCow::boxed(std::mem::transmute::<Box<[*const RGBA]>, Box<[Pointer<RGBA>]>>(rows));
+    let rows = SeaCow::boxed(mem::transmute::<Box<[*const RGBA]>, Box<[Pointer<RGBA>]>>(rows));
     let rows_slice = rows.as_slice();
     if rows_slice.iter().any(|r| r.0.is_null()) {
         return None;
@@ -52,6 +53,6 @@ pub unsafe fn liq_write_remapped_image_rows_impl(result: &mut QuantizationResult
 }
 
 /// Not recommended
-pub unsafe fn liq_image_set_memory_ownership_impl(image: &mut Image<'_>, own_rows: bool, own_pixels: bool, free_fn: unsafe extern "C" fn(*mut std::os::raw::c_void)) -> Result<(), Error> {
+pub unsafe fn liq_image_set_memory_ownership_impl(image: &mut Image<'_>, own_rows: bool, own_pixels: bool, free_fn: unsafe extern "C" fn(*mut c_void)) -> Result<(), Error> {
     image.px.set_memory_ownership(own_rows, own_pixels, free_fn)
 }

src/error.rs

@@ -1,5 +1,5 @@
+use core::{error, fmt};
 use std::collections::TryReserveError;
-use std::fmt;
 pub use Error::*;
 
 /// Error codes
@@ -29,7 +29,7 @@ pub enum Error {
     Unsupported,
 }
 
-impl std::error::Error for Error {}
+impl error::Error for Error {}
 
 impl fmt::Display for Error {
     #[cold]

src/hist.rs

@@ -5,8 +5,8 @@ use crate::quant::QuantizationResult;
 use crate::rows::{temp_buf, DynamicRows};
 use crate::Attributes;
 use std::collections::{HashMap, HashSet};
-use std::fmt;
-use std::hash::Hash;
+use core::{fmt, hash, mem};
+use core::hash::Hash;
 
 /// Number of pixels in a given color for [`Histogram::add_colors()`]
 ///
@@ -57,7 +57,7 @@ impl HistItem {
     // The u32 has been initialized when constructing the object, and u8/u16 is smaller than that
     #[inline(always)]
     pub fn likely_palette_index(&self) -> PalIndex {
-        assert!(std::mem::size_of::<PalIndex>() <= std::mem::size_of::<u32>());
+        assert!(mem::size_of::<PalIndex>() <= mem::size_of::<u32>());
         unsafe { self.tmp.likely_palette_index }
     }
 }
@@ -241,7 +241,7 @@ impl Histogram {
         let new_posterize_mask = self.posterize_mask();
 
         let new_size = (self.hashmap.len() / 3).max(self.hashmap.capacity() / 5);
-        let old_hashmap = std::mem::replace(&mut self.hashmap, HashMap::with_capacity_and_hasher(new_size, U32Hasher(0)));
+        let old_hashmap = mem::replace(&mut self.hashmap, HashMap::with_capacity_and_hasher(new_size, U32Hasher(0)));
         self.hashmap.extend(old_hashmap.into_iter().map(move |(k, v)| {
             (k & new_posterize_mask, v)
         }));
@@ -381,7 +381,7 @@ pub(crate) struct Cluster {
 }
 
 // Simple deterministic hasher for the color hashmap
-impl std::hash::BuildHasher for U32Hasher {
+impl hash::BuildHasher for U32Hasher {
     type Hasher = Self;
 
     #[inline(always)]
@@ -391,7 +391,7 @@ impl std::hash::BuildHasher for U32Hasher {
 }
 
 pub(crate) struct U32Hasher(pub u32);
-impl std::hash::Hasher for U32Hasher {
+impl hash::Hasher for U32Hasher {
     // magic constant from fxhash. For a single 32-bit key that's all it needs!
     #[inline(always)]
     fn finish(&self) -> u64 { u64::from(self.0).wrapping_mul(0x517cc1b727220a95) }
@@ -422,7 +422,7 @@ pub(crate) struct HashColor {
 #[allow(clippy::derived_hash_with_manual_eq)]
 impl Hash for HashColor {
     #[inline]
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+    fn hash<H: hash::Hasher>(&self, state: &mut H) {
         let s: &[u8] = self.rgba.as_ref();
         u32::from_ne_bytes(s.try_into().unwrap()).hash(state);
     }

src/image.rs

@@ -7,7 +7,7 @@ use crate::rows::{DynamicRows, PixelsSource};
 use crate::seacow::{RowBitmap, SeaCow};
 use crate::{PushInCapacity, LIQ_HIGH_MEMORY_LIMIT};
 use rgb::prelude::*;
-use std::mem::MaybeUninit;
+use core::mem::{self, MaybeUninit};
 
 /// Describes image dimensions and pixels for the library
 ///
@@ -105,7 +105,7 @@ impl<'pixels> Image<'pixels> {
         };
         // if image is huge or converted pixels are not likely to be reused then don't cache converted pixels
         let low_memory_hint = !attr.use_contrast_maps && attr.use_dither_map == DitherMapMode::None;
-        let limit = if low_memory_hint { LIQ_HIGH_MEMORY_LIMIT / 8 } else { LIQ_HIGH_MEMORY_LIMIT } / std::mem::size_of::<f_pixel>();
+        let limit = if low_memory_hint { LIQ_HIGH_MEMORY_LIMIT / 8 } else { LIQ_HIGH_MEMORY_LIMIT } / mem::size_of::<f_pixel>();
         if (img.width()) * (img.height()) > limit {
             attr.verbose_print("  conserving memory"); // for simplicity of this API there's no explicit pixels argument,
         }
@@ -117,7 +117,7 @@ impl<'pixels> Image<'pixels> {
             return false;
         }
         if width.max(height) as usize > i32::MAX as usize ||
-            width as usize > isize::MAX as usize / std::mem::size_of::<f_pixel>() / height as usize {
+            width as usize > isize::MAX as usize / mem::size_of::<f_pixel>() / height as usize {
             return false;
         }
         true

src/kmeans.rs

@@ -3,9 +3,9 @@ use crate::nearest::Nearest;
 use crate::pal::{f_pixel, PalF, PalIndex, PalPop};
 use crate::rayoff::*;
 use crate::{CacheLineAlign, Error};
+use core::cell::RefCell;
 use rgb::prelude::*;
 use rgb::Argb;
-use std::cell::RefCell;
 
 /// K-Means iteration: new palette color is computed from weighted average of colors that map best to that palette entry.
 // avoid false sharing

src/lib.rs

@@ -39,8 +39,8 @@ mod rayoff;
 #[cfg(feature = "threads")]
 mod rayoff {
     pub(crate) fn num_cpus() -> usize { std::thread::available_parallelism().map(|n| n.get()).unwrap_or(1) }
-    pub(crate) use rayon::prelude::{ParallelBridge, ParallelIterator, ParallelSliceMut};
     pub(crate) use rayon::in_place_scope as scope;
+    pub(crate) use rayon::prelude::{ParallelBridge, ParallelIterator, ParallelSliceMut};
     pub(crate) use thread_local::ThreadLocal;
 }
 
@@ -51,6 +51,8 @@ pub(crate) struct CacheLineAlign<T>(pub T);
 #[cfg(feature = "_internal_c_ffi")]
 pub mod capi;
 
+use core::cmp::Ordering;
+
 pub use attr::{Attributes, ControlFlow};
 pub use error::Error;
 pub use hist::{Histogram, HistogramEntry};
@@ -201,7 +203,7 @@ fn thread() {
 
 #[test]
 fn r_callback_test() {
-    use std::mem::MaybeUninit;
+    use core::mem::MaybeUninit;
     use std::sync::atomic::AtomicU16;
     use std::sync::atomic::Ordering::SeqCst;
     use std::sync::Arc;
@@ -231,14 +233,14 @@ fn r_callback_test() {
 
 #[test]
 fn sizes() {
-    use pal::PalF;
-    use pal::Palette;
-    assert!(std::mem::size_of::<PalF>() < crate::pal::MAX_COLORS*(8*4)+32, "{}", std::mem::size_of::<PalF>());
-    assert!(std::mem::size_of::<QuantizationResult>() < std::mem::size_of::<PalF>() + std::mem::size_of::<Palette>() + 100, "{}", std::mem::size_of::<QuantizationResult>());
-    assert!(std::mem::size_of::<Attributes>() < 200);
-    assert!(std::mem::size_of::<Image>() < 300);
-    assert!(std::mem::size_of::<Histogram>() < 200);
-    assert!(std::mem::size_of::<crate::hist::HistItem>() <= 32);
+    use core::mem::size_of;
+    use pal::{PalF, Palette};
+    assert!(size_of::<PalF>() < crate::pal::MAX_COLORS * (8 * 4) + 32, "{}", size_of::<PalF>());
+    assert!(size_of::<QuantizationResult>() < size_of::<PalF>() + size_of::<Palette>() + 100, "{}", size_of::<QuantizationResult>());
+    assert!(size_of::<Attributes>() < 200);
+    assert!(size_of::<Image>() < 300);
+    assert!(size_of::<Histogram>() < 200);
+    assert!(size_of::<crate::hist::HistItem>() <= 32);
 }
 
 #[doc(hidden)]
@@ -259,7 +261,7 @@ pub fn _unstable_internal_kmeans_bench() -> impl FnMut() {
     let lut = pal::gamma_lut(0.45455);
     let mut p = PalF::new();
     for i in 0..=255 {
-        p.push(pal::f_pixel::from_rgba(&lut, RGBA::new(i|7, i, i, 255)), PalPop::new(1.));
+        p.push(pal::f_pixel::from_rgba(&lut, RGBA::new(i | 7, i, i, 255)), PalPop::new(1.));
     }
 
     move || {
@@ -293,8 +295,8 @@ impl Eq for OrdFloat<f32> {
 
 impl Ord for OrdFloat<f32> {
     #[inline]
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        self.0.partial_cmp(&other.0).unwrap_or(std::cmp::Ordering::Equal)
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.0.partial_cmp(&other.0).unwrap_or(Ordering::Equal)
     }
 }
 
@@ -303,8 +305,8 @@ impl Eq for OrdFloat<f64> {
 
 impl Ord for OrdFloat<f64> {
     #[inline]
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        self.0.partial_cmp(&other.0).unwrap_or(std::cmp::Ordering::Equal)
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.0.partial_cmp(&other.0).unwrap_or(Ordering::Equal)
     }
 }