Image clone

Author: kornelski

src/image.rs

@@ -16,6 +16,7 @@ use std::mem::MaybeUninit;
 /// Create one using [`Attributes::new_image()`].
 ///
 /// All images are internally in the RGBA format.
+#[derive(Clone)]
 pub struct Image<'pixels> {
     pub(crate) px: DynamicRows<'pixels, 'pixels>,
     pub(crate) importance_map: Option<Box<[u8]>>,

src/pal.rs

@@ -345,6 +345,7 @@ pub fn gamma_lut(gamma: f64) -> [f32; 256] {
 /// Not used in the Rust API.
 /// RGBA colors obtained from [`QuantizationResult`](crate::QuantizationResult)
 #[repr(C)]
+#[derive(Clone)]
 pub struct Palette {
     /// Number of used colors in the `entries`
     pub count: std::os::raw::c_uint,

src/quant.rs

@@ -295,6 +295,24 @@ impl QuantizationResult {
     }
 }
 
+impl Clone for QuantizationResult {
+    /// It will be without a progress callback
+    fn clone(&self) -> Self {
+        Self {
+            remapped: self.remapped.clone(),
+            palette: self.palette.clone(),
+            progress_callback: None,
+            int_palette: self.int_palette.clone(),
+            dither_level: self.dither_level,
+            gamma: self.gamma,
+            palette_error: self.palette_error,
+            min_posterization_output: self.min_posterization_output,
+            use_dither_map: self.use_dither_map,
+            single_threaded_dithering: self.single_threaded_dithering,
+        }
+    }
+}
+
 fn sort_palette(attr: &Attributes, palette: &mut PalF) {
     let last_index_transparent = attr.last_index_transparent;
 

src/remap.rs

@@ -18,6 +18,7 @@ pub enum DitherMapMode {
     Always = 2,
 }
 
+#[derive(Clone)]
 pub(crate) struct Remapped {
     pub(crate) int_palette: Palette,
     pub(crate) palette_error: Option<f64>,

src/rows.rs

@@ -45,6 +45,38 @@ pub(crate) struct DynamicRows<'pixels, 'rows> {
     pub(crate) gamma: f64,
 }
 
+impl Clone for DynamicRows<'_, '_> {
+    fn clone(&self) -> Self {
+        Self {
+            width: self.width,
+            height: self.height,
+            f_pixels: self.f_pixels.clone(),
+            pixels: match &self.pixels {
+                PixelsSource::Pixels { rows, pixels } => {
+                    PixelsSource::Pixels {
+                        rows: rows.clone(),
+                        pixels: pixels.clone(),
+                    }
+                },
+                PixelsSource::Callback(_) => {
+                    let area = self.width as usize * self.height as usize;
+                    let mut out = Vec::with_capacity(area);
+                    let out_rows = out.spare_capacity_mut()[..area].chunks_exact_mut(self.width as usize);
+                    for (i, row) in out_rows.enumerate() {
+                        self.row_rgba(row, i);
+                    }
+                    unsafe {
+                        out.set_len(area);
+                    }
+                    let pixels = SeaCow::boxed(out.into_boxed_slice());
+                    PixelsSource::for_pixels(pixels, self.width, self.height, self.width).unwrap()
+                }
+            },
+            gamma: self.gamma,
+        }
+    }
+}
+
 pub(crate) struct DynamicRowsIter<'parent, 'pixels, 'rows> {
     px: &'parent DynamicRows<'pixels, 'rows>,
     temp_f_row: Option<Box<[MaybeUninit<f_pixel>]>>,

src/seacow.rs

@@ -2,6 +2,7 @@
 use std::os::raw::c_void;
 use std::mem::MaybeUninit;
 
+#[derive(Clone)]
 pub struct SeaCow<'a, T> {
     inner: SeaCowInner<'a, T>,
 }
@@ -65,6 +66,22 @@ impl<'a, T> SeaCow<'a, T> {
     }
 }
 
+impl<T: Clone> Clone for SeaCowInner<'_, T> {
+    #[inline(never)]
+    fn clone(&self) -> Self {
+        let slice = match self {
+            Self::Borrowed(data) => return Self::Borrowed(data),
+            #[cfg(feature = "_internal_c_ffi")]
+            Self::Owned { ptr, len, free_fn: _ } => unsafe { std::slice::from_raw_parts(*ptr, *len) },
+            Self::Boxed(data) => &**data,
+        };
+        let mut v = Vec::new();
+        v.try_reserve_exact(slice.len()).unwrap();
+        v.extend_from_slice(slice);
+        Self::Boxed(v.into_boxed_slice())
+    }
+}
+
 enum SeaCowInner<'a, T> {
     #[cfg(feature = "_internal_c_ffi")]
     Owned { ptr: *mut T, len: usize, free_fn: unsafe extern fn(*mut c_void) },