add missing crc32 helpers

Author: folkertdev

libz-rs-sys/src/lib.rs

@@ -243,6 +243,30 @@ pub extern "C" fn get_crc_table() -> *const [u32; 256] {
     zlib_rs::get_crc_table()
 }
 
+/// Return the operator corresponding to length `len2`, to be used with
+/// [`crc32_combine_op`]. `len2` must be non-negative.
+#[cfg_attr(feature = "export-symbols", export_name = prefix!(crc32_combine_gen64))]
+pub const extern "C" fn crc32_combine_gen64(len2: z_off64_t) -> c_ulong {
+    debug_assert!(len2 >= 0, "`len2` must be non-negative");
+    zlib_rs::crc32::crc32_combine_gen(len2 as u64) as c_ulong
+}
+
+/// Return the operator corresponding to length `len2`, to be used with
+/// [`crc32_combine_op`]. `len2` must be non-negative.
+#[cfg_attr(feature = "export-symbols", export_name = prefix!(crc32_combine_gen))]
+pub const extern "C" fn crc32_combine_gen(len2: z_off_t) -> c_ulong {
+    debug_assert!(len2 >= 0, "`len2` must be non-negative");
+    zlib_rs::crc32::crc32_combine_gen(len2 as u64) as c_ulong
+}
+
+/// Give the same result as [`crc32_combine`], using `op` in place of `len2`.
+/// `op` is is generated from `len2` by [`crc32_combine_gen`].
+/// This will be faster than [`crc32_combine`] if the generated `op` is used more than once.
+#[cfg_attr(feature = "export-symbols", export_name = prefix!(crc32_combine_op))]
+pub const extern "C" fn crc32_combine_op(crc1: c_ulong, crc2: c_ulong, op: c_ulong) -> c_ulong {
+    zlib_rs::crc32::crc32_combine_op(crc1 as u32, crc2 as u32, op as u32) as c_ulong
+}
+
 /// Calculates the [adler32](https://en.wikipedia.org/wiki/Adler-32) checksum
 /// of a sequence of bytes.
 ///

test-libz-rs-sys/src/lib.rs

@@ -59,6 +59,16 @@ macro_rules! assert_eq_rs_ng {
                     len2: libz_rs_sys::z_off64_t,
                 ) -> core::ffi::c_ulong;
 
+                #[allow(unused)]
+                fn crc32_combine_gen(len2: z_off_t) -> core::ffi::c_ulong;
+
+                #[allow(unused)]
+                fn crc32_combine_op(
+                    crc1: core::ffi::c_ulong,
+                    crc2: core::ffi::c_ulong,
+                    op: core::ffi::c_ulong,
+                ) -> core::ffi::c_ulong;
+
                 #[allow(unused)]
                 fn adler32_z(
                     crc: core::ffi::c_ulong,
@@ -192,6 +202,55 @@ mod null {
         assert_eq!(libz_rs_sys::crc32_combine(2, 123, -16), 2171032315);
     }
 
+    #[test]
+    fn test_crc32_combine() {
+        ::quickcheck::quickcheck(test as fn(_) -> _);
+
+        fn test(data: Vec<u8>) -> bool {
+            let Some(buf_len) = data.first().copied() else {
+                return true;
+            };
+
+            let buf_size = Ord::max(buf_len, 1) as usize;
+
+            assert_eq_rs_ng!({
+                let crc0 = 0;
+                let mut crc1 = crc0;
+                let mut crc2 = crc0;
+
+                /* CRC32 */
+                for chunk in data.chunks(buf_size) {
+                    let crc3 = crc32(crc0, chunk.as_ptr(), chunk.len() as _);
+                    let op = crc32_combine_gen(chunk.len() as _);
+                    let crc4 = crc32_combine_op(crc1, crc3, op);
+                    crc1 = crc32(crc1, chunk.as_ptr(), chunk.len() as _);
+
+                    assert_eq!(crc1, crc4);
+                }
+
+                crc2 = crc32(crc2, data.as_ptr(), data.len() as _);
+
+                assert_eq!(crc1, crc2);
+
+                let combine1 = crc32_combine(crc1, crc2, data.len() as _);
+                let combine2 = crc32_combine(crc1, crc1, data.len() as _);
+                assert_eq!(combine1, combine2);
+
+                // Fast CRC32 combine.
+                let op = crc32_combine_gen(data.len() as _);
+                let combine1 = crc32_combine_op(crc1, crc2, op);
+                let combine2 = crc32_combine_op(crc2, crc1, op);
+                assert_eq!(combine1, combine2);
+
+                let combine1 = crc32_combine(crc1, crc2, data.len() as _);
+                let combine2 = crc32_combine_op(crc2, crc1, op);
+                assert_eq!(combine1, combine2);
+            });
+
+            true
+        }
+    }
+
     #[test]
     fn uncompress() {
         let mut dest = [0; 64];

zlib-rs/src/crc32.rs

@@ -10,7 +10,7 @@ mod pclmulqdq;
 #[cfg(feature = "vpclmulqdq")]
 mod vpclmulqdq;
 
-pub use combine::crc32_combine;
+pub use combine::{crc32_combine, crc32_combine_gen, crc32_combine_op};
 
 pub fn crc32(start: u32, buf: &[u8]) -> u32 {
     /* For lens < 64, crc32_braid method is faster. The CRC32 instruction for

zlib-rs/src/crc32/combine.rs

@@ -5,12 +5,12 @@ pub const fn crc32_combine(crc1: u32, crc2: u32, len2: u64) -> u32 {
 }
 
 #[inline(always)]
-const fn crc32_combine_gen(len2: u64) -> u32 {
+pub const fn crc32_combine_gen(len2: u64) -> u32 {
     x2nmodp(len2, 3)
 }
 
 #[inline(always)]
-const fn crc32_combine_op(crc1: u32, crc2: u32, op: u32) -> u32 {
+pub const fn crc32_combine_op(crc1: u32, crc2: u32, op: u32) -> u32 {
     multmodp(op, crc1) ^ crc2
 }