fmt

kornelski · kornelski · commit 0a808e0eee85 · 2024-08-04T20:40:38.000+01:00
diff --git a/imagequant-sys/build.rs b/imagequant-sys/build.rs
@@ -1,4 +1,3 @@
-
 fn main() {
     println!("cargo:include={}", std::env::var("CARGO_MANIFEST_DIR").unwrap());
 }
diff --git a/imagequant-sys/src/ffi.rs b/imagequant-sys/src/ffi.rs
@@ -12,10 +12,8 @@ use imagequant::capi::*;
 use imagequant::Error::LIQ_OK;
 use imagequant::*;
 use std::ffi::CString;
-use std::mem::ManuallyDrop;
-use std::mem::MaybeUninit;
-use std::os::raw::c_char;
-use std::os::raw::{c_int, c_uint, c_void};
+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;
diff --git a/src/attr.rs b/src/attr.rs
@@ -1,9 +1,7 @@
 use crate::error::Error;
 use crate::hist::Histogram;
 use crate::image::Image;
-use crate::pal::PalLen;
-use crate::pal::MAX_COLORS;
-use crate::pal::RGBA;
+use crate::pal::{PalLen, MAX_COLORS, RGBA};
 use crate::quant::{mse_to_quality, quality_to_mse, QuantizationResult};
 use crate::remap::DitherMapMode;
 use std::sync::Arc;
diff --git a/src/capi.rs b/src/capi.rs
@@ -4,15 +4,13 @@
 #![allow(clippy::missing_safety_doc)]
 
 use crate::rows::RowCallback;
-use crate::seacow::Pointer;
-use crate::seacow::RowBitmapMut;
-use crate::seacow::SeaCow;
 use crate::Attributes;
 use crate::Error;
 use crate::Image;
 use crate::pal::Palette;
 use crate::QuantizationResult;
 use crate::RGBA;
+use crate::seacow::{Pointer, RowBitmapMut, SeaCow};
 use std::mem::MaybeUninit;
 
 pub const LIQ_VERSION: u32 = 40202;
diff --git a/src/hist.rs b/src/hist.rs
@@ -1,12 +1,8 @@
 use crate::error::*;
 use crate::image::Image;
-use crate::pal::PalIndex;
-use crate::pal::ARGBF;
-use crate::pal::MAX_COLORS;
-use crate::pal::{f_pixel, gamma_lut, RGBA};
+use crate::pal::{f_pixel, gamma_lut, PalIndex, ARGBF, MAX_COLORS, RGBA};
 use crate::quant::QuantizationResult;
-use crate::rows::temp_buf;
-use crate::rows::DynamicRows;
+use crate::rows::{temp_buf, DynamicRows};
 use crate::Attributes;
 use std::collections::{HashMap, HashSet};
 use std::fmt;
@@ -387,6 +383,7 @@ pub(crate) struct Cluster {
 // Simple deterministic hasher for the color hashmap
 impl std::hash::BuildHasher for U32Hasher {
     type Hasher = Self;
+
     #[inline(always)]
     fn build_hasher(&self) -> Self {
         Self(0)
diff --git a/src/image.rs b/src/image.rs
@@ -4,10 +4,9 @@ use crate::error::*;
 use crate::pal::{f_pixel, PalF, PalIndexRemap, MAX_COLORS, MIN_OPAQUE_A, RGBA};
 use crate::remap::DitherMapMode;
 use crate::rows::{DynamicRows, PixelsSource};
-use crate::seacow::RowBitmap;
-use crate::seacow::SeaCow;
 use crate::PushInCapacity;
 use crate::LIQ_HIGH_MEMORY_LIMIT;
+use crate::seacow::{RowBitmap, SeaCow};
 use rgb::prelude::*;
 use std::mem::MaybeUninit;
 
@@ -336,7 +335,7 @@ impl<'pixels> Image<'pixels> {
             Ok(p) => p,
             Err(e) => {
                 attr.verbose_print(format!("Buffer length is {} bytes, which is not enough for {}×{}×4 RGBA bytes", pixels_len*4, stride, height));
-                return Err(e)
+                return Err(e);
             },
         };
         Image::new_internal(attr, pixels_rows, width, height, gamma)
diff --git a/src/lib.rs b/src/lib.rs
@@ -51,11 +51,9 @@ pub(crate) struct CacheLineAlign<T>(pub T);
 #[cfg(feature = "_internal_c_ffi")]
 pub mod capi;
 
-pub use attr::Attributes;
-pub use attr::ControlFlow;
+pub use attr::{Attributes, ControlFlow};
 pub use error::Error;
-pub use hist::Histogram;
-pub use hist::HistogramEntry;
+pub use hist::{Histogram, HistogramEntry};
 pub use image::Image;
 #[doc(hidden)]
 pub use pal::Palette;
@@ -88,8 +86,7 @@ fn copy_img() {
 fn takes_rgba() {
     let liq = Attributes::new();
 
-    let img = vec![RGBA {r:0, g:0, b:0, a:0}; 8];
-
+    let img = vec![RGBA { r: 0, g: 0, b: 0, a: 0 }; 8];
 
     liq.new_image_borrowed(&img, 1, 1, 0.0).unwrap();
     liq.new_image_borrowed(&img, 4, 2, 0.0).unwrap();
@@ -103,11 +100,11 @@ fn histogram() {
     let attr = Attributes::new();
     let mut hist = Histogram::new(&attr);
 
-    let bitmap1 = [RGBA {r:0, g:0, b:0, a:0}; 1];
+    let bitmap1 = [RGBA { r: 0, g: 0, b: 0, a: 0 }; 1];
     let mut image1 = attr.new_image(&bitmap1[..], 1, 1, 0.0).unwrap();
     hist.add_image(&attr, &mut image1).unwrap();
 
-    let bitmap2 = [RGBA {r:255, g:255, b:255, a:255}; 1];
+    let bitmap2 = [RGBA { r: 255, g: 255, b: 255, a: 255 }; 1];
     let mut image2 = attr.new_image(&bitmap2[..], 1, 1, 0.0).unwrap();
     hist.add_image(&attr, &mut image2).unwrap();
 
diff --git a/src/mediancut.rs b/src/mediancut.rs
@@ -1,6 +1,5 @@
 use crate::hist::{HistItem, HistogramInternal};
-use crate::pal::{f_pixel, PalF, PalPop};
-use crate::pal::{PalLen, ARGBF};
+use crate::pal::{f_pixel, PalF, PalLen, PalPop, ARGBF};
 use crate::quant::quality_to_mse;
 use crate::PushInCapacity;
 use crate::{Error, OrdFloat};
diff --git a/src/nearest.rs b/src/nearest.rs
@@ -1,6 +1,4 @@
-use crate::pal::PalIndex;
-use crate::pal::MAX_COLORS;
-use crate::pal::{f_pixel, PalF};
+use crate::pal::{f_pixel, PalF, PalIndex, MAX_COLORS};
 use crate::{Error, OrdFloat};
 
 impl<'pal> Nearest<'pal> {
diff --git a/src/pal.rs b/src/pal.rs
@@ -78,7 +78,7 @@ impl f_pixel {
             vst1q_f32(max_gb.as_mut_ptr(), vpaddq_f32(max, max));
 
             // add rgb, not a
-            
+
             max_r[1] + max_gb[1]
         }
     }
diff --git a/src/quant.rs b/src/quant.rs
@@ -316,7 +316,7 @@ impl Clone for QuantizationResult {
 fn sort_palette(attr: &Attributes, palette: &mut PalF) {
     let last_index_transparent = attr.last_index_transparent;
 
-    let mut tmp: ArrayVec<_, {MAX_COLORS}> = palette.iter_mut().map(|(c,p)| (*c, *p)).collect();
+    let mut tmp: ArrayVec<_, { MAX_COLORS }> = palette.iter_mut().map(|(c, p)| (*c, *p)).collect();
     tmp.sort_by_key(|(color, pop)| {
         let is_transparent = color.a <= MAX_TRANSP_A;
         (is_transparent == last_index_transparent, Reverse(OrdFloat::new(pop.popularity())))
diff --git a/src/rayoff.rs b/src/rayoff.rs
@@ -21,9 +21,8 @@ impl<T> ThreadLocal<T> {
 }
 
 impl<T> IntoIterator for ThreadLocal<T> {
-    type Item = T;
-
     type IntoIter = std::option::IntoIter<T>;
+    type Item = T;
 
     #[inline(always)]
     fn into_iter(mut self) -> Self::IntoIter {
diff --git a/src/remap.rs b/src/remap.rs
@@ -1,4 +1,3 @@
-use crate::CacheLineAlign;
 use crate::error::Error;
 use crate::image::Image;
 use crate::kmeans::Kmeans;
@@ -8,6 +7,7 @@ use crate::quant::QuantizationResult;
 use crate::rayoff::*;
 use crate::rows::{temp_buf, DynamicRows};
 use crate::seacow::{RowBitmap, RowBitmapMut};
+use crate::CacheLineAlign;
 use std::cell::RefCell;
 use std::mem::MaybeUninit;
 
@@ -268,7 +268,7 @@ fn dither_row(row_pixels: &[f_pixel], output_pixels_row: &mut [MaybeUninit<PalIn
             last_match
         };
         let (matched, dither_diff) = n.search(&spx, guessed_match as _);
-        let mut matched = matched  as PalIndexRemap;
+        let mut matched = matched as PalIndexRemap;
         last_match = matched as PalIndexRemap;
         let mut output_px = palette[last_match as usize];
         if let Some(bg_pixel) = bg_pixels.get(col) {
diff --git a/src/rows.rs b/src/rows.rs
@@ -1,7 +1,6 @@
 use crate::error::Error;
 use crate::pal::{f_pixel, gamma_lut, RGBA};
-use crate::seacow::Pointer;
-use crate::seacow::SeaCow;
+use crate::seacow::{Pointer, SeaCow};
 use crate::LIQ_HIGH_MEMORY_LIMIT;
 use std::mem::MaybeUninit;
 
@@ -52,11 +51,9 @@ impl Clone for DynamicRows<'_, '_> {
             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::Pixels { rows, pixels } => PixelsSource::Pixels {
+                    rows: rows.clone(),
+                    pixels: pixels.clone(),
                 },
                 PixelsSource::Callback(_) => {
                     let area = self.width as usize * self.height as usize;
@@ -118,7 +115,7 @@ impl<'a, 'pixels, 'rows> DynamicRowsIter<'a, 'pixels, 'rows> {
     }
 }
 
-impl<'pixels,'rows> DynamicRows<'pixels,'rows> {
+impl<'pixels, 'rows> DynamicRows<'pixels, 'rows> {
     #[inline]
     pub(crate) fn new(width: u32, height: u32, pixels: PixelsSource<'pixels, 'rows>, gamma: f64) -> Self {
         debug_assert!(gamma > 0.);
@@ -134,7 +131,7 @@ impl<'pixels,'rows> DynamicRows<'pixels,'rows> {
                 cb(temp_row, row);
                 // cb needs to be marked as unsafe, since it's responsible for initialization :(
                 unsafe { slice_assume_init_mut(temp_row) }
-            }
+            },
         }
     }
 
diff --git a/src/seacow.rs b/src/seacow.rs
@@ -29,19 +29,15 @@ impl<T> SeaCow<'static, T> {
     #[inline]
     #[must_use]
     pub fn boxed(data: Box<[T]>) -> Self {
-        Self {
-            inner: SeaCowInner::Boxed(data),
-        }
+        Self { inner: SeaCowInner::Boxed(data) }
     }
 }
 
 impl<'a, T> SeaCow<'a, T> {
     #[inline]
     #[must_use]
     pub fn borrowed(data: &'a [T]) -> Self {
-        Self {
-            inner: SeaCowInner::Borrowed(data),
-        }
+        Self { inner: SeaCowInner::Borrowed(data) }
     }
 
     /// The pointer must be `malloc`-allocated
@@ -187,7 +183,7 @@ impl<'a, T: Sync + Send + Copy + 'static> RowBitmapMut<'a, T> {
         })
     }
 
-    pub(crate) fn chunks(&mut self, chunk_size: usize) -> impl Iterator<Item=RowBitmapMut<'_, T>> {
+    pub(crate) fn chunks(&mut self, chunk_size: usize) -> impl Iterator<Item = RowBitmapMut<'_, T>> {
         self.rows.borrow_mut().chunks_mut(chunk_size).map(|chunk| RowBitmapMut {
             width: self.width,
             rows: MutCow::Borrowed(chunk),

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,3 @@`
`1`		`-`
`2`	`1`	`fn main() {`
`3`	`2`	`println!("cargo:include={}", std::env::var("CARGO_MANIFEST_DIR").unwrap());`
`4`	`3`	`}`
Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,7 @@ impl f_pixel {`
`78`	`78`	`vst1q_f32(max_gb.as_mut_ptr(), vpaddq_f32(max, max));`
`79`	`79`
`80`	`80`	`// add rgb, not a`
`81`		`-`
	`81`	`+`
`82`	`82`	`max_r[1] + max_gb[1]`
`83`	`83`	`}`
`84`	`84`	`}`