Modified 'CMakeLists.txt' to produce a meaningful summary of external

codecs support.

1 files changed, 113 insertions, 110 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index ea8f62d1..a70485e5 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -448,90 +448,81 @@ option(mdi "support for Microsoft Document Imaging" ON)
 set(MDI_SUPPORT ${mdi})
 
 # ZLIB
-option(zlib "use zlib (required for Deflate compression)" ON)
-if (zlib)
-  find_package(ZLIB)
-endif()
-set(ZLIB_SUPPORT 0)
-if(ZLIB_FOUND)
-  set(ZLIB_SUPPORT 1)
+set(ZLIB_SUPPORT FALSE)
+find_package(ZLIB)
+option(zlib "use zlib (required for Deflate compression)" ${ZLIB_FOUND})
+if(zlib AND ZLIB_FOUND)
+  set(ZLIB_SUPPORT TRUE)
 endif()
 set(ZIP_SUPPORT ${ZLIB_SUPPORT})
 
-
 # libdeflate
-option(libdeflate "use libdeflate (optional for faster Deflate support, still requires zlib)" ON)
-if (libdeflate)
-  set(DEFLATE_FOUND 0)
-  find_path(DEFLATE_INCLUDE_DIR libdeflate.h)
-  set(DEFLATE_NAMES ${DEFLATE_NAMES} deflate)
-  find_library(DEFLATE_LIBRARY NAMES ${DEFLATE_NAMES})
-  if (DEFLATE_INCLUDE_DIR AND DEFLATE_LIBRARY)
-    set(DEFLATE_FOUND 1)
+set(LIBDEFLATE_SUPPORT FALSE)
+find_path(DEFLATE_INCLUDE_DIR libdeflate.h)
+set(DEFLATE_NAMES ${DEFLATE_NAMES} deflate libdeflate libdeflatestatic)
+find_library(DEFLATE_LIBRARY NAMES ${DEFLATE_NAMES})
+if (DEFLATE_INCLUDE_DIR AND DEFLATE_LIBRARY)
+    set(DEFLATE_FOUND TRUE)
     set(DEFLATE_LIBRARIES ${DEFLATE_LIBRARY})
     message(STATUS "Found libdeflate: ${DEFLATE_LIBRARY}")
-  endif()
+  else()
+    set(DEFLATE_FOUND FALSE)
 endif()
-set(LIBDEFLATE_SUPPORT FALSE)
-if(DEFLATE_FOUND)
+option(libdeflate "use libdeflate (optional for faster Deflate support, still requires zlib)" ${DEFLATE_FOUND})
+if (libdeflate AND DEFLATE_FOUND AND ZIP_SUPPORT)
   set(LIBDEFLATE_SUPPORT TRUE)
 endif()
-
-if(LIBDEFLATE_SUPPORT AND NOT ZIP_SUPPORT)
+if(DEFLATE_FOUND AND NOT ZIP_SUPPORT)
     message(WARNING "libdeflate available but zlib is not. libdeflate cannot be used")
-    set(LIBDEFLATE_SUPPORT FALSE)
 endif()
-
 set(LIBDEFLATE_SUPPORT ${LIBDEFLATE_SUPPORT})
 
-
 # Option for Pixar log-format algorithm
-
 # Pixar log format
-option(pixarlog "support for Pixar log-format algorithm (requires Zlib)" ON)
 set(PIXARLOG_SUPPORT FALSE)
-if (ZLIB_SUPPORT)
-  if(pixarlog)
-    set(PIXARLOG_SUPPORT TRUE)
-  endif()
+option(pixarlog "support for Pixar log-format algorithm (requires Zlib)" ${ZLIB_SUPPORT})
+if(pixarlog AND ZLIB_SUPPORT)
+   set(PIXARLOG_SUPPORT TRUE)
 endif()
 
 # JPEG
-option(jpeg "use libjpeg (required for JPEG compression)" ON)
-if (jpeg)
-  find_package(JPEG)
-endif()
 set(JPEG_SUPPORT FALSE)
-if(JPEG_FOUND)
-  set(JPEG_SUPPORT TRUE)
+find_path(JPEG_INCLUDE_DIR jpeglib.h)
+set(JPEG_NAMES ${JPEG_NAMES} jpeg jpeg-static libjpeg libjpeg-static turbojpeg turbojpeg-static)
+find_library(JPEG_LIBRARY NAMES ${JPEG_NAMES})
+if (JPEG_INCLUDE_DIR AND JPEG_LIBRARY)
+   set(JPEG_FOUND TRUE)
+   set(JPEG_LIBRARIES ${JPEG_LIBRARY})
+   message(STATUS "Found jpeg: ${JPEG_LIBRARY}")
+else()
+   set(JPEG_FOUND FALSE)
+endif()
+option(jpeg "use libjpeg (required for JPEG compression)" ${JPEG_FOUND})
+if (jpeg AND JPEG_FOUND)
+   set(JPEG_SUPPORT TRUE)
 endif()
 
-option(old-jpeg "support for Old JPEG compression (read-only)" ON)
+# Old-jpeg
 set(OJPEG_SUPPORT FALSE)
-if (JPEG_SUPPORT)
-  if (old-jpeg)
-    set(OJPEG_SUPPORT TRUE)
-  endif()
+option(old-jpeg "support for Old JPEG compression (read-only)" ${JPEG_SUPPORT})
+if (old-jpeg AND JPEG_SUPPORT)
+   set(OJPEG_SUPPORT TRUE)
 endif()
 
 # JBIG-KIT
-option(jbig "use ISO JBIG compression (requires JBIT-KIT library)" ON)
-if (jbig)
-  set(JBIG_FOUND 0)
-  find_path(JBIG_INCLUDE_DIR jbig.h)
-  set(JBIG_NAMES ${JBIG_NAMES} jbig libjbig)
-  find_library(JBIG_LIBRARY NAMES ${JBIG_NAMES})
-  if (JBIG_INCLUDE_DIR AND JBIG_LIBRARY)
-    set(JBIG_FOUND 1)
+set(JBIG_SUPPORT FALSE)
+find_path(JBIG_INCLUDE_DIR jbig.h)
+set(JBIG_NAMES ${JBIG_NAMES} jbig libjbig)
+find_library(JBIG_LIBRARY NAMES ${JBIG_NAMES})
+if (JBIG_INCLUDE_DIR AND JBIG_LIBRARY)
+    set(JBIG_FOUND TRUE)
     set(JBIG_LIBRARIES ${JBIG_LIBRARY})
-  endif()
+  else()
+    set(JBIG_FOUND FALSE)
 endif()
-set(JBIG_SUPPORT 0)
-if(JBIG_FOUND)
-  set(JBIG_FOUND TRUE)
-  set(JBIG_SUPPORT 1)
-else()
-  set(JBIG_FOUND FALSE)
+option(jbig "use ISO JBIG compression (requires JBIT-KIT library)" ${JBIG_FOUND})
+if (jbig AND JBIG_FOUND)
+   set(JBIG_SUPPORT TRUE)
 endif()
 
 set(CMAKE_REQUIRED_INCLUDES_SAVE ${CMAKE_REQUIRED_INCLUDES})
@@ -540,63 +531,63 @@ check_symbol_exists(jbg_newlen "jbig.h" HAVE_JBG_NEWLEN)
 set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES_SAVE})
 
 # liblzma2
-option(lzma "use liblzma (required for LZMA2 compression)" ON)
-if (lzma)
-  find_package(LibLZMA)
-endif()
-set(LZMA_SUPPORT 0)
-if(LIBLZMA_FOUND)
-  set(LZMA_SUPPORT 1)
+set(LZMA_SUPPORT FALSE)
+find_package(LibLZMA)
+option(lzma "use liblzma (required for LZMA2 compression)" ${LZMA_FOUND})
+if (lzma AND LIBLZMA_FOUND)
+   set(LZMA_SUPPORT TRUE)
 endif()
 
 # libzstd
-option(zstd "use libzstd (required for ZSTD compression)" ON)
-if (zstd)
-    find_path(ZSTD_INCLUDE_DIR zstd.h)
-    find_library(ZSTD_LIBRARY NAMES zstd)
-    if (ZSTD_INCLUDE_DIR AND ZSTD_LIBRARY)
-        check_library_exists ("${ZSTD_LIBRARY}" ZSTD_decompressStream "" ZSTD_RECENT_ENOUGH)
-        if (ZSTD_RECENT_ENOUGH)
-            set(ZSTD_FOUND TRUE)
-            set(ZSTD_LIBRARIES ${ZSTD_LIBRARY})
-            message(STATUS "Found ZSTD library: ${ZSTD_LIBRARY}")
-        else ()
-            message(WARNING "Found ZSTD library, but not recent enough. Use zstd >= 1.0")
-        endif ()
-    endif ()
-endif()
-set(ZSTD_SUPPORT 0)
-if(ZSTD_FOUND)
-  set(ZSTD_SUPPORT 1)
+set(ZSTD_SUPPORT FALSE)
+find_path(ZSTD_INCLUDE_DIR zstd.h)
+find_library(ZSTD_LIBRARY NAMES zstd zstd_static)
+if (ZSTD_INCLUDE_DIR AND ZSTD_LIBRARY)
+    check_library_exists ("${ZSTD_LIBRARY}" ZSTD_decompressStream "" ZSTD_RECENT_ENOUGH)
+    if (ZSTD_RECENT_ENOUGH)
+        set(ZSTD_FOUND TRUE)
+        set(ZSTD_LIBRARIES ${ZSTD_LIBRARY})
+        message(STATUS "Found ZSTD library: ${ZSTD_LIBRARY}")
+      else()
+        message(WARNING "Found ZSTD library, but not recent enough. Use zstd >= 1.0")
+    endif()
+      else()
+        set(ZSTD_FOUND FALSE)
+endif()
+option(zstd "use libzstd (required for ZSTD compression)" ${ZSTD_FOUND})
+if (zstd AND ZSTD_FOUND)
+   set(ZSTD_SUPPORT TRUE)
 endif()
 
 # libwebp
-option(webp "use libwebp (required for WEBP compression)" ON)
-if (webp)
-    find_path(WEBP_INCLUDE_DIR /webp/decode.h)
-    find_library(WEBP_LIBRARY NAMES webp)
-endif()
-set(WEBP_SUPPORT 0)
-set(WEBP_FOUND FALSE)
+set(WEBP_SUPPORT FALSE)
+find_path(WEBP_INCLUDE_DIR /webp/decode.h)
+find_library(WEBP_LIBRARY NAMES webp)
 if (WEBP_INCLUDE_DIR AND WEBP_LIBRARY)
-  set(WEBP_SUPPORT 1)
-  set(WEBP_FOUND TRUE)
-  set(WEBP_LIBRARIES ${WEBP_LIBRARY})
-  message(STATUS "Found WEBP library: ${WEBP_LIBRARY}")
+    set(WEBP_LIBRARIES ${WEBP_LIBRARY})
+    set(WEBP_FOUND TRUE)
+    message(STATUS "Found WEBP library: ${WEBP_LIBRARY}")
+  else()
+    set(WEBP_FOUND FALSE)
+endif()
+option(webp "use libwebp (required for WEBP compression)" ${WEBP_FOUND})
+if (webp AND WEBP_FOUND)
+  set(WEBP_SUPPORT TRUE)
 endif()
 
 # 8/12-bit jpeg mode
-option(jpeg12 "enable libjpeg 8/12-bit dual mode (requires separate
-12-bit libjpeg build)" ON)
 set(JPEG12_INCLUDE_DIR JPEG12_INCLUDE_DIR-NOTFOUND CACHE PATH "Include directory for 12-bit libjpeg")
 set(JPEG12_LIBRARY JPEG12_LIBRARY-NOTFOUND CACHE FILEPATH "12-bit libjpeg library")
-set(JPEG12_FOUND FALSE)
+set(JPEG_DUAL_MODE_8_12 FALSE)
 if (JPEG12_INCLUDE_DIR AND JPEG12_LIBRARY)
-  set(JPEG12_LIBRARIES ${JPEG12_LIBRARY})
-  set(JPEG12_FOUND TRUE)
+    set(JPEG12_LIBRARIES ${JPEG12_LIBRARY})
+    set(JPEG12_FOUND TRUE)
+  else()
+    set(JPEG12_FOUND FALSE)
 endif()
-if (JPEG12_FOUND)
-  set(JPEG_DUAL_MODE_8_12 1)
+option(jpeg12 "enable libjpeg 8/12-bit dual mode (requires separate 12-bit libjpeg build)" ${JPEG12_FOUND})
+if (jpeg12 AND JPEG12_FOUND)
+  set(JPEG_DUAL_MODE_8_12 TRUE)
   set(LIBJPEG_12_PATH "${JPEG12_INCLUDE_DIR}/jpeglib.h")
 endif()
 
@@ -634,7 +625,7 @@ set(USE_WIN32_FILEIO ${win32_io})
 # Orthogonal features
 
 # Strip chopping
-option(strip-chopping "strip chopping (whether or not to convert single-strip uncompressed images to multiple strips of specified size to reduce memory usage)" ON)
+option(strip-chopping "strip chopping (whether or not to convert single-strip uncompressed images to mutiple strips of specified size to reduce memory usage)" ON)
 set(TIFF_DEFAULT_STRIP_SIZE 8192 CACHE STRING "default size of the strip in bytes (when strip chopping is enabled)")
 
 set(STRIPCHOP_DEFAULT)
@@ -770,16 +761,28 @@ message(STATUS "  NeXT 2-bit RLE algorithm:           ${next}")
 message(STATUS "  LogLuv high dynamic range encoding: ${logluv}")
 message(STATUS "")
 message(STATUS " Support for external codecs:")
-message(STATUS "  ZLIB support:                       ${zlib} (requested) ${ZLIB_FOUND} (availability)")
-message(STATUS "  libdeflate support:                 ${libdeflate} (requested) ${LIBDEFLATE_SUPPORT} (availability)")
-message(STATUS "  Pixar log-format algorithm:         ${pixarlog} (requested) ${PIXARLOG_SUPPORT} (availability)")
-message(STATUS "  JPEG support:                       ${jpeg} (requested) ${JPEG_FOUND} (availability)")
-message(STATUS "  Old JPEG support:                   ${old-jpeg} (requested) ${JPEG_FOUND} (availability)")
-message(STATUS "  JPEG 8/12 bit dual mode:            ${jpeg12} (requested) ${JPEG12_FOUND} (availability)")
-message(STATUS "  ISO JBIG support:                   ${jbig} (requested) ${JBIG_FOUND} (availability)")
-message(STATUS "  LZMA2 support:                      ${lzma} (requested) ${LIBLZMA_FOUND} (availability)")
-message(STATUS "  ZSTD support:                       ${zstd} (requested) ${ZSTD_FOUND} (availability)")
-message(STATUS "  WEBP support:                       ${webp} (requested) ${WEBP_FOUND} (availability)")
+message(STATUS "  ZLIB support:                       Requested:${zlib} Availability:${ZLIB_FOUND} Support:${ZLIB_SUPPORT}")
+if(ZLIB_SUPPORT)
+    message(STATUS "  libdeflate support:                 Requested:${libdeflate} Availability:${DEFLATE_FOUND} Support:${LIBDEFLATE_SUPPORT}")
+  else()
+    message(STATUS "  libdeflate support:                 Requested:${libdeflate} Availability:${DEFLATE_FOUND} Support:${LIBDEFLATE_SUPPORT} (Depends on ZLIB Support)")
+endif()
+if(ZLIB_SUPPORT)
+    message(STATUS "  Pixar log-format algorithm:         Requested:${pixarlog} Availability:${ZLIB_FOUND} Support:${PIXARLOG_SUPPORT}")
+  else()
+    message(STATUS "  Pixar log-format algorithm:         Requested:${pixarlog} Availability:${ZLIB_FOUND} Support:${PIXARLOG_SUPPORT} (Depends on ZLIB Support)")
+endif()
+message(STATUS "  JPEG support:                       Requested:${jpeg} Availability:${JPEG_FOUND} Support:${JPEG_SUPPORT}")
+if(JPEG_SUPPORT)
+    message(STATUS "  Old JPEG support:                   Requested:${old-jpeg} Availability:${JPEG_SUPPORT} Support:${OJPEG_SUPPORT}")
+  else()
+    message(STATUS "  Old JPEG support:                   Requested:${old-jpeg} Availability:${JPEG_SUPPORT} Support:${OJPEG_SUPPORT} (Depends on JPEG Support)")
+endif()
+message(STATUS "  JPEG 8/12 bit dual mode:            Requested:${jpeg12} Availability:${JPEG12_FOUND} Support:${JPEG_DUAL_MODE_8_12}")
+message(STATUS "  ISO JBIG support:                   Requested:${jbig} Availability:${JBIG_FOUND} Support:${JBIG_SUPPORT}")
+message(STATUS "  LZMA2 support:                      Requested:${lzma} Availability:${LIBLZMA_FOUND} Support:${LZMA_SUPPORT}")
+message(STATUS "  ZSTD support:                       Requested:${zstd} Availability:${ZSTD_FOUND} Support:${ZSTD_SUPPORT}")
+message(STATUS "  WEBP support:                       Requested:${webp} Availability:${WEBP_FOUND} Support:${WEBP_SUPPORT}")
 message(STATUS "")
 message(STATUS "  C++ support:                        ${cxx} (requested) ${CXX_SUPPORT} (availability)")
 message(STATUS "")