Add:maptool:Compress with libdeflate when it is available

libdeflate produces the same raw deflate format as zlib, only faster.
The library is optional: without it, maptool compresses with zlib as
before. Ubuntu ships the library as libdeflate-dev.

A benchmark on 400 real tiles of a map of France, 38.4 MB:

    codec            time     size against zlib level 9
    zlib 9          4.99 s    +-0.0%
    zlib 6          1.42 s     +1.0%
    libdeflate 9    1.14 s     -0.2%
    libdeflate 6    0.32 s     -0.6%
    libdeflate 12   5.18 s    -10.9%

Level 6 of libdeflate is 15.6 times faster than level 9 of zlib and the
result is smaller. Level 12 needs the time of zlib level 9 and gives a
map that is 11 percent smaller, which helps a map that comes near the
2 GiB limit of a GitHub release asset.

Measured on a map of Luxembourg with 8 threads and the parallel
compression: level 9 of zlib needs 4.9 s for the tiles, level 6 of
libdeflate needs 0.7 s. The maps stay semantically identical, every
member has a correct CRC, and two runs give identical files.

Author: pgrandin

navit/maptool/CMakeLists.txt

@@ -24,6 +24,19 @@ if(BUILD_MAPTOOL)
 		SET(NAVIT_LIBS ${NAVIT_LIBS} m)
 	endif(NOT MSVC)
 
+	# libdeflate compresses much faster than zlib. It is optional: without it,
+	# maptool compresses with zlib as before.
+	find_path(LIBDEFLATE_INCLUDE_DIR libdeflate.h)
+	find_library(LIBDEFLATE_LIBRARY deflate)
+	if(LIBDEFLATE_INCLUDE_DIR AND LIBDEFLATE_LIBRARY)
+		message(STATUS "maptool: compressing with libdeflate (${LIBDEFLATE_LIBRARY})")
+		set_property(SOURCE zip.c APPEND PROPERTY COMPILE_DEFINITIONS HAVE_LIBDEFLATE=1)
+		target_include_directories(maptool_core PRIVATE ${LIBDEFLATE_INCLUDE_DIR})
+		target_link_libraries(maptool_core ${LIBDEFLATE_LIBRARY})
+	else()
+		message(STATUS "maptool: libdeflate not found, compressing with zlib")
+	endif()
+
 	target_link_libraries(maptool maptool_core ${NAVIT_LIBNAME} ${NAVIT_LIBS})
 
 	install(TARGETS maptool

navit/maptool/zip.c

@@ -28,6 +28,9 @@
 #include <unistd.h>
 #include <zconf.h>
 #include <zlib.h>
+#ifdef HAVE_LIBDEFLATE
+#    include <libdeflate.h>
+#endif
 
 struct zip_info {
     int zipnum;
@@ -49,7 +52,7 @@ static int zip_write(struct zip_info *info, void *data, int len) {
     return 1;
 }
 
-#ifdef HAVE_ZLIB
+#if defined(HAVE_ZLIB) && !defined(HAVE_LIBDEFLATE)
 static int compress2_int(Byte *dest, uLongf *destLen, const Bytef *source, uLong sourceLen, int level) {
     z_stream stream;
     int err;
@@ -101,7 +104,25 @@ void zip_compress_member(struct zip_info *zip_info, char *data, int data_size, s
     m->buffer = NULL;
     m->crc = crc32(crc32(0, NULL, 0), (unsigned char *)data, data_size);
     m->method = zip_info->compression_level ? 8 : 0;
-#ifdef HAVE_ZLIB
+#ifdef HAVE_LIBDEFLATE
+    if (zip_info->compression_level) {
+        /* libdeflate produces the same raw deflate format as the zlib call
+         * below, only faster. Level 6 of libdeflate compresses tile data
+         * better than level 9 of zlib. A compressor is not safe for use by
+         * several threads, so every call allocates its own. */
+        struct libdeflate_compressor *comp = libdeflate_alloc_compressor(zip_info->compression_level);
+        size_t destlen = data_size + data_size / 500 + 12;
+        size_t outlen;
+        m->buffer = g_malloc(destlen);
+        outlen = libdeflate_deflate_compress(comp, data, data_size, m->buffer, destlen);
+        libdeflate_free_compressor(comp);
+        if (outlen && outlen < (size_t)data_size) {
+            m->data = m->buffer;
+            m->data_size = outlen;
+        } else
+            m->method = 0;
+    }
+#elif defined(HAVE_ZLIB)
     if (zip_info->compression_level) {
         uLongf destlen = data_size + data_size / 500 + 12;
         int error;