# CMake build for libtiff # Run "cmake" to generate the build files for your platform # # Copyright © 2015 Open Microscopy Environment / University of Dundee # Written by Roger Leigh # # Permission to use, copy, modify, distribute, and sell this software and # its documentation for any purpose is hereby granted without fee, provided # that (i) the above copyright notices and this permission notice appear in # all copies of the software and related documentation, and (ii) the names of # Sam Leffler and Silicon Graphics may not be used in any advertising or # publicity relating to the software without the specific, prior written # permission of Sam Leffler and Silicon Graphics. # # THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, # EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY # WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. # # IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR # ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, # OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, # WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF # LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE # OF THIS SOFTWARE. cmake_minimum_required(VERSION 2.8.11) # b/c of use of BUILD_INTERFACE generator expression # Default policy is from 2.8.9 cmake_policy(VERSION 2.8.9) # Set MacOSX @rpath usage globally. if (POLICY CMP0020) cmake_policy(SET CMP0020 NEW) endif(POLICY CMP0020) if (POLICY CMP0042) cmake_policy(SET CMP0042 NEW) endif(POLICY CMP0042) # Use new variable expansion policy. if (POLICY CMP0053) cmake_policy(SET CMP0053 NEW) endif(POLICY CMP0053) if (POLICY CMP0054) cmake_policy(SET CMP0054 NEW) endif(POLICY CMP0054) # Read version information from configure.ac. FILE(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/configure.ac" configure REGEX "^LIBTIFF_.*=") foreach(line ${configure}) foreach(var LIBTIFF_MAJOR_VERSION LIBTIFF_MINOR_VERSION LIBTIFF_MICRO_VERSION LIBTIFF_ALPHA_VERSION LIBTIFF_CURRENT LIBTIFF_REVISION LIBTIFF_AGE) if(NOT ${var} AND line MATCHES "^${var}=(.*)") set(${var} "${CMAKE_MATCH_1}") break() endif() endforeach() endforeach() math(EXPR SO_MAJOR "${LIBTIFF_CURRENT} - ${LIBTIFF_AGE}") set(SO_MINOR "${LIBTIFF_AGE}") set(SO_REVISION "${LIBTIFF_REVISION}") message(STATUS "Building tiff version ${LIBTIFF_MAJOR_VERSION}.${LIBTIFF_MINOR_VERSION}.${LIBTIFF_MICRO_VERSION}${LIBTIFF_ALPHA_VERSION}") message(STATUS "libtiff library version ${SO_MAJOR}.${SO_MINOR}.${SO_REVISION}") set(BUILD_SHARED_LIBS ON CACHE BOOL "Build shared libraries") # Project version project(tiff C) set(VERSION "${LIBTIFF_MAJOR_VERSION}.${LIBTIFF_MINOR_VERSION}.${LIBTIFF_MICRO_VERSION}") set(tiff_VERSION "${VERSION}") set(tiff_VERSION_MAJOR "${LIBTIFF_MAJOR_VERSION}") set(tiff_VERSION_MINOR "${LIBTIFF_MINOR_VERSION}") set(tiff_VERSION_PATCH "${LIBTIFF_MICRO_VERSION}") # the other tiff_VERSION_* variables are set automatically set(tiff_VERSION_ALPHA "${LIBTIFF_ALPHA_VERSION}") # Library version (unlike libtool's baroque scheme, WYSIWYG here) set(SO_COMPATVERSION "${SO_MAJOR}") set(SO_VERSION "${SO_MAJOR}.${SO_MINOR}.${SO_REVISION}") # For autotools header compatibility set(PACKAGE_NAME "LibTIFF Software") set(PACKAGE_TARNAME "${PROJECT_NAME}") set(PACKAGE_VERSION "${PROJECT_VERSION}${tiff_VERSION_ALPHA}") set(PACKAGE_STRING "${PACKAGE_NAME} ${PACKAGE_VERSION}") set(PACKAGE_BUGREPORT "tiff@lists.maptools.org") include(GNUInstallDirs) include(CheckCCompilerFlag) include(CheckCSourceCompiles) include(CheckIncludeFile) include(CheckLibraryExists) include(CheckTypeSize) include(CheckSymbolExists) enable_testing() macro(current_date var) if(UNIX) execute_process(COMMAND "date" +"%Y%m%d" OUTPUT_VARIABLE ${var}) endif() endmacro() current_date(RELEASE_DATE) macro(extra_dist) foreach(file ${ARGV}) file(RELATIVE_PATH relfile "${PROJECT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/${file}") list(APPEND EXTRA_DIST "${relfile}") endforeach() set(EXTRA_DIST "${EXTRA_DIST}" PARENT_SCOPE) endmacro() set(EXTRA_DIST HOWTO-RELEASE Makefile.vc SConstruct autogen.sh configure.com nmake.opt libtiff-4.pc.in) # These are annoyingly verbose, produce false positives or don't work # nicely with all supported compiler versions, so are disabled unless # explicitly enabled. option(extra-warnings "Enable extra compiler warnings" OFF) # This will cause the compiler to fail when an error occurs. option(fatal-warnings "Compiler warnings are errors" OFF) # Check if the compiler supports each of the following additional # flags, and enable them if supported. This greatly improves the # quality of the build by checking for a number of common problems, # some of which are quite serious. if(CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_C_COMPILER_ID MATCHES "Clang") set(test_flags -Wall -Winline -W -Wformat-security -Wpointer-arith -Wdisabled-optimization -Wno-unknown-pragmas -Wdeclaration-after-statement -fstrict-aliasing) if(extra-warnings) list(APPEND test_flags -Wfloat-equal -Wmissing-prototypes -Wunreachable-code) endif() if(fatal-warnings) list(APPEND test_flags -Werror) endif() elseif(CMAKE_C_COMPILER_ID STREQUAL "MSVC") set(test_flags) if(extra-warnings) list(APPEND test_flags /W4) else() list(APPEND test_flags /W3) endif() if (fatal-warnings) list(APPEND test_flags /WX) endif() endif() foreach(flag ${test_flags}) string(REGEX REPLACE "[^A-Za-z0-9]" "_" flag_var "${flag}") set(test_c_flag "C_FLAG${flag_var}") CHECK_C_COMPILER_FLAG(${flag} "${test_c_flag}") if (${test_c_flag}) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${flag}") endif (${test_c_flag}) endforeach(flag ${test_flags}) if(MSVC) set(CMAKE_DEBUG_POSTFIX "d") endif() option(ld-version-script "Enable linker version script" ON) # Check if LD supports linker scripts. file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/conftest.map" "VERS_1 { global: sym; }; VERS_2 { global: sym; } VERS_1; ") set(CMAKE_REQUIRED_FLAGS_SAVE ${CMAKE_REQUIRED_FLAGS}) set(CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS} "-Wl,--version-script=${CMAKE_CURRENT_BINARY_DIR}/conftest.map") check_c_source_compiles("int main(void){return 0;}" HAVE_LD_VERSION_SCRIPT) set(CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS_SAVE}) file(REMOVE "${CMAKE_CURRENT_BINARY_DIR}/conftest.map") if (ld-version-script AND HAVE_LD_VERSION_SCRIPT) set(HAVE_LD_VERSION_SCRIPT TRUE) else() set(HAVE_LD_VERSION_SCRIPT FALSE) endif() # Find libm, if available find_library(M_LIBRARY m) check_include_file(assert.h HAVE_ASSERT_H) check_include_file(dlfcn.h HAVE_DLFCN_H) check_include_file(fcntl.h HAVE_FCNTL_H) check_include_file(inttypes.h HAVE_INTTYPES_H) check_include_file(io.h HAVE_IO_H) check_include_file(search.h HAVE_SEARCH_H) check_include_file(stdint.h HAVE_STDINT_H) check_include_file(string.h HAVE_STRING_H) check_include_file(strings.h HAVE_STRINGS_H) check_include_file(sys/time.h HAVE_SYS_TIME_H) check_include_file(sys/types.h HAVE_SYS_TYPES_H) check_include_file(unistd.h HAVE_UNISTD_H) # Inspired from /usr/share/autoconf/autoconf/c.m4 foreach(inline_keyword "inline" "__inline__" "__inline") if(NOT DEFINED C_INLINE) set(CMAKE_REQUIRED_DEFINITIONS_SAVE ${CMAKE_REQUIRED_DEFINITIONS}) set(CMAKE_REQUIRED_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS} "-Dinline=${inline_keyword}") check_c_source_compiles(" typedef int foo_t; static inline foo_t static_foo() {return 0;} foo_t foo(){return 0;} int main(int argc, char *argv[]) {return 0;}" C_HAS_${inline_keyword}) set(CMAKE_REQUIRED_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS_SAVE}) if(C_HAS_${inline_keyword}) set(C_INLINE TRUE) set(INLINE_KEYWORD "${inline_keyword}") endif() endif() endforeach() if(NOT DEFINED C_INLINE) set(INLINE_KEYWORD) endif() # off_t and size_t checks omitted; not clear they are used at all # Are off_t and size_t checks strictly necessary? # Check if sys/time.h and time.h allow use together check_c_source_compiles(" #include #include int main(void){return 0;}" TIME_WITH_SYS_TIME) # Check if struct tm is in sys/time.h check_c_source_compiles(" #include #include int main(void){ struct tm tm; int *p = &tm.tm_sec; return !p; }" TM_IN_SYS_TIME) # Check type sizes # NOTE: Could be replaced with C99 check_type_size("signed int" SIZEOF_SIGNED_INT) check_type_size("unsigned int" SIZEOF_UNSIGNED_INT) check_type_size("signed long" SIZEOF_SIGNED_LONG) check_type_size("unsigned long" SIZEOF_UNSIGNED_LONG) check_type_size("signed long long" SIZEOF_SIGNED_LONG_LONG) check_type_size("unsigned long long" SIZEOF_UNSIGNED_LONG_LONG) check_type_size("unsigned char *" SIZEOF_UNSIGNED_CHAR_P) set(CMAKE_EXTRA_INCLUDE_FILES_SAVE ${CMAKE_EXTRA_INCLUDE_FILES}) set(CMAKE_EXTRA_INCLUDE_FILES ${CMAKE_EXTRA_INCLUDE_FILES} "stddef.h") check_type_size("size_t" SIZEOF_SIZE_T) check_type_size("ptrdiff_t" SIZEOF_PTRDIFF_T) set(CMAKE_EXTRA_INCLUDE_FILES ${CMAKE_EXTRA_INCLUDE_FILES_SAVE}) macro(report_values) foreach(val ${ARGV}) message(STATUS "${val} set to ${${val}}") endforeach() endmacro() set(TIFF_INT8_T "signed char") set(TIFF_UINT8_T "unsigned char") set(TIFF_INT16_T "signed short") set(TIFF_UINT16_T "unsigned short") if(SIZEOF_SIGNED_INT EQUAL 4) set(TIFF_INT32_T "signed int") set(TIFF_INT32_FORMAT "%d") elseif(SIZEOF_SIGNED_LONG EQUAL 4) set(TIFF_INT32_T "signed long") set(TIFF_INT32_FORMAT "%ld") endif() if(SIZEOF_UNSIGNED_INT EQUAL 4) set(TIFF_UINT32_T "unsigned int") set(TIFF_UINT32_FORMAT "%u") elseif(SIZEOF_UNSIGNED_LONG EQUAL 4) set(TIFF_UINT32_T "unsigned long") set(TIFF_UINT32_FORMAT "%lu") endif() if(SIZEOF_SIGNED_LONG EQUAL 8) set(TIFF_INT64_T "signed long") set(TIFF_INT64_FORMAT "%ld") elseif(SIZEOF_SIGNED_LONG_LONG EQUAL 8) set(TIFF_INT64_T "signed long long") if (MINGW) set(TIFF_INT64_FORMAT "%I64d") else() set(TIFF_INT64_FORMAT "%lld") endif() endif() if(SIZEOF_UNSIGNED_LONG EQUAL 8) set(TIFF_UINT64_T "unsigned long") set(TIFF_UINT64_FORMAT "%lu") elseif(SIZEOF_UNSIGNED_LONG_LONG EQUAL 8) set(TIFF_UINT64_T "unsigned long long") if (MINGW) set(TIFF_UINT64_FORMAT "%I64u") else() set(TIFF_UINT64_FORMAT "%llu") endif() endif() if(SIZEOF_UNSIGNED_INT EQUAL SIZEOF_SIZE_T) set(TIFF_SIZE_T "unsigned int") set(TIFF_SIZE_FORMAT "%u") set(TIFF_SSIZE_T "signed int") set(TIFF_SSIZE_FORMAT "%d") elseif(SIZEOF_UNSIGNED_LONG EQUAL SIZEOF_SIZE_T) set(TIFF_SIZE_T "unsigned long") set(TIFF_SIZE_FORMAT "%lu") set(TIFF_SSIZE_T "signed long") set(TIFF_SSIZE_FORMAT "%ld") elseif(SIZEOF_UNSIGNED_LONG_LONG EQUAL SIZEOF_SIZE_T) set(TIFF_SIZE_T "unsigned long long") set(TIFF_SSIZE_T "signed long long") if (MINGW) set(TIFF_SIZE_FORMAT "%I64u") set(TIFF_SSIZE_FORMAT "%I64d") else() set(TIFF_SIZE_FORMAT "%llu") set(TIFF_SSIZE_FORMAT "%lld") endif() endif() if(NOT SIZEOF_PTRDIFF_T) set(TIFF_PTRDIFF_T "${TIFF_SSIZE_T}") set(TIFF_PTRDIFF_FORMAT "${SSIZE_FORMAT}") else() set(TIFF_PTRDIFF_T "ptrdiff_t") set(TIFF_PTRDIFF_FORMAT "%ld") endif() #report_values(TIFF_INT8_T TIFF_INT8_FORMAT # TIFF_UINT8_T TIFF_UINT8_FORMAT # TIFF_INT16_T TIFF_INT16_FORMAT # TIFF_UINT16_T TIFF_UINT16_FORMAT # TIFF_INT32_T TIFF_INT32_FORMAT # TIFF_UINT32_T TIFF_UINT32_FORMAT # TIFF_INT64_T TIFF_INT64_FORMAT # TIFF_UINT64_T TIFF_UINT64_FORMAT # TIFF_SSIZE_T TIFF_SSIZE_FORMAT # TIFF_PTRDIFF_T TIFF_PTRDIFF_FORMAT) check_symbol_exists(mmap "sys/mman.h" HAVE_MMAP) check_symbol_exists(setmode "unistd.h" HAVE_SETMODE) check_symbol_exists(snprintf "stdio.h" HAVE_SNPRINTF) check_symbol_exists(strcasecmp "strings.h" HAVE_STRCASECMP) check_symbol_exists(strtol "stdlib.h" HAVE_STRTOL) check_symbol_exists(strtoll "stdlib.h" HAVE_STRTOLL) check_symbol_exists(strtoul "stdlib.h" HAVE_STRTOUL) check_symbol_exists(strtoull "stdlib.h" HAVE_STRTOULL) check_symbol_exists(getopt "unistd.h;stdio.h" HAVE_GETOPT) check_symbol_exists(lfind "search.h" HAVE_LFIND) if(NOT HAVE_SNPRINTF) add_definitions(-DNEED_LIBPORT) endif() # CPU bit order set(HOST_FILLORDER FILLORDER_MSB2LSB) if(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "i.*86.*" OR CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "amd64.*" OR # AMD64 on Windows CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "AMD64" OR CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "x86_64.*") set(HOST_FILLORDER FILLORDER_LSB2MSB) endif() # CPU endianness include(TestBigEndian) test_big_endian(HOST_BIG_ENDIAN) # IEEE floating point set(HAVE_IEEEFP 1) report_values(CMAKE_HOST_SYSTEM_PROCESSOR HOST_FILLORDER HOST_BIG_ENDIAN HAVE_IEEEFP) # Large file support if (UNIX OR MINGW) # This might not catch every possibility catered for by # AC_SYS_LARGEFILE. add_definitions(-D_FILE_OFFSET_BITS=64) set(FILE_OFFSET_BITS 64) endif() # Documentation install directory (default to cmake project docdir) set(LIBTIFF_DOCDIR "${CMAKE_INSTALL_FULL_DOCDIR}") # Options to enable and disable internal codecs option(ccitt "support for CCITT Group 3 & 4 algorithms" ON) set(CCITT_SUPPORT ${ccitt}) option(packbits "support for Macintosh PackBits algorithm" ON) set(PACKBITS_SUPPORT ${packbits}) option(lzw "support for LZW algorithm" ON) set(LZW_SUPPORT ${lzw}) option(thunder "support for ThunderScan 4-bit RLE algorithm" ON) set(THUNDER_SUPPORT ${thunder}) option(next "support for NeXT 2-bit RLE algorithm" ON) set(NEXT_SUPPORT ${next}) option(logluv "support for LogLuv high dynamic range algorithm" ON) set(LOGLUV_SUPPORT ${logluv}) # Option for Microsoft Document Imaging 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) endif() set(ZIP_SUPPORT ${ZLIB_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() 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) endif() option(old-jpeg "support for Old JPEG compression (read-only)" ON) set(OJPEG_SUPPORT FALSE) if (JPEG_SUPPORT) if (old-jpeg) set(OJPEG_SUPPORT TRUE) endif() 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_LIBRARIES ${JBIG_LIBRARY}) endif() endif() set(JBIG_SUPPORT 0) if(JBIG_FOUND) set(JBIG_FOUND TRUE) set(JBIG_SUPPORT 1) else() set(JBIG_FOUND FALSE) endif() set(CMAKE_REQUIRED_INCLUDES_SAVE ${CMAKE_REQUIRED_INCLUDES}) set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES} ${JBIG_INCLUDE_DIR}) 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) 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) 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) 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}") 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) if (JPEG12_INCLUDE_DIR AND JPEG12_LIBRARY) set(JPEG12_LIBRARIES ${JPEG12_LIBRARY}) set(JPEG12_FOUND TRUE) endif() if (JPEG12_FOUND) set(JPEG_DUAL_MODE_8_12 1) set(LIBJPEG_12_PATH "${JPEG12_INCLUDE_DIR}/jpeglib.h") endif() # C++ support option(cxx "Enable C++ stream API building (requires C++ compiler)" ON) set(CXX_SUPPORT FALSE) if (cxx) enable_language(CXX) set(CXX_SUPPORT TRUE) endif() # OpenGL and GLUT find_package(OpenGL) find_package(GLUT) set(HAVE_OPENGL FALSE) if(OPENGL_FOUND AND OPENGL_GLU_FOUND AND GLUT_FOUND) set(HAVE_OPENGL TRUE) endif() # Purely to satisfy the generated headers: check_include_file(GL/gl.h HAVE_GL_GL_H) check_include_file(GL/glu.h HAVE_GL_GLU_H) check_include_file(GL/glut.h HAVE_GL_GLUT_H) check_include_file(GLUT/glut.h HAVE_GLUT_GLUT_H) check_include_file(OpenGL/gl.h HAVE_OPENGL_GL_H) check_include_file(OpenGL/glu.h HAVE_OPENGL_GLU_H) # Win32 IO set(win32_io FALSE) if(WIN32) set(win32_io TRUE) endif() 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 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) if(strip-chopping) set(STRIPCHOP_DEFAULT TRUE) if(TIFF_DEFAULT_STRIP_SIZE) set(STRIP_SIZE_DEFAULT "${TIFF_DEFAULT_STRIP_SIZE}") endif() endif() # Defer loading of strip/tile offsets option(defer-strile-load "enable deferred strip/tile offset/size loading (also available at runtime with the 'D' flag of TIFFOpen())" OFF) set(DEFER_STRILE_LOAD ${defer-strile-load}) # CHUNKY_STRIP_READ_SUPPORT option(chunky-strip-read "enable reading large strips in chunks for TIFFReadScanline() (experimental)" OFF) set(CHUNKY_STRIP_READ_SUPPORT ${chunky-strip-read}) # SUBIFD support set(SUBIFD_SUPPORT 1) # Default handling of ASSOCALPHA support. option(extrasample-as-alpha "the RGBA interface will treat a fourth sample with no EXTRASAMPLE_ value as being ASSOCALPHA. Many packages produce RGBA files but don't mark the alpha properly" ON) if(extrasample-as-alpha) set(DEFAULT_EXTRASAMPLE_AS_ALPHA 1) endif() # Default handling of YCbCr subsampling support. # See Bug 168 in Bugzilla, and JPEGFixupTestSubsampling() for details. option(check-ycbcr-subsampling "enable picking up YCbCr subsampling info from the JPEG data stream to support files lacking the tag" ON) if (check-ycbcr-subsampling) set(CHECK_JPEG_YCBCR_SUBSAMPLING 1) endif() # Generate pkg-config file set(prefix "${CMAKE_INSTALL_PREFIX}") set(exec_prefix "${CMAKE_INSTALL_PREFIX}") set(libdir "${CMAKE_INSTALL_FULL_LIBDIR}") set(includedir "${CMAKE_INSTALL_FULL_INCLUDEDIR}") configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libtiff-4.pc.in ${CMAKE_CURRENT_BINARY_DIR}/libtiff-4.pc) install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libtiff-4.pc DESTINATION "${CMAKE_INSTALL_FULL_LIBDIR}/pkgconfig") # Includes used by libtiff (and tests) if(ZLIB_INCLUDE_DIRS) list(APPEND TIFF_INCLUDES ${ZLIB_INCLUDE_DIRS}) endif() if(JPEG_INCLUDE_DIR) list(APPEND TIFF_INCLUDES ${JPEG_INCLUDE_DIR}) endif() if(JPEG12_INCLUDE_DIR) list(APPEND TIFF_INCLUDES ${JPEG12_INCLUDE_DIR}) endif() if(JBIG_INCLUDE_DIR) list(APPEND TIFF_INCLUDES ${JBIG_INCLUDE_DIR}) endif() if(LIBLZMA_INCLUDE_DIRS) list(APPEND TIFF_INCLUDES ${LIBLZMA_INCLUDE_DIRS}) endif() if(ZSTD_INCLUDE_DIR) list(APPEND TIFF_INCLUDES ${ZSTD_INCLUDE_DIR}) endif() if(WEBP_INCLUDE_DIR) list(APPEND TIFF_INCLUDES ${WEBP_INCLUDE_DIR}) endif() # Libraries required by libtiff set(TIFF_LIBRARY_DEPS) if(M_LIBRARY) list(APPEND TIFF_LIBRARY_DEPS ${M_LIBRARY}) endif() if(ZLIB_LIBRARIES) list(APPEND TIFF_LIBRARY_DEPS ${ZLIB_LIBRARIES}) endif() if(JPEG_LIBRARIES) list(APPEND TIFF_LIBRARY_DEPS ${JPEG_LIBRARIES}) endif() if(JPEG12_LIBRARIES) list(APPEND TIFF_LIBRARY_DEPS ${JPEG12_LIBRARIES}) endif() if(JBIG_LIBRARIES) list(APPEND TIFF_LIBRARY_DEPS ${JBIG_LIBRARIES}) endif() if(LIBLZMA_LIBRARIES) list(APPEND TIFF_LIBRARY_DEPS ${LIBLZMA_LIBRARIES}) endif() if(ZSTD_LIBRARIES) list(APPEND TIFF_LIBRARY_DEPS ${ZSTD_LIBRARIES}) endif() if(WEBP_LIBRARIES) list(APPEND TIFF_LIBRARY_DEPS ${WEBP_LIBRARIES}) endif() #report_values(TIFF_INCLUDES TIFF_LIBRARY_DEPS) # Process subdirectories add_subdirectory(port) add_subdirectory(libtiff) add_subdirectory(tools) add_subdirectory(test) add_subdirectory(contrib) add_subdirectory(build) add_subdirectory(man) add_subdirectory(html) #message(STATUS "EXTRA_DIST: ${EXTRA_DIST}") message(STATUS "") message(STATUS "Libtiff is now configured for ${host}") message(STATUS "") message(STATUS " Installation directory: ${prefix}") message(STATUS " Documentation directory: ${LIBTIFF_DOCDIR}") message(STATUS " C compiler: ${CMAKE_C_COMPILER}") message(STATUS " C++ compiler: ${CMAKE_CXX_COMPILER}") message(STATUS " Build shared libraries: ${BUILD_SHARED_LIBS}") message(STATUS " Enable linker symbol versioning: ${HAVE_LD_VERSION_SCRIPT}") message(STATUS " Support Microsoft Document Imaging: ${mdi}") message(STATUS " Use win32 IO: ${USE_WIN32_FILEIO}") message(STATUS "") message(STATUS " Support for internal codecs:") message(STATUS " CCITT Group 3 & 4 algorithms: ${ccitt}") message(STATUS " Macintosh PackBits algorithm: ${packbits}") message(STATUS " LZW algorithm: ${lzw}") message(STATUS " ThunderScan 4-bit RLE algorithm: ${thunder}") 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 " 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 "") message(STATUS " C++ support: ${cxx} (requested) ${CXX_SUPPORT} (availability)") message(STATUS "") # message(STATUS " X Athena Widgets support: ${HAVE_XAW}") message(STATUS " OpenGL support: ${HAVE_OPENGL}") message(STATUS "")