Fix C API unsetting callbacks

Author: kornelski

imagequant-sys/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "imagequant-sys"
-version = "4.2.0"
+version = "4.5.0"
 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."
 authors = ["Kornel Lesiński <kornel@pngquant.org>"]
 license = "GPL-3.0-or-later"
@@ -14,7 +14,7 @@ readme = "README.md"
 edition = "2021"
 links = "imagequant"
 build = "build.rs"
-rust-version = "1.64"
+rust-version = "1.65"
 
 [features]
 default = ["imagequant/default"]

imagequant-sys/src/ffi.rs

@@ -182,16 +182,24 @@ unsafe impl Sync for AnySyncSendPtr {}
 
 #[no_mangle]
 #[inline(never)]
-pub unsafe extern "C" fn liq_attr_set_progress_callback(attr: &mut liq_attr, callback: liq_progress_callback_function, user_info: AnySyncSendPtr) {
+pub unsafe extern "C" fn liq_attr_set_progress_callback(attr: &mut liq_attr, callback: Option<liq_progress_callback_function>, user_info: AnySyncSendPtr) {
     if bad_object!(attr, LIQ_ATTR_MAGIC) { return; }
+    let Some(callback) = callback else {
+        attr.inner.clear_progress_callback();
+        return;
+    };
     let cb = move |f| if callback(f, user_info) == 0 { ControlFlow::Break} else { ControlFlow::Continue};
     attr.inner.set_progress_callback(cb);
 }
 
 #[no_mangle]
 #[inline(never)]
-pub unsafe extern "C" fn liq_result_set_progress_callback(result: &mut liq_result, callback: liq_progress_callback_function, user_info: AnySyncSendPtr) {
+pub unsafe extern "C" fn liq_result_set_progress_callback(result: &mut liq_result, callback: Option<liq_progress_callback_function>, user_info: AnySyncSendPtr) {
     if bad_object!(result, LIQ_RESULT_MAGIC) { return; }
+    let Some(callback) = callback else {
+        result.inner.clear_progress_callback();
+        return;
+    };
     result.inner.set_progress_callback(move |f| if callback(f, user_info) == 0 { ControlFlow::Break} else { ControlFlow::Continue});
 }
 
@@ -206,8 +214,12 @@ unsafe fn attr_to_liq_attr_ptr(ptr: &Attributes) -> &liq_attr {
 
 #[no_mangle]
 #[inline(never)]
-pub unsafe extern "C" fn liq_set_log_callback(attr: &mut liq_attr, callback: liq_log_callback_function, user_info: AnySyncSendPtr) {
+pub unsafe extern "C" fn liq_set_log_callback(attr: &mut liq_attr, callback: Option<liq_log_callback_function>, user_info: AnySyncSendPtr) {
     if bad_object!(attr, LIQ_ATTR_MAGIC) { return; }
+    let Some(callback) = callback else {
+        attr.inner.clear_log_callback();
+        return;
+    };
     attr.inner.set_log_callback(move |attr, msg| {
         if let Ok(tmp) = CString::new(msg) {
             callback(attr_to_liq_attr_ptr(attr), tmp.as_ptr(), user_info);
@@ -217,8 +229,12 @@ pub unsafe extern "C" fn liq_set_log_callback(attr: &mut liq_attr, callback: liq
 
 #[no_mangle]
 #[inline(never)]
-pub unsafe extern "C" fn liq_set_log_flush_callback(attr: &mut liq_attr, callback: liq_log_flush_callback_function, user_info: AnySyncSendPtr) {
+pub unsafe extern "C" fn liq_set_log_flush_callback(attr: &mut liq_attr, callback: Option<liq_log_flush_callback_function>, user_info: AnySyncSendPtr) {
     if bad_object!(attr, LIQ_ATTR_MAGIC) { return; }
+    let Some(callback) = callback else {
+        attr.inner.clear_log_flush_callback();
+        return;
+    };
     attr.inner.set_log_flush_callback(move |attr| callback(attr_to_liq_attr_ptr(attr), user_info));
 }
 

src/attr.rs

@@ -225,13 +225,25 @@ impl Attributes {
         self.log_callback = Some(Arc::new(callback));
     }
 
+    /// Drop callback from `set_log_callback`
+    pub fn clear_log_callback(&mut self) {
+        self.log_callback = None;
+    }
+
     /// Callback for flushing output (if you buffer messages, that's the time to flush those buffers)
     #[inline]
     pub fn set_log_flush_callback<F: Fn(&Self) + Send + Sync + 'static>(&mut self, callback: F) {
         self.verbose_printf_flush();
         self.log_flush_callback = Some(Arc::new(callback));
     }
 
+    /// Drop callback from `set_log_flush_callback`
+    #[inline]
+    pub fn clear_log_flush_callback(&mut self) {
+        self.verbose_printf_flush();
+        self.log_flush_callback = None;
+    }
+
     /// Set callback function to be called every time the library makes a progress.
     /// It can be used to cancel operation early.
     ///
@@ -241,6 +253,11 @@ impl Attributes {
         self.progress_callback = Some(Arc::new(callback));
     }
 
+    /// Drop callback from `set_progress_callback`
+    pub fn clear_progress_callback(&mut self) {
+        self.progress_callback = None;
+    }
+
     /// Move transparent color to the last entry in the palette
     ///
     /// This is less efficient for PNG, but required by some broken software

src/quant.rs

@@ -224,6 +224,14 @@ impl QuantizationResult {
         self.progress_callback = Some(Box::new(callback));
     }
 
+    /// Drop callback from `set_progress_callback`
+    #[inline(always)]
+    pub fn clear_progress_callback(&mut self) {
+        self.progress_callback = None;
+    }
+
+
+
     // true == abort
     pub(crate) fn remap_progress(&self, percent: f32) -> bool {
         self.progress_callback.as_ref().map_or(false, |cb| cb(percent) == ControlFlow::Break)