Update for latest RGB

Author: kornelski

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "imagequant"
-version = "4.3.1"
+version = "4.3.2"
 description = "Convert 24/32-bit images to 8-bit palette with alpha channel.\nFor lossy PNG compression and high-quality GIF images\nDual-licensed like pngquant. See https://pngquant.org for details."
 authors = ["Kornel Lesiński <[email protected]>"]
 license = "GPL-3.0-or-later"
@@ -32,13 +32,13 @@ doctest = false
 
 [dependencies]
 arrayvec = "0.7.4"
-rgb = { version = "0.8.37", features = ["argb"] }
+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 }
 once_cell = "1.19.0"
 
 [dev-dependencies]
-lodepng = "3.10.0"
+lodepng = "3.10.4"
 
 [workspace]
 members = ["imagequant-sys", "imagequant-sys/c_test"]

src/capi.rs

@@ -24,7 +24,7 @@ pub fn liq_get_palette_impl(r: &mut QuantizationResult) -> &Palette {
 
 #[must_use]
 pub unsafe fn liq_image_create_rgba_rows_impl<'rows>(attr: &Attributes, rows: &'rows [*const RGBA], width: u32, height: u32, gamma: f64) -> Option<crate::image::Image<'rows>> {
-    let rows = SeaCow::borrowed(&*(rows as *const [*const rgb::RGBA<u8>] as *const [Pointer<rgb::RGBA<u8>>]));
+    let rows = SeaCow::borrowed(&*(rows as *const [*const rgb::Rgba<u8>] as *const [Pointer<rgb::Rgba<u8>>]));
     let rows_slice = rows.as_slice();
     if rows_slice.iter().any(|r| r.0.is_null()) {
         return None;

src/hist.rs

@@ -8,7 +8,6 @@ use crate::quant::QuantizationResult;
 use crate::rows::temp_buf;
 use crate::rows::DynamicRows;
 use crate::Attributes;
-use rgb::ComponentSlice;
 use std::collections::{HashMap, HashSet};
 use std::fmt;
 use std::hash::Hash;
@@ -424,7 +423,8 @@ pub(crate) struct HashColor { pub rgba: RGBA, pub index: PalIndex }
 impl Hash for HashColor {
     #[inline]
     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        u32::from_ne_bytes(self.rgba.as_slice().try_into().unwrap()).hash(state);
+        let s: &[u8] = self.rgba.as_ref();
+        u32::from_ne_bytes(s.try_into().unwrap()).hash(state);
     }
 }
 

src/image.rs

@@ -8,7 +8,7 @@ use crate::seacow::RowBitmap;
 use crate::seacow::SeaCow;
 use crate::PushInCapacity;
 use crate::LIQ_HIGH_MEMORY_LIMIT;
-use rgb::ComponentMap;
+use rgb::prelude::*;
 use std::mem::MaybeUninit;
 
 /// Describes image dimensions and pixels for the library

src/kmeans.rs

@@ -4,8 +4,8 @@ use crate::nearest::Nearest;
 use crate::pal::{f_pixel, PalF, PalIndex, PalPop};
 use crate::rayoff::*;
 use crate::Error;
-use rgb::alt::ARGB;
-use rgb::ComponentMap;
+use rgb::Argb;
+use rgb::prelude::*;
 use std::cell::RefCell;
 
 /// K-Means iteration: new palette color is computed from weighted average of colors that map best to that palette entry.
@@ -17,7 +17,7 @@ pub(crate) struct Kmeans {
 
 #[derive(Copy, Clone, Default)]
 struct ColorAvg {
-    pub sum: ARGB<f64>,
+    pub sum: Argb<f64>,
     pub total: f64,
 }
 

src/mediancut.rs

@@ -4,8 +4,7 @@ use crate::pal::{PalLen, ARGBF};
 use crate::quant::quality_to_mse;
 use crate::PushInCapacity;
 use crate::{Error, OrdFloat};
-use rgb::ComponentMap;
-use rgb::ComponentSlice;
+use rgb::prelude::*;
 use std::cmp::Reverse;
 
 struct MedianCutter<'hist> {
@@ -98,7 +97,7 @@ impl<'hist> MBox<'hist> {
         }
 
         // Sort dimensions by their variance, and then sort colors first by dimension with the highest variance
-        let vars = self.variance.as_slice();
+        let vars: [f32; 4] = rgb::bytemuck::cast(self.variance);
         let mut channels = [
             ChanVariance { chan: 0, variance: vars[0] },
             ChanVariance { chan: 1, variance: vars[1] },
@@ -108,7 +107,7 @@ impl<'hist> MBox<'hist> {
         channels.sort_by_key(|a| Reverse(OrdFloat::new(a.variance)));
 
         for a in self.colors.iter_mut() {
-            let chans = a.color.as_slice();
+            let chans: [f32; 4] = rgb::bytemuck::cast(a.color.0);
             // Only the first channel really matters. But other channels are included, because when trying median cut
             // many times with different histogram weights, I don't want sort randomness to influence the outcome.
             a.tmp.mc_sort_value = (((chans[channels[0].chan] * 65535.) as u32) << 16)

src/pal.rs

@@ -1,13 +1,13 @@
 use crate::OrdFloat;
 use arrayvec::ArrayVec;
-use rgb::ComponentMap;
+use rgb::prelude::*;
 use std::ops::{Deref, DerefMut};
 
 /// 8-bit RGBA in sRGB. This is the only color format *publicly* used by the library.
-pub type RGBA = rgb::RGBA<u8>;
+pub type RGBA = rgb::Rgba<u8>;
 
 #[allow(clippy::upper_case_acronyms)]
-pub type ARGBF = rgb::alt::ARGB<f32>;
+pub type ARGBF = rgb::Argb<f32>;
 
 pub const INTERNAL_GAMMA: f64 = 0.57;
 pub const LIQ_WEIGHT_A: f32 = 0.625;