├── imagequant-sys ├── COPYRIGHT ├── .gitignore ├── org │ └── pngquant │ │ ├── PngQuantException.java │ │ ├── LiqObject.java │ │ ├── Image.java │ │ ├── Result.java │ │ ├── PngQuant.java │ │ └── PngQuant.c ├── c_test │ ├── build.rs │ ├── src │ │ └── lib.rs │ ├── Cargo.toml │ └── test.c ├── build.rs ├── imagequant.pc.in ├── Cargo.toml ├── Makefile ├── pom.xml ├── example.c ├── libimagequant.cs ├── libimagequant.h └── imagequant.xcodeproj │ └── project.pbxproj ├── .gitignore ├── .github └── workflows │ └── ci.yml ├── examples └── basic.rs ├── CONTRIBUTING.md ├── Cargo.toml ├── src ├── error.rs ├── rayoff.rs ├── blur.rs ├── capi.rs ├── kmeans.rs ├── seacow.rs ├── nearest.rs ├── rows.rs ├── mediancut.rs ├── lib.rs ├── attr.rs ├── image.rs ├── remap.rs └── hist.rs ├── benches └── bench.rs ├── CODE_OF_CONDUCT.md ├── CHANGELOG └── README.md /imagequant-sys/COPYRIGHT: -------------------------------------------------------------------------------- 1 | ../COPYRIGHT -------------------------------------------------------------------------------- /imagequant-sys/.gitignore: -------------------------------------------------------------------------------- 1 | usr/ 2 | target/ 3 | -------------------------------------------------------------------------------- /imagequant-sys/org/pngquant/PngQuantException.java: -------------------------------------------------------------------------------- 1 | package org.pngquant; 2 | 3 | public class PngQuantException extends Exception { 4 | } 5 | -------------------------------------------------------------------------------- /imagequant-sys/c_test/build.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | cc::Build::new() 3 | .include("..") 4 | .file("test.c") 5 | .compile("imagequanttestbin"); 6 | } 7 | -------------------------------------------------------------------------------- /imagequant-sys/c_test/src/lib.rs: -------------------------------------------------------------------------------- 1 | #[cfg(test)] 2 | extern crate imagequant_sys; 3 | 4 | #[cfg(test)] 5 | extern "C" { 6 | fn run_liq_tests(); 7 | } 8 | 9 | #[test] 10 | fn c_test() { 11 | unsafe { 12 | run_liq_tests(); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | imagequant.pc 2 | *.lo 3 | *.o 4 | *.a 5 | *.so.0 6 | *.so 7 | *.bz2 8 | *.dylib 9 | *.dylib.0 10 | *.jnilib 11 | *.dSYM 12 | org/pngquant/*.class 13 | org/pngquant/*.h 14 | target/ 15 | quantized_example.png 16 | example 17 | lodepng.? 18 | Cargo.lock 19 | -------------------------------------------------------------------------------- /imagequant-sys/build.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | if cfg!(all(feature = "std", feature = "no_std")) { 3 | println!("cargo:warning=both std and no_std features are enabled in imagequant-sys"); 4 | } 5 | println!("cargo:include={}", std::env::var("CARGO_MANIFEST_DIR").unwrap()); 6 | } 7 | -------------------------------------------------------------------------------- /imagequant-sys/c_test/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "c_test" 3 | version = "0.1.0" 4 | edition = "2021" 5 | publish = false 6 | 7 | [lib] 8 | doctest = false 9 | 10 | [package.metadata.release] 11 | release = false 12 | 13 | [dependencies] 14 | imagequant-sys = { version = "4.0.3", path = ".." } 15 | 16 | [build-dependencies] 17 | cc = "1.1.7" 18 | -------------------------------------------------------------------------------- /imagequant-sys/imagequant.pc.in: -------------------------------------------------------------------------------- 1 | prefix=@PREFIX@ 2 | includedir=${prefix}/include 3 | libdir=${prefix}/lib 4 | 5 | Name: imagequant 6 | Description: Small, portable C library for high-quality conversion of RGBA images to 8-bit indexed-color (palette) images. 7 | URL: https://pngquant.org/lib/ 8 | Version: @VERSION@ 9 | Libs: -L${libdir} -limagequant 10 | Cflags: -I${includedir} 11 | -------------------------------------------------------------------------------- /imagequant-sys/org/pngquant/LiqObject.java: -------------------------------------------------------------------------------- 1 | package org.pngquant; 2 | 3 | abstract class LiqObject { 4 | static { 5 | // libimagequant.jnilib or libimagequant.so must be in java.library.path 6 | System.loadLibrary("imagequant"); 7 | } 8 | 9 | long handle; 10 | 11 | /** 12 | * Free memory used by the library. The object must not be used after this call. 13 | */ 14 | abstract public void close(); 15 | 16 | protected void finalize() throws Throwable { 17 | close(); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /.github/workflows/ci.yml: -------------------------------------------------------------------------------- 1 | name: CI 2 | 3 | on: 4 | push: 5 | branches: [ main ] 6 | pull_request: 7 | branches: [ main ] 8 | 9 | env: 10 | CARGO_TERM_COLOR: always 11 | CARGO_REGISTRIES_CRATES_IO_PROTOCOL: sparse 12 | 13 | jobs: 14 | build: 15 | runs-on: ubuntu-latest 16 | steps: 17 | - uses: actions/checkout@v4 18 | - uses: actions-rs/toolchain@v1 19 | with: 20 | profile: minimal 21 | toolchain: stable 22 | - uses: actions-rs/cargo@v1 23 | with: 24 | command: test 25 | args: --no-default-features 26 | - uses: actions-rs/cargo@v1 27 | with: 28 | command: test 29 | args: --all-features --all 30 | - uses: actions-rs/cargo@v1 31 | with: 32 | command: test 33 | args: --all-features --all --release 34 | -------------------------------------------------------------------------------- /examples/basic.rs: -------------------------------------------------------------------------------- 1 | //! 2 | 3 | fn main() { 4 | // Image loading/saving is outside scope of this library 5 | let width = 10; 6 | let height = 10; 7 | let fakebitmap = vec![imagequant::RGBA {r:100, g:200, b:250, a:255}; width * height]; 8 | 9 | // Configure the library 10 | let mut liq = imagequant::new(); 11 | liq.set_speed(5).unwrap(); 12 | liq.set_quality(70, 99).unwrap(); 13 | 14 | // Describe the bitmap 15 | let mut img = liq.new_image(&fakebitmap[..], width, height, 0.0).unwrap(); 16 | 17 | // The magic happens in quantize() 18 | let mut res = match liq.quantize(&mut img) { 19 | Ok(res) => res, 20 | Err(err) => panic!("Quantization failed, because: {err:?}"), 21 | }; 22 | 23 | // Enable dithering for subsequent remappings 24 | res.set_dithering_level(1.0).unwrap(); 25 | 26 | // You can reuse the result to generate several images with the same palette 27 | let (palette, pixels) = res.remapped(&mut img).unwrap(); 28 | 29 | println!( 30 | "Done! Got palette {palette:?} and {} pixels with {}% quality", 31 | pixels.len(), 32 | res.quantization_quality().unwrap() 33 | ); 34 | } 35 | -------------------------------------------------------------------------------- /CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | 2 | Thank you for contributing! pngquant and libimagequant are licensed under multiple 3 | licenses, so to make things clear, I'm accepting contributions as licensed under 4 | the BSD 2-clause license: 5 | 6 | Redistribution and use in source and binary forms, with or without modification, 7 | are permitted provided that the following conditions are met: 8 | 9 | 1. Redistributions of source code must retain the above copyright notice, 10 | this list of conditions and the following disclaimer. 11 | 12 | 2. Redistributions in binary form must reproduce the above copyright notice, 13 | this list of conditions and the following disclaimer in the documentation 14 | and/or other materials provided with the distribution. 15 | 16 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 17 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 19 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 20 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 22 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 23 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 24 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 25 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 | 27 | -------------------------------------------------------------------------------- /Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "imagequant" 3 | version = "4.5.0" 4 | 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." 5 | authors = ["Kornel Lesiński "] 6 | license = "GPL-3.0-or-later" 7 | homepage = "https://pngquant.org/lib" 8 | repository = "https://github.com/ImageOptim/libimagequant" 9 | documentation = "https://docs.rs/imagequant" 10 | categories = ["multimedia::images"] 11 | keywords = ["quantization", "palette", "pngquant", "compression", "gif"] 12 | include = ["COPYRIGHT", "src/*.rs", "*.h", "README.md", "Cargo.toml"] 13 | readme = "README.md" 14 | edition = "2021" 15 | rust-version = "1.65" 16 | 17 | [features] 18 | default = ["threads", "std"] 19 | 20 | # libimagequant makes good use of multi-threading, so disabling threads has a significant performance peanalty 21 | threads = ["dep:rayon", "dep:thread_local", "std"] 22 | 23 | # supports up to 2048 colors for palettes, but NOT FOR REMAPPING 24 | large_palettes = [] 25 | 26 | # To opt-in you must disable the default features to disable `std` and `threads`, and also enable `no_std` 27 | std = [] 28 | no_std = ["dep:hashbrown"] 29 | 30 | # this is private and unstable for imagequant-sys only, do not use 31 | _internal_c_ffi = [] 32 | 33 | [profile.release] 34 | debug = false 35 | strip = true 36 | panic = "abort" 37 | 38 | [profile.dev] 39 | panic = "abort" 40 | 41 | [lib] 42 | doctest = false 43 | 44 | [dependencies] 45 | arrayvec = { version = "0.7.4", default-features = false } 46 | rgb = { version = "0.8.47", default-features = false, features = ["bytemuck"] } 47 | rayon = { version = "1.10.0", optional = true } 48 | thread_local = { version = "1.1.8", optional = true } 49 | # Used only in no_std 50 | hashbrown = { version = "0.15.4", optional = true, default-features = false } 51 | 52 | [dev-dependencies] 53 | lodepng = "3.10" 54 | 55 | [workspace] 56 | members = ["imagequant-sys", "imagequant-sys/c_test"] 57 | 58 | [package.metadata.release] 59 | consolidate-commits = true 60 | tag-message = "" 61 | tag-prefix = "" 62 | tag-name = "{{version}}" 63 | -------------------------------------------------------------------------------- /src/error.rs: -------------------------------------------------------------------------------- 1 | use core::{error, fmt}; 2 | use std::collections::TryReserveError; 3 | pub use Error::*; 4 | 5 | /// Error codes 6 | #[cfg_attr(feature = "_internal_c_ffi", repr(C))] 7 | #[cfg_attr(not(feature = "_internal_c_ffi"), non_exhaustive)] // it's meant to be always set, but Rust complains for a good but unrelated reason 8 | #[derive(Copy, Clone, Debug, Eq, PartialEq)] 9 | #[allow(non_camel_case_types)] 10 | pub enum Error { 11 | /// Not an error. Exists for back-compat with the C API 12 | #[cfg(feature = "_internal_c_ffi")] 13 | LIQ_OK = 0, 14 | /// [`set_quality()`][crate::Attributes::set_quality] was used with a minimum quality, and the minimum could not be achieved 15 | QualityTooLow = 99, 16 | /// Function called with invalid arguments 17 | ValueOutOfRange = 100, 18 | /// Either the system/process really hit a limit, or some data like image size was ridiculously wrong. Could be a bug too 19 | OutOfMemory, 20 | /// Progress callback said to stop 21 | Aborted, 22 | /// Some terrible inconsistency happened 23 | InternalError, 24 | /// Slice needs to be bigger, or width/height needs to be smaller 25 | BufferTooSmall, 26 | /// NULL pointer or use-after-free in the C API 27 | InvalidPointer, 28 | /// Congratulations, you've discovered an edge case 29 | Unsupported, 30 | } 31 | 32 | impl error::Error for Error {} 33 | 34 | impl fmt::Display for Error { 35 | #[cold] 36 | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 37 | f.write_str(match *self { 38 | #[cfg(feature = "_internal_c_ffi")] 39 | Self::LIQ_OK => "OK", 40 | Self::QualityTooLow => "QUALITY_TOO_LOW", 41 | Self::ValueOutOfRange => "VALUE_OUT_OF_RANGE", 42 | Self::OutOfMemory => "OUT_OF_MEMORY", 43 | Self::Aborted => "ABORTED", 44 | Self::InternalError => "INTERNAL_ERROR", 45 | Self::BufferTooSmall => "BUFFER_TOO_SMALL", 46 | Self::InvalidPointer => "INVALID_POINTER", 47 | Self::Unsupported => "UNSUPPORTED", 48 | }) 49 | } 50 | } 51 | 52 | impl From for Error { 53 | fn from(e: core::convert::Infallible) -> Self { 54 | match e {} 55 | } 56 | } 57 | 58 | impl From for Error { 59 | #[cold] 60 | fn from(_: TryReserveError) -> Self { 61 | Self::OutOfMemory 62 | } 63 | } 64 | -------------------------------------------------------------------------------- /src/rayoff.rs: -------------------------------------------------------------------------------- 1 | use core::slice::ChunksMut; 2 | use core::cell::OnceCell; 3 | 4 | #[cfg(all(not(feature = "std"), feature = "no_std"))] 5 | use std::boxed::Box; 6 | 7 | pub(crate) struct ThreadLocal(OnceCell); 8 | 9 | impl ThreadLocal { 10 | #[inline(always)] 11 | pub fn new() -> Self { 12 | Self(OnceCell::new()) 13 | } 14 | 15 | #[inline(always)] 16 | pub fn get_or(&self, f: impl FnOnce() -> T) -> &T { 17 | self.0.get_or_init(f) 18 | } 19 | 20 | #[inline(always)] 21 | pub fn get_or_try(&self, f: impl FnOnce() -> Result) -> Result<&T, core::convert::Infallible> { 22 | // https://github.com/rust-lang/rust/issues/109737 23 | Ok(self.0.get_or_init(move || f().ok().unwrap())) 24 | } 25 | } 26 | 27 | impl IntoIterator for ThreadLocal { 28 | type IntoIter = core::option::IntoIter; 29 | type Item = T; 30 | 31 | #[inline(always)] 32 | fn into_iter(mut self) -> Self::IntoIter { 33 | self.0.take().into_iter() 34 | } 35 | } 36 | 37 | pub(crate) trait FakeRayonIter: Sized + Iterator { 38 | fn par_bridge(self) -> Self { self } 39 | fn for_each_init(self, init: I, mut cb: F) where I: FnOnce() -> T, F: FnMut(&mut T, Self::Item) { 40 | let mut tmp = init(); 41 | for item in self { 42 | cb(&mut tmp, item); 43 | } 44 | } 45 | } 46 | 47 | 48 | impl FakeRayonIter for T where Self: Sized { 49 | } 50 | 51 | pub(crate) trait FakeRayonIntoIter { 52 | fn par_chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<'_, T>; 53 | } 54 | 55 | impl<'a, T> FakeRayonIntoIter for &'a mut [T] { 56 | #[inline(always)] 57 | fn par_chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<'_, T> { 58 | self.chunks_mut(chunk_size) 59 | } 60 | } 61 | 62 | impl<'a, T> FakeRayonIntoIter for Box<[T]> { 63 | #[inline(always)] 64 | fn par_chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<'_, T> { 65 | self.chunks_mut(chunk_size) 66 | } 67 | } 68 | 69 | pub(crate) struct SpawnMock; 70 | 71 | impl SpawnMock { 72 | #[inline(always)] 73 | pub fn spawn(&self, f: F) -> R where F: FnOnce(SpawnMock) -> R { 74 | f(SpawnMock) 75 | } 76 | } 77 | 78 | #[inline(always)] 79 | pub(crate) fn scope(f: F) -> R where F: FnOnce(SpawnMock) -> R { 80 | f(SpawnMock) 81 | } 82 | 83 | #[inline(always)] 84 | pub(crate) fn num_cpus() -> usize { 85 | 1 86 | } 87 | -------------------------------------------------------------------------------- /imagequant-sys/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "imagequant-sys" 3 | version = "4.2.0" 4 | description = "Convert 24/32-bit images to 8-bit palette with alpha channel.\nC API/FFI libimagequant that powers pngquant lossy PNG compressor.\n\nDual-licensed like pngquant. See https://pngquant.org for details." 5 | authors = ["Kornel Lesiński "] 6 | license = "GPL-3.0-or-later" 7 | homepage = "https://pngquant.org/lib" 8 | repository = "https://github.com/ImageOptim/libimagequant" 9 | documentation = "https://docs.rs/imagequant" 10 | categories = ["multimedia::images"] 11 | keywords = ["quantization", "palette", "image", "dither", "quant"] 12 | include = ["COPYRIGHT", "src/*.rs", "build.rs", "*.h", "README.md", "Cargo.toml"] 13 | readme = "README.md" 14 | edition = "2021" 15 | links = "imagequant" 16 | build = "build.rs" 17 | rust-version = "1.64" 18 | 19 | [features] 20 | default = ["imagequant/default"] 21 | 22 | # libimagequant makes good use of multi-threading, so disabling threads has a significant performance peanalty 23 | threads = ["imagequant/threads"] 24 | 25 | # To opt-in you must disable the default features to disable `std` and `threads`, and also enable `no_std` 26 | std = ["imagequant/std"] 27 | no_std = ["imagequant/no_std"] 28 | 29 | # Enable if you get errors like "no global memory allocator found" or "`#[panic_handler]` function required, but not found" 30 | no_std_global_handlers = ["no_std"] 31 | 32 | # internal for cargo-c only 33 | capi = [] 34 | 35 | [lib] 36 | crate-type = ["staticlib", "lib"] 37 | doctest = false 38 | path = "src/ffi.rs" 39 | name = "imagequant_sys" 40 | 41 | [dependencies] 42 | imagequant = { path = "..", version = "4.5.0", default-features = false, features = ["_internal_c_ffi"] } 43 | bitflags = "2.5" 44 | libc = "0.2.153" 45 | 46 | [profile.release] 47 | debug = false 48 | strip = true 49 | panic = "abort" 50 | 51 | [profile.dev] 52 | panic = "abort" 53 | 54 | [package.metadata.capi.library] 55 | name = "imagequant" 56 | version = "0.4.1" 57 | 58 | [package.metadata.capi.pkg_config] 59 | name = "imagequant" 60 | filename = "imagequant" 61 | description = "Convert 24/32-bit images to 8-bit palette with alpha channel." 62 | 63 | [package.metadata.capi.header] 64 | name = "libimagequant" 65 | subdirectory = "" 66 | generation = false 67 | 68 | [package.metadata.capi.install.include] 69 | asset = [{from = "libimagequant.h"}] 70 | 71 | [package.metadata.release] 72 | consolidate-commits = true 73 | tag-message = "" 74 | tag-prefix = "" 75 | tag-name = "{{version}}" 76 | 77 | -------------------------------------------------------------------------------- /benches/bench.rs: -------------------------------------------------------------------------------- 1 | #![feature(test)] 2 | 3 | extern crate test; 4 | use core::mem::MaybeUninit; 5 | use test::Bencher; 6 | 7 | use imagequant::*; 8 | 9 | #[bench] 10 | fn histogram(b: &mut Bencher) { 11 | let img = lodepng::decode32_file("/Users/kornel/Desktop/canvas.png").unwrap(); 12 | let liq = Attributes::new(); 13 | b.iter(move || { 14 | let mut img = liq.new_image(&*img.buffer, img.width, img.height, 0.).unwrap(); 15 | let mut hist = Histogram::new(&liq); 16 | hist.add_image(&liq, &mut img).unwrap(); 17 | }); 18 | } 19 | 20 | #[bench] 21 | fn remap_ord(b: &mut Bencher) { 22 | let img = lodepng::decode32_file("/Users/kornel/Desktop/canvas.png").unwrap(); 23 | let mut buf = vec![MaybeUninit::uninit(); img.width * img.height]; 24 | let mut liq = Attributes::new(); 25 | liq.set_speed(10).unwrap(); 26 | let mut img = liq.new_image(img.buffer, img.width, img.height, 0.).unwrap(); 27 | liq.set_max_colors(256).unwrap(); 28 | let mut res = liq.quantize(&mut img).unwrap(); 29 | res.set_dithering_level(0.).unwrap(); 30 | b.iter(move || { 31 | res.remap_into(&mut img, &mut buf).unwrap(); 32 | res.remap_into(&mut img, &mut buf).unwrap(); 33 | }); 34 | } 35 | 36 | #[bench] 37 | fn kmeans(b: &mut Bencher) { 38 | b.iter(_unstable_internal_kmeans_bench()); 39 | } 40 | 41 | #[bench] 42 | fn remap_floyd(b: &mut Bencher) { 43 | let img = lodepng::decode32_file("/Users/kornel/Desktop/canvas.png").unwrap(); 44 | let mut buf = vec![MaybeUninit::uninit(); img.width * img.height]; 45 | let mut liq = Attributes::new(); 46 | liq.set_speed(10).unwrap(); 47 | let mut img = liq.new_image(img.buffer, img.width, img.height, 0.).unwrap(); 48 | let mut res = liq.quantize(&mut img).unwrap(); 49 | res.set_dithering_level(1.).unwrap(); 50 | b.iter(move || { 51 | res.remap_into(&mut img, &mut buf).unwrap(); 52 | res.remap_into(&mut img, &mut buf).unwrap(); 53 | }); 54 | } 55 | 56 | #[bench] 57 | fn quantize_s8(b: &mut Bencher) { 58 | let img = lodepng::decode32_file("/Users/kornel/Desktop/canvas.png").unwrap(); 59 | let mut liq = Attributes::new(); 60 | liq.set_speed(8).unwrap(); 61 | b.iter(move || { 62 | let mut img = liq.new_image(&*img.buffer, img.width, img.height, 0.).unwrap(); 63 | liq.quantize(&mut img).unwrap(); 64 | }); 65 | } 66 | 67 | #[bench] 68 | fn quantize_s1(b: &mut Bencher) { 69 | let img = lodepng::decode32_file("/Users/kornel/Desktop/canvas.png").unwrap(); 70 | let mut liq = Attributes::new(); 71 | liq.set_speed(1).unwrap(); 72 | b.iter(move || { 73 | let mut img = liq.new_image(&*img.buffer, img.width, img.height, 0.).unwrap(); 74 | liq.quantize(&mut img).unwrap(); 75 | }); 76 | } 77 | -------------------------------------------------------------------------------- /imagequant-sys/Makefile: -------------------------------------------------------------------------------- 1 | # You can configure these 2 | PREFIX ?= /usr/local 3 | LIBDIR ?= $(PREFIX)/lib 4 | INCLUDEDIR ?= $(PREFIX)/include 5 | PKGCONFIGDIR ?= $(LIBDIR)/pkgconfig 6 | DESTDIR ?= "" 7 | 8 | VERSION=$(shell grep '^version = "4' Cargo.toml | grep -Eo "4\.[0-9.]+") 9 | STATICLIB=libimagequant.a 10 | 11 | JNILIB=libimagequant.jnilib 12 | 13 | JAVACLASSES = org/pngquant/LiqObject.class org/pngquant/PngQuant.class org/pngquant/Image.class org/pngquant/Result.class 14 | JAVAHEADERS = $(JAVACLASSES:.class=.h) 15 | JAVAINCLUDE = -I'$(JAVA_HOME)/include' -I'$(JAVA_HOME)/include/linux' -I'$(JAVA_HOME)/include/win32' -I'$(JAVA_HOME)/include/darwin' 16 | 17 | PKGCONFIG = imagequant.pc 18 | 19 | all: static 20 | 21 | static: $(STATICLIB) 22 | 23 | java: $(JNILIB) 24 | 25 | $(STATICLIB): Cargo.toml 26 | cargo build --release --lib --target-dir=../target 27 | cp ../target/release/libimagequant_sys.a $(STATICLIB) 28 | 29 | $(JNILIB): $(JAVAHEADERS) $(STATICLIB) org/pngquant/PngQuant.c 30 | # You may need to set LDFLAGS env var. See: cargo rustc -- --print native-static-libs 31 | $(CC) -g $(CFLAGS) $(LDFLAGS) $(JAVAINCLUDE) -shared -o $@ org/pngquant/PngQuant.c $(STATICLIB) 32 | 33 | $(JAVACLASSES): %.class: %.java 34 | javac $< 35 | 36 | $(JAVAHEADERS): %.h: %.class 37 | javah -o $@ $(subst /,., $(patsubst %.class,%,$<)) && touch $@ 38 | 39 | example: example.c lodepng.h lodepng.c $(STATICLIB) 40 | # remove -lpthread on Windows 41 | # add -ldl on Linux 42 | # You may need to set LDFLAGS env var. See: cargo rustc -- --print native-static-libs 43 | $(CC) -g $(CFLAGS) -Wall example.c $(STATICLIB) -lm -lpthread $(LDFLAGS) -o example 44 | 45 | lodepng.h: 46 | curl -o lodepng.h -L https://raw.githubusercontent.com/lvandeve/lodepng/master/lodepng.h 47 | 48 | lodepng.c: 49 | curl -o lodepng.c -L https://raw.githubusercontent.com/lvandeve/lodepng/master/lodepng.cpp 50 | 51 | clean: 52 | rm -f $(SHAREDLIBVER) $(SHAREDLIB) $(STATICLIB) 53 | rm -f $(JAVAHEADERS) $(JAVACLASSES) $(JNILIB) example 54 | rm -rf ../target 55 | 56 | distclean: clean 57 | rm -f imagequant.pc 58 | 59 | install: all $(PKGCONFIG) 60 | install -d $(DESTDIR)$(LIBDIR) 61 | install -d $(DESTDIR)$(PKGCONFIGDIR) 62 | install -d $(DESTDIR)$(INCLUDEDIR) 63 | install -m 644 $(STATICLIB) $(DESTDIR)$(LIBDIR)/$(STATICLIB) 64 | install -m 644 $(PKGCONFIG) $(DESTDIR)$(PKGCONFIGDIR)/$(PKGCONFIG) 65 | install -m 644 libimagequant.h $(DESTDIR)$(INCLUDEDIR)/libimagequant.h 66 | $(FIX_INSTALL_NAME) 67 | 68 | uninstall: 69 | rm -f $(DESTDIR)$(LIBDIR)/$(STATICLIB) 70 | rm -f $(DESTDIR)$(PKGCONFIGDIR)/$(PKGCONFIG) 71 | rm -f $(DESTDIR)$(INCLUDEDIR)/libimagequant.h 72 | 73 | $(PKGCONFIG): Cargo.toml 74 | sed 's|@PREFIX@|$(PREFIX)|;s|@VERSION@|$(VERSION)|' < imagequant.pc.in > $(PKGCONFIG) 75 | 76 | .PHONY: all static clean distclean java 77 | .DELETE_ON_ERROR: 78 | -------------------------------------------------------------------------------- /imagequant-sys/pom.xml: -------------------------------------------------------------------------------- 1 | 3 | 4.0.0 4 | org.pngquant 5 | libimagequant 6 | jar 7 | 4.1.0 8 | pngquant 9 | https://pngquant.org 10 | 11 | . 12 | 13 | 14 | org.codehaus.mojo 15 | exec-maven-plugin 16 | 1.1 17 | 18 | 19 | build 20 | compile 21 | exec 22 | 23 | make 24 | 25 | -j8 26 | USE_SSE=1 27 | java 28 | 29 | 30 | 31 | 32 | clean 33 | clean 34 | exec 35 | 36 | make 37 | 38 | clean 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | mac-x64 49 | 50 | 51 | Mac 52 | x64 53 | 54 | 55 | 56 | 57 | org.pngquant 58 | libimagequant-jni 59 | 1 60 | jnilib 61 | mac-x64 62 | 63 | 64 | 65 | 66 | linux-x64 67 | 68 | 69 | unix 70 | Linux 71 | x64 72 | 73 | 74 | 75 | 76 | org.pngquant 77 | libimagequant-jni 78 | so 79 | 1 80 | linux-x64 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | -------------------------------------------------------------------------------- /imagequant-sys/org/pngquant/Image.java: -------------------------------------------------------------------------------- 1 | package org.pngquant; 2 | 3 | import org.pngquant.*; 4 | import java.awt.image.*; 5 | 6 | /** 7 | * PngQuant's representation of an Image constructed from BufferedImage. 8 | */ 9 | public class Image extends LiqObject { 10 | 11 | /** 12 | * Converts BufferedImage to internal representation (pixel data is copied). 13 | * It's best to use BufferedImage in RGB/RGBA format backed by DataBufferByte. 14 | * Throws if conversion fails. 15 | */ 16 | public Image(BufferedImage image) throws PngQuantException { 17 | this(new PngQuant(), image); 18 | } 19 | 20 | public Image(PngQuant attr, BufferedImage image) throws PngQuantException { 21 | handle = handleFromImage(attr, image); 22 | 23 | if (handle == 0) { 24 | BufferedImage converted = new BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_4BYTE_ABGR); 25 | converted.getGraphics().drawImage(image, 0, 0, null); 26 | handle = handleFromImage(attr, converted); 27 | 28 | if (handle == 0) { 29 | throw new PngQuantException(); 30 | } 31 | } 32 | } 33 | 34 | /** 35 | * Guarantees presence of the given color in the palette (subject to setMaxColors()) 36 | * if this image is used for quantization. 37 | */ 38 | public native boolean addFixedColor(int r, int g, int b, int a); 39 | public boolean addFixedColor(int r, int g, int b) { 40 | return addFixedColor(r, g, b, 255); 41 | } 42 | public native int getWidth(); 43 | public native int getHeight(); 44 | 45 | public void close() { 46 | if (handle != 0) { 47 | liq_image_destroy(handle); 48 | handle = 0; 49 | } 50 | } 51 | 52 | private static long handleFromImage(PngQuant attr, BufferedImage image) { 53 | // The JNI wrapper will accept non-premultiplied ABGR and BGR only. 54 | int type = image.getType(); 55 | if (type != BufferedImage.TYPE_3BYTE_BGR && 56 | type != BufferedImage.TYPE_4BYTE_ABGR && 57 | type != BufferedImage.TYPE_4BYTE_ABGR_PRE) return 0; 58 | 59 | WritableRaster raster = image.getRaster(); 60 | ColorModel color = image.getColorModel(); 61 | if (type == BufferedImage.TYPE_4BYTE_ABGR_PRE) color.coerceData(raster, false); 62 | 63 | DataBuffer buffer = raster.getDataBuffer(); 64 | if (buffer instanceof DataBufferByte) { 65 | byte[] imageData = ((DataBufferByte)buffer).getData(); 66 | return liq_image_create(attr.handle, imageData, 67 | raster.getWidth(), raster.getHeight(), color.getNumComponents()); 68 | } 69 | return 0; 70 | } 71 | 72 | private static native long liq_image_create(long attr, byte[] bitmap, int width, int height, int components); 73 | private static native void liq_image_destroy(long handle); 74 | } 75 | -------------------------------------------------------------------------------- /src/blur.rs: -------------------------------------------------------------------------------- 1 | /// Blurs image horizontally (width 2*size+1) and writes it transposed to dst (called twice gives 2d blur) 2 | #[inline(never)] 3 | fn transposing_1d_blur(src: &[u8], dst: &mut [u8], width: usize, height: usize, size: u16) { 4 | if width < 2 * size as usize + 1 || height < 2 * size as usize + 1 { 5 | return; 6 | } 7 | 8 | for (j, row) in src.chunks_exact(width).enumerate() { 9 | let mut sum = u16::from(row[0]) * size; 10 | for &v in &row[0..size as usize] { 11 | sum += u16::from(v); 12 | } 13 | for i in 0..size as usize { 14 | sum -= u16::from(row[0]); 15 | sum += u16::from(row[i + size as usize]); 16 | dst[i * height + j] = (sum / (size * 2)) as u8; 17 | } 18 | for i in size as usize..width - size as usize { 19 | sum -= u16::from(row[i - size as usize]); 20 | sum += u16::from(row[i + size as usize]); 21 | dst[i * height + j] = (sum / (size * 2)) as u8; 22 | } 23 | for i in width - size as usize..width { 24 | sum -= u16::from(row[i - size as usize]); 25 | sum += u16::from(row[width - 1]); 26 | dst[i * height + j] = (sum / (size * 2)) as u8; 27 | } 28 | } 29 | } 30 | 31 | /// Picks maximum of neighboring pixels (blur + lighten) 32 | #[inline(never)] 33 | pub(crate) fn liq_max3(src: &[u8], dst: &mut [u8], width: usize, height: usize) { 34 | liq_op3(src, dst, width, height, |a, b| a.max(b)); 35 | } 36 | 37 | pub(crate) fn liq_op3(src: &[u8], dst: &mut [u8], width: usize, height: usize, op: impl Fn(u8, u8) -> u8) { 38 | for j in 0..height { 39 | let row = &src[j * width..][..width]; 40 | let dst = &mut dst[j * width..][..width]; 41 | let prevrow = &src[j.saturating_sub(1) * width..][..width]; 42 | let nextrow = &src[(j + 1).min(height - 1) * width..][..width]; 43 | let mut prev: u8; 44 | let mut curr = row[0]; 45 | let mut next = row[0]; 46 | for i in 0..width - 1 { 47 | prev = curr; 48 | curr = next; 49 | next = row[i + 1]; 50 | let t1 = op(prev, next); 51 | let t2 = op(nextrow[i], prevrow[i]); 52 | dst[i] = op(curr, op(t1, t2)); 53 | } 54 | let t1 = op(curr, next); 55 | let t2 = op(nextrow[width - 1], prevrow[width - 1]); 56 | dst[width - 1] = op(curr, op(t1, t2)); 57 | } 58 | } 59 | 60 | /// Picks minimum of neighboring pixels (blur + darken) 61 | #[inline(never)] 62 | pub(crate) fn liq_min3(src: &[u8], dst: &mut [u8], width: usize, height: usize) { 63 | liq_op3(src, dst, width, height, |a, b| a.min(b)); 64 | } 65 | 66 | /// Filters src image and saves it to dst, overwriting tmp in the process. 67 | /// Image must be width*height pixels high. Size controls radius of box blur. 68 | pub(crate) fn liq_blur(src_dst: &mut [u8], tmp: &mut [u8], width: usize, height: usize, size: u16) { 69 | transposing_1d_blur(src_dst, tmp, width, height, size); 70 | transposing_1d_blur(tmp, src_dst, height, width, size); 71 | } 72 | -------------------------------------------------------------------------------- /src/capi.rs: -------------------------------------------------------------------------------- 1 | //! These are internal unstable private helper methods for imagequant-sys. 2 | //! For public stable a C FFI interface, see imagequant-sys crate instead. 3 | #![allow(missing_docs)] 4 | #![allow(clippy::missing_safety_doc)] 5 | 6 | #[cfg(all(not(feature = "std"), feature = "no_std"))] 7 | use crate::no_std_compat::*; 8 | 9 | use crate::pal::Palette; 10 | use crate::rows::RowCallback; 11 | use crate::seacow::{Pointer, RowBitmapMut, SeaCow}; 12 | use crate::{Attributes, Error, Image, QuantizationResult, RGBA}; 13 | use core::ffi::c_void; 14 | use core::mem::{self, MaybeUninit}; 15 | 16 | pub const LIQ_VERSION: u32 = 40202; 17 | 18 | #[must_use] 19 | pub fn liq_get_palette_impl(r: &mut QuantizationResult) -> &Palette { 20 | r.int_palette() 21 | } 22 | 23 | #[must_use] 24 | pub unsafe fn liq_image_create_rgba_rows_impl<'rows>(attr: &Attributes, rows: &'rows [*const RGBA], width: u32, height: u32, gamma: f64) -> Option> { 25 | let rows = SeaCow::borrowed(&*(rows as *const [*const rgb::Rgba] as *const [Pointer>])); 26 | let rows_slice = rows.as_slice(); 27 | if rows_slice.iter().any(|r| r.0.is_null()) { 28 | return None; 29 | } 30 | crate::image::Image::new_internal(attr, crate::rows::PixelsSource::Pixels { rows, pixels: None }, width, height, gamma).ok() 31 | } 32 | 33 | #[must_use] 34 | pub unsafe fn liq_image_create_rgba_bitmap_impl<'rows>(attr: &Attributes, rows: Box<[*const RGBA]>, width: u32, height: u32, gamma: f64) -> Option> { 35 | let rows = SeaCow::boxed(mem::transmute::, Box<[Pointer]>>(rows)); 36 | let rows_slice = rows.as_slice(); 37 | if rows_slice.iter().any(|r| r.0.is_null()) { 38 | return None; 39 | } 40 | crate::image::Image::new_internal(attr, crate::rows::PixelsSource::Pixels { rows, pixels: None }, width, height, gamma).ok() 41 | } 42 | 43 | #[must_use] 44 | pub unsafe fn liq_image_create_custom_impl<'rows>(attr: &Attributes, row_callback: Box>, width: u32, height: u32, gamma: f64) -> Option> { 45 | Image::new_internal(attr, crate::rows::PixelsSource::Callback(row_callback), width, height, gamma).ok() 46 | } 47 | 48 | pub unsafe fn liq_write_remapped_image_impl(result: &mut QuantizationResult, input_image: &mut Image, buffer_bytes: &mut [MaybeUninit]) -> Result<(), Error> { 49 | let rows = RowBitmapMut::new_contiguous(buffer_bytes, input_image.width()); 50 | result.write_remapped_image_rows_internal(input_image, rows) 51 | } 52 | 53 | pub unsafe fn liq_write_remapped_image_rows_impl(result: &mut QuantizationResult, input_image: &mut Image, rows: &mut [*mut MaybeUninit]) -> Result<(), Error> { 54 | let rows = RowBitmapMut::new(rows, input_image.width()); 55 | result.write_remapped_image_rows_internal(input_image, rows) 56 | } 57 | 58 | /// Not recommended 59 | 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> { 60 | image.px.set_memory_ownership(own_rows, own_pixels, free_fn) 61 | } 62 | -------------------------------------------------------------------------------- /imagequant-sys/org/pngquant/Result.java: -------------------------------------------------------------------------------- 1 | package org.pngquant; 2 | 3 | import org.pngquant.*; 4 | import java.awt.image.*; 5 | 6 | /** 7 | * Quantization result that holds palette and options for remapping. 8 | */ 9 | public class Result extends LiqObject { 10 | 11 | /** 12 | * Throws when quantization fails (e.g. due to failing to achieve minimum quality) 13 | */ 14 | public Result(PngQuant pngquant, Image image) throws PngQuantException { 15 | handle = liq_quantize_image(pngquant.handle, image.handle); 16 | if (handle == 0) { 17 | throw new PngQuantException(); 18 | } 19 | } 20 | 21 | /** 22 | * @return BufferedImage remapped to palette this Result has been created with or null on failure. 23 | */ 24 | public BufferedImage getRemapped(Image orig_image) { 25 | byte[] pal = liq_get_palette(handle); 26 | IndexColorModel color = new IndexColorModel(8, pal.length/4, pal, 0, true); 27 | BufferedImage img = new BufferedImage( 28 | orig_image.getWidth(), orig_image.getHeight(), 29 | BufferedImage.TYPE_BYTE_INDEXED, color); 30 | 31 | byte[] data = get8bitDataFromImage(img); 32 | if (data == null) return null; 33 | 34 | if (!liq_write_remapped_image(handle, orig_image.handle, data)) return null; 35 | 36 | return img; 37 | } 38 | 39 | /** 40 | * Dithering strength. Floyd-Steinberg is always used and in 41 | * speed settings 1-5 high-quality adaptive dithering is used. 42 | * @see PngQuant.setSpeed() 43 | * @link http://pngquant.org/lib/#liq_set_dithering_level 44 | * 45 | * @param dither_level Dithering in range 0 (none) and 1 (full) 46 | */ 47 | public native boolean setDitheringLevel(float dither_level); 48 | 49 | /** 50 | * The default is 0.45455 (1/2.2) which is PNG's approximation of sRGB. 51 | */ 52 | public native boolean setGamma(double gamma); 53 | public native double getGamma(); 54 | 55 | /** 56 | * Mean Square Error of remapping of image used to create this result. 57 | * @link http://pngquant.org/lib/#liq_get_quantization_error 58 | * 59 | * @return MSE or -1 if not available 60 | */ 61 | public native double getMeanSquareError(); 62 | 63 | /** 64 | * @link http://pngquant.org/lib/#liq_get_quantization_quality 65 | * @return Actually achieved quality in 0-100 range on scale compatible with PngQuant.setQuality() 66 | */ 67 | public native int getQuality(); 68 | 69 | public void close() { 70 | if (handle != 0) { 71 | liq_result_destroy(handle); 72 | handle = 0; 73 | } 74 | } 75 | 76 | private static byte[] get8bitDataFromImage(BufferedImage image) { 77 | if (image.getType() == BufferedImage.TYPE_BYTE_INDEXED) { 78 | DataBuffer buffer = image.getRaster().getDataBuffer(); 79 | if (buffer instanceof DataBufferByte) { 80 | return ((DataBufferByte)buffer).getData(); 81 | } 82 | } 83 | return null; 84 | } 85 | 86 | private static native byte[] liq_get_palette(long handle); 87 | private static native long liq_quantize_image(long attr, long image); 88 | private static native boolean liq_write_remapped_image(long handle, long image, byte[] buffer); 89 | private static native void liq_result_destroy(long handle); 90 | } 91 | -------------------------------------------------------------------------------- /CODE_OF_CONDUCT.md: -------------------------------------------------------------------------------- 1 | # Contributor Covenant Code of Conduct 2 | 3 | ## Our Pledge 4 | 5 | In the interest of fostering an open and welcoming environment, we as 6 | contributors and maintainers pledge to making participation in our project and 7 | our community a harassment-free experience for everyone, regardless of age, body 8 | size, disability, ethnicity, gender identity and expression, level of experience, 9 | nationality, personal appearance, race, religion, or sexual identity and 10 | orientation. 11 | 12 | ## Our Standards 13 | 14 | Examples of behavior that contributes to creating a positive environment 15 | include: 16 | 17 | * Using welcoming and inclusive language 18 | * Being respectful of differing viewpoints and experiences 19 | * Gracefully accepting constructive criticism 20 | * Focusing on what is best for the community 21 | * Showing empathy towards other community members 22 | 23 | Examples of unacceptable behavior by participants include: 24 | 25 | * The use of sexualized language or imagery and unwelcome sexual attention or 26 | advances 27 | * Trolling, insulting/derogatory comments, and personal or political attacks 28 | * Public or private harassment 29 | * Publishing others' private information, such as a physical or electronic 30 | address, without explicit permission 31 | * Other conduct which could reasonably be considered inappropriate in a 32 | professional setting 33 | 34 | ## Our Responsibilities 35 | 36 | Project maintainers are responsible for clarifying the standards of acceptable 37 | behavior and are expected to take appropriate and fair corrective action in 38 | response to any instances of unacceptable behavior. 39 | 40 | Project maintainers have the right and responsibility to remove, edit, or 41 | reject comments, commits, code, wiki edits, issues, and other contributions 42 | that are not aligned to this Code of Conduct, or to ban temporarily or 43 | permanently any contributor for other behaviors that they deem inappropriate, 44 | threatening, offensive, or harmful. 45 | 46 | ## Scope 47 | 48 | This Code of Conduct applies both within project spaces and in public spaces 49 | when an individual is representing the project or its community. Examples of 50 | representing a project or community include using an official project e-mail 51 | address, posting via an official social media account, or acting as an appointed 52 | representative at an online or offline event. Representation of a project may be 53 | further defined and clarified by project maintainers. 54 | 55 | ## Enforcement 56 | 57 | Instances of abusive, harassing, or otherwise unacceptable behavior may be 58 | reported by contacting the project team at kornel@geekhood.net. All 59 | complaints will be reviewed and investigated and will result in a response that 60 | is deemed necessary and appropriate to the circumstances. The project team is 61 | obligated to maintain confidentiality with regard to the reporter of an incident. 62 | Further details of specific enforcement policies may be posted separately. 63 | 64 | Project maintainers who do not follow or enforce the Code of Conduct in good 65 | faith may face temporary or permanent repercussions as determined by other 66 | members of the project's leadership. 67 | 68 | ## Attribution 69 | 70 | This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, 71 | available at [http://contributor-covenant.org/version/1/4][version] 72 | 73 | [homepage]: http://contributor-covenant.org 74 | [version]: http://contributor-covenant.org/version/1/4/ 75 | -------------------------------------------------------------------------------- /CHANGELOG: -------------------------------------------------------------------------------- 1 | version 4.4 2 | ----------- 3 | - palette quality improvements 4 | - Histogram::from_palette convenience method 5 | 6 | version 4.3 7 | ----------- 8 | - code quality and performance improvements 9 | - copyable Image object 10 | 11 | version 4.2 12 | ----------- 13 | - rewritten and improved handling of fixed palette colors 14 | - support for palettes larger than 256 colors 15 | - fix for remapping when importance_map has lots of pixels with 0 importance 16 | 17 | version 4.1 18 | ----------- 19 | - improved dithering over preset background 20 | - remap_into_vec method 21 | - fix for images over 16 megapixels 22 | 23 | version 4.0 24 | ----------- 25 | - rewritten in Rust 26 | - replaced Makefiles with Cargo 27 | 28 | version 2.17 29 | ------------ 30 | - quality improvement 31 | - ARM64 build fix 32 | 33 | version 2.16 34 | ------------ 35 | - fixed LCMS2 error handling 36 | 37 | version 2.15 38 | ------------ 39 | - speed and quality improvements 40 | 41 | version 2.14 42 | ------------ 43 | - improved Rust API 44 | - quality improvements for remapping overlays over a background 45 | 46 | version 2.13 47 | ------------ 48 | - support OpenMP in clang 49 | - dropped old Internet Explorer workarounds 50 | - speed and quality improvements 51 | 52 | version 2.12 53 | ------------ 54 | - new liq_histogram_add_fixed_color() 55 | - faster for large/complex images 56 | - workarounds for Microsoft's outdated C compiler 57 | 58 | version 2.11 59 | ------------ 60 | - new liq_image_set_background() for high-quality remapping of GIF frames 61 | - new liq_image_set_importance_map() for controlling which parts of the image get more palette colors 62 | - improved OpenMP support 63 | 64 | version 2.10 65 | ----------- 66 | - supports building with Rust/Cargo 67 | 68 | version 2.9 69 | ----------- 70 | - new liq_histogram_add_colors() 71 | 72 | version 2.8 73 | ----------- 74 | - standalone version 75 | - added Java interface (JNI) 76 | - new API for remapping multiple images to a single shared palette 77 | 78 | version 2.7 79 | ----------- 80 | - improved dithering of saturated and semitransparent colors 81 | - libimagequant reports detailed progress and supports aborting of operations via callbacks 82 | - fixed order of log output when using openmp 83 | 84 | version 2.5 85 | ----------- 86 | - replaced color search algorithm with vantage point tree, which is much faster and more reliable 87 | - deprecated IE6 workaround 88 | - warn when compiled without color profile support 89 | - improved support for predefined colors in libimagequant 90 | 91 | version 2.4 92 | ----------- 93 | - fixed remapping of bright colors when dithering 94 | - added libimagequant API to add fixed preset colors to the palette 95 | 96 | version 2.3 97 | ----------- 98 | - added ./configure script for better support of Intel C compiler and dependencies [thanks to pdknsk] 99 | - tweaked quality metric to better estimate quality of images with large solid backgrounds [thanks to Rolf Timmermans] 100 | - avoid applying quality setting to images that use palette already 101 | 102 | version 2.2 103 | ----------- 104 | - OpenMP acceleration 105 | - improved support for Intel C Compiler, speedup in 32-bit GCC, and some workarounds for Visual Studio's incomplete C support 106 | 107 | version 2.1 108 | ----------- 109 | - option to generate posterized output (for use with 16-bit textures) 110 | 111 | version 2.0 112 | ----------- 113 | - refactored codebase into pngquant and standalone libimagequant 114 | - reduced memory usage by further 30% (and more for very large images) 115 | - less precise remapping improving speed by 25% in higher speed settings 116 | - fixed regression in dithering of alpha channel 117 | -------------------------------------------------------------------------------- /imagequant-sys/org/pngquant/PngQuant.java: -------------------------------------------------------------------------------- 1 | package org.pngquant; 2 | 3 | import org.pngquant.*; 4 | import java.awt.image.*; 5 | 6 | /** 7 | * Starting point for the library. Holds configuration. Equivalent of liq_attr* in libimagequant. 8 | */ 9 | public class PngQuant extends LiqObject { 10 | 11 | /** 12 | * Single instance can be "recycled" for many remappings. 13 | */ 14 | public PngQuant() { 15 | handle = liq_attr_create(); 16 | } 17 | 18 | public PngQuant(PngQuant other) { 19 | handle = liq_attr_copy(other.handle); 20 | } 21 | 22 | /** 23 | * 1-shot quantization and remapping with current settings. 24 | * @see quantize() 25 | * 26 | * @return 8-bit indexed image or null on failure 27 | */ 28 | public BufferedImage getRemapped(BufferedImage bufimg) { 29 | try { 30 | Image liqimg = new Image(this, bufimg); 31 | BufferedImage remapped = getRemapped(liqimg); 32 | liqimg.close(); 33 | return remapped; 34 | } catch(PngQuantException e) { 35 | return null; 36 | } 37 | } 38 | 39 | /** @return remapped image or null on failure */ 40 | public BufferedImage getRemapped(Image liqimg) { 41 | Result result = quantize(liqimg); 42 | if (result == null) return null; 43 | BufferedImage remapped = result.getRemapped(liqimg); 44 | result.close(); 45 | return remapped; 46 | } 47 | 48 | /** 49 | * Performs quantization (chooses optimal palette for the given Image). 50 | * Returned object can be used to customize remapping and reused to remap other images to the same palette. 51 | * @link http://pngquant.org/lib/#liq_quantize_image 52 | * 53 | * @return null on failure 54 | */ 55 | public Result quantize(Image img) { 56 | try { 57 | return new Result(this, img); 58 | } catch(PngQuantException e) { 59 | return null; 60 | } 61 | } 62 | 63 | /** 64 | * Remapped images won't use more than given number of colors (may use less if setQuality() is used) 65 | * 66 | * @link http://pngquant.org/lib/#liq_set_max_colors 67 | */ 68 | public native boolean setMaxColors(int colors); 69 | 70 | /** 71 | * Equivalent of setQuality(target/2, target) 72 | * 73 | * @link http://pngquant.org/lib/#liq_set_quality 74 | */ 75 | public native boolean setQuality(int target); 76 | 77 | /** 78 | * Quality in range 0-100. Quantization will fail if minimum quality cannot 79 | * be achieved with given number of colors. 80 | * 81 | * @link http://pngquant.org/lib/#liq_set_quality 82 | */ 83 | public native boolean setQuality(int min, int max); 84 | 85 | /** 86 | * Speed in range 1 (slowest) and 11 (fastest). 3 is the optimum. 87 | * Higher speeds quantize quicker, but at cost of quality and sometimes larger images. 88 | * 89 | * @link http://pngquant.org/lib/#liq_set_speed 90 | */ 91 | public native boolean setSpeed(int speed); 92 | 93 | /** 94 | * Reduces color precision by truncating number of least significant bits. 95 | * Slightly improves speed and helps generating images for low-fidelity displays/textures. 96 | * 97 | * @link http://pngquant.org/lib/#liq_set_min_posterization 98 | */ 99 | public native boolean setMinPosterization(int bits); 100 | 101 | public void close() { 102 | if (handle != 0) { 103 | liq_attr_destroy(handle); 104 | handle = 0; 105 | } 106 | } 107 | 108 | private static native long liq_attr_create(); 109 | private static native long liq_attr_copy(long orig); 110 | private static native void liq_attr_destroy(long handle); 111 | } 112 | -------------------------------------------------------------------------------- /imagequant-sys/example.c: -------------------------------------------------------------------------------- 1 | /** 2 | 3 | This is an example how to write your own simple pngquant using libimagequant. 4 | 5 | libimagequant works with any PNG library. This example uses lodepng, because it's easier to use than libpng. 6 | 7 | 1. Get lodepng.c (download lodepng.cpp and rename it) and lodepng.h 8 | from https://lodev.org/lodepng/ and put them in this directry 9 | 10 | 2. Compile libimagequant (see README.md) 11 | 12 | 3. Compile and run the example: 13 | 14 | gcc -O3 example.c libimagequant.a -o example 15 | ./example truecolor_file.png 16 | 17 | 18 | This example code can be freely copied under CC0 (public domain) license. 19 | */ 20 | 21 | #include "lodepng.h" // Get it from https://raw.githubusercontent.com/lvandeve/lodepng/master/lodepng.h 22 | #include "lodepng.c" // Get it from https://raw.githubusercontent.com/lvandeve/lodepng/master/lodepng.cpp and rename 23 | #include 24 | #include 25 | #include "libimagequant.h" 26 | 27 | int main(int argc, char *argv[]) { 28 | if (argc < 2) { 29 | fprintf(stderr, "Please specify a path to a PNG file\n"); 30 | return EXIT_FAILURE; 31 | } 32 | 33 | const char *input_png_file_path = argv[1]; 34 | 35 | // Load PNG file and decode it as raw RGBA pixels 36 | // This uses lodepng library for PNG reading (not part of libimagequant) 37 | 38 | unsigned int width, height; 39 | unsigned char *raw_rgba_pixels; 40 | unsigned int status = lodepng_decode32_file(&raw_rgba_pixels, &width, &height, input_png_file_path); 41 | if (status) { 42 | fprintf(stderr, "Can't load %s: %s\n", input_png_file_path, lodepng_error_text(status)); 43 | return EXIT_FAILURE; 44 | } 45 | 46 | // Use libimagequant to make a palette for the RGBA pixels 47 | 48 | liq_attr *handle = liq_attr_create(); 49 | liq_image *input_image = liq_image_create_rgba(handle, raw_rgba_pixels, width, height, 0); 50 | // You could set more options here, like liq_set_quality 51 | liq_result *quantization_result; 52 | if (liq_image_quantize(input_image, handle, &quantization_result) != LIQ_OK) { 53 | fprintf(stderr, "Quantization failed\n"); 54 | return EXIT_FAILURE; 55 | } 56 | 57 | // Use libimagequant to make new image pixels from the palette 58 | 59 | size_t pixels_size = width * height; 60 | unsigned char *raw_8bit_pixels = malloc(pixels_size); 61 | liq_set_dithering_level(quantization_result, 1.0); 62 | 63 | liq_write_remapped_image(quantization_result, input_image, raw_8bit_pixels, pixels_size); 64 | const liq_palette *palette = liq_get_palette(quantization_result); 65 | 66 | // Save converted pixels as a PNG file 67 | // This uses lodepng library for PNG writing (not part of libimagequant) 68 | 69 | LodePNGState state; 70 | lodepng_state_init(&state); 71 | state.info_raw.colortype = LCT_PALETTE; 72 | state.info_raw.bitdepth = 8; 73 | state.info_png.color.colortype = LCT_PALETTE; 74 | state.info_png.color.bitdepth = 8; 75 | 76 | for(int i=0; i < palette->count; i++) { 77 | lodepng_palette_add(&state.info_png.color, palette->entries[i].r, palette->entries[i].g, palette->entries[i].b, palette->entries[i].a); 78 | lodepng_palette_add(&state.info_raw, palette->entries[i].r, palette->entries[i].g, palette->entries[i].b, palette->entries[i].a); 79 | } 80 | 81 | unsigned char *output_file_data; 82 | size_t output_file_size; 83 | unsigned int out_status = lodepng_encode(&output_file_data, &output_file_size, raw_8bit_pixels, width, height, &state); 84 | if (out_status) { 85 | fprintf(stderr, "Can't encode image: %s\n", lodepng_error_text(out_status)); 86 | return EXIT_FAILURE; 87 | } 88 | 89 | const char *output_png_file_path = "quantized_example.png"; 90 | FILE *fp = fopen(output_png_file_path, "wb"); 91 | if (!fp) { 92 | fprintf(stderr, "Unable to write to %s\n", output_png_file_path); 93 | return EXIT_FAILURE; 94 | } 95 | fwrite(output_file_data, 1, output_file_size, fp); 96 | fclose(fp); 97 | 98 | printf("Written %s\n", output_png_file_path); 99 | 100 | // Done. Free memory. 101 | 102 | liq_result_destroy(quantization_result); // Must be freed only after you're done using the palette 103 | liq_image_destroy(input_image); 104 | liq_attr_destroy(handle); 105 | 106 | free(raw_8bit_pixels); 107 | lodepng_state_cleanup(&state); 108 | } 109 | -------------------------------------------------------------------------------- /imagequant-sys/c_test/test.c: -------------------------------------------------------------------------------- 1 | #undef NDEBUG 2 | #include 3 | #include "libimagequant.h" 4 | #include 5 | #include 6 | 7 | static char magic[] = "magic"; 8 | 9 | static void test_log_callback_function(const liq_attr *at, const char *message, void* user_info) { 10 | assert(at); 11 | assert(user_info == magic); 12 | assert(message); 13 | assert(strlen(message)); 14 | } 15 | 16 | static int test_abort_callback(float progress_percent, void* user_info) { 17 | assert(progress_percent >= 0.0 && progress_percent <= 100.0); 18 | assert(user_info == magic); 19 | return 0; 20 | } 21 | 22 | static int progress_called = 0; 23 | static int test_continue_callback(float progress_percent, void* user_info) { 24 | assert(progress_percent >= 0.0 && progress_percent <= 100.0); 25 | assert(user_info == magic); 26 | progress_called++; 27 | return 1; 28 | } 29 | 30 | static void test_abort() { 31 | liq_attr *attr = liq_attr_create(); 32 | 33 | unsigned char dummy[4] = {0}; 34 | liq_image *img = liq_image_create_rgba(attr, dummy, 1, 1, 0); 35 | 36 | liq_attr_set_progress_callback(attr, test_abort_callback, magic); 37 | 38 | liq_result *res = liq_quantize_image(attr, img); 39 | assert(!res); 40 | 41 | liq_attr_destroy(attr); 42 | } 43 | 44 | static void test_zero_histogram() { 45 | liq_attr *attr = liq_attr_create(); 46 | liq_histogram *hist = liq_histogram_create(attr); 47 | assert(hist); 48 | 49 | liq_result *res; 50 | liq_error err = liq_histogram_quantize(hist, attr, &res); 51 | assert(!res); 52 | assert(err); 53 | 54 | liq_attr_destroy(attr); 55 | liq_histogram_destroy(hist); 56 | } 57 | 58 | static void test_histogram() { 59 | liq_attr *attr = liq_attr_create(); 60 | liq_histogram *hist = liq_histogram_create(attr); 61 | assert(hist); 62 | 63 | const unsigned char dummy1[4] = {255,0,255,255}; 64 | liq_image *const img1 = liq_image_create_rgba(attr, dummy1, 1, 1, 0); 65 | assert(img1); 66 | 67 | const liq_error err1 = liq_histogram_add_image(hist, attr, img1); 68 | assert(LIQ_OK == err1); 69 | 70 | const unsigned char dummy2[4] = {0,0,0,0}; 71 | liq_image *const img2 = liq_image_create_rgba(attr, dummy2, 1, 1, 0); 72 | assert(img2); 73 | liq_image_add_fixed_color(img2, (liq_color){255,255,255,255}); 74 | 75 | 76 | const liq_error err2 = liq_histogram_add_image(hist, attr, img2); 77 | assert(LIQ_OK == err2); 78 | 79 | liq_image_destroy(img1); 80 | liq_image_destroy(img2); 81 | 82 | liq_result *res; 83 | liq_error err = liq_histogram_quantize(hist, attr, &res); 84 | assert(LIQ_OK == err); 85 | assert(res); 86 | 87 | liq_attr_destroy(attr); 88 | 89 | liq_histogram_destroy(hist); 90 | 91 | const liq_palette *pal = liq_get_palette(res); 92 | assert(pal); 93 | assert(pal->count == 3); 94 | 95 | liq_result_destroy(res); 96 | } 97 | 98 | static void test_fixed_colors() { 99 | liq_attr *attr = liq_attr_create(); 100 | 101 | liq_attr_set_progress_callback(attr, test_continue_callback, magic); 102 | liq_set_log_callback(attr, test_log_callback_function, magic); 103 | 104 | unsigned char dummy[4] = {0}; 105 | liq_image *img = liq_image_create_rgba(attr, dummy, 1, 1, 0); 106 | assert(img); 107 | 108 | liq_image_add_fixed_color(img, (liq_color){0,0,0,0}); 109 | 110 | liq_result *res = liq_quantize_image(attr, img); 111 | assert(res); 112 | assert(progress_called); 113 | 114 | const liq_palette *pal = liq_get_palette(res); 115 | assert(pal); 116 | assert(pal->count == 1); 117 | 118 | liq_result_destroy(res); 119 | liq_image_destroy(img); 120 | liq_attr_destroy(attr); 121 | } 122 | 123 | static void test_fixed_colors_order() { 124 | liq_attr *attr = liq_attr_create(); 125 | 126 | unsigned char dummy[4] = {0}; 127 | liq_image *img = liq_image_create_rgba(attr, dummy, 1, 1, 0); 128 | assert(img); 129 | 130 | liq_color colors[17] = { 131 | {0,0,0,0}, {1,1,1,1}, {2,2,2,2}, {3,3,3,3}, {4,4,4,4}, {5,4,4,4}, 132 | {6,4,4,4}, {6,7,4,4}, {6,7,8,4}, {6,7,8,9}, {10,7,8,9}, {10,11,8,9}, 133 | {10,11,12,9}, {10,11,12,13}, {14,11,12,13}, {14,15,12,13}, {253,254,255,254}, 134 | }; 135 | 136 | for(int i=0; i < 17; i++) { 137 | liq_image_add_fixed_color(img, colors[i]); 138 | } 139 | 140 | liq_result *res = liq_quantize_image(attr, img); 141 | assert(res); 142 | 143 | const liq_palette *pal = liq_get_palette(res); 144 | assert(pal); 145 | assert(pal->count == 17); 146 | 147 | for(int i=0; i < 17; i++) { 148 | assert(pal->entries[i].r == colors[i].r); 149 | assert(pal->entries[i].g == colors[i].g); 150 | assert(pal->entries[i].b == colors[i].b); 151 | assert(pal->entries[i].a == colors[i].a); 152 | } 153 | 154 | liq_set_dithering_level(res, 1.0); 155 | 156 | char buf[1]; 157 | assert(LIQ_OK == liq_write_remapped_image(res, img, buf, 1)); 158 | 159 | liq_result_set_progress_callback(res, test_abort_callback, magic); 160 | assert(LIQ_ABORTED == liq_write_remapped_image(res, img, buf, 1)); 161 | 162 | liq_result_destroy(res); 163 | liq_image_destroy(img); 164 | liq_attr_destroy(attr); 165 | } 166 | 167 | void run_liq_tests() { 168 | test_fixed_colors(); 169 | test_fixed_colors_order(); 170 | test_abort(); 171 | test_histogram(); 172 | test_zero_histogram(); 173 | } 174 | -------------------------------------------------------------------------------- /src/kmeans.rs: -------------------------------------------------------------------------------- 1 | use crate::hist::{HistItem, HistogramInternal}; 2 | use crate::nearest::Nearest; 3 | use crate::pal::{f_pixel, PalF, PalIndex, PalPop}; 4 | use crate::rayoff::*; 5 | use crate::{CacheLineAlign, Error}; 6 | use core::cell::RefCell; 7 | use rgb::prelude::*; 8 | use rgb::Argb; 9 | 10 | #[cfg(all(not(feature = "std"), feature = "no_std"))] 11 | use crate::no_std_compat::*; 12 | 13 | /// K-Means iteration: new palette color is computed from weighted average of colors that map best to that palette entry. 14 | // avoid false sharing 15 | pub(crate) struct Kmeans { 16 | averages: Vec, 17 | weighed_diff_sum: f64, 18 | } 19 | 20 | #[derive(Copy, Clone, Default)] 21 | struct ColorAvg { 22 | pub sum: Argb, 23 | pub total: f64, 24 | } 25 | 26 | impl Kmeans { 27 | #[inline] 28 | pub fn new(pal_len: usize) -> Result { 29 | let mut averages = Vec::new(); 30 | averages.try_reserve_exact(pal_len)?; 31 | averages.resize(pal_len, ColorAvg::default()); 32 | Ok(Self { 33 | averages, 34 | weighed_diff_sum: 0., 35 | }) 36 | } 37 | 38 | #[inline] 39 | pub fn update_color(&mut self, px: f_pixel, value: f32, matched: PalIndex) { 40 | let c = &mut self.averages[matched as usize]; 41 | c.sum += (px.0 * value).map(f64::from); 42 | c.total += f64::from(value); 43 | } 44 | 45 | pub fn finalize(self, palette: &mut PalF) -> f64 { 46 | for (avg, (color, pop)) in self.averages.iter().zip(palette.iter_mut()).filter(|(_, (_, pop))| !pop.is_fixed()) { 47 | let total = avg.total; 48 | *pop = PalPop::new(total as f32); 49 | if total > 0. && color.a != 0. { 50 | *color = avg.sum.map(move |c| (c / total) as f32).into(); 51 | } 52 | } 53 | self.weighed_diff_sum 54 | } 55 | 56 | #[inline(never)] 57 | pub(crate) fn iteration(hist: &mut HistogramInternal, palette: &mut PalF, adjust_weight: bool) -> Result { 58 | if hist.items.is_empty() { 59 | return Ok(0.); 60 | } 61 | 62 | let n = Nearest::new(palette)?; 63 | let colors = palette.as_slice(); 64 | let len = colors.len(); 65 | 66 | let tls = ThreadLocal::new(); 67 | let total = hist.total_perceptual_weight; 68 | 69 | // chunk size is a trade-off between parallelization and overhead 70 | hist.items.par_chunks_mut(256).for_each_init( 71 | || tls.get_or(move || CacheLineAlign(RefCell::new(Self::new(len)))), 72 | move |kmeans, batch| { 73 | let Ok(mut tls) = kmeans.0.try_borrow_mut() else { 74 | debug_assert!(false); 75 | return; 76 | }; 77 | if let Ok(ref mut kmeans) = *tls { 78 | kmeans.iterate_batch(batch, &n, colors, adjust_weight); 79 | } 80 | }); 81 | 82 | let diff = tls.into_iter() 83 | .map(|c| c.0.into_inner()) 84 | .reduce(Self::try_merge) 85 | .transpose()? 86 | .map_or(0., |kmeans| kmeans.finalize(palette) / total); 87 | 88 | replace_unused_colors(palette, hist)?; 89 | Ok(diff) 90 | } 91 | 92 | fn iterate_batch(&mut self, batch: &mut [HistItem], n: &Nearest, colors: &[f_pixel], adjust_weight: bool) { 93 | self.weighed_diff_sum += batch.iter_mut().map(|item| { 94 | let px = item.color; 95 | let (matched, mut diff) = n.search(&px, item.likely_palette_index()); 96 | item.tmp.likely_palette_index = matched; 97 | if adjust_weight { 98 | let remapped = colors[matched as usize]; 99 | let (_, new_diff) = n.search(&f_pixel(px.0 + px.0 - remapped.0), matched); 100 | debug_assert!(new_diff.is_finite()); 101 | diff = new_diff; 102 | item.adjusted_weight = 2.0f32.mul_add(item.adjusted_weight, item.perceptual_weight) * (0.5 + diff); 103 | } 104 | debug_assert!(f64::from(diff) < 1e20); 105 | self.update_color(px, item.adjusted_weight, matched); 106 | f64::from(diff * item.perceptual_weight) 107 | }).sum::(); 108 | } 109 | 110 | #[inline] 111 | pub fn merge(mut self, new: Self) -> Self { 112 | self.weighed_diff_sum += new.weighed_diff_sum; 113 | self.averages.iter_mut().zip(new.averages).for_each(|(p, n)| { 114 | p.sum += n.sum; 115 | p.total += n.total; 116 | }); 117 | self 118 | } 119 | 120 | #[inline] 121 | pub fn try_merge(old: Result, new: Result) -> Result { 122 | match (old, new) { 123 | (Ok(old), Ok(new)) => Ok(Self::merge(old, new)), 124 | (Err(e), _) | (_, Err(e)) => Err(e), 125 | } 126 | } 127 | } 128 | 129 | /// kmeans may have merged or obsoleted some palette entries. 130 | /// This replaces these entries with histogram colors that are currently least-fitting the palette. 131 | fn replace_unused_colors(palette: &mut PalF, hist: &HistogramInternal) -> Result<(), Error> { 132 | for pal_idx in 0..palette.len() { 133 | let Some(pop) = palette.pop_as_slice().get(pal_idx) else { break }; 134 | if pop.popularity() == 0. && !pop.is_fixed() { 135 | let n = Nearest::new(palette)?; 136 | let mut worst = None; 137 | let mut worst_diff = 0.; 138 | let colors = palette.as_slice(); 139 | // the search is just for diff, ignoring adjusted_weight, 140 | // because the palette already optimizes for the max weight, so it'd likely find another redundant entry. 141 | for item in hist.items.iter() { 142 | // the early reject avoids running full palette search for every entry 143 | let may_be_worst = colors.get(item.likely_palette_index() as usize) 144 | .map_or(true, |pal| pal.diff(&item.color) > worst_diff); 145 | if may_be_worst { 146 | let diff = n.search(&item.color, item.likely_palette_index()).1; 147 | if diff > worst_diff { 148 | worst_diff = diff; 149 | worst = Some(item); 150 | } 151 | } 152 | } 153 | if let Some(worst) = worst { 154 | palette.set(pal_idx, worst.color, PalPop::new(worst.adjusted_weight)); 155 | } 156 | } 157 | } 158 | Ok(()) 159 | } 160 | -------------------------------------------------------------------------------- /src/seacow.rs: -------------------------------------------------------------------------------- 1 | use core::mem::{self, MaybeUninit}; 2 | use core::slice; 3 | 4 | #[cfg(all(not(feature = "std"), feature = "no_std"))] 5 | use std::{boxed::Box, vec::Vec}; 6 | 7 | #[cfg(feature = "_internal_c_ffi")] 8 | use core::ffi::c_void; 9 | 10 | #[derive(Clone)] 11 | pub struct SeaCow<'a, T> { 12 | inner: SeaCowInner<'a, T>, 13 | } 14 | 15 | unsafe impl Send for SeaCowInner<'_, T> {} 16 | unsafe impl Sync for SeaCowInner<'_, T> {} 17 | 18 | /// Rust assumes `*const T` is never `Send`/`Sync`, but it can be. 19 | /// This is fudge for https://github.com/rust-lang/rust/issues/93367 20 | #[repr(transparent)] 21 | #[derive(Copy, Clone)] 22 | pub(crate) struct Pointer(pub *const T); 23 | 24 | #[derive(Copy, Clone)] 25 | #[repr(transparent)] 26 | pub(crate) struct PointerMut(pub *mut T); 27 | 28 | unsafe impl Send for Pointer {} 29 | unsafe impl Sync for Pointer {} 30 | unsafe impl Send for PointerMut {} 31 | unsafe impl Sync for PointerMut {} 32 | 33 | impl SeaCow<'static, T> { 34 | #[inline] 35 | #[must_use] 36 | pub fn boxed(data: Box<[T]>) -> Self { 37 | Self { inner: SeaCowInner::Boxed(data) } 38 | } 39 | } 40 | 41 | impl<'a, T> SeaCow<'a, T> { 42 | #[inline] 43 | #[must_use] 44 | pub const fn borrowed(data: &'a [T]) -> Self { 45 | Self { inner: SeaCowInner::Borrowed(data) } 46 | } 47 | 48 | /// The pointer must be `malloc`-allocated 49 | #[inline] 50 | #[cfg(feature = "_internal_c_ffi")] 51 | #[must_use] 52 | pub unsafe fn c_owned(ptr: *mut T, len: usize, free_fn: unsafe extern "C" fn(*mut c_void)) -> Self { 53 | debug_assert!(!ptr.is_null()); 54 | debug_assert!(len > 0); 55 | 56 | Self { 57 | inner: SeaCowInner::Owned { ptr, len, free_fn }, 58 | } 59 | } 60 | 61 | #[inline] 62 | #[cfg(feature = "_internal_c_ffi")] 63 | pub(crate) fn make_owned(&mut self, free_fn: unsafe extern "C" fn(*mut c_void)) { 64 | if let SeaCowInner::Borrowed(slice) = self.inner { 65 | self.inner = SeaCowInner::Owned { ptr: slice.as_ptr().cast_mut(), len: slice.len(), free_fn }; 66 | } 67 | } 68 | } 69 | 70 | impl Clone for SeaCowInner<'_, T> { 71 | #[inline(never)] 72 | fn clone(&self) -> Self { 73 | let slice = match self { 74 | Self::Borrowed(data) => return Self::Borrowed(data), 75 | #[cfg(feature = "_internal_c_ffi")] 76 | Self::Owned { ptr, len, free_fn: _ } => unsafe { slice::from_raw_parts(*ptr, *len) }, 77 | Self::Boxed(data) => &**data, 78 | }; 79 | let mut v = Vec::new(); 80 | v.try_reserve_exact(slice.len()).unwrap(); 81 | v.extend_from_slice(slice); 82 | Self::Boxed(v.into_boxed_slice()) 83 | } 84 | } 85 | 86 | enum SeaCowInner<'a, T> { 87 | #[cfg(feature = "_internal_c_ffi")] 88 | Owned { ptr: *mut T, len: usize, free_fn: unsafe extern "C" fn(*mut c_void) }, 89 | Borrowed(&'a [T]), 90 | Boxed(Box<[T]>), 91 | } 92 | 93 | #[cfg(feature = "_internal_c_ffi")] 94 | impl Drop for SeaCowInner<'_, T> { 95 | fn drop(&mut self) { 96 | if let Self::Owned { ptr, free_fn, .. } = self { 97 | unsafe { 98 | (free_fn)((*ptr).cast()); 99 | } 100 | } 101 | } 102 | } 103 | 104 | impl SeaCow<'_, T> { 105 | #[must_use] 106 | pub fn as_slice(&self) -> &[T] { 107 | match &self.inner { 108 | #[cfg(feature = "_internal_c_ffi")] 109 | SeaCowInner::Owned { ptr, len, .. } => unsafe { slice::from_raw_parts(*ptr, *len) }, 110 | SeaCowInner::Borrowed(a) => a, 111 | SeaCowInner::Boxed(x) => x, 112 | } 113 | } 114 | } 115 | 116 | pub(crate) struct RowBitmap<'a, T> { 117 | rows: &'a [Pointer], 118 | width: usize, 119 | } 120 | unsafe impl Send for RowBitmap<'_, T> {} 121 | 122 | pub(crate) struct RowBitmapMut<'a, T> { 123 | rows: MutCow<'a, [PointerMut]>, 124 | width: usize, 125 | } 126 | unsafe impl Send for RowBitmapMut<'_, T> {} 127 | 128 | impl RowBitmapMut<'_, MaybeUninit> { 129 | #[inline] 130 | pub(crate) unsafe fn assume_init<'maybeowned>(&'maybeowned mut self) -> RowBitmap<'maybeowned, T> { 131 | #[allow(clippy::transmute_ptr_to_ptr)] 132 | RowBitmap { 133 | width: self.width, 134 | rows: mem::transmute::<&'maybeowned [PointerMut>], &'maybeowned [Pointer]>(self.rows.borrow_mut()), 135 | } 136 | } 137 | } 138 | 139 | impl RowBitmap<'_, T> { 140 | pub fn rows(&self) -> impl Iterator { 141 | let width = self.width; 142 | self.rows.iter().map(move |row| { 143 | unsafe { slice::from_raw_parts(row.0, width) } 144 | }) 145 | } 146 | } 147 | 148 | enum MutCow<'a, T: ?Sized> { 149 | Owned(Box), 150 | #[allow(dead_code)] /// This is optional, for FFI only 151 | Borrowed(&'a mut T), 152 | } 153 | 154 | impl MutCow<'_, T> { 155 | #[must_use] 156 | pub fn borrow_mut(&mut self) -> &mut T { 157 | match self { 158 | Self::Owned(a) => a, 159 | Self::Borrowed(a) => a, 160 | } 161 | } 162 | } 163 | 164 | impl<'a, T: Sync + Send + Copy + 'static> RowBitmapMut<'a, T> { 165 | #[inline] 166 | #[must_use] 167 | pub fn new_contiguous(data: &mut [T], width: usize) -> Self { 168 | Self { 169 | rows: MutCow::Owned(data.chunks_exact_mut(width).map(|r| PointerMut(r.as_mut_ptr())).collect()), 170 | width, 171 | } 172 | } 173 | 174 | /// Inner pointers must be valid for `'a` too, and at least `width` large each 175 | #[inline] 176 | #[cfg(feature = "_internal_c_ffi")] 177 | #[must_use] 178 | pub unsafe fn new(rows: &'a mut [*mut T], width: usize) -> Self { 179 | Self { 180 | rows: MutCow::Borrowed(&mut *(rows as *mut [*mut T] as *mut [PointerMut])), 181 | width, 182 | } 183 | } 184 | 185 | pub fn rows_mut(&mut self) -> impl Iterator + Send { 186 | let width = self.width; 187 | self.rows.borrow_mut().iter().map(move |row| { 188 | unsafe { slice::from_raw_parts_mut(row.0, width) } 189 | }) 190 | } 191 | 192 | pub(crate) fn chunks(&mut self, chunk_size: usize) -> impl Iterator> { 193 | self.rows.borrow_mut().chunks_mut(chunk_size).map(|chunk| RowBitmapMut { 194 | width: self.width, 195 | rows: MutCow::Borrowed(chunk), 196 | }) 197 | } 198 | 199 | #[must_use] 200 | pub(crate) fn len(&mut self) -> usize { 201 | self.rows.borrow_mut().len() 202 | } 203 | } 204 | -------------------------------------------------------------------------------- /imagequant-sys/org/pngquant/PngQuant.c: -------------------------------------------------------------------------------- 1 | #include "org/pngquant/PngQuant.h" 2 | #include "org/pngquant/Image.h" 3 | #include "org/pngquant/Result.h" 4 | #include "libimagequant.h" 5 | #include 6 | 7 | typedef struct { 8 | liq_image *image; 9 | jbyte *data; 10 | } liq_jni_image; 11 | 12 | static void *handle(JNIEnv *env, jobject obj) { 13 | jlong h = (*env)->GetLongField(env, obj, (*env)->GetFieldID(env, (*env)->GetObjectClass(env, obj), "handle", "J")); 14 | return (void*)h; 15 | } 16 | 17 | JNIEXPORT jlong JNICALL Java_org_pngquant_PngQuant_liq_1attr_1create(JNIEnv *env, jclass class) { 18 | return (jlong)liq_attr_create(); 19 | } 20 | 21 | JNIEXPORT jlong JNICALL Java_org_pngquant_PngQuant_liq_1attr_1copy(JNIEnv *env, jclass class, jlong attr) { 22 | return (jlong)liq_attr_copy((liq_attr*)attr); 23 | } 24 | 25 | JNIEXPORT void JNICALL Java_org_pngquant_PngQuant_liq_1attr_1destroy(JNIEnv *env, jclass class, jlong attr) { 26 | return liq_attr_destroy((liq_attr*)attr); 27 | } 28 | 29 | JNIEXPORT jboolean JNICALL Java_org_pngquant_PngQuant_setMaxColors(JNIEnv *env, jobject obj, jint colors) { 30 | return LIQ_OK == liq_set_max_colors(handle(env, obj), colors); 31 | } 32 | 33 | JNIEXPORT jboolean JNICALL Java_org_pngquant_PngQuant_setSpeed(JNIEnv *env, jobject obj, jint speed) { 34 | return LIQ_OK == liq_set_speed(handle(env, obj), speed); 35 | } 36 | 37 | JNIEXPORT jboolean JNICALL Java_org_pngquant_PngQuant_setMinPosterization(JNIEnv *env, jobject obj, jint p) { 38 | return LIQ_OK == liq_set_min_posterization(handle(env, obj), p); 39 | } 40 | 41 | JNIEXPORT jboolean JNICALL Java_org_pngquant_PngQuant_setQuality__I(JNIEnv *env, jobject obj, jint q) { 42 | return LIQ_OK == liq_set_quality(handle(env, obj), q/2, q); 43 | } 44 | 45 | JNIEXPORT jboolean JNICALL Java_org_pngquant_PngQuant_setQuality__II(JNIEnv *env, jobject obj, jint qmin, jint qmax) { 46 | return LIQ_OK == liq_set_quality(handle(env, obj), qmin, qmax); 47 | } 48 | 49 | static void convert_abgr(liq_color row_out[], int row_index, int width, void* user_info) { 50 | liq_jni_image *jniimg = user_info; 51 | int column_index; 52 | for(column_index=0; column_index < width; column_index++) { 53 | row_out[column_index].r = jniimg->data[4*(width*row_index + column_index) + 3]; 54 | row_out[column_index].g = jniimg->data[4*(width*row_index + column_index) + 2]; 55 | row_out[column_index].b = jniimg->data[4*(width*row_index + column_index) + 1]; 56 | row_out[column_index].a = jniimg->data[4*(width*row_index + column_index) + 0]; 57 | } 58 | } 59 | 60 | static void convert_bgr(liq_color row_out[], int row_index, int width, void* user_info) { 61 | liq_jni_image *jniimg = user_info; 62 | int column_index; 63 | for(column_index=0; column_index < width; column_index++) { 64 | row_out[column_index].r = jniimg->data[3*(width*row_index + column_index) + 2]; 65 | row_out[column_index].g = jniimg->data[3*(width*row_index + column_index) + 1]; 66 | row_out[column_index].b = jniimg->data[3*(width*row_index + column_index) + 0]; 67 | row_out[column_index].a = 255; 68 | } 69 | } 70 | 71 | JNIEXPORT jlong JNICALL Java_org_pngquant_Image_liq_1image_1create(JNIEnv *env, jclass class, jlong attr, jbyteArray bytearray, jint w, jint h, jint components) { 72 | /* liq_image needs to be wrapped to keep track of allocated buffer */ 73 | liq_jni_image *jniimg = malloc(sizeof(liq_jni_image)); 74 | 75 | /* copying buffer, since ReleaseByteArrayElements was crashing when called from finalize() */ 76 | jsize size = (*env)->GetArrayLength(env, bytearray); 77 | jniimg->data = malloc(size); 78 | (*env)->GetByteArrayRegion(env, bytearray, 0, size, jniimg->data); 79 | 80 | jniimg->image = liq_image_create_custom((liq_attr*)attr, components == 4 ? convert_abgr : convert_bgr, jniimg, w, h, 0); 81 | 82 | if (!jniimg->image) { 83 | free(jniimg->data); 84 | free(jniimg); 85 | return 0; 86 | } 87 | return (jlong)jniimg; 88 | } 89 | 90 | JNIEXPORT jboolean JNICALL Java_org_pngquant_Image_addFixedColor(JNIEnv *env, jobject obj, jint r, jint g, jint b, jint a) { 91 | liq_color c = {r,g,b,a}; 92 | return LIQ_OK == liq_image_add_fixed_color(((liq_jni_image*)handle(env,obj))->image, c); 93 | } 94 | 95 | JNIEXPORT jint JNICALL Java_org_pngquant_Image_getWidth(JNIEnv *env, jobject obj) { 96 | return liq_image_get_width(((liq_jni_image*)handle(env,obj))->image); 97 | } 98 | 99 | JNIEXPORT jint JNICALL Java_org_pngquant_Image_getHeight(JNIEnv *env, jobject obj) { 100 | return liq_image_get_height(((liq_jni_image*)handle(env,obj))->image); 101 | } 102 | 103 | JNIEXPORT void JNICALL Java_org_pngquant_Image_liq_1image_1destroy(JNIEnv *env, jclass class, jlong handle) { 104 | liq_jni_image *jniimg = (liq_jni_image*)handle; 105 | liq_image_destroy(jniimg->image); 106 | free(jniimg->data); 107 | free(jniimg); 108 | } 109 | 110 | JNIEXPORT jlong JNICALL Java_org_pngquant_Result_liq_1quantize_1image(JNIEnv *env, jclass class, jlong attr, jlong handle) { 111 | return (jlong)liq_quantize_image((liq_attr*)attr, ((liq_jni_image*)handle)->image); 112 | } 113 | 114 | JNIEXPORT jboolean JNICALL Java_org_pngquant_Result_setDitheringLevel(JNIEnv *env, jobject obj, jfloat l) { 115 | return LIQ_OK == liq_set_dithering_level(handle(env, obj), l); 116 | } 117 | 118 | JNIEXPORT jboolean JNICALL Java_org_pngquant_Result_setGamma(JNIEnv *env, jobject obj, jdouble gamma) { 119 | return LIQ_OK == liq_set_output_gamma(handle(env, obj), gamma); 120 | } 121 | 122 | JNIEXPORT jdouble JNICALL Java_org_pngquant_Result_getGamma(JNIEnv *env, jobject obj) { 123 | return liq_get_output_gamma(handle(env, obj)); 124 | } 125 | 126 | JNIEXPORT jboolean JNICALL Java_org_pngquant_Result_liq_1write_1remapped_1image(JNIEnv *env, jclass class, jlong result, jlong image_handle, jbyteArray bytearray) { 127 | jsize size = (*env)->GetArrayLength(env, bytearray); 128 | 129 | jbyte *bitmap = (*env)->GetByteArrayElements(env, bytearray, 0); 130 | liq_error err = liq_write_remapped_image((liq_result*)result, ((liq_jni_image*)image_handle)->image, bitmap, size); 131 | (*env)->ReleaseByteArrayElements(env, bytearray, bitmap, 0); 132 | 133 | return LIQ_OK == err; 134 | } 135 | 136 | JNIEXPORT jdouble JNICALL Java_org_pngquant_Result_getMeanSquareError(JNIEnv *env, jobject obj) { 137 | return liq_get_quantization_error(handle(env, obj)); 138 | } 139 | 140 | JNIEXPORT jint JNICALL Java_org_pngquant_Result_getQuality(JNIEnv *env, jobject obj) { 141 | return liq_get_quantization_quality(handle(env, obj)); 142 | } 143 | 144 | JNIEXPORT void JNICALL Java_org_pngquant_Result_liq_1result_1destroy(JNIEnv *env, jclass class, jlong result) { 145 | return liq_result_destroy((liq_result*)result); 146 | } 147 | 148 | JNIEXPORT jbyteArray JNICALL Java_org_pngquant_Result_liq_1get_1palette(JNIEnv *env, jclass class, jlong result) { 149 | const liq_palette *pal = liq_get_palette((liq_result*)result); 150 | jbyteArray arr = (*env)->NewByteArray(env, pal->count * 4); 151 | int i; 152 | for(i=0; i < pal->count; i++) { 153 | (*env)->SetByteArrayRegion(env, arr, i*4, 4, ((jbyte*)&pal->entries[i])); 154 | } 155 | return arr; 156 | } 157 | -------------------------------------------------------------------------------- /imagequant-sys/libimagequant.cs: -------------------------------------------------------------------------------- 1 | /* 2 | This is an example demonstrating use of libimagequant from C#. 3 | 4 | This example code can be freely copied under CC0 (public domain) license. 5 | */ 6 | 7 | using System; 8 | using System.Collections.Generic; 9 | using System.Runtime.InteropServices; 10 | 11 | [StructLayout(LayoutKind.Sequential)] 12 | struct liq_color 13 | { 14 | public byte r, g, b, a; 15 | }; 16 | 17 | [StructLayout(LayoutKind.Sequential)] 18 | struct liq_palette 19 | { 20 | public int count; 21 | [MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)] 22 | public liq_color[] entries; 23 | }; 24 | 25 | enum liq_error 26 | { 27 | LIQ_OK = 0, 28 | LIQ_QUALITY_TOO_LOW = 99, 29 | LIQ_VALUE_OUT_OF_RANGE = 100, 30 | LIQ_OUT_OF_MEMORY, 31 | LIQ_ABORTED, 32 | LIQ_BITMAP_NOT_AVAILABLE, 33 | LIQ_BUFFER_TOO_SMALL, 34 | LIQ_INVALID_POINTER, 35 | }; 36 | 37 | namespace liq 38 | { 39 | using liq_attr_ptr = IntPtr; 40 | using liq_image_ptr = IntPtr; 41 | using liq_result_ptr = IntPtr; 42 | using size_t = UIntPtr; 43 | 44 | class Liq 45 | { 46 | [DllImport(@"imagequant.dll")] 47 | public static extern liq_attr_ptr liq_attr_create(); 48 | [DllImport(@"imagequant.dll")] 49 | public static extern liq_attr_ptr liq_attr_copy(liq_attr_ptr attr); 50 | [DllImport(@"imagequant.dll")] 51 | public static extern void liq_attr_destroy(liq_attr_ptr attr); 52 | 53 | [DllImport(@"imagequant.dll")] 54 | public static extern liq_error liq_set_max_colors(liq_attr_ptr attr, int colors); 55 | [DllImport(@"imagequant.dll")] 56 | public static extern int liq_get_max_colors(liq_attr_ptr attr); 57 | [DllImport(@"imagequant.dll")] 58 | public static extern liq_error liq_set_speed(liq_attr_ptr attr, int speed); 59 | [DllImport(@"imagequant.dll")] 60 | public static extern int liq_get_speed(liq_attr_ptr attr); 61 | [DllImport(@"imagequant.dll")] 62 | public static extern liq_error liq_set_min_opacity(liq_attr_ptr attr, int min); 63 | [DllImport(@"imagequant.dll")] 64 | public static extern int liq_get_min_opacity(liq_attr_ptr attr); 65 | [DllImport(@"imagequant.dll")] 66 | public static extern liq_error liq_set_min_posterization(liq_attr_ptr attr, int bits); 67 | [DllImport(@"imagequant.dll")] 68 | public static extern int liq_get_min_posterization(liq_attr_ptr attr); 69 | [DllImport(@"imagequant.dll")] 70 | public static extern liq_error liq_set_quality(liq_attr_ptr attr, int minimum, int maximum); 71 | [DllImport(@"imagequant.dll")] 72 | public static extern int liq_get_min_quality(liq_attr_ptr attr); 73 | [DllImport(@"imagequant.dll")] 74 | public static extern int liq_get_max_quality(liq_attr_ptr attr); 75 | [DllImport(@"imagequant.dll")] 76 | public static extern void liq_set_last_index_transparent(liq_attr_ptr attr, int is_last); 77 | 78 | [DllImport(@"imagequant.dll")] 79 | public static extern liq_image_ptr liq_image_create_rgba(liq_attr_ptr attr, [In, MarshalAs(UnmanagedType.LPArray)] byte[] bitmap, int width, int height, double gamma); 80 | 81 | [DllImport(@"imagequant.dll")] 82 | public static extern liq_error liq_image_set_memory_ownership(liq_image_ptr image, int ownership_flags); 83 | [DllImport(@"imagequant.dll")] 84 | public static extern liq_error liq_image_add_fixed_color(liq_image_ptr img, liq_color color); 85 | [DllImport(@"imagequant.dll")] 86 | public static extern int liq_image_get_width(liq_image_ptr img); 87 | [DllImport(@"imagequant.dll")] 88 | public static extern int liq_image_get_height(liq_image_ptr img); 89 | [DllImport(@"imagequant.dll")] 90 | public static extern void liq_image_destroy(liq_image_ptr img); 91 | 92 | [DllImport(@"imagequant.dll")] 93 | public static extern liq_result_ptr liq_quantize_image(liq_attr_ptr attr, liq_image_ptr input_image); 94 | 95 | [DllImport(@"imagequant.dll")] 96 | public static extern liq_error liq_set_dithering_level(liq_result_ptr res, float dither_level); 97 | [DllImport(@"imagequant.dll")] 98 | public static extern liq_error liq_set_output_gamma(liq_result_ptr res, double gamma); 99 | [DllImport(@"imagequant.dll")] 100 | public static extern double liq_get_output_gamma(liq_result_ptr res); 101 | 102 | [DllImport(@"imagequant.dll")] 103 | public static extern IntPtr liq_get_palette(liq_result_ptr res); 104 | 105 | [DllImport(@"imagequant.dll")] 106 | public static extern liq_error liq_write_remapped_image(liq_result_ptr res, liq_image_ptr input_image, [Out, MarshalAs(UnmanagedType.LPArray)] byte[] buffer, size_t buffer_size); 107 | 108 | [DllImport(@"imagequant.dll")] 109 | public static extern double liq_get_quantization_error(liq_result_ptr res); 110 | [DllImport(@"imagequant.dll")] 111 | public static extern int liq_get_quantization_quality(liq_result_ptr res); 112 | [DllImport(@"imagequant.dll")] 113 | public static extern double liq_get_remapping_error(liq_result_ptr res); 114 | [DllImport(@"imagequant.dll")] 115 | public static extern int liq_get_remapping_quality(liq_result_ptr res); 116 | 117 | [DllImport(@"imagequant.dll")] 118 | public static extern void liq_result_destroy(liq_result_ptr res); 119 | 120 | [DllImport(@"imagequant.dll")] 121 | public static extern int liq_version(); 122 | 123 | static void Main(string[] args) 124 | { 125 | Console.WriteLine("library version: {0}", liq_version()); 126 | 127 | int width = 3; 128 | int height = 1; 129 | 130 | var attr = liq_attr_create(); 131 | if (attr == IntPtr.Zero) throw new Exception("can't create attr"); 132 | 133 | byte[] bitmap = { // R, G, B, A, R, G, B, A, ... 134 | 111, 222, 33, 255, 135 | 255, 0, 255, 255, 136 | 255, 0, 255, 255, 137 | }; 138 | var img = liq_image_create_rgba(attr, bitmap, width, height, 0); 139 | if (img == IntPtr.Zero) throw new Exception("can't create image"); 140 | 141 | var res = liq_quantize_image(attr, img); 142 | if (res == IntPtr.Zero) throw new Exception("can't quantize image"); 143 | 144 | var buffer_size = width * height; 145 | var remapped = new byte[buffer_size]; 146 | 147 | var err = liq_write_remapped_image(res, img, remapped, (UIntPtr)buffer_size); 148 | if (err != liq_error.LIQ_OK) 149 | { 150 | throw new Exception("remapping error"); 151 | } 152 | 153 | Console.WriteLine("first pixel is {0}th palette entry", remapped[0]); 154 | 155 | liq_palette pal = (liq_palette)Marshal.PtrToStructure(liq_get_palette(res), typeof(liq_palette)); 156 | 157 | Console.WriteLine("palette entries: {0}; red of first entry: {1}", pal.count, pal.entries[0].r); 158 | 159 | liq_image_destroy(img); 160 | liq_result_destroy(res); 161 | liq_attr_destroy(attr); 162 | } 163 | } 164 | } 165 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # [libimagequant](https://pngquant.org/lib/) — Image Quantization Library 2 | 3 | Imagequant library converts RGBA images to palette-based 8-bit indexed images, *including* alpha component. It's ideal for generating tiny PNG images and [nice-looking GIFs](https://gif.ski). 4 | 5 | Image encoding/decoding isn't handled by the library itself, bring your own encoder. If you're looking for a command-line tool, see [pngquant](https://pngquant.org). 6 | 7 | ## Getting started in C 8 | 9 | This library can be used in C programs via [imagequant-sys](https://github.com/ImageOptim/libimagequant/tree/main/imagequant-sys) [Rust](https://www.rust-lang.org/) package. 10 | 11 | ```bash 12 | rustup update 13 | git clone https://github.com/ImageOptim/libimagequant 14 | cd libimagequant/imagequant-sys 15 | cargo build --release --target-dir=target 16 | # makes target/release/libimagequant_sys.a 17 | ``` 18 | 19 | See [the C library API documentation](https://pngquant.org/lib/) and [the readme](https://lib.rs/imagequant-sys) for more info. 20 | 21 | ## Getting started in Rust 22 | 23 | Add to `Cargo.toml`: 24 | 25 | ```bash 26 | rustup update 27 | cargo add imagequant 28 | ``` 29 | 30 | [See docs.rs for the library API documentation](https://docs.rs/imagequant). 31 | 32 | ## License 33 | 34 | Libimagequant is dual-licensed: 35 | 36 | * For Free/Libre Open Source Software it's available under GPL v3 or later with additional [copyright notices](https://raw.github.com/ImageOptim/libimagequant/master/COPYRIGHT) for historical reasons. 37 | * For use in closed-source software, AppStore distribution, and other non-GPL uses, you can [obtain a commercial license](https://supso.org/projects/pngquant). Feel free to ask kornel@pngquant.org for details and custom licensing terms if you need them. 38 | 39 | ## Upgrading instructions 40 | 41 | libimagequant v2 used to be a C library. libimagequant v4 is written entirely in Rust, but still exports the same C interface for C programs. You will need to install Rust 1.70+ to build it, and adjust your build commands. If you do not want to upgrade, you can keep using [the C version of the library](https://github.com/imageoptim/libimagequant/tree/2.x) in the `2.x` branch of the [repo](https://github.com/ImageOptim/libimagequant). 42 | 43 | ### C static library users 44 | 45 | Files for C/C++ are now in the `imagequant-sys/` subdirectory, not in the root of the repo. There is no `configure && make` any more. 46 | 47 | To build the library, install [Rust via rustup](https://rustup.rs), and run: 48 | 49 | ```bash 50 | rustup update 51 | cd imagequant-sys 52 | cargo build --release 53 | ``` 54 | 55 | It produces `target/release/libimagequant_sys.a` static library. The API, ABI, and header files remain the same, so everything else should work the same. 56 | If you're building for macOS or iOS, see included xcodeproj file (add it as a [subproject](https://gitlab.com/kornelski/cargo-xcode#usage) to yours). 57 | 58 | If you're building for Android, run `rustup target add aarch64-linux-android; cargo build --release --target aarch64-linux-android` and use `target/aarch64-linux-android/release/libimagequant_sys.a`. Same for cross-compiling to other platforms. See `rustup target list`. 59 | 60 | See [imagequant-sys readme](https://lib.rs/imagequant-sys#readme-building-for-c) for instructions how to make smaller builds. 61 | 62 | ### C dynamic library for package maintainers 63 | 64 | If you're an application developer, please use the static linking option above — that option is much easier, and gives smaller executables. 65 | 66 | The API and ABI of this library remains the same. It has the same sover, so it can be a drop-in replacement for the previous C version. 67 | 68 | This library is now a typical Rust/Cargo library. If you want to set up [off-line builds](https://doc.rust-lang.org/cargo/faq.html#how-can-cargo-work-offline) or [override dependencies](https://doc.rust-lang.org/cargo/reference/overriding-dependencies.html), it works the same as for every other Rust project. See [Cargo docs](https://doc.rust-lang.org/cargo/) for things like [`cargo fetch`](https://doc.rust-lang.org/cargo/commands/cargo-fetch.html) or [`cargo vendor`](https://doc.rust-lang.org/cargo/commands/cargo-vendor.html) (but I don't recommend vendoring). 69 | 70 | If you want to build a dynamic library, but aren't bothered by soname and rpath being wrong, modify `imagequant-sys/Cargo.toml` and add `"cdylib"` to the existing `crate-type` property, and then `cargo build --release` will do its usual half-finished job and build `target/release/libimagequant.{so,dylib,dll}`. 71 | 72 | #### Building with `make` 73 | 74 | `configure && make` is gone. I hoped I could build a dynamic library just by wrapping the static library, but apparently that won't work, so I can't easily recreate the old `make install`. I wish there was a more standard and lightweight solution than using the `cargo-c` tool, so if you're good at wrangling linker flags and symbol visibility, please send pull requests. 75 | 76 | #### Building with `cargo-c` 77 | 78 | The [`cargo-c`](https://lib.rs/cargo-c) tool knows how to build and link so/dylib properly, and generates an accurate pkg-config file, so it's de-facto required for a correct system-wide install of a dynamic library. 79 | 80 | ```bash 81 | rustup update 82 | cd imagequant-sys 83 | cargo install cargo-c 84 | cargo cinstall --prefix=/usr/local --destdir=. 85 | ``` 86 | 87 | This makes Rust 1.70 and `cargo-c` package a build-time dependency. No runtime deps (apart from Cargo-internal ones). OpenMP has been dropped entirely. 88 | 89 | #### Interaction with pngquant 90 | 91 | pngquant v2 can use this library as a dynamic library. However, pngquant v4 does not support unbundling. It uses this library as a Cargo dependency via its Rust-native interface. The shared libimagequant library exports only a stable ABI for C programs, and this interface is not useful for Rust programs. 92 | 93 | ### Upgrading for Rust users 94 | 95 | If you've used the [`imagequant-sys`](https://lib.rs/imagequant-sys) crate, switch to the higher-level [`imagequant`](https://lib.rs/imagequant) crate. The `imagequant` v4 is almost entirely backwards-compatible, with small changes that the Rust compiler will point out (e.g. changed use of `c_int` to `u32`). See [docs](https://docs.rs/imagequant). Please fix any deprecation warnings you may get, because the deprecated functions will be removed. 96 | 97 | The `openmp` Cargo feature has been renamed to `threads`. 98 | 99 | `.new_image()` can now take ownership of its argument to avoid copying. If you get an error that `From<&Vec>` is not implemented, then either don't pass by reference (moves, avoids copying), or call `.as_slice()` on it (to copy the pixels), or use `.new_image_borrowed()` method instead. 100 | 101 | ### Threads support and WASM 102 | 103 | By default, when the `threads` Cargo feature is enabled, this library uses multi-threading. Number of threads can be controlled via `RAYON_NUM_THREADS` environment variable. 104 | 105 | Threads in WASM are experimental, and require [special handling](https://github.com/RReverser/wasm-bindgen-rayon). If you're targeting WASM, you'll most likely want to disable threads. 106 | 107 | To disable threads when using this library as a dependency, disable default features like this in `Cargo.toml`: 108 | 109 | ```toml 110 | [dependencies] 111 | imagequant = { version = "4.0", default-features = false } 112 | ``` 113 | 114 | When you compile the library directly, add `--no-default-features` flag instead. 115 | 116 | -------------------------------------------------------------------------------- /imagequant-sys/libimagequant.h: -------------------------------------------------------------------------------- 1 | /* 2 | * https://pngquant.org 3 | */ 4 | 5 | #ifndef LIBIMAGEQUANT_H 6 | #define LIBIMAGEQUANT_H 7 | 8 | #ifdef IMAGEQUANT_EXPORTS 9 | #define LIQ_EXPORT __declspec(dllexport) 10 | #endif 11 | 12 | #ifndef LIQ_EXPORT 13 | #define LIQ_EXPORT extern 14 | #endif 15 | 16 | #define LIQ_VERSION 40003 17 | #define LIQ_VERSION_STRING "4.0.3" 18 | 19 | #ifndef LIQ_PRIVATE 20 | #if defined(__GNUC__) || defined (__llvm__) 21 | #define LIQ_PRIVATE __attribute__((visibility("hidden"))) 22 | #define LIQ_NONNULL __attribute__((nonnull)) 23 | #define LIQ_USERESULT __attribute__((warn_unused_result)) 24 | #else 25 | #define LIQ_PRIVATE 26 | #define LIQ_NONNULL 27 | #define LIQ_USERESULT 28 | #endif 29 | #endif 30 | 31 | #ifdef __cplusplus 32 | extern "C" { 33 | #endif 34 | 35 | #include 36 | 37 | typedef struct liq_attr liq_attr; 38 | typedef struct liq_image liq_image; 39 | typedef struct liq_result liq_result; 40 | typedef struct liq_histogram liq_histogram; 41 | 42 | typedef struct liq_color { 43 | unsigned char r, g, b, a; 44 | } liq_color; 45 | 46 | typedef struct liq_palette { 47 | unsigned int count; 48 | liq_color entries[256]; 49 | } liq_palette; 50 | 51 | typedef enum liq_error { 52 | LIQ_OK = 0, 53 | LIQ_QUALITY_TOO_LOW = 99, 54 | LIQ_VALUE_OUT_OF_RANGE = 100, 55 | LIQ_OUT_OF_MEMORY, 56 | LIQ_ABORTED, 57 | LIQ_BITMAP_NOT_AVAILABLE, 58 | LIQ_BUFFER_TOO_SMALL, 59 | LIQ_INVALID_POINTER, 60 | LIQ_UNSUPPORTED, 61 | } liq_error; 62 | 63 | enum liq_ownership { 64 | LIQ_OWN_ROWS=4, 65 | LIQ_OWN_PIXELS=8, 66 | LIQ_COPY_PIXELS=16, 67 | }; 68 | 69 | typedef struct liq_histogram_entry { 70 | liq_color color; 71 | unsigned int count; 72 | } liq_histogram_entry; 73 | 74 | LIQ_EXPORT LIQ_USERESULT liq_attr* liq_attr_create(void); 75 | LIQ_EXPORT LIQ_USERESULT liq_attr* liq_attr_create_with_allocator(void* removed, void *unsupported); 76 | LIQ_EXPORT LIQ_USERESULT liq_attr* liq_attr_copy(const liq_attr *orig) LIQ_NONNULL; 77 | LIQ_EXPORT void liq_attr_destroy(liq_attr *attr) LIQ_NONNULL; 78 | 79 | LIQ_EXPORT LIQ_USERESULT liq_histogram* liq_histogram_create(const liq_attr* attr); 80 | LIQ_EXPORT liq_error liq_histogram_add_image(liq_histogram *hist, const liq_attr *attr, liq_image* image) LIQ_NONNULL; 81 | LIQ_EXPORT liq_error liq_histogram_add_colors(liq_histogram *hist, const liq_attr *attr, const liq_histogram_entry entries[], int num_entries, double gamma) LIQ_NONNULL; 82 | LIQ_EXPORT liq_error liq_histogram_add_fixed_color(liq_histogram *hist, liq_color color, double gamma) LIQ_NONNULL; 83 | LIQ_EXPORT void liq_histogram_destroy(liq_histogram *hist) LIQ_NONNULL; 84 | 85 | LIQ_EXPORT liq_error liq_set_max_colors(liq_attr* attr, int colors) LIQ_NONNULL; 86 | LIQ_EXPORT LIQ_USERESULT int liq_get_max_colors(const liq_attr* attr) LIQ_NONNULL; 87 | LIQ_EXPORT liq_error liq_set_speed(liq_attr* attr, int speed) LIQ_NONNULL; 88 | LIQ_EXPORT LIQ_USERESULT int liq_get_speed(const liq_attr* attr) LIQ_NONNULL; 89 | LIQ_EXPORT liq_error liq_set_min_opacity(liq_attr* attr, int min) LIQ_NONNULL; 90 | LIQ_EXPORT LIQ_USERESULT int liq_get_min_opacity(const liq_attr* attr) LIQ_NONNULL; 91 | LIQ_EXPORT liq_error liq_set_min_posterization(liq_attr* attr, int bits) LIQ_NONNULL; 92 | LIQ_EXPORT LIQ_USERESULT int liq_get_min_posterization(const liq_attr* attr) LIQ_NONNULL; 93 | LIQ_EXPORT liq_error liq_set_quality(liq_attr* attr, int minimum, int maximum) LIQ_NONNULL; 94 | LIQ_EXPORT LIQ_USERESULT int liq_get_min_quality(const liq_attr* attr) LIQ_NONNULL; 95 | LIQ_EXPORT LIQ_USERESULT int liq_get_max_quality(const liq_attr* attr) LIQ_NONNULL; 96 | LIQ_EXPORT void liq_set_last_index_transparent(liq_attr* attr, int is_last) LIQ_NONNULL; 97 | 98 | typedef void liq_log_callback_function(const liq_attr*, const char *message, void* user_info); 99 | typedef void liq_log_flush_callback_function(const liq_attr*, void* user_info); 100 | LIQ_EXPORT void liq_set_log_callback(liq_attr*, liq_log_callback_function*, void* user_info); 101 | LIQ_EXPORT void liq_set_log_flush_callback(liq_attr*, liq_log_flush_callback_function*, void* user_info); 102 | 103 | typedef int liq_progress_callback_function(float progress_percent, void* user_info); 104 | LIQ_EXPORT void liq_attr_set_progress_callback(liq_attr*, liq_progress_callback_function*, void* user_info); 105 | LIQ_EXPORT void liq_result_set_progress_callback(liq_result*, liq_progress_callback_function*, void* user_info); 106 | 107 | // The rows and their data are not modified. The type of `rows` is non-const only due to a bug in C's typesystem design. 108 | LIQ_EXPORT LIQ_USERESULT liq_image *liq_image_create_rgba_rows(const liq_attr *attr, void *const rows[], int width, int height, double gamma) LIQ_NONNULL; 109 | LIQ_EXPORT LIQ_USERESULT liq_image *liq_image_create_rgba(const liq_attr *attr, const void *bitmap, int width, int height, double gamma) LIQ_NONNULL; 110 | 111 | typedef void liq_image_get_rgba_row_callback(liq_color row_out[], int row, int width, void* user_info); 112 | LIQ_EXPORT LIQ_USERESULT liq_image *liq_image_create_custom(const liq_attr *attr, liq_image_get_rgba_row_callback *row_callback, void* user_info, int width, int height, double gamma); 113 | 114 | LIQ_EXPORT liq_error liq_image_set_memory_ownership(liq_image *image, int ownership_flags) LIQ_NONNULL; 115 | LIQ_EXPORT liq_error liq_image_set_background(liq_image *img, liq_image *background_image) LIQ_NONNULL; 116 | LIQ_EXPORT liq_error liq_image_set_importance_map(liq_image *img, unsigned char buffer[], size_t buffer_size, enum liq_ownership memory_handling) LIQ_NONNULL; 117 | LIQ_EXPORT liq_error liq_image_add_fixed_color(liq_image *img, liq_color color) LIQ_NONNULL; 118 | LIQ_EXPORT LIQ_USERESULT int liq_image_get_width(const liq_image *img) LIQ_NONNULL; 119 | LIQ_EXPORT LIQ_USERESULT int liq_image_get_height(const liq_image *img) LIQ_NONNULL; 120 | LIQ_EXPORT void liq_image_destroy(liq_image *img) LIQ_NONNULL; 121 | 122 | LIQ_EXPORT LIQ_USERESULT liq_error liq_histogram_quantize(liq_histogram *const input_hist, liq_attr *const options, liq_result **result_output) LIQ_NONNULL; 123 | LIQ_EXPORT LIQ_USERESULT liq_error liq_image_quantize(liq_image *const input_image, liq_attr *const options, liq_result **result_output) LIQ_NONNULL; 124 | LIQ_EXPORT LIQ_USERESULT liq_error liq_result_from_palette(const liq_attr *options, const liq_color *palette, unsigned int palette_size, double gamma, liq_result **result_output) LIQ_NONNULL; 125 | 126 | LIQ_EXPORT liq_error liq_set_dithering_level(liq_result *res, float dither_level) LIQ_NONNULL; 127 | LIQ_EXPORT liq_error liq_set_output_gamma(liq_result* res, double gamma) LIQ_NONNULL; 128 | LIQ_EXPORT LIQ_USERESULT double liq_get_output_gamma(const liq_result *result) LIQ_NONNULL; 129 | 130 | LIQ_EXPORT LIQ_USERESULT const liq_palette *liq_get_palette(liq_result *result) LIQ_NONNULL; 131 | 132 | LIQ_EXPORT liq_error liq_write_remapped_image(liq_result *result, liq_image *input_image, void *buffer, size_t buffer_size) LIQ_NONNULL; 133 | LIQ_EXPORT liq_error liq_write_remapped_image_rows(liq_result *result, liq_image *input_image, unsigned char **row_pointers) LIQ_NONNULL; 134 | 135 | LIQ_EXPORT double liq_get_quantization_error(const liq_result *result) LIQ_NONNULL; 136 | LIQ_EXPORT int liq_get_quantization_quality(const liq_result *result) LIQ_NONNULL; 137 | LIQ_EXPORT double liq_get_remapping_error(const liq_result *result) LIQ_NONNULL; 138 | LIQ_EXPORT int liq_get_remapping_quality(const liq_result *result) LIQ_NONNULL; 139 | 140 | LIQ_EXPORT void liq_result_destroy(liq_result *) LIQ_NONNULL; 141 | 142 | LIQ_EXPORT int liq_version(void); 143 | 144 | 145 | // Deprecated 146 | LIQ_EXPORT LIQ_USERESULT liq_result *liq_quantize_image(liq_attr *options, liq_image *input_image) LIQ_NONNULL; 147 | 148 | #ifdef __cplusplus 149 | } 150 | #endif 151 | 152 | #endif 153 | -------------------------------------------------------------------------------- /src/nearest.rs: -------------------------------------------------------------------------------- 1 | use crate::pal::{f_pixel, PalF, PalIndex, MAX_COLORS}; 2 | use crate::{Error, OrdFloat}; 3 | 4 | #[cfg(all(not(feature = "std"), feature = "no_std"))] 5 | use crate::no_std_compat::*; 6 | 7 | impl<'pal> Nearest<'pal> { 8 | #[inline(never)] 9 | pub fn new(palette: &'pal PalF) -> Result { 10 | if palette.len() > PalIndex::MAX as usize + 1 { 11 | return Err(Error::Unsupported); 12 | } 13 | let mut indexes: Vec<_> = (0..palette.len()) 14 | .map(|idx| MapIndex { idx: idx as _ }) 15 | .collect(); 16 | if indexes.is_empty() { 17 | return Err(Error::Unsupported); 18 | } 19 | let mut handle = Nearest { 20 | root: vp_create_node(&mut indexes, palette), 21 | palette, 22 | nearest_other_color_dist: [0.; MAX_COLORS], 23 | }; 24 | for (i, color) in palette.as_slice().iter().enumerate() { 25 | let mut best = Visitor { 26 | idx: 0, 27 | distance: f32::MAX, 28 | distance_squared: f32::MAX, 29 | exclude: Some(i as PalIndex), 30 | }; 31 | vp_search_node(&handle.root, color, &mut best); 32 | handle.nearest_other_color_dist[i] = best.distance_squared / 4.; 33 | } 34 | Ok(handle) 35 | } 36 | } 37 | 38 | impl Nearest<'_> { 39 | #[inline] 40 | pub fn search(&self, px: &f_pixel, likely_colormap_index: PalIndex) -> (PalIndex, f32) { 41 | // The index may be invalid, so it needs to be checked 42 | let mut best_candidate = if let Some(pal_px) = self.palette.as_slice().get(likely_colormap_index as usize) { 43 | let guess_diff = px.diff(pal_px); 44 | if guess_diff < self.nearest_other_color_dist[likely_colormap_index as usize] { 45 | return (likely_colormap_index, guess_diff); 46 | } 47 | Visitor { 48 | distance: guess_diff.sqrt(), 49 | distance_squared: guess_diff, 50 | idx: likely_colormap_index, 51 | exclude: None, 52 | } 53 | } else { 54 | Visitor { 55 | distance: f32::INFINITY, 56 | distance_squared: f32::INFINITY, 57 | idx: 0, 58 | exclude: None, 59 | } 60 | }; 61 | 62 | vp_search_node(&self.root, px, &mut best_candidate); 63 | (best_candidate.idx, best_candidate.distance_squared) 64 | } 65 | } 66 | 67 | pub(crate) struct Nearest<'pal> { 68 | root: Node, 69 | palette: &'pal PalF, 70 | nearest_other_color_dist: [f32; MAX_COLORS], 71 | } 72 | 73 | pub struct MapIndex { 74 | pub idx: PalIndex, 75 | } 76 | 77 | pub struct Visitor { 78 | pub distance: f32, 79 | pub distance_squared: f32, 80 | pub idx: PalIndex, 81 | pub exclude: Option, 82 | } 83 | 84 | impl Visitor { 85 | #[inline] 86 | fn visit(&mut self, distance: f32, distance_squared: f32, idx: PalIndex) { 87 | if distance_squared < self.distance_squared && self.exclude != Some(idx) { 88 | self.distance = distance; 89 | self.distance_squared = distance_squared; 90 | self.idx = idx; 91 | } 92 | } 93 | } 94 | 95 | pub(crate) struct Node { 96 | vantage_point: f_pixel, 97 | inner: NodeInner, 98 | idx: PalIndex, 99 | } 100 | 101 | const LEAF_MAX_SIZE: usize = 6; 102 | 103 | enum NodeInner { 104 | Nodes { 105 | radius: f32, 106 | radius_squared: f32, 107 | near: Box, 108 | far: Box, 109 | }, 110 | Leaf { 111 | len: u8, 112 | idxs: [PalIndex; LEAF_MAX_SIZE], 113 | colors: Box<[f_pixel; LEAF_MAX_SIZE]>, 114 | }, 115 | } 116 | 117 | #[inline(never)] 118 | fn vp_create_node(indexes: &mut [MapIndex], items: &PalF) -> Node { 119 | debug_assert!(!indexes.is_empty()); 120 | let palette = items.as_slice(); 121 | 122 | if indexes.len() <= 1 { 123 | let idx = indexes.first().map(|i| i.idx).unwrap_or_default(); 124 | return Node { 125 | vantage_point: palette.get(usize::from(idx)).copied().unwrap_or_default(), 126 | idx, 127 | inner: NodeInner::Leaf { len: 0, idxs: [0; LEAF_MAX_SIZE], colors: Box::new([f_pixel::default(); LEAF_MAX_SIZE]) }, 128 | }; 129 | } 130 | 131 | let most_popular_item = indexes.iter().enumerate().max_by_key(move |(_, idx)| { 132 | OrdFloat::new(items.pop_as_slice().get(usize::from(idx.idx)) 133 | .map(|p| p.popularity()).unwrap_or_default()) 134 | }).map(|(n, _)| n).unwrap_or_default(); 135 | indexes.swap(most_popular_item, 0); 136 | let (ref_, indexes) = indexes.split_first_mut().unwrap(); 137 | 138 | let vantage_point = palette.get(usize::from(ref_.idx)).copied().unwrap_or_default(); 139 | indexes.sort_by_cached_key(move |i| { 140 | OrdFloat::new(palette.get(usize::from(i.idx)) 141 | .map(|px| vantage_point.diff(px)).unwrap_or_default()) 142 | }); 143 | 144 | let num_indexes = indexes.len(); 145 | 146 | let inner = if num_indexes <= LEAF_MAX_SIZE { 147 | let mut colors = [f_pixel::default(); LEAF_MAX_SIZE]; 148 | let mut idxs = [Default::default(); LEAF_MAX_SIZE]; 149 | 150 | indexes.iter().zip(colors.iter_mut().zip(idxs.iter_mut())).for_each(|(i, (color, idx))| { 151 | if let Some(c) = palette.get(usize::from(i.idx)) { 152 | *idx = i.idx; 153 | *color = *c; 154 | } 155 | }); 156 | NodeInner::Leaf { 157 | len: num_indexes as _, 158 | idxs, 159 | colors: Box::new(colors), 160 | } 161 | } else { 162 | let half_index = num_indexes / 2; 163 | let (near, far) = indexes.split_at_mut(half_index); 164 | debug_assert!(!near.is_empty()); 165 | debug_assert!(!far.is_empty()); 166 | let radius_squared = palette.get(usize::from(far[0].idx)) 167 | .map(|px| vantage_point.diff(px)).unwrap_or_default(); 168 | let radius = radius_squared.sqrt(); 169 | NodeInner::Nodes { 170 | radius, radius_squared, 171 | near: Box::new(vp_create_node(near, items)), 172 | far: Box::new(vp_create_node(far, items)), 173 | } 174 | }; 175 | 176 | Node { 177 | inner, 178 | vantage_point, 179 | idx: ref_.idx, 180 | } 181 | } 182 | 183 | #[inline(never)] 184 | fn vp_search_node(mut node: &Node, needle: &f_pixel, best_candidate: &mut Visitor) { 185 | loop { 186 | let distance_squared = node.vantage_point.diff(needle); 187 | let distance = distance_squared.sqrt(); 188 | 189 | best_candidate.visit(distance, distance_squared, node.idx); 190 | 191 | match node.inner { 192 | NodeInner::Nodes { radius, radius_squared, ref near, ref far } => { 193 | // Recurse towards most likely candidate first to narrow best candidate's distance as soon as possible 194 | if distance_squared < radius_squared { 195 | vp_search_node(near, needle, best_candidate); 196 | // The best node (final answer) may be just ouside the radius, but not farther than 197 | // the best distance we know so far. The vp_search_node above should have narrowed 198 | // best_candidate->distance, so this path is rarely taken. 199 | if distance >= radius - best_candidate.distance { 200 | node = far; 201 | continue; 202 | } 203 | } else { 204 | vp_search_node(far, needle, best_candidate); 205 | if distance <= radius + best_candidate.distance { 206 | node = near; 207 | continue; 208 | } 209 | } 210 | break; 211 | }, 212 | NodeInner::Leaf { len: num, ref idxs, ref colors } => { 213 | colors.iter().zip(idxs.iter().copied()).take(num as usize).for_each(|(color, idx)| { 214 | let distance_squared = color.diff(needle); 215 | best_candidate.visit(distance_squared.sqrt(), distance_squared, idx); 216 | }); 217 | break; 218 | }, 219 | } 220 | } 221 | } 222 | -------------------------------------------------------------------------------- /src/rows.rs: -------------------------------------------------------------------------------- 1 | use crate::error::Error; 2 | use crate::pal::{f_pixel, gamma_lut, RGBA}; 3 | use crate::seacow::{Pointer, SeaCow}; 4 | use crate::LIQ_HIGH_MEMORY_LIMIT; 5 | use core::mem::{size_of, MaybeUninit}; 6 | use core::slice; 7 | 8 | #[cfg(all(not(feature = "std"), feature = "no_std"))] 9 | use std::{boxed::Box, vec::Vec}; 10 | 11 | pub(crate) type RowCallback<'a> = dyn Fn(&mut [MaybeUninit], usize) + Send + Sync + 'a; 12 | 13 | pub(crate) enum PixelsSource<'pixels, 'rows> { 14 | /// The `pixels` field is never read, but it is used to store the rows. 15 | #[allow(dead_code)] 16 | Pixels { 17 | rows: SeaCow<'rows, Pointer>, 18 | pixels: Option>, 19 | }, 20 | Callback(Box>), 21 | } 22 | 23 | impl<'pixels> PixelsSource<'pixels, '_> { 24 | pub(crate) fn for_pixels(pixels: SeaCow<'pixels, RGBA>, width: u32, height: u32, stride: u32) -> Result { 25 | if stride < width || height == 0 || width == 0 { 26 | return Err(Error::ValueOutOfRange); 27 | } 28 | let stride = stride as usize; 29 | let width = width as usize; 30 | let height = height as usize; 31 | 32 | let slice = pixels.as_slice(); 33 | let min_area = stride.checked_mul(height).and_then(|a| a.checked_add(width)).ok_or(Error::ValueOutOfRange)? - stride; 34 | if slice.len() < min_area { 35 | return Err(Error::BufferTooSmall); 36 | } 37 | 38 | let rows = SeaCow::boxed(slice.chunks(stride).map(|row| Pointer(row.as_ptr())).take(height).collect()); 39 | Ok(Self::Pixels { rows, pixels: Some(pixels) }) 40 | } 41 | } 42 | 43 | pub(crate) struct DynamicRows<'pixels, 'rows> { 44 | pub(crate) width: u32, 45 | pub(crate) height: u32, 46 | f_pixels: Option>, 47 | pixels: PixelsSource<'pixels, 'rows>, 48 | pub(crate) gamma: f64, 49 | } 50 | 51 | impl Clone for DynamicRows<'_, '_> { 52 | fn clone(&self) -> Self { 53 | Self { 54 | width: self.width, 55 | height: self.height, 56 | f_pixels: self.f_pixels.clone(), 57 | pixels: match &self.pixels { 58 | PixelsSource::Pixels { rows, pixels } => PixelsSource::Pixels { 59 | rows: rows.clone(), 60 | pixels: pixels.clone(), 61 | }, 62 | PixelsSource::Callback(_) => { 63 | let area = self.width as usize * self.height as usize; 64 | let mut out = Vec::with_capacity(area); 65 | let out_rows = out.spare_capacity_mut()[..area].chunks_exact_mut(self.width as usize); 66 | for (i, row) in out_rows.enumerate() { 67 | self.row_rgba(row, i); 68 | } 69 | unsafe { 70 | out.set_len(area); 71 | } 72 | let pixels = SeaCow::boxed(out.into_boxed_slice()); 73 | PixelsSource::for_pixels(pixels, self.width, self.height, self.width).unwrap() 74 | }, 75 | }, 76 | gamma: self.gamma, 77 | } 78 | } 79 | } 80 | 81 | pub(crate) struct DynamicRowsIter<'parent, 'pixels, 'rows> { 82 | px: &'parent DynamicRows<'pixels, 'rows>, 83 | temp_f_row: Option]>>, 84 | } 85 | 86 | impl DynamicRowsIter<'_, '_, '_> { 87 | #[must_use] 88 | pub fn row_f<'px>(&'px mut self, temp_row: &mut [MaybeUninit], row: usize) -> &'px [f_pixel] { 89 | debug_assert_eq!(temp_row.len(), self.px.width as usize); 90 | if let Some(pixels) = self.px.f_pixels.as_ref() { 91 | let start = self.px.width as usize * row; 92 | &pixels[start..start + self.px.width as usize] 93 | } else { 94 | let lut = gamma_lut(self.px.gamma); 95 | let row_pixels = self.px.row_rgba(temp_row, row); 96 | 97 | match self.temp_f_row.as_mut() { 98 | Some(t) => DynamicRows::convert_row_to_f(t, row_pixels, &lut), 99 | None => &mut [], // this can't happen 100 | } 101 | } 102 | } 103 | 104 | #[must_use] 105 | pub fn row_f_shared<'px>(&'px self, temp_row: &mut [MaybeUninit], temp_row_f: &'px mut [MaybeUninit], row: usize) -> &'px [f_pixel] { 106 | if let Some(pixels) = self.px.f_pixels.as_ref() { 107 | &pixels[self.px.width as usize * row..] 108 | } else { 109 | let lut = gamma_lut(self.px.gamma); 110 | let row_pixels = self.px.row_rgba(temp_row, row); 111 | 112 | DynamicRows::convert_row_to_f(temp_row_f, row_pixels, &lut) 113 | } 114 | } 115 | 116 | #[must_use] 117 | pub fn row_rgba<'px>(&'px self, temp_row: &'px mut [MaybeUninit], row: usize) -> &'px [RGBA] { 118 | self.px.row_rgba(temp_row, row) 119 | } 120 | } 121 | 122 | impl<'pixels, 'rows> DynamicRows<'pixels, 'rows> { 123 | #[inline] 124 | pub(crate) fn new(width: u32, height: u32, pixels: PixelsSource<'pixels, 'rows>, gamma: f64) -> Self { 125 | debug_assert!(gamma > 0.); 126 | Self { width, height, f_pixels: None, pixels, gamma } 127 | } 128 | 129 | fn row_rgba<'px>(&'px self, temp_row: &'px mut [MaybeUninit], row: usize) -> &'px [RGBA] { 130 | match &self.pixels { 131 | PixelsSource::Pixels { rows, .. } => unsafe { 132 | slice::from_raw_parts(rows.as_slice()[row].0, self.width()) 133 | }, 134 | PixelsSource::Callback(cb) => { 135 | cb(temp_row, row); 136 | // cb needs to be marked as unsafe, since it's responsible for initialization :( 137 | unsafe { slice_assume_init_mut(temp_row) } 138 | }, 139 | } 140 | } 141 | 142 | fn convert_row_to_f<'f>(row_f_pixels: &'f mut [MaybeUninit], row_pixels: &[RGBA], gamma_lut: &[f32; 256]) -> &'f mut [f_pixel] { 143 | assert_eq!(row_f_pixels.len(), row_pixels.len()); 144 | for (dst, src) in row_f_pixels.iter_mut().zip(row_pixels) { 145 | dst.write(f_pixel::from_rgba(gamma_lut, *src)); 146 | } 147 | // Safe, just initialized 148 | unsafe { slice_assume_init_mut(row_f_pixels) } 149 | } 150 | 151 | #[must_use] 152 | fn should_use_low_memory(&self) -> bool { 153 | self.width() * self.height() > LIQ_HIGH_MEMORY_LIMIT / size_of::() 154 | } 155 | 156 | #[inline] 157 | fn temp_f_row_for_iter(&self) -> Result]>>, Error> { 158 | if self.f_pixels.is_some() { 159 | return Ok(None); 160 | } 161 | Ok(Some(temp_buf(self.width())?)) 162 | } 163 | 164 | pub fn prepare_iter(&mut self, temp_row: &mut [MaybeUninit], allow_steamed: bool) -> Result<(), Error> { 165 | debug_assert_eq!(temp_row.len(), self.width as _); 166 | 167 | if self.f_pixels.is_some() || (allow_steamed && self.should_use_low_memory()) { 168 | return Ok(()); 169 | } 170 | 171 | let width = self.width(); 172 | let lut = gamma_lut(self.gamma); 173 | let mut f_pixels = temp_buf(width * self.height())?; 174 | for (row, f_row) in f_pixels.chunks_exact_mut(width).enumerate() { 175 | let row_pixels = self.row_rgba(temp_row, row); 176 | Self::convert_row_to_f(f_row, row_pixels, &lut); 177 | } 178 | // just initialized 179 | self.f_pixels = Some(unsafe { box_assume_init(f_pixels) }); 180 | Ok(()) 181 | } 182 | 183 | #[inline] 184 | pub fn rows_iter(&mut self, temp_row: &mut [MaybeUninit]) -> Result, Error> { 185 | self.prepare_iter(temp_row, true)?; 186 | Ok(DynamicRowsIter { 187 | temp_f_row: self.temp_f_row_for_iter()?, 188 | px: self, 189 | }) 190 | } 191 | 192 | /// Call `prepare_iter()` first 193 | #[inline] 194 | pub fn rows_iter_prepared(&self) -> Result, Error> { 195 | Ok(DynamicRowsIter { 196 | temp_f_row: self.temp_f_row_for_iter()?, 197 | px: self, 198 | }) 199 | } 200 | 201 | #[inline] 202 | pub fn rgba_rows_iter(&self) -> Result, Error> { 203 | // This happens when histogram image is recycled 204 | if let PixelsSource::Pixels { rows, .. } = &self.pixels { 205 | if rows.as_slice().is_empty() { 206 | return Err(Error::Unsupported); 207 | } 208 | } 209 | Ok(DynamicRowsIter { px: self, temp_f_row: None }) 210 | } 211 | 212 | #[inline] 213 | pub fn all_rows_f(&mut self) -> Result<&[f_pixel], Error> { 214 | if self.f_pixels.is_some() { 215 | return Ok(self.f_pixels.as_ref().unwrap()); // borrow-checker :( 216 | } 217 | self.prepare_iter(&mut temp_buf(self.width())?, false)?; 218 | self.f_pixels.as_deref().ok_or(Error::Unsupported) 219 | } 220 | 221 | /// Not recommended 222 | #[cfg(feature = "_internal_c_ffi")] 223 | pub(crate) unsafe fn set_memory_ownership(&mut self, own_rows: bool, own_pixels: bool, free_fn: unsafe extern "C" fn(*mut core::ffi::c_void)) -> Result<(), Error> { 224 | if own_rows { 225 | match &mut self.pixels { 226 | PixelsSource::Pixels { rows, .. } => rows.make_owned(free_fn), 227 | PixelsSource::Callback(_) => return Err(Error::ValueOutOfRange), 228 | } 229 | } 230 | 231 | if own_pixels { 232 | let len = self.width() * self.height(); 233 | match &mut self.pixels { 234 | PixelsSource::Pixels { pixels: Some(pixels), .. } => pixels.make_owned(free_fn), 235 | PixelsSource::Pixels { pixels, rows } => { 236 | // the row with the lowest address is assumed to be at the start of the bitmap 237 | let ptr = rows.as_slice().iter().map(|p| p.0).min().ok_or(Error::Unsupported)?; 238 | *pixels = Some(SeaCow::c_owned(ptr.cast_mut(), len, free_fn)); 239 | }, 240 | PixelsSource::Callback(_) => return Err(Error::ValueOutOfRange), 241 | } 242 | } 243 | Ok(()) 244 | } 245 | 246 | pub fn free_histogram_inputs(&mut self) { 247 | if self.f_pixels.is_some() { 248 | self.pixels = PixelsSource::Pixels { 249 | rows: SeaCow::borrowed(&[]), 250 | pixels: None, 251 | }; 252 | } 253 | } 254 | 255 | #[inline(always)] 256 | #[must_use] 257 | pub const fn width(&self) -> usize { 258 | self.width as usize 259 | } 260 | 261 | #[inline(always)] 262 | #[must_use] 263 | pub const fn height(&self) -> usize { 264 | self.height as usize 265 | } 266 | } 267 | 268 | pub(crate) fn temp_buf(len: usize) -> Result]>, Error> { 269 | let mut v = Vec::new(); 270 | v.try_reserve_exact(len)?; 271 | unsafe { v.set_len(len) }; 272 | Ok(v.into_boxed_slice()) 273 | } 274 | 275 | #[test] 276 | fn send() { 277 | fn is_send() {} 278 | fn is_sync() {} 279 | is_send::(); 280 | is_sync::(); 281 | is_send::(); 282 | is_sync::(); 283 | } 284 | 285 | #[inline(always)] 286 | unsafe fn box_assume_init(s: Box<[MaybeUninit]>) -> Box<[T]> { 287 | core::mem::transmute(s) 288 | } 289 | 290 | #[inline(always)] 291 | unsafe fn slice_assume_init_mut(s: &mut [MaybeUninit]) -> &mut [T] { 292 | &mut *(s as *mut [MaybeUninit] as *mut [T]) 293 | } 294 | -------------------------------------------------------------------------------- /imagequant-sys/imagequant.xcodeproj/project.pbxproj: -------------------------------------------------------------------------------- 1 | // !$*UTF8*$! 2 | { 3 | /* generated with cargo-xcode 1.11.0 */ 4 | archiveVersion = 1; 5 | classes = { 6 | }; 7 | objectVersion = 53; 8 | objects = { 9 | 10 | /* Begin PBXBuildFile section */ 11 | CA0074F714595B987CA78108 /* Cargo.toml in Sources */ = {isa = PBXBuildFile; fileRef = CAF9EDA9C64B3EF4668187A5 /* Cargo.toml */; settings = {COMPILER_FLAGS = "--lib"; }; }; 12 | /* End PBXBuildFile section */ 13 | 14 | /* Begin PBXBuildRule section */ 15 | CAF4EDA9C64BAC6C1400ACA8 /* PBXBuildRule */ = { 16 | isa = PBXBuildRule; 17 | compilerSpec = com.apple.compilers.proxy.script; 18 | dependencyFile = "$(DERIVED_FILE_DIR)/$(ARCHS)-$(EXECUTABLE_NAME).d"; 19 | filePatterns = "*/Cargo.toml"; 20 | fileType = pattern.proxy; 21 | inputFiles = ( 22 | ); 23 | isEditable = 0; 24 | name = "Cargo project build"; 25 | outputFiles = ( 26 | "$(TARGET_BUILD_DIR)/$(EXECUTABLE_NAME)", 27 | ); 28 | runOncePerArchitecture = 0; 29 | script = "# generated with cargo-xcode 1.11.0\nset -euo pipefail;\nexport PATH=\"$HOME/.cargo/bin:$PATH:/usr/local/bin:/opt/homebrew/bin\";\n# don't use ios/watchos linker for build scripts and proc macros\nexport CARGO_TARGET_AARCH64_APPLE_DARWIN_LINKER=/usr/bin/ld\nexport CARGO_TARGET_X86_64_APPLE_DARWIN_LINKER=/usr/bin/ld\nexport NO_COLOR=1\n\ncase \"$PLATFORM_NAME\" in\n \"macosx\")\n CARGO_XCODE_TARGET_OS=darwin\n if [ \"${IS_MACCATALYST-NO}\" = YES ]; then\n CARGO_XCODE_TARGET_OS=ios-macabi\n fi\n ;;\n \"iphoneos\") CARGO_XCODE_TARGET_OS=ios ;;\n \"iphonesimulator\") CARGO_XCODE_TARGET_OS=ios-sim ;;\n \"appletvos\" | \"appletvsimulator\") CARGO_XCODE_TARGET_OS=tvos ;;\n \"watchos\") CARGO_XCODE_TARGET_OS=watchos ;;\n \"watchsimulator\") CARGO_XCODE_TARGET_OS=watchos-sim ;;\n \"xros\") CARGO_XCODE_TARGET_OS=visionos ;;\n \"xrsimulator\") CARGO_XCODE_TARGET_OS=visionos-sim ;;\n *)\n CARGO_XCODE_TARGET_OS=\"$PLATFORM_NAME\"\n echo >&2 \"warning: cargo-xcode needs to be updated to handle $PLATFORM_NAME\"\n ;;\nesac\n\nCARGO_XCODE_TARGET_TRIPLES=\"\"\nCARGO_XCODE_TARGET_FLAGS=\"\"\nLIPO_ARGS=\"\"\nfor arch in $ARCHS; do\n if [[ \"$arch\" == \"arm64\" ]]; then arch=aarch64; fi\n if [[ \"$arch\" == \"i386\" && \"$CARGO_XCODE_TARGET_OS\" != \"ios\" ]]; then arch=i686; fi\n triple=\"${arch}-apple-$CARGO_XCODE_TARGET_OS\"\n CARGO_XCODE_TARGET_TRIPLES+=\" $triple\"\n CARGO_XCODE_TARGET_FLAGS+=\" --target=$triple\"\n LIPO_ARGS+=\"$CARGO_TARGET_DIR/$triple/$CARGO_XCODE_BUILD_PROFILE/$CARGO_XCODE_CARGO_FILE_NAME\n\"\ndone\n\necho >&2 \"Cargo $CARGO_XCODE_BUILD_PROFILE $ACTION for $PLATFORM_NAME $ARCHS =$CARGO_XCODE_TARGET_TRIPLES; using ${SDK_NAMES:-}. \\$PATH is:\"\ntr >&2 : '\\n' <<<\"$PATH\"\n\nif command -v rustup &> /dev/null; then\n for triple in $CARGO_XCODE_TARGET_TRIPLES; do\n if ! rustup target list --installed | grep -Eq \"^$triple$\"; then\n echo >&2 \"warning: this build requires rustup toolchain for $triple, but it isn't installed (will try rustup next)\"\n rustup target add \"$triple\" || {\n echo >&2 \"warning: can't install $triple, will try nightly -Zbuild-std\";\n OTHER_INPUT_FILE_FLAGS+=\" -Zbuild-std\";\n if [ -z \"${RUSTUP_TOOLCHAIN:-}\" ]; then\n export RUSTUP_TOOLCHAIN=nightly\n fi\n break;\n }\n fi\n done\nfi\n\nif [ \"$CARGO_XCODE_BUILD_PROFILE\" = release ]; then\n OTHER_INPUT_FILE_FLAGS=\"$OTHER_INPUT_FILE_FLAGS --release\"\nfi\n\nif [ \"$ACTION\" = clean ]; then\n cargo clean --verbose --manifest-path=\"$SCRIPT_INPUT_FILE\" $CARGO_XCODE_TARGET_FLAGS $OTHER_INPUT_FILE_FLAGS;\n rm -f \"$SCRIPT_OUTPUT_FILE_0\"\n exit 0\nfi\n\n{ cargo build --manifest-path=\"$SCRIPT_INPUT_FILE\" --features=\"${CARGO_XCODE_FEATURES:-}\" $CARGO_XCODE_TARGET_FLAGS $OTHER_INPUT_FILE_FLAGS --verbose --message-format=short 2>&1 | sed -E 's/^([^ :]+:[0-9]+:[0-9]+: error)/\\1: /' >&2; } || { echo >&2 \"$SCRIPT_INPUT_FILE: error: cargo-xcode project build failed; $CARGO_XCODE_TARGET_TRIPLES\"; exit 1; }\n\ntr '\\n' '\\0' <<<\"$LIPO_ARGS\" | xargs -0 lipo -create -output \"$SCRIPT_OUTPUT_FILE_0\"\n\nif [ ${LD_DYLIB_INSTALL_NAME:+1} ]; then\n install_name_tool -id \"$LD_DYLIB_INSTALL_NAME\" \"$SCRIPT_OUTPUT_FILE_0\"\nfi\n\nDEP_FILE_DST=\"$DERIVED_FILE_DIR/${ARCHS}-${EXECUTABLE_NAME}.d\"\necho \"\" > \"$DEP_FILE_DST\"\nfor triple in $CARGO_XCODE_TARGET_TRIPLES; do\n BUILT_SRC=\"$CARGO_TARGET_DIR/$triple/$CARGO_XCODE_BUILD_PROFILE/$CARGO_XCODE_CARGO_FILE_NAME\"\n\n # cargo generates a dep file, but for its own path, so append our rename to it\n DEP_FILE_SRC=\"$CARGO_TARGET_DIR/$triple/$CARGO_XCODE_BUILD_PROFILE/$CARGO_XCODE_CARGO_DEP_FILE_NAME\"\n if [ -f \"$DEP_FILE_SRC\" ]; then\n cat \"$DEP_FILE_SRC\" >> \"$DEP_FILE_DST\"\n fi\n echo >> \"$DEP_FILE_DST\" \"${SCRIPT_OUTPUT_FILE_0/ /\\\\ /}: ${BUILT_SRC/ /\\\\ /}\"\ndone\ncat \"$DEP_FILE_DST\"\n\necho \"success: $ACTION of $SCRIPT_OUTPUT_FILE_0 for $CARGO_XCODE_TARGET_TRIPLES\"\n"; 30 | }; 31 | /* End PBXBuildRule section */ 32 | 33 | /* Begin PBXFileReference section */ 34 | CA00DA7A53FB47C0CE156F07 /* libimagequant.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libimagequant.a; sourceTree = BUILT_PRODUCTS_DIR; }; 35 | CAF9EDA9C64B3EF4668187A5 /* Cargo.toml */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = Cargo.toml; path = Cargo.toml; sourceTree = ""; }; 36 | /* End PBXFileReference section */ 37 | 38 | /* Begin PBXGroup section */ 39 | CAF0EDA9C64BD65BC3C892A8 = { 40 | isa = PBXGroup; 41 | children = ( 42 | CAF9EDA9C64B3EF4668187A5 /* Cargo.toml */, 43 | CAF1EDA9C64B22869D176AE5 /* Products */, 44 | CAF2EDA9C64B98AF0B5890DB /* Frameworks */, 45 | ); 46 | sourceTree = ""; 47 | }; 48 | CAF1EDA9C64B22869D176AE5 /* Products */ = { 49 | isa = PBXGroup; 50 | children = ( 51 | CA00DA7A53FB47C0CE156F07 /* libimagequant.a */, 52 | ); 53 | name = Products; 54 | sourceTree = ""; 55 | }; 56 | CAF2EDA9C64B98AF0B5890DB /* Frameworks */ = { 57 | isa = PBXGroup; 58 | children = ( 59 | ); 60 | name = Frameworks; 61 | sourceTree = ""; 62 | }; 63 | /* End PBXGroup section */ 64 | 65 | /* Begin PBXNativeTarget section */ 66 | CA00DA7A53FB5B987CA78108 /* imagequant_sys.a (static library) */ = { 67 | isa = PBXNativeTarget; 68 | buildConfigurationList = CA000042D4435B987CA78108 /* Build configuration list for PBXNativeTarget "imagequant_sys.a (static library)" */; 69 | buildPhases = ( 70 | CA007A177A415B987CA78108 /* Sources */, 71 | ); 72 | buildRules = ( 73 | CAF4EDA9C64BAC6C1400ACA8 /* PBXBuildRule */, 74 | ); 75 | dependencies = ( 76 | ); 77 | name = "imagequant_sys.a (static library)"; 78 | productName = libimagequant.a; 79 | productReference = CA00DA7A53FB47C0CE156F07 /* libimagequant.a */; 80 | productType = "com.apple.product-type.library.static"; 81 | }; 82 | /* End PBXNativeTarget section */ 83 | 84 | /* Begin PBXProject section */ 85 | CAF3EDA9C64BE04653AD465F /* Project object */ = { 86 | isa = PBXProject; 87 | attributes = { 88 | BuildIndependentTargetsInParallel = YES; 89 | LastUpgradeCheck = 1510; 90 | TargetAttributes = { 91 | CA00DA7A53FB5B987CA78108 = { 92 | CreatedOnToolsVersion = 9.2; 93 | ProvisioningStyle = Automatic; 94 | }; 95 | }; 96 | }; 97 | buildConfigurationList = CAF6EDA9C64B80E02D6C7F57 /* Build configuration list for PBXProject "imagequant" */; 98 | compatibilityVersion = "Xcode 11.4"; 99 | developmentRegion = en; 100 | hasScannedForEncodings = 0; 101 | knownRegions = ( 102 | en, 103 | Base, 104 | ); 105 | mainGroup = CAF0EDA9C64BD65BC3C892A8; 106 | productRefGroup = CAF1EDA9C64B22869D176AE5 /* Products */; 107 | projectDirPath = ""; 108 | projectRoot = ""; 109 | targets = ( 110 | CA00DA7A53FB5B987CA78108 /* imagequant_sys.a (static library) */, 111 | ); 112 | }; 113 | /* End PBXProject section */ 114 | 115 | /* Begin PBXSourcesBuildPhase section */ 116 | CA007A177A415B987CA78108 /* Sources */ = { 117 | isa = PBXSourcesBuildPhase; 118 | buildActionMask = 2147483647; 119 | files = ( 120 | CA0074F714595B987CA78108 /* Cargo.toml in Sources */, 121 | ); 122 | runOnlyForDeploymentPostprocessing = 0; 123 | }; 124 | /* End PBXSourcesBuildPhase section */ 125 | 126 | /* Begin XCBuildConfiguration section */ 127 | CA00E0FF0C645B987CA78108 /* Release */ = { 128 | isa = XCBuildConfiguration; 129 | buildSettings = { 130 | CARGO_XCODE_CARGO_DEP_FILE_NAME = libimagequant_sys.d; 131 | CARGO_XCODE_CARGO_FILE_NAME = libimagequant_sys.a; 132 | INSTALL_GROUP = ""; 133 | INSTALL_MODE_FLAG = ""; 134 | INSTALL_OWNER = ""; 135 | PRODUCT_NAME = imagequant; 136 | SKIP_INSTALL = YES; 137 | SUPPORTED_PLATFORMS = "xrsimulator xros watchsimulator watchos macosx iphonesimulator iphoneos driverkit appletvsimulator appletvos"; 138 | }; 139 | name = Release; 140 | }; 141 | CA00B3274B715B987CA78108 /* Debug */ = { 142 | isa = XCBuildConfiguration; 143 | buildSettings = { 144 | CARGO_XCODE_CARGO_DEP_FILE_NAME = libimagequant_sys.d; 145 | CARGO_XCODE_CARGO_FILE_NAME = libimagequant_sys.a; 146 | INSTALL_GROUP = ""; 147 | INSTALL_MODE_FLAG = ""; 148 | INSTALL_OWNER = ""; 149 | PRODUCT_NAME = imagequant; 150 | SKIP_INSTALL = YES; 151 | SUPPORTED_PLATFORMS = "xrsimulator xros watchsimulator watchos macosx iphonesimulator iphoneos driverkit appletvsimulator appletvos"; 152 | }; 153 | name = Debug; 154 | }; 155 | CAF7A7C4F8A63CC16B37690B /* Release */ = { 156 | isa = XCBuildConfiguration; 157 | buildSettings = { 158 | "ADDITIONAL_SDKS[sdk=i*]" = macosx; 159 | "ADDITIONAL_SDKS[sdk=w*]" = macosx; 160 | "ADDITIONAL_SDKS[sdk=x*]" = macosx; 161 | "ADDITIONAL_SDKS[sdk=a*]" = macosx; 162 | ALWAYS_SEARCH_USER_PATHS = NO; 163 | CARGO_TARGET_DIR = "$(PROJECT_TEMP_DIR)/cargo_target"; 164 | CARGO_XCODE_BUILD_PROFILE = release; 165 | CARGO_XCODE_FEATURES = ""; 166 | CURRENT_PROJECT_VERSION = 4.1; 167 | ENABLE_USER_SCRIPT_SANDBOXING = NO; 168 | MARKETING_VERSION = 4.1.0; 169 | PRODUCT_NAME = "imagequant-sys"; 170 | RUSTUP_TOOLCHAIN = ""; 171 | SDKROOT = macosx; 172 | SUPPORTS_MACCATALYST = YES; 173 | }; 174 | name = Release; 175 | }; 176 | CAF8A7C4F8A6228BE02872F8 /* Debug */ = { 177 | isa = XCBuildConfiguration; 178 | buildSettings = { 179 | "ADDITIONAL_SDKS[sdk=i*]" = macosx; 180 | "ADDITIONAL_SDKS[sdk=w*]" = macosx; 181 | "ADDITIONAL_SDKS[sdk=x*]" = macosx; 182 | "ADDITIONAL_SDKS[sdk=a*]" = macosx; 183 | ALWAYS_SEARCH_USER_PATHS = NO; 184 | CARGO_TARGET_DIR = "$(PROJECT_TEMP_DIR)/cargo_target"; 185 | CARGO_XCODE_BUILD_PROFILE = debug; 186 | CARGO_XCODE_FEATURES = ""; 187 | CURRENT_PROJECT_VERSION = 4.1; 188 | ENABLE_USER_SCRIPT_SANDBOXING = NO; 189 | MARKETING_VERSION = 4.1.0; 190 | ONLY_ACTIVE_ARCH = YES; 191 | PRODUCT_NAME = "imagequant-sys"; 192 | RUSTUP_TOOLCHAIN = ""; 193 | SDKROOT = macosx; 194 | SUPPORTS_MACCATALYST = YES; 195 | }; 196 | name = Debug; 197 | }; 198 | /* End XCBuildConfiguration section */ 199 | 200 | /* Begin XCConfigurationList section */ 201 | CA000042D4435B987CA78108 /* Build configuration list for PBXNativeTarget "imagequant_sys.a (static library)" */ = { 202 | isa = XCConfigurationList; 203 | buildConfigurations = ( 204 | CA00E0FF0C645B987CA78108 /* Release */, 205 | CA00B3274B715B987CA78108 /* Debug */, 206 | ); 207 | defaultConfigurationIsVisible = 0; 208 | defaultConfigurationName = Release; 209 | }; 210 | CAF6EDA9C64B80E02D6C7F57 /* Build configuration list for PBXProject "imagequant" */ = { 211 | isa = XCConfigurationList; 212 | buildConfigurations = ( 213 | CAF7A7C4F8A63CC16B37690B /* Release */, 214 | CAF8A7C4F8A6228BE02872F8 /* Debug */, 215 | ); 216 | defaultConfigurationIsVisible = 0; 217 | defaultConfigurationName = Release; 218 | }; 219 | /* End XCConfigurationList section */ 220 | }; 221 | rootObject = CAF3EDA9C64BE04653AD465F /* Project object */; 222 | } 223 | -------------------------------------------------------------------------------- /src/mediancut.rs: -------------------------------------------------------------------------------- 1 | use crate::hist::{HistItem, HistogramInternal}; 2 | use crate::pal::{f_pixel, PalF, PalLen, PalPop, ARGBF}; 3 | use crate::quant::quality_to_mse; 4 | use crate::{Error, OrdFloat, PushInCapacity}; 5 | use core::cmp::Reverse; 6 | use rgb::prelude::*; 7 | 8 | #[cfg(all(not(feature = "std"), feature = "no_std"))] 9 | use crate::no_std_compat::*; 10 | 11 | struct MedianCutter<'hist> { 12 | boxes: Vec>, 13 | hist_total_perceptual_weight: f64, 14 | target_colors: PalLen, 15 | } 16 | 17 | struct MBox<'hist> { 18 | /// Histogram entries that fell into this bucket 19 | pub colors: &'hist mut [HistItem], 20 | /// Center color selected to represent the colors 21 | pub avg_color: f_pixel, 22 | /// Difference from the average color, per channel, weighed using `adjusted_weight` 23 | pub variance: ARGBF, 24 | pub adjusted_weight_sum: f64, 25 | pub total_error: Option, 26 | /// max color difference between avg_color and any histogram entry 27 | pub max_error: f32, 28 | } 29 | 30 | impl<'hist> MBox<'hist> { 31 | pub fn new(hist: &'hist mut [HistItem]) -> Self { 32 | let weight_sum = hist.iter().map(|item| { 33 | debug_assert!(item.adjusted_weight.is_finite()); 34 | debug_assert!(item.adjusted_weight > 0.); 35 | f64::from(item.adjusted_weight) 36 | }).sum(); 37 | Self::new_inner(hist, weight_sum, weighed_average_color(hist)) 38 | } 39 | 40 | fn from_split(hist: &'hist mut [HistItem], adjusted_weight_sum: f64) -> Self { 41 | debug_assert!(!hist.is_empty()); 42 | let avg_color = weighed_average_color(hist); 43 | Self::new_inner(hist, adjusted_weight_sum, avg_color) 44 | } 45 | 46 | fn new_inner(hist: &'hist mut [HistItem], adjusted_weight_sum: f64, avg_color: f_pixel) -> Self { 47 | let (variance, max_error) = Self::box_stats(hist, avg_color); 48 | debug_assert!(adjusted_weight_sum.is_finite()); 49 | Self { 50 | variance, 51 | max_error, 52 | avg_color, 53 | colors: hist, 54 | adjusted_weight_sum, 55 | total_error: None, 56 | } 57 | } 58 | 59 | fn box_stats(hist: &[HistItem], avg_color: f_pixel) -> (ARGBF, f32) { 60 | let mut variance = ARGBF::default(); 61 | let mut max_error = 0.; 62 | for item in hist { 63 | variance += (avg_color.0 - item.color.0).map(|c| c * c) * item.adjusted_weight; 64 | let diff = avg_color.diff(&item.color); 65 | if diff > max_error { 66 | max_error = diff; 67 | } 68 | } 69 | (variance, max_error) 70 | } 71 | 72 | pub fn compute_total_error(&mut self) -> f64 { 73 | let avg = self.avg_color; 74 | let e = self.colors.iter().map(move |a| f64::from(avg.diff(&a.color)) * f64::from(a.perceptual_weight)).sum::(); 75 | self.total_error = Some(e); 76 | e 77 | } 78 | 79 | pub fn prepare_sort(&mut self) { 80 | struct ChanVariance { 81 | pub chan: usize, 82 | pub variance: f32, 83 | } 84 | 85 | // Sort dimensions by their variance, and then sort colors first by dimension with the highest variance 86 | let vars: [f32; 4] = rgb::bytemuck::cast(self.variance); 87 | let mut channels = [ 88 | ChanVariance { chan: 0, variance: vars[0] }, 89 | ChanVariance { chan: 1, variance: vars[1] }, 90 | ChanVariance { chan: 2, variance: vars[2] }, 91 | ChanVariance { chan: 3, variance: vars[3] }, 92 | ]; 93 | channels.sort_unstable_by_key(|ch| Reverse(OrdFloat::new(ch.variance))); 94 | 95 | for item in self.colors.iter_mut() { 96 | let chans: [f32; 4] = rgb::bytemuck::cast(item.color.0); 97 | // Only the first channel really matters. But other channels are included, because when trying median cut 98 | // many times with different histogram weights, I don't want sort randomness to influence the outcome. 99 | item.tmp.mc_sort_value = (u32::from((chans[channels[0].chan] * 65535.) as u16) << 16) 100 | | u32::from(((chans[channels[2].chan] + chans[channels[1].chan] / 2. + chans[channels[3].chan] / 4.) * 65535.) as u16); // box will be split to make color_weight of each side even 101 | } 102 | } 103 | 104 | fn median_color(&mut self) -> f_pixel { 105 | let len = self.colors.len(); 106 | let (_, mid_item, _) = self.colors.select_nth_unstable_by_key(len / 2, |a| a.mc_sort_value()); 107 | mid_item.color 108 | } 109 | 110 | pub fn prepare_color_weight_total(&mut self) -> f64 { 111 | let median = self.median_color(); 112 | self.colors.iter_mut().map(move |a| { 113 | let w = (median.diff(&a.color).sqrt() * (2. + a.adjusted_weight)).sqrt(); 114 | debug_assert!(w.is_finite()); 115 | a.mc_color_weight = w; 116 | f64::from(w) 117 | }) 118 | .sum() 119 | } 120 | 121 | #[inline] 122 | pub fn split(mut self) -> [Self; 2] { 123 | self.prepare_sort(); 124 | let half_weight = self.prepare_color_weight_total() / 2.; 125 | // yeah, there's some off-by-one error in there 126 | let break_at = hist_item_sort_half(self.colors, half_weight).max(1); 127 | 128 | let (left, right) = self.colors.split_at_mut(break_at); 129 | let left_sum = left.iter().map(|a| f64::from(a.adjusted_weight)).sum(); 130 | let right_sum = self.adjusted_weight_sum - left_sum; 131 | 132 | [MBox::from_split(left, left_sum), 133 | MBox::from_split(right, right_sum)] 134 | } 135 | } 136 | 137 | #[inline] 138 | fn qsort_pivot(base: &[HistItem]) -> usize { 139 | let len = base.len(); 140 | if len < 32 { 141 | return len / 2; 142 | } 143 | let mut pivots = [8, len / 2, len - 1]; 144 | // LLVM can't see it's in bounds :( 145 | pivots.sort_unstable_by_key(move |&idx| unsafe { 146 | debug_assert!(base.get(idx).is_some()); 147 | base.get_unchecked(idx) 148 | }.mc_sort_value()); 149 | pivots[1] 150 | } 151 | 152 | fn qsort_partition(base: &mut [HistItem]) -> usize { 153 | let mut r = base.len(); 154 | base.swap(qsort_pivot(base), 0); 155 | let pivot_value = base[0].mc_sort_value(); 156 | let mut l = 1; 157 | while l < r { 158 | if base[l].mc_sort_value() >= pivot_value { 159 | l += 1; 160 | } else { 161 | r -= 1; 162 | while l < r && base[r].mc_sort_value() <= pivot_value { 163 | r -= 1; 164 | } 165 | base.swap(l, r); 166 | } 167 | } 168 | l -= 1; 169 | base.swap(l, 0); 170 | l 171 | } 172 | 173 | /// sorts the slice to make the sum of weights lower than `weight_half_sum` one side, 174 | /// returns index of the edge between halfvar parts of the set 175 | #[inline(never)] 176 | fn hist_item_sort_half(mut base: &mut [HistItem], mut weight_half_sum: f64) -> usize { 177 | let mut base_index = 0; 178 | if base.is_empty() { 179 | return 0; 180 | } 181 | loop { 182 | let partition = qsort_partition(base); 183 | let (left, right) = base.split_at_mut(partition + 1); // +1, because pivot stays on the left side 184 | let left_sum = left.iter().map(|c| f64::from(c.mc_color_weight)).sum::(); 185 | if left_sum >= weight_half_sum { 186 | match left.get_mut(..partition) { // trim pivot point, avoid panick branch in [] 187 | Some(left) if !left.is_empty() => { base = left; continue; }, 188 | _ => return base_index, 189 | } 190 | } 191 | weight_half_sum -= left_sum; 192 | base_index += left.len(); 193 | if !right.is_empty() { 194 | base = right; 195 | } else { 196 | return base_index; 197 | } 198 | } 199 | } 200 | 201 | impl<'hist> MedianCutter<'hist> { 202 | fn total_box_error_below_target(&mut self, mut target_mse: f64) -> bool { 203 | target_mse *= self.hist_total_perceptual_weight; 204 | let mut total_error = self.boxes.iter().filter_map(|mb| mb.total_error).sum::(); 205 | if total_error > target_mse { 206 | return false; 207 | } 208 | for mb in self.boxes.iter_mut().filter(|mb| mb.total_error.is_none()) { 209 | total_error += mb.compute_total_error(); 210 | if total_error > target_mse { 211 | return false; 212 | } 213 | } 214 | true 215 | } 216 | 217 | pub fn new(hist: &'hist mut HistogramInternal, target_colors: PalLen) -> Result { 218 | let hist_total_perceptual_weight = hist.total_perceptual_weight; 219 | 220 | debug_assert!(hist.clusters[0].begin == 0); 221 | debug_assert!(hist.clusters.last().unwrap().end as usize == hist.items.len()); 222 | 223 | let mut hist_items = &mut hist.items[..]; 224 | let mut boxes = Vec::new(); 225 | boxes.try_reserve(target_colors as usize)?; 226 | 227 | let used_boxes = hist.clusters.iter().filter(|b| b.begin != b.end).count(); 228 | if used_boxes <= target_colors as usize / 3 { 229 | // boxes are guaranteed to be sorted 230 | let mut prev_end = 0; 231 | for b in hist.clusters.iter().filter(|b| b.begin != b.end) { 232 | let begin = b.begin as usize; 233 | debug_assert_eq!(begin, prev_end); 234 | let end = b.end as usize; 235 | prev_end = end; 236 | let (this_box, rest) = hist_items.split_at_mut(end - begin); 237 | hist_items = rest; 238 | boxes.push_in_cap(MBox::new(this_box)); 239 | } 240 | } else { 241 | boxes.push_in_cap(MBox::new(hist_items)); 242 | } 243 | 244 | Ok(Self { 245 | boxes, 246 | hist_total_perceptual_weight, 247 | target_colors, 248 | }) 249 | } 250 | 251 | fn into_palette(mut self) -> PalF { 252 | let mut palette = PalF::new(); 253 | 254 | for (i, mbox) in self.boxes.iter_mut().enumerate() { 255 | mbox.colors.iter_mut().for_each(move |a| a.tmp.likely_palette_index = i as _); 256 | 257 | // store total color popularity (perceptual_weight is approximation of it) 258 | let pop = mbox.colors.iter().map(|a| f64::from(a.perceptual_weight)).sum::(); 259 | let mut representative_color = mbox.avg_color; 260 | if mbox.colors.len() > 2 { 261 | representative_color = mbox.colors.iter().min_by_key(|a| OrdFloat::new(representative_color.diff(&a.color))).map(|a| a.color).unwrap_or_default(); 262 | } 263 | palette.push(representative_color, PalPop::new(pop as f32)); 264 | } 265 | palette 266 | } 267 | 268 | fn cut(mut self, target_mse: f64, max_mse: f64) -> PalF { 269 | let max_mse = max_mse.max(quality_to_mse(20)); 270 | 271 | while self.boxes.len() < self.target_colors as usize { 272 | // first splits boxes that exceed quality limit (to have colors for things like odd green pixel), 273 | // later raises the limit to allow large smooth areas/gradients get colors. 274 | let fraction_done = self.boxes.len() as f64 / f64::from(self.target_colors); 275 | let current_max_mse = (fraction_done * 16.).mul_add(max_mse, max_mse); 276 | let Some(bi) = self.take_best_splittable_box(current_max_mse) else { 277 | break 278 | }; 279 | 280 | self.boxes.extend(bi.split()); 281 | 282 | if self.total_box_error_below_target(target_mse) { 283 | break; 284 | } 285 | } 286 | 287 | self.into_palette() 288 | } 289 | 290 | fn take_best_splittable_box(&mut self, max_mse: f64) -> Option> { 291 | self.boxes.iter().enumerate() 292 | .filter(|(_, mbox)| mbox.colors.len() > 1) 293 | .map(move |(i, mbox)| { 294 | let mut thissum = mbox.adjusted_weight_sum * mbox.variance.iter().map(|f| f as f64).sum::(); 295 | if f64::from(mbox.max_error) > max_mse { 296 | thissum = thissum * f64::from(mbox.max_error) / max_mse; 297 | } 298 | (i, thissum) 299 | }) 300 | .max_by_key(|&(_, thissum)| OrdFloat::new64(thissum)) 301 | .map(|(i, _)| self.boxes.swap_remove(i)) 302 | } 303 | } 304 | 305 | #[inline(never)] 306 | pub(crate) fn mediancut(hist: &mut HistogramInternal, target_colors: PalLen, target_mse: f64, max_mse_per_color: f64) -> Result { 307 | Ok(MedianCutter::new(hist, target_colors)?.cut(target_mse, max_mse_per_color)) 308 | } 309 | 310 | fn weighed_average_color(hist: &[HistItem]) -> f_pixel { 311 | debug_assert!(!hist.is_empty()); 312 | let mut t = f_pixel::default(); 313 | let mut sum = 0.; 314 | for c in hist { 315 | sum += c.adjusted_weight; 316 | t.0 += c.color.0 * c.adjusted_weight; 317 | } 318 | debug_assert!(sum.is_finite()); 319 | if sum != 0. { 320 | t.0 /= sum; 321 | } 322 | t 323 | } 324 | -------------------------------------------------------------------------------- /src/lib.rs: -------------------------------------------------------------------------------- 1 | //! 2 | //! 3 | //! Converts RGBA images to 8-bit with alpha channel. 4 | //! 5 | //! See `examples/` directory for example code. 6 | #![cfg_attr(all(not(feature = "std"), feature = "no_std"), no_std)] 7 | 8 | #![doc(html_logo_url = "https://pngquant.org/pngquant-logo.png")] 9 | #![deny(missing_docs)] 10 | #![allow(clippy::bool_to_int_with_if)] 11 | #![allow(clippy::cast_possible_truncation)] 12 | #![allow(clippy::doc_markdown)] 13 | #![allow(clippy::if_not_else)] 14 | #![allow(clippy::inline_always)] 15 | #![allow(clippy::items_after_statements)] 16 | #![allow(clippy::map_unwrap_or)] 17 | #![allow(clippy::missing_errors_doc)] 18 | #![allow(clippy::module_name_repetitions)] 19 | #![allow(clippy::redundant_closure_for_method_calls)] 20 | #![allow(clippy::unreadable_literal)] 21 | #![allow(clippy::wildcard_imports)] 22 | #![deny(clippy::semicolon_if_nothing_returned)] 23 | 24 | #[cfg(all(not(feature = "std"), feature = "no_std"))] 25 | extern crate alloc as std; 26 | 27 | #[cfg(all(not(feature = "std"), feature = "no_std"))] 28 | use std::vec::Vec; 29 | 30 | mod attr; 31 | mod blur; 32 | mod error; 33 | mod hist; 34 | mod image; 35 | mod kmeans; 36 | mod mediancut; 37 | mod nearest; 38 | mod pal; 39 | mod quant; 40 | mod remap; 41 | mod rows; 42 | mod seacow; 43 | 44 | #[cfg(not(feature = "threads"))] 45 | mod rayoff; 46 | 47 | #[cfg(feature = "threads")] 48 | mod rayoff { 49 | pub(crate) fn num_cpus() -> usize { std::thread::available_parallelism().map(|n| n.get()).unwrap_or(1) } 50 | pub(crate) use rayon::in_place_scope as scope; 51 | pub(crate) use rayon::prelude::{ParallelBridge, ParallelIterator, ParallelSliceMut}; 52 | pub(crate) use thread_local::ThreadLocal; 53 | } 54 | 55 | #[cfg_attr(feature = "threads", repr(align(128)))] 56 | pub(crate) struct CacheLineAlign(pub T); 57 | 58 | /// Use imagequant-sys crate instead 59 | #[cfg(feature = "_internal_c_ffi")] 60 | pub mod capi; 61 | 62 | use core::cmp::Ordering; 63 | 64 | pub use attr::{Attributes, ControlFlow}; 65 | pub use error::Error; 66 | pub use hist::{Histogram, HistogramEntry}; 67 | pub use image::Image; 68 | #[doc(hidden)] 69 | pub use pal::Palette; 70 | pub use pal::RGBA; 71 | pub use quant::QuantizationResult; 72 | 73 | #[doc(hidden)] 74 | #[deprecated(note = "Please use the imagequant::Error type. This will be removed")] 75 | pub use error::Error as liq_error; 76 | 77 | const LIQ_HIGH_MEMORY_LIMIT: usize = 1 << 26; 78 | 79 | /// [Start here][Attributes]: creates new handle for library configuration 80 | /// 81 | /// See [`Attributes`] 82 | #[inline(always)] 83 | #[must_use] 84 | pub fn new() -> Attributes { 85 | Attributes::new() 86 | } 87 | 88 | #[test] 89 | fn copy_img() { 90 | let tmp = vec![RGBA::new(1, 2, 3, 4); 10 * 100]; 91 | let liq = Attributes::new(); 92 | let _ = liq.new_image_stride(tmp, 10, 100, 10, 0.).unwrap(); 93 | } 94 | 95 | #[test] 96 | fn takes_rgba() { 97 | let liq = Attributes::new(); 98 | 99 | let img = vec![RGBA { r: 0, g: 0, b: 0, a: 0 }; 8]; 100 | 101 | liq.new_image_borrowed(&img, 1, 1, 0.0).unwrap(); 102 | liq.new_image_borrowed(&img, 4, 2, 0.0).unwrap(); 103 | liq.new_image_borrowed(&img, 8, 1, 0.0).unwrap(); 104 | assert!(liq.new_image_borrowed(&img, 9, 1, 0.0).is_err()); 105 | assert!(liq.new_image_borrowed(&img, 4, 3, 0.0).is_err()); 106 | } 107 | 108 | #[test] 109 | fn histogram() { 110 | let attr = Attributes::new(); 111 | let mut hist = Histogram::new(&attr); 112 | 113 | let bitmap1 = [RGBA { r: 0, g: 0, b: 0, a: 0 }; 1]; 114 | let mut image1 = attr.new_image(&bitmap1[..], 1, 1, 0.0).unwrap(); 115 | hist.add_image(&attr, &mut image1).unwrap(); 116 | 117 | let bitmap2 = [RGBA { r: 255, g: 255, b: 255, a: 255 }; 1]; 118 | let mut image2 = attr.new_image(&bitmap2[..], 1, 1, 0.0).unwrap(); 119 | hist.add_image(&attr, &mut image2).unwrap(); 120 | 121 | hist.add_colors(&[HistogramEntry { 122 | color: RGBA::new(255, 128, 255, 128), 123 | count: 10, 124 | }], 0.0).unwrap(); 125 | 126 | let mut res = hist.quantize(&attr).unwrap(); 127 | let pal = res.palette(); 128 | assert_eq!(3, pal.len()); 129 | } 130 | 131 | #[test] 132 | fn poke_it() { 133 | let width = 10usize; 134 | let height = 10usize; 135 | let mut fakebitmap = vec![RGBA::new(255, 255, 255, 255); width * height]; 136 | 137 | fakebitmap[0].r = 0x55; 138 | fakebitmap[0].g = 0x66; 139 | fakebitmap[0].b = 0x77; 140 | 141 | // Configure the library 142 | let mut liq = Attributes::new(); 143 | liq.set_speed(5).unwrap(); 144 | liq.set_quality(70, 99).unwrap(); 145 | liq.set_min_posterization(1).unwrap(); 146 | assert_eq!(1, liq.min_posterization()); 147 | liq.set_min_posterization(0).unwrap(); 148 | 149 | use core::sync::atomic::AtomicBool; 150 | use core::sync::atomic::Ordering::SeqCst; 151 | use std::sync::Arc; 152 | 153 | let log_called = Arc::new(AtomicBool::new(false)); 154 | let log_called2 = log_called.clone(); 155 | liq.set_log_callback(move |_attr, _msg| { 156 | log_called2.store(true, SeqCst); 157 | }); 158 | 159 | let prog_called = Arc::new(AtomicBool::new(false)); 160 | let prog_called2 = prog_called.clone(); 161 | liq.set_progress_callback(move |_perc| { 162 | prog_called2.store(true, SeqCst); 163 | ControlFlow::Continue 164 | }); 165 | 166 | // Describe the bitmap 167 | let img = &mut liq.new_image(&fakebitmap[..], width, height, 0.0).unwrap(); 168 | 169 | // The magic happens in quantize() 170 | let mut res = match liq.quantize(img) { 171 | Ok(res) => res, 172 | Err(err) => panic!("Quantization failed, because: {err:?}"), 173 | }; 174 | 175 | // Enable dithering for subsequent remappings 176 | res.set_dithering_level(1.0).unwrap(); 177 | 178 | // You can reuse the result to generate several images with the same palette 179 | let (palette, pixels) = res.remapped(img).unwrap(); 180 | 181 | assert_eq!(width * height, pixels.len()); 182 | assert_eq!(100, res.quantization_quality().unwrap()); 183 | assert_eq!(RGBA { r: 255, g: 255, b: 255, a: 255 }, palette[0]); 184 | assert_eq!(RGBA { r: 0x55, g: 0x66, b: 0x77, a: 255 }, palette[1]); 185 | 186 | assert!(log_called.load(SeqCst)); 187 | assert!(prog_called.load(SeqCst)); 188 | } 189 | 190 | #[test] 191 | fn set_importance_map() { 192 | let liq = new(); 193 | let bitmap = &[RGBA::new(255, 0, 0, 255), RGBA::new(0u8, 0, 255, 255)]; 194 | let mut img = liq.new_image(&bitmap[..], 2, 1, 0.).unwrap(); 195 | let map = &[255, 0]; 196 | img.set_importance_map(&map[..]).unwrap(); 197 | let mut res = liq.quantize(&mut img).unwrap(); 198 | let pal = res.palette(); 199 | assert_eq!(1, pal.len(), "{pal:?}"); 200 | assert_eq!(bitmap[0], pal[0]); 201 | } 202 | 203 | #[test] 204 | fn thread() { 205 | let liq = Attributes::new(); 206 | std::thread::spawn(move || { 207 | let b = vec![RGBA::new(0, 0, 0, 0); 1]; 208 | liq.new_image_borrowed(&b, 1, 1, 0.).unwrap(); 209 | }).join().unwrap(); 210 | } 211 | 212 | #[test] 213 | fn r_callback_test() { 214 | use core::mem::MaybeUninit; 215 | use core::sync::atomic::AtomicU16; 216 | use core::sync::atomic::Ordering::SeqCst; 217 | use std::sync::Arc; 218 | 219 | let called = Arc::new(AtomicU16::new(0)); 220 | let called2 = called.clone(); 221 | let mut res = { 222 | let a = new(); 223 | let get_row = move |output_row: &mut [MaybeUninit], y: usize| { 224 | assert!((0..5).contains(&y)); 225 | assert_eq!(123, output_row.len()); 226 | for (n, out) in output_row.iter_mut().enumerate() { 227 | let n = n as u8; 228 | out.write(RGBA::new(n, n, n, n)); 229 | } 230 | called2.fetch_add(1, SeqCst); 231 | }; 232 | let mut img = unsafe { 233 | Image::new_fn(&a, get_row, 123, 5, 0.).unwrap() 234 | }; 235 | a.quantize(&mut img).unwrap() 236 | }; 237 | let called = called.load(SeqCst); 238 | assert!(called > 5 && called < 50); 239 | assert_eq!(123, res.palette().len()); 240 | } 241 | 242 | #[test] 243 | fn sizes() { 244 | use core::mem::size_of; 245 | use pal::{PalF, Palette}; 246 | assert!(size_of::() < crate::pal::MAX_COLORS * (8 * 4) + 32, "{}", size_of::()); 247 | assert!(size_of::() < size_of::() + size_of::() + 100, "{}", size_of::()); 248 | assert!(size_of::() < 200); 249 | assert!(size_of::() < 300); 250 | assert!(size_of::() < 200); 251 | assert!(size_of::() <= 32); 252 | } 253 | 254 | #[doc(hidden)] 255 | pub fn _unstable_internal_kmeans_bench() -> impl FnMut() { 256 | use crate::pal::{PalF, PalPop}; 257 | 258 | let attr = new(); 259 | let mut h = hist::Histogram::new(&attr); 260 | 261 | let e = (0..10000u32).map(|i| HistogramEntry { 262 | count: i.wrapping_mul(17) % 12345, 263 | color: RGBA::new(i as u8, (i.wrapping_mul(7) >> 2) as u8, (i.wrapping_mul(11) >> 11) as u8, 255), 264 | }).collect::>(); 265 | 266 | h.add_colors(&e, 0.).unwrap(); 267 | let mut hist = h.finalize_builder(0.45455).unwrap(); 268 | 269 | let lut = pal::gamma_lut(0.45455); 270 | let mut p = PalF::new(); 271 | for i in 0..=255 { 272 | p.push(pal::f_pixel::from_rgba(&lut, RGBA::new(i | 7, i, i, 255)), PalPop::new(1.)); 273 | } 274 | 275 | move || { 276 | kmeans::Kmeans::iteration(&mut hist, &mut p, false).unwrap(); 277 | } 278 | } 279 | 280 | trait PushInCapacity { 281 | fn push_in_cap(&mut self, val: T); 282 | } 283 | 284 | impl PushInCapacity for Vec { 285 | #[track_caller] 286 | #[inline(always)] 287 | fn push_in_cap(&mut self, val: T) { 288 | debug_assert!(self.capacity() != self.len()); 289 | if self.capacity() != self.len() { 290 | self.push(val); 291 | } 292 | } 293 | } 294 | 295 | /// Rust is too conservative about sorting floats. 296 | /// This library uses only finite values, so they're sortable. 297 | #[derive(Debug, PartialEq, PartialOrd, Copy, Clone)] 298 | #[repr(transparent)] 299 | struct OrdFloat(pub(crate) T); 300 | 301 | impl Eq for OrdFloat { 302 | } 303 | 304 | impl Ord for OrdFloat { 305 | #[inline] 306 | fn cmp(&self, other: &Self) -> Ordering { 307 | self.0.partial_cmp(&other.0).unwrap_or(Ordering::Equal) 308 | } 309 | } 310 | 311 | impl Eq for OrdFloat { 312 | } 313 | 314 | impl Ord for OrdFloat { 315 | #[inline] 316 | fn cmp(&self, other: &Self) -> Ordering { 317 | self.0.partial_cmp(&other.0).unwrap_or(Ordering::Equal) 318 | } 319 | } 320 | 321 | impl OrdFloat { 322 | #[cfg_attr(debug_assertions, track_caller)] 323 | pub fn new(v: f32) -> Self { 324 | debug_assert!(v.is_finite()); 325 | Self(v) 326 | } 327 | } 328 | 329 | impl OrdFloat { 330 | #[cfg_attr(debug_assertions, track_caller)] 331 | pub fn new64(v: f64) -> Self { 332 | debug_assert!(v.is_finite()); 333 | Self(v) 334 | } 335 | } 336 | 337 | #[test] 338 | fn test_fixed_colors() { 339 | let attr = Attributes::new(); 340 | let mut h = Histogram::new(&attr); 341 | let tmp = (0..128).map(|c| HistogramEntry { 342 | color: RGBA::new(c,c,c,255), 343 | count: 1, 344 | }).collect::>(); 345 | h.add_colors(&tmp, 0.).unwrap(); 346 | for f in 200..255 { 347 | h.add_fixed_color(RGBA::new(f, f, f, 255), 0.).unwrap(); 348 | } 349 | let mut r = h.quantize(&attr).unwrap(); 350 | let pal = r.palette(); 351 | 352 | for (i, c) in (200..255).enumerate() { 353 | assert_eq!(pal[i], RGBA::new(c, c, c, 255)); 354 | } 355 | 356 | for c in 0..128 { 357 | assert!(pal[55..].iter().any(|&p| p == RGBA::new(c, c, c, 255))); 358 | } 359 | } 360 | 361 | #[cfg(all(not(feature = "std"), feature = "no_std"))] 362 | pub(crate) mod no_std_compat { 363 | pub use std::boxed::Box; 364 | pub use std::vec::Vec; 365 | pub use std::format; 366 | 367 | extern "C" { 368 | fn pow(_: f64, _: f64) -> f64; 369 | fn powf(_: f32, _: f32) -> f32; 370 | fn sqrt(_: f64) -> f64; 371 | fn sqrtf(_: f32) -> f32; 372 | } 373 | 374 | pub(crate) trait NoMath: Sized { 375 | fn mul_add(self, mul: Self, add: Self) -> Self; 376 | fn powi(self, n: u32) -> Self; 377 | fn powf(self, e: Self) -> Self; 378 | fn sqrt(self) -> Self; 379 | } 380 | 381 | impl NoMath for f32 { 382 | fn mul_add(self, mul: Self, add: Self) -> Self { 383 | self * mul + add 384 | } 385 | fn powi(self, n: u32) -> Self { 386 | assert_eq!(n, 2); 387 | self * self 388 | } 389 | fn powf(self, e: Self) -> Self { 390 | unsafe { powf(self, e) } 391 | } 392 | fn sqrt(self) -> Self { 393 | unsafe { sqrtf(self) } 394 | } 395 | } 396 | 397 | impl NoMath for f64 { 398 | fn mul_add(self, mul: Self, add: Self) -> Self { 399 | self * mul + add 400 | } 401 | fn powi(self, n: u32) -> Self { 402 | assert_eq!(n, 2); 403 | self * self 404 | } 405 | fn powf(self, e: Self) -> Self { 406 | unsafe { pow(self, e) } 407 | } 408 | fn sqrt(self) -> Self { 409 | unsafe { sqrt(self) } 410 | } 411 | } 412 | } 413 | -------------------------------------------------------------------------------- /src/attr.rs: -------------------------------------------------------------------------------- 1 | use crate::error::Error; 2 | use crate::hist::Histogram; 3 | use crate::image::Image; 4 | use crate::pal::{PalLen, MAX_COLORS, RGBA}; 5 | use crate::quant::{mse_to_quality, quality_to_mse, QuantizationResult}; 6 | use crate::remap::DitherMapMode; 7 | use std::sync::Arc; 8 | 9 | #[cfg(all(not(feature = "std"), feature = "no_std"))] 10 | use crate::no_std_compat::*; 11 | 12 | /// Starting point and settings for the quantization process 13 | #[derive(Clone)] 14 | #[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."))] 15 | pub struct Attributes { 16 | pub(crate) max_colors: PalLen, 17 | target_mse: f64, 18 | max_mse: Option, 19 | kmeans_iteration_limit: f64, 20 | kmeans_iterations: u16, 21 | feedback_loop_trials: u16, 22 | pub(crate) max_histogram_entries: u32, 23 | min_posterization_output: u8, 24 | min_posterization_input: u8, 25 | pub(crate) last_index_transparent: bool, 26 | pub(crate) use_contrast_maps: bool, 27 | pub(crate) single_threaded_dithering: bool, 28 | pub(crate) use_dither_map: DitherMapMode, 29 | speed: u8, 30 | pub(crate) progress_stage1: u8, 31 | pub(crate) progress_stage2: u8, 32 | pub(crate) progress_stage3: u8, 33 | 34 | progress_callback: Option ControlFlow + Send + Sync>>, 35 | log_callback: Option>, 36 | log_flush_callback: Option>, 37 | } 38 | 39 | impl Attributes { 40 | /// New handle for library configuration 41 | /// 42 | /// See also [`Attributes::new_image()`] 43 | #[inline] 44 | #[must_use] 45 | pub fn new() -> Self { 46 | let mut attr = Self { 47 | target_mse: 0., 48 | max_mse: None, 49 | max_colors: MAX_COLORS as PalLen, 50 | last_index_transparent: false, 51 | kmeans_iteration_limit: 0., 52 | max_histogram_entries: 0, 53 | min_posterization_output: 0, 54 | min_posterization_input: 0, 55 | kmeans_iterations: 0, 56 | feedback_loop_trials: 0, 57 | use_contrast_maps: false, 58 | use_dither_map: DitherMapMode::None, 59 | single_threaded_dithering: false, 60 | speed: 0, 61 | progress_stage1: 0, 62 | progress_stage2: 0, 63 | progress_stage3: 0, 64 | progress_callback: None, 65 | log_callback: None, 66 | log_flush_callback: None, 67 | }; 68 | let _ = attr.set_speed(4); 69 | attr 70 | } 71 | 72 | /// Make an image from RGBA pixels. 73 | /// 74 | /// The `pixels` argument can be `Vec`, or `Box<[RGBA]>` or `&[RGBA]`. 75 | /// See [`Attributes::new_image_borrowed`] for a non-copying alternative. 76 | /// 77 | /// Use 0.0 for gamma if the image is sRGB (most images are). 78 | #[inline] 79 | pub fn new_image(&self, pixels: VecRGBA, width: usize, height: usize, gamma: f64) -> Result, Error> where VecRGBA: Into> { 80 | Image::new(self, pixels, width, height, gamma) 81 | } 82 | 83 | /// Generate palette for the image 84 | pub fn quantize(&self, image: &mut Image<'_>) -> Result { 85 | let mut hist = Histogram::new(self); 86 | hist.add_image(self, image)?; 87 | hist.quantize_internal(self, false) 88 | } 89 | 90 | /// It's better to use `set_quality()` 91 | #[inline] 92 | pub fn set_max_colors(&mut self, colors: u32) -> Result<(), Error> { 93 | if !(2..=256).contains(&colors) { 94 | return Err(Error::ValueOutOfRange); 95 | } 96 | self.max_colors = colors as PalLen; 97 | Ok(()) 98 | } 99 | 100 | /// Range 0-100, roughly like JPEG. 101 | /// 102 | /// If the minimum quality can't be met, the quantization will be aborted with an error. 103 | /// 104 | /// Default is min 0, max 100, which means best effort, and never aborts the process. 105 | /// 106 | /// If max is less than 100, the library will try to use fewer colors. 107 | /// Images with fewer colors are not always smaller, due to increased dithering it causes. 108 | pub fn set_quality(&mut self, minimum: u8, target: u8) -> Result<(), Error> { 109 | if !(0..=100).contains(&target) || target < minimum { 110 | return Err(Error::ValueOutOfRange); 111 | } 112 | if target < 30 { 113 | self.verbose_print(" warning: quality set too low"); 114 | } 115 | self.target_mse = quality_to_mse(target); 116 | self.max_mse = Some(quality_to_mse(minimum)); 117 | Ok(()) 118 | } 119 | 120 | /// 1-10. 121 | /// 122 | /// Faster speeds generate images of lower quality, but may be useful 123 | /// for real-time generation of images. 124 | /// 125 | /// The default is 4. 126 | #[inline] 127 | pub fn set_speed(&mut self, value: i32) -> Result<(), Error> { 128 | if !(1..=10).contains(&value) { 129 | return Err(Error::ValueOutOfRange); 130 | } 131 | let mut iterations = (8 - value).max(0) as u16; 132 | iterations += iterations * iterations / 2; 133 | self.kmeans_iterations = iterations; 134 | self.kmeans_iteration_limit = 1. / f64::from(1 << (23 - value)); 135 | self.feedback_loop_trials = (56 - 9 * value).max(0) as _; 136 | self.max_histogram_entries = ((1 << 17) + (1 << 18) * (10 - value)) as _; 137 | self.min_posterization_input = if value >= 8 { 1 } else { 0 }; 138 | self.use_dither_map = if value <= 6 { DitherMapMode::Enabled } else { DitherMapMode::None }; 139 | if self.use_dither_map != DitherMapMode::None && value < 3 { 140 | self.use_dither_map = DitherMapMode::Always; 141 | } 142 | self.use_contrast_maps = (value <= 7) || self.use_dither_map != DitherMapMode::None; 143 | self.single_threaded_dithering = value == 1; 144 | self.speed = value as u8; 145 | self.progress_stage1 = if self.use_contrast_maps { 20 } else { 8 }; 146 | if self.feedback_loop_trials < 2 { 147 | self.progress_stage1 += 30; 148 | } 149 | self.progress_stage3 = (50 / (1 + value)) as u8; 150 | self.progress_stage2 = 100 - self.progress_stage1 - self.progress_stage3; 151 | Ok(()) 152 | } 153 | 154 | /// Number of least significant bits to ignore. 155 | /// 156 | /// Useful for generating palettes for VGA, 15-bit textures, or other retro platforms. 157 | #[inline] 158 | pub fn set_min_posterization(&mut self, value: u8) -> Result<(), Error> { 159 | if !(0..=4).contains(&value) { 160 | return Err(Error::ValueOutOfRange); 161 | } 162 | self.min_posterization_output = value; 163 | Ok(()) 164 | } 165 | 166 | /// Returns number of bits of precision truncated 167 | #[inline(always)] 168 | #[must_use] 169 | pub fn min_posterization(&self) -> u8 { 170 | self.min_posterization_output 171 | } 172 | 173 | /// Return currently set speed/quality trade-off setting 174 | #[inline(always)] 175 | #[must_use] 176 | pub fn speed(&self) -> u32 { 177 | self.speed.into() 178 | } 179 | 180 | /// Return max number of colors set 181 | #[inline(always)] 182 | #[must_use] 183 | pub fn max_colors(&self) -> u32 { 184 | self.max_colors.into() 185 | } 186 | 187 | /// Reads values set with `set_quality` 188 | #[must_use] 189 | pub fn quality(&self) -> (u8, u8) { 190 | ( 191 | self.max_mse.map_or(0, mse_to_quality), 192 | mse_to_quality(self.target_mse), 193 | ) 194 | } 195 | 196 | /// Describe dimensions of a slice of RGBA pixels 197 | /// 198 | /// Use 0.0 for gamma if the image is sRGB (most images are). 199 | #[inline] 200 | pub fn new_image_borrowed<'pixels>(&self, bitmap: &'pixels [RGBA], width: usize, height: usize, gamma: f64) -> Result, Error> { 201 | Image::new_borrowed(self, bitmap, width, height, gamma) 202 | } 203 | 204 | /// Like `new_image_stride_borrowed`, but makes a copy of the pixels. 205 | /// 206 | /// The `pixels` argument can be `Vec`, or `Box<[RGBA]>` or `&[RGBA]`. 207 | #[inline] 208 | pub fn new_image_stride(&self, pixels: VecRGBA, width: usize, height: usize, stride: usize, gamma: f64) -> Result, Error> where VecRGBA: Into> { 209 | Image::new_stride(self, pixels, width, height, stride, gamma) 210 | } 211 | 212 | #[doc(hidden)] 213 | #[deprecated(note = "use new_image_stride")] 214 | #[cold] 215 | pub fn new_image_stride_copy(&self, bitmap: &[RGBA], width: usize, height: usize, stride: usize, gamma: f64) -> Result, Error> { 216 | self.new_image_stride(bitmap, width, height, stride, gamma) 217 | } 218 | 219 | /// Set callback function to be called every time the library wants to print a message. 220 | /// 221 | /// To share data with the callback, use `Arc` or `Atomic*` types and `move ||` closures. 222 | #[inline] 223 | pub fn set_log_callback(&mut self, callback: F) { 224 | self.verbose_printf_flush(); 225 | self.log_callback = Some(Arc::new(callback)); 226 | } 227 | 228 | /// Callback for flushing output (if you buffer messages, that's the time to flush those buffers) 229 | #[inline] 230 | pub fn set_log_flush_callback(&mut self, callback: F) { 231 | self.verbose_printf_flush(); 232 | self.log_flush_callback = Some(Arc::new(callback)); 233 | } 234 | 235 | /// Set callback function to be called every time the library makes a progress. 236 | /// It can be used to cancel operation early. 237 | /// 238 | /// To share data with the callback, use `Arc` or `Atomic*` types and `move ||` closures. 239 | #[inline] 240 | pub fn set_progress_callback ControlFlow + Send + Sync + 'static>(&mut self, callback: F) { 241 | self.progress_callback = Some(Arc::new(callback)); 242 | } 243 | 244 | /// Move transparent color to the last entry in the palette 245 | /// 246 | /// This is less efficient for PNG, but required by some broken software 247 | #[inline(always)] 248 | pub fn set_last_index_transparent(&mut self, is_last: bool) { 249 | self.last_index_transparent = is_last; 250 | } 251 | 252 | // true == abort 253 | #[inline] 254 | #[must_use] 255 | pub(crate) fn progress(&self, percent: f32) -> bool { 256 | if let Some(f) = &self.progress_callback { 257 | f(percent) == ControlFlow::Break 258 | } else { 259 | false 260 | } 261 | } 262 | 263 | #[inline(always)] 264 | pub(crate) fn verbose_print(&self, msg: impl AsRef) { 265 | fn print_(a: &Attributes, msg: &str) { 266 | if let Some(f) = &a.log_callback { 267 | f(a, msg); 268 | } 269 | } 270 | print_(self, msg.as_ref()); 271 | } 272 | 273 | #[inline] 274 | pub(crate) fn verbose_printf_flush(&self) { 275 | if let Some(f) = &self.log_flush_callback { 276 | f(self); 277 | } 278 | } 279 | 280 | #[must_use] 281 | pub(crate) fn feedback_loop_trials(&self, hist_items: usize) -> u16 { 282 | let mut feedback_loop_trials = self.feedback_loop_trials; 283 | if hist_items > 5000 { 284 | feedback_loop_trials = (feedback_loop_trials * 3 + 3) / 4; 285 | } 286 | if hist_items > 25000 { 287 | feedback_loop_trials = (feedback_loop_trials * 3 + 3) / 4; 288 | } 289 | if hist_items > 50000 { 290 | feedback_loop_trials = (feedback_loop_trials * 3 + 3) / 4; 291 | } 292 | if hist_items > 100_000 { 293 | feedback_loop_trials = (feedback_loop_trials * 3 + 3) / 4; 294 | } 295 | feedback_loop_trials 296 | } 297 | 298 | /// `max_mse`, `target_mse`, user asked for perfect quality 299 | pub(crate) fn target_mse(&self, hist_items_len: usize) -> (Option, f64, bool) { 300 | let max_mse = self.max_mse.map(|mse| mse * if hist_items_len <= MAX_COLORS { 0.33 } else { 1. }); 301 | let aim_for_perfect_quality = self.target_mse == 0.; 302 | let mut target_mse = self.target_mse.max((f64::from(1 << self.min_posterization_output) / 1024.).powi(2)); 303 | if let Some(max_mse) = max_mse { 304 | target_mse = target_mse.min(max_mse); 305 | } 306 | (max_mse, target_mse, aim_for_perfect_quality) 307 | } 308 | 309 | /// returns iterations, `iteration_limit` 310 | #[must_use] 311 | pub(crate) fn kmeans_iterations(&self, hist_items_len: usize, palette_error_is_known: bool) -> (u16, f64) { 312 | let mut iteration_limit = self.kmeans_iteration_limit; 313 | let mut iterations = self.kmeans_iterations; 314 | if hist_items_len > 5000 { 315 | iterations = (iterations * 3 + 3) / 4; 316 | } 317 | if hist_items_len > 25000 { 318 | iterations = (iterations * 3 + 3) / 4; 319 | } 320 | if hist_items_len > 50000 { 321 | iterations = (iterations * 3 + 3) / 4; 322 | } 323 | if hist_items_len > 100_000 { 324 | iterations = (iterations * 3 + 3) / 4; 325 | iteration_limit *= 2.; 326 | } 327 | if iterations == 0 && !palette_error_is_known && self.max_mse.is_some() { 328 | iterations = 1; 329 | } 330 | (iterations, iteration_limit) 331 | } 332 | 333 | #[inline] 334 | #[must_use] 335 | pub(crate) fn posterize_bits(&self) -> u8 { 336 | self.min_posterization_output.max(self.min_posterization_input) 337 | } 338 | } 339 | 340 | impl Drop for Attributes { 341 | fn drop(&mut self) { 342 | self.verbose_printf_flush(); 343 | } 344 | } 345 | 346 | impl Default for Attributes { 347 | #[inline(always)] 348 | fn default() -> Self { 349 | Self::new() 350 | } 351 | } 352 | 353 | /// Result of callback in [`Attributes::set_progress_callback`] 354 | #[derive(Clone, Copy, Debug, Eq, PartialEq)] 355 | #[repr(C)] 356 | pub enum ControlFlow { 357 | /// Continue processing as normal 358 | Continue = 1, 359 | /// Abort processing and fail 360 | Break = 0, 361 | } 362 | 363 | #[test] 364 | fn counters() { 365 | let mut a = Attributes::new(); 366 | a.set_speed(10).unwrap(); 367 | let (iter, _) = a.kmeans_iterations(1000, false); 368 | assert_eq!(iter, 0); 369 | a.set_quality(80, 90).unwrap(); 370 | let (iter, limit) = a.kmeans_iterations(1000, false); 371 | assert_eq!(iter, 1); 372 | assert!(limit > 0. && limit < 0.01); 373 | 374 | let (iter, _) = a.kmeans_iterations(1000, true); 375 | assert_eq!(iter, 0); 376 | 377 | let mut a = Attributes::new(); 378 | a.set_quality(50, 80).unwrap(); 379 | 380 | let (max_mse, target_mse, aim_perfect) = a.target_mse(10000); 381 | let max_mse = max_mse.unwrap(); 382 | assert!(!aim_perfect); 383 | assert!(target_mse > 0. && target_mse < 0.01); 384 | assert!(max_mse > 0. && max_mse > target_mse && max_mse < 0.01); 385 | } 386 | 387 | #[test] 388 | fn getset() { 389 | let mut a = Attributes::new(); 390 | assert!(a.set_quality(0, 101).is_err()); 391 | assert!(a.set_quality(50, 49).is_err()); 392 | assert!(a.feedback_loop_trials(1000) > 0); 393 | 394 | let (max_mse, target_mse, aim_perfect) = a.target_mse(10000); 395 | assert!(aim_perfect); 396 | assert!(target_mse < 0.0001); 397 | assert_eq!(max_mse, None); 398 | 399 | a.set_speed(5).unwrap(); 400 | assert_eq!(5, a.speed()); 401 | assert!(a.set_speed(99).is_err()); 402 | assert!(a.set_speed(0).is_err()); 403 | 404 | a.set_max_colors(5).unwrap(); 405 | assert_eq!(5, a.max_colors()); 406 | assert!(a.set_max_colors(0).is_err()); 407 | 408 | a.set_min_posterization(2).unwrap(); 409 | assert_eq!(2, a.min_posterization()); 410 | assert_eq!(2, a.posterize_bits()); 411 | assert!(a.set_min_posterization(8).is_err()); 412 | 413 | let mut a = Attributes::new(); 414 | a.set_speed(10).unwrap(); 415 | assert_eq!(1, a.posterize_bits()); 416 | } 417 | -------------------------------------------------------------------------------- /src/image.rs: -------------------------------------------------------------------------------- 1 | use crate::attr::Attributes; 2 | use crate::blur::{liq_blur, liq_max3, liq_min3}; 3 | use crate::error::*; 4 | use crate::pal::{f_pixel, PalF, PalIndexRemap, MAX_COLORS, RGBA}; 5 | use crate::remap::DitherMapMode; 6 | use crate::rows::{DynamicRows, PixelsSource}; 7 | use crate::seacow::{RowBitmap, SeaCow}; 8 | use crate::{PushInCapacity, LIQ_HIGH_MEMORY_LIMIT}; 9 | use rgb::prelude::*; 10 | use core::mem::{self, MaybeUninit}; 11 | 12 | #[cfg(all(not(feature = "std"), feature = "no_std"))] 13 | use crate::no_std_compat::*; 14 | 15 | /// Describes image dimensions and pixels for the library 16 | /// 17 | /// Create one using [`Attributes::new_image()`]. 18 | /// 19 | /// All images are internally in the RGBA format. 20 | #[derive(Clone)] 21 | pub struct Image<'pixels> { 22 | pub(crate) px: DynamicRows<'pixels, 'pixels>, 23 | pub(crate) importance_map: Option>, 24 | pub(crate) edges: Option>, 25 | pub(crate) dither_map: Option>, 26 | pub(crate) background: Option>>, 27 | pub(crate) fixed_colors: Vec, 28 | } 29 | 30 | impl<'pixels> Image<'pixels> { 31 | /// Makes an image from RGBA pixels. 32 | /// 33 | /// See the [`rgb`] and [`bytemuck`](https://lib.rs/bytemuck) crates for making `[RGBA]` slices from `[u8]` slices. 34 | /// 35 | /// The `pixels` argument can be `Vec`, or `Box<[RGBA]>` or `&[RGBA]`. 36 | /// 37 | /// If you want to supply RGB or ARGB pixels, convert them to RGBA first, or use [`Image::new_fn`] to supply your own pixel-swapping function. 38 | /// 39 | /// Use `0.` for gamma if the image is sRGB (most images are). 40 | #[inline(always)] 41 | pub fn new(attr: &Attributes, pixels: VecRGBA, width: usize, height: usize, gamma: f64) -> Result where VecRGBA: Into> { 42 | Self::new_stride(attr, pixels, width, height, width, gamma) 43 | } 44 | 45 | /// Describe dimensions of a slice of RGBA pixels. 46 | /// 47 | /// Same as [`Image::new`], except it doesn't copy the pixels, but holds a temporary reference instead. 48 | /// 49 | /// If you want to supply RGB or ARGB pixels, use [`Image::new_fn`] to supply your own pixel-swapping function. 50 | /// 51 | /// See the [`rgb`] and [`bytemuck`](https://lib.rs/bytemuck) crates for making `[RGBA]` slices from `[u8]` slices. 52 | /// 53 | /// Use `0.` for gamma if the image is sRGB (most images are). 54 | #[inline(always)] 55 | pub fn new_borrowed(attr: &Attributes, pixels: &'pixels [RGBA], width: usize, height: usize, gamma: f64) -> Result { 56 | Self::new_stride_borrowed(attr, pixels, width, height, width, gamma) 57 | } 58 | 59 | /// Generate rows on demand using a callback function. 60 | /// 61 | /// The callback function should be cheap (e.g. just byte-swap pixels). The parameters are: line of RGBA pixels (slice's len is equal to image width), and row number (0-indexed). 62 | /// The callback will be called multiple times per row. May be called from multiple threads at once. 63 | /// 64 | /// Use `0.` for gamma if the image is sRGB (most images are). 65 | /// 66 | /// ## Safety 67 | /// 68 | /// This function is marked as unsafe, because the callback function MUST initialize the entire row (call `write` on every `MaybeUninit` pixel). 69 | /// 70 | pub unsafe fn new_fn], usize) + Send + Sync>(attr: &Attributes, convert_row_fn: F, width: usize, height: usize, gamma: f64) -> Result { 71 | let width = width.try_into().map_err(|_| ValueOutOfRange)?; 72 | let height = height.try_into().map_err(|_| ValueOutOfRange)?; 73 | Image::new_internal(attr, PixelsSource::Callback(Box::new(convert_row_fn)), width, height, gamma) 74 | } 75 | 76 | pub(crate) fn free_histogram_inputs(&mut self) { 77 | // importance_map must stay for remapping, because remap performs kmeans on potentially-unimportant pixels 78 | self.px.free_histogram_inputs(); 79 | } 80 | 81 | pub(crate) fn new_internal( 82 | attr: &Attributes, 83 | pixels: PixelsSource<'pixels, 'pixels>, 84 | width: u32, 85 | height: u32, 86 | gamma: f64, 87 | ) -> Result { 88 | if !Self::check_image_size(width, height) { 89 | return Err(ValueOutOfRange); 90 | } 91 | 92 | if !(0. ..=1.).contains(&gamma) { 93 | attr.verbose_print(" error: gamma must be >= 0 and <= 1 (try 1/gamma instead)"); 94 | return Err(ValueOutOfRange); 95 | } 96 | let img = Image { 97 | px: DynamicRows::new( 98 | width, 99 | height, 100 | pixels, 101 | if gamma > 0. { gamma } else { 0.45455 }, 102 | ), 103 | importance_map: None, 104 | edges: None, 105 | dither_map: None, 106 | background: None, 107 | fixed_colors: Vec::new(), 108 | }; 109 | // if image is huge or converted pixels are not likely to be reused then don't cache converted pixels 110 | let low_memory_hint = !attr.use_contrast_maps && attr.use_dither_map == DitherMapMode::None; 111 | let limit = if low_memory_hint { LIQ_HIGH_MEMORY_LIMIT / 8 } else { LIQ_HIGH_MEMORY_LIMIT } / mem::size_of::(); 112 | if (img.width()) * (img.height()) > limit { 113 | attr.verbose_print(" conserving memory"); // for simplicity of this API there's no explicit pixels argument, 114 | } 115 | Ok(img) 116 | } 117 | 118 | fn check_image_size(width: u32, height: u32) -> bool { 119 | if width == 0 || height == 0 { 120 | return false; 121 | } 122 | if width.max(height) as usize > i32::MAX as usize || 123 | width as usize > isize::MAX as usize / mem::size_of::() / height as usize { 124 | return false; 125 | } 126 | true 127 | } 128 | 129 | pub(crate) fn update_dither_map(&mut self, remapped_image: &RowBitmap<'_, PalIndexRemap>, palette: &PalF, uses_background: bool) -> Result<(), Error> { 130 | if self.edges.is_none() { 131 | self.contrast_maps()?; 132 | } 133 | let Some(mut edges) = self.edges.take() else { return Ok(()) }; 134 | let colors = palette.as_slice(); 135 | 136 | let width = self.width(); 137 | let mut prev_row: Option<&[_]> = None; 138 | let mut rows = remapped_image.rows().zip(edges.chunks_exact_mut(width)).peekable(); 139 | while let Some((this_row, edges)) = rows.next() { 140 | let mut lastpixel = this_row[0]; 141 | let mut lastcol = 0; 142 | for (col, px) in this_row.iter().copied().enumerate().skip(1) { 143 | if uses_background && colors[px as usize].is_fully_transparent() { 144 | // Transparency may or may not create an edge. When there's an explicit background set, assume no edge. 145 | continue; 146 | } 147 | if px != lastpixel || col == width - 1 { 148 | let mut neighbor_count = 10 * (col - lastcol); 149 | let mut i = lastcol; 150 | while i < col { 151 | if let Some(prev_row) = prev_row { 152 | let pixelabove = prev_row[i]; 153 | if pixelabove == lastpixel { neighbor_count += 15; } 154 | } 155 | if let Some((next_row, _)) = rows.peek() { 156 | let pixelbelow = next_row[i]; 157 | if pixelbelow == lastpixel { neighbor_count += 15; } 158 | } 159 | i += 1; 160 | } 161 | while lastcol <= col { 162 | edges[lastcol] = (f32::from(u16::from(edges[lastcol]) + 128) 163 | * (255. / (255 + 128) as f32) 164 | * (1. - 20. / (20 + neighbor_count) as f32)) 165 | as u8; 166 | lastcol += 1; 167 | } 168 | lastpixel = px; 169 | } 170 | } 171 | prev_row = Some(this_row); 172 | } 173 | self.dither_map = Some(edges); 174 | Ok(()) 175 | } 176 | 177 | /// Set which pixels are more important (and more likely to get a palette entry) 178 | /// 179 | /// The map must be `width`×`height` pixels large. Higher numbers = more important. 180 | pub fn set_importance_map(&mut self, map: impl Into>) -> Result<(), Error> { 181 | let map = map.into(); 182 | if map.len() != self.width() * self.height() { 183 | return Err(BufferTooSmall); 184 | } 185 | self.importance_map = Some(map); 186 | Ok(()) 187 | } 188 | 189 | /// Remap pixels assuming they will be displayed on this background. This is designed for GIF's "keep" mode. 190 | /// 191 | /// Pixels that match the background color will be made transparent if there's a fully transparent color available in the palette. 192 | /// 193 | /// The background image's pixels must outlive this image. 194 | pub fn set_background(&mut self, background: Self) -> Result<(), Error> { 195 | if background.background.is_some() { 196 | return Err(Unsupported); 197 | } 198 | if self.px.width != background.px.width || self.px.height != background.px.height { 199 | return Err(BufferTooSmall); 200 | } 201 | self.background = Some(Box::new(background)); 202 | Ok(()) 203 | } 204 | 205 | /// Reserves a color in the output palette created from this image. It behaves as if the given color was used in the image and was very important. 206 | /// 207 | /// The RGB values are assumed to have the same gamma as the image. 208 | /// 209 | /// It must be called before the image is quantized. 210 | /// 211 | /// Returns error if more than 256 colors are added. If image is quantized to fewer colors than the number of fixed colors added, then excess fixed colors will be ignored. 212 | pub fn add_fixed_color(&mut self, color: RGBA) -> Result<(), Error> { 213 | if self.fixed_colors.len() >= MAX_COLORS { return Err(Unsupported); } 214 | self.fixed_colors.try_reserve(1)?; 215 | self.fixed_colors.push_in_cap(color); 216 | Ok(()) 217 | } 218 | 219 | /// Width of the image in pixels 220 | #[must_use] 221 | #[inline(always)] 222 | pub const fn width(&self) -> usize { 223 | self.px.width as _ 224 | } 225 | 226 | /// Height of the image in pixels 227 | #[must_use] 228 | #[inline(always)] 229 | pub const fn height(&self) -> usize { 230 | self.px.height as _ 231 | } 232 | 233 | #[inline(always)] 234 | pub(crate) fn gamma(&self) -> Option { 235 | if self.px.gamma > 0. { Some(self.px.gamma) } else { None } 236 | } 237 | 238 | /// Builds two maps: 239 | /// `importance_map` - approximation of areas with high-frequency noise, except straight edges. 1=flat, 0=noisy. 240 | /// edges - noise map including all edges 241 | pub(crate) fn contrast_maps(&mut self) -> Result<(), Error> { 242 | let width = self.width(); 243 | let height = self.height(); 244 | if width < 4 || height < 4 || (3 * width * height) > LIQ_HIGH_MEMORY_LIMIT { 245 | return Ok(()); // shrug 246 | } 247 | 248 | let noise = if let Some(n) = self.importance_map.as_deref_mut() { n } else { 249 | let vec = try_zero_vec(width * height)?; 250 | self.importance_map.get_or_insert_with(move || vec.into_boxed_slice()) 251 | }; 252 | 253 | let edges = if let Some(e) = self.edges.as_mut() { e } else { 254 | let vec = try_zero_vec(width * height)?; 255 | self.edges.get_or_insert_with(move || vec.into_boxed_slice()) 256 | }; 257 | 258 | let mut rows_iter = self.px.all_rows_f()?.chunks_exact(width); 259 | 260 | let mut next_row = rows_iter.next().ok_or(Error::InvalidPointer)?; 261 | let mut curr_row = next_row; 262 | let mut prev_row; 263 | 264 | for (noise_row, edges_row) in noise[..width * height].chunks_exact_mut(width).zip(edges[..width * height].chunks_exact_mut(width)) { 265 | prev_row = curr_row; 266 | curr_row = next_row; 267 | next_row = rows_iter.next().unwrap_or(next_row); 268 | let mut prev; 269 | let mut curr = curr_row[0].0; 270 | let mut next = curr; 271 | for i in 0..width { 272 | prev = curr; 273 | curr = next; 274 | next = curr_row[(i + 1).min(width - 1)].0; 275 | // contrast is difference between pixels neighbouring horizontally and vertically 276 | let horiz = (prev + next - curr * 2.).map(f32::abs); // noise is amplified 277 | let prevl = prev_row[i].0; 278 | let nextl = next_row[i].0; 279 | let vert = (prevl + nextl - curr * 2.).map(f32::abs); 280 | let horiz = horiz.a.max(horiz.r).max(horiz.g.max(horiz.b)); 281 | let vert = vert.a.max(vert.r).max(vert.g.max(vert.b)); 282 | let edge = horiz.max(vert); 283 | let mut z = (horiz - vert).abs().mul_add(-0.5, edge); 284 | z = 1. - z.max(horiz.min(vert)); 285 | z *= z; 286 | z *= z; 287 | // 85 is about 1/3rd of weight (not 0, because noisy pixels still need to be included, just not as precisely). 288 | noise_row[i] = z.mul_add(176., 80.) as u8; 289 | edges_row[i] = ((1. - edge) * 256.) as u8; 290 | } 291 | } 292 | // noise areas are shrunk and then expanded to remove thin edges from the map 293 | let mut tmp = try_zero_vec(width * height)?; 294 | liq_max3(noise, &mut tmp, width, height); 295 | liq_max3(&tmp, noise, width, height); 296 | liq_blur(noise, &mut tmp, width, height, 3); 297 | liq_max3(noise, &mut tmp, width, height); 298 | liq_min3(&tmp, noise, width, height); 299 | liq_min3(noise, &mut tmp, width, height); 300 | liq_min3(&tmp, noise, width, height); 301 | liq_min3(edges, &mut tmp, width, height); 302 | liq_max3(&tmp, edges, width, height); 303 | for (edges, noise) in edges.iter_mut().zip(noise) { 304 | *edges = (*noise).min(*edges); 305 | } 306 | Ok(()) 307 | } 308 | 309 | /// Stride is in pixels. Allows defining regions of larger images or images with padding without copying. The stride is in pixels. 310 | /// 311 | /// Otherwise the same as [`Image::new_borrowed`]. 312 | #[inline(always)] 313 | pub fn new_stride_borrowed(attr: &Attributes, pixels: &'pixels [RGBA], width: usize, height: usize, stride: usize, gamma: f64) -> Result { 314 | Self::new_stride_internal(attr, SeaCow::borrowed(pixels), width, height, stride, gamma) 315 | } 316 | 317 | /// Create new image by copying `pixels` to an internal buffer, so that it makes a self-contained type. 318 | /// 319 | /// The `pixels` argument can be `Vec`, or `Box<[RGBA]>` or `&[RGBA]`. 320 | /// 321 | /// Otherwise the same as [`Image::new_stride_borrowed`]. 322 | #[inline] 323 | pub fn new_stride(attr: &Attributes, pixels: VecRGBA, width: usize, height: usize, stride: usize, gamma: f64) -> Result, Error> where VecRGBA: Into> { 324 | Self::new_stride_internal(attr, SeaCow::boxed(pixels.into()), width, height, stride, gamma) 325 | } 326 | 327 | fn new_stride_internal<'a>(attr: &Attributes, pixels: SeaCow<'a, RGBA>, width: usize, height: usize, stride: usize, gamma: f64) -> Result, Error> { 328 | let width = width.try_into().map_err(|_| ValueOutOfRange)?; 329 | let height = height.try_into().map_err(|_| ValueOutOfRange)?; 330 | let stride = stride.try_into().map_err(|_| ValueOutOfRange)?; 331 | 332 | let pixels_len = pixels.as_slice().len(); 333 | let pixels_rows = match PixelsSource::for_pixels(pixels, width, height, stride) { 334 | Ok(p) => p, 335 | Err(e) => { 336 | attr.verbose_print(format!("Buffer length is {} bytes, which is not enough for {}×{}×4 RGBA bytes", pixels_len * 4, stride, height)); 337 | return Err(e); 338 | }, 339 | }; 340 | Image::new_internal(attr, pixels_rows, width, height, gamma) 341 | } 342 | } 343 | 344 | fn try_zero_vec(len: usize) -> Result, Error> { 345 | let mut vec = Vec::new(); 346 | vec.try_reserve_exact(len)?; 347 | vec.resize(len, 0); 348 | Ok(vec) 349 | } 350 | -------------------------------------------------------------------------------- /src/remap.rs: -------------------------------------------------------------------------------- 1 | use crate::error::Error; 2 | use crate::image::Image; 3 | use crate::kmeans::Kmeans; 4 | use crate::nearest::Nearest; 5 | use crate::pal::{f_pixel, PalF, PalIndexRemap, Palette, ARGBF}; 6 | use crate::quant::QuantizationResult; 7 | use crate::rayoff::*; 8 | use crate::rows::{temp_buf, DynamicRows}; 9 | use crate::seacow::{RowBitmap, RowBitmapMut}; 10 | use crate::CacheLineAlign; 11 | use core::cell::RefCell; 12 | use core::mem::MaybeUninit; 13 | 14 | #[cfg(all(not(feature = "std"), feature = "no_std"))] 15 | use crate::no_std_compat::*; 16 | 17 | #[repr(u8)] 18 | #[derive(Eq, PartialEq, Clone, Copy)] 19 | pub enum DitherMapMode { 20 | None = 0, 21 | Enabled = 1, 22 | Always = 2, 23 | } 24 | 25 | #[derive(Clone)] 26 | pub(crate) struct Remapped { 27 | pub(crate) int_palette: Palette, 28 | pub(crate) palette_error: Option, 29 | } 30 | 31 | #[inline(never)] 32 | pub(crate) fn remap_to_palette<'x, 'b: 'x>(px: &mut DynamicRows, background: Option<&mut Image<'_>>, importance_map: Option<&[u8]>, output_pixels: &'x mut RowBitmapMut<'b, MaybeUninit>, palette: &mut PalF) -> Result<(f64, RowBitmap<'x, PalIndexRemap>), Error> { 33 | let n = Nearest::new(palette)?; 34 | let colors = palette.as_slice(); 35 | let palette_len = colors.len(); 36 | if palette_len > PalIndexRemap::MAX as usize + 1 { 37 | return Err(Error::Unsupported); 38 | } 39 | 40 | let tls = ThreadLocal::new(); 41 | let width = px.width as usize; 42 | let per_thread_buffers = move || -> Result<_, Error> { Ok(CacheLineAlign(RefCell::new((Kmeans::new(palette_len)?, temp_buf(width)?, temp_buf(width)?, temp_buf(width)?)))) }; 43 | 44 | let tls_tmp1 = tls.get_or_try(per_thread_buffers)?; 45 | let mut tls_tmp = tls_tmp1.0.borrow_mut(); 46 | 47 | let input_rows = px.rows_iter(&mut tls_tmp.1)?; 48 | let (background, transparent_index) = background.map(|background| { 49 | (Some(background), n.search(&f_pixel::default(), 0).0 as PalIndexRemap) 50 | }) 51 | .filter(|&(_, transparent_index)| colors[usize::from(transparent_index)].is_fully_transparent()) 52 | .unwrap_or((None, 0)); 53 | let background = background.map(|bg| bg.px.rows_iter(&mut tls_tmp.1)).transpose()?; 54 | 55 | if background.is_some() { 56 | tls_tmp.0.update_color(f_pixel::default(), 1., transparent_index as _); 57 | } 58 | 59 | drop(tls_tmp); 60 | 61 | let remapping_error = output_pixels.rows_mut().enumerate().par_bridge().map(|(row, output_pixels_row)| { 62 | let mut remapping_error = 0.; 63 | #[allow(irrefutable_let_patterns)] 64 | let Ok(tls_res) = tls.get_or_try(per_thread_buffers) else { return f64::NAN }; 65 | let (kmeans, temp_row, temp_row_f, temp_row_f_bg) = &mut *tls_res.0.borrow_mut(); 66 | 67 | let output_pixels_row = &mut output_pixels_row[..width]; 68 | let importance_map = importance_map.and_then(|m| m.get(row * width..)).unwrap_or(&[]); 69 | let row_pixels = &input_rows.row_f_shared(temp_row, temp_row_f, row)[..width]; 70 | let bg_pixels = if let Some(background) = &background { 71 | &background.row_f_shared(temp_row, temp_row_f_bg, row)[..width] 72 | } else { &[] }; 73 | 74 | let mut last_match = 0; 75 | for (col, (inp, out)) in row_pixels.iter().zip(output_pixels_row).enumerate() { 76 | let (matched, diff) = n.search(inp, last_match as _); 77 | let matched = matched as PalIndexRemap; 78 | last_match = matched; 79 | if let Some(bg) = bg_pixels.get(col) { 80 | let bg_diff = bg.diff(inp); 81 | if bg_diff <= diff { 82 | remapping_error += f64::from(bg_diff); 83 | out.write(transparent_index); 84 | continue; 85 | } 86 | } 87 | remapping_error += f64::from(diff); 88 | out.write(matched); 89 | let importance = f32::from(importance_map.get(col).copied().unwrap_or(1)); 90 | kmeans.update_color(*inp, importance, matched as _); 91 | } 92 | remapping_error 93 | }) 94 | .sum::(); 95 | 96 | if remapping_error.is_nan() { 97 | return Err(Error::OutOfMemory); 98 | } 99 | 100 | if let Some(kmeans) = tls.into_iter() 101 | .map(|t| t.0.into_inner().0) 102 | .reduce(Kmeans::merge) { kmeans.finalize(palette); } 103 | 104 | let remapping_error = remapping_error / f64::from(px.width * px.height); 105 | Ok((remapping_error, unsafe { output_pixels.assume_init() })) 106 | } 107 | 108 | fn get_dithered_pixel(dither_level: f32, max_dither_error: f32, thiserr: f_pixel, px: f_pixel) -> f_pixel { 109 | let s = thiserr.0 * dither_level; 110 | // This prevents gaudy green pixels popping out of the blue (or red or black! ;) 111 | let dither_error = s.r.mul_add(s.r, s.g * s.g) + s.b.mul_add(s.b, s.a * s.a); 112 | if dither_error < 2. / 256. / 256. { 113 | // don't dither areas that don't have noticeable error — makes file smaller 114 | return px; 115 | } 116 | 117 | let mut ratio: f32 = 1.; 118 | const MAX_OVERFLOW: f32 = 1.1; 119 | const MAX_UNDERFLOW: f32 = -0.1; 120 | // allowing some overflow prevents undithered bands caused by clamping of all channels 121 | if px.r + s.r > MAX_OVERFLOW { 122 | ratio = ratio.min((MAX_OVERFLOW - px.r) / s.r); 123 | } else if px.r + s.r < MAX_UNDERFLOW { 124 | ratio = ratio.min((MAX_UNDERFLOW - px.r) / s.r); 125 | } 126 | if px.g + s.g > MAX_OVERFLOW { 127 | ratio = ratio.min((MAX_OVERFLOW - px.g) / s.g); 128 | } else if px.g + s.g < MAX_UNDERFLOW { 129 | ratio = ratio.min((MAX_UNDERFLOW - px.g) / s.g); 130 | } 131 | if px.b + s.b > MAX_OVERFLOW { 132 | ratio = ratio.min((MAX_OVERFLOW - px.b) / s.b); 133 | } else if px.b + s.b < MAX_UNDERFLOW { 134 | ratio = ratio.min((MAX_UNDERFLOW - px.b) / s.b); 135 | } 136 | if dither_error > max_dither_error { 137 | ratio *= 0.8; 138 | } 139 | f_pixel(ARGBF { 140 | a: (px.a + s.a).clamp(0., 1.), 141 | r: s.r.mul_add(ratio, px.r), 142 | g: s.g.mul_add(ratio, px.g), 143 | b: s.b.mul_add(ratio, px.b), 144 | }) 145 | } 146 | 147 | /// Uses edge/noise map to apply dithering only to flat areas. Dithering on edges creates jagged lines, and noisy areas are "naturally" dithered. 148 | /// 149 | /// If `output_image_is_remapped` is true, only pixels noticeably changed by error diffusion will be written to output image. 150 | #[inline(never)] 151 | pub(crate) fn remap_to_palette_floyd(input_image: &mut Image, mut output_pixels: RowBitmapMut<'_, MaybeUninit>, palette: &PalF, quant: &QuantizationResult, max_dither_error: f32, output_image_is_remapped: bool) -> Result<(), Error> { 152 | let progress_stage1 = if quant.use_dither_map != DitherMapMode::None { 20 } else { 0 }; 153 | 154 | let width = input_image.width(); 155 | let height = input_image.height(); 156 | 157 | let mut temp_row = temp_buf(width)?; 158 | 159 | let dither_map = if quant.use_dither_map != DitherMapMode::None { 160 | input_image.dither_map.as_deref().or(input_image.edges.as_deref()).unwrap_or(&[]) 161 | } else { 162 | &[] 163 | }; 164 | 165 | let n = Nearest::new(palette)?; 166 | let palette = palette.as_slice(); 167 | 168 | let mut background = input_image.background.as_mut().map(|bg| { 169 | bg.px.prepare_iter(&mut temp_row, true)?; 170 | Ok::<_, Error>(&bg.px) 171 | }).transpose()?; 172 | 173 | let transparent_index = if background.is_some() { n.search(&f_pixel::default(), 0).0 as PalIndexRemap } else { 0 }; 174 | if background.is_some() && !palette[transparent_index as usize].is_fully_transparent() { 175 | background = None; 176 | } 177 | // response to this value is non-linear and without it any value < 0.8 would give almost no dithering 178 | let mut base_dithering_level = (1. - quant.dither_level).mul_add(-(1. - quant.dither_level), 1.) * (15. / 16.); // prevent small errors from accumulating 179 | if !dither_map.is_empty() { 180 | base_dithering_level *= 1. / 255.; // dither_map is in 0-255 scale 181 | } 182 | 183 | // when using remapping on top of a background, lots of pixels may be transparent, making poor guesses 184 | // (guesses are only for speed, don't affect visuals) 185 | let guess_from_remapped_pixels = output_image_is_remapped && background.is_none(); 186 | 187 | input_image.px.prepare_iter(&mut temp_row, true)?; 188 | let input_image_px = &input_image.px; 189 | let n = &n; 190 | 191 | // Chunks have overhead, so should be big (more than 2 bring diminishing results). Chunks risk causing seams, so should be tall. 192 | let num_chunks = if quant.single_threaded_dithering { 1 } else { (width * height / 524_288).min(height / 128).max(if height > 128 {2} else {1}).min(num_cpus()) }; 193 | let chunks = output_pixels.chunks((height + num_chunks - 1) / num_chunks).map(CacheLineAlign); 194 | scope(move |s| { 195 | let mut chunk_start_row = 0; 196 | for mut chunk in chunks { 197 | let chunk_len = chunk.0.len(); 198 | let mut temp_row = temp_buf(width)?; 199 | let mut input_image_iter = input_image_px.rows_iter_prepared()?; 200 | let mut background = background.map(|bg| bg.rows_iter_prepared()).transpose()?; 201 | let mut diffusion = Vec::new(); 202 | let errwidth = width + 2; // +2 saves from checking out of bounds access 203 | diffusion.try_reserve_exact(errwidth * 2)?; 204 | diffusion.resize(errwidth * 2, f_pixel::default()); 205 | 206 | // restart of dithering creates a seam. this does redundant work to init diffusion state, 207 | // so that later chunks don't start from scratch 208 | if chunk_start_row > 2 { 209 | let mut discard_row = temp_buf(width)?; 210 | for row in (chunk_start_row - 2) .. chunk_start_row { 211 | let row_pixels = input_image_iter.row_f(&mut temp_row, row as _); 212 | let bg_pixels = background.as_mut().map(|b| b.row_f(&mut temp_row, row as _)).unwrap_or(&[]); 213 | let dither_map = dither_map.get(row * width .. row * width + width).unwrap_or(&[]); 214 | let scan_forward = row & 1 == 0; 215 | dither_row(row_pixels, &mut discard_row, width as u32, dither_map, base_dithering_level, max_dither_error, n, palette, transparent_index, bg_pixels, guess_from_remapped_pixels, &mut diffusion, scan_forward); 216 | } 217 | } 218 | // parallel remap makes progress not very useful 219 | if quant.remap_progress(progress_stage1 as f32 + chunk_start_row as f32 * (100. - progress_stage1 as f32) / height as f32) { 220 | return Err(Error::Aborted); 221 | } 222 | s.spawn(move |_| { 223 | for (chunk_row, output_pixels_row) in chunk.0.rows_mut().enumerate() { 224 | let row = chunk_start_row + chunk_row; 225 | let row_pixels = input_image_iter.row_f(&mut temp_row, row as _); 226 | let bg_pixels = background.as_mut().map(|b| b.row_f(&mut temp_row, row as _)).unwrap_or(&[]); 227 | let dither_map = dither_map.get(row * width .. row * width + width).unwrap_or(&[]); 228 | let scan_forward = row & 1 == 0; 229 | dither_row(row_pixels, output_pixels_row, width as u32, dither_map, base_dithering_level, max_dither_error, n, palette, transparent_index, bg_pixels, guess_from_remapped_pixels, &mut diffusion, scan_forward); 230 | } 231 | }); 232 | chunk_start_row += chunk_len; 233 | } 234 | Ok(()) 235 | }) 236 | } 237 | 238 | #[inline(never)] 239 | fn dither_row(row_pixels: &[f_pixel], output_pixels_row: &mut [MaybeUninit], width: u32, dither_map: &[u8], base_dithering_level: f32, max_dither_error: f32, n: &Nearest, palette: &[f_pixel], transparent_index: PalIndexRemap, bg_pixels: &[f_pixel], guess_from_remapped_pixels: bool, diffusion: &mut [f_pixel], even_row: bool) { 240 | let width = width as usize; 241 | assert_eq!(row_pixels.len(), width); 242 | assert_eq!(output_pixels_row.len(), width); 243 | 244 | let (thiserr, nexterr) = { 245 | // +2 saves from checking out of bounds access 246 | let (d1, d2) = diffusion.split_at_mut(width + 2); 247 | if even_row { (d1, d2) } else { (d2, d1) } 248 | }; 249 | 250 | nexterr.fill_with(f_pixel::default); 251 | 252 | let mut undithered_bg_used = 0u8; 253 | let mut last_match = 0; 254 | for x in 0..width { 255 | let col = if even_row { x } else { width - 1 - x }; 256 | let thiserr = &mut thiserr[col .. col + 3]; 257 | let nexterr = &mut nexterr[col .. col + 3]; 258 | let input_px = row_pixels[col]; 259 | 260 | let mut dither_level = base_dithering_level; 261 | if let Some(&l) = dither_map.get(col) { 262 | dither_level *= f32::from(l); 263 | } 264 | 265 | let spx = get_dithered_pixel(dither_level, max_dither_error, thiserr[1], input_px); 266 | let guessed_match = if guess_from_remapped_pixels { 267 | unsafe { output_pixels_row[col].assume_init() } 268 | } else { 269 | last_match 270 | }; 271 | let (matched, dither_diff) = n.search(&spx, guessed_match as _); 272 | let mut matched = matched as PalIndexRemap; 273 | last_match = matched as PalIndexRemap; 274 | let mut output_px = palette[last_match as usize]; 275 | if let Some(bg_pixel) = bg_pixels.get(col) { 276 | // if the background makes better match *with* dithering, it's a definitive win 277 | let bg_for_dither_diff = spx.diff(bg_pixel); 278 | if bg_for_dither_diff <= dither_diff { 279 | output_px = *bg_pixel; 280 | matched = transparent_index; 281 | } else if undithered_bg_used > 1 { 282 | // the undithered fallback can cause artifacts when too many undithered pixels accumulate a big dithering error 283 | // so periodically ignore undithered fallback to prevent that 284 | undithered_bg_used = 0; 285 | } else { 286 | // if dithering is not applied, there's a high risk of creating artifacts (flat areas, error accumulating badly), 287 | // OTOH poor dithering disturbs static backgrounds and creates oscilalting frames that break backgrounds 288 | // back and forth in two differently bad ways 289 | let max_diff = input_px.diff(bg_pixel); 290 | let dithered_diff = input_px.diff(&output_px); 291 | // if dithering is worse than natural difference between frames 292 | // (this rule dithers moving areas, but does not dither static areas) 293 | if dithered_diff > max_diff { 294 | // then see if an undithered color is closer to the ideal 295 | let guessed_px = palette[guessed_match as usize]; 296 | let undithered_diff = input_px.diff(&guessed_px); // If dithering error is crazy high, don't propagate it that much 297 | if undithered_diff < max_diff { 298 | undithered_bg_used += 1; 299 | output_px = guessed_px; 300 | matched = guessed_match; 301 | } 302 | } 303 | } 304 | } 305 | output_pixels_row[col].write(matched); 306 | let mut err = spx.0 - output_px.0; 307 | // This prevents weird green pixels popping out of the blue (or red or black! ;) 308 | if err.r.mul_add(err.r, err.g * err.g) + err.b.mul_add(err.b, err.a * err.a) > max_dither_error { 309 | err *= 0.75; 310 | } 311 | if even_row { 312 | thiserr[2].0 += err * (7. / 16.); 313 | nexterr[0].0 += err * (3. / 16.); 314 | nexterr[1].0 += err * (5. / 16.); 315 | nexterr[2].0 = err * (1. / 16.); 316 | } else { 317 | thiserr[0].0 += err * (7. / 16.); 318 | nexterr[0].0 = err * (1. / 16.); 319 | nexterr[1].0 += err * (5. / 16.); 320 | nexterr[2].0 += err * (3. / 16.); 321 | } 322 | } 323 | } 324 | 325 | #[test] 326 | fn send() { 327 | fn is_send() {} 328 | 329 | is_send::>>(); 330 | } 331 | 332 | #[test] 333 | fn background_to_nop() { 334 | use crate::RGBA; 335 | let pixels: Vec<_> = (0..200*200).map(|n| RGBA::new(n as u8, (n/17) as u8, (n/78) as u8, 255)).collect(); 336 | 337 | let mut attr = crate::new(); 338 | let mut img = attr.new_image_borrowed(&pixels, 200, 200, 0.).unwrap(); 339 | let img2 = attr.new_image_borrowed(&pixels, 200, 200, 0.).unwrap(); 340 | img.set_background(img2).unwrap(); 341 | img.add_fixed_color(RGBA::new(0,0,0,0)).unwrap(); 342 | attr.set_max_colors(3).unwrap(); 343 | let mut res = attr.quantize(&mut img).unwrap(); 344 | res.set_dithering_level(0.).unwrap(); 345 | let (_, idx) = res.remapped(&mut img).unwrap(); 346 | let first = idx[0]; 347 | assert!(idx.iter().all(|&x| x == first)); 348 | 349 | res.set_dithering_level(1.).unwrap(); 350 | let (_, idx) = res.remapped(&mut img).unwrap(); 351 | let first = idx[0]; 352 | assert!(idx.iter().all(|&x| x == first)); 353 | } 354 | -------------------------------------------------------------------------------- /src/hist.rs: -------------------------------------------------------------------------------- 1 | use crate::error::*; 2 | use crate::image::Image; 3 | use crate::pal::{f_pixel, gamma_lut, PalIndex, ARGBF, MAX_COLORS, RGBA}; 4 | use crate::quant::QuantizationResult; 5 | use crate::rows::{temp_buf, DynamicRows}; 6 | use crate::Attributes; 7 | use core::{fmt, hash, mem}; 8 | use core::hash::Hash; 9 | 10 | #[cfg(all(not(feature = "std"), feature = "no_std"))] 11 | use std::{format, boxed::Box, vec::Vec}; 12 | 13 | #[cfg(all(not(feature = "std"), feature = "no_std"))] 14 | use hashbrown::{HashMap, HashSet}; 15 | 16 | #[cfg(not(all(not(feature = "std"), feature = "no_std")))] 17 | use std::collections::{HashMap, HashSet}; 18 | 19 | 20 | /// Number of pixels in a given color for [`Histogram::add_colors()`] 21 | /// 22 | /// Used for building a histogram manually. Otherwise see [`Histogram::add_image()`] 23 | #[repr(C)] 24 | #[derive(Debug, Copy, Clone)] 25 | pub struct HistogramEntry { 26 | /// The color 27 | pub color: RGBA, 28 | /// Importance of the color (e.g. number of occurrences) 29 | pub count: u32, 30 | } 31 | 32 | /// Generate one shared palette for multiple images 33 | /// 34 | /// If you're converting one image at a time, see [`Attributes::new_image`] instead 35 | pub struct Histogram { 36 | gamma: Option, 37 | fixed_colors: FixedColorsSet, 38 | 39 | /// The key is the RGBA cast to u32 40 | /// The value is a (boosted) count or 0 if it's a fixed color 41 | hashmap: HashMap, 42 | 43 | posterize_bits: u8, 44 | max_histogram_entries: u32, 45 | } 46 | 47 | pub(crate) type FixedColorsSet = HashSet; 48 | 49 | #[derive(Clone)] 50 | pub(crate) struct HistItem { 51 | pub color: f_pixel, 52 | pub adjusted_weight: f32, 53 | pub perceptual_weight: f32, 54 | /// temporary in median cut 55 | pub mc_color_weight: f32, 56 | pub tmp: HistSortTmp, 57 | } 58 | 59 | impl HistItem { 60 | // Safety: just an int, and it's been initialized when constructing the object 61 | #[inline(always)] 62 | pub fn mc_sort_value(&self) -> u32 { 63 | unsafe { self.tmp.mc_sort_value } 64 | } 65 | 66 | // The u32 has been initialized when constructing the object, and u8/u16 is smaller than that 67 | #[inline(always)] 68 | pub fn likely_palette_index(&self) -> PalIndex { 69 | assert!(mem::size_of::() <= mem::size_of::()); 70 | unsafe { self.tmp.likely_palette_index } 71 | } 72 | } 73 | 74 | impl fmt::Debug for HistItem { 75 | #[cold] 76 | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 77 | f.debug_struct("HistItem") 78 | .field("color", &self.color) 79 | .field("adjusted_weight", &self.adjusted_weight) 80 | .field("perceptual_weight", &self.perceptual_weight) 81 | .field("color_weight", &self.mc_color_weight) 82 | .finish() 83 | } 84 | } 85 | 86 | #[repr(C)] 87 | #[derive(Clone, Copy)] 88 | pub union HistSortTmp { 89 | pub mc_sort_value: u32, 90 | pub likely_palette_index: PalIndex, 91 | } 92 | 93 | impl Histogram { 94 | /// Creates histogram object that will be used to collect color statistics from multiple images. 95 | /// 96 | /// All options should be set on `attr` before the histogram object is created. Options changed later may not have effect. 97 | #[inline] 98 | #[must_use] 99 | pub fn new(attr: &Attributes) -> Self { 100 | Self { 101 | posterize_bits: attr.posterize_bits(), 102 | max_histogram_entries: attr.max_histogram_entries, 103 | fixed_colors: HashSet::with_hasher(U32Hasher(0)), 104 | hashmap: HashMap::with_hasher(U32Hasher(0)), 105 | gamma: None, 106 | } 107 | } 108 | 109 | /// "Learns" colors from the image, which will be later used to generate the palette. 110 | /// 111 | /// Fixed colors added to the image are also added to the histogram. If the total number of fixed colors exceeds 256, 112 | /// this function will fail with `LIQ_BUFFER_TOO_SMALL`. 113 | #[inline(never)] 114 | pub fn add_image(&mut self, attr: &Attributes, image: &mut Image) -> Result<(), Error> { 115 | let width = image.width(); 116 | let height = image.height(); 117 | if image.importance_map.is_none() && attr.use_contrast_maps { 118 | image.contrast_maps()?; 119 | } 120 | 121 | self.gamma = image.gamma(); 122 | 123 | if !image.fixed_colors.is_empty() { 124 | self.fixed_colors.extend(image.fixed_colors.iter().copied().enumerate().map(|(idx, rgba)| { 125 | HashColor { rgba, index: idx as _ } 126 | })); 127 | } 128 | 129 | if attr.progress(f32::from(attr.progress_stage1) * 0.40) { 130 | return Err(Aborted); // bow can free the RGBA source if copy has been made in f_pixels 131 | } 132 | 133 | let posterize_bits = attr.posterize_bits(); 134 | let surface_area = height * width; 135 | let estimated_colors = (surface_area / (posterize_bits as usize + if surface_area > 512 * 512 { 7 } else { 5 })).min(250_000); 136 | self.reserve(estimated_colors); 137 | 138 | self.add_pixel_rows(&image.px, image.importance_map.as_deref(), posterize_bits)?; 139 | 140 | Ok(()) 141 | } 142 | 143 | /// Alternative to `add_image()`. Intead of counting colors in an image, it directly takes an array of colors and their counts. 144 | /// 145 | /// This function is only useful if you already have a histogram of the image from another source. 146 | /// 147 | /// The gamma may be 0 to mean sRGB. All calls to `add_colors` and `add_fixed_color` should use the same gamma value. 148 | #[inline(never)] 149 | pub fn add_colors(&mut self, entries: &[HistogramEntry], gamma: f64) -> Result<(), Error> { 150 | if entries.is_empty() || entries.len() > 1 << 24 { 151 | return Err(ValueOutOfRange); 152 | } 153 | 154 | if !(0. ..1.).contains(&gamma) { 155 | return Err(ValueOutOfRange); 156 | } 157 | 158 | if self.gamma.is_none() && gamma > 0. { 159 | self.gamma = Some(gamma); 160 | } 161 | 162 | self.reserve(entries.len()); 163 | 164 | for e in entries { 165 | self.add_color(e.color, e.count); 166 | } 167 | 168 | Ok(()) 169 | } 170 | 171 | /// Add a color guaranteed to be in the final palette 172 | /// 173 | /// The gamma may be 0 to mean sRGB. All calls to `add_colors` and `add_fixed_color` should use the same gamma value. 174 | pub fn add_fixed_color(&mut self, rgba: RGBA, gamma: f64) -> Result<(), Error> { 175 | if self.fixed_colors.len() >= MAX_COLORS { 176 | return Err(Unsupported); 177 | } 178 | 179 | if self.gamma.is_none() && gamma > 0. { 180 | self.gamma = Some(gamma); 181 | } 182 | 183 | let idx = self.fixed_colors.len(); 184 | self.fixed_colors.insert(HashColor { rgba, index: idx as _ }); 185 | 186 | Ok(()) 187 | } 188 | 189 | /// Generate palette for all images/colors added to the histogram. 190 | /// 191 | /// Palette generated using this function won't be improved during remapping. 192 | /// If you're generating palette for only one image, it's better not to use the `Histogram`. 193 | #[inline] 194 | pub fn quantize(&mut self, attr: &Attributes) -> Result { 195 | self.quantize_internal(attr, true) 196 | } 197 | 198 | #[inline(never)] 199 | pub(crate) fn quantize_internal(&mut self, attr: &Attributes, freeze_result_colors: bool) -> Result { 200 | if self.hashmap.is_empty() && self.fixed_colors.is_empty() { 201 | return Err(Unsupported); 202 | } 203 | 204 | if attr.progress(0.) { return Err(Aborted); } 205 | if attr.progress(f32::from(attr.progress_stage1) * 0.89) { 206 | return Err(Aborted); 207 | } 208 | 209 | let gamma = self.gamma.unwrap_or(0.45455); 210 | let hist = self.finalize_builder(gamma).map_err(|_| OutOfMemory)?; 211 | 212 | attr.verbose_print(format!(" made histogram...{} colors found", hist.items.len())); 213 | 214 | QuantizationResult::new(attr, hist, freeze_result_colors, gamma) 215 | } 216 | 217 | #[inline(always)] 218 | fn add_color(&mut self, rgba: RGBA, boost: u32) { 219 | if boost == 0 { 220 | return; 221 | } 222 | 223 | let px_int = if rgba.a != 0 { 224 | self.posterize_mask() & unsafe { RGBAInt { rgba }.int } 225 | } else { 0 }; 226 | 227 | self.hashmap.entry(px_int) 228 | // it can overflow on images over 2^24 pixels large 229 | .and_modify(move |e| e.0 = e.0.saturating_add(boost)) 230 | .or_insert((boost, rgba)); 231 | } 232 | 233 | fn reserve(&mut self, entries: usize) { 234 | let new_entries = entries.saturating_sub(self.hashmap.len() / 3); // assume some will be dupes, if called multiple times 235 | self.hashmap.reserve(new_entries); 236 | } 237 | 238 | #[inline(always)] 239 | const fn posterize_mask(&self) -> u32 { 240 | let channel_mask = 255 << self.posterize_bits; 241 | u32::from_ne_bytes([channel_mask, channel_mask, channel_mask, channel_mask]) 242 | } 243 | 244 | /// optionallys et 245 | fn init_posterize_bits(&mut self, posterize_bits: u8) { 246 | if self.posterize_bits >= posterize_bits { 247 | return; 248 | } 249 | self.posterize_bits = posterize_bits; 250 | let new_posterize_mask = self.posterize_mask(); 251 | 252 | let new_size = (self.hashmap.len() / 3).max(self.hashmap.capacity() / 5); 253 | let old_hashmap = mem::replace(&mut self.hashmap, HashMap::with_capacity_and_hasher(new_size, U32Hasher(0))); 254 | self.hashmap.extend(old_hashmap.into_iter().map(move |(k, v)| { 255 | (k & new_posterize_mask, v) 256 | })); 257 | } 258 | 259 | pub(crate) fn add_pixel_rows(&mut self, image: &DynamicRows<'_, '_>, importance_map: Option<&[u8]>, posterize_bits: u8) -> Result<(), Error> { 260 | let width = image.width as usize; 261 | let height = image.height as usize; 262 | 263 | debug_assert!(importance_map.map_or(true, |m| m.len() == image.width() * image.height())); 264 | 265 | let mut importance_map = importance_map.unwrap_or(&[]).chunks_exact(width).fuse(); 266 | let image_iter = image.rgba_rows_iter()?; 267 | 268 | let mut temp_row = temp_buf(width)?; 269 | for row in 0..height { 270 | let pixels_row = &image_iter.row_rgba(&mut temp_row, row)[..width]; 271 | let importance_map = importance_map.next().map(move |m| &m[..width]).unwrap_or(&[]); 272 | for (col, px) in pixels_row.iter().copied().enumerate() { 273 | let boost = importance_map.get(col).copied().unwrap_or(255); 274 | self.add_color(px, boost.into()); 275 | } 276 | } 277 | self.init_posterize_bits(posterize_bits); 278 | 279 | if self.hashmap.len() > self.max_histogram_entries as usize && self.posterize_bits < 3 { 280 | self.init_posterize_bits(self.posterize_bits + 1); 281 | } 282 | Ok(()) 283 | } 284 | 285 | pub(crate) fn finalize_builder(&mut self, gamma: f64) -> Result { 286 | debug_assert!(gamma > 0.); 287 | 288 | // Fixed colors will be put into normal hashmap, but with very high weight, 289 | // and temporarily 0 means this fixed max weight 290 | for &HashColor { rgba, .. } in &self.fixed_colors { 291 | let px_int = if rgba.a != 0 { 292 | unsafe { RGBAInt { rgba }.int } 293 | } else { 0 }; 294 | 295 | self.hashmap.insert(px_int, (0, rgba)); 296 | } 297 | 298 | let mut temp = Vec::new(); 299 | temp.try_reserve_exact(self.hashmap.len())?; 300 | 301 | let mut counts = [0; LIQ_MAXCLUSTER]; 302 | temp.extend(self.hashmap.values().map(|&(boost, color)| { 303 | let cluster_index = ((color.r >> 7) << 3) | ((color.g >> 7) << 2) | ((color.b >> 7) << 1) | (color.a >> 7); 304 | counts[cluster_index as usize] += 1; 305 | 306 | // fixed colors result in weight == 0. 307 | let weight = boost as f32; 308 | TempHistItem { color, weight, cluster_index } 309 | })); 310 | 311 | let mut clusters = [Cluster { begin: 0, end: 0 }; LIQ_MAXCLUSTER]; 312 | let mut next_begin = 0; 313 | for (cluster, count) in clusters.iter_mut().zip(counts) { 314 | cluster.begin = next_begin; 315 | cluster.end = next_begin; 316 | next_begin += count; 317 | } 318 | 319 | let mut items = Vec::new(); 320 | items.try_reserve_exact(temp.len())?; 321 | items.resize(temp.len(), HistItem { 322 | color: if cfg!(debug_assertions) { f_pixel( ARGBF { r:f32::NAN, g:f32::NAN, b:f32::NAN, a:f32::NAN } ) } else { f_pixel::default() }, 323 | adjusted_weight: if cfg!(debug_assertions) { f32::NAN } else { 0. }, 324 | perceptual_weight: if cfg!(debug_assertions) { f32::NAN } else { 0. }, 325 | mc_color_weight: if cfg!(debug_assertions) { f32::NAN } else { 0. }, 326 | tmp: HistSortTmp { mc_sort_value: if cfg!(debug_assertions) { !0 } else { 0 } }, 327 | }); 328 | let mut items = items.into_boxed_slice(); 329 | 330 | // Limit perceptual weight to 1/10th of the image surface area to prevent 331 | // a single color from dominating all others. 332 | let max_perceptual_weight = ((0.1 / 255.) * temp.iter().map(|t| f64::from(t.weight)).sum::()) as f32; 333 | 334 | let lut = gamma_lut(gamma); 335 | let mut total_perceptual_weight = 0.; 336 | for temp_item in temp { 337 | let cluster = &mut clusters[temp_item.cluster_index as usize]; 338 | let next_index = cluster.end as usize; 339 | cluster.end += 1; 340 | 341 | // weight == 0 means it's a fixed color 342 | let weight = if temp_item.weight > 0. { 343 | (temp_item.weight * (1. / 255.)).min(max_perceptual_weight) 344 | } else { 345 | max_perceptual_weight * 16. 346 | }; 347 | total_perceptual_weight += f64::from(weight); 348 | 349 | items[next_index].color = f_pixel::from_rgba(&lut, temp_item.color); 350 | items[next_index].perceptual_weight = weight; 351 | items[next_index].adjusted_weight = weight; 352 | } 353 | 354 | let mut fixed_colors: Vec<_> = self.fixed_colors.iter().collect(); 355 | fixed_colors.sort_by_key(|c| c.index); // original order 356 | let fixed_colors = fixed_colors.iter().map(|c| f_pixel::from_rgba(&lut, c.rgba)).collect(); 357 | 358 | Ok(HistogramInternal { items, total_perceptual_weight, clusters, fixed_colors }) 359 | } 360 | } 361 | 362 | #[derive(Copy, Clone)] 363 | struct TempHistItem { 364 | color: RGBA, 365 | weight: f32, 366 | cluster_index: u8, 367 | } 368 | 369 | #[repr(C)] 370 | union RGBAInt { 371 | rgba: RGBA, 372 | int: u32, 373 | } 374 | 375 | /// Clusters form initial boxes for quantization, to ensure extreme colors are better represented 376 | pub const LIQ_MAXCLUSTER: usize = 16; 377 | 378 | pub(crate) struct HistogramInternal { 379 | pub items: Box<[HistItem]>, 380 | pub total_perceptual_weight: f64, 381 | pub clusters: [Cluster; LIQ_MAXCLUSTER], 382 | pub fixed_colors: Box<[f_pixel]>, 383 | } 384 | 385 | // Pre-grouped colors 386 | #[derive(Copy, Clone, Debug)] 387 | pub(crate) struct Cluster { 388 | pub begin: u32, 389 | pub end: u32, 390 | } 391 | 392 | // Simple deterministic hasher for the color hashmap 393 | impl hash::BuildHasher for U32Hasher { 394 | type Hasher = Self; 395 | 396 | #[inline(always)] 397 | fn build_hasher(&self) -> Self { 398 | Self(0) 399 | } 400 | } 401 | 402 | pub(crate) struct U32Hasher(pub u32); 403 | impl hash::Hasher for U32Hasher { 404 | // magic constant from fxhash. For a single 32-bit key that's all it needs! 405 | #[inline(always)] 406 | fn finish(&self) -> u64 { u64::from(self.0).wrapping_mul(0x517cc1b727220a95) } 407 | #[inline(always)] 408 | fn write_u32(&mut self, i: u32) { self.0 = i; } 409 | 410 | fn write(&mut self, _bytes: &[u8]) { unimplemented!() } 411 | fn write_u8(&mut self, _i: u8) { unimplemented!() } 412 | fn write_u16(&mut self, _i: u16) { unimplemented!() } 413 | fn write_u64(&mut self, _i: u64) { unimplemented!() } 414 | fn write_u128(&mut self, _i: u128) { unimplemented!() } 415 | fn write_usize(&mut self, _i: usize) { unimplemented!() } 416 | fn write_i8(&mut self, _i: i8) { unimplemented!() } 417 | fn write_i16(&mut self, _i: i16) { unimplemented!() } 418 | fn write_i32(&mut self, _i: i32) { unimplemented!() } 419 | fn write_i64(&mut self, _i: i64) { unimplemented!() } 420 | fn write_i128(&mut self, _i: i128) { unimplemented!() } 421 | fn write_isize(&mut self, _i: isize) { unimplemented!() } 422 | } 423 | 424 | /// ignores the index 425 | #[derive(PartialEq, Debug)] 426 | pub(crate) struct HashColor { 427 | pub rgba: RGBA, 428 | pub index: PalIndex, 429 | } 430 | 431 | #[allow(clippy::derived_hash_with_manual_eq)] 432 | impl Hash for HashColor { 433 | #[inline] 434 | fn hash(&self, state: &mut H) { 435 | let s: &[u8] = self.rgba.as_ref(); 436 | u32::from_ne_bytes(s.try_into().unwrap()).hash(state); 437 | } 438 | } 439 | 440 | impl Eq for HashColor { 441 | fn assert_receiver_is_total_eq(&self) {} 442 | } 443 | --------------------------------------------------------------------------------